Come programmare giochi per computer (con immagini)

2024 Autore: Robert Blare | [email protected]. Ultima modifica: 2024-01-31 12:17

Hai un'idea per un gioco per computer e vuoi realizzarla? O ti sei mai chiesto come vengono scritti i giochi per computer? Questo articolo spiega come scrivere tre giochi per computer di base in Python. Avrai bisogno di una conoscenza di base di Python e dei concetti generali di programmazione per sviluppare il tuo primo gioco.

Passi

Parte 1 di 3: creare un gioco basato sul testo

Passaggio 1. Scegli un linguaggio di programmazione

Tutti i linguaggi di programmazione sono diversi, quindi dovrai decidere quale usare per scrivere il tuo gioco. Tutti i principali linguaggi di programmazione supportano l'input di testo, l'output di testo e le costruzioni if (le cose principali di cui hai bisogno per un semplice gioco basato sul testo), quindi esplora le opzioni e decidi con quale ti senti più a tuo agio e dedicato all'apprendimento. Ecco alcuni fattori da considerare:

Qual è la lingua maggiormente utilizzata?

Alcuni linguaggi di programmazione, come JavaScript, sono progettati per essere utilizzati per il Web, mentre altri, come Python, C o C++, sono progettati per eseguire programmi per computer. Per il tuo gioco, punta a un linguaggio con una gamma di utilizzo più ampia, come Python, C, C++ o JavaScript.
Quanto è difficile imparare?

Sebbene scrivere un programma dovrebbe essere abbastanza facile dopo un po' di pratica in qualsiasi normale linguaggio di programmazione (cioè, non uno specificamente progettato per creare confusione come Malbolge), alcuni sono più amichevoli con i principianti di altri. Java e C, ad esempio, richiederanno di comprendere concetti di programmazione più profondi rispetto a qualcosa come Python, noto per la sua sintassi più accessibile e diretta.
Dove posso usarlo?

Probabilmente vorrai che le persone su sistemi diversi, come Linux, Mac o Windows, siano tutti in grado di giocare al tuo gioco. Quindi non dovresti usare un linguaggio che è supportato solo su alcuni sistemi, come Visual Basic, che è supportato solo su Windows.

Questo articolo utilizzerà Python per gli esempi di un gioco basato su testo, ma puoi cercare come vengono eseguiti i concetti in qualsiasi altro linguaggio di programmazione.

Passaggio 2. Prepara il tuo computer

I due componenti principali di cui avrai bisogno sono un editor di testo, in cui scriverai il tuo codice, e un compilatore, che utilizzerai per trasformarlo in un gioco. Se vuoi seguire l'esempio in questo articolo, dovresti installare Python e imparare come eseguire i programmi. Se lo desideri, puoi configurare un IDE (Integraded Desktop Environment), che combina modifica, compilazione e debug in un unico programma. L'IDE di Python si chiama IDLE. Ma puoi anche utilizzare qualsiasi editor di testo che supporti il testo normale, come Blocco note per Windows, TextEdit per macOS o Vim per Linux.

Passaggio 3. Scrivi un codice per salutare il giocatore

Il giocatore vorrà sapere cosa sta succedendo e cosa deve fare, quindi dovresti stampare del testo per loro.

Questo viene fatto con la funzione print() in Python. Per provarlo, apri un nuovo file con estensione.py, inserisci il seguente codice, salvalo ed eseguilo:
```
print("Benvenuto nel gioco di indovinare i numeri!") print("Inserisci un numero intero compreso tra 1 e 1000:")
```

Passaggio 4. Genera un numero casuale

Creiamo un gioco basato sul testo che chieda al giocatore di indovinare il numero corretto. La prima cosa che dovremo fare è generare un numero casuale all'inizio del gioco in modo che il giocatore non indovini sempre lo stesso numero. Poiché il numero rimarrà lo stesso per tutto il programma, ti consigliamo di memorizzare il numero casuale in una variabile.

