Pojazdy Polskie pociagi w 32bpp

Kod:

grf {                                    

    grfid: "oPpK";                        

    name: string(STR_GRF_NAME);            

    desc: string(STR_GRF_DESCRIPTION);     

    version: 0;                            

    min_compatible_version: 0; }    



train_width_32_px = 1;

traininfo_y_offset = 2;

    

template tmpl_sprit_train(x, y) {        

    [ x  ,   y,     10, 30,      -5,-15 ]    

    [ x+ 18 ,y,     28, 28,     -19,-18 ]     

    [ x+ 52 ,y,     42, 18,     -26,-14 ]     

    [ x+ 100,y,     28, 28,     -12,-21 ]     

    [ x+ 136,y,     10, 30,      -3,-18 ]     

    [ x+ 152,y,     28, 28,     -15,-20 ]     

    [ x+ 186,y,     42, 18,     -17,-14 ]    

    [ x+ 234,y,     28, 28,      -7,-18 ] }    

template tmpl_train_zi4(x, y) {            

    [ x,     y,     68,139,     -44,-47 ]     

    [ x+  80,y,    144, 99,    -119,-36 ]     

    [ x+ 240,y,    222, 78,    -164,-55 ]     

    [ x+ 480,y,    144,110,     -87,-72 ]     

    [ x+ 640,y,     68,140,     -44,-88 ]     

    [ x+ 720,y,    144,110,     -75,-70 ]     

    [ x+ 880,y,    222, 78,     -84,-56 ]    

    [ x+1120,y,    144, 99,     -44,-41 ] }    

template templ_sprite_dep(x, y) {        

    [ x,     y,     43, 12,     -20,-10 ] }        

template templ_sprite_dep_zi4(x, y) {    

    [ x,     y,    201, 76,     -67,-67 ] }    

template tmpl_sprit_meni(x, y) {        

    [ x,     y,     44, 12,     -21, -8 ] }    



spriteset(sprity_atrapa, "gfx/atrapa.png")   {

    [ 0,     0,      1,  1,       0,  0 ] }    

spriteset(sprity_vectron_meni, "gfx/vectron.png") {

    tmpl_sprit_meni(4, 60) }    

spriteset(                                

    sprity_vectron_w_depocie                

    , "gfx/vectron.png") { templ_sprite_dep(4, 60) }    

alternative_sprites(                    

    sprity_vectron_w_depocie, ZOOM_LEVEL_IN_4X, BIT_DEPTH_32BPP, "gfx/pkpcargo32.png") 

 {                                        

    templ_sprite_dep_zi4(34, 2)         

 }        

spriteset(sprity_vectron, "gfx/vectron.png") {

    tmpl_sprit_train(4, 20) }     

alternative_sprites(                    

    sprity_vectron, ZOOM_LEVEL_IN_4X, BIT_DEPTH_32BPP, "gfx/pkpcargo00-32.png") 

 {                                        

    tmpl_train_zi4(18, 8)                

 }    

        

switch(FEAT_TRAINS, SELF, sw_vectron_przegubowy, extra_callback_info1) {

    1: return element_vectron;            

    return CB_RESULT_NO_MORE_ARTICULATED_PARTS;

 }                                        

switch(FEAT_TRAINS, SELF, sw_vectron_dlugosc , position_in_vehid_chain % 2)  

 {                                        

    1: return 5;                        

    return 8;                            

 }                                        

switch(FEAT_TRAINS, SELF, sw_vectron_grafiki, position_in_vehid_chain % 2) {

    0: return sprity_vectron;            

    return sprity_atrapa;                

 }                                        

switch(FEAT_TRAINS, SELF, sw_vectron_grafiki_w_depocie, position_in_vehid_chain % 2) {

    0: return sprity_vectron_w_depocie;    

    return sprity_atrapa;                

 }                                        

switch(FEAT_TRAINS, SELF, sw_sprity_PKPCargo , vehicle_is_in_depot)  

 {                                        

    1: sw_vectron_grafiki_w_depocie ;     

    sw_vectron_grafiki ;                  

 }                                        

