👩‍⚕️ 🎮 🤶🏻 द लिटिल ब्रेव अर्कानॉइड (भाग 4) ☮️ 🎬 👃🏿

अल्प विराम के बाद, हम अपना विकास जारी रखेंगे। आज हम इस परियोजना के लिए एक छोटा सा ध्वनि प्रभाव जोड़ेंगे, जब गेंद खेल के मैदान पर कुछ हिट करती है। मैंने पहले ही SoundEngine के साथ काम करने के बारे में लिखा था (जिसका उपयोग हम आज करेंगे)। इस कारण से, आज मैं आपको उसके बारे में इतना नहीं बताऊंगा, लेकिन इसके उपयोग से उस परियोजना पर क्या प्रभाव पड़ेगा जो हम विकसित कर रहे हैं।

SoundEngine परियोजना में शामिल करने का मुख्य (और मेरे लिए कुछ अप्रत्याशित) परिणाम IwGl से IwGx पर स्विच करने की आवश्यकता थी। तथ्य यह है कि साउंडफाइनन ध्वनि प्रभावों का विवरण डाउनलोड करने के लिए IwResManager सबसिस्टम की क्षमताओं का उपयोग करता है। विवरण स्वयं इस प्रकार है:

sounds.group

CIwResGroup { name "sounds" "./sounds/contact.wav" CIwSoundSpec { name "contact" data "contact" vol 0.9 loop false } CIwSoundGroup { name "sound_effects" maxPolyphony 8 killOldest true addSpec "contact" } }

परियोजना में IwResManager को शामिल करने का प्रयास इस तथ्य की ओर जाता है कि यह बस संकलन बंद कर देता है:

IwGeom को प्रोजेक्ट में जोड़ने से भी थोड़ी मदद मिलती है:

स्थिति को सुधारने के लिए फलहीन प्रयासों के बाद, मैंने IwGl के उपयोग को छोड़ने और IwGx पर स्विच करने का निर्णय लिया। किसी भी मामले में मैं जोर नहीं देता कि यह एकमात्र संभव समाधान है, लेकिन यह मुझे सबसे उचित लगा।

हमेशा की तरह, mkb फ़ाइल से शुरू करें:

arcanoid.mkb

 #!/usr/bin/env mkb options { module_path="../yaml" module_path="../box2d" + module_path="$MARMALADE_ROOT/examples" } subprojects { - iwgl + iwgx + iwresmanager + SoundEngine yaml box2d } includepath { ./source/Main ./source/Model } files { [Main] (source/Main) Main.cpp Main.h Quads.cpp Quads.h TouchPad.cpp TouchPad.h Desktop.cpp Desktop.h IO.cpp IO.h World.cpp World.h + ResourceManager.cpp + ResourceManager.h [Model] (source/Model) IBox2DItem.h Board.cpp Board.h Bricks.cpp Bricks.h Ball.cpp Ball.h Handle.cpp Handle.h + [Data] + (data) + sounds.group } assets { (data) level.json + (data-ram/data-gles1, data/data-gles1) + sounds.group.bin }

लोड हो रहा है और खेल संसाधनों एक नए (और अब तक बहुत सरल) मॉड्यूल द्वारा किया जाएगा:

ResourceManager.h

 #ifndef _RESOURCEMANAGER_H_ #define _RESOURCEMANAGER_H_ #include <map> #include <string> #include "s3e.h" #include "IwResManager.h" #include "IwSound.h" #define SOUND_GROUP "sounds" using namespace std; class ResourceManager { private: bool checkSound() {return true;} public: void init(); void release(); void update(); void fireSound(const char* name); }; extern ResourceManager rm; #endif // _RESOURCEMANAGER_H_

