POJAZDY Polskie pociagi w 32bpp

[seriously]

W OpenTTD gram juz z dekade i powoli mecza mnie te piksele, zas sam zBase poza budynkami ktore mozna zniesc, nie oferuje mi do konca tego, co bym chcial. Alternatyw poki co brak, Mashinky wygladaja sredniawo, Transport Fever to nieporozumienie. Postanowilem wiec zakasac rekawy i zrobic sobie na wlasna reke jakis dodatek pojazdow 32bpp, zeby gra na zBase byla znosna. Pare pojazdow jest gotowych,w zalaczniku na zachete EP09. Jak uda mi sie to zakodowac na cos grywalnego, to moge sie podzielic. Zdaje sobie sprawe ile to pracy, ale robie to glownie na wlasny uzytek, post tutaj w ramach ciekawostki i dla zainteresowanych.

[Walter Novotny]

Sam do tej herezji nie przyłożę ręki ale jeśli na własny użytek to nie widzę nic w tym złego. Co kto lubi.

[Damgam]

[Obrazek: db7.jpg]

[ShedletskyPL]

https://imgur.com/a/DHdZZ

[McZapkie]

Osobiście wolę piksele bo bardziej pasują do kanciastości gry, ale coraz więcej powstaje dodatków 32bit, np. Czesi mają auta i pociągi w dużej rozdzielczości. W czym to robisz? Jakby co, to mam trochę modeli w 3dsmax z czasów Maszyny EU07.

Co do kanciastości: proponuję wyeksportować dodatkowe widoki skośne, bo takie ładne obrazki brzydko wyglądają gdy gwałtownie skręcają pod kątem 45 stopni. W openttd jest możliwość testowania jak głęboko w zakręt wszedł pojazd (vehicle_curv_info). Przykładowo cets to wykorzystuje:
http://dev.openttdcoop.org/projects/cets...normal.png

Dobrze byłoby też wyeksportować obrazki aby były podobne w skali do np. CSD.

[seriously]

Osobiście wolę piksele bo bardziej pasują do kanciastości gry, ale coraz więcej powstaje dodatków 32bit, np. Czesi mają auta i pociągi w dużej rozdzielczości. W czym to robisz? Jakby co, to mam trochę modeli w 3dsmax z czasów Maszyny EU07.

Co do kanciastości: proponuję wyeksportować dodatkowe widoki skośne, bo takie ładne obrazki brzydko wyglądają gdy gwałtownie skręcają pod kątem 45 stopni. W openttd jest możliwość testowania jak głęboko w zakręt wszedł pojazd (vehicle_curv_info). Przykładowo cets to wykorzystuje:
http://dev.openttdcoop.org/projects/cets...normal.png

Dobrze byłoby też wyeksportować obrazki aby były podobne w skali do np. CSD.

Pamietam Cie z maszyny Na tabor nie narzekam, swego czasu troche sie nastukalo rzeczy, a to jeszcze zupelnie inna skala detali, tutaj bardzo mocne low poly daje rade. Pracuje w 3ds max wlasnie. Na codzien przy modelach wlasnie do gier w stylu cities skylines uzywam substance paintera, ale tutaj stykaja tekstury w inkscape - te z z tej dziewiatki robilem wlasnie tam.

Przegladalem wiki openttd i tt forums, ale nie znalazlem nigdzie ustawien kamery zeby zlapac idealny kat. Juz w ogole marzeniem bylby jakis szablon z kamerami i potem tylko render z X kamer, zeby miec wszystkie rzuty. To jest najwiekszy problem o ktorym na poczatku w ogole nie pomyslalem. Bede szukal dalej i probowal. Dziekuje za template.

Zas jesli chodzi o CSD, odezwalem sie do osobn robiacych na tt forums wlasnie ten Czech Replacement Set i dostosowalem oswietlenie, zeby pasowalo. Skale tez dopasuje.

[yard]

 Set Polskich Kolei v.3 