Python non ha una funzione di numero casuale incorporata, ma ha una libreria standard (questo significa che l'utente non dovrà installare nulla in più) che lo fa. Quindi vai all'inizio del tuo codice (prima delle funzioni print()) e digita la riga import random.
Usa la funzione casuale. Si chiama randint(), si trova nella libreria casuale che hai appena importato e prende come argomento il valore minimo e massimo che il numero può avere. Quindi torna alla fine del tuo codice e inserisci la seguente riga:
```
rightNum = random.randint(0, 1000)
```

Passaggio 5. Ottieni input dal lettore

In un gioco, il giocatore vuole fare qualcosa o interagire con qualcosa. In un gioco basato sul testo, ciò è possibile inserendo del testo. Ora che abbiamo un numero casuale, le nostre prossime righe di codice dovrebbero chiedere al giocatore di inserire la sua ipotesi migliore.

Poiché il codice che hai inserito stampa l'istruzione per inserire un numero per il giocatore, dovrebbe anche leggere il numero che inseriscono. Questo viene fatto con input() in Python 3 e raw_input() in Python 2. Dovresti scrivere in Python 3, poiché Python 2 diventerà presto obsoleto. Aggiungi la seguente riga al tuo codice per memorizzare l'input del giocatore in una variabile chiamata numero:
```
numeroutente = input()
```

Passaggio 6. Trasforma l'input del lettore in un tipo di dati utilizzabile

Il giocatore ha inserito un numero, e adesso?

Fai in modo che l'input del giocatore sia un numero. Ora, questo potrebbe sembrare confuso perché hanno appena inserito un numero. Ma c'è una buona ragione: Python presuppone che tutto l'input sia testo, o una "stringa", come viene chiamata in programmazione. Questo testo contiene il numero che vuoi ottenere. Python ha una funzione che converte una stringa che contiene solo un numero nel numero all'interno. Tipo:
```
numeroutente = int(numeroutente)
```

Passaggio 7. Confronta il numero del giocatore con il numero corretto

Una volta che il giocatore ha inserito il proprio numero, dovrai confrontarlo con quello che è stato generato casualmente. Se i numeri non sono gli stessi, il tuo gioco può far provare al giocatore un altro numero. Se i numeri corrispondono, puoi dire al giocatore che ha indovinato correttamente e uscire dal programma. Questo viene fatto con il seguente codice:

while userNum != rightNum: userNum = int(input())

Passaggio 8. Dai un feedback al giocatore

Mentre hai già elaborato il loro input, il giocatore non lo vedrà. Dovrai effettivamente stampare i risultati al giocatore in modo che capisca cosa sta succedendo.

Sicuramente, potresti semplicemente dire al giocatore se il suo numero è giusto o sbagliato. Ma con questo approccio, il giocatore potrebbe dover indovinare 1000 volte nel peggiore dei casi, il che sarebbe molto noioso.
Quindi dì al giocatore se il suo numero è troppo piccolo o troppo grande. Ciò ridurrà significativamente il loro numero di ipotesi. Se, ad esempio, il giocatore indovina per primo 500 e il gioco risponde "Troppo grande. Riprova", ci saranno solo 500 numeri possibili invece di 1000. Questo viene fatto con le costruzioni if, quindi sostituisci la stampa ("Sbagliato. Riprova.") con uno.
Tieni presente che il controllo della corrispondenza tra due numeri viene eseguito con ==, non con =. = assegna il valore a destra di esso alla variabile a sinistra di esso!

if userNum < rightNum: print("Troppo piccolo. Riprova:") if userNum > rightNum: print("Troppo grande. Riprova:")

Passaggio 9. Testa il tuo codice

Come programmatore, dovresti essere sicuro che il tuo codice funzioni prima di considerarlo finito.

Quando si programma in Python, assicurarsi di ottenere i rientri corretti. Il tuo codice dovrebbe assomigliare a questo:

import random print("Benvenuto nel gioco di indovinare i numeri!") print("Inserisci un numero intero compreso tra 1 e 1000:") rightNum = random.randint(0, 1000) userNum = input() userNum = int(userNum) while userNum != rightNum: if userNum < rightNum: print("Troppo piccolo. Riprova:") if userNum > rightNum: print("Troppo grande. Riprova:") userNum = int(input()) print("Hai indovinato correttamente.")

Passaggio 10. Convalidare l'input

Il giocatore non dovrebbe essere in grado di interrompere il tuo gioco semplicemente inserendo la cosa sbagliata. "Convalidare l'input" significa assicurarsi che il giocatore abbia inserito la cosa corretta prima di elaborarla.

Apri di nuovo il gioco e prova a inserire qualcosa che non sia un numero. Il gioco uscirà con un ValueError. Per evitare ciò, puoi implementare un modo per verificare se l'input era un numero.
Definire una funzione. Poiché convalidare l'input è piuttosto lungo e devi farlo più volte, dovresti definire una funzione. Non accetta argomenti e restituisce un numero. Per prima cosa, scrivi def numInput(): all'inizio del tuo codice, direttamente sotto import random.
Ottieni l'input del giocatore una volta. Usa la funzione input() e assegna il risultato alla variabile inp.
Quando l'input del giocatore non è un numero, chiedigli di inserire un numero. Per verificare se una stringa è un numero, usa le funzioni isdigit(), che consente solo un numero intero, quindi non dovrai verificarlo separatamente.
Se l'input è un numero, convertilo da stringa a numero e restituisci il risultato. Usa la funzione int() per convertire la stringa in un intero. Ciò renderà non necessaria la conversione nel codice principale e dovresti rimuoverlo da lì.
Sostituisci tutte le chiamate a input() nel codice principale con chiamate a numInput().
Il codice della funzione numInput() sarà simile a questo:

def numInput(): inp = input() while not inp.isdigit(): print("Ti è stato detto di inserire un numero intero! Inserisci un numero intero:") inp = input() return int(inp)

Passaggio 11. Prova di nuovo il gioco

Inserisci le cose sbagliate di proposito per vedere cosa succede, quindi correggi eventuali errori man mano che si presentano.

Prova a inserire del testo quando il programma ti chiede un numero. Ora, invece di uscire con un messaggio di errore, il programma ti chiederà di nuovo un numero

Passaggio 12. Suggerisci di riavviare il gioco al termine

In questo modo, il giocatore potrebbe giocare più a lungo senza doverlo riavviare costantemente.

Metti tutto il codice tranne l'importazione e la definizione della funzione in un ciclo while. Imposta True come condizione: questo sarà sempre vero, quindi il ciclo continuerà per sempre.
Chiedi al giocatore se vuole giocare di nuovo dopo aver indovinato il numero correttamente. Usa la funzione print().
Se rispondono "No", esci dallo sguardo. Se rispondono a qualcos'altro, continua. L'interruzione di un ciclo viene eseguita con l'istruzione break.
Sposta il "Benvenuto nel gioco di indovinare i numeri" al di fuori del ciclo while. Il giocatore probabilmente non vuole essere accolto ogni volta che gioca. Sposta l'istruzione print("Benvenuto nel gioco di indovinare i numeri!" sopra il while True:, in modo che venga stampata solo una volta, quando l'utente avvia il primo gioco.

Passaggio 13. Prova il gioco

Dovrai testare il tuo gioco ogni volta che implementi una nuova funzionalità.

Assicurati di rispondere almeno una volta sia "Sì" che "No" per assicurarti che entrambe le opzioni funzionino. Ecco come dovrebbe essere il tuo codice:

import random def numInput(): inp = input() while not inp.isdigit(): print("Ti è stato detto di inserire un numero intero! Inserisci un numero intero:") inp = input() return int(inp) print ("Benvenuto nel gioco di indovinare i numeri!") while True: print("Inserisci un numero intero compreso tra 1 e 1000:") rightNum = random.randint(0, 1000) userNum = numInput() while userNum != rightNum: if userNum < rightNum: print("Troppo piccolo. Riprova:") if userNum > rightNum: print("Troppo grande. Riprova:") userNum = numInput() print("Hai indovinato.") print("Hai vuoi giocare di nuovo? Inserisci No per uscire.") if input() == "No": break

Passaggio 14. Scrivi altri giochi di testo

Che ne dici di scrivere un'avventura testuale dopo? O un gioco a quiz? Essere creativo.

ConsiglioNota: a volte è utile consultare la documentazione se non si è sicuri di come viene eseguita una operazione o di come viene utilizzata una funzione. La documentazione di Python 3 si trova su https://docs.python.org/3/. A volte anche la ricerca di qualsiasi cosa tu voglia fare su Internet restituisce buoni risultati.

Parte 2 di 3: creare un gioco con grafica 2D

Passaggio 1. Scegli una libreria grafica

Fare la grafica è molto complicato e la maggior parte dei linguaggi di programmazione (inclusi Python, C++, C, JavaScript) fornisce solo un supporto minimo o addirittura nessun supporto per la grafica nel core o nelle librerie standard. Quindi dovrai usare una libreria esterna per essere in grado di creare grafica, ad esempio Pygame per Python.

Anche con una libreria grafica, dovrai preoccuparti di cose come come visualizzare un menu, come controllare cosa ha cliccato il giocatore, come visualizzare le tessere e così via. Se preferisci concentrarti sullo sviluppo del gioco vero e proprio, puoi utilizzare una libreria del motore di gioco come Unity, che implementa facilmente queste cose

Questo articolo utilizzerà Python con Cocos2D per mostrare come creare un semplice platform 2D. Alcuni dei concetti menzionati potrebbero non esistere in altri motori di gioco. Fare riferimento alla loro documentazione per ulteriori informazioni.

Passaggio 2. Installa la libreria grafica che hai scelto

Cocos2D per Python è facile da installare. Puoi ottenerlo da https://python.cocos2d.org/index.html o eseguendo sudo pip3 install cocos2d se stai usando Linux.

Passaggio 3. Crea una nuova directory per il tuo gioco e i tuoi contenuti multimediali

Utilizzerai cose come immagini e suoni nel tuo gioco. Tieni queste cose nella stessa directory del programma. Questa directory non dovrebbe contenere nient'altro in modo che tu possa vedere facilmente quali risorse hai nel gioco.

Passaggio 4. Creare un nuovo file di codice nella nuova directory

Chiamalo main, con l'estensione del file per il tuo linguaggio di programmazione. Se scrivi un programma grande e complesso in cui ha senso avere più file di programma, questo ti mostrerà qual è il file principale.

In questo esempio, creeremo un file chiamato main.py che conterrà tutto il nostro codice

Passaggio 5. Crea la finestra del gioco

Questo è il prerequisito di base per un gioco con grafica.

Importa i sottomoduli cocos2d necessari: cocos.director, cocos.scene e cocos.layer. Questo viene fatto con from subModuleName import *, dove sub-Module name è il sottomodulo che vuoi importare. La differenza tra from … import * e import … è che non devi mettere il nome del modulo davanti a tutto ciò che usi da quel modulo con il primo.
Definire una sottoclasse MainMenuBgr di ColorLayer. Ciò significa sostanzialmente che qualsiasi sfondo del menu principale che crei si comporterà come un livello di colore con alcune modifiche apportate.
Avvia il direttore del Cocos. Questo ti darà una nuova finestra. Se non imposti una didascalia, la finestra avrà la stessa didascalia del nome del file (main.py), che non avrà un aspetto professionale. Consenti il ridimensionamento della finestra impostando ridimensionabile su True.
Definire una funzione showMainMenu. Dovresti inserire il codice per mostrare il menu principale in una funzione perché questo ti permetterà di tornare facilmente al menu principale chiamando di nuovo la funzione.
Crea una scena. La scena è composta per ora da un livello, che è un oggetto della classe MainMenuBgr che hai definito.
Esegui questa scena nella finestra.

from cocos.director import * from cocos.scene import * from cocos.layer import * class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenu, self)._init_(0, 200, 255, 255) def showMainMenu(): menuSc = Scene(MainMenuBgr()) director.run(menuSc) director.init(caption="IcyPlat - un semplice platform", ridimensionabile=True) showMainMenu()

