Programmazione videogames come creare videogiochi

Questo sito utilizza cookie, anche di terze parti. Se vuoi saperne di più leggi la nostra Cookie Policy. Scorrendo questa pagina o cliccando qualunque suo elemento acconsenti all’uso dei cookie.I testi seguenti sono di proprietà dei rispettivi autori che ringraziamo per l'opportunità che ci danno di far conoscere gratuitamente a studenti , docenti e agli utenti del web i loro testi per sole finalità illustrative didattiche e scientifiche.

Le informazioni di medicina e salute contenute nel sito sono di natura generale ed a scopo puramente divulgativo e per questo motivo non possono sostituire in alcun caso il consiglio di un medico (ovvero un soggetto abilitato legalmente alla professione).

Programmazione videogames come creare videogiochi

Primi passi nella programmazione di videogames

rev. 2, dicembre 2010

Premessa: a che serve questo documento

Questo documento è stato scritto per la prima volta ad aprile 2009 per rispondere e, se possibile, soddisfare, uno specifico interesse che un gruppo di ragazzi della 5AT ha dimostrato nel corso di informatica: la programmazione grafica applicata ai videogames. In particolare Vincenzo Dibiase ha detto : “I programmatori di videogames sono molto richiesti e mi piacerebbe imparare, ma non so da dove cominciare”. Successiva mente, Vincenzo ha rinunciato a sviluppare videogames e si è iscritto a scenze biotecnologiche.

L'obiettivo è dunque cominciare a capire come si può realizzare un videogame utilizzando:

l'ambiente di programmazione Visual C++, che conosciamo abbastanza bene,
nuovi oggetti e nuove funzioni che includeremo e utilizzeremo nei programmi C++.

A partire da da questo anno scolastico 2010-2011 alcuni elementi di programmazione di videogames fanno parte del programma di informatica per le quinte, e chiunque cominci a studiarlo con interesse e con risultati soddisfacenti, può presentarlo come approfondimento all'esame di maturità.

Perchè includerlo nel programma? L'informatica è una materia che comprende argomenti consolidati nel corso di studi che partono dal XIX secolo e argomenti il cui continuo aggiornamento è guidato dall'evoluzione della tecnologia hardware e software. Un argomento come la programmazione di videogames, perciò, potrebbe completare il nostro programma, che comprende:

La programmazione ad oggetti

Il linguaggio C++
Introduzione alla programmazione orientata agli oggetti
Esempi di programmazione visuale in ambiente Windows.

Lo sviluppo di software per videogames in C++ è un campo in cui c'è molto da scoprire, e vorrei esplorarlo con voi, perchè, oltre alla capacità di utilizzare il linguaggio C++ e alla confidenza con matematica, fisica e inglese, ci vogliono fantasia e capacità grafiche. Probabilmente di queste ultime due qualità siete dotati più di me.

Per cominciare: cerchiamo gli strumenti

Innanzitutto, preparatevi al fatto che dovrete cercare, scrivere e forse anche pensare in inglese. Questo nel migliore dei casi, perchè dalle vostre ricerche possono venir fuori anche risultati in russo, come è successo a me quando ho cercato la soluzione al primo errore di compilazione.

Ricercando su Google le frasi “videogames development” oppure “to develop videogames”, mi sono imbattuta in un forum in cui si consigliava a chi avesse familiarità col Visual C++ di andare sul sito darkgdk.thegamecreators.com e scaricare l'ambiente di sviluppo Dark GDK per costruire videogames all'interno del Visual C++.

Dark GDK comprende un insieme di librerie e di oggetti grafici che, a loro volta, utilizzano Microsoft DirectX, un altro ambiente per la programmazione di videogames.

Per utilizzare Dark GDK è necessario:

installare Microsoft Visual C++ 2008 (o anche 2010)
installare Microsoft DirectX 9.0c SDK (August 2007)
installare Dark GDK

Microsoft’s DirectX 9.0c SDK August 2007 può essere scaricato da