item(FEAT_TRAINS, element_vectron)         

 {                                        

    property {                             

        name:                              string(STR_NAME_PKP_CARGO);

        climates_available:                ALL_CLIMATES & ~bitmask(CLIMATE_TOYLAND);            

        introduction_date:                 date(2015, 1, 1);

        model_life:                        VEHICLE_NEVER_EXPIRES;

        vehicle_life:                      25;    

        reliability_decay:                 20;    

        cost_factor:                       35 ;     

        running_cost_factor:               230 ;     

        sprite_id:                         SPRITE_ID_NEW_TRAIN;

        speed:                             200 km/h;

        misc_flags:                        bitmask();

        refit_cost:                        0;    

        track_type:                        RAIL;    

        ai_special_flag:                   AI_FLAG_CARGO;

        power:                             6400 kW;

        running_cost_base:                 RUNNING_COST_ELECTRIC;

        dual_headed:                       0;    

        weight:                            87 ton;

        ai_engine_rank:                    0;     

        engine_class:                      ENGINE_CLASS_ELECTRIC;

        extra_power_per_wagon:             0 kW;

        tractive_effort_coefficient:       0.352;

        air_drag_coefficient:              0.07;

        length:                            8;    

        extra_weight_per_wagon:            0;    

        visual_effect_and_powered:         visual_effect_and_powered(VISUAL_EFFECT_DEFAULT, 0, DISABLE_WAGON_POWER);

        bitmask_vehicle_info:              0;    

    }                                        

    graphics {                            

        purchase:                          sprity_vectron_meni;

        default:                           sw_sprity_PKPCargo; 

        articulated_part:                  sw_vectron_przegubowy;

        length:                            sw_vectron_dlugosc;         

    }                                    

 }

Kod:

#Importowanie wymaganych rzeczy - korzystanie z tzw. modułów tudzież bibliotek (skompilowane wersje .pyc, działają szybciej)

from time import sleep, gmtime, strftime

import time

from random import randint

import sys

import os

import argparse







#wyswietlenie początkowego komunikatu :



print("\n = = = eNeMeL konsolidator ! = = = \n")







#obsługa argumentów z interfejsu wiersza poleceń



parser = argparse.ArgumentParser(description="Patchowanie  GRF ~ w NML ~ z plików pnml do jednego pliku NML. Jeśli nie podano żadnych argumentów, program zapętli się i poprosi o dane wejściowe do skompilowania pliku. OSTRZEŻENIE! To NIE kompiluje się do pliku .grf, a tylko łata składowe pliki .pnml do pliku .nml, aby można było skompilować z NMLC!")



parser.add_argument("-o", "--output", type=str, help='Plik do wyjśca , zapisanie do pliku. Podanie nazwy pliku tylko, nie w cudzysłowie ( np.: output.nml ) ' )

parser.add_argument("-f", "--plik", type=str, help="Plik nagłówka do odczytania. Podanie nazwy pliku ze ścieżką w cudzysłowie.")

parser.add_argument("-b", "--backup", type=int, help="1 lub 0, aby potwierdzić, czy program utworzy kopię zapasową w przypadku zastąpienia pliku wyjściowego.", choices=[0,1])



args = parser.parse_args()







#Sprawdzanie, czy którykolwiek z argumentów ma jakąkolwiek wartość, która nie jest "None"

used_args = False

arguments = vars(args)



for argument in arguments:

    if not used_args and arguments[argument] != None:

        used_args = True





        

#Definiowanie funkcji ogólnego przeznaczenia ( usuniecie rozszerzenia nazwy pliku )



def rm_file_extension(file_name):

    found_file_extension = False

    end_point = len(file_name)-1

        

    #Znajdowanie ostatniego miejsca po kropce w nazwie nagłówka pliku

    for pos in range(len(file_name)-1,-1,-1):

        if file_name[pos]    == "." and not found_file_extension:

            end_point = pos

            found_file_extension = True

    return file_name[:end_point]



    

    

#Funkcja tworzenia kopii zapasowej, która -najpierw- tworzy kopię zapasową pliku wyjściowego (jeśli już istnieje)

def backup(name):

    if name in os.listdir():

        if not ("backups" in os.listdir()):

            os.mkdir("backups")

        os.rename(name, "backups/" + rm_file_extension(name) + "-" + strftime("%H-%M-%S-%Y-%m-%d", gmtime())+".nml")





        

#Znany błąd drukowania