Passaggio 6. Aggiungi un menu principale alla finestra

Oltre al gioco vero e proprio, dovrai aggiungere un menu che il giocatore può usare per chiudere la finestra, tra gli altri elementi che puoi aggiungere in seguito.

Importa cocos.menu (di nuovo con l'istruzione from) e pyglet.app (questa volta con import).
Definisci MainMenu come una sottoclasse di Menu.
Imposta l'allineamento del menu principale. Devi impostare l'allineamento verticale e orizzontale separatamente.
Crea un elenco di voci di menu e aggiungile al menu. Dovresti avere almeno le voci di menu "Avvia gioco" e "Esci". Ogni voce di menu deve essere inserita tra parentesi. Ogni elemento deve avere un'etichetta e una funzione di callback che determina cosa succede quando il giocatore fa clic su di esso. Per la voce "Inizia partita", usa la funzione startGame (lo scriverai presto), per la voce "Esci", usa "pyglet.app.exit" (già esistente). Crea il menu vero e proprio chiamando self.create_menu(menuItems).
Definisci startGame(). Per ora metti solo pass nella definizione, lo sostituirai quando scriverai il gioco vero e proprio.
Vai al punto del codice in cui hai creato la scena menuSc e aggiungi un oggetto MainMenu ad essa.

L'intero codice dovrebbe ora apparire come segue:

from cocos.director import * from cocos.menu import * from cocos.scene import * from cocos.layer import * import pyglet.app class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenuBgr, self)._init_(0, 200, 255, 255) class MainMenu(Menu): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Start Game ", startGame)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) def startGame(): pass def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add(MainMenu()) director.run(menuSc) director.init(caption="IcyPlat - un semplice platform", ridimensionabile=True) showMainMenu()