http://download.microsoft.com/download/3/3/f/33f1af6e-c61b-4f14-a0de-3e9096ed4b3a/dxsdk_aug2007.exe

NOTA 1: state attenti a scaricare proprio questa versione e non una successiva, perchè ci manca un file.

Potete anche non installare DirectX, perchè provvederà a installarlo la stessa procedura di installazione di Dark GDK.

Secondo passo: esploriamo ciò che abbiamo installato

Se l'installazione è andata a buon fine, sul vostro computer è stata creata la cartella rappresentata nella figura seguente:

La cartella Tutorials contiene dei progetti Visual C++ da studiare, modificare, compilare e provare.

A questo scopo l'ho duplicata, rinominando la copia in esercizi. In questo modo possiamo partire da un programma di esempio e modificarlo come vogliamo.

La cartella Samples contiene progetti un po' più complicati rispetto a quelli di Tutorial, ma interessanti da studiare. Aprite il programma Sample Viewer per vedere le animazioni prodotte.

La cartella Media contiene alcuni oggetti musicali e grafici che possiamo utilizzare nella costruzione dei videogames.

La cartella Documentation contiene il file di Help con la descrizione di tutte le funzioni (ovviamente in inglese).

Terzo passo: apriamo un progetto e proviamo a compilarlo

Dalla cartella Tutorials, oppure dalla cartella esercizi se ci siamo fatti la copia, apriamo il progetto Getting Started. Se stiamo usando Windows Vista, apparirà il messaggio:

Scegliamo di riavviare Visual C++ come amministratore, oppure, per evitare questo problema, spostiamo la cartella esercizi (copia di Tutorials) dal percorso The Game Creators / Dark GDK ad un altro percorso, che potrebbe essere, ad esempio, quello in cui tniamo i nostri progetti C++.

Riapriamo il progetto Getting Started e proviamo a compilarlo.

Avremo subito i seguenti errori:

Fatal error C1083: Cannot open include file: ‘DarkGDK.h’: No such file

or directory

 Fatal error C1083: Cannot open include file: ‘d3dx9.h’: No such file or

Quarto passo: capiamo come è strutturato un programma per videogames

Osserviamo il file main.cpp : è molto ben commentato (in inglese) e contiene pochissime istruzioni:

#include "DarkGDK.h"

void DarkGDK ( void )

{

dbSyncOn ( );

dbSyncRate ( 60 );

dbCreateAnimatedSprite ( 1, "animatedsprite.png", 4, 4, 1 );

while ( LoopGDK ( ) )

{

dbPasteSprite ( 1, 0, 0 );

dbPlaySprite ( 1, 1, 16, 200 );

dbSync ( );

}

return;

}

La parte fondamentale del programma è la struttura di ripetizione while (condizione) {........}

che avete studiato.

Questo while ripete le istruzioni all'interno delle parentesi graffe finchè la funzione LoopGDK() restituisce un valore > 0. La funzione restituirà un valore <= 0 quando l'utente cercherà di chiudere l'applicazione con un clic sulla crocetta in alto a destra, oppure premendo contemporaneamente i tasti ALT F4, oppure premendo Esc. Con l'istruzione return il controllo tornerà a Windows.

Per essere sicuri di aver capito bene, andiamo a vedere qualche altro programma tra i più semplici, ad esempio Shaders-Beginners, che visualizza un cubo ruotante. Se avete problemi a tradurre i commenti, ditemelo, che poi lo riferisco alla prof. di inglese.

void DarkGDK ( void )

{

// this is the entry point for the program

// switch on sync rate and set the maximum

// refresh rate to 60 frames per second

dbSyncOn ( );

dbSyncRate ( 60 );

// make our cube, load the effect and apply

// it to our object

dbMakeObjectCube ( 1, 1 );

dbLoadEffect ( "DetailMapping.dbs", 1, 1 );

dbSetObjectEffect ( 1, 1 );

dbSetEffectConstantFloat ( 1, "detailScale", 1 );

// main program loop

while ( LoopGDK ( ) )

{

// rotate the object

dbTurnObjectLeft ( 1, 0.5 );

// update the screen

dbSync ( );

}

Altro esempio, in cui il main program loop è semplicissimo e non fa altro che aggiornare lo schermo è 3D Objects. Il programma visualizza questo personaggio che si muove:

In questo caso, a differenza dell'esempio precedente, i movimenti del personaggio non sono causati da un'istruzione del programma, che si limita ad eseguire l'animazione contenuta nell'oggetto, ma sono definiti nel file Colonel-X.X che descrive completamente l'oggetto. Questo file si trova nella cartella più interna del progetto 3D Objects ed è un file di tipo DirectX. Se facciamo doppio clic sul nome del file si aprirà il DirectX Viewer. Vedremo in seguito come sono fatti gli oggetti che useremo. Per ora, torniamo al programma:

void DarkGDK ( void )

{

// turn on sync rate and set maximum rate to 60 fps

dbSyncOn ( );

dbSyncRate ( 60 );

dbPrint ( "Please wait loading model..." );

dbSync ( );

dbLoadObject ( "Colonel-X.X", 1 ); // carica l'oggetto

dbPositionCamera ( 0, 50, -80 ); // posiziona la videocamera

dbLoopObject ( 1 ); // esegue ciclicamente l'animazione contenuta nell'oggetto

dbSetObjectSpeed ( 1, 40 ); // imposta la velocità

// main loop

while ( LoopGDK ( ) )

{

// update the screen

dbSync ( );

}

// return back to windows

return;

}

Nei prossimi paragrafi vedremo come modificare questo programma e riusciremo a:

sdoppiare il personaggio, creando un gemello del Colonnello X, che collocheremo in un'altra posizione ed a cui assegneremo un'altra velocità;
ruotare la videocamera con il mouse;
fare lo zoom con i tasti freccia in alto e freccia in basso;
far muovere i due personaggi a suon di musica;
farli muovere in un ambiente che fa da sfondo.

Riflessioni sulla struttura del programma

Questi programmi non assomigliano per niente ai programmi Windows Form che possiamo realizzare in Visual C++.

Possiamo osservare che, mentre l'output del programma ha una grafica spettacolare, la programmazione è molto poco visuale: manca l'equivalente della progettazione in Windows Form, dove posizioniamo oggetti su finestre e ne modifichiamo le proprietà.

Assomiglia invece alla programmazione Windows non visuale nata alla fine degli anni '80 e cresciuta all'inizio degli anni '90. A quei tempi poche centinaia di migliaia di programmatori al mondo, tra cui Bill Gates ed io, creavamo programmi Windows strutturati con un main loop attivo per tutta l'esecuzione del programma. Un esempio di questo tipo di programmazione si può avere creando in Visual C++ un progetto Win32.

Possiamo inoltre osservare la semplicità del codice: poche istruzioni, per la maggior parte chiamate alle funzioni di Dark GDK. Notiamo che:

stiamo utilizzando oggetti grafici i cui dati non conosciamo affatto e ci limitiamo a fornire poche variabili in input;
le funzioni Dark GDK utilizzano gli oggetti e le funzioni DirectX, che abbiamo installato, ma che non dobbiamo necessariamente conoscere.

Troviamo dunque l'applicazione dei concetti fondamentali di astrazione dei dati e di incapsulamento che studieremo nella programmazione object oriented.

Ora che esamineremo alcune funzioni, ci accorgeremo che possono essere chiamate con diversi parametri in input. Ad esempio:

void dbLoopObject ( int iObject )
void dbLoopObject ( int iObject, int iStart )
void dbLoopObject ( int iObject, int iStart, int iEnd )

Questa caratteristica si chiama overloading.

Quinto passo: creiamo un nuovo programma

Nel file Installation.pdf che troviamo nella cartella Dark GDK è scritto che per creare un nuovo programma basta creare un nuovo progetto in Visual C++ e selezionare dalla finestra Nuovo progetto le opzioni Wizard – New GDK Game, come illustrato nella figura seguente.

Purtroppo, però, queste opzioni non compaiono, e ciò può essere causato o da qualche bug nella procedura di installazione oppure dal fatto che stiamo usando Visual C++ Express edition, che è un'edizione ridotta e gratuita, molto utile per imparare, ma non per produrre.

Per poter utilizzare uno dei modelli indicati nella figura, è necessario copiare nella cartella Wizards che si trova sotto la cartella Visual Studio 2008 i files contenuti nel percorso The Game Creators / Dark GDK / Wizards /Files.

In questo modo, quando creiamo un nuovo progetto in Visual C++ ci comparirà la voce Procedure guidate al posto di Wizards. Selezionandola saranno visibili i modelli Dark GDK della figura precedente.

Un altro modo relativamente semplice è creare un progetto vuoto, aggiungere un file .cpp e incollargli il modello di programma vuoto descritto qui sotto. In questo caso possiamo salvare il progetto col nome che vogliamo.

Modello di programma vuoto:

// whenever using Dark GDK you must include the header file

#include "DarkGDK.h"

// the main entry point for the application is this function

void DarkGDK ( void )

{

// at the start of the program we will switch the sync rate on

dbSyncOn ( );

dbSyncRate ( 60 );

// this is our main loop

while ( LoopGDK ( ) )

{

// inside our main loop we can control the logic of the program,

// the final call in our main loop is to dbSync, this function will

// update the screen and draw any graphics

dbSync ( );

}

// return back to windows

return;

}

Per creare un progetto vuoto in Visual C++ si sceglie Generale – Progetto vuoto:

Dal menu Progetto selezioniamo Aggiungi nuovo elemento. Sarà visualizzata la seguente finestra, in cui dobbiamo scegliere Codice – File di C++.

Una volta creato il file, che chiameremo main.cpp, incolliamo il codice.

Se lo compiliamo già da ora, non avremo errori, ma il seguente avvertimento:

LINK : warning LNK4098: la libreria predefinita 'LIBCMT' è in conflitto con l'utilizzo di altre librerie; utilizzare /NODEFAULTLIB:libreria

Fino ad ora questo non ha creato problemi.

Sesto passo: cominciamo a capire come usare le funzioni di Dark GDK

Quando si studia una lingua straniera, o anche il latino e il greco antico, spesso si parte dalla grammatica e dalla sintassi e successivamente si traducono esempi che ci fanno comprendere le regole teoriche. La conseguenza di questo è che solitamente la prima parte dello studio è meno piacevole. Io ho amato moltissimo il latino negli ultimi tre anni di liceo, mentre alla scuola media (perchè ai miei tempi si studiava anche alla scuola media) era faticoso.

Nella programmazione non si usa lo stesso metodo di studio: non vi sarebbe utile leggere anche rapidamente il manuale dei comandi di Dark GDK per passare successivamente agli esempi. Del resto, nenche in C++ abbiamo seguito questo approccio.

E' più utile esaminare il codice di un programma semplice, chiedersi “a che serve questa istruzione?”, e andare a cercare la risposta sul manuale. In questo modo prenderemo confidenza almeno con i comandi usati più frequentemante, tra cui quelli che abbiamo visto negli esempi precedenti, e saremo poi in grado di comprendere anche gli altri. In ogni caso, non dovremo impararli tutti.

Se apriamo il file Dark GDK.hlp nella cartella Documentation, troviamo l'elenco dei comandi, suddivisi per categoria:

1. CORE COMMANDS
2. TEXT COMMANDS
3. INPUT COMMANDS
4. FILE COMMANDS
5. DISPLAY COMMANDS
6. BASIC2D COMMANDS
7. BITMAP COMMANDS
8. SOUND COMMANDS
9. MUSIC COMMANDS
10. SPRITE COMMANDS
11. IMAGE COMMANDS
12. LIGHT COMMANDS
13. CAMERA COMMANDS
14. BASIC3D COMMANDS
15. MATRIX COMMANDS
16. WORLD COMMANDS
17. PARTICLES COMMANDS
18. 3DMATHS COMMANDS
19. FTP COMMANDS
20. MEMBLOCKS COMMANDS
21. MULTIPLAYER COMMANDS
22. SYSTEM COMMANDS
23. TERRAIN COMMAND

Tutti questi comandi sono funzioni i cui prototipi sono descritti nei corrispondenti file di inclusione che si trovano nella cartella INCLUDE.

Ad esempio, le funzioni che realizzano l'aggiornamento dello schermo appartengono alla categoria CORE:

dbSyncOn : void dbSyncOn ( void )

dbSyncOff : void dbSyncOff ( void )

dbSync : void dbSync ( void )

dbSyncRate : void dbSyncRate ( int iRate )

Se apriamo col blocco note il file DarkSDKCore.h troviamo la definizione dei prototipi delle funzioni:

void dbSyncOn ( void );

void dbSyncOff ( void );

void dbSync ( void );

void dbSyncRate ( int dbiRate );

Una categoria particolarmente interessante è BASIC3D, che contiene moltissimi comandi. I comandi di questa categoria consentono di visualizzare, manipolare, muovere, far collidere oggetti tridimensionali, perciò sono utilissimi nella creazione di videogames.

Per imparare a usare alcuni comandi duplicheremo il programma 3D Objects e realizzeremo le modifiche elencate nel paragrafo Quarto passo.

Settimo passo: che cosa ci manca?

Facciamo il punto della situazione. Adesso abbiamo:

l'ambiente di sviluppo: Visual C++, DirectX, Dark GDK;
esempi di programmi;
oggetti da utilizzare nei programmi;
documentazione dei comandi;
possibilità di scambiare idee e chiedere aiuto a sviluppatori di videogames attraverso il sito http://forum.thegamecreators.com/

Che cosa ci manca?

Un po' di conoscenze teoriche. Avremmo bisogno di un glossario per comprendere bene il significato di termini come texture, limb, sprite, etc.

Inoltre abbiamo bisogno di conoscere la matematica dei videogames (e qui il gioco si fa duro: adesso perderemo qualcuno di quelli che erano inizialmente interessati).

Avrete senz'altro notato che esiste la categoria di funzioni 3D Maths, che comprende funzioni matematiche nello spazio. Altre funzioni matematiche sono incluse in CORE.

Che cosa c'entra la matematica con i videogames?

Innanzitutto mi viene da pensare che se un personaggio è illuminato con una luce che viene da sopra, l'ombra che proietta sul pavimento sarà lunga all'incirca quanto la sua altezza per il coseno dell'angolo di cui è inclinato rispetto al pavimento. Se invece la luce viene davanti o di lato, l'ombra che proietta sul muro sarà lunga circa quanto l'altezza per il seno dell'angolo di cui è inclinato rispetto al pavimento.

Secondo: quando muoviamo oggetti nello spazio 3D abbiamo bisogno di matrici che descrivano le coordinate.

Abbiamo innanzitutto bisogno di capire come è fatto lo spazio 3D. A questo proposito, provando alcune istruzioni su oggetti 3D, mi sono resa conto che la terna di assi cartesiani X,Y,Z ha l'asse Z negativo in avanti, diversamente da come siamo abituati a disegnarla in fisica. Questa idea è stata confermata da un articolo di un professore dell'Università di San Paolo del Brasile, che rappresenta così lo spazio 3D:

L'articolo è interessante, ma ha un difetto: è in portoghese. Comunque si capisce buona parte del contenuto. L'articolo è reperibile all'indirizzo: http://osorio.wait4.org/GDK/HandsOn-GDK.pdf

Un altra cosa utile sarebbe la possibilità di disegnare noi stessi alcuni oggetti, personaggi, ambienti da utilizzare nello spazio 3D. Infatti i modelli contenuti in Dark GDK sono alquanto brutti per chi non ama tutto ciò che è aggressivo e militaresco.

Sempre nell'articolo in portoghese è indicato il link al sito di uno strumento grafico che si può scaricare liberamente:

http://www.blender.org/

Con questo software si può provare a costruire personaggi più gradevoli. Ma non ho ancora verificato che siano compatibili con DirectX e Dark GDK.

Cominciamo a lavorare

Come primo lavoro, ci proponiamo di arricchire il programma 3D Objects con le seguenti modifiche, che svilupperemo e proveremo una per volta:

sdoppiare il personaggio, creando un gemello del Colonnello X, che collocheremo in un'altra posizione ed a cui assegneremo un'altra velocità;
ruotare la videocamera con il mouse;
fare lo zoom con i tasti freccia in alto e freccia in basso;
far muovere i due personaggi a suon di musica;
farli muovere in un ambiente che fa da sfondo.

Prima di manipolare il progetto assicuriamoci di averlo duplicato, per poter mantenere l'originale inalterato.

Poi leggiamo attentamente il file 3D Objects.pdf, che spiega il significato di tutte le istruzioni.

Sdoppiamo il personaggio

Non lo ricarichiamo, perchè sarebbe un inutile rallentamento, ma lo cloniamo e ne avviamo la sequenza con le istruzioni:

dbCloneObject(2,1);

dbLoopObject ( 2 );

Per rendere visibile lo sdoppiamento, diamo al secondo oggetto una velocità diversa da quella del primo:

dbSetObjectSpeed ( 2, 70 );

Lo mettiamo in una posizione leggermente diversa dal primo, un po' più a destra, un po' più in basso e un po' più avanti:

dbPositionObject(2, dbObjectPositionX(1)+20, dbObjectPositionY(1)-20, dbObjectPositionZ(1)-20);

Abbiamo utilizzato, all'inteno di dbPositionObject, i comandi che ci danno la posizione dell'oggetto 1.

Scriviamo le istruzioni in questo modo:

void DarkGDK ( void )

{

// turn on sync rate and set maximum rate to 60 fps

dbSyncOn ( );

dbSyncRate ( 60 );

dbPrint ( "Please wait loading model..." );

dbSync ( );

dbLoadObject ( "Colonel-X.X", 1 );

dbPositionCamera ( 0, 50, -80 );

dbLoopObject ( 1 );

dbSetObjectSpeed ( 1, 40 );

// aggiunta 1

dbCloneObject(2,1);

dbLoopObject ( 2 );

dbSetObjectSpeed ( 2, 70 );

dbPositionObject(2, dbObjectPositionX(1)+20, dbObjectPositionY(1)-20, dbObjectPositionZ(1)-20);

// our main loop

while ( LoopGDK ( ) )

{

// update the screen

dbSync ( );

}

// return back to windows

return;

}

Compiliamo e avviamo senza debug, perchè parte prima. A questo punto i colonnelli saranno due.

Ruotiamo la videocamera con il mouse

Questa modifica l'ho presa da un altro programma, Game Level, con cui si può esplorare un ambiente a più piani.

La funzione dbWrapValue fa variare l'angolo tra 0 e 360°.

Non ho capito perchè la rotazione sull'asse X dipende dal movimento del mouse sull'asse Y e viceversa. Spero che qualcuno di voi ci arrivi prima di me. Ho provato ad invertire le funzioni dbMouseMoveX e dbMouseMoveY, ma. In questo caso, spostando il mouse verticalmente la videocamera ruotava orizzontalmente e viceversa.

Comunque, aggiungiamo le istruzioni evidenziate all'interno del main loop, compiliamo e proviamo.

// our main loop

while ( LoopGDK ( ) )

{

//aggiunta 2

float fCameraAngleX, fCameraAngleY;

// create a rotation axis based on mouse movement

fCameraAngleX = dbWrapValue ( fCameraAngleX + dbMouseMoveY ( ) * 0.4f );

fCameraAngleY = dbWrapValue ( fCameraAngleY + dbMouseMoveX ( ) * 0.4f );

// rotate camera

dbXRotateCamera ( fCameraAngleX );

dbYRotateCamera ( fCameraAngleY );

// update the screen

dbSync ( );

}

Zoom in avanti e indietro con i tasti freccia in alto e freccia in basso

Anche questa modifica è presa da Game Level ed è aggiunta all'interno del main loop.

// our main loop

while ( LoopGDK ( ) )

{

//aggiunta 2

float fCameraAngleX, fCameraAngleY;

// create a rotation axis based on mouse movement

fCameraAngleX = dbWrapValue ( fCameraAngleX + dbMouseMoveY ( ) * 0.4f );

fCameraAngleY = dbWrapValue ( fCameraAngleY + dbMouseMoveX ( ) * 0.4f );

// rotate camera

dbXRotateCamera ( fCameraAngleX );

dbYRotateCamera ( fCameraAngleY );

//aggiunta 3 : move the camera using the arrow keys

dbControlCameraUsingArrowKeys ( 0, 5.0f, 0.3f );

// update the screen

dbSync ( );

}

Nel manuale è scritto che i tasti freccia a destra e a sinistra fanno girare la videocamera, ma a me non riesce.

Facciamo ballare i due personaggi

Data la mia antipatia per i personaggi violenti, ho pensato di aggiungere un tocco di humor con un sottofondo musicale. E' possibile caricare e mandare in esecuzione un file mp3 con le istruzioni dbLoadMusic e dbPlayMusic. Il file si può trovare nella stessa cartella del progetto, dove risiede main.cpp, oppure, se si trova in una cartella diversa, si dovrà farla diventare directory corrente con il comando SetCurrentDirectory ( ......);

Ad esempio se sotto la directory di progetto c'e' la cartella media che contiene i files che ci interessano :

SetCurrentDirectory ( "media" );

Per far ballare i due colonnelli ho scelto la canzone di Caparezza “vieni a ballare in Puglia”.

La modifica si può fare prima del main loop. Se si desidera che il brano sia rieseguito ciclicamente si utilizza dbLoopMusic al posto di dbPlayMusic.

void DarkGDK ( void )

{

// turn on sync rate and set maximum rate to 60 fps

dbSyncOn ( );

dbSyncRate ( 60 );

dbPrint ( "Please wait loading model..." );

dbSync ( );

dbLoadObject ( "Colonel-X.X", 1 );

dbPositionCamera ( 0, 50, -80 );

dbLoopObject ( 1 );

dbSetObjectSpeed ( 1, 40 );

// aggiunta 1

dbCloneObject(2,1);

dbLoopObject ( 2 );

dbSetObjectSpeed ( 2, 70 );

dbPositionObject(2, dbObjectPositionX(1)+20, dbObjectPositionY(1)-20, dbObjectPositionZ(1)-20);

//aggiunta 4

dbLoadMusic("Caparezza.mp3", 1);

dbPlayMusic(1);

// our main loop

while ( LoopGDK ( ) )

{

.....................................................

Diamo un ambiente ai due personaggi

Anche l'ambiente in cui collocare i due personaggi è un oggetto, costituito dal file universe.dbo che ho copiato nella cartella di progetto prendendolo dal progetto Game Level. Se ci limitiamo a copiare questo file, l'ambiente sarà costituito da sagome in bianco e nero. Per completarne la grafica dobbiamo copiare le cartelle levelbank e texturebank.

Non chiedetemi dettagli sul loro contenuto: come ho detto nella premessa, sono anch'io principiante come voi, e spero proprio che qualcuno di voi mi superi in abilità.

Comunque l'idea che mi sono fatta è che gli oggetti, personaggi e ambienti, siano sagome in bianco, nero e grigio che vengono riempite con immagini dette “texture”.

Dopo un po' di prove, ho ottenuto il risultato migliore

caricando l'oggetto ambiente per primo,
spostando l'istruzione di posizionamento della videocamera dopo quella di posizionamento del secondo oggetto.

Il codice diventa:

void DarkGDK ( void )

{

// turn on sync rate and set maximum rate to 60 fps

dbSyncOn ( );

dbSyncRate ( 60 );

dbPrint ( "Please wait loading model..." );

dbSync ( );

//aggiunta 5

dbLoadObject ( "universe.dbo", 3 );

dbLoadObject ( "Colonel-X.X", 1 );

dbLoopObject ( 1 );

dbSetObjectSpeed ( 1, 40 );

// aggiunta 1

dbCloneObject(2,1);

dbLoopObject ( 2 );

dbSetObjectSpeed ( 2, 70 );

dbPositionObject(2, dbObjectPositionX(1)+20, dbObjectPositionY(1)-20, dbObjectPositionZ(1)-20);

dbPositionCamera ( 0, 50, -80 );

//aggiunta 4

dbLoadMusic("Caparezza.mp3", 1);

dbPlayMusic(1);

// our main loop

while ( LoopGDK ( ) )

{

//aggiunta 2

float fCameraAngleX, fCameraAngleY;

// create a rotation axis based on mouse movement

fCameraAngleX = dbWrapValue ( fCameraAngleX + dbMouseMoveY ( ) * 0.4f );

fCameraAngleY = dbWrapValue ( fCameraAngleY + dbMouseMoveX ( ) * 0.4f );

// rotate camera

dbXRotateCamera ( fCameraAngleX );

dbYRotateCamera ( fCameraAngleY );

//aggiunta 3 : move the camera using the arrow keys

dbControlCameraUsingArrowKeys ( 0, 5.0f, 5.0f );

// update the screen

dbSync ( );

}

// return back to windows

return;

}

Compiliamo e mandiamo in esecuzione. E voilà: i due colonnelli rischiano di cadere nel vuoto sulla sinistra, da un locale buio che sulla destra ha una scala illuminata da una luce giallastra. La potete vedere spostando il mouse verso destra e potete avvicinarvi alla scala con la freccia in alto.

Se avete esplorato il programma Game Level avrete visto che, posizionando opportunamente la videocamera e usando il tasto freccia in alto, si possono fare diversi percorsi nell'edificio.

Ci proponiamo due obiettivi:

spostare i personaggi in una posizione più interna,
posizionare meglio la videocamera, in modo da poter entrare nell'ambiente con la scala.

Posizioniamo l'oggetto 1 con una coordinata X di 100 ed una Y di 0. Notate che lo zero coincide con il pavimento!

Riposizioniamo anche l'oggetto 2 in funzione delle coordinate di 1, evitando di diminuire la Y di 20, perchè altrimenti vedremmo i piedi sprofondare nel pavimento. In sintesi:

// aggiunta 1

dbCloneObject(2,1);

dbLoopObject ( 2 );

dbSetObjectSpeed ( 2, 70 );

// aggiunta 6

dbPositionObject(1, 100, 0, -80);

dbPositionObject(2, dbObjectPositionX(1)+20, dbObjectPositionY(1), dbObjectPositionZ(1)-20);

dbPositionCamera ( 0, 50, -80 );

Il risultato è questo:

Lavorando con mouse e frecce possiamo anche arrivare alla scala e riprendere i personaggi da un altro punto di vista:

Ora cerchiamo di posizionare meglio la videocamera, spostandola in avanti sull'asse Z.

Ho posizionato la videocamera in questo modo:

dbPositionCamera ( 20, 50, -100 );

Sono salita sulla scala e ora li sto guardando dall'alto:

Adesso continuate voi!!!

Fate muovere i personaggi nell'ambiente. Fateli salire al piano di sopra.

Studiate e modificate gli altri esempi. Studiate come costruire altri personaggi ed altri ambienti.

Quando sarete diventati bravi potrete mandare il vostro curriculum ad aziende come

www.pmstudios.it

Il link per chi vuole collaborare con questa azienda di Bari è

http://www.pmstudios.it/index.php?option=com_performs&formid=2&Itemid=58

Ma ricordate che un buon curriculum si costruisce con buoni voti negli studi !!!

Fonte: http://gabryprof.altervista.org/programmazione_videogames.doc

Sito web da visitare : http://gabryprof.altervista.org

Autore del testo: non indicato nel documento di origine (prof Gabry ?)

Parola chiave google : Programmazione videogames come creare videogiochi tipo file : doc

Programmazione videogames come creare videogiochi