În zilele noastre este foarte greu să găsești o persoană care nu a jucat jocuri pe mobil, doar amintește-ți de clasicul „Șarpe”. Dar ți-a trecut vreodată prin cap să-ți creezi propriul joc, în care vor fi propriii tăi eroi, inventați doar de tine?
Pentru a începe să creați chiar și cel mai simplu joc mobil, trebuie să ai anumite abilități. Ce anume este necesar?
- Trebuie să te gândești la un scenariu, poate chiar să-l scrii, să-l arăți prietenilor sau familiei. La urma urmei, ce rost are să începi creația dacă nu există încă un complot?
- Aș dori să observ imediat că crearea unui joc fără abilități de programare este un proces destul de lung, complex și plictisitor. Deși, cunoscându-l pe acesta din urmă, nimic nu se va schimba prea mult, procesul nu va deveni deloc distractiv. Fii răbdător!
- Și, în sfârșit, veți avea nevoie de software, sau mai degrabă de un designer de jocuri, poate chiar mai mult de unul. Vă spun mai jos pe care să o alegeți.
Ce este un designer și cum să-l alegi corect?
Acesta este un program creat pentru a face viața mai ușoară utilizatorilor. Dar mai are și un scop - designerul ar trebui să ofere posibilitatea de a crea aplicații nu numai pentru persoanele cu anumite abilități de programare, ci și pentru cei care nu au idee despre ce este. Adică, cu ajutorul designerului, oricine își poate crea propriul joc.
Cum să alegi designerul potrivit? Destul de ciudat, dar trebuie să începi să-l alegi pe baza în primul rând cunoştinţelor tale - de la abilităţile de programare până la nivelul de competenţă Limba engleză. Dacă primul punct este zero pentru tine, atunci recomand să alegi programe pentru începători, acestea fiind mai ușor de folosit. Al doilea criteriu de selecție este funcționalitatea necesară. Aici avem nevoie de scenariul nostru alcătuit cu precizie; trebuie să-l citim din nou „din scoarță în scoarță” și să înțelegem cât de complex va fi viitorul joc. Cu cât proiectul este mai complex, cu atât va trebui folosit mai mult tot felul de „clopote și fluiere”, ceea ce înseamnă că designerul trebuie să fie mai puternic și mai profesionist.
Mai jos voi da câteva exemple de cei mai des întâlniți designeri pe care profesioniștii îi sfătuiesc începătorilor.
Construcția 2
Această aplicație a fost inclusă pe bună dreptate în lista TOP a programelor de design de mulți ani la rând, deoarece face posibilă crearea de jocuri pe practic toate platformele posibile și în toate genurile. Interfața Construct este cât se poate de simplă, dar nu există încă o rusificare. Setul de instrumente este suficient pentru a crea orice joc bidimensional. Un alt avantaj este că nu este necesar să cumpărați o licență de program; vă puteți descurca cu ușurință cu funcționalitatea oferită în versiunea gratuită.
Descarca: Construcția 2
Tutoriale video despre Construct 2
Stencyl
Acest constructor este conceput și pentru începătorii care nu înțeleg programarea. Este perfect pentru a crea jocuri simple bidimensionale și va oferi ocazia de a lansa un proiect cu o interfață grafică decentă.
În plus, dacă mai aveți măcar ceva cunoștințe în domeniul programarii, atunci Stencyl vă va oferi posibilitatea de a scrie propriul cod în blocuri. Setul de instrumente vă va permite să creați jocuri de aproape orice gen, dar funcționalitatea este mai orientată spre crearea de „trăgători”.
Programul este gratuit, dar dacă doriți să vă convertiți creația în formate pe care le „înțelege” Calculator personal, atunci va trebui să cumpărați un abonament licențiat, iar acesta este, fără îndoială, un minus, deoarece acest abonament nu este ieftin, costă aproape 100 de dolari pe an. Ei bine, dacă vă vedeți în viitor ca un creator profesionist de jocuri mobile, atunci pregătiți-vă să plătiți 200 USD pe an, care este exact cât va costa un program cu capacitatea de a salva un proiect în formatul sistemelor de operare mobile.
Descarca: Stencyl
Tutoriale video despre Stencyl
Unitate 3D
Cred că mulți oameni au auzit acest nume și au văzut acest logo pe ecranele dispozitivelor lor mobile. Chestia este că compania care produce software pentru crearea de jocuri produce și aplicații cu design propriu.
Unity 3D este cel mai puternic designer pentru crearea de aplicații 3D. Nivelul la care vă puteți duce proiectul este decent (doar uitați-vă la captura de ecran de mai sus). Aceasta nu este o imagine procesată, ci o captură de ecran reală a unui joc neterminat! De acord, acesta este un nivel foarte înalt pentru un joc mobil.
Dar un astfel de rezultat va necesita anumite abilități. Deși programul este poziționat ca o aplicație pentru începători, este mai probabil destinat amatorilor și profesioniștilor, deoarece pentru a lucra cu el veți avea nevoie cunostinte de baza programare și modelare 3D. Și, desigur, în Unity puteți crea un proiect de orice complexitate și orice gen; setul de instrumente este pur și simplu uriaș.
Descarca: Unitate 3D
Tutoriale video despre Unity 3D
Cum se folosesc constructorii?
Nu există instrucțiuni specifice pentru crearea unui joc. Totul depinde de genul pe care îl alegi, de aptitudinile tale și, bineînțeles, de programul cu care vei face toate acestea. În acest sens, vă recomand ca proiect de pornire să încercați să faceți ceva ce a fost deja făcut de oameni mai experimentați, YouTube vă va ajuta. Acest lucru vă va ajuta să vă familiarizați cu mediul de dezvoltare a jocului, să înțelegeți cum funcționează instrumentele de bază și, eventual, să vă schimbați scenariul de dezvoltare.
Când faci un proiect de „test” și te hotărăști cu siguranță pe al tău, alege un program, apoi caută pe internet videoclipuri despre designerul pe care îl vei folosi.
Nu vă fie teamă să experimentați, să căutați pe internet și să încercați lucruri. Doar așa vei învăța și te vei dezvolta. Succes la crearea ta capodopera.
Instrucțiuni
Selectează platforma pentru care va fi jocul tău. Deoarece piața sistemelor de operare mobile este foarte diversă, iar fiecare sistem are propriile caracteristici de a crea aplicații. Cele mai populare acum sunt următoarele sisteme iOS, Android, Symbian OS și Windows Phone 7. Cel mai bun sistem de operare cu care începem este Windows Phone 7. Are un mediu de dezvoltare convenabil care acceptă diverse tehnologii precum XNA și Silverlight.
Învață un limbaj de programare. Acest scena principala la crearea oricărui program. Și cu cât mai multe abilități de programare, cu atât mai multe oportunități de a implementa idei. Unul dintre limbajele de programare puternice și în același timp ușor de învățat este C#. Proiectat de către Microsoft Ca alternativă la Java, acest limbaj are capacități grozave.
Vino cu ideea ta pentru un joc. Notează pe o foaie de hârtie sau într-un document separat tot ceea ce vrei să implementezi în jocul tău. Dar luați în considerare opțiunile dvs. Nu este nevoie să faceți planuri greu de implementat. Luați în considerare toate punctele și evidențiați-le pe cele pe care nu le puteți completa pe baza cunoștințelor dvs. Pentru a rezolva probleme dificile, alăturați-vă forumurilor pentru dezvoltatori. Acolo puteți pune oricând întrebări programatorilor mai experimentați.
Instalați mediul de dezvoltare. Pentru a crea jocuri pentru Windows Phone 7, veți avea nevoie de Visual Studio 2010 și Windows Phone Developer Tools. Ambele produse sunt complet gratuite
Începeți să dezvoltați jocul. Decideți tipul de proiect, tehnologiile suplimentare și clasele. Determinați imediat tipul de control al jocului. Poate că va fi clicuri simple care implică una sau ambele mâini. Sau poate vor fi folosiți diverși senzori de poziție și o cameră. Gândiți-vă la logica jocului și la implementarea acesteia.
Implică-te în designul jocului. O parte din conținutul aplicației, cum ar fi texturi, imagini, fonturi și sunete, poate fi găsit pe Internet. Restul îl poți desena singur sau să întrebi pe altcineva.
Începeți să testați jocul. Acest stadiu final dezvoltarea aplicației. Creați teste pentru logica aplicației și urmăriți erorile care apar. Încercați să reduceți numărul lor la minimum.
Dacă jocul este gata, publicați-l. Postează-l în Acces liber sau înregistrează-te în magazinul de aplicații și încearcă să câștigi bani din el. Nu vă abandonați creația, ci încercați să o susțineți îmbunătățindu-l și introducând ceva nou.
Video pe tema
Surse:
- Tot ce ai nevoie pentru a crea jocuri
- joc online pentru telefon
Crearea de jocuri pentru telefoane este realizată de un dezvoltator care, de regulă, este reprezentat de o companie. Dar există și cazuri când o persoană este implicată într-un astfel de proces.
Instrucțiuni
Decideți asupra sistemului de operare mobil pentru care va fi proiectat jocul. Cert este că astăzi în lume nu există nimeni platforma mobila, care este copleșitor cu majoritatea cantitativă (de exemplu, ca în computere, unde Windows conduce, fără îndoială). Fiecare producător promovează ceva diferit și, ca urmare, piața are aproximativ zece sisteme de operare. Cele mai utilizate sisteme de operare sunt Android, Symbian OS, iOS și Windows Phone 7.
La început, va trebui să dezvoltați jocul pentru una dintre aceste platforme și abia apoi să refaceți (portați) jocul pentru alții. Un astfel de proces nu este banal și necesită o abordare îndrăzneață, deoarece Uneori, diferențele dintre platforme sunt destul de semnificative.
Învață un limbaj de programare. Programarea este cea mai importantă parte în crearea oricărui program de calculator, iar programatorul este cel mai important creator al acestuia, iar nivelul de profesionalism este direct proporțional cu succesul viitorului joc.
Opțiunea ideală pentru dezvoltarea pentru dispozitive mobile este limbajul Java. Începătorilor le va fi dificil să-și înțeleagă elementele de bază. Ar fi mai corect și mai ușor să începem cu elementele de bază ale programării, mai întâi stăpânirea curiculumul scolar informatică.
Fă-ți o idee pentru un joc viitor. Creați un document special în care descrieți tot ce ține de proiect, dar fără fanatism. Nu trebuie să faci planuri grandioase, dar tot trebuie să le transformi în realitate folosind abilitățile tale de programare. Când vă gândiți la concept, amintiți-vă de literatura despre programare, gândiți-vă la totul din punct de vedere logic.
Acest tutorial începe o serie de articole despre scrierea de jocuri arcade pentru Android. Baza a fost preluată dintr-o serie pe care am scris-o și am publicat-o pe blogul meu Tamas Jano. Materialul se adresează în primul rând programatorilor începători care doresc să își încerce mâna la crearea de jocuri pentru Android. Mi-am propus să creez pe site-ul nostru cel mai ușor de înțeles și mai accesibil manual pentru un public tânăr vorbitor de limbă rusă, așa că sper cu adevărat la criticile, întrebările și comentariile dumneavoastră. Materialul publicat în această serie va fi revizuit constant ținând cont de întrebările, dorințele și comentariile dumneavoastră. Sper că împreună putem duce cu succes acest mic experiment.
Alexandru Ledkov
Idee și arhitectură
Înainte de a trece direct la programare, să ne definim sarcinile și să le descriem în schiță generală viitorul nostru joc. Ideea este simpla: personaj principal se luptă cu hoarde de roboți care vor să-l distrugă. Are trei vieți și un pistol laser. Roboții nu pot trage. Tot ce pot face este să-l prindă pe eroul nostru și să-i smulgă capul... sau altceva. Personajul este controlat folosind două „joystick-uri tactile” în care probabil le-ați văzut jocuri similare. În colțul din stânga jos va exista un joystick responsabil cu mutarea eroului. În colțul din dreapta jos - pentru armă.
Să simulăm o situație de joc. Personajul nostru este în centrul ecranului. Roboții se apropie de el la fiecare 1/10 de secundă. La fiecare zece secundă verificăm și dacă ecranul a fost atins. Dacă se întâmplă acest lucru, ne mișcăm personajul în direcția dorită sau tragem o lovitură. dacă focul este tras, la fiecare bifă (1/10 de secundă) verificăm ciocnirea glonțului cu inamicii. Dacă glonțul lovește robotul, atunci atât robotul, cât și glonțul explodează; dacă nu, roboții și glonțul se mută în noi poziții (robotul se mișcă cu 5 pixeli pe bifă, iar glonțul se mișcă cu 50 de pixeli). De asemenea, verificăm dacă robotul ne-a prins eroul. Dacă este prins, jocul se termină.
În cel mai simplu caz, arhitectura jocului poate fi reprezentată sub forma următoarelor module, care se numesc ciclic:
- Modul de control. Aici se citesc coordonatele atingerii ecranului.
- Motor de joc. Aici trebuie să actualizăm starea obiectelor de joc, adică să calculăm noile lor coordonate, să verificăm sănătatea, coliziunile și altele asemenea.
- Modul audio.
- Modul grafic. Aici pe baza starea curenta se formează un nou cadru și se afișează pe ecran.
Să aruncăm o privire mai atentă la modulele noastre.
Modul de control
În jocul nostru, mesajele sunt generate atunci când utilizatorul atinge două zone de pe ecran. Programul monitorizează evenimentele onTouch și înregistrează coordonatele fiecărei atingeri. Dacă coordonatele sunt în interiorul zonei de control, trimitem comanda corespunzătoare motorului de joc. De exemplu, dacă există o atingere pe partea laterală a cercului, trebuie să ne mișcăm personajul în direcția corespunzătoare. Dacă cercul care controlează arma este atins, trimitem o comandă motorului pentru a procesa evenimentul de împușcare.
Motor de joc
Modulul logic al jocului este responsabil pentru schimbarea stărilor tuturor personajelor jocului, prin care mă refer la fiecare obiect care are o stare (eroul nostru, roboții, loviturile cu laser). 
Să ne uităm la interacțiunea dintre modulul de control și motorul de joc. Imaginea de mai sus arată cercul controlerului. Un punct verde deschis simbolizează zona de contact. Modulul de control raportează coordonatele tactile motorului de joc (dx și dy - distanțe în pixeli de la centrul cercului). Pe baza acestor coordonate motor de joc calculează direcția și viteza de mișcare a eroului nostru. De exemplu, dacă dx>0, personajul nostru se deplasează la dreapta, dacă dy>0 - în sus.
Modul audio
Acest modul controlează redarea sunetului în funcție de situație de joc. Sunetele pot fi generate de diferite obiecte de joc, dar întrucât numărul de canale de sunet este limitat (numărul de canale de sunet corespunde numărului de fișiere de sunet care pot fi redate simultan), modulul audio trebuie să decidă ce sunete să redă și care nu. . De exemplu, un robot reprezintă un pericol imens pentru eroul nostru, așa că trebuie să atragem atenția jucătorului asupra aspectului său, de exemplu, să pornim sunetul unei sirene și, desigur, trebuie pur și simplu să rostim toate fotografiile personajului nostru.
Modul grafic
Acest modul este responsabil pentru afișarea situației jocului pe ecranul telefonului. În Android, există mai multe moduri de a crea o imagine pe ecran. Puteți desena direct pe pânza primită de la vizualizare sau puteți utiliza un buffer grafic separat și apoi îl transmiteți în vizualizare sau puteți utiliza capacitățile bibliotecii OpenGL. Este util atunci când dezvoltați un joc să măsurați în mod constant FPS - numărul de cadre pe secundă pe care le produce motorul dvs. grafic. O valoare de 30 FPS înseamnă că într-o secundă programul nostru reușește să actualizeze ecranul de 30 de ori. Privind în viitor, voi spune că pentru un dispozitiv mobil 30 FPS este mai mult decât o cifră decentă.
Crearea unui proiect șablon pentru un viitor joc Android
Nu voi descrie procesul în detaliu aici. Instalări Android SDK și Eclipse, voi lăsa pașii elementari pentru crearea unui proiect Android în afara domeniului povestirii. Minciuna pe internet o cantitate mare lecții și articole pe această temă.
Crea proiect nou. În câmpul Nume proiect, introduceți Droidz. Selectați Android 2.2 sau o versiune ulterioară ca platformă țintă. În numele pachetului - " ro.mobilab.gamesample„. Nu uitați să bifați caseta Creare activitate. Pentru numele activității principale, introduceți DroidzActivity.
Deschideți fișierul src/ru.mobilab.gamesample/DroidzActivity.java
import android.app.Activity;
import android.os.Bundle;
clasa publică DroidzActivity extinde activitatea (
/** Apelat când activitatea este creată pentru prima dată. */
@Trece peste
public void onCreate(Bundle savedInstanceState) (
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Metoda onCreate este apelată atunci când se creează o activitate în timpul pornirii aplicației. Această metodă poate fi considerată ca punct de intrare în program. Clasa R.java este generată automat de Eclipse și conține link-uri către resurse. De fiecare dată când schimbați resurse în Eclipse, clasa R este reconstruită.
Bucla principală a jocului
Orice joc trebuie să aibă o buclă care să înregistreze comenzile utilizatorului, să le proceseze, să le schimbe în funcție de starea obiectelor de joc, să afișeze un nou cadru pe ecran și să redă sunet. Am creat deja un proiect simplu pentru Android. Să creăm acum o implementare a buclei de joc.
După cum vă amintiți, în Android totul se întâmplă în interiorul unei activități. Activitatea creează o vizualizare - un obiect în care se întâmplă toată distracția. Prin intermediul acestuia putem obține informații despre atingerile ecranului și aici putem afișa o imagine pe ecran.
Să deschidem fișierul DroidzActivity.java. În constructorul clasei veți vedea linia
SetContentView(R.layout.main);
această linie selectează obiectul View curent pentru Activitate. Să creăm un nou obiect View. Cel mai într-un mod simplu obținerea unei vizualizări - creați-vă propria clasă bazată pe SurfaceView. În clasa noastră, implementăm interfața SurfaceHolder.Callback pentru a accelera accesul la modificările de suprafață, cum ar fi atunci când este distrusă când se schimbă orientarea dispozitivului.
MainGamePanel.java
pachet ru.mobilab.gamesample;
SurfaceHolder.Callback(
super(context);
// Adăugați această clasă ca conține funcția inversă
// apel pentru a interacționa cu evenimente
// face ca GamePanelul să fie focalizat astfel încât să poată gestiona mesajele
setFocusable(true);
}
@Trece peste
}
@Trece peste
}
@Trece peste
}
@Trece peste
}
@Trece peste
}
}
Lista de mai sus arată șablonul de clasă pe care trebuie să-l implementăm. Să aruncăm o privire mai atentă la conținutul constructorului. Linia
GetHolder().addCallback(this);
Setează clasa curentă (MainGamePanel) ca un handler de evenimente pentru suprafață.
SetFocusable (adevărat);
Această linie face clasa noastră concentrabilă. Aceasta înseamnă că poate primi focalizare și, prin urmare, evenimente.
Să creăm un fir în care bucla noastră de joc va fi de fapt implementată. Împărțirea unui joc în mai multe fire paralele este o practică comună în dezvoltarea jocurilor moderne. Să creăm o clasă pentru firul nostru: MainThread.java
Pachetul ru.mobilab.gamesample;
clasa publică MainThread extinde Thread (
//steagul care indică faptul că jocul rulează.
Funcționare booleană privată;
public void setRunning (rulare booleană) (
this.running = alergare;
}
@Trece peste
public void run() (
in timpul alergarii) (
// actualizați starea obiectelor de joc
// afișează grafica pe ecran
}
}
}
După cum puteți vedea, această clasă este mult mai simplă decât cea anterioară. Intern am suprascris metoda run(). Firul rulează atâta timp cât această metodă este executată, așa că am creat o buclă infinită în interiorul lui. Am adăugat o variabilă booleană care rulează, care servește ca indicator pentru ieșirea din buclă. Acum, pentru a termina firul, trebuie doar să schimbați valoarea acestei variabile la false undeva.
După ce am creat clasa de thread, trebuie să o rulăm. Să-l rulăm când se încarcă ecranul. Să schimbăm clasa MainGamePanel
Pachetul ru.mobilab.gamesample;
import android.content.Context;
import android.graphics.Canvas;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
Clasa publică MainGamePanel extinde implementele SurfaceView
SurfaceHolder.Callback(
Fir privat MainThread;
Public MainGamePanel (context context) (
super(context);
getHolder().addCallback(this);
// creează un fir pentru bucla de joc
thread = new MainThread();
SetFocusable (adevărat);
}
@Trece peste
public void surfaceChanged (suport SurfaceHolder, format int, lățime int, înălțime int) (
}
@Trece peste
public void surfaceCreated (suport SurfaceHolder) (
thread.setRunning(true);
thread.start();
}
@Trece peste
suprafață public voidDestroyed (suport Surface Holder) (
//trimite firului de execuție o comandă de închidere și de așteptare
//până când fluxul este închis.
reîncercare booleană = adevărat;
în timp ce (reîncearcă) (
încerca (
thread.join();
reîncercați = fals;
) catch (InterruptedException e) (
// încercând să oprim firul din nou
}
}
}
@Trece peste
public boolean onTouchEvent(eveniment MotionEvent) (
return super.onTouchEvent(eveniment);
}
@Trece peste
void protejat onDraw(Canvas canvas) (
}
}
Am declarat un obiect thread
Fir privat MainThread;
și l-a creat în constructor
Thread = nou MainThread();
în metoda surfaceCreated setăm indicatorul de rulare la true și pornim firul. Până în acest moment, obiectul thread a fost deja creat cu succes și îl putem lansa fără teamă.
Metoda surfaceDestroyed este apelată înainte ca suprafața să fie închisă. Aici nu este suficient să eliminați pur și simplu steagul de rulare. Trebuie să ne asigurăm că fluxul este de fapt închis. Pur și simplu blocăm firul și așteptăm până când moare.
Adăugarea interacțiunii cu ecranul
Pentru a arăta cum să procesăm atingerile în Android, să scriem un mic exemplu. Vom ieși din program când utilizatorul atinge partea de jos a ecranului. Dacă atingerea a avut loc undeva mai sus, vom înregistra pur și simplu coordonatele corespunzătoare. Să adăugăm următoarele linii la clasa MainThread:
Private SurfaceHolder surfaceHolder;
privat MainGamePanel gamePanel;
public MainThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) (
super();
this.surfaceHolder = surfaceHolder;
this.gamePanel = gamePanel;
}
Astfel, am definit variabilele gamePanel și surfaceHolder, luând valorile corespunzătoare din parametrii constructorului. Trebuie să ne amintim aceste valori, astfel încât apoi să putem bloca suprafața în timp ce desenăm, iar acest lucru se poate face numai prin surfaceHolder.
Schimbați linia din clasa MainGamePanel pentru a adăuga parametrii nou declarați la constructor
Thread = new MainThread(getHolder(), this);
Transmitem manerul și panoul curent noului constructor. Acest lucru ne va permite să-l accesăm din thread. În gamePanel vom crea o metodă de actualizare și o vom comuta din flux, dar deocamdată vom lăsa totul așa cum este.
Logare
Mai jos vom scrie cod auxiliar care efectuează înregistrarea - înregistrarea liniilor speciale de depanare cu text care reflectă starea programului nostru într-un fișier special, pe care apoi îl puteți vizualiza și încerca să înțelegeți ce se întâmplă în program. Să adăugăm constanta TAG la clasa MainThread. Fiecare clasă va avea propria sa constantă numită TAG, care va conține numele clasei corespunzătoare. Am folosi cadrul de logare Android pentru a face înregistrarea; în această bibliotecă, fiecare jurnal ar trebui să aibă doi parametri. Primul parametru determină locația din care este scris jurnalul. În aceste scopuri am creat constanta TAG. Al doilea parametru este mesajul real pe care vrem să-l scriem în jurnal. Utilizarea numelor de clasă ca prim parametru este o practică destul de comună printre programatorii Java.
Pentru a vizualiza jurnalele înregistrate în timpul execuției programului, trebuie să selectați meniul
Ferestre -> Afișare vizualizare -> Altele...
și apoi în dialogul deschis
Android -> LogCat
În fereastra care se deschide, puteți nu numai să vizualizați jurnalele, ci și să filtrați și să căutați.
Să revenim la codul nostru. Să facem modificări la MainThread.java
Pachetul ro. mobilab. gamesamp; import android. util. Buturuga ; import android. vedere. SurfaceHolder; clasă publică MainThreadextends Thread( private static String final TAG= MainThread. clasa . getSimpleName() ; private SurfaceHolder surfaceHolder; private MainGamePanel gamePanel; private boolean running; public void setRunning(boolean running) ( this. running= running; ) public MainThread() surfaceHolder, MainGamePanel gamePanel) ( super() ; this. surfaceHolder= surfaceHolder; this. gamePanel= gamePanel; ) @ Ignoră public void run() ( long tickCount= 0L; Log . d(TAG, „Început bucla jocului”) ; while (în rulare) ( tickCount++; // starea jocului va fi actualizată aici // și formează un cadru pentru afișare) Buturuga . d(TAG, "Bucla jocului executată " + tickCount+ " ori" ); ) )
După cum puteți vedea, am definit un TAG și am numit comanda Log în cadrul metodei de rulare, care face o intrare corespunzătoare în fișierul jurnal. Înregistrăm valoarea variabilei tickCount, care este de fapt un contor de bucle de joc și arată de câte ori a fost executată bucla de joc în timp ce programul rulează.
Să mergem la fișierul MainGamePanel.java și să găsim metoda onTouchEvent, care este manipulatorul de atingere a ecranului.
public boolean onTouchEvent(eveniment MotionEvent) ( dacă (eveniment. getAction() == MotionEvent. ACTION_DOWN) ( dacă (eveniment. getY() > getHeight() - 50) ( thread. setRunning(false) ; ((Activitate) getContext( ) ) .finish() ; ) else ( Jurnal . d(TAG, „Coords: x=" + event. getX() + ",y=" + event. getY() ) ; ) ) return super. onTouchEvent(eveniment ) ; )Mai întâi verificăm dacă a avut loc un eveniment de atingere a ecranului (MotionEvent.ACTION_DOWN). Dacă se întâmplă acest lucru, verificăm coordonata y și dacă aceasta se află în partea de jos a ecranului (50 de pixeli de jos), trimitem firului o comandă de terminare (prin setarea variabilei de rulare la false) și apoi apelăm finish( ) pe activitatea principală, care închide întregul nostru program .
Cometariu. Originea sistemului de coordonate al ecranului este în colțul din stânga sus. Axa y este în jos, axa x este dreapta. Lățimea și înălțimea ecranului pot fi obținute folosind metodele getWidth() și respectiv getHeight().
Să schimbăm DroidzActivity.java adăugând comenzi pentru a scrie în jurnal
Pachetul ro. mobilab. gamesamp; import android. aplicația. Activitate; import android. os. Pachet; import android. util. Buturuga ; import android. vedere. Fereastră; import android. vedere. WindowManager; clasă publică DroidzActivityextends Activitatea( /** Apelat când este creată o activitate. */ Private static final String TAG= DroidzActivity. clasă. getSimpleName() ; @Override public void onCreate(Bundle savedInstanceState) ( super. onCreate(savedInstanceState) ; // solicită dezactivarea barei de titlu requestWindowFeature(Fereastra. FEATURE_NO_TITLE) ; // comută aplicația în modul ecran complet getWindow() . setFlags(WindowManager. LayoutParams. FLAG_FULLSCREEN, WindowManager. LayoutParams. FLAG_FULLSCREEN) ; // setați MainGamePanel ca vizualizare setContentView(new MainGamePanel(this)); Buturuga. d(TAG, „Vizualizare adăugată” ); ) @ Override protected void onDestroy() ( Jurnal . d(TAG, „Distrugerea...” ) ; super. onDestroy() ; ) @ Override protected void onStop() ( Jurnal . d(TAG, „Oprire...” ); super. onStop() ; ))
Să lansăm aplicația. După lansare, ar trebui să vedeți un ecran negru. Faceți clic pe partea de sus a ecranului de mai multe ori și apoi pe partea de jos. programul se va închide. Este timpul să verificați jurnalul.
Privind jurnalul, veți obține o idee clară a ordinii în care sunt executate metodele. De asemenea, puteți vedea de câte ori a fost executată bucla de joc în timp ce programul rulează. Această cifră nu înseamnă nimic, data viitoare vom înregistra mai multe Informatii utile: FPS și UPS (actualizări pe secundă).
Rezuma. Am creat o aplicație pe ecran complet. Am scris o clasă care rulează într-un fir separat și va conține motorul de joc. A scris cea mai simplă metodă procesarea atingerilor de ecran și închiderea corectă a aplicației.
Data viitoare vom trece la desen. Codul sursă pentru acest tutorial poate fi descărcat.
Traducere și adaptare: Alexandru Ledkov
Scriem un joc în HTML5/JS
javascript gamedev html5 canvas
Am găsit ceva timp liber în weekend și am decis să exersez dezvoltarea. Am vrut să scriu un fel de jucărie de mult timp, dar nu m-am înțeles niciodată.
Cum să creați singur un joc pe Android de la zero
Am răsfoit rapid pe internet în căutarea modului în care o fac guru adevărați. Mi-a placut acest articol. Am luat cadrul autorului articolului ca bază pentru viitorul meu joc.
start
- - biblioteca pentru lucrul cu sprites
- — încărcarea resurselor
- - biblioteca de introducere a tastaturii
- - fișierul jocului principal
Pentru o animație lină vom folosi. Puteți afla mai multe despre el aici
Să împărțim dezvoltarea jocului nostru în mai multe etape:
- Crearea și inițializarea unei pânze pe o pagină
- Adăugarea unei funcții de buclă principală a jocului
- Gestionarea evenimentelor de intrare de utilizator
- Matematică și calculul ciocnirilor de obiecte în joc
Etapa 1: Crearea și inițializarea pânzei
Primul lucru pe care trebuie să-l facem este să creăm un element și să-l adăugăm la eticheta paginii principale a jocului.
- Creați un obiect
- Indicăm că creăm un joc 2D (vom folosi obiectul peste tot în cod)
- Setarea dimensiunilor pânzei
- Adăugarea unei pânze la o etichetă de pe pagină
Etapa 2. Adăugarea unei funcții de buclă principală
Bucla principală este necesară pentru a actualiza și a reda jocul.
Aici numim funcția requestAnimFrame (din păcate, nu este acceptată în toate browserele), care generează 60 de cadre/secundă (cum este descris mai sus).
Etapa 3. Inițializarea și redarea obiectelor și resurselor de joc
Îl folosim pentru a încărca resurse în joc. Bună regulă este să adaugi toate imaginile într-un sprite, dar din moment ce nu l-am desenat eu, ci am luat poze gata făcute, așa că am decis să nu mă deranjez cu asta, mai ales că în acest caz, nu este atât de critic. Așa arată în cod
În funcția încărcăm lumea și adăugăm un handler de butoane, după terminarea jocului.
Stare initiala
Actualizare starea jocului
Conform ideii noastre, păianjenii ar trebui să se târască din toate cele 4 părți ale terenului de joc. Pentru a face acest lucru să se întâmple aleatoriu, folosim funcția getRandomInt.
O folosim aici. Întreaga funcție poate fi vizualizată în codul sursă.
Pasul 4: Gestionarea evenimentelor introduse de utilizator
Eroul nostru trebuie să fie capabil să se miște în sus, în jos, la stânga, la dreapta. În consecință, vă ofer mai jos implementarea acestei soluții
Când dați clic pe bara de spațiu, ideea este să plasați turnuri care vor trage aleatoriu în toate direcțiile. Pentru a face procesul de joc puțin mai dificil, turnurile pot fi plasate la o anumită distanță unul de celălalt. În acest caz este.
Etapa 5. Matematică și calculul ciocnirilor de obiecte din joc
Animația personajelor, matematica mișcării glonțurilor și logica mișcării NPC în joc sunt descrise în funcție. Aici avem nevoie de cunoștințe de bază despre algebra liniară.
Logica pentru actualizarea animațiilor de sprite turn. Și creăm cartușe pentru fiecare turn din matricea noastră.
Dinamica gloanțelor turelei:
Permiteți-mi să vă reamintesc că scopul nostru a fost ca turnurile să tragă la întâmplare în toate direcțiile.
Am înzestrat păianjenii cu inteligență simplă și, prin urmare, se târăsc mereu după noi ca să ne muște.
Codul complet al funcției poate fi vizualizat în sursă pe GitHub.
Matematica calculării coliziunilor este bine descrisă în articolul autorului (secțiunea Collision Detection) al bootstrap-ului 2d pe care îl folosesc.
Etapa 6. Game Over și reporniți
Când păianjenii se târăsc la eroul nostru, vine sfârșitul jocului.
Afișează fereastra GAME OVER și butonul „Începe din nou”. Faceți clic pe el și totul începe de la capăt :)
Concluzie
Drept urmare, mi-am dat seama că există multe avantaje:
- Să aveți un timp distractiv și interesant
- Îți repeți cursul de geometrie de la școală. Dacă jocul este mai serios, atunci îți amintești de facultate :)
- Practica de programare a jocurilor
- Satisfacția cu munca depusă
Puteți vizualiza sursa aici și puteți juca aici.
Dezvoltare tipică a jocului
Crearea de jocuri este o activitate distractivă pentru un programator. Dar toate jocurile urmează un scenariu comun. Există mai multe ecrane pentru interacțiunea utilizatorului:
Ecran de prezentare Ecran de prezentare care prezintă sigla companiei, scene din joc, versiune etc. Apare pentru câteva secunde și apoi dispare. Muzica de fundal poate fi redată Meniu Al doilea ecran, unde utilizatorul poate naviga prin elementele de meniu, de exemplu, Redare, Cont, Setări, Ajutor Ecran principal Aici are loc acțiunea reală procesul de joc Setări Ecran Setări joc Fereastra de scor care poate fi accesată din meniu. Aici puteți afișa statistici privind realizările și un tabel cu înregistrări. Ajutor Afișează instrucțiuni pentru joc: descriere, comenzi, sfaturi
Acest exemplu tipic joc standard. Desigur, puteți refuza unele ecrane sau, dimpotrivă, puteți adăuga mai multe, dar în general imaginea este clară. Astfel, trebuie să implementăm șase activități:
- SplashActivity - activitate implicită. Afișat pentru câteva secunde. După aceasta, ar trebui să fie afișată activitatea MenuActivity
- MenuActivity - conține butoane, imagini și alte elemente care pot fi folosite pentru a lansa alte activități
- GameActivity este ecranul principal al jocului, unde sunt afișate grafice, sunt calculate puncte etc.
- SettingsActivity - salvați diferite setări pentru joc
- ScoresActivity - încarcă date despre realizările jucătorilor și le afișează pentru ca utilizatorul să le vadă
- HelpActivity - afișează informații generale. Dacă textul este mare, atunci trebuie să oferiți și defilarea
Fiecare clasă de activitate trebuie să aibă propriul fișier de marcare cu propriul set de elemente. Sarcina ta este să înveți cum să gestionezi starea aplicației, să folosești setările și să lansezi activitățile necesare.
De asemenea, este convenabil să creați o altă clasă de activitate de bază cu componente publice, cum ar fi BaseActivity.
Contextul aplicației
Contextul aplicației este baza pentru funcționarea oricărei aplicații, inclusiv a jocurilor. Este folosit pentru a obține acces la setările și resursele utilizate de mai multe instanțe de activitate.
Puteți accesa contextul de aplicare al procesului curent prin metoda getApplicationContext():
Deoarece clasa Activitate provine din clasa Context, puteți utiliza cuvânt cheie aceasta în loc să specifice în mod explicit contextul aplicației.
După ce ați înțeles funcționalitatea viitorului joc, puteți începe să îl implementați.
Știm că clasa Activitate este clasa principală a oricărei aplicații Android. Aceasta înseamnă că vom avea nevoie de cinci clase de activitate diferite pentru scopul nostru. În timpul jocului, utilizatorul va trece de la o activitate la alta (cu excepția primei activități, unde va fi asigurată tranziția automată).
Există mai multe opțiuni pentru lansarea activităților
- Printr-o indicație în fișierul manifest, așa se lansează activitatea implicit. În cazul nostru, acesta este un screensaver Splash
- Utilizarea contextului aplicației folosind startActivity
- Lansarea unei activități pentru copil dintr-o activitate de părinte
Ecran splash
Ecranul în sine ar trebui să apară pentru câteva secunde. De obicei, pe el sunt plasate o imagine, numele jocului, numărul versiunii, autorul etc. În unele cazuri, este indicat să folosiți o animație mică.
Meniul jocului
Ecranul meniului jocului este folosit pentru a naviga prin diferitele ecrane de joc.
Dezvoltare tipică a jocului
Meniul apare imediat după ecranul de introducere și oferă utilizatorului o alegere de acțiuni suplimentare - mergeți direct la joc, citiți instrucțiunile, vizualizați tabelul de înregistrare și așa mai departe.
Ecran de ajutor
Pe acest ecran utilizatorul se poate familiariza cu regulile jocului. Prin urmare, trebuie să afișați aici un text de ajutor care poate fi derulat.
Scor sau tabel de înregistrări
În tabelul de înregistrări, utilizatorul poate vedea contul curent de joc cu o listă a jucătorilor care au câștigat cel mai mare număr puncte. Cu alte cuvinte, aici sunt afișate statisticile cu cele mai bune realizări ale jocurilor sau scorul curent.
Ecran de setări
Pe acest ecran, utilizatorul poate edita și salva diverse setări, cum ar fi numele sau avatarul.
Ecranul principal
Aici are loc acțiunea principală a jocului. Dacă jocul este finalizat, atunci trebuie să accesați ecranul tabelului cu scoruri mari pentru a vedea rezultatul jocului.
Implementarea unui prototip de aplicație
Să creăm un nou proiect cu activitatea SplashActivity, care va fi numit mai întâi. În continuare trebuie să creăm fișiere de aspect pentru fiecare activitate. Deoarece ecranul de introducere va fi apelat primul, redenumiți fișierul main.xml în splash.xml. Apoi puteți face cinci copii ale splash.xml și le puteți da nume noi: game.xml, help.xml, menu.xml, scores.xml și settings.xml.
Acum deschideți fiecare fișier de marcare și schimbați linia android:text="@string/hello" pe android:text="@string/splash"și așa mai departe.
După această operațiune nu veți fi confuz în ecrane.
Puteți să vă ocupați imediat de o nouă pictogramă pentru joc și să o adăugați în folderul /drawable.
Am convenit deja că vom avea o clasă principală, BaseActivity. Creați un fișier de clasă BaseActivity.java și inserați codul minim:
Reveniți la fișierul SplashActivity.java și extindeți-l din clasa BaseActivity în loc de clasa Activitate.
Copiați SplashActivity și creați noi clase MenuActivity, HelpActivity, ScoresActivity, SettingsActivity și GameActivity.
În fiecare clasă creată trebuie să înlocuiți în linie setContentView(R.layout.splash); resursă de aspect la cea corespunzătoare, de exemplu pentru ecranul de setări, aceasta va fi R.setări.aspect.
Pentru a verifica, puteți rula proiectul pe un emulator. Dacă totul este făcut corect, ecranul Splash va apărea în fereastra emulatorului, care conține textul Splash Screen.
Crearea unui ecran Splash
Sarcina noastră este să creăm un ecran care va dispărea de la sine după o scurtă pauză. Pentru joc, puteți folosi un screensaver animat, precum și să afișați informații despre versiune, dezvoltator etc. Permiteți-mi să vă reamintesc că pentru aspectul ecranului de introducere utilizăm fișierul splash.xml din folderul de aspect.
După animație, trebuie să lansați un nou ecran cu meniul și să închideți ecranul curent.
Publicitate
Acest articol a fost plătit de pisici - producători de pisoi de renume mondial.
Dacă ți-a plăcut articolul, poți susține proiectul.
Cum se creează un joc pe Android?
Crearea unui joc pentru oricine sistem de operare necesită cunoștințe de programare. Chiar și jocurile simple precum Flappy Bird necesită să cunoașteți elementele de bază. Să vedem cum este creat un joc folosind sistemul de operare Android ca exemplu.
Motor
Primul pas în scrierea unui joc este instalarea motorului. Există multe motoare pe web scrise în diverse limbi programare. Desigur, motoarele plătite au mai multe funcții, sunt mai stabile și oferă oportunități mai mari. Cu toate acestea, costul lor poate fi foarte mare. Prin urmare, vom lua ca exemplu motorul gratuit LibGDX.
Acest motor are destul de multe capacități și are instrucțiuni de utilizare în limba rusă. Motorul este multi-platformă și, prin urmare, un joc scris pe el poate fi instalat pe alte platforme.
Mediu de programare
De asemenea foarte punct important este utilizarea unui mediu de programare. Acest termen se referă la instrumentul în care va fi scris jocul. În cazul motorului LibGDX, mediul de programare va fi Exlipce. Din moment ce motorul jocului a fost scris programare java, apoi, pentru a utiliza mediul de programare, va trebui să utilizați abilitățile și cunoștințele de bază de programare în acest limbaj special. Deci, dacă nu cunoașteți elementele de bază, va trebui să le învățați.
Crearea unui proiect
Pentru a scrie un joc pe Android, ca pe orice altă platformă, trebuie mai întâi să creați un proiect. Acest lucru nu este greu de făcut. În cazul LibGDX, pentru a face acest lucru, trebuie doar să despachetați motorul într-un folder și să găsiți fișierul cu același nume în el. În continuare, va trebui să faceți clic pe butonul „Creați un proiect” și veți fi deja la un pas de a crea un proiect. Apoi trebuie doar să selectați platforma pentru joc și să indicați numele proiectului. În configurație trebuie să indicați unde va fi amplasat jocul în mediul de programare. Motorul va crea proiectul în sine și vă va spune dacă ați greșit ceva. Apoi, puteți merge la mediul de programare și puteți începe să scrieți un joc.
După cum puteți vedea, crearea unui joc pentru Android sau orice alt sistem de operare este pur și simplu imposibilă fără cunoștințele de bază ale limbajelor de programare. Cu toate acestea, acum motoarele devin mai bune și mai convenabile chiar și pentru cei care abia își încep călătoria în această afacere. Un exemplu de astfel de motor este Game Maker. Puteți citi despre acest motor și despre crearea unui joc pe el în articol.
