Aiuto
Livello = 1/10
Pre-Requisiti:
- come sono fatte le animazioni(necessarie per i layer animati, in questa prima parte però non verranno menzionate)
Cosa si utilizzerà:
- una copia del file .def dello stage di Kfm
- un editor di testo
- il programma Fighter Factory
Molti si chiedono come programmare uno stage.
E' in realtà piuttosto semplice. L'unica cosa che si richiede come re-requisito è sapere, in grandi linee, come è fatta una animazione AIR (Esclusi i Clsn Boxes che qui NON servono).
Se non lo sapete vi rinvio al file AIR.txt contenuto nella cartella "docs" della vostra release Mugen. Date un'occhiata alla traduzione di Oy ;)
Fatta questa dovuta introduzione spieghiamo come è strutturato questo tutorial:
Esso è strutturato in due livelli. Il primo livello spiega passo passo uno stage di base costruito su un solo layer.
Il secondo livello si occupa di approfondire di più la programmazione dei layers che sono poi il fulcro vero e proprio degli stage, dando per presupposta la conoscenza di ciò che è stato spiegato nel primo livello (e quindi viene omessa ogni spiegazione su come si completa la prima parte del .DEF, spiegata in questa prima parte del tutorial)
Possiamo, infatti, dividere idealmente lo stage .DEF in due parti.
La prima parte consiste in tutte le informazioni base dello stage (tutte le istruzioni fino alle istruzioni [BGDef …] comprese)
La seconda parte consiste nelle istruzioni di tutti i layer (livelli di disegno) che compongono lo stage. Le due parti non sono tra loro slegate, ma qui daremo prevalenza alla prima parte (accenneremo solo alla seconda parte per quello che ci serve in funzione della prima).
Il nostro primo obiettivo, quindi, è realizzare uno stage semplice, fatto solo di una immagine o di una animazione che determina, da sé, tutto l'aspetto dello stage (es. lo stage è il disegno di una casa con alberi ed è composto solo dall'immagine di una casa con alberi).
#----
Ipotizziamo quindi che il nostro stage sarà fatto di una immagine unica (di dimensioni 400x300) che raffiguri una casa con un cielo e degli alberi (una immagine unica e statica). Come possiamo rendere questa immagine uno stage giocabile?
Per prima cosa dobbiamo fare una copia del .Def dello stage di kfm (si trova in Mugen\Stages) e lo chiamiamo "casa.def" (potete ovviamente dargli un altro nome, cercate di capire l'esempio per quello che è).
Ora noi sappiamo (cosa fondamentale) quanto è grande esattamente il nostro stage. In questo caso è molto semplice perché la dimensione corrisponde alla dimensione dell'unica immagine della nostra fantomatica casa (400x300). Comunque, anche negli stage più complessi, di norma, c'è una immagine che fa da sfondo generale e che ci permette di sapere con esattezza la dimensione dello stage.
Altra cosa importante: la schermata del Mugen è grande 320x240 (si parla del Mugen classico, il tutorial si basa su quello) e quindi gli stage devono essere almeno grandi quanto quelle dimensioni, senza esagerare in altezza.
Cominciamo quindi a modificare il nostro file casa.def (e leggiamo i commenti che sono utilissimi, seppure in inglese).
[Info]
name = "Casa con gli alberi"
Questo è il nome dello stage (va racchiuso tra virgolette). Questo nome, in particolare, apparirà quando il Mugen ti permette di scegliere lo stage che vuoi utilizzare mostrandoti i nomi degli stage inseriti.
[Camera]
In questa sezione settiamo i movimenti della "telecamera" (lo stage scorre, mentre i nostri eroi combattenti si muovono in esso, seguendo i movimenti dei nostri personaggi in gioco)
startx = 0
starty = 0
Normalmente questi parametri (startx e starty)vanno lasciati così. L'unica cosa che succede cambiandoli è di avere un effetto di camera che, da un punto diverso dalla posizione dei combattenti si muove (VELOCEMENTE) verso i combattenti. Al 99% dei casi tali parametri vanno lasciati così come sono
boundleft = -40
boundright = 40
Tendenzialmente, quando uno stage ha dimensioni pari (come nel nostro caso perché la lunghezza dello stage è 400 pixel … ed è la regola che uno stage sia di lunghezza pari) i due parametri boundleft e boundright sono uguali. L'unica differenza è che boundleft è un valore negativo, mentre boundright è positivo.
Partendo dal presupposto che l'immagine è di dimensione pari (in questo caso 400 è un numero pari) e sapendo quanto è lunga, possiamo calcolare con esattezza questi valori.
boundright = (LUNGHEZZA_IMMAGINE / 2) - 160
boundright = (400 / 2) - 160 ;abbiamo detto che la nostra casa è "lunga" 400 pixel
boundright = 200 - 160
boundright = 40
Come abbiamo detto, essendo l'immagine di dimensione pari il valore di boundleft è lo stesso, solo che sarà un valore negativo, e quindi sarà -40
Cosa sono boundleft e boundright? molto semplicemente i parametri che ci dicono quanto spazio rimane ai giocatori da camminare andando a destra o a sinistra dello schermo.
boundhigh = -60
boundlow = 0
Manca solo da calcolare lo scorrimento verticale determinato da boundhigh e boundlow.
boundlow è molto facile da settare: il suo valore DEVE essere sempre 0 (non chiedetemi perché il Mugen ha voluto imporre un parametro che non è opportuno cambiare).
Per calcolare boundhigh (che, come potete vedere, è SEMPRE un valore NEGATIVO) abbiamo anche qui una formula
boundhigh = - (ALTEZZA_IMMAGINE - 240)
boundhigh = - (300-240) ;la nostra casa è "alta" 300 pixel
boundhigh = - (60)
boundhigh = -60
verticalfollow = .2
floortension = 0
tension = 60
Gli ultimi 3 parametri della telecamera servono per determinare la velocità di scorrimento verticale dello stage (più veloce se uno stage è molto alto e lo si vuole "mostrare" tutto, più lento se uno stage è più "basso").
Per settare questi parametri si va un po' a tentativi. Generalmente ho visto che gioca tutto su floortension e verticalfollow (io in particolare gioco su verticalfollow), mentre tendenzialmente il valore di tension l'ho sempre tenuto a 60. Comunque, come ho detto qui, per determinare i valori si va a tentativi. Quindi per ora si lasciano quelli che ci sono per poi cambiarli quando si prova lo stage fino a che non si è soddisfatti del risultato.
Altre (intere) sezioni che possiamo (e per alcuni parametri DOBBIAMO) lasciare completamente inalterate:
[PlayerInfo]
[Scaling]
[Bound]
Io non ho mai modificato alcun parametro in queste 3 sezioni e non è praticamente mai necessario farlo. Si va quindi alla sezione successiva
[StageInfo] ;Z offset for drawing ;Adjust this value to move the ground level up/down in the screen. ;It's the position where the players stand at. ;Up - smaller, Down - larger ;*** zoffset = 200 ;Leave this at 1. It makes the players face each other autoturn = 1 ;Set the following to 1 to have the background be reset between ;rounds. resetBG = 0
I commenti si spiegano da soli. Nella sezione [StageInfo] dobbiamo tendenzialmente modificare solo il parametro zoffset. autoturn DEVE essere lasciato ad 1. resetBG può essere settato anche ad 1 anziché a 0 ma, tendenzialmente, va lasciato a 0 (vedere commento: trad: "Imposta il seguente valore ad 1 per far ripartire le animazioni dello sfondo nel passaggio tra i vari round").
Ora quindi settiamo zoffset. Zoffset determina la linea di suolo. Il valore nello stage di kfm è 200, ma va modificato (a tentativi) fino a quando i personaggi stanno alla giusta altezza (toccando coi piedi il suolo). Come si può leggere dal commento, più alto è il numero e più in basso sarà posizionata la linea di suolo in cui i personaggi cammineranno.
[Shadow] ;This is the shadow color given in r,g,b. Valid values for each ;range from 0 (lightest) to 255 (darkest). ;Defaults to 92,92,92 if omitted. color = 32,32,32 ;This is the scale factor of the shadow. Use a big scale factor ;to make the shadow longer. You can use a NEGATIVE scale factor ;to make the shadow fall INTO the screen. ;Defaults to 0.4 if omitted. yscale = -.1 ;Set to 1 to draw "reflection" shadows. Defaults to 0. reflect = 1
Ora dobbiamo determinare come è fatta l'ombra. Color mi dà il colore (in RGB) della stessa (tendenzialmente va bene 32,32,32 che è un grigio molto scuro praticamente nero). Il valore scale determina la "grandezza" dell'ombra che viene determinata da una operazione di riduzione in scala. I commenti spiegano tutto, ma per i non anglofoni lo traduco
"Questo è il valore in scala dell'ombra. Usa un valore alto per rendere l'ombra più lunga. Puoi usare un valore NEGATIVO per far sì che l'ombra cada NELLO schermo"
In poche parole un valore negativo fa sé che l'ombra, anziché essere inclinata verso il basso sia inclinata verso l'alto. Tenete conto che un valore di 1 produrrebbe un'ombra grande quanto il vostro char (cosa del tutto innaturale) quindi il valore tendenzialmente è un valore che nemmeno si avvicina ad 1 (0.5 è già un valore che comincia ad essere grandicello).
Infine abbiamo "reflect" che, se impostato ad 1, produce un effetto di riflessione a specchio nel pavimento (come accade nel pavimento dello stage di KFM). Se questo tipo di effetto nel vostro stage stona (es. nello stage di Nobunaga ci starebbe come un cavolo a merenda, visto che si vede che il pavimento non deve essere riflettente) basta impostare il valore di reflect a 0.
[Music]
bgmusic = sound/casa.mp3
bgvolume = 255
Bhe, mi pare chiaro. Qui si dice quale musica va suonata quando si utilizza il nostro stage. Nell'esempio ipotizziamo di avere un file "casa.mp3" e di averlo copiato nella sotto-cartella "sound" del nostro mugen.
É infatti una buona pratica raccogliere le musiche nella cartella "sound" del Mugen
bgvolume è il volume della musica (valore massimo: 255). Visto che il Mugen abbassa di molto il volume tendenzialmente consiglio il valore massimo (255).
[BGdef]
spr = casa.sff
debugbg = 1
Qui termina la prima parte del file .DEF dei parametri generali. Dopo questa sezione comincia la seconda parte dello stage, quella dei layers.
In BGdef troviamo due parametri.
Il primo serve per sapere come si chiama il file .sff (su cui ci soffermeremo tra poco) che contiene le immagini dello stage (nel nostro caso il file .sff conterrà UNA SOLA IMMAGINE, grande 400x300 pixel e con disegnata una casa con alberi).
Noi il file .sff non l'abbiamo ancora creato ma sappiamo già che si chiamerà "casa.sff" quindi intanto completiamo il parametro.
La riga debugbg = 1 e' IMPORTANTISSIMA in questa fase di realizzazione dello stage. Infatti essa permette di sostituire gli eventuali "pezzi vuoti di stage" con dei pixel di colore rosa. Questo ci permetterà di individuare facilmente la presenza di eventuali "buchi" (che NON DEVONO esserci) nello stage. Una volta che lo stage è DEFINITIVAMENTE terminato e che siamo SICURI che non vi siano "buchi" e che tutto è a posto, possiamo tranquillamente ELIMINARE questa riga (disattivando la relativa funzione ed alleggerendo quindi il caricamento del nostro stage). Ora, in uno stage come il nostro (fatto di una sola immagine) è più difficile che ci sia una eventualità del genere, ma in stage più complessi può diventare vitale poter verificare subito ed in maniera immediata se sono rimasti o meno dei "buchi".
#----
Ora manca solo di programmare il nostro layer e di fare il nostro file .sff
Dobbiamo però occuparci prima del file .sff
Salviamo quindi le nostre modifiche e creiamo il nostro file .sff
Io spiego il metodo con Fighter Factory perché è più semplice per i neofiti, ma personalmente (poiché come vedremo sapremo già ESATTAMENTE come posizionare gli assi) io di solito utilizzo direttamente sprmaker perché ci vuole decisamente meno tempo.
Per creare il file .sff abbiamo bisogno della immagine della casa (deve essere in formato .PCX a 256 colori o, solo se usiamo Fighter Factory, può essere anche in formato .BMP a 256 colori) Ipotizziamo di avere quindi l'immagine "casa.pcx" grande 400x300 pixel.
Apriamo Fighter Factory -> andiamo nella sezione .SFF
Qui scegliamo di creare un nuovo file .SFF che chiamiamo "casa.sff"
Aggiungiamo l'immagine "casa.pcx" al gruppo 0, immagine 0 (palette individuale).
Posizioniamo l'immagine "casa.pcx" alle coordinate 200, 60 impostando direttamente i parametri degli assi, senza usare il mouse per far scorrere l'immagine.
Salviamo il file .sff
Non vi allarmate: ora vi spiego come si arriva a determinare che il disegno della casa debba essere posizionato ai valori 200, 60.
Se avete seguito il metodo fino a qui avrete capito che noi ci stiamo basando sulla dimensione dello schermo del Mugen (320x240) e sulla dimensione della immagine (400x300). Sappiamo (anche se non l'ho detto, ma non era indispensabile dirvelo avendovi dato io le formule di calcolo già pronte) che lo stage va messo "in mezzo" in maniera tale da poter essere "scorso" sia a destra che a sinistra. Sapendo queste informazioni, così come abbiamo potuto prima calcolare (nel .DEF) i valori di boundleft, boundright e boundhigh, ora possiamo calcolare la posizione degli assi nel file .sff
Qui sotto i valori per determinare i valori dell'asse x e dell'asse y da adottare nel file .sff quando si inserisce l'immagine principale dello sfondo dello stage
SFF: asse x = LUNGHEZZA_IMMAGINE / 2
SFF: asse y = ALTEZZA_IMMAGINE - 240
asse x = 400 / 2 = 200
asse y = 300 - 240 = 60
Ecco quindi perché la coordinata per l'asse x avrà valore di 200 e la coordinata per l'asse y avrà valore di 60.
Ora abbiamo salvato il file .sff e sappiamo che la nostra immagine è stata salvata come immagine 0,0 (numero gruppo, numero immagine).
Come sappiamo (e se non lo sapete datevi una occhiata ai tutorial Mugen) nel file SFF ogni immagine viene individuata NON da un nome di file, ma da una coppia unica di valori (in questo caso 0,0). Negli stage la scelta dei gruppi e dei numeri immagini è del tutto libera, ma si consiglia di utilizzare un gruppo per ogni diverso layer e una numerazione progressiva dei numeri immagine. In tal caso ci sarà più ordine.
Se ad esempio il nostro stage fosse composto da 3 layer (es. l'immagine "principale" dello stage, le nuvole e i lampi) ognuno dei quali risultasse essere una animazione composta da 3 immagini, sarebbe stata buona norma usare:
- un gruppo per l'immagine "principale" (es. gruppo 1)
- un gruppo per le nuvole (es. gruppo 2)
- un gruppo per i lampi (es. gruppo 3).
e quindi le immagini 1,1 1,2 e 1,3 saranno i 3 frames del primo layer (immagine principale)
le immagini 2,1 2,2 e 2,3 saranno i 3 frames del secondo layer (nuvole)
le immagine 3,1 3,2 e 3,3 saranno i 3 frames del terzo layer (lampi)
#------
Ma ora torniamo al nostro esempio di partenza.
Abbiamo completato la prima parte del file .def (fino a [BGdef] compreso), abbiamo pronto il file .sff (casa.sff) il quale contiene il disegno della casa e memorizzata nell'sff come immagine 0,0.
Dobbiamo ora inserire ora i layer. Questo nostro stage è fatto di una sola immagine (la casa) che racchiude tutti gli elementi dello stage. Abbiamo quindi un unico layer da programmare.
Riapriamo quindi il file .def e lo scorriamo fino alla fine delle istruzioni [BGdef].
Come vedete, subito dopo le righe [BGdef] abbiamo un sacco di istruzioni che iniziano con [BG qualcosa], ognuna delle quali rappresenta un layer dello stage che abbiamo usato come base di programmazione (quindi sono i layer che appartenevano allo stage di KFM).
Tutta questa roba, quindi, con il nostro stage non c'entra nulla. Ora dobbiamo inserire i nostri layer (nel nostro caso IL nostro layer).
Cancelliamo quindi TUTTE le istruzioni seguenti a [BGdef] e i suoi due parametri (spr e debugbg).
Una volta fatto questo aggiungiamo il nostro layer, che nello specifico sarà programmato così
[BG Casa] type = normal start = 0,0 spriteno = 0,0 mask = 0 delta = 1,1 layerno = 0
Salviamo il file .def ed il nostro stage sarà pronto.
Ci occuperemo più a fondo di cosa sono i layer e di come si programmano nella seconda parte del tutorial. Ora ci limiteremo a spiegare brevemente cosa abbiamo scritto.
[BG Casa]
Ogni layer inizia con una etichetta [BG qualcosa] dove "qualcosa" può essere qualunque stringa o anche un numero progressivo (es. [BG 0]). Non importa cosa si scrive esattamente al posto di "qualcosa"... Generalmente consiglio di scrivere una cosa che faccia capire a noi cosa stiamo disegnando con una descrizione breve, ma non è assolutamente un obbligo. Diciamo solo che il mio consiglio è finalizzato ad individuare più facilmente i punti che possano necessitare di correzioni in fase di prova.
type = normal
Il nostro layer è costituito da una sola immagine fissa. Quindi è un layer "normal" (un solo disegno fisso). Sui tipi di layer ci soffermeremo nella seconda parte del tutorial.
start = 0,0
La nostra immagine che "copre" tutta l'area dello stage, determinandolo, l'abbiamo già accuratamente posizionata calcolando gli assi nell'SFF. Quindi non abbiamo bisogno di fare ulteriori spostamenti. Il parametro "start" serve per sapere dove posizionare il disegno rispetto agli assi SFF. In questo caso non abbiamo bisogno di spostamenti ulteriori, quindi lo mettiamo a 0,0. In altri casi, per stage complessi composti da più layers, invece, sarà necessario per alcuni layer andare a tentativi per un perfetto posizionamento e quindi bisogna provare fino a quando non si arriva al valore di start che ci serve. Non è però il nostro caso.
spriteno = 0,0
Il nostro layer è fatto di una sola immagine che, nel file SFF, abbiamo salvato come immagine 0,0. Quindi settiamo spriteno (che richiama una singola immagine) con la coppia di valori che individua l'immagine nell'sff (nel nostro caso l'abbiamo salvata come immagine 0,0 e quindi mettiamo 0,0).
delta = 1,1
questo dice la velocità di scorrimento. 1,1 significa che la velocità è di un 1 pixel in lunghezza e 1 pixel in larghezza per ogni pixel di spostamento dei char (in poche parole va di pari passo con i personaggi).
Generalmente i layer a velocità normale vengono settati sempre con delta = 1,1.
Di norma layer che richiedono una velocità diversa possono essere ad esempio i layer in secondo piano (che sono più lenti) o quelli in primo piano (che sono più veloci) quando si vuole dare una sorta di impressione di visione prospettica.
layerno = 0
Negli stage questo può assumere il valore di 0 se il layer (come in questo caso) deve stare dietro al char. Invece va impostato ad 1 se il layer deve stare davanti al char (es. una colonna su cui i chars devono "passare dietro" quando la attraversano).
mask = 0
Serve per disegnare anche il colore 0 che normalmente non andrebbe disegnato. In questo caso l'abbiamo messo a 0, ma nella normalità dei casi andrà messo ad 1. NOTA: questo parametro ha effetto solo sui layer fissi e non sulle animazioni.
#-----
FINE PRIMA PARTE.
Note: Le formule che vi ho dato me le sono ricavate da me e sono state "verificate sul campo" dal sottoscritto ;)