def print_error(cause, place, action):

    print("\nWystąpił błąd!")

    print("Przyczyna      : ", cause)

    print("Znalezione w   : ", place)

    print("Jak ulepszyć   : ", action)



    

    

#Nieznany błąd drukowania

def print_general_error(cause):

    print("\nWystąpił błąd!")

    print("Przyczyna      : ", cause)

    print("Najprawdopodobniej był to błąd wewnętrzny.\n")





    

#Definiowanie klasy, która zapisuje do pliku wyjściowego



class writer:

    """Interfejs zapisujący do pliku wyjściowego"""

    

    output_text = ""

    

    def __init__(self):

        output = arguments["output"]

        self.output = open(output, "w")

    

    def write_line(self, line):

        self.output.write(str(line) + "\n")

    

    def close(self):

        self.output.close()

    



    

#Definiowanie głównej klasy czytajacej



class reader:

    """Klasa, która czyta z pliku i robi z nim różne rzeczy"""

    

    list_of_definitions = {}

    total_list_of_errors = []

    faulty_definitions = []

    

    def __init__(self, file_name, *parent_variables):

        try:

            self.current_line = 0

            self.errors_made = 0

            self.file_name = file_name

            self.input = ""

            self.input = open(self.file_name, "r")

        except (OSError, FileNotFoundError) as inst:

            self.errors_made += 1

            if parent_variables:

                self.total_list_of_errors.append([inst, "Linia " + str(parent_variables[2]) + " ze " + str(parent_variables[0]) + ": " + str(parent_variables[1]), "Sprawdź, czy wiersz kodu jest poprawny"])

            else:

                self.total_list_of_errors.append([inst, "Wkład bezpośrdni/Argument", "Upewnij się, że podałeś prawidłową nazwę pliku"])

            

    

    def read_line(self):

        line_read = self.input.readline()

        return line_read.replace("\n","")

        

    def close(self):

        if str(type(self.input)) == "<class '_io.TextIOWrapper'>":

            self.input.close()

        

        if len(self.total_list_of_errors):

            if len(self.total_list_of_errors) == 1:

                print("\nWystąpił 1 błąd w tej poprawce")

            else:

                print("\nNapotkany", len(self.total_list_of_errors), "errors w patch'u .")

            for error in self.total_list_of_errors:

                if len(error) == 1:

                    print_general_error(error[0])

                else:

                    print_error(error[0], error[1], error[2])

    

    def main(self):

        #Główna funkcja, która czyta plik i zapisuje go w  pliku wyjściowym

        

        #Generowanie listy każdego wiersza kodu w pliku docelowym, a następnie usuwanie nowych znaków wiersza

        lines = [line.replace("\n","") for line in self.input]

        

        #Główna pętla - zapętlenia przez każdą linię kodu

        self.line_counter = 0

        for line in lines:

            self.line_counter += 1

            do_write = True

            

            #Jeśli wiersz zaczyna się od polecenia „#include”, to tworzy kolejną instancję, która najpierw czyta i zapisuje ten plik

            if line.lower()[:8] == "#include":

            

                self.subreader = reader(line.replace('"', '')[9:], self.file_name, line, self.line_counter)

                self.subreader.main()

                

                if self.subreader.errors_made == 1:

                    print("Załatać", line.replace('"', '')[9:], "z 1 error!")

                elif self.subreader.errors_made > 1:

                    print("Załatać", line.replace('"', '')[9:], "z", self.subreader.errors_made, "errors!")

                else:

                    print("Łatane", line.replace('"', '')[9:], "z bez errors.")

                            

                do_write = False

                

            elif line.lower()[:7] == "#define":

                new_line = line[8:]

                

                #Znajdowanie końca nazwy definicji

                def_name = ""

                found_def_name = False

                for letter in new_line:

                    if letter == " " and not found_def_name:

                        new_line = new_line.replace(def_name + " ", "")

                        if len(new_line) > 0:

                            print("Wykonano ustanowioną definicję", def_name, "o wartości", new_line)

                            self.list_of_definitions[def_name] = new_line

                        elif len(def_name) > 1:

                            self.total_list_of_errors.append(["Nieprawidłowa definicja !", "Linia" + str(self.line_counter) + " ze " + self.file_name + ": " + line, "Do sprawdzenia wartość definicji"])

                        

                        found_def_name = True

                        

                    def_name += letter

                

                do_write = False

                

            else:

                #Sprawdzanie ustanowionych definicji

                for definition in self.list_of_definitions:

                    if definition in line:

                        line = line.replace(definition, self.list_of_definitions[definition])

                        

                #Jeśli zostanie znaleziona definicja uznana za wadliwą, wysyła błąd

                for definition in self.faulty_definitions:

                    if definition in line:

                        self.errors_made +=1

                        self.total_list_of_errors.append(["Użyto niepoprawnej definicji !", "Linia " + str(self.line_counter) + " ze " + self.file_name + ": " + line, "Sprawdź wartość definicji"])

                    

            

            if do_write:

                output.write_line(line)

        

                

                

