Scrierea unor jocuri simple în C. De ce scriu jocuri în C (da, C). Ce trebuie sa stii
Joc 2D scris în JavaScript ES6 HTML5, 17 nivele.
Postat de: xAtom | JavaScript | Orice sistem de operare
Jocul este 2D, scris în WinAPI, în mediul CodeBlocks 17.12 (unicode) în C++14.
Postat de: xAtom | Visual C++ | Windows NT/2000/XP/Vista/7
tic tac toe cu gust))
Veți vedea singur, asigurați-vă că citiți fișierul txt
Ilyosiddin_kalandar@mail.ru
pentru orice intrebare
Postat de: kalandar | C/C++ | Windows NT/2000/XP/Vista/7
Un exemplu de grafică Raycast simplă cu capacitatea de a se deplasa pe hartă și de a roti camera, în limbaj de asamblare, compilatorul FASM funcționează în mod real. Se folosește modul video 13h BIOS 320x200, 256 culori.
Sunt folosite întreruperile BIOS
- INT 10h
- INT 16h
Capabilitati shell grafic:
- Umplerea ecranului
- Desenarea sprite-urilor
- Desen dreptunghiuri (linii simple)
Caracteristicile shell-ului grafic
- Greutate ușoară, simplitate
- Utilizarea buffer-ului video pentru a crea un cadru
În această versiune, puteți roti camera, scena este desenată prin aruncarea unui fascicul, cu cât fasciculul este mai lung, cu cât obstacolul este mai departe, cu atât este mai departe, cu atât este mai mic.
Avantajele acestei surse:
- Raycast aproape complet funcțional
- Posibilitate de rotire a camerei
- Abilitatea de a se deplasa în spațiu.
Minusuri:
- Performanța scăzută necesită optimizare
Sursa jocului (sursa):
http://catcut.net/CAPB
Canalul canalului YouTube:
https://www.youtube.com/TypeProgrammer
Site-ul proiectului:
http://neosoft.pp.ua
Postat de: Tip Programator | Asamblator | Orice sistem de operare
Sursele programului pentru setarea parametrilor jocului IL-2. Limbajul de programare VB6. Arhiva conține toate fișierele și resursele necesare, inclusiv bibliotecile de plug-in.
Postat de: Alik044 | Visual Basic | Windows NT/2000/XP/Vista/7
Un joc cu unele dezamăgiri de la echipa Gravity Games, jocul nu este foarte bun, este totul cu probleme. În această cursă 2D există daune la mașini, turbo etc. Jocul a fost creat pe Construct 2.
Postat de: admins | document | Orice sistem de operare
Joc 2D Crawler robot, joc pe 12 niveluri creat în mediul Eclipse pentru Android.
Postat de: xAtom | Java | Alt sistem de operare
Automatul celular, sau jocul „vieții” în asamblare, compilator FASM, funcționează în modul real. Se folosește modul video 13h BIOS 320x200, 256 culori. Acest cod rulează pe bare metal în modul real.
http://catcut.net/tihx
http://catcut.net/7Nqw
vitaliynovak555@gmail.com
Site-ul proiectului:
http://neosoft.pp.ua
Postat de: Tip Programator | Asamblator | Orice sistem de operare
Un șablon pentru crearea unui joc de dame în assembler, compilatorul FASM, funcționează în modul real. Se folosește modul video 13h BIOS 320x200, 256 culori.
În acest cod sursă nu există condiții pentru victorie, înfrângere și nici regi.
Pentru condus:
W,S,D,A - Deplasarea pe terenul de joc.
Enter - Selectați o verificare, apoi reveniți la celula unde ar trebui să meargă.
Sursa poate fi descărcată de aici:
http://catcut.net/5ZGy
Există, de asemenea, un canal de proiect în care uneori apar videoclipuri și surse de programe noi:
https://www.youtube.com/channel/UCTVn_Azy0WTDGAh7OYNReJg?view_as=subscriber
Și da, canalul are propriul server cu coduri sursă, unde sursele sunt mai ales în assembler (aproape toate gunoi), dar și în C++, un sistem de operare în C și un program în Pascal:
http://catcut.net/7Nqw
Dacă doriți să adăugați sursa pe server, scrieți-mi pe e-mail:
vitaliynovak555@gmail.com
(Da, anonimatul nu este treaba mea...)
Site-ul proiectului:
http://neosoft.pp.ua
Postat de: Tip Programator | Asamblator | Orice sistem de operare
Joc 2D Ball Adventure, 25 de nivele. Pentru Android, jocul a fost creat folosind Eclipse.
Postat de: xAtom | Java | Alt sistem de operare
Într-un joc simplu pentru doi, persoana care trage ultimul meci va pierde.
(Jocul este simplu, dar avantajul este că poate fi lansat fără un sistem de operare)
Sursa poate fi descărcată de aici:
http://catcut.net/YMqw
Există, de asemenea, un canal de proiect în care uneori apar videoclipuri și surse de programe noi:
https://www.youtube.com/channel/UCTVn_Azy0WTDGAh7OYNReJg?view_as=subscriber
Și da, canalul are propriul server cu coduri sursă, unde sursele sunt mai ales în assembler (aproape toate gunoi), dar și în C++, un sistem de operare în C și un program în Pascal:
http://catcut.net/7Nqw
Dacă doriți să adăugați sursa pe server, scrieți-mi pe e-mail:
vitaliynovak555@gmail.com
(Da, anonimatul nu este treaba mea...)
Postat de: Tip Programator | Asamblator | Alt sistem de operare
Un joc simplu în limbaj de asamblare, compilator FASM, care rulează în modul real. Se folosește modul video 13h BIOS 320x200, 256 culori. Ciocnire primitivă în lățime și înălțime.
Esența jocului este să împiedici cometele să intre în nava ta, pentru a face acest lucru nu poți decât să te deplasezi la stânga sau la dreapta, până la cadre, în timp jocul se accelerează, jocul continuă până când jucătorul pierde.
Sursa poate fi descărcată de aici:
http://catcut.net/KMqw
Există, de asemenea, un canal de proiect în care uneori apar videoclipuri și surse de programe noi:
https://www.youtube.com/channel/UCTVn_Azy0WTDGAh7OYNReJg?view_as=subscriber
Și da, canalul are propriul server cu coduri sursă, unde sursele sunt mai ales în assembler (aproape toate gunoi), dar și în C++, un sistem de operare în C și un program în Pascal:
http://catcut.net/7Nqw
Dacă doriți să adăugați sursa pe server, scrieți-mi pe e-mail:
vitaliynovak555@gmail.com
(Da, anonimatul nu este treaba mea...)
Jocurile pe calculator sunt afaceri mari. Veniturile totale din industria jocurilor video din SUA au atins anul trecut 23,5 miliarde de dolari, în creștere cu 5% față de 2014. În spatele fiecărui joc grozav se află programatori care aduc contribuții semnificative la produsul final. Desigur, diferite limbaje de programare sunt folosite pentru a crea jocuri diferite. În acest articol vă vom prezenta câteva dintre cele mai populare.
limbaj de asamblare
Multe jocuri Sega și Dendy au fost scrise în diferite dialecte în limbaj de asamblare, inclusiv Super Mario Brothers.
Jocurile Super Mario s-au vândut în peste 70 de milioane de exemplare. IGN a numit a treia parte a Super Mario Brothers cel mai tare joc din toate timpurile.
limbajul C
Limbajul C rămâne unul dintre cele mai populare limbaje de programare datorită simplității sale relative și structurii clare. id Software a folosit C pentru a crea jocul Doom, lansat pentru prima dată în 1993.
Doom a fost numit cel mai influent joc FPS, devenind prototipul pentru multe alte jocuri la persoana întâi și jocuri 3D în general. Se estimează că Doom a avut aproximativ 10 milioane de instalări în 1995.
C++
Limbajul C++ a fost folosit pentru a crea multe sisteme de operare moderne, software, jocuri și motoare de jocuri. Datorită flexibilității sale, jocurile pot fi portate de pe PC pe consolă și invers, cu relativă ușurință. Unul dintre cele mai populare jocuri scrise în C++ este World of Warcraft.
S-a vândut în 14 milioane de exemplare de la lansare. 48% dintre abonați locuiesc în regiunea asiatică, 22% din SUA. Wiki WoW conține peste 100.000 de articole.
C#
Dezvoltat de Microsoft în 2000, C# a devenit destul de popular printre dezvoltatorii de jocuri. Motorul Unity, utilizat pe scară largă pentru a crea jocuri pentru computere, console și dispozitive mobile, este scris în principal în C#. Unul dintre cele mai notabile jocuri din această clasă este Angry Birds.
Angry Birds este al treilea cel mai popular joc iOS din toate timpurile, chiar după Candy Crush Saga și Fruit Ninja. Costul dezvoltării primei versiuni a jocului a fost de aproximativ 140.000 USD, care este un număr foarte modest de acest gen. Patru oameni au lucrat la joc timp de aproximativ opt luni.
Java
Java este oarecum o rudă cu C#. Sunt influențați unul de celălalt, ambele au colectoare de gunoi și sunt orientate pe obiecte. Dar Java este poziționat inițial ca un limbaj independent de platformă, ceea ce înseamnă că (prin proiectare) funcționează exact la fel pe toate dispozitivele. Poveștile despre jocurile de succes scrise în Java includ RuneScape și Minecraft.
Versiunea alfa a jocului a fost creată în doar 6 zile. Minecraft este al doilea cel mai bine vândut joc din lume. Inițial a fost numit „Cave Game”.
Doriți să găsiți mai multe resurse de dezvoltare a jocurilor și poate chiar să dezvoltați una dintre ele? Aruncăm o privire la.
Sunt încă un fruct. Toate proiectele mele personale de jocuri în care am fost implicat în ultima vreme au fost scrise în „vanilie” C. Nimeni altcineva nu face asta, așa că cred că s-ar putea să fiți interesat să știți de ce am făcut această alegere.
Ceea ce urmează conține opinii despre limbaje de programare care s-ar putea să nu vă placă. am avertizat.
Ce am nevoie de la limba mea?
Unele cerințe nu fac obiectul discuțiilor sau compromisurilor. În primul rând, limbajul trebuie să fie de încredere. Nu-mi permit să-mi pierd timpul căutând greșeli pe care nu le-am făcut.Am scris multe jocuri în Flash, apoi Flash a murit. Nu vreau să pierd timpul portând jocuri vechi pe platforme moderne, vreau să scriu jocuri noi. Am nevoie de o platformă care să fiu sigur că va dura.
Ceea ce vreau cu siguranță este să evit dependența de un anumit sistem de operare. În mod ideal, ar fi posibil să se dezvolte și pentru console. Prin urmare, este important ca limbajul să permită portarea ușoară a ceea ce este scris în el și, de asemenea, să aibă un suport bun pentru bibliotecile multiplatforme.
Ce vreau de la o limbă?
Cea mai importantă, dar nu obligatorie, cerință este simplitatea. Mi se pare incredibil de plictisitor să studiez caracteristicile limbajului și minunatul său API „inteligent”. Puteți învăța o limbă ideală o dată și nu mai folosiți niciodată documentația acesteia.Găsirea și remedierea erorilor epuizează creativitatea. Vreau să las mai puține erori, așa că vreau tastare puternică, mesaje de eroare de înaltă calitate și analiză statică a codului. Vreau să facilitez găsirea erorilor și, prin urmare, instrumente bune de depanare și analiză dinamică.
Nu mă interesează o imagine frumoasă și realistă, dar îmi pasă de performanță. Mai puține cerințe de resurse extind gama de posibilități disponibile pentru implementare. Este deosebit de interesant de observat ce se întâmplă cu computerele moderne puternice atunci când dezvoltatorul nu se gândește la performanță.
Sunt și mai îngrijorat de viteza compilatorului. Nu sunt un maestru budist al concentrării, iar așteptarea mai mult de 10 secunde este o risipă. Mai rău, te scoate din flux. Se pare că tocmai m-am uitat pe Twitter și 5 minute au dispărut undeva.
Nu sunt un urmăritor OOP. Majoritatea timpului mi-am petrecut lucrând cu clase și obiecte. Dar cu cât merg mai departe, cu atât înțeleg mai puțin de ce este necesar să combin codul și datele atât de strict. Vreau să lucrez cu date ca date și să scriu cod care funcționează cel mai bine pentru o anumită situație.
Alternative
C++ continuă să fie cel mai comun limbaj pentru dezvoltarea jocurilor și din motive întemeiate. Până acum, majoritatea proiectelor mele personalizate sunt scrise în el și nu îmi place.C++ îmi acoperă nevoile, dar nu îmi satisface dorințele. Este extrem de complex. În ciuda disponibilității instrumentelor adecvate, este ușor să faci greșeli insidioase. De asemenea, în comparație cu C, se compilează lent. C++ are performanțe înalte și oferă caracteristici pe care C nu le are, dar nu asta îmi doresc și vine cu prețul multor complexități.
C# și Java au probleme similare. Aceștia sunt monștri proliști și complexi, dar am nevoie de un animal mic și simplu. Ambele limbi trimit programatorul direct în abisul OOP, iar eu sunt împotrivă. Ca și în cazul majorității limbilor de nivel înalt, multe dintre lucrurile complexe sunt ascunse, astfel încât să nu vă împușcați accidental în picior.
Îmi place foarte mult Go. În multe privințe, este un C reinventat, deși unul care a fost în pregătire cu câțiva ani înainte de a fi lansat publicului. Aș dori să folosesc Go, dar există o capcană uriașă - colectarea gunoiului. Dezvoltarea jocului în Go este discutabilă, deoarece colectorul de gunoi va întrerupe întreaga lume a jocului, ceea ce dezvoltatorul nu și-o poate permite. De asemenea, totul nu este foarte bine aici cu bibliotecile de jocuri. Și deși puteți adapta oricând o bibliotecă C pentru această sarcină și fără probleme, aceasta generează totuși multă muncă inutilă. În plus, am îndoieli cu privire la perspective. Go ar fi grozav pentru web, dar este un mediu în schimbare rapidă. Acest lucru s-a simțit mai ales odată cu moartea lui Flash.
Nu-mi place deloc JavaScript. Oferă atât de multă libertate încât nu înțeleg cum reușesc oamenii să scrie proiecte complexe pe el. Și nici nu vreau să-l încerc.
Haxe pare mult mai promițător decât alte limbi de pe această listă. Nu are probleme cu bibliotecile. Dacă încep să scriu din nou pentru web, cu siguranță voi ajunge să-l cunosc mai bine. Relativa tinerețe a limbii este oarecum îngrijorătoare: va supraviețui? Nu mai am nimic de adăugat, am reușit doar să mă joc puțin cu Haxe, fără să merg mai adânc.
Jonathan Blow își scrie propria limbă. Limba pe care el însuși ar dori să o folosească. Îi admir decizia și, uneori, eu însumi sunt entuziasmat de ideea de a face același lucru. Dar nu aruncați toate bibliotecile existente. Dar obținerea compatibilității deplină cu ele nu este atât de ușoară. Și, în general, este dificil, aș prefera să continui să scriu jocuri decât limbaje de programare.
De ce C este cea mai bună alegere pentru mine
Deși C este periculos, este de încredere. Acesta este un cuțit foarte ascuțit care poate tăia degetele la fel de ușor ca tăierea legumelor. Dar este simplu și să înveți cum să-l folosești corect nu va fi dificil.Bună e rapid. Și când vine vorba de compilare, nu îmi imaginez că vreo limbă poate să o facă mai rapid.
Este posibil să scrieți cod, astfel încât să funcționeze peste tot. Și de obicei este relativ ușor. Este greu de imaginat că într-o zi asta se va schimba.
Există un suport excelent pentru biblioteci și instrumente.
Deși mă întristează puțin, C este totuși cel mai bun limbaj pentru mine.
Nu prea vreau să spun ceva de genul „Hei, ar trebui să scrii și tu C”. Îmi dau seama că preferințele mele sunt foarte specifice. În plus, în ceea ce privește cantitatea de cod pe care am scris-o în diferite limbi, codul C „vanilat” ocupă o poziție de lider, așa că acesta face deja parte din zona mea de confort.
Deci da, C este cea mai bună alegere pentru mine.
De la traducător
Traducerea este destul de liberă pe alocuri, dar nu în detrimentul sensului sau al conținutului.Traducerea am pregătit-o special pentru vineri, în această zi este deosebit de potrivită, după părerea mea. Deși autorul textului original pare să scrie cu toată seriozitatea... tu însuți înțelegi totul dacă îl citești. Ceea ce citești nu trebuie luat drept adevăr.
Cu sugestii, urări și comentarii, ca de obicei, în PM.
Bună, Habrahabr!
Nu există multe lecții despre crearea de jocuri pe Habré, de ce să nu sprijini dezvoltatorii autohtoni?
Vă prezint lecțiile mele care vă învață cum să creați jocuri în C++ folosind SDL!
Ce trebuie sa stii
- Cel puțin cunoștințe de bază de C++ (vom folosi Visual Studio)
- Răbdare
Despre ce este această parte?
- Vom crea un cadru pentru toate jocurile, vom folosi SDL ca renderer. Aceasta este o bibliotecă grafică.
Vor fi mai multe acțiuni în postările următoare, aceasta este doar o pregătire :)
De ce SDL?
Am ales această bibliotecă ca fiind cea mai ușor și mai rapid de învățat. Într-adevăr, va trece mult timp de la primul articol pe OpenGL sau DirectX pe care l-ați citit și până la a suta de mii de relansare a șarpelui.Acum poți începe.
1.1. Începutul timpului
Descărcați SDL de pe site-ul oficial.Creăm un proiect Win32 în Visual Studio, conectăm biblioteci SDL și include (dacă nu știi cum să faci asta, atunci Google te poate ajuta!)
De asemenea, trebuie să utilizați o codificare de caractere pe mai mulți octeți. Pentru a face acest lucru, accesați Project->Properties->Configuration Properties->Character Set->Use multibyte encoding.
Creați fișierul main.cpp
#include
Deocamdată nu face nimic.
Regele și zeul cadrului - Clasa de joc
Joc.h
#ifndef _GAME_H_ #define _GAME_H_ clasa Joc (privat: bool run; public: Game(); int Execute(); void Exit(); ); #endif
Joc.cpp
#include "Game.h" Game::Game() ( run = true; ) int Game::Execute() ( while(run); return 0; ) void Game::Exit() (run = false; )
Creăm fișierul Project.h, ne va fi foarte util pe viitor
#ifndef _PROJECT_H_ #define _PROJECT_H_ #include
Schimbarea main.cpp
#include "Project.h" int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int) ( Joc joc; returnare joc.Execute(); )
Este puțin mai bine, dar cumva nu este gros.
1.2. Arte grafice
Creăm până la 2 clase - Grafică pentru desenarea grafică și Imagine pentru desenarea imaginilorGrafică.h
#ifndef _GRAPHICS_H_ #define _GRAPHICS_H_ #include „Project.h” #include „Image.h” clasa Imagine; clasa Graphics (privat: SDL_Surface* Screen; public: Graphics(int width, int high); Image* NewImage(char* file); Image* NewImage(char* file, int r, int g, int b); bool DrawImage( Imagine* img, int x, int y); bool DrawImage(Imagine* img, int x, int y, int startX, int endX, int endY); #endif
Imagine.h
#ifndef _IMAGE_H #define _IMAGE_H #include imaginea clasei "Project.h" ( private: SDL_Surface* surf; public: friend class Graphics; int GetWidth(); int GetHeight(); ); #endif
Schimbarea proiectului.h
#ifndef _PROJECT_H_ #define _PROJECT_H_ #pragma comment(lib,"SDL.lib") #include
SDL_Surface - o clasă din SDL pentru stocarea informațiilor despre o imagine
Luați în considerare grafica
NewImage - există 2 opțiuni pentru încărcarea unei imagini. Prima opțiune pur și simplu încarcă imaginea, iar a doua după aceasta oferă și transparență imaginii. Dacă avem un fundal roșu în imagine, atunci introduceți r=255,g=0,b=0
DrawImage - de asemenea 2 opțiuni pentru desenarea unei imagini. Primul desenează întreaga imagine, al doilea desenează doar o parte din imagine. startX, startY - coordonatele începutului unei părți a imaginii. endX, endY - coordonatele finale ale unei părți a imaginii. Această metodă de desen este utilizată dacă se folosesc atlasuri de imagini. Iată un exemplu de atlas:
(imagine preluată de pe resursa web interesnoe.info)
Luați în considerare imaginea
Pur și simplu își menține suprafața și oferă acces membrilor săi privați la clasa Graphics și schimbă suprafața.
În esență, acesta este un wrapper peste SDL_Surface. Oferă și dimensiunea imaginii
Grafică.cpp
#include „Graphics.h” Graphics::Graphics(int width, int height) ( SDL_Init(SDL_INIT_EVERYTHING); Ecran = SDL_SetVideoMode(width,height,32,SDL_HWSURFACE|SDL_DOUBLEBUF); ) Imagine* Graphics::NewImage(char* file) ) ( Imagine* imagine = imagine nouă(); imagine->surf = SDL_DisplayFormat(SDL_LoadBMP(fișier)); imagine returnată; ) Imagine* Graphics::NewImage(char* file, int r, int g, int b) ( Imagine * imagine = new Image(); imagine->surf = SDL_DisplayFormat(SDL_LoadBMP(file)); returnează imaginea; ) bool Graphics::DrawImage(Imagine* img, int x, int y) ( if(Screen == NULL || img->surf == NULL) return false; SDL_Rect Area; Area.x = x; .y = y; SDL_BlitSurface(img->surf, NULL, Screen, &Area bool Graphics::DrawImage(Imagine* img, int startX, int endX, int endY ) ( if(Screen == NULL || img->surf == NULL) SDL_Rect Area.x = y SDL_Rect; SrcArea.x = startX; SrcArea.y = startY; SrcArea.w = endX; SrcArea.h = endY; SDL_BlitSurface(img->surf, &SrcArea, Screen, &Area); returnează adevărat; ) void Graphics::Flip() ( SDL_Flip(Ecran); SDL_FillRect(Ecran,NULL, 0x000000); )
Constructorul inițializează SDL și creează ecranul.
Funcția Flip ar trebui apelată de fiecare dată după desenarea imaginilor, prezintă imaginea rezultată pe ecran și șterge negrul ecranului pentru randare ulterioară.
Funcțiile rămase sunt de puțin interes, recomand să le descoperiți singur
Imagine.cpp
#include "Image.h" int Image::GetWidth() ( return surf->w; ) int Image::GetHeight() ( return surf->h; )
Nu, faci totul bine, acest fișier ar trebui să fie așa :)
Trebuie să schimbați Game.h, Game.cpp și main.cpp
Joc.h
#ifndef _GAME_H_ #define _GAME_H_ #include Grafica clasa „Project.h”; clasa Joc (privat: bool run; Grafică* grafică; public: Game(); int Execute(int lățime, int înălțime); void Ieșire(); ); #endif
Aici adăugăm un pointer la Graphics și în Execute adăugăm dimensiunea ecranului
Joc.cpp
#include "Game.h" Game::Game() ( run = true; ) int Game::Execute(int width, int height) (grafica = new Graphics(width,height); while(run); SDL_Quit() ; return 0 ) void Game::Exit() ( run = false; )
Nimic special, cu excepția poate sări peste funcția SDL_Quit pentru a șterge SDL
Principal.cpp
#include "Project.h" int WINAPI WinMain(HINSTANCE,HINSTANCE,LPSTR,int) ( Joc joc; returnare joc.Execute(500,350); )
Aici creăm un ecran care măsoară 500 pe 350.
1.3. introduce
Trebuie să lucrați cu introducerea de la tastaturăCreare intrare.h
#ifndef _INPUT_H_ #define _INPUT_H_ #include intrarea clasei „Project.h” (privat: SDL_Event evt; public: void Update(); bool IsMouseButtonDown(cheie octet); bool IsMouseButtonUp(cheie octet); POINT GetButtonDownDownCoords(y); tasta byte); bool IsKeyUp(byte KeyPressedKey(); #endif
SDL_Event este o clasă a unui eveniment, o păstrăm în Intrare pentru a nu crea un obiect din această clasă în fiecare ciclu
Mai jos sunt metode care nu prezintă un interes deosebit. Notă: Metodele care se termină în Jos sunt apelate când tasta a fost apăsată, iar metodele care se termină în Sus sunt apelate când tasta a fost coborâtă.
Intrare.cpp
#include „Input.h” void Input::Update() ( while(SDL_PollEvent(&evt)); ) bool Input::IsMouseButtonDown(byte key) ( if(evt.type == SDL_MOUSEBUTTONDOWN) if(evt.button.button == key) return true; return false; bool Input::IsMouseButtonUp(byte key) ( if(evt.type == SDL_MOUSEBUTTONUP) if(evt.button.button == key) return true; return false; ) POINT ::GetButtonDownCoords() (POINT point; point.x = evt.button.x; point.y = evt.button.y; return point; ) bool Input::IsKeyDown(byte key) ( return (evt.type == SDL_KEYDOWN && evt.key.keysym.sym == cheie); bool Input::IsKeyUp(byte key) ( return (evt.type == SDL_KEYUP && evt.key.keysym.sym == cheie); ) byte Input: : GetPressedKey() ( return evt.key.keysym.sym; ) bool Input::IsExit() ( return (evt.type == SDL_QUIT); )
Aici ne ocupăm de obiectul evenimentului în funcția Update, iar restul funcțiilor pur și simplu verifică tipul evenimentului și valorile acestuia.
Acum schimbăm Game.h și Game.cpp
#ifndef _GAME_H_ #define _GAME_H_ #include „Project.h” #include „Graphics.h” clasa Grafică; #include „Input.h” clasa Intrare; clasa Joc (privat: bool run; Grafică* grafică; Intrare* intrare; public: Joc(); int Execute(int lățime, int înălțime); Grafică* GetGraphics(); Input* GetInput(); void Exit(); ) ; #endif
După cum puteți vedea, am adăugat un pointer la Input și am creat metode de returnare Graphics și Input
Joc.cpp
#include "Game.h" Game::Game() ( run = true; ) int Game::Execute(int width, int height) (grafica = new Graphics(width,height); input = new Input(); while (run) ( input->Update(); ) delete graphics; delete input( ) Graphics* Game::GetGraphics() ( return graphics; ) Input* Game::GetInput() ( return input ; ) void :Exit() ( rula = fals; )
1.4. Rezultate
Aceasta a fost prima lecție. Dacă ați ajuns până aici, felicitări! Ai voința inerentă unui programator :) Vezi linkurile de la începutul articolului către lecțiile ulterioare pentru a învăța multe mai multe!Pentru orice întrebări, vă rog să mă contactați prin PM, iar dacă aveți ghinionul să fiți înregistrat pe Habré, scrieți la izarizar@mail.ru
Crearea unui joc Linux folosind Weaver Framework
Acest articol este despre Weaver Framework, un cadru mic pentru crearea de jocuri 2D pentru Linux. Weaver este scris în limbajul de programare C, adică. Pentru a crea un joc folosindu-l, veți avea nevoie de cel puțin cunoștințe de bază ale acestui limbaj de programare.
Pentru început, trebuie spus că cadrul conține aproximativ 70 de funcții în total pentru manipularea sunetului, imaginilor, crearea de primitive grafice, un detector de coliziuni și altceva. Pe parcursul acestui articol, aproape toate funcțiile vor fi descrise.
Site-ul web al proiectului se află la adresa http://weaver.nongnu.org/ , acolo puteți obține, de asemenea, un pachet deja asamblat în format .deb sau un tarball cu cod sursă pentru sisteme care nu sunt bazate pe Debian. Asadar, haideti sa începem.
După finalizarea cu succes a instalării, puteți începe imediat crearea proiectului. Pentru a face acest lucru, trebuie să deschideți consola, să mergeți la directorul în care va fi localizat noul nostru proiect și să tastați:
ţesător
În timpul creării proiectului
2.1. Crearea unui proiect gol
testul țesătorului
Câteva cuvinte despre conținutul directorului de proiect.
Test
|-fonturi
|-imagini
|-muzică
|-sunete
| |-țesător
LICENȚĂ
Makefile
Practic, numele vorbesc de la sine. Am să menționez doar/src , aici sunt conținute ambele fișiere de proiect direct ( joc.c , joc.h - principal) și (în director/ţesător ) fișierele cadrului propriu-zis necesare pentru asamblarea cu succes a proiectului.
Luați în considerare fișierul /src/game.c mai multe detalii. Este fișierul principal al proiectului și în el se află bucla principală a programului.
int main(int argc, char **argv)
Awake_the_weaver(); // Inițializarea API-ului Weaver
// Bucla principală
Pentru(;;)(
Get_input();
Daca(tastatura)(
Pauză;
weaver_rest(10000000);
May_the_weaver_sleep();
Întoarce 0;
Funcții
awake_the_weaver()
may_the_weaver_sleep()
permit și interzice utilizarea funcțiilor din cadru. Între ele se află bucla principală a programului.
get_input() servește la captarea stării tastaturii și mouse-ului. Urmează o secțiune de cod. responsabil pentru ieșirea din program prin apăsarea oricărei taste.
weaver_rest(n) este conceput pentru a întrerupe programul pentru un anumit număr de nanosecunde, aceeași funcție este responsabilă și pentru FPS, cu cât este mai mic numărul n, cu atât este mai mare FPS.
Pentru a construi proiectul, tastați comanda în consolă face și așteptați finalizarea cu succes.
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/weaver/display.c
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/weaver/keyboard.c
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/weaver/vector2.c
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/weaver/vector3.c
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/weaver/vector4.c
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/weaver/weaver.c
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/weaver/sound.c
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/weaver/image.c
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/weaver/font.c
gcc -Wall -O2 -g $(freetype-config --cflags) -c src/game.c
gcc -Wall -O2 -g $(freetype-config --cflags) -g -o test display.o keyboard.o vector2.o vector3.o vector4.o weaver.o sound.o image.o font.o joc. o -lX11 -lXext -lm -lvorbisfile -lasound -lpng -lfreetype $(freetype-config --cflags)
Noroc. Să începem proiectul:
./Test
Asta e tot! Apăsând orice tastă se închide jocul.
2.2. Folosind tastatura
Starea tastaturii conține o variabilă globală tastatură . Puteți afla dacă tasta de care aveți nevoie este apăsată în acest mod simplu:
dacă (tastatură[
// ceva se întamplă
Dacă aveți nevoie ca programul să răspundă la o combinație de taste, utilizați Logic-ȘI:
dacă (tastatură[
//se va întâmpla ceva!
Acum să schimbăm programul, astfel încât ieșirea să se facă apăsând Ctrl-Q.
Hai sa schimbam
daca(tastatura)
Pauză;
pe
if(tastatură și& tastatură[Q])
Pauză;
Să ne asumăm riscul de a asambla și de a lansa jocul. Acum, pentru a ieși, trebuie să apăsăm combinația de taste Ctrl-Q.
2.3. Desenarea primitivelor grafice
Următoarele funcții sunt utilizate pentru a desena primitive:
desen_cerc()
draw_elipse()
draw_line()
draw_point()
draw_rectangle()
Funcțiile sunt folosite pentru umplerea primitivă
umple_cerc()
umple_elipsa()
umple_dreptunghi()
Numele lor, ca și numele majorității funcțiilor de țesător, sunt descriptive și nu necesită o descriere detaliată. Doar parametrii necesită descrieri, dar un link către Ghidul de referință va fi dat la sfârșitul articolului.
Să nu stăm pe loc și să desenăm un pătrat galben cu coordonatele (x=50, y=150) și dimensiunea 125x125. Să adăugăm următoarea intrare în bucla principală:
draw_dreptunghi(50, 150, 125, 125, GALBEN);
unde GALBEN este culoarea pătratului nostru.
Să punem la punct proiectul și să vedem ce se întâmplă.
Nu cum ne așteptam, nu?
Faptul este că atunci când setăm culoarea în desenul unui pătrat, setăm culoarea marginii acestuia, așa că trebuie să ne umplem pătratul folosind funcția fill_rectangle(). Aceasta este ceea ce facem adăugând următoarea linie după comanda de a desena un pătrat:
umple_dreptunghi(50, 150, 125, 125, GALBEN);
Să încercăm și să vedem!
De data asta am reușit. Acum să încercăm să combinăm cunoștințele noastre despre utilizarea tastaturii și desenarea primitivelor. Dar înainte de asta, să ne optimizăm puțin programul creând pătratul în sine ca o variabilă.
dreptunghiul este o structură cu 4 parametri axa x (parametrul x), axa y (parametrul y), lățimea (parametrul w) și înălțimea (parametrul z).
Să creăm o variabilă de tip dreptunghi, adăugând weaver după inițializare (permiteți-mi să vă reamintesc, acesta este awake_the_weaver()):
dreptunghi rect1;
Apoi îi inițializam parametrii:
dreptunghi rect1;
rect1.x=50;
rect1.y=150;
rect1.w=rect1.z=125;
Să setăm procesarea pentru apăsările de taste<стрелка-влево>Și<стрелка-вправо>tastaturi.
Dacă (tastatură)
Rect1.x-=10;
Dacă (tastatură)
Rect1.x+=10;
Și apoi desenați pătratul în sine:
draw_rectangle(rect1.x, rect1.y, rect1.w, rect1.z, GALBEN);
Observ că inițializarea parametrilor variabili trebuie să aibă loc înainte de ciclul principal de desenare, adică. la pentru(;;).
Să asamblam și să lansăm proiectul nostru.
Și din nou, nu ceea ce ne-am dori să vedem?
Faptul este că desenul are loc la fiecare iterație a buclei principale, dar asta este tot. Tot ceea ce a fost desenat înainte de această iterație rămâne pe ecran fără a fi șters. Acest lucru poate fi rezolvat cu ușurință prin ștergerea ecranului înainte de fiecare nouă redare a ecranului. Pentru a umple (și în acest caz, ștergeți) ecranul, utilizați funcția
fill_screen()
luând culoarea de umplere ca parametru. Să-l adăugăm înainte de a desena pătratul și să vedem ce se întâmplă din nou.
Noroc! Să trecem la încărcarea și desenarea imaginilor.
Singurul format de imagine posibil în Weaver este . png , îl vom folosi. Trebuie să rețineți că toate imaginile trebuie să fie în director
Mai întâi, să declarăm și să inițializam un pointer către tipul de suprafață care reprezintă imagini:
suprafață *face=new_image("face.png");
funcția new_image(). ia un argument - numele fișierului grafic.
Există o funcție pentru afișarea unui fișier grafic
draw_surface()
luând ca argumente un pointer către fișierul grafic care urmează să fie imagine ( suprafata *origine ), un indicator spre unde ( suprafata *destin) si coordonatele (x, y).
Fișierele grafice pot fi desenate pe alte fișiere grafice pentru a desena pur și simplu pe ecran, trebuie să specificați fereastra ca parametru de destin, acesta este un pointer către fereastra de desen curent.
Să eliminăm mențiunile inutile ale pătratului, să asamblam proiectul și să-l lansăm.
Rezultatul eforturilor noastre:
Pentru o manipulare mai convenabilă a imaginii, vom crea o structură constând dintr-un pointer către imagine și coordonatele acesteia pe ecran.
struct pict(
Suprafață *fc;
Int x;
Int y;
Să recreăm și să inițializam imaginea:
face.fc=new_image("face.png");
fata.x=100;
fata.y=100;
Să-l facem să apară:
draw_surface(face.fc, fereastra,face.x, face.y);
Acum putem încerca să controlăm locația imaginii folosind cunoștințele noastre despre tastatură. Nu vă voi da niciun indiciu, sper că o puteți face.
2.5.Ieșirea textului pe ecran.
Probabil că această secțiune vă va dezamăgi, dar Weaver nu poate afișa mesaje text pe ecran. Proiectul are module responsabile pentru ieșirea textului, dar acestea nu sunt utilizate. De ce? Se pare că autorul nu este încă pregătit pentru asta ;). Dar el însuși a propus o soluție la problemă. Pentru afișarea textului se folosește un fel de paletă - un set de litere plasate pe imagine, de unde sunt preluate litere și afișate pe ecran după cum este necesar. Această tehnică a fost folosită înainte în jocurile vechi (și nu atât de vechi).
Îl vom folosi și noi. Pentru a face acest lucru, vom încărca o imagine cu literele deja introduse în jocul nostru.
suprafață *font=new_image("font2.png");
Deci, avem o poză cu mai multe litere plasate pe ea. Cum poți lua din el scrisorile de care ai nevoie? Pentru a afișa o parte a imaginii, este utilizată funcția blit_surface(). Parametrul *src acceptă un pointer către fișierul grafic original, *dest acceptă un pointer către suprafața imaginii, (x_src, y_src) - coordonatele de unde va începe imaginea tăiată, lățime - lățimea noii imagini, înălțime - înălțimea acesteia, (x_dest, y_dest) - coordonatele suprafeței țintă unde va fi afișată imaginea decupată.
Să adăugăm un apel de funcție și să vedem ce se întâmplă.
blit_surface(font, fereastră, 0, 0, 90, 100, 500, 500);
Nu este chiar atât de înfricoșător, dar rămâne o întrebare - în imagine sunt litere roșii pe un fundal albastru închis, dar sunt afișate doar litere roșii. Acest lucru se datorează faptului că, implicit, culoarea albastru închis (#00029a) este considerată transparentă și nu este scoasă. Dacă nu sunteți mulțumit de această culoare anume, atunci o puteți modifica prin simpla setare a unei valori diferite pentru variabila transparent_color.
2.5.Sunet
Din păcate, există și o limitare a formatului fișierului audio - weaver redă numai fișiere în format Ogg Vorbis. Există două funcții pentru redarea sunetelor: play_music() și play_sound(). Diferența dintre cele două este că play_music() va repeta muzica până când stop_music() este apelat. Funcția play_sound() redă fișierul muzical o singură dată și nu putem controla redarea acestei funcții. Evident, play_music() este mai bine folosit pentru a reda sunetul de fundal al jocului, iar play_sound() este mai bine folosit pentru a reda efecte sonore.
Să încercăm să reproducem sunetul. Pentru play_sound(), fișierul trebuie să fie localizat în directorul de sunet, iar pentru play_music() în directorul muzical, respectiv.
Să adăugăm înainte de bucla principală:
play_sound("sound.ogg");
Apoi, ca de obicei, vom asambla și vom lansa jocul. Et voilà, se aude zgomot de focuri de armă.
2.6 Detectarea coliziunilor
Pentru a determina coliziunile dintre obiecte, se folosește un set de funcții, care are un prefix în numele său coliziune_* . Sunt la fel de ușor de folosit ca orice altceva. De exemplu, să creăm două dreptunghiuri:
dreptunghi rect1, rect2;
rect1.x=rect1.y=50;
rect1.w=rect1.z=25;
rect2.x=rect2.y=150;
rect2.w=rect2.z=50;
Unul dintre ei se va muta:
dacă (tastatură)
Rect1.x-=10;
dacă (tastatură)
Rect1.x+=10;
dacă (tastatură)
Rect1.y-=10;
dacă (tastatură)
Rect1.y+=10;
Și partea finală, verificând o coliziune și reacționând la aceasta:
dacă (colision_rectangle_rectangle(&rect1, &rect2))
Pauză;
Desigur, pentru claritate, ar trebui să ne afișăm dreptunghiurile pe ecran.
Acum știm destule pentru a încerca să scriem propriul nostru joc mic. Va fi un Mario foarte simplificat, fără obstacole, dar cu inamici.
Sa incepem!
3.1. Proiectul se va numi YAM (Yet Another Mario)
igname țesător
Toate acestea sunt bine și bune, dar de unde să încep? Pentru început, ar fi o idee bună să veniți cu o interfață pentru joc, apoi să găsiți resursele necesare pentru designul grafic al jocului. Ce este asta? Acestea ar putea fi sprites de caractere, o imagine de fundal, o paletă de litere.
Despre interfata. Nu îl vom avea, de fapt, jocul va fi un nivel scurt, va trebui să îl finalizați într-o singură încercare.
Acum despre sprites. Puteți citi mai multe despre ele pe Wikipedia. Există un număr mare de site-uri unde puteți găsi atât sprite-uri smulse din jocuri, cât și cele originale făcute „pe baza lor”. Avem nevoie de cel puțin două tipuri de sprite, unul pentru Mario și unul pentru adversarul său. După ce am căutat pe google, am găsit mai multe site-uri cu baze de date de sprite, unul dintre ele avea sprite-uri plasate într-o singură imagine, altul le-a furnizat ca imagini separate. Să alegem unde sunt împărțiți, vom avea nevoie de asta pentru crearea mai convenabilă a animației personajelor.
3.2. Deoarece dorim nu doar o imagine statică să se miște atunci când apăsați tasta de mișcare, ci să aibă cel puțin o aparență de mișcare, trebuie să animam personajele. Acest lucru se face folosind o serie de imagini similare, unde diferențele sunt doar în detalii.
Avem 3 tipuri de sprites pentru animația Mario.
Principiul animației, cred că ești familiar, este pur și simplu o imagine secvențială a mai multor imagini.
Să creăm o structură în care vom stoca datele despre caractere:
caracter structura (
Suprafață *fc;
Int x;
Int y;);
Să inițializam variabila pentru Mario:
Mario.x=mario.y=100;
Mario.fc=new_image("mw1.png");
Mario.fc=new_image("mw2.png");
Mario.fc=new_image("mw3.png");
Și, în sfârșit, să începem cu animația personajelor, dar din moment ce ecranul este actualizat la fiecare 0,01 secunde, imaginile se vor schimba foarte des. Acest lucru poate fi remediat fie prin reducerea valorii FPS, trecând funcției weaver_rest() o valoare mai mare decât cea actuală, fie prin utilizarea unui contor de cadre, care va decide ce sprite va fi afișat într-un cadru dat. Vom folosi metoda counter.
Înainte de bucla principală, vom crea un contor variabil, care va fi contorul
int counter=0;
Și în bucla principală va fi o verificare a contorului și, în funcție de valoarea acestuia, va fi desenat unul sau altul sprite de animație:
Dacă (contor<=10){
Counter++;
Dacă (contor>10 && contor<=20){
Draw_surface(mario.fc, window, mario.x, mario.y);
Counter++;
Dacă (contor>20 && contor<=29){
Draw_surface(mario.fc, window, mario.x, mario.y);
Counter++;
Dacă (contor>29)
Contor=0;
Gata, puteți asambla proiectul și îl puteți lansa.
Îl animam pe adversarul lui Mario în același mod.
Acum, pentru ca Mario să aibă măcar o oportunitate de a câștiga, vom implementa posibilitatea ca el să sară. Totul este simplu cu asta: atunci când apăsați o tastă, valoarea coordonatelor verticale se schimbă.
După aceasta, puteți începe să procesați coliziunile dintre Mario și adversarul său. Pentru a face acest lucru, vom adăuga un dreptunghi structurilor care descriu personajul jocului, a cărui intersecție o vom urmări.
Acum structura arată astfel:
caracter structura (
Suprafață *fc;
Int x;
Int y;
dreptunghi col_det;);
Setăm valorile de bază pentru caractere (în principiu, acest lucru nu este necesar, deoarece vor fi actualizate oricum în bucla principală), adăugăm câteva linii pentru a lega dreptunghiurile la coordonatele sprite-urilor. Pentru claritate, să facem dreptunghiurile să apară în roșu pentru un timp, vom elimina acest lucru la sfârșit. Hai să-l rulăm și să vedem ce se întâmplă.
Acum putem începe să implementăm răspunsul la intersecția dreptunghiurilor pentru aceasta folosim funcția deja familiară collsion_rectangle_rectangle():
dacă (colision_rectangle_rectangle(&mario.col_det, &bowser.col_det))
Pauză;
Asta e tot, când personajele se ciocnesc, jocul se va termina. Simplu și ușor.
3.3. Rămâne să adăugăm tușele finale jocului nostru, adică. fundal și efecte sonore
Pentru a adăuga efecte sonore și muzică de fundal, vom folosi funcțiile play_music()/stop_music() și play_sound().
Comenzile sunt simple - săgeată stânga - săgeată dreapta - mutare, săgeată sus - săriți
Deci biata noastră parodie a unui joc grozav este gata. Dacă doriți, puteți adăuga nori, tufișuri și, bineînțeles, ciuperci.
După cum puteți vedea, scrierea unui joc folosind doar C este destul de ușoară, dar a-l face bine este mult mai dificil.
În sfârșit, o mică listă de link-uri utile
http://weaver.nongnu.org / este site-ul web Weaver framework, unde veți găsi atât documentație detaliată, cât și exemple de cod.
Dacă doriți să repetați exemplele din articol, iată un link către arhiva cu codul sursă al jocului nostru:http://narod.ru/disk/16196657001/yam.tar.gz.html.