ResourceManager.cpp

 #include "ResourceManager.h" ResourceManager rm; void ResourceManager::init() { IwSoundInit(); IwResManagerInit(); #ifdef IW_BUILD_RESOURCES IwGetResManager()->AddHandler(new CIwResHandlerWAV); #endif IwGetResManager()->LoadGroup("sounds.group"); } void ResourceManager::release() { IwResManagerTerminate(); IwSoundTerminate(); } void ResourceManager::update() { IwGetSoundManager()->Update(); } void ResourceManager::fireSound(const char* name) { if (!checkSound()) return; CIwResGroup* resGroup = IwGetResManager()->GetGroupNamed(SOUND_GROUP); CIwSoundSpec* SoundSpec = (CIwSoundSpec*)resGroup->GetResNamed(name, IW_SOUND_RESTYPE_SPEC); CIwSoundInst* SoundInstance = SoundSpec->Play(); }

विश्व मॉड्यूल से ध्वनि प्रभाव को सक्रिय करना सरल और आसान होगा:

World.cpp

 #include "s3e.h" +#include "ResourceManager.h" #include "World.h" #include "Ball.h" ... void World::PostSolve(b2Contact* contact, const b2ContactImpulse* impulse) { impact(contact->GetFixtureA()->GetBody()); impact(contact->GetFixtureB()->GetBody()); isContacted = true; + rm.fireSound(CONTACT_SOUND); }

वास्तव में ये सभी परिवर्तन हैं जो ध्वनि प्रभावों के कार्यान्वयन के लिए आवश्यक थे। अब हमें IwGl से IwGx में संक्रमण से संबंधित कई बदलाव करने हैं।

Desktop.cpp

 #include "Desktop.h" #include "IwGx.h" #include "s3e.h" Desktop desktop; void Desktop::init() { IwGxInit(); IwGxLightingOff(); width = IwGxGetScreenWidth(); height = IwGxGetScreenHeight(); IwGxSetColClear(0, 0, 0, 0); vSize = 0; duration = 1000 / 60; } void Desktop::release() { IwGxTerminate(); } void Desktop::update() { IwGxClear(IW_GX_COLOUR_BUFFER_F | IW_GX_DEPTH_BUFFER_F); CIwMaterial* pMat = IW_GX_ALLOC_MATERIAL(); IwGxSetMaterial(pMat); } void Desktop::refresh() { IwGxFlush(); IwGxSwapBuffers(); s3eDeviceYield(duration); } int Desktop::toRSize(int x) const { if (vSize == 0) return x; return (x * width) / vSize; }

Quads.h

 #ifndef _QUADS_H_ #define _QUADS_H_ #include "IwGX.h" #define MAX_VERTS 2000 class Quads { private: CIwSVec2 verts[MAX_VERTS]; CIwColour cols[MAX_VERTS]; int vertc; public: void update() {vertc = 0;} void refresh(); void setVert(int x, int y, int r, int g, int b, int a); }; extern Quads quads; #endif // _QUADS_H_

Quads.cpp

 #include "Quads.h" #include "s3e.h" Quads quads; void Quads::refresh() { IwGxSetVertStreamScreenSpace(verts, vertc); IwGxSetColStream(cols, vertc); IwGxDrawPrims(IW_GX_TRI_LIST, NULL, vertc); } void Quads::setVert(int x, int y, int r, int g, int b, int a) { if (vertc >= MAX_VERTS) return; verts[vertc].x = x; verts[vertc].y = y; cols[vertc].r = r; cols[vertc].g = g; cols[vertc].b = b; cols[vertc].a = a; vertc++; }

Bricks.h

 #ifndef _BRICKS_H_ #define _BRICKS_H_ #include "IwGX.h" #include "s3e.h" #include "Desktop.h" #include "World.h" #include "IBox2DItem.h" #define BRICK_HALF_WIDTH 20 #define BRICK_HALF_HEIGHT 10 #include <vector> using namespace std; class Bricks: public IBox2DItem { private: struct SBrick { SBrick(int x, int y): x(x), y(y), body(NULL), isBroken(false), hw(BRICK_HALF_WIDTH), hh(BRICK_HALF_HEIGHT) {} SBrick(const SBrick& p): x(px), y(py), body(p.body), isBroken(p.isBroken), hw(p.hw), hh(p.hh) {} int x, y, hw, hh; int isBroken; b2Body* body; }; vector<SBrick>* bricks; virtual bool impact(b2Body* b); public: Bricks(): bricks() {} void init(); void release(); void refresh(); void clear(){bricks->clear();} void add(SBrick& b); typedef vector<SBrick>::iterator BIter; friend class Board; }; #endif // _BRICKS_H_