#Definiowanie innych funkcji ogólnych



#Jeśli dane wyjściowe nie są zdefiniowane, ale plik nagłówkowy jest, to zostanie zdefiniowany tak samo jak dane wejściowe

if arguments["plik"] != None and arguments["output"] == None:

    arguments["output"] = rm_file_extension(arguments["plik"])+".nml"



    

    

#Tworzenie kopii zapasowej, jeśli kopia zapasowa jest ustawiona na 1

if arguments["backup"] != None and str(arguments["backup"]) != "0" :

    print("Próba wykonania kopii zapasowej", arguments["output"])

    backup(arguments["output"])





    

#Wyświetlanie podanych argumentów użytkownikowi

for argument in arguments:

    if arguments[argument] != None:

        print(argument.capitalize(), ":", arguments[argument])





        

#Sprawdzanie, czy używane są argumenty



if used_args:



    #Sprawdzenie, czy podano argument „plik”, ponieważ program nie może bez niego kontynuować

    if arguments["plik"] != None:

        

        try:

            #Główna sekwencja, która otwiera pliki, a następnie zapisuje na wyjściu

            output = writer()

            header = reader(arguments["plik"])

            header.main()

            output.close()

            header.close()

            

            #Wyświetlanie komunikatów po łataniu

            if len(header.list_of_definitions) > 0:

                print("\nLista ustanowionych definicji używanych w tym pliku:")

                for definition in header.list_of_definitions:

                    print(definition, header.list_of_definitions[definition])

            

        #Wyłapanie wszelkich innyh zgłoszonych błędów

        except Exception as inst:

            print_general_error(str(inst) + " z " + str(type(inst))) 

    else:

        print("\nNie podano pliku wejściowego!")

    

else:

    print("\nAby wyjść z programu, wpisz 'exit'\n")

    #Wprowadzenie w pętlę, którą można przerwać za pomocą Ctrl + C lub polecenia

    while True:

    

        try:

            print("\n = = = = = = = = = = = = = = = = = \n")

            #Uzyskiwanie informacji od użytkowników

            arguments["plik"] = input("Plik wejściowy: ")

            

            #Jeśli typ użytkownika zakończy działanie, program się zakończy

            if arguments["plik"].lower() == "exit":

                raise KeyboardInterrupt

                

            #Tworzenie pliku wyjściowego na podstawie nazwy pliku wejściowego

            arguments["output"] = rm_file_extension(arguments["plik"])+".nml"

                        

            #Główna sekwencja, która otwiera pliki, a następnie zapisuje na wyjściu

            output = writer()

            header = reader(arguments["plik"])

            header.main()

            output.close()

            header.close()

            

            #Wyświetlanie komunikatów po łataniu

            if len(header.list_of_definitions) > 0:

                print("\nLista ustanowionych definicji używanych w tym pliku:")

                for definition in header.list_of_definitions:

                    print(definition, header.list_of_definitions[definition])

        

        #Jeśli polecenie zostanie wprowadzone lub zostanie naciśnięty klawisz Ctrl + C, program zostanie zakończony

        except KeyboardInterrupt:

            print("\nWyjście z programu!")

            break

            

        #Wyłapanie wszelkich innych zgłaszanych błędów (#Wyjątek jako inst)

        except SyntaxError:#Exception as inst:

            print_general_error(str(inst) + " z " + str(type(inst))) 



    



#input("\nNaciśnięcie enter, by kontynuować\n")