Passaggio 7. Testa il tuo codice

Testa il codice in anticipo, mentre è ancora breve e relativamente semplice. Quindi puoi identificare e correggere eventuali errori nella struttura di base prima che le cose diventino troppo complicate.

Il codice delle istruzioni dovrebbe aprire una finestra intitolata "IcyPlat - un semplice platform". Lo sfondo è azzurro ed è possibile ridimensionare la finestra. Quando fai clic su "Avvia gioco" nel menu, non dovrebbe accadere (ancora) nulla. Quando fai clic su "Esci", la finestra si chiuderà

Passaggio 8. Crea uno sprite

Uno sprite è un "oggetto di gioco" o un'immagine bidimensionale. Gli sprite possono essere oggetti di gioco, icone, decorazioni di sfondo, personaggi e qualsiasi altra cosa tu possa rappresentare con un'immagine nel gioco. Inizieremo creando uno sprite per un personaggio con cui il giocatore può interagire.

Importa il sottomodulo cocos.sprite con l'espressione from-import.
Trova un'immagine per rappresentare lo sprite. Non puoi visualizzare uno sprite se non hai un'immagine per esso. Puoi disegnarne uno o ottenerne uno da Internet (fai attenzione alle licenze, però, se hai intenzione di pubblicare il tuo gioco). Per questo esempio, vai su https://opengameart.org/content/tux-classic-hero-style e salva l'immagine-p.webp" />
Crea un livello come nuovo oggetto della classe ScrollableLayer. Quindi, crea lo sprite come oggetto Sprite e imposta la sua posizione su (8, 250). Per riferimento, il punto (0, 0) è nell'angolo in basso a sinistra. Questo è abbastanza alto, ma farà in modo che il pinguino non rimanga bloccato nel ghiaccio.
Aggiungi lo sprite al livello dello sprite.
Crea una nuova scena dal livello dello sprite ed eseguila.

def startGame(): figLayer = ScrollableLayer() fig = Sprite('pingu.png') fig.position = (75, 100) figLayer.add(fig) # gameSc = Scene(figLayer) director.run(gameSc)

Esegui il codice. Dovresti vedere una piccola figura di pinguino (o qualunque cosa tu abbia disegnato) su uno sfondo nero dopo aver fatto clic Inizia il gioco.

Passaggio 9. Sogna il tuo paesaggio

Nella maggior parte dei giochi, i tuoi sprite non dovrebbero semplicemente fluttuare nel vuoto. Dovrebbero effettivamente stare su una superficie, con qualcosa intorno a loro. Nei giochi 2D, questo viene spesso fatto con un set di tessere e una mappa di tessere. Il set di tessere dice fondamentalmente che tipo di quadrati di superficie e di sfondo esistono e che aspetto hanno.

Crea un set di tessere. Il set di tessere per questo gioco sarà molto semplice: una tessera per il ghiaccio e una per il cielo. La tessera di ghiaccio usata in questo esempio proviene da qui, sotto CC-BY-SA 3.0.
Crea un'immagine del set di tessere. Questa è un'immagine di tutte le tessere, che devono essere tutte della stessa dimensione (modificale se non lo sono) e avere le dimensioni che vuoi vedere nel gioco, una accanto all'altra. Salva la tua foto come icyTiles.png.
Crea la descrizione del set di tessere. Questo è un file XML. Il file XML contiene informazioni sulla dimensione dei riquadri nell'immagine del set di riquadri, sull'immagine da utilizzare e su dove trovare il riquadro. Crea un file XML chiamato icyTiles.xml con il codice seguente:
```
     
```

Passaggio 10. Crea una mappa delle tessere per il tuo paesaggio

Una mappa delle tessere è una mappa che definisce quale tessera si trova in quale posizione nel tuo livello. Nell'esempio, dovresti definire una funzione per generare mappe di tessere perché la progettazione di mappe di tessere a mano è molto noiosa. Un gioco più avanzato di solito ha una sorta di editor di livelli, ma per acquisire familiarità con lo sviluppo di giochi 2D, un algoritmo può fornire livelli sufficientemente buoni.

Scopri quante righe e colonne sono necessarie. Per questo, dividi la dimensione dello schermo per la dimensione della piastrella sia orizzontalmente (colonne) che verticalmente (righe). Arrotondare il numero verso l'alto; hai bisogno di una funzione del modulo math per questo, quindi aggiungi da math import ceil alle importazioni nella parte superiore del tuo codice.
Apri un file per la scrittura. Questo cancellerà tutto il contenuto precedente del file, quindi scegli un nome che nessun file nella directory ha ancora, come levelMap.xml.
Scrivi i tag di apertura nel file.
Genera una mappa delle tessere secondo l'algoritmo. Usa quello nel codice qui sotto, oppure puoi inventarne uno da solo. Assicurati di importare la funzione randint dal modulo random: è necessario che il codice sotto funzioni e qualunque cosa ti venga in mente probabilmente avrà bisogno anche di numeri interi casuali. Inoltre, assicurati di posizionare le tessere cielo e le tessere ghiaccio in strati diversi: il ghiaccio è solido, il cielo no.
Scrivi i tag di chiusura nel file e chiudi il file.

def generateTilemap(): colAmount = ceil(800 / 16)*3 # (larghezza dello schermo / dimensione del riquadro) * 3 rowAmount = ceil(600 / 16) # altezza dello schermo / dimensione del riquadro tileFile = open("levelMap.xml", " w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) for i in range(0, colAmount): tileFile.write('') makeHole = False se randint(0, 50) == 10 e i != 0: # non consentono buchi allo spawnpoint makeHole = True for j in range(0, rowAmount): if makeHole: tileFile.write('\n') else: if j <= iceHeight: tileFile.write('\n') else: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) if iceHeight < 0: # limita l'abbassamento delle tessere iceHeight = randint(1, 5) if iceHeight > rowAmount: # impedisce alle tessere di andare troppo in alto iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n') tileFile.write ('\n\n') for i in range(0, colAmount): tileFile.write('') for j in range(0, rowAmount): tileFile.write('\n') tileFile.write('\ n') tileFile.write('\n\n') tileFile.close()

Passaggio 11. Visualizza la mappa delle tessere

Importa tutto da cocos.tiles e poi vai nella funzione startGame per quello.

All'inizio della tua funzione startGame, genera una mappa delle tessere usando la funzione che hai definito per quella.
Crea un nuovo gestore di scorrimento. Fallo direttamente sotto la linea in cui aggiungi lo sprite al suo livello.
Crea un nuovo livello contenente le tessere, che verrà caricato dalla mappa delle tessere levelMap.xml generata dalla funzione generateTilemap.
Aggiungi il livello non solido, il livello solido e il livello sprite al gestore di scorrimento, esattamente in questo ordine. Se lo desideri, puoi aggiungere una posizione z.
Invece di creare la scena dal livello sprite, creala dal gestore scorrimento.

La tua funzione startGame dovrebbe ora assomigliare a questa:

def startGame(): generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 500) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang.add(solidTiles, z=0) scrMang.add(figLayer, z =1) # gameSc = Scene(scrMang) director.run(gameSc)

Passaggio 12. Testa il tuo codice

Dovresti testare spesso il tuo codice per assicurarti che le nuove funzionalità che hai implementato funzionino davvero.

Il codice nell'esempio dovrebbe ora mostrare un paesaggio ghiacciato dietro il pinguino. Se il pinguino sembra librarsi lontano sul ghiaccio, non hai fatto nulla di sbagliato e verrà risolto nel passaggio successivo

Passaggio 13. Aggiungi i controlli

Il giocatore ha molti più modi per interagire con il programma in un gioco 2D che in un gioco basato su testo. Uno comune include lo spostamento della loro figura quando viene premuto il tasto corretto.

Importa tutto da cocos.mapcolliders e da cocos.actions. Importa anche la chiave da pyglet.window.
"Dichiarare" alcune variabili globali. Le variabili globali sono condivise tra le funzioni. Non puoi davvero dichiarare variabili in Python, ma devi dire che esiste una variabile globale nel codice principale prima di usarla. Puoi assegnare 0 come valore perché una funzione si occuperà di assegnare il valore corretto in un secondo momento. Quindi aggiungi sotto le espressioni di importazione:
```
# "dichiarando" variabili globali keyboard = 0 scrMang = 0
```

Regola la tua funzione startGame:

Diciamo che usi la tastiera delle variabili globali e scrMang. Fallo scrivendo la tastiera globale, scrMang nella parte superiore della funzione.
Fai in modo che la finestra ascolti gli eventi della tastiera.
Dì alla figura di agire in base a un PlatformerController. Implementerai presto questo PlatformerController.
Crea un collisore di mappe per gestire le collisioni tra le tessere solide e la figura.

def startGame(): tastiera globale, scrMang generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # keyboard = key. KeyStateHandler() director.window.push_handlers(keyboard) # fig.do(PlatformerController()) mapcollider = RectMapCollider(velocity_on_bump ='slide') fig.collision_handler = make_collision_handler(mapcollider, solidTiles) # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) scrMang.add(solidTiles, z=0) scrMang.add(figLayer, z= 1) # gameSc = Scene(scrMang) director.run(gameSc)

Crea un controller platform. Questo è ciò che sposterà la figura in base alla pressione dei tasti.
- Definisci il controller platform come una sottoclasse di Action.
- Definisci la velocità di movimento, la velocità di salto e la gravità.
- Definire la funzione di avvio. Questa funzione viene chiamata una volta, quando il controller del platform è collegato alla figura. Dovrebbe impostare la sua velocità su 0 sia in direzione x che in direzione y.
- Definire la funzione passo. Verrà ripetuto mentre la scena è in esecuzione.
- Dire alla funzione step di utilizzare la tastiera delle variabili globali e scrMang.
- Ottieni e modifica la velocità. Salva la velocità x e y in variabili separate. Imposta la velocità x su 1 o -1 (a seconda che sia stato premuto il tasto sinistro o destro) moltiplicata per la velocità di spostamento. Aggiungi la gravità alla velocità y. Moltiplicalo con i tempi di inattività in modo che funzioni allo stesso modo sui dispositivi più lenti. Se viene premuto il tasto spazio e la figura è in piedi a terra, salta modificando la velocità y in velocità di salto.
- Calcola dove dovrebbe muoversi la figura. Quindi lascia che il gestore delle collisioni regoli quella posizione se si trova all'interno di una piastrella solida. Infine, sposta la figura nella nuova posizione regolata.
- Imposta il focus del gestore di scorrimento sulla figura. Ciò fa sì che la telecamera si muova in modo ragionevole quando la figura si muove.
```
class PlatformerController(Action): tastiera globale, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start(self): self.target.velocity = (0, 0) def step(self, dt): tastiera globale, scroller se dt > 0.1: # non fa nulla durante i tempi di inattività per un grande ritorno vx, vy = self.target.velocity vx = (keyboard[key. RIGHT] - keyboard[key. LEFT]) * self. MOVE_SPEED vy + = self. GRAVITY * dt if self.on_ground e keyboard[key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() new.x += dx new.y += dy self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(*new.center)
```

Passaggio 14. Testa il tuo codice

Se hai seguito l'esempio, ora dovresti essere in grado di spostare il pinguino con i tasti freccia e saltare premendo la barra spaziatrice. Inoltre, il pinguino dovrebbe ora cadere invece di librarsi sul terreno.

Passaggio 15. Crea un finale per il gioco

Anche i giochi che possono andare avanti all'infinito dovrebbero avere la possibilità di perdere. Poiché il livello che hai realizzato nell'esempio con una funzione ha una fine, dovrai anche rendere possibile la vittoria arrivando a quella fine. Altrimenti, il giocatore salterebbe solo sui blocchi di ghiaccio lì, il che diventerebbe noioso.

All'interno del controller platform, dopo aver impostato la messa a fuoco, ottieni la posizione xey della figura. Se la posizione y è minore di 0, chiama la funzione finishGame() (la scriverai in seguito) con "Game Over" come argomento. Se la posizione x è maggiore della dimensione dello schermo moltiplicata per 3 (prima l'avevi impostata come dimensione del livello).
```
posX, posY = self.target.position if posY < 0: finishGame("Game Over") return se posX > 800*3: # dimensione livello finishGame("Level Completed") return
```
Definire una classe finishMenu. Dovrebbe essere come la classe del menu principale che hai definito prima, ma invece di avere una stringa vuota come titolo, dovrebbe usare un testo variabile che la funzione _init_ prende come argomento. Le voci di menu dovrebbero essere etichettate "Riprova" e "Esci" ora, ma le funzioni che chiamano rimangono le stesse.
```
class FinishMenu(Menu): def _init_(self, text): super(FinishMenu, self)._init_(text) self.menu_valign = CENTER self.menu_halign = CENTER menuItems = [(MenuItem("Riprova", startGame)), (MenuItem("Esci", pyglet.app.exit))] self.create_menu(menuItems)
```
Definire la funzione finishGame(). Dovrebbe prendere il testo come argomento. Dovrebbe creare una scena dallo sfondo del menu principale, un FinishMenu con l'argomento testo passato a questo menu. Quindi dovrebbe eseguire questa scena.
```
def finishGame(testo): menuSc = Scene(MainMenuBgr()) menuSc.add(FinishMenu(testo)) director.run(menuSc)
```

Passaggio 16. Aggiungi crediti

Qui è dove ottieni il credito per il tuo fantastico codice, oltre a dare credito a chiunque altro ti abbia aiutato lungo la strada. Se hai utilizzato un'immagine da un altro sito Web (con autorizzazione), assicurati di attribuire quell'immagine al suo creatore.

Crea un file CREDITI e inserisci lì tutti i tuoi crediti, in questo modo:

Pinguino: Kelvin Shadewing, sotto CC0 Blocco di ghiaccio: Michał Banas digit1024 su opengameart.org sotto CC-BY-SA 3.0

Torna al tuo codice Python e importa Label da cocos.text.

Definire una sottoclasse Crediti di Layer. Nella sua funzione _init_, leggi il file CREDITS e crea un'etichetta di testo nella posizione corretta su ogni riga al suo interno.

class Credits(Layer): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n ") for i in range(0, len(creds)): credLabel = Label(creds, font_size=32, anchor_x="left", anchor_y="top") credLabel.position = 25, 500-(i +1)*40 self.add(credLabel)

Vai alla tua classe del menu principale e aggiungi una voce di menu denominata "Crediti" che chiama la funzione showCredits quando viene cliccata.
Definire una sottoclasse BackToMainMenuButton di Menu. Rendi questo un menu con un elemento, etichettato "Indietro", che chiama la funzione showMainMenu. Questo "menu", che è più simile a un pulsante, dovrebbe essere allineato verticalmente in basso e orizzontalmente in alto.
```
class BackToMainMenuButton(Menu): def _init_(self): super(BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self. create_menu(menuItems)
```
Definire la funzione showCredits. Dovrebbe creare una scena da un livello MainMenuBgr e un livello Crediti ed eseguire quella scena.
```
def showCredits(): credSc = Scene(MainMenuBgr()) credSc.add(Credits()) credSc.add(BackToMainMenuBgr()) director.run(credSc)
```

Passaggio 17. Controlla il tuo codice

Quando pensi di aver finito il tuo codice, dovresti esaminarlo di nuovo tutto. Questo può aiutarti a notare se qualcosa può essere ottimizzato o se ci sono alcune righe non necessarie che hai dimenticato di eliminare. Se hai seguito l'esempio, l'intero codice dovrebbe ora apparire come segue:

da cocos.director importazione * da cocos.menu importazione * da cocos.scene importazione * da cocos.layer importazione * da cocos.sprite importazione * da cocos.tiles importazione * da cocos.mapcolliders importazione * da cocos.actions importazione * da cocos.text import Label import pyglet.app from pyglet.window import key from math import ceil from random import randint # "dichiara" variabili globali keyboard = 0 scrMang = 0 class MainMenuBgr(ColorLayer): def _init_(self): super(MainMenuBgr, self)._init_(0, 200, 255, 255) class MainMenu(Menu): def _init_(self): super(MainMenu, self)._init_("") self.menu_valign = CENTRO self.menu_halign = CENTRO menuItems = [(MenuItem("Start Game", startGame)), (MenuItem("Credits", showCredits)), (MenuItem("Quit", pyglet.app.exit))] self.create_menu(menuItems) class Credits(Layer): def _init_(self): super(Credits, self)._init_() credFile = open("CREDITS", "r") creds = credFile.read() creds = creds.split("\n") for i nell'intervallo (0, len(creds)): credLabel = Label(creds, font_size=32, anchor_x="left", anchor_y="top") credLabel.position = 25, 500-(i+1)*40 self.add(credLabel) class BackToMainMenuButton(Menu): def _init_(self): super (BackToMainMenuButton, self)._init_("") self.menu_valign = BOTTOM self.menu_halign = LEFT menuItems = [(MenuItem("Back", showMainMenu))] self.create_menu(menuItems) class FinishMenu(Menu): def _init_(self, text): super(FinishMenu, self)._init_(text) self.menu_valign = CENTRO self.menu_halign = CENTRO menuItems = [(MenuItem("Riprova", startGame)), (MenuItem("Esci", pyglet. app.exit))] self.create_menu(menuItems) class PlatformerController(Action): tastiera globale, scrMang on_ground = True MOVE_SPEED = 300 JUMP_SPEED = 500 GRAVITY = -1200 def start(self): self.target.velocity = (0, 0) def step(self, dt): tastiera globale, scroller se dt > 0.1: # non fa nulla mentre i tempi di inattività sono troppo grandi return vx, vy = self.target.velocity vx = (keyboard[key. RIGHT] - keyboard [key. LEFT]) * self. MOVE_SPEED vy += self. GRAVITY * dt se self.on _ground and keyboard[key. SPACE]: vy = self. JUMP_SPEED dx = vx * dt dy = vy * dt last = self.target.get_rect() new = last.copy() new.x += dx new.y + = dy self.target.velocity = self.target.collision_handler(last, new, vx, vy) self.on_ground = (new.y == last.y) self.target.position = new.center scrMang.set_focus(* new.center) posX, posY = self.target.position if posY < 0: finishGame("Game Over") return if posX > 800*3: # level size finishGame("Level Completed") return def finishGame(testo): menuSc = Scene(MainMenuBgr()) menuSc.add(FinishMenu(text)) director.run(menuSc) def showCredits(): credSc = Scene(MainMenuBgr()) credSc.add(Credits()) credSc.add(BackToMainMenuButton()) director.run(credSc) def generateTilemap(): colAmount = ceil(800 / 16)*3 # (larghezza schermo / dimensione tile) * 3 rowAmount = ceil(600 / 16) # altezza schermo / dimensione tile tileFile = open ("levelMap.xml", "w") tileFile.write('\n\n\n') iceHeight = randint(1, 10) for i in range(0, colAmount): tileFile.write('') makeHole = Falso se rand int(0, 50) == 10 e i != 0: # non consentono buchi al punto di spawn makeHole = True for j in range(0, rowAmount): if makeHole: tileFile.write('\n') else: if j <= iceHeight: tileFile.write('\n') else: tileFile.write('\n') iceHeight = randint(iceHeight-5, iceHeight+5) if iceHeight < 0: # limita l'uscita anche delle tessere low iceHeight = randint(1, 5) if iceHeight > rowAmount: # impedisce alle tessere di andare troppo in alto iceHeight = randint(int(rowAmount/2)-5, int(rowAmount/2)+5) tileFile.write('\n ') tileFile.write('\n\n') for i in range(0, colAmount): tileFile.write('') for j in range(0, rowAmount): tileFile.write('\n') tileFile.write('\n') tileFile.write('\n\n') tileFile.close() def startGame(): tastiera globale, scrMang generateTilemap() # fig = Sprite('pingu.png') fig.position = (8, 250) figLayer = ScrollableLayer() figLayer.add(fig) # tileLayer = load('levelMap.xml') solidTiles = tileLayer['solid'] nsoliTiles = tileLayer['not_solid'] # keyboard = key. KeyStateHandler () director.window.push_handlers(keybo ard) # fig.do(PlatformerController()) mapcollider = RectMapCollider(velocity_on_bump='slide') fig.collision_handler = make_collision_handler(mapcollider, solidTiles) # scrMang = ScrollingManager() scrMang.add(nsoliTiles, z=-1) add(solidTiles, z=0) scrMang.add(figLayer, z=1) # gameSc = Scene(scrMang) director.run(gameSc) def showMainMenu(): menuSc = Scene(MainMenuBgr()) menuSc.add(MainMenu()) director.run(menuSc) window = director.init(caption="IcyPlat - un semplice platform", ridimensionabile=True) showMainMenu()

Sono 168 righe in totale e 152 righe se conti solo il codice. Questo fa sembrare molto, ma per un gioco così complesso, in realtà è una piccola quantità.

Passaggio 18. Finito

Ora prova il gioco. Quando programmi qualcosa, devi verificare se funziona ogni volta che hai implementato qualcosa di nuovo. Inoltre, potresti voler giocare al gioco che hai scritto per un po' di tempo.

Parte 3 di 3: pubblicazione di un gioco

Passaggio 1. Annotare le dipendenze

Chiunque utilizzi un altro computer non avrà gli stessi software e librerie installati come te. Quindi, dovrai assicurarti che tutti coloro che installano il tuo gioco sappiano esattamente di cosa avranno bisogno per eseguirlo. Non devi scrivere tutte le dipendenze di tutte le dipendenze di tutte le dipendenze e così via, ma dovresti almeno scrivere le dipendenze dei tuoi pacchetti e le loro dipendenze.

Passaggio 2. Assicurati di avere il permesso di utilizzare tutti i media

Questo vale per tutta la grafica, inclusi modelli 3D, musica, dialoghi, musica, librerie e framework che hai usato per il tuo gioco. Tutto ciò che non hai scritto tu.

Spesso ci sono alcune condizioni, come dover citare l'autore o condividere le modifiche dei media con la stessa licenza. A volte sarai in grado di utilizzare la grafica senza attribuire i creatori finché non addebiti per il gioco. Se devi citare l'autore, fallo in un posto ben visibile, come una scheda "Crediti" nel tuo gioco.
Ci sono anche media con diritti d'autore rivendicati e nessuna licenza specificata, a volte con del testo come "Tutti i diritti riservati". In tal caso, è necessario ottenere l'autorizzazione esplicita dall'autore prima di includerlo nel gioco.
Le biblioteche sono generalmente rilasciate con licenze che ne consentono l'utilizzo come biblioteche. Un'eccezione degna di nota è l'eccezione GPL senza collegamento: tale licenza consente di utilizzarla solo in un programma con determinate licenze. E dovresti sempre leggere almeno i punti di base della licenza per assicurarti che tutto ciò che stai facendo con i media o la libreria sia consentito.

AvvertimentoNota: l'utilizzo di contenuti multimediali o librerie in un modo non consentito dalla licenza in un gioco che pubblichi può causare seri problemi legali. Quindi, chiedi all'autore o evita del tutto il pezzo di media se non sei sicuro se il tuo utilizzo è consentito.

Passaggio 3. Decidi le condizioni su cui vuoi pubblicare il tuo gioco

Venderai il tuo gioco? Vuoi consentire ad altri di utilizzare le tue immagini e idee? Mentre devi stare attento ai media che usi nel tuo progetto, di solito puoi decidere come vuoi consentire ad altri di usare il tuo gioco. Puoi utilizzare una licenza Creative Commons CC0 per rilasciare il tuo gioco nel dominio pubblico. Per consentire la distribuzione e la modifica in determinate condizioni mantenendo alcuni diritti, prova la licenza Gnu General Public License (GPL) o la licenza Berkeley Software Distribution (BSD). Oppure, potresti rendere il tuo software proprietario, il che significa che nessuno è autorizzato a distribuirlo o modificarlo senza il tuo permesso.

Sebbene sia possibile guadagnare vendendo giochi, è improbabile che le persone acquistino il tuo primo gioco che di solito ha poche funzionalità e niente di speciale. Inoltre, se un programma gratuito non funziona, le persone che lo hanno scaricato rimarranno semplicemente deluse. Se lo hanno pagato, tuttavia, chiederanno indietro i loro soldi, causando più problemi sia a te che agli utenti. Quindi considera di rendere disponibili i tuoi primi programmi gratuitamente

Passaggio 4. Decidi come vuoi pubblicare il tuo gioco

Ogni metodo ha alcuni vantaggi e svantaggi, quindi devi decidere tu stesso.

Pubblicarlo su un sito web:

Se hai un sito web, puoi caricare il tuo gioco per renderlo disponibile per il download. Assicurati di fornire istruzioni chiare su come installare il software, nonché tutte le dipendenze richieste. Lo svantaggio di questo è che i giocatori dovranno installare le dipendenze manualmente, il che potrebbe essere difficile per alcune persone.
Creare un pacchetto per un gestore di pacchetti:

Esistono diversi gestori di pacchetti, come apt, Yum e Homebrew, che semplificano l'installazione di app in ambienti Linux e basati su Linux. Hanno tutti diversi formati di pacchetto. La cosa buona dei pacchetti è che installano automaticamente tutte le dipendenze (se le configuri correttamente). Quindi il giocatore deve solo installare il tuo pacchetto e può quindi giocare. Il problema è che ci sono molti gestori di pacchetti diversi su piattaforme diverse, quindi dovrai impegnarti per fornire pacchetti per tutti i più comuni.

Passaggio 5. Dirigi l'attenzione sul tuo programma

Considera di caricare il tuo programma in un repository di pacchetti principale, come quelli gestiti da Ubuntu e Debian, per consentire installazioni facili. Inoltre, posta nei forum appropriati, come la sezione progetti di GameDev o una parte di tigSource. Ma non essere deluso se i tuoi primi giochi non diventano famosi. Se hai l'idea che a molte persone piaccia, il tuo gioco può diventare famoso.

Suggerimenti

Sii paziente e disposto ad imparare. La programmazione a volte può essere frustrante!
Se ti chiedi come si fa qualcosa in un altro gioco e il gioco è open-source, puoi guardare il suo codice sorgente.
Quando cerchi contenuti multimediali, prova a trovare contenuti di pubblico dominio. Cerca immagini e musica "Creative Commons" o "Public Domain" e utilizza siti Web come https://opengameart.org o
Non copiare grandi blocchi di codice senza controllare la licenza. È spesso vietato e, in caso contrario, di solito richiede l'attribuzione.
Non fare spam o postare in luoghi inappropriati quando promuovi il tuo gioco. È probabile che questo ti blocchi dalla pagina, è semplicemente fastidioso e danneggerà la tua reputazione.