Bricks.cpp

 #include "Bricks.h" #include "Quads.h" void Bricks::init() { bricks = new vector<SBrick>(); } void Bricks::release() { delete bricks; } void Bricks::refresh() { for (BIter p = bricks->begin(); p != bricks->end(); ++p) { if (p->isBroken) continue; quads.setVert(p->x - p->hw, p->y - p->hh, 0x00, 0xff, 0x50, 0xff); quads.setVert(p->x - p->hw, p->y + p->hh, 0x00, 0xff, 0x50, 0xff); quads.setVert(p->x + p->hw, p->y - p->hh, 0x00, 0xff, 0x50, 0xff); quads.setVert(p->x + p->hw, p->y + p->hh, 0x00, 0xff, 0x50, 0xff); quads.setVert(p->x + p->hw, p->y - p->hh, 0x00, 0xff, 0x50, 0xff); quads.setVert(p->x - p->hw, p->y + p->hh, 0x00, 0xff, 0x50, 0xff); } } bool Bricks::impact(b2Body* b) { for (BIter p = bricks->begin(); p != bricks->end(); ++p) { if (p->body == b) { p->isBroken = true; return true; } } return false; } void Bricks::add(SBrick& b) { b.body = world.addBrick(bx, by, b.hw, b.hh, (IBox2DItem*)this); bricks->push_back(b); }

यहां आपको त्रिभुजों में तिरछे आघात के क्रम पर ध्यान देना चाहिए। पहली चीज जो मैंने देखी, IwGl से IwGx पर स्विच करने के बाद, ईंटों के कोयले-काले आंकड़े और धीरे बैंगनी पृष्ठभूमि पर एक गेंद थी। मैं "अंदर से" बिल्कुल उन सभी त्रिकोणों को प्रदर्शित करने में कामयाब रहा जो मेरे पास थे।

स्मृति के साथ काम करने वाली दूसरी महत्वपूर्ण बात है। मुझे नहीं पता कि IwGx मेमोरी के साथ कैसे काम करता है, लेकिन अंगूठे का एक महत्वपूर्ण नियम है जो मैं आया था। गतिशील रूप से आवंटित सभी मेमोरी (एसटीएल में) को तब तक मुक्त किया जाना चाहिए जब तक कि IwGxTerminate नहीं कहा जाता है (अन्यथा यह नष्ट हो जाएगा)। इस कारण से, ईंट वेक्टर वेक्टर के लिए एक संकेतक बन गया है। शायद यह सबसे सुरुचिपूर्ण समाधान नहीं है, लेकिन इसने आवश्यक परिवर्तन की न्यूनतम संख्या में प्रवेश किया।

इसी तरह, हम शेष मॉड्यूल को बदलते हैं:

Ball.h

 #ifndef _BALL_H_ #define _BALL_H_ #include <vector> #include "s3e.h" #include "Desktop.h" #include "World.h" #include "IBox2DItem.h" #define MAX_SEGMENTS 7 #define BALL_RADIUS 15 using namespace std; class Ball: public IBox2DItem { private: struct Offset { Offset(int dx, int dy): dx(dx), dy(dy) {} Offset(const Offset& p): dx(p.dx), dy(p.dy) {} int dx, dy; }; vector<Offset>* offsets; int x; int y; b2Body* body; public: void init(); void release(); void refresh(); virtual void setXY(int X, int Y); typedef vector<Offset>::iterator OIter; }; #endif // _BALL_H_

