Impariamo insieme Denmakufu ph3 parte 1 (Introduzione struttura e sintassi)

Di TheXanada96

Danmakufu è un programma per Windows (eseguibile su MacOS e distribuzioni Linux usando Wine) che consente alle persone di creare modelli danmaku simili a quelli nei giochi Touhou Project e altri Bullet Hell/Shoot ‘Em Up. Fornisce una moltitudine di funzioni integrate da utilizzare e, sebbene sia molto limitato in termini di ciò per cui può essere utilizzato in quanto è stato progettato per gestire gli Shoot ‘Em Up in stile Touhou, è comunque possibile fare in modo che Danmakufu faccia ciò vuoi entro quei limiti sorprendentemente flessibili come giochi Shoot ‘Em Up orizzontali (Come i primi giochi di Touhou) o come Visual Novels che sono molto possibili con il framework Danmakufu esistente.

Per cominciare facciamo un esempio di codice:

let str = "Questo è un codice in Danmakufu.";

Per digitare in Danmakufu devi usare le estensioni .dnh sui tuoi file per i servizi di evidenziazione del testo descritti più avanti in questa lezione e per una varietà di altri scopi.

Premessa:

Questo tutorial mira a coprire tutto, dalle basi ai concetti moderatamente avanzati sia in Danmakufu che in Informatica, e avrà risorse per quanto riguarda l’editing grafico e Audacity.

Consiglio vivamente di fare questi tutorial in un ordine relativo: all’interno di un’unità, fai ogni lezione una alla volta e assicurati di aver compreso gli argomenti trattati in una lezione precedente prima di passare a quella successiva. Alla fine, colui che imparerà questa lingua sei tu, e questo tutorial è semplicemente una delle tante risorse pensate per assisterti nell’apprendimento del Danmakufu Ph3 di base.

Come scarico denmakufu?

Il link ufficiale per il download di Touhou Danmakufu ph3 si trova qui.

Per riferimento futuro, puoi anche fare clic su “Download Ph3” nella pagina principale di Danmakufu, che ti porterà a questo sito. Ovviamente è tutto in giapponese, ma non lasciarti confondere, fai clic sul collegamento per la versione più recente, che dovrebbe essere in alto a sinistra.

Dopo averlo fatto, inizierà il download. Controlla se lo script è preconfezionato con Danmakufu. In tal caso, esegui l’eseguibile fornito

Come aprire Denmakufu

Inizieremo questa lezione con le note su come eseguire Danmakufu. Per ph3 fai semplicemente doppio clic sull’eseguibile (th_dnh.exe). Per le versioni di Danmakufu precedenti di ph3, era necessario utilizzare le impostazioni di testo giapponesi per aprire Danmakufu o non funzionava correttamente.

Nella cartella di Danmakufu c’è anche un DnhViewer.exe. Questo è un po ‘come l’exe principale tranne per il fatto che sono disponibili alcune chiavi di debug (come l’invincibilità o la trasparenza nelle texture). C’è anche un config.exe per le opzioni di configurazione.

Danmakufu si apre con il titolo che indica la versione di Danmakufu in esecuzione. Ci sono 7 opzioni in ph3 e un misuratore FPS in basso a destra: questo misuratore FPS è molto importante, quindi ti preghiamo di prenderne nota durante lo scripting.

Le opzioni nel menu principale di Danmakufu sono le seguenti:

• All: Visualizza tutti i file eseguibili che Danmakufu può trovare nella directory “script”: questa è raramente una buona opzione per fare clic e può effettivamente eseguire l’overflow dello stack se si hanno molti script e poca RAM.
• Single: Visualizza ogni singolo script singolare Danmakufu che puoi trovare nella directory “script”
• Plural: visualizza più script che Danmakufu può trovare nella directory “script”
• Stage: Visualizza solo lo stage che Danmakufu può trovare nella directory “script”
• Package: Visualizza ogni pacchetto che Danmakufu può trovare nella directory “script”
• Directory:

• All: Visualizza tutti i file eseguibili che Danmakufu può trovare nella directory “script”: questa è raramente una buona opzione per fare clic e può effettivamente eseguire l’overflow dello stack se si hanno molti script e poca RAM.
• Single: Visualizza ogni singolo script singolare Danmakufu che puoi trovare nella directory “script”
• Plural: visualizza più script che Danmakufu può trovare nella directory “script”
• Stage: Visualizza solo lo stage che Danmakufu può trovare nella directory “script”
• Package: Visualizza ogni pacchetto che Danmakufu può trovare nella directory “script”
• Directory:

• All: Visualizza tutti i file eseguibili che Danmakufu può trovare nella directory “script”: questa è raramente una buona opzione per fare clic e può effettivamente eseguire l’overflow dello stack se si hanno molti script e poca RAM.
• Single: Visualizza ogni singolo script singolare Danmakufu che puoi trovare nella directory “script”
• Plural: visualizza più script che Danmakufu può trovare nella directory “script”
• Stage: Visualizza solo lo stage che Danmakufu può trovare nella directory “script”
• Package: Visualizza ogni pacchetto che Danmakufu può trovare nella directory “script”
• Directory: Entra nella directory degli script tramite Danmakufu e ti consente di navigare facilmente tra i file.
• Quit: Esci dall’applicazione.

Nei menu di Danmakufu, usa Z per selezionare e X per annullare. Usa i tasti freccia per navigare. Indipendentemente dall’opzione (eccetto Quit), verrai portato a un nuovo menu che elenca i tuoi script. Nella metà inferiore sarà il percorso relativo dall’interno della directory dello script al file eseguibile (in rosso), il tipo di file (in viola), il testo. Premi Z per selezionare. Ti verranno date le opzioni per giocare e per eseguire replay se li hai. I replay vengono memorizzati nella directory “replay” all’interno di una cartella di script. Se in Directory, ci sarà un percorso per la directory in cui ci si trova attualmente in alto e si seleziona una directory (contrassegnata in rosso) per inserirla. Nota che solo gli script riconosciuti da Danmakufu verranno visualizzati come eseguibili blu. Dopo aver selezionato “Play” verrai portato a una scena di selezione del giocatore. Seleziona il tuo giocatore e il gioco è fatto! Nota che se aggiungi un file a una cartella di script, Danmakufu lo caricherà una volta che sarai reinserito nella directory. Tuttavia, se rimuovi uno script del giocatore dopo aver caricato Danmakufu, l’opzione per quello script del giocatore sarà ancora presente e mostrerà un errore quando selezionato. Di conseguenza, è necessario chiudere e riavviare Danmakufu per aggiornare l’elenco dei giocatori.

I comandi

In Danmakufu, come lo standard Touhou, puoi sparare, bombardare, focussare e mettere in pausa, tra le altre cose. Tuttavia, ph3 consente agli scripter di aggiungere chiavi virtuali personalizzate ad esempio puoi far sparare altri tipi di missile con H o K, ma di base i controlli sono:

• Z: Per selezionare o sparare
• X: Per annullare, tornare indietro o bombardare
• Shift: Per focussare(rallentare e concentrarsi)
• Ctrl: Per velocizzare
• Esc: Per mettere in paura o uscire.

Quali sono i diversi tipi di script in Danmakufu?

Per prima cosa, esaminiamo il singolo, che tende a contenere un attacco, sebbene possa essere modificato per includerne più o meno uno a seconda degli obiettivi dello sceneggiatore. In generale, sarà una parte della barra della vita del boss e conterrà un non incantesimo o un incantesimo.

Gli script Single sono sorprendentemente versatili. Poiché ph3 ti consente di controllare parti significative del sistema, puoi trasformare una non magia in una magia a metà, usare più boss e altre cose, a seconda di ciò di cui hai bisogno.

Ora passiamo agli script Plural. La funzione principale di uno script “plural” è di contenere riferimenti a singoli script al fine di concatenare attacchi insieme in una battaglia con un boss. Sebbene ph3 ti permetta di mettere ciò che normalmente sarebbe inserito in uno script plurale in uno stage, consiglio comunque di usare script plurali per le battaglie con i boss, in quanto consente un accesso facile e veloce ai singoli script. Inoltre, si consiglia di padroneggiare gli script plurali prima di passare agli stage: gli script iniziali avranno un uso limitato per gli script stage, di cui parleremo in seguito.

Gli script Stage sono gli elementi costitutivi dei giochi completi e vengono utilizzati anche per rilasciare battaglie con i boss indipendenti con selezione di difficoltà incorporata e altre opzioni. Le fasi possono caricare più script e vengono fornite con una varietà di opzioni di personalizzazione. Una volta che hai imparato l’uso dei plurali, molto probabilmente passerai direttamente alle fasi. Tuttavia, è per molto dopo, quindi non concentrarti su questo ora.

I Packages sono nuovi in ph3. con la nuova versione abbiamo la funzionalità che funge da menu principale per il tuo gioco. Sono personalizzabili al 100%, sebbene abbiano limitazioni in termini di funzioni consentite. I pacchetti vengono utilizzati per giochi completi e progetti in cui si desidera un menu principale.

Sebbene i precedenti siano i tipi principali di script, ci sono anche alcuni tipi di file chiave da notare: file di sfondo e di sistema. Ne discuteremo in dettaglio più avanti in futuro, ma diciamo solo che potresti voler usare le impostazioni predefinite fino a quando non ti sentirai a tuo agio con il compito e la manipolazione di immagini e testo di base in Danmakufu.

Struttura del codice

#TouhouDanmakufu[Single]
#ScriptVersion[3] //Questo è necessario negli script ph3
#Title["SampleA01"]
#Text["SampleA01：Shooting Bullets Straight Down"] 

//Carica i valori predefiniti di sparo
#include "script/default_system/Default_ShotConst.txt"
//----------------------------------------------------
//Dichiara variabili globali
//Le variabili qui dichiarate possono essere utilizzate in tutto lo script. 
//Tuttavia, le variabili qui dichiarate sono statiche. 
//(Possono essere modificati, ma non da soli in quanto non sono nel ciclo principale) 
//(Poiché non è possibile garantire l'ordine di esecuzione, non è possibile utilizzare numeri casuali)
//----------------------------------------------------
let objEnemy; //Oggetto nemico 
let frame = 0; //Conta il tempo dei movimenti nemici (continuerà ad aumentare di uno in @MainLoop)

//----------------------------------------------------
//Movimento del nemico
//----------------------------------------------------
@Event
{
 alternative(GetEventType())
 case(EV_REQUEST_LIFE)
 {
 //Questo codice chiede della vita del nemico
 SetScriptResult(500); //Imposta la vita del nemico a 500
 }
}

@Initialize
{
 //Creazione e registrazione di nemici 
 objEnemy = ObjEnemy_Create(OBJ_ENEMY_BOSS);
 ObjEnemy_Regist(objEnemy);

 //Impostazione dell'immagine del nemico 
 let imgExRumia = GetCurrentScriptDirectory() ~ "ExRumia.png"; //percorso del file dell'immagine
 ObjPrim_SetTexture(objEnemy, imgExRumia); 
        //Imposta il file immagine come una texture per l'oggetto nemico (objEnemy) 
 ObjSprite2D_SetSourceRect(objEnemy, 64, 1, 127, 64); 
        //Impostazione delle coordinate del rettangolo nell'immagine nemica da utilizzare (Sinistra, Alto, Destra, Basso). 
 ObjSprite2D_SetDestCenter(objEnemy); 
        //Posiziona al centro del rettangolo (con texture) a (0, 0) sullo stage (angolo in alto a sinistra). 

 //Spostamento alla coordinata (cx, 60) in 60 fotogrammi 
 let cx = GetStgFrameWidth() / 2;
        //definisce la variabile cx come il centro orizzontale dello stage. (Larghezza dello stage / 2) 

 ObjMove_SetDestAtFrame(objEnemy, cx, 60, 60);
}

@MainLoop
{
 //recupero delle coordinate nemiche 
 let ex = ObjMove_GetX(objEnemy);
 let ey = ObjMove_GetY(objEnemy);

 if(frame == 60)
 {
 // si esegue quando il frame è uguale a 60
  // ・ spara un proiettile verso il basso dalla posizione del nemico
  // ・ velocità: 3 pixel per fotogramma
  // ・ angolo: 90 (giù) (0 = destra, 180 = sinistra, 270 = su)
  // ・ ritardo: 30 fotogrammi 
 CreateShotA1(ex, ey, 3, 90, DS_BALL_S_RED, 30);

 frame = 0;
         //dopo che il proiettile è stato sparato, il frame viene riportato a 0 per aumentare di nuovo fino a 60 e sparare un altro proiettile. 

 }

 //Impostazione della hitbox del nemico 
 ObjEnemy_SetIntersectionCircleToShot(objEnemy, ex, ey, 32); //hitbox contro i proiettili del giocatore. 32 è il raggio.
 ObjEnemy_SetIntersectionCircleToPlayer(objEnemy, ex, ey, 24); //hitbox contro il giocatore. 24 è il raggio.

 //aggiungendo +1 al frame. "frame ++" è equivalente a "frame = frame + 1;" o "frame + = 1;" 
 frame++;

 //Se la vita del nemico è 0 
 if(ObjEnemy_GetInfo(objEnemy, INFO_LIFE) <= 0)
 {
 //il nemico viene ucciso immediatamente quando la vita è 0 
 //si tratta di uno script di esempio per principianti,
 //lo script termina immediatamente senza attendere un effetto esplosione 
 Obj_Delete(objEnemy);
 CloseScript(GetOwnScriptID());
 return;
 }
}

Se non hai esperienza con l’informatica, probabilmente sei completamente sopraffatto da questo muro di codice. Questo particolare singolo è la traduzione (dal giapponese) di SampleA01, che si trova nella directory “sample” all’interno della cartella dello script ph3. Questo è codice scritto per essere utilizzato come modello per gli scripter e, come tale, è ciò che userò come esempio. Per riferimento futuro, utilizza gli script di esempio (e il boss e il giocatore di ExRumia), poiché sono una risorsa utile. Quindi ora guarderemo il testo e lo smonteremo pezzo per pezzo.

Quali sono i componenti dell’intestazione Danmakufu?

#TouhouDanmakufu[Single]
#ScriptVersion[3] //Questo è necessario negli script ph3
#Title["SampleA01"]
#Text["SampleA01：Shooting Bullets Straight Down"] 

Come in molti linguaggi i “//” sono dei commenti.

Innanzitutto, ci sono cose in alto precedute dall’hashtag #. Questi compongono l’intestazione Danmakufu. La prima riga è #TouhouDanmakufu [Single]. Questo designa lo script come uno script Touhou Danmakufu – senza questa riga, Danmakufu non leggerà il file come eseguibile danmakufu e quindi non verrà visualizzato in nessuna delle ricerche. Al posto di “Singolo”, puoi anche utilizzare “Plural”, “Stage” e “Pacckages”, i tipi di script elaborati nella Parte 1.

Poi c’è #ScriptVersion [3]. Come affermato dal commento accanto ad esso, situato dopo //, è richiesto per tutti gli script ph3. #ScriptVersion [2] si riferisce a Danmakufu 0.12m e #ScriptVersion [1] si riferisce a qualcosa di fatto quando Touhou 10 non esisteva. Diciamo solo che devi solo avere #ScriptVersion [3] affinché ph3 esegua lo script correttamente.

Dopo la versione dello script ci sono due campi etichettati #Title e #Text, con una stringa all’interno contenente tutte le informazioni utilizzate per descrivere i campi. Ciò che è inserito in #Title apparirà come etichetta per lo script quando attraversi gli elenchi di script di Danmakufu e #Text descrive il testo nel quarto inferiore sinistro dello schermo. Consiglio vivamente di non lasciare mai #Title vuoto, poiché può confondere le persone che navigano in una cartella se improvvisamente hai uno script senza titolo – se non vuoi che Danmakufu elenchi lo script quando sputa l’elenco di tutti gli script eseguibili, è meglio commentare la riga #TouhouDanmakufu [ScriptType] invece. Come manipolare le stringhe in ph3 e come commentare sarà discusso in un tutorial successivo.

Come rapido esempio, vedere quanto segue. Notare che [r] viene utilizzato per le interruzioni di riga.

#Title["Descent of the Mochi Hammer - Stage 6"]
#Text["Descent of the Mochi Hammer[r]Stage 6[r]By Sparen"]

Inoltre, ci sono alcuni campi che non vengono mostrati qui, #Image, #BGM, #Player, #Background e #System. Queste sono le parti facoltative dell’intestazione. Per prima cosa parlerò di #Image e #BGM. #Image controlla se un’immagine verrà visualizzata o meno nel quarto in basso a destra dello schermo quando passi il mouse su un particolare script nei menu di Danmakufu. Se vuoi includere un’immagine, inserirai il percorso dell’immagine all’interno delle parentesi, È possibile includere un percorso per un file musicale in #BGM riprodurre una traccia musicale. È possibile includere un percorso per un file musicale in #BGM per riprodurre una traccia musicale. Questo è abbastanza utile se non vuoi caricare e riprodurre manualmente il file bgm, ma ci sono vari usi per entrambi.

#Player può essere utilizzato per limitare i giocatori che possono essere giocati. Viene utilizzato principalmente per specificare un giocatore (solitamente incluso nello script). Se non desideri specificare un giocatore da utilizzare, ometti completamente questo campo. Per specificare più giocatori, dovresti avere una virgola tra i percorsi dei file. Per esempio:

Quali sono le routine principali utilizzate in un singolo?

Gli elementi con prefisso @. Queste sono le routine di un singolo script. Come elencato nella pagina, ci sono @Event, @Initialize e @MainLoop, oltre a @Loading e @Finalize, che devono essere utilizzati insieme durante il caricamento delle risorse. I principianti dovrebbero semplicemente ignorare @Finalize e @Loading fino a quando non creano progetti più grandi. Nota che la L in @MainLoop è in maiuscolo. Danmakufu distingue tra maiuscole e minuscole. Non utilizzare @Mainloop o il tuo script non funzionerà perché MainLoop e Mainloop sono due cose completamente diverse.

In @Initialize, viene eseguito solo una volta all’inizio dello script, i comandi tra le parentesi graffe {} vengono eseguiti in ordine. Qui registrerai i nemici, preparerai le risorse e di solito sposterai il boss nella posizione di partenza desiderata. Non entrerò più nei dettagli su questi ora, ma imparerai gradualmente cosa mettere qui man mano che acquisirai il tuo stile di codifica. Ne discuterò quando assembliamo il nostro primo copione singolo.

Il prossimo è @MainLoop. Per impostazione predefinita, questa routine viene eseguita una volta per frame. Ci sono 60 fotogrammi in un secondo, si spera, come mostrato nel misuratore FPS. Poiché @MainLoop esegue ogni frame, è comunemente usato per cose che devono eseguire ogni frame, come l’impostazione della hitbox del boss. Puoi controllare una serie di cose qui, anche se la maggior parte degli scripter tende a utilizzare le attività in combinazione con @MainLoop o completamente indipendentemente da @MainLoop.

Il prossimo è @Event, che è stato introdotto in ph3. Qui, vari “eventi” sono controllati e qui imposterai cose come bonus degli incantesimi, vita del boss e altre cose. Parleremo brevemente di @Event quando realizzeremo il nostro primo singolo, anche se dal momento che può diventare complicato, la maggior parte dei dettagli verrà trattenuta per tutorial di livello superiore.

Infine, @Finalize, che era presente in 0.12m, e @Loading, che è stato introdotto in ph3. @Loading viene eseguito una volta prima di @Initialize e deve essere utilizzato solo per caricare le risorse. In un lontano futuro, potrebbe esserci una spiegazione molto più completa di ciò che fa @Loading, ma per ora, tieni presente che esiste. @Finalize viene eseguito una volta alla fine di uno script e viene utilizzato per eliminare le risorse caricate. Entrambi sono completamente opzionali e possono essere omessi da uno script.

Cosa sono i commenti?

let x; //Questo codice dichiara una variabile chiamata x. 
x = 5; //Ora il valore di x è stato impostato su 5.
x = 3; //Il valore di x è stato sovrascritto e ora è 3. 
let y = x; //Creiamo una nuova variabile y, il cui valore corrente è quello di x, che è 3. 
x = 4; //x è attualmente 4, ma y mantiene il suo valore pari a 3 

let x; //Questo codice dichiara una variabile chiamata x. 
let x = 5; //Ora il valore di x è stato impostato su 5.

x = 5; //Questo codice dice alla variabile x di memorizzare il valore 5.
let x = 3; //Dichiara una variabile x che memorizza il valore 3. 

Cosa sono le costanti?

Le costanti sono identificatori che non cambiano mentre un programma è in esecuzione, a differenza delle variabili. I nomi delle costanti sono tutti maiuscoli per convenzione. Ad esempio, le costanti incorporate in Danmakufu includono BLEND_ADD_ARGB e EV_GRAZE, tra le altre cose. La maggior parte di questi sono incorporati o utilizzati nei fogli di ripresa. Se decidi di utilizzare le tue costanti, assicurati che il nome sia MAIUSCOLO e di non modificare affatto il valore. Ad esempio:

let CIRNO = 9;

Quali operazioni matematiche posso eseguire a Danmakufu?

let x;
x = 3 + 5; //x ora contiene il valore 8 
x=x+3; //x ora contiene il valore 11. Nota che lo spazio bianco non ha importanza. 
x++; //Questo è equivalente a x = x + 1. Incrementa x di 1. Molto utile per i contatori. 
x--; //Come sopra. Decrementa il valore di x di 1. 
let y = 6;
y = y * 2; //y è ora uguale a 12. 
y = y / 3; //y è ora uguale a 4. 
y = y ^ 2; //y viene elevato alla seconda potenza e ora è 16. 
y = y % 2; //Dal momento che il resto / modulo quando y / 2 = 0, y ora è 0. 

Tuttavia, si prega di prestare attenzione a quanto segue:

let y = (55)(33); //Questo non funzionerà.
let y = 55 * 33; // Questo è il modo corretto per moltiplicare i due numeri. 

Notare inoltre che non è possibile eseguire operazioni su variabili che non esistono

let y = 30; 
let z = x * y; //Verrà visualizzato un errore poiché x non è stato dichiarato. 

E infine, una delle cose più odiose che farà apparire un errore.

let y = 30; 
y += .5;

L'errore? Ebbene, Danmakufu non capisce cosa significhi il periodo. Devi usare 0.5 invece di .5 affinché Danmakufu lo riconosca e non ti sbagli. 

Cosa sono variabili globali e locali?

Quindi ora, per la nostra discussione sulle variabili locali e globali (e sull’ambito delle variabili), faremo riferimento al codice utilizzato nella lezione precedente.

Le variabili globali sono variabili dichiarate al di fuori di attività, funzioni e routine. Di solito sono dichiarati tra Danmakufu Header e @Initialize o @Event (a seconda di quale si verifica per primo). È possibile fare riferimento a una variabile dichiarata qui e modificarla da qualsiasi altra parte dello script. Ad esempio, nel codice fornito, objEnemy e frame sono dichiarati come variabili globali. In @MainLoop, il frame viene referenziato e modificato più volte. Ricorda solo che le modifiche apportate a una variabile globale utilizzata in più posizioni influenzeranno tutte le posizioni in cui viene utilizzata, quindi si consiglia di modificare solo una variabile globale in una routine / funzione / attività e in nessun altro. Per i contatori, suggerisco di utilizzare @MainLoop.

In @MainLoop, il ciclo inizia con la dichiarazione di ex ed ey. Queste sono variabili locali: esistono solo in @MainLoop e una volta che @MainLoop termina un round, vengono ripristinate. Ciò significa che vengono aggiornati ogni frame a causa della natura di @ MainLoop.

Le variabili locali vengono create anche nei cicli di salita e discesa e anche i parametri di funzioni e attività sono variabili locali, tranne per il fatto che queste variabili locali hanno una qualità speciale: sovrascriveranno le variabili globali con lo stesso nome quando chiamate all’interno del ciclo, funzione, o compito. Questo è noto come ombreggiatura variabile e verrà spiegato nelle sezioni relative ai concetti forniti. Queste variabili locali, poiché sono accessibili solo all’interno del blocco (area all’interno di {}) in cui sono dichiarate, hanno il loro ambito (l’area in cui possono essere referenziate) limitato a quel blocco, a differenza delle variabili globali il cui ambito è limitato all’intero script (il file specifico, non l’intero progetto, che tendiamo a chiamare anche uno “script Danmakufu”).

Infine, puoi dichiarare le variabili locali nel modo seguente:

local{
     let x;
}

Tuttavia, pochissimi scripter lo usano e molto probabilmente non lo incontrerai mai a meno che tu non stia cercando di decodificare il codice di qualcun altro dai giorni iniziali di ph3. Per fornire un esempio più concreto di variabili locali e globali (e di scoping delle variabili), osservare di seguito.

let x = 1;

@MainLoop {
    let y = 2 * x;
    ascent(i in 0..y){
        let j = i + x/y;
    }

    //non è possibile accedere a i o j qui 
}

//non è possibile accedere a i, j o y qui 

Nel codice precedente, x è una variabile globale a cui è possibile accedere ovunque nello script. Di conseguenza, all’interno di @MainLoop, possiamo accedere a x. y tuttavia è locale rispetto a @MainLoop e non è possibile accedervi al di fuori di @MainLoop. Tuttavia, è possibile accedervi all’interno del ciclo di risalita poiché ha un ambito globale rispetto al ciclo di risalita. In quanto tali, i e j, che sono locali rispetto al ciclo di risalita, possono usare sia x che y, ma non è possibile accedervi al di fuori del ciclo di risalita.

Esempi di logica javascript:

let x = 8; //dichiaro che x ha il valore di 8
x += 5; // dichiaro che x deve addizionarsi con 5 diventando 13
x = x ^ 2; // dichiaro che x deve elevarsi a 2 (13x13)diventando 169
x -= 3; //dichiaro che x deve sottrarsi di 3 diventando 166

Il valore finale è 166

let x = 8; //dichiaro che x ha il valore di 8
let y = 6; //dichiaro che y ha il valore di 8
x = x * (y - 3);// dichiaro che x deve moltiplicarsi a 3(risultato di y-3)= 24
x += 9; //dichiaro che x deve addizionarsi a 9 diventando 33

il valore finale è 33

Cosa sono i caratteri e posso cambiare il tipo di una variabile?

In Informatica, un carattere tipico si riferisce a una singola lettera, numero o simbolo. I caratteri sono indicati utilizzando virgolette singole, in questo modo: let x = ‘a’;

In Danmakufu, molto probabilmente non userete i caratteri, piuttosto userete le stringhe, l’argomento della parte successiva. Tuttavia, ora è un buon momento per mostrare uno dei concetti più importanti di Danmakufu (e dell’informatica in generale): i tipi di variabili.

let x = 6; //x è un contenitore che contiene un numero intero 6
let y = '$'; //y è un contenitore che contiene il carattere $ 
let z = '3'; //z è un contenitore che contiene il carattere 3 
x = '3'; //Questo codice mostrerà un errore 

Quindi, perché non puoi impostare il valore della variabile x da 6 a “3”? Bene, questo perché quando assegni per la prima volta un valore a x, contiene un numero intero. Successivamente, stai cercando di impostare il suo valore su un carattere. Ciò non è consentito, poiché x è stato impostato per accettare solo numeri. “3” non è un numero in Danmakufu, è un carattere. In altre lingue, i caratteri possono avere equivalenti interi e l’addizione può essere possibile, ma ti suggerisco semplicemente di non provare a farlo perché potrebbe avere risultati indesiderati.

Ma cosa succede se si desidera definire x = ’33’ ;? Beh … non funzionerà, e lo vedremo nella prossima parte.

cosa sono le stringhe?

Le stringhe sono molto più utili dei personaggi in Danmakufu. Le stringhe possono essere utilizzate per contenere frasi, percorsi di file e altro e sono indicate mediante virgolette doppie. Si prega di notare che se si utilizzano virgolette intelligenti (ad esempio “Non programmare in Microsoft Word, per favore.”), Danmakufu non capirà cosa sono e potrebbe non trovare il file in cui sono utilizzati in / crash / altri comportamenti indesiderati. Di seguito sono riportati esempi di stringhe.

let randomstring = "Questa è una stringa casuale."; 
let spellname = "Segno di fuoco e acqua \" Geyser degli abissi \ ""; 
let imgRumia = GetCurrentScriptDirectory() ~ "img/imgrumia.png"; 
let desc = "Questa è una spellcard creata da Obama. [r] continua a tuo rischio e pericolo."; 

Ovviamente, le stringhe contengono molte più informazioni di un carattere e sono molto più utili. Puoi includere numeri nelle stringhe, come “3 + 6 = Cirno” e altre cose del genere.

Nei quattro esempi sopra, abbiamo tre scenari speciali che meritano un’attenzione particolare: il carattere di escape(la barra rovesciata \.) di spellname, la concatenazione di stringhe di imgRumia e la [r] di descrizione,

In primo luogo, il carattere \. Nella maggior parte dei linguaggi di programmazione e scripting, viene utilizzato come carattere di escape e, se seguito da determinati simboli, eseguirà una funzione specifica.

Ad esempio, nella maggior parte delle lingue, \n denota una nuova riga (non in ph3 – ne parleremo più avanti), \t denota una tabulazione e, più specificamente per questo scenario.

\ “denota una”.
Poiché le stringhe iniziano e finiscono con virgolette doppie, avere virgolette doppie all’interno di una stringa richiede alcune soluzioni alternative, e tale soluzione è fornita da \ “, che non verrà letto come chiusura della stringa ma piuttosto come un simbolo che, quando la stringa viene stampata, utilizzerà le virgolette doppie invece di \ “.

La prossima è la concatenazione di stringhe. Ai fini di questo tutorial, tieni presente che GetCurrentScriptDirectory restituisce una stringa.

let imgRumia = GetCurrentScriptDirectory () ~ “img / imgrumia.png”;

Qui abbiamo una stringa ~ stringa. Allora cosa fa questo? Questo è noto come concatenazione di stringhe e unisce le due stringhe. Per esempio:

let string = "String1" ~ "String2"; //la stringa ora è "String1String2" 

Lo userai quasi sempre per i percorsi assegnati alle variabili. Inoltre è utile in una serie di altre situazioni. 

E infine, [r]. [r] è nuovo in ph3 (0.12m usato \ n). [r] denota una nuova riga e funziona come un’interruzione di riga. Pertanto, let string = “one [r] two” ;, se stampato, mostrerebbe quanto segue:

one
two

Molto utile in #Testo, con dialoghi e molte altre cose.

Nota che per il testo giapponese c'è anche [ruby], ma questo va oltre lo scopo di questo tutorial. 

L’ultima cosa che discuteremo in questa lezione sono gli array, che sono essenzialmente contenitori che contengono più cose dello stesso tipo. Ad esempio, una stringa è un array di caratteri. In Danmakufu, dichiari gli array come segue:

let array = []; //Dichiara un array vuoto 
let array2 = [3, 4, 6, 8]; //Dichiara una matrice di numeri contenente 3, 4, 6 e 8 
let array3 = GetAllEnemyID(); //Dichiara un array contenente gli ID di ogni oggetto nemico attualmente esistente 

Notare che una volta dichiarato un array, il nome della variabile che si utilizza non può essere utilizzato per altro che per un array. Non puoi fare quanto segue:

let array = []; //Dichiara un array vuoto 
array = 999;

La variabile “array” è stata utilizzata per un array e non può essere utilizzata per nient’altro. Per quelli di voi che provengono da altri linguaggi di programmazione, notare che non è possibile dichiarare un array di una dimensione predefinita in Danmakufu. Raccomandiamo la concatenazione di nuovi elementi.

Gli array sono molto utili, ma ovviamente dovrai aggiungere e recuperare dati da essi. Pertanto, ci sono modi per aggiungere elementi agli array, rimuovere elementi dagli array e ottenere i valori contenuti negli array.

Per prima cosa discuteremo l’aggiunta di cose agli array. Utilizzando l’operatore di concatenazione ~, puoi eseguire le seguenti operazioni:

let array = [3, 6]; // Definisce un array di numeri interi
array = array ~ [4]; // l’array ora è [3, 6, 4]

Si noti che è necessario includere l’elemento che si intende aggiungere come array: in sostanza, si stanno combinando due array. Inoltre, puoi usare concatenate (array1, array2) per concatenare due array, sebbene il metodo con ~ sia molto più semplice. Ecco un altro esempio, questa volta che mostra come includere il valore di una variabile in un array:

let array = []; //Declare an empty array
let element = "Test";
array = array ~ [element]; //l'array è ora [element], dove il valore dell'elemento è "Test" 

Successivamente discuteremo dell’indicizzazione. È possibile ottenere la lunghezza di un array utilizzando length (nameofarray). La prima cosa è però la prima: il primo elemento in un array è indicizzato 0, non 1. Indicizzi un array come segue:

let dnh = ["ExPorygon", "Naut", "Trickysticks", "AJS"]; //Dichiara un array di lunghezza 4 contenente i nomi degli Script Danmakufu 
let lengthdnh = length(dnh); // lunghezza degli array, in questo caso 4
let scripter = dnh[2]; //Trova l'elemento con l'indice 2 - "Trickysticks"
let scripter2 = dnh[2..4]; //Ottieni un array con gli indici da 2 a 3 di dnh - ["Trickysticks", "AJS"] 
let scripter3 = dnh[lengthdnh]; //Viene visualizzato un errore perché il quarto indice non esiste 

Una volta superato il fatto che inizia da 0, non è poi così male. Inoltre, notare i due punti per ottenere un sottoarray dell'array iniziale. Il nuovo array include l'indice prima dei due punti ma non quello dopo. Lo vedremo più avanti con i cicli di risalita e anche la funzione slice () svolge la stessa funzione. Ora, considera il seguente array: 

let array = [3, 6, 9, 12, 9, 9, 12];

Eseguiremo operazioni su questo array sopra!

array = [3, 6, 9, 12, 9, 9, 12];
array[4] = array[4] - 1;

Adesso l'array sarà così:
[3, 6, 9, 12, 8, 9, 12]

Quello che abbiamo fatto è il seguente: abbiamo indicizzato un array, ottenendo un riferimento al valore contenuto in quell'indice e quindi eseguito un'operazione (- 1) su di esso. Ecco come eseguire le operazioni sui contenuti degli array.
Ci sono, ovviamente, altre operazioni (molte decisamente più complicate), ma per ora chiuderemo con la rimozione degli indici. In realtà è molto semplice.

array = [3, 6, 9, 12, 8, 9, 12];
array = erase(array, 5); //Cancella il quinto indice dell'array 'array' 

Dopo aver eseguito la funzione erase () sull'array, ci rimane il seguente array

array = [3, 6, 9, 12, 8, 12];

Come nota finale, poiché le stringhe sono matrici di caratteri, puoi anche indicizzare le stringhe nello stesso modo in cui indicizzi le matrici.

Cosa sono i booleani?

Un booleano è, in poche parole un “vero o falso”. I booleani in Danmakufu funzionano esattamente come nella maggior parte degli altri linguaggi di programmazione fortemente tipizzati.

let bool = true;
let bool2 = false;

Le espressioni booleane sono espressioni che sono vere o false e saranno molto utili quando discuteremo le istruzioni if e if-else.

let test = (5 > 6); //Falso, poiché 5 non è maggiore di 6 
let test2 = (4 == 6); //Falso poiché 4 non è uguale 6 
let test3 = (1 <= 3); //vero perché 1 è minore o uguale a 3. 
let test4 = (6 != 3); //vero perché 6 non è uguale a 3. 

La prima cosa da notare è il doppio segno di uguale ==. Questo è usato per la logica in Danmakufu al posto del segno di uguale =, che viene usato per assegnare valori a variabili e costanti. La prossima cosa da notare è l’uso di “!”, Che funziona come “non” ed è usato in negazione. Nota che caratteri, stringhe e booleani non possono usare cose come <(minore di) o> = (maggiore o uguale a) in Danmakufu. Puoi, tuttavia, testare l’uguaglianza e la disuguaglianza per questi. Ora discuteremo le espressioni booleane che coinvolgono più booleani usando || (OR logico) e && (AND logico)

let bool = true;
let bool2 = false;
let test = (bool || bool2); //test è vero se bool OR bool2 lo è, altrimenti è falso
let test2 = (bool && bool2); //test2 è vero se bool AND bool2 sono uguali, else false
let test3 = (bool || !bool2); //test3 è vero se bool OR non bool2 è vero. cioè se bool2 è falso.

Come visto sopra, || denota OR e && denota AND.
Quando discuteremo delle dichiarazioni if e if-else nella parte successiva, torneremo su questo, poiché è il fondamento del controllo e del flusso dello script in danmakufu.
Le parentesi vengono utilizzate per controllare l’esecuzione in modo simile all’ordine delle operazioni. Per chiudere, tieni presente che il booleano true è equivalente a 1 e il boolean false è equivalente a 0 (ossia 1 + true restituisce 2; true + false restituisce 1). Questo è buono a sapersi per la programmazione per computer in generale, ma non consigliamo di utilizzare 1 e 0 come sostituto di vero e falso in Danmakufu.

Cosa sono le dichiarazioni If e If-Else?

Quindi ora che abbiamo tutta questa conoscenza di booleani ed espressioni booleane, cosa ne faremo? Bene, se vuoi eseguire solo un determinato codice in determinate condizioni, puoi usare booleani ed espressioni booleane nelle istruzioni if, if-else e alternative-case (switch)!

if(count > 30){count = 0;}

Sopra è un esempio di un'istruzione if. Se le istruzioni hanno una condizione vera, verrà eseguito il codice tra parentesi graffe che seguono l'istruzione. Nella situazione precedente, la variabile count sarà impostata a 0 se il suo valore è maggiore di 30. Se il suo valore non è maggiore di 30, il codice tra parentesi graffe non verrà eseguito 

Per riferimento futuro, il codice all’interno di {parentesi graffe} è considerato un blocco. Puoi avere più istruzioni (una singola istruzione) all’interno di un blocco: ricorda di terminare ogni istruzione con un punto e virgola.

Se invece vuoi fare qualcos’altro quando una data condizione è falsa, puoi usare le istruzioni if-else.

if(count > 30) {
    count = 0;
} else {
    count++;
}

Ora, se count non è maggiore di 30, count aumenterà di 1! Puoi anche annidare istruzioni if else e avere più istruzioni else, in questo modo.

if(count > 30) {
    count = 0;
} else if(count < 0) {
    count = 0;
} else {
    count++;
    if(count % 3 == 0) {
        //fa qualcosa
    }
}

Nell’esempio sopra, c’è un altro caso: se count è minore di 0. In questo modo, puoi impostare il codice per fare una varietà di cose. Nell’ultima parte, nel caso in cui count sia maggiore o uguale a 0 AND minore o uguale a 30, c’è un’altra istruzione if che consente al codice di fare ancora un’altra cosa.

Tuttavia, se hai molti casi diversi che utilizzano la stessa variabile, un muro di istruzioni if else diventa goffo e pesante da leggere(non facciamo l’errore di Yanderedev) di conseguenza, ci sono istruzioni switch, nota come istruzioni case alternative in Danmakufu. Sono fondamentalmente una scorciatoia per affermazioni if-else in cui la condizione implica l’uguaglianza con una cosa specifica.
Ma aspetta! Non li abbiamo visti prima in @Event? Perchè si. Questo è uno dei posti in cui li utilizzerai.

   alternative(x)
    case(-3){
        //Fa robe
    }
    case(2){
        //Fa altre robe
    }
    case(10){
        //Fa qualche roba
    }
    others{
        //Fa varie robe
    }

Il modo in cui funziona un’istruzione case alternative è il seguente: La variabile all’interno di alternative () è la variabile che viene testata. Il primo caso chiede se x == -3. Se vero, eseguirà le cose all’interno delle parentesi graffe per maiuscole e minuscole (-3) e ignorerà tutto il resto. Se x non è -3, passerà al caso successivo e così via. Infine, se ha esaurito le sue opzioni, farà tutto ciò che è in altri {} o, se altri {} non sono presenti, semplicemente uscirà dall’istruzione e non farà nulla.

L’istruzione if-else equivalente alla precedente è la seguente:

 if (x == -3) {
	//Fa cose
    } else if (x == 2) {
	//Fa altre robe
    } else if (x == 10) {
	//Fa qualche roba
    } else {
	//Fa varie robe
    }

Cosa sono i loop e come si usano?

Se vuoi fare ripetutamente la stessa cosa più e più volte (e forse con effetti leggermente diversi), i loop sono la soluzione! Ci sono alcuni tipi di loop in Danmakufu.

Il primo tipo di ciclo è il ciclo generico. È una struttura che accetta un parametro intero n e eseguirà il codice nel blocco seguente n volte. Il parametro deve essere un numero intero perché non ha senso ripetere qualcosa per 3,5 volte. Per esempio:

let x = 5;
loop(20){
    x++;
}

Nel codice sopra, dichiariamo prima la variabile x, alla quale viene poi assegnato il valore numerico 5. Dopodiché, x ++ viene chiamato in un ciclo (20). Quello che fa il ciclo è ripetere il codice contenuto all'interno di {} il numero di volte indicato tra parentesi. Pertanto, x sarà uguale a 25 dopo che questo codice è stato eseguito. Se avessi una variabile intera y, potresti anche ripetere (y), che ripeterebbe il codice tra parentesi graffe y volte. 

Ora è un buon momento per parlare di loop infiniti, ossia come congelare Danmakufu. Un ciclo infinito si verifica quando una sezione di codice continua a ripetersi all’infinito e l’unico modo per fermarlo è terminare del tutto il programma. Più avanti in questa lezione, discuteremo il rendimento; (il modo migliore per rendere un ciclo infinito non effettivamente infinito ma ottenere funzioni simili fino al termine dello script), ma come breve nota, il ciclo immediatamente seguito da una parentesi graffa di apertura {(ad esempio loop {blah;}) attiverà un ciclo infinito. L’uso di cicli infiniti dovrebbe essere evitato finché non si ha una conoscenza sufficiente della resa;

I prossimi sono i cicli while. Fondamentalmente, mentre una certa condizione è vera (booleana), Il codice tra parentesi graffe dopo verrà eseguito, proprio come un’istruzione if tranne che viene ripetuto automaticamente.

let x = 5;
while(x < 20){
x++;
}

Nel codice sopra, dichiariamo x e quindi eseguiamo un ciclo while dove, mentre x è minore di 20, x è incrementato di 1. Il codice in questione eseguirà un ciclo da solo e x sarà 20 dopo che il codice è stato eseguito. Più specificamente, x continuerà ad aumentare di uno fino a quando non è 20, a quel punto il ciclo terminerà.

let x = 5;
while(x > 20){
    x++;
}

Nello scenario precedente, x è minore di 20, quindi la condizione per il ciclo while non viene mai soddisfatta. Pertanto, il ciclo while non viene mai eseguito e x viene lasciato come 5 in seguito. 

let x = 5;
while(x > 0){
    x++;
}
Successivamente, considereremo il codice precedente, dove x è dichiarato essere 5 e mentre x> 0, x aumenta di 1. Come è facilmente osservabile, x non diventerà mai effettivamente minore o uguale a 0. Pertanto, questo codice causerà un ciclo infinito e Danmakufu si bloccherà. 

let x = 5;
let y = 0;
while(x > 0){
    while (y < 5) {
        x -= 1;
    }
    y += 1;
}

Infine, discuteremo i cicli while annidati sopra. Qui definiamo le variabili x e y, e mentre x è maggiore di 0 (il che è), esegue un nuovo ciclo while. Questo ciclo while viene eseguito finché y è inferiore a 5, il che è. Come prima, avremo un ciclo infinito, poiché x continuerà a diminuire ma poiché y non è mutato all'interno del ciclo while interno, la condizione y <5 sarà sempre vera e il ciclo non terminerà mai. Notare che y + = 1; la riga non viene mai eseguita: questo è un esempio di blocco, dove poiché abbiamo un ciclo while prima dell'istruzione, il ciclo deve terminare prima che l'istruzione possa essere eseguita.

Ora discuteremo dell'ultimo tipo di loop in Danmakufu: il ciclo for. A Danmakufu, il ciclo for è disponibile in due varietà, salita e discesa. Nota: per i programmatori provenienti da altri linguaggi: non esiste un ciclo for generico o for-each. È necessario utilizzare un ciclo while o salita / discesa. 

Un generico loop di risalita è strutturato come segue:

let x = 5;
ascent(i in 0..8){
    x++;
}
Quello che fa questo codice è in realtà un po 'difficile da capire. Puoi pensarlo in questo modo: viene dichiarata una variabile locale chiamata i, con una variabile 0. Dopodiché, viene eseguito il blocco di codice all'interno delle parentesi graffe {}. Dopodiché, i viene incrementato di 1 fintanto che è inferiore a 8. Se è inferiore a 8 dopo essere stato incrementato, il codice si ripete. Una volta che la variabile i è uguale a 8, il ciclo termina. Ciò significa che non sarò mai effettivamente uguale a 8 in una corsa attraverso il ciclo. 

let x = 5;
ascent(i in 0..8){
    x = i;
}

Se fai quanto sopra, x inizierà da 0, ma sarà impostato al valore di i, che è 0. Mentre il ciclo continua, x sarà impostato a 1, 2, 3 e, infine, 7. Dopo di esso è impostato su 7, la variabile locale i è impostata su 8 e il ciclo termina, lasciando x come 7. In totale, il codice viene ripetuto 8 volte e i ha valori da 0 a 7. 

Per riferimento, Drake ha scritto una volta il seguente codice equivalente per un ciclo di risalita: 

ascent(var in 0..10){
    bla(var);
}

//Above is equivalent to below

local{
    let var = 0;
    while(var < 10){
        bla(var);
        var++;
    }
}

Si noti che per convenzione, i valori utilizzati in ascent / descent / for loop sono i seguenti: i, j, k, l, ecc. Per quanto riguarda i loop di discesa, la variabile locale diminuisce invece di aumentare. Avrai bisogno di loop di discesa per alcune cose, ma utilizzerai i loop di risalita per la maggior parte del tempo. Se non capisci i loop di risalita, va benissimo: sono più difficili da capire di alcune delle altre cose in Danmakufu e non ti serviranno fino a quando non proverai a fare fade-in grafici o schemi di proiettili più complessi. 

Infine, su una nota importante, ricorda la pausa; - questo ti farà uscire dal ciclo più interno. Questo ha una varietà di usi, che saranno utili in seguito. Tuttavia, usando break; al di fuori di un ciclo potrebbe bloccarsi Danmakufu. Si prega di essere avvisati. 

Cosa sono le funzioni?

Abbiamo già fatto riferimento a funzioni in precedenza, ma ora è il momento di approfondire cos’è una funzione e come usarle.

In primo luogo, una funzione è in grado di accettare e restituire parametri, noti anche come argomenti o input. Ad esempio, puoi avere una funzione f (x) = x + 5 che prende un valore x e restituisce quel valore incrementato di 5. In Danmakufu, assomiglia a questo:

function math(var){  //anche l'uso di 'let var' è accettabile, ma nessuno lo fa davvero. 
    return var + 5;
}

In questo codice, il nome della funzione è math, il parametro tra parentesi è var e il valore restituito è var + 5. Per quanto riguarda come usarlo, ecco uno snippet di codice.

function math(var){
    return var + 5;
}

let y = math(6); //y sarà uguale a 11 

Semplice, vero? Una funzione prende i suoi parametri nella forma (a, b, c, ...) e restituisce qualunque cosa sia nell'istruzione return. Una funzione non deve restituire nulla e non richiede parametri. Nota che puoi restituire solo una cosa - in alternativa, puoi restituire un array di cose diverse purché siano dello stesso tipo. Tuttavia, questo diventa goffo e può creare confusione, quindi è meglio che una funzione restituisca un singolo valore. Le funzioni sono molto utili per cose veloci come riportare l'angolo dal giocatore al boss, ottenere la direzione di movimento del giocatore, ecc. Tutte le funzioni integrate vengono eseguite immediatamente quando chiamate e terminano l'esecuzione prima che venga eseguita la riga di codice successiva. Puoi anche usare la resa; in una funzione e dove la funzione è stata chiamata, nient'altro verrà eseguito fino a quando la funzione non avrà completato la sua esecuzione (le cose non nello script, come bgm, sfondo e sistema funzioneranno ancora), ma ci occuperemo più tardi quando parliamo di resa ;. Si noti che quando si fa riferimento a una funzione, le persone di solito si riferiscono alla funzione come nomefunzione (). Le parentesi indicano i parametri, che è la caratteristica principale delle funzioni.

Cosa sono le attività?

Ora che abbiamo le funzioni fuori mano, è il momento di spiegare le attività, note anche come coroutine. È possibile inviare parametri anche a un’attività e la differenza principale tra attività e funzioni è che le attività vengono eseguite insieme agli altri script. Ad esempio, potresti creare un’attività che crea un proiettile e quindi gli fa fare qualcosa ogni fotogramma per 60 fotogrammi prima di scomparire solo per riapparire altrove sullo schermo e dividere in altri proiettili. Le attività danno flessibilità a Danmakufu e sono eccellenti nell’organizzazione del codice. Nota che per convenzione, non metti parentesi dopo un’attività a meno che non ci siano parametri, a differenza del caso con le funzioni.

Anche le attività sono sorprendenti nel flusso di script. Ad esempio, se desideri che un effetto sonoro riproduca trenta fotogrammi dopo la generazione di un punto elenco, puoi semplicemente chiamare un’attività che attende 30 fotogrammi e quindi riproduce un effetto sonoro. Molto utile per sincronizzare le cose in una sceneggiatura.

Quando discuto di vari stili di scripting, discuterò dello stile di tasking, che è molto popolare grazie ai tutorial video di Helepolis. Si noti, tuttavia, che in ph3, a differenza di 0.12m, lo stile standard @MainLoop richiede comunque di esternalizzare i comandi alle attività perché è necessario controllare manualmente quando i proiettili vengono generati e utilizzare return; in una routine come @MainLoop ha il potenziale per mandare in crash Danmakufu. Detto questo, utilizzando return; in una coroutine / task interromperà l’esecuzione del resto del task e ignorerà tutto dopo il ritorno; dichiarazione, terminando completamente l’attività. Le attività non possono restituire un valore.

Tuttavia, ora che abbiamo così tante cose sulle attività e sul controllo degli script, dovremmo probabilmente andare oltre yield;

Come si usa il yield ;?

La funzione della resa; è mettere in pausa l’esecuzione di una routine, una subroutine, una funzione o un’attività di un frame.

Questo è letteralmente il modo più semplice per spiegare cosa produce; fa.

Si prega di notare, tuttavia, quanto segue:

1. yield; ing in @Initialize non dovrebbe mai essere fatto e chiamare una funzione o una subroutine in @Initialize che usa yield ;, per estensione, è una cattiva idea. Potrebbe non fare nulla o Danmakufu potrebbe bloccarsi. Per favore non provare questo.
2. DEVI cedere; una volta in @MainLoop in modo che le attività vengano eseguite. Solo una volta. Non fare di più, non fare di meno. Avere sempre una resa; alla fine di @MainLoop indipendentemente dal fatto che tu abbia o meno il compito.
3. Se hai un ciclo infinito, DEVI avere una resa; al suo interno o Danmakufu si congelerà. Se Danmakufu si blocca, è il 99,9999% delle volte un problema in cui ti sei dimenticato di cedere; in un ciclo {} o while (true) {}.

Ora che le basi sono state tolte, è il momento di creare la nostra prima funzione.

function wait(n){loop(n){yield;}}

Questa funzione è un must per la libreria di funzioni di tutti. Produce n frame. attendere (60); è l’equivalente di loop (60) {yield;}, ma uno è più lungo dell’altro, quindi le persone usano solo wait ().

Con il progredire di questo tutorial, imparerai altri modi per utilizzare la resa; così come altre tecniche in cui cedere; è una componente chiave. Ma ora … il punto e virgola.

Cosa dovrei sapere sulla sintassi di Danmakufu?

Ora avremo una breve discussione sulla sintassi di Danmakufu. Come tutti sapete, Danmakufu è un linguaggio di scripting e, come i linguaggi di programmazione, ha sia convenzioni che regole. Come altri linguaggi di programmazione, tutti i nomi di funzioni, attività, variabili e routine fanno distinzione tra maiuscole e minuscole. In altre parole, @mainloop non verrà riconosciuto perché Danmakufu riconosce solo @MainLoop. Chiamare una funzione Wait (n) quando hai una funzione wait (n) farà apparire un errore di funzione non definito.

Inoltre, per favore, per favore, PER FAVORE ricordati di chiudere tutti i tuoi (, [e {. Prima di eseguire uno script (o dopo aver ricevuto un errore), usa un test ctrl-F per assicurarti che il numero di {sia uguale al numero di}. In caso contrario, si verificherà un errore. Garantito.

Si prega inoltre di utilizzare la tabulazione. Non posso sottolineare abbastanza. In questo tutorial, utilizzo 2, 4 o 8 spazi per le tabulazioni. Tuttavia, la spaziatura non è ciò che conta: avere uno spazio bianco in primo luogo è ciò che è importante. Avere un codice illeggibile significa che gli altri saranno meno propensi ad aiutarti.

E infine … la rovina di tutta l’esistenza. IL SEMICOLON.

Danmakufu richiede un punto e virgola alla fine di ogni istruzione (ci sono alcune eccezioni), e se dimentichi di metterne uno dopo un’istruzione, l’errore farà riferimento alla riga successiva e non alla riga con l’errore. Se chiami una funzione o un’attività, ricordati di inserire un; dopo la parentesi di chiusura. Se dichiari una variabile, metti un; dopo aver dichiarato la variabile. Questo è il modo in cui Danmakufu (e altre lingue) determinano quando hai terminato un’affermazione e senza di essa Danmakufu sarà confuso. Le due grandi eccezioni alla regola del punto e virgola sono le intestazioni e le istruzioni include (tratteremo le istruzioni include molto più avanti). L’altro è che non è necessario un punto e virgola in un blocco contenente solo un’istruzione se l’istruzione è seguita immediatamente da una parentesi graffa di chiusura}. Tuttavia, metti sempre il punto e virgola: non mi interessa come mkm vuole che tu codifichi; Questa è una procedura migliore e più rilevante per l’informatica nel suo complesso.

È tutto per ora. I quiz di seguito dovrebbero essere sufficienti per esaminare le informazioni.

Quali sono le parole chiave riservate?

Concluderò questa lezione con alcune note sulle parole chiave riservate. Nota che ho ottenuto queste informazioni dai tutorial su Fragmented Skies, quindi potrebbero essercene alcune mancanti o alcune che in realtà non sono parole chiave riservate.

In un linguaggio di programmazione, una parola chiave riservata è un nome che non può essere utilizzato per le tue variabili, funzioni, ecc. Ad esempio, non puoi avere un’attività chiamata ‘funzione’, perché ‘funzione’ è una parola chiave riservata in quanto ha una utilizzo specifico preprogrammato nella lingua.

Di seguito sono riportati esempi di parole chiave riservate:

alternativa ascent break case descent else funzione se in let local loop altri restituiscono i tempi del sub task mentre cedono

Ci sono anche nomi di funzioni incorporati in Danmakufu che sono riservati e non possono essere sovrascritti (se provi a sovrascriverli con una funzione, otterrai un errore in cui una funzione con lo stesso nome è già definita. Se assegni a una variabile una delle seguenti questi, probabilmente si bloccherà invece di generare errori, ma potrebbe anche causare strani messaggi di errore, comportamenti indefiniti o altre cose indesiderate.

aggiungi aggiungi confronta concatena dividi falso lunghezza indice moltiplica negativo non pi potenza predecessore resto risultato fetta successore sottrazione vero

In questa nota, per favore usa l’operatore matematico se è disponibile. aggiungere (3, 5) è assolutamente inutile quando 3 + 5 è significativamente più facile e meno faticoso da scrivere.

Esempi

let x = 5; // dichiaro che X ha valore 5
let y = 10; //dichiaro che Y ha valore 10
while(x < y){ // Se X è minore di Y
    y--; // decrementa il valore di Y fino a diventare 5 dato che deve fermarsi al valore di X
}
let z = x + y; // il valore di Z è di 10 

Author: mycus