Taki można właściwie chyba założyć .
Mogłoby znajdować się w nim tylko grafiki z zoom zi2 (w tym "x4") .
Standard ( uwzględniając wymiany klimatu) to około min.10 lokomotyw
różnej mocy o żywotności przeciętnie 30 lat .
Na początku mógłby znajdować się wybrany polski tabor :
  2 parowozy lub wiecej np. zabytkowy odrestaurowany do dziś
     ( min. 1 historyczny z czasów xx lecia międzywojennego + 1 nowszy do lat '80)
       -nie miałyby ekonomicznych parametrów , awaryjny , ale niska cena zakupu
z 5 spalinówek 
     ( 1 po roku '50 + 1 motorowo-pasażerski tj.SN61 lata  '70/2000 + 1 szynobus od '2000 + 
       1 z teraźniejszości + 1 realny projekt prototypowy po roku 2018)
       -droższy do nabycia , tańszy w kosztach, bardziej niezawodne
  3 elektrowozy
     ( 1 z '60/'90 + 1 z 90/2020 + 1 obecny na lata do 2040 )
       -konkurencyjne na lepsze prędkości torów, szybsze , ale wymaga nakładów w trakcje
  
w dalszej kolejności :  
  1 wagon typu osobowego przebudowywalny na poczte i przesyłki -paczki kosztowności
     ( max 210 km/h)
  4 wagony towarowe (max 130 km/h)
     wagon na węgiel lub żelazo albo inne surowce mineralne oraz przebudowywalny do przewozu żywca
     wagon kryty na ziarno lub żywność
     wagon cysterna na zawartości płynne , z wymienną "beczką" 
     wagon platforma na konstrukcje stalowe, drewno, towary w kontenerach

Z możliwością całkiem rozszerzenia na inne wytyczne, przemysły , piętrowe dla aut .

[Hunter3000]

Co do Transport Fever, gierka jest całkiem niezła, niestety brak jakichkolwiek PKPowych modeli (oprócz ST44/M62)

[metro]

 NewGRF 32bpp
Tabor :   PKPCARGO
Rodzaj : Lokomotywa
Nazwa :  Vectron 


   

Dla lepszej przejrzystości "okodowanie" w następnym poście  
  

---

 8bpp :

[metro]

 .nml  -

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;         
    }                                    
}

oraz english.lng i polish.lng (w kolejnych postach)

[metro]

english.lng

Kod:

##grflangid 0x01

#Main grf title and description
STR_GRF_NAME                                       :{TITLE} {VERSION}
STR_GRF_DESCRIPTION                                :{}{TITLE} locomotive electric & diesel for OpenTTD {COPYRIGHT}2019.{} Graphix: "{ORANGE}CZTR Team{BLACK}" , {} 8bpp ~{ORANGE} PKPSet {GOLD}{TRAIN}{BLACK}. {}License: {GREEN}GPL v2{}{BLACK}Website:{SILVER} https://www.facebook.com/OTTD-Czech-realistic-replacement-1978368325710456/

#Vehicle names
STR_NAME_PKP_CARGO                                 :{TITLE} 'I'

 

---

[metro]

 polish.lng

Kod:

##grflangid 0x30

# Główny tytuł i opis grf
STR_GRF_NAME                                       :{TITLE} {VERSION}
STR_GRF_DESCRIPTION                                :{TITLE} lokomotywa spalinowa i elektryczna dla OpenTTD (c)2019. {} Grafix: "{ORANGE}CZTR Team{BLACK}" , {} 8bpp~{ORANGE} PKPSet{BLACK}. {}Licencja: {GREEN}GPL v2{}{BLACK}Website:{SILVER} https://www.facebook.com/OTTD-Czech-realistic-replacement-1978368325710456/

# Pojazd nazwy
STR_NAME_PKP_CARGO                                 :{TITLE} 'I'

 ^ opcjonalnie

[metro]

schemat podkatalogow :

 |- lang
 |   |- english.lng (oraz polish.lng)
 |
 |- gfx
 |   |- obrazy.png
 |
 |- pkpcargo.nml
 |
 |- custom_tags.txt (ponizej)

Kod:

VERSION    :1.0
TITLE      :PKPCARGO

[metro]

dodatkokwy obraz
   

[metro]

uzyte atrapa.png (1 pixel ) to :
https://dev.openttdcoop.org/projects/pkp.../dummy.png
tylko zmieniana nazwa .

[metro]

dodatkowo mozna wlaczyc jazde bez elektryfikacji 
- przed:

visual_effect_and_powered: visual_effect_and_powered(VISUAL_EFFECT_DEFAULT, 0, DISABLE_WAGON_POWER);

-nalezy wstawic komentarz "//"

zaraz po nastepujacym znaku "}" dopisac
// Parametr dla railtype () -powinien być literałem ciągowym, który znajduje się również w tabeli typu szyny :

if (railtype("RAIL"))  
  {
   property 
   {
    engine_class: ENGINE_CLASS_DIESEL;
    visual_effect_and_powered: visual_effect_and_powered(VISUAL_EFFECT_DIESEL, 0,  DISABLE_WAGON_POWER);
   }
 }
if (railtype("ELRL"))  
 {
   property 
   {
    engine_class: ENGINE_CLASS_DIESEL;
    visual_effect_and_powered: visual_effect_and_powered(VISUAL_EFFECT_ELECTRIC, 0,  DISABLE_WAGON_POWER);
   }
}

a wczesniej przed blokiem template
-dopisac:

railtypetable 
 {
   RAIL, 
   ELRL,
 }

// zdefiniowanie tabeli typów szyn, pozwala to na odwoływanie się do typów szyn, niezależnie od załadowanych plików // GRFs

lub dodac linie nad item  :

switch (FEAT_TRAINS, SELF, sw_vectron_power, current_railtype ) {
  0: visual_effect_and_powered(VISUAL_EFFECT_DIESEL, 0, DISABLE_WAGON_POWER);
  1: visual_effect_and_powered(VISUAL_EFFECT_ELECTRIC, 0, DISABLE_WAGON_POWER);
  CB_FAILED;
} 

wtedy po graphics między { , a } dodac linie : 

visual_effect_and_powered: sw_vectron_power;

[metro]

lub mozna zamienic adekwatne na:
visual_effect_and_powered: visual_effect_and_powered(VISUAL_EFFECT_DISABLE, 0, DISABLE_WAGON_POWER);

[metro]

Zeby wlasnie lepiej mozna bylo nanosic poprawki (szczgolnie dla dodawania nowych objektow-pojazdow),
umozliwiono uproszczenie tego etapu .
Rozdzielono bloki w pojedynczym pliku .nml 
do poszczegolnych plikow zrodlowych .pnml - ilosc,rozmieszczenie i nazewnictwo bywa rozne:
 przewaznieJakGRF.pnml    - naglowkowy rozpoczynajacy , zawierajacy spis pozostalej zawartosci
 \src\GRFid.pnml  . . . . . .  .  - nazwa, wersja, parametry etc
 \src\templates.pnml  . . . . .  - zdefiniowane sprity jako czesc wspolna
 \src\engine_dizel.pnml  .  .  - plik okreslajacy lokomotywe
 \src\wagon_pietrowy.pnml  - plik jakiegos wagonu
niestandardowe rozszerzenia: 
 \src\railtype_table.pnml  . .  - tabela typow torow  
 \src\cargos.pnml  . . . . . . .. - zestawienie obslugiwanych towarow 
 \src\costs.pnml  . . . . . . . .  - zmienne koszty
Przy budowaniu .grf nalezy to oczywiscie konsolidowac do .nml przed kompilacja.
Sluzy do tego pewien automatyczny program, ktory zawiera instrukcje do zrobienia podczas tego procesu .
Wystarczy uruchomic podajac nazwe (linia polecen). Chyba nieaktualne:  s.f.net z minGW .
Jesli jest w pythonie to bez rozszerzenia po kropce np. MakePY 
albo klikajac plik PreBuild.py lub dowolnie nazwany - skojarzony  .  
Po skonfigurowaniu cala kompilacja moze odbywac sie poprzez przycisk na belce, w menu aplikacji,
 w ktorej pisane .pnml .
Tym rozni sie .pnml od .nml , ze umieszczone sa wstawki , ktore nie wystepuja w tym drugim -- "nieimplementowane".

[metro]

.py

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")

 ^ mozna skopiowac calosc i wkleic

[metro]

W 32 bpp na poczatek wlasciwie mozna pominac dawne pliki z paleta 8 bit per pixel i wpisujac 0 lub 1 tymczasowo w nml.
Choc do korekcji obrazow w 8bpp nadaje sie spec szybka stronka:
http://bundles.openttdcoop.org/pixeltool/push/LATEST/
 
GIMP staje sie troche toporny, oblozony w coraz wiecej mniej uzywanych gadzetow dla zwyklejszej grafiki.
Preferuje na drobniejsze zmiany zerknac freeware P.Studio , ktory daje mozliwosc wylaczenia co akurat nie zamierzane obslugiwac:
  photofiltre.com
Oprocz wlasciwosci painta z "gumkowaniem" oraz po polsku,
jest wielokrotne,'cofanie' czynnosci czy plugin wymierzajacy pixele .