Ball.cpp

 #include "Ball.h" #include "Desktop.h" #include "Quads.h" #include <math.h> void Ball::init(){ x = desktop.getWidth() / 2; y = desktop.getHeight()/ 2; offsets = new vector<Offset>(); float delta = - PI / (float)MAX_SEGMENTS; float angle = delta / 2.0f; float r = (float)desktop.toRSize(BALL_RADIUS); for (int i = 0; i < MAX_SEGMENTS * 2; i++) { offsets->push_back(Offset((int16)(cos(angle) * r), (int16)(sin(angle) * r))); angle = angle + delta; offsets->push_back(Offset((int16)(cos(angle) * r), (int16)(sin(angle) * r))); } body = world.addBall(x, y, (int)r, (IBox2DItem*)this); } void Ball::release() { delete offsets; } void Ball::setXY(int X, int Y) { x = X; y = Y; } void Ball::refresh() { OIter o = offsets->begin(); int r = desktop.toRSize(BALL_RADIUS); for (int i = 0; i < MAX_SEGMENTS * 2; i++) { quads.setVert(x + (r / 4), y + (r / 4), 0xff, 0xff, 0xff, 0xff); quads.setVert(x + o->dx, y + o->dy, 0x00, 0x00, 0x00, 0x00); o++; quads.setVert(x + o->dx, y + o->dy, 0x00, 0x00, 0x00, 0x00); o++; } }

Handle.h

 #ifndef _HANDLE_H_ #define _HANDLE_H_ #include "IwGX.h" #include "s3e.h" #include "Desktop.h" #include "World.h" #include "IBox2DItem.h" #define HANDLE_COLOR 0xffff3000 #define HANDLE_H_WIDTH 40 #define HANDLE_H_HEIGHT 10 class Handle: public IBox2DItem { private: int x; int y; int touchId; public: void init(); void refresh(); void update(); virtual void setXY(int X, int Y); }; #endif // _HANDLE_H_

Handle.cpp

 #include "Handle.h" #include "Quads.h" #include "TouchPad.h" void Handle::init() { x = desktop.getWidth() / 2; y = desktop.getHeight(); touchId = -1; } void Handle::setXY(int X, int Y) { x = X; y = Y; } void Handle::refresh() { int hw = desktop.toRSize(HANDLE_H_WIDTH); int hh = desktop.toRSize(HANDLE_H_HEIGHT); quads.setVert(x - hw, y - hh, 0x00, 0x30, 0xff, 0xff); quads.setVert(x - hw, y + hh, 0x00, 0x30, 0xff, 0xff); quads.setVert(x + hw, y - hh, 0x00, 0x30, 0xff, 0xff); quads.setVert(x + hw, y + hh, 0x00, 0x30, 0xff, 0xff); quads.setVert(x + hw, y - hh, 0x00, 0x30, 0xff, 0xff); quads.setVert(x - hw, y + hh, 0x00, 0x30, 0xff, 0xff); world.addHandle(x, y, desktop.toRSize(HANDLE_H_WIDTH), desktop.toRSize(HANDLE_H_HEIGHT), (IBox2DItem*)this); } void Handle::update() { Touch* t = NULL; if (touchId > 0) { t = touchPad.getTouchByID(touchId); } else { t = touchPad.getTouchPressed(); } if (t != NULL) { touchId = t->id; world.moveHandle(t->x, t->y); } else { touchId = -1; } }

बोर्ड में, हम केवल दो वैक्टर (स्कोप और प्रकार) को प्रतिस्थापित करते हैं जो कि वैक्टर को इंगित करते हैं। अगला, एप्लिकेशन चलाएँ और सुनिश्चित करें कि सब कुछ काम करता है:

आप देख सकते हैं कि मैंने ईंटों से ग्रेडिएंट फिल को हटा दिया। ईमानदारी से, यह सिर्फ इसके साथ छेड़छाड़ करने के लिए बहुत आलसी था, यह देखते हुए कि वैसे भी, बनावट सभी वस्तुओं पर खींची जाएगी (अन्यथा, किसी को भी किसी भी प्रस्तुति का सपना नहीं होना चाहिए)।

द लिटिल ब्रेव अर्कानॉइड (भाग 4)

More articles: