🚣 🔺 👼🏿 मुरब्बा एसडीके में 2 डी ऑब्जेक्ट कोलिज़ेशन का पता लगाना 👑 🚿 🎖️

सभी को नमस्कार! मैं मुरब्बा एसडीके के लिए विकासशील अनुप्रयोगों में अपने अनुभव को साझा करना चाहता हूं।

मैं आपको याद दिलाना चाहता हूं कि बहु-प्लेटफ़ॉर्म एप्लिकेशन बनाने के लिए मुरब्बा एक महान उपकरण है। आप एलजी टीवी और मोबाइल डिवाइस (Android, Bada, iOS, सिम्बियन और WindowsMobile पर आधारित) दोनों के लिए आवेदन लिख सकते हैं।
इस लेख में आप पाएंगे:

मुरब्बा एसडीके के तहत एक आवेदन बनाने की प्रक्रिया;
प्रक्षेपण निर्माण का उपयोग करके उत्तल बहुभुज का टकराव का पता लगाना
टकराव (न्यूनतम पथ के साथ वस्तु का आउटपुट) पर प्रतिक्रिया का निर्धारण।

थोडा पूर्वजन्म। एक बार, एक परियोजना के लिए, मुझे विभिन्न वस्तुओं के लिए टकराव की जांच को लागू करने की आवश्यकता थी। और मैं इस तथ्य से बहुत आश्चर्यचकित था कि, इस तथ्य के बावजूद कि लगभग कोई भी खेल वस्तुओं के टकराव और चौराहों के लिए जांच के बिना नहीं कर सकता है, इस तरह के कार्य के लिए तैयार समाधान और सरल उदाहरण ढूंढना इतना आसान नहीं है। विशेष रूप से अधिक या कम स्पष्ट स्पष्टीकरण के साथ। मुझे खुद इसे लागू करना था।

मैं पहले से चेतावनी देना चाहता हूं कि लेख का सभी कोड C ++ में लिखा गया है।

एक साइट पर, प्रोजेक्शन निर्माण का उपयोग करके टकराव की जांच का वर्णन पाया गया था। यह विधि अपेक्षाकृत सरल और काफी तेज है। संभवतः इसकी सबसे बड़ी कमी यह है कि यह केवल उत्तल बहुभुज के लिए उपयुक्त है। लेकिन इस समस्या को एक अवतल बहुभुज को दो या अधिक उत्तल लोगों में विभाजित करके हल किया जा सकता है।

तो, चलो एक सरल के साथ शुरू करते हैं - एक मुरब्बा परियोजना का निर्माण।

मुरब्बा में, यह सब mkb फ़ाइल से शुरू होता है, इसलिए इस पर विचार करें। प्रोजेक्ट फ़ोल्डर में फ़ाइल test2d.mkb और स्रोत फ़ोल्डर बनाएँ। Mkb फ़ाइल में, निम्नलिखित लिखें:

#!/usr/bin/env mkb
files {
[Source]
(source)
main.cpp
entity.cpp
entity.h
}
subprojects {
iw2d
}

टैग "फाइलों" में हम अपनी परियोजना की फाइलों की सूची का वर्णन करते हैं। हमारे पास केवल तीन फाइलें होंगी जो स्रोत फ़ोल्डर में हैं (कोष्ठकों की सामग्री यह इंगित करती है)। "सबप्रोजेक्ट्स" टैग में, हम उन मुरब्बा पुस्तकालयों को सूचीबद्ध करते हैं जिनका हम उपयोग करेंगे। इस मामले में, हमारे पास 2 डी ग्राफिक्स के साथ काम करने के लिए केवल एक पुस्तकालय है।

"स्रोत" फ़ोल्डर में तीन खाली फाइलें (main.cpp, unit.cpp और unit.h) बनाएं, और फिर test2d.mkb चलाएं। परिणामस्वरूप, मुरब्बा विकास पर्यावरण के लिए आवश्यक डेटा उत्पन्न करेगा (मेरे मामले में यह विजुअल स्टूडियो के लिए "build_test2d_vc10" फ़ोल्डर है), साथ ही परियोजना सेटिंग्स के साथ "डेटा" फ़ोल्डर।

प्रोजेक्ट बनाया गया है, अब कोड लिखना शुरू करते हैं।

प्राथमिक कार्य इस प्रकार है:

मंच पर कई ऑब्जेक्ट बनाएं;
हम वस्तुओं में से एक का नियंत्रण लागू करते हैं (नियंत्रण कीबोर्ड द्वारा किया जाएगा: तीर - आंदोलन, 1 और 2 - रोटेशन);
हम दृश्य में अन्य वस्तुओं के साथ एक नियंत्रित वस्तु के टकराव की जांच को लागू करते हैं, साथ ही टकराव के लिए एक पर्याप्त प्रतिक्रिया प्रदान करते हैं।

तो, हम main.cpp फ़ाइल के कोड पर विचार करेंगे, जिसमें हम आरंभ करेंगे, आवश्यक आकृतियों और ऑब्जेक्ट्स को बनाएंगे, एप्लिकेशन के मुख्य चक्र को लागू करेंगे, और एप्लिकेशन के समाप्त होने पर डेटा की सफाई भी करेंगे।

  #include "iw2d.h" #include "iwArray.h" #include "entity.h" #include "s3eKeyboard.h" #include "s3eDevice.h" #include <time.h> #include <s3e.h> #define FPS 30 #define MOVE_SPEED 100 #define OBJECT_DIMENSION 50 /***************************************************************/ int main(int argc, char* argv[]) { s3eResult result = S3E_RESULT_SUCCESS; /*      2D  */ Iw2DInit(); /*    */ uint32 width = Iw2DGetSurfaceWidth(); uint32 height = Iw2DGetSurfaceHeight(); /*    "" */ int wall_size = MAX(width, height); /*    */ CIwArray<CEntity*> arr_objects; /*  3    */ /*    */ CIwSVec2 m_Verts1[5]; CIwSVec2 m_Verts2[4]; CIwSVec2 m_Verts3[4]; /*  1 */ m_Verts1[0] = CIwVec2(-OBJECT_DIMENSION, -OBJECT_DIMENSION); m_Verts1[1] = CIwVec2(OBJECT_DIMENSION, -OBJECT_DIMENSION); m_Verts1[2] = CIwVec2(OBJECT_DIMENSION, 0); m_Verts1[3] = CIwVec2(0, OBJECT_DIMENSION); m_Verts1[4] = CIwVec2(-OBJECT_DIMENSION, OBJECT_DIMENSION); /*  2 */ m_Verts2[0] = CIwVec2(-OBJECT_DIMENSION/2, OBJECT_DIMENSION + OBJECT_DIMENSION/2); m_Verts2[1] = CIwVec2(OBJECT_DIMENSION/2, OBJECT_DIMENSION/2); m_Verts2[2] = CIwVec2(OBJECT_DIMENSION/2, -OBJECT_DIMENSION/2); m_Verts2[3] = CIwVec2(-OBJECT_DIMENSION/2, -OBJECT_DIMENSION/2); /*  3:  */ m_Verts3[0] = CIwVec2(-5, wall_size/2); m_Verts3[1] = CIwVec2(5, wall_size/2); m_Verts3[2] = CIwVec2(5, -wall_size/2); m_Verts3[3] = CIwVec2(-5, -wall_size/2); /*  ,    */ /*  ,     */ CEntity *main_object = new CEntity(CIwSVec2(width/2, height/2), &m_Verts2[0], 4, 0xFFff0000); arr_objects.append(main_object); /*         ,   . */ CEntity *tmp_object = new CEntity(CIwSVec2(width/2, height/2), &m_Verts1[0], 5, 0xFF0000ff); tmp_object->SetAngle(IW_ANGLE_PI/3); arr_objects.append(tmp_object); tmp_object = new CEntity(CIwSVec2(50, 50), &m_Verts1[0], 5, 0xFF0000ff); tmp_object->SetAngle(IW_ANGLE_PI/2); arr_objects.append(tmp_object); /*  4 "" */ tmp_object = new CEntity(CIwSVec2(0, height/2), &m_Verts3[0], 4, 0xFFff0000); arr_objects.append(tmp_object); tmp_object = new CEntity(CIwSVec2(width, height/2), &m_Verts3[0], 4, 0xFFff0000); arr_objects.append(tmp_object); tmp_object = new CEntity(CIwSVec2(width/2, 0), &m_Verts3[0], 4, 0xFFff0000); tmp_object->SetAngle(IW_ANGLE_PI/2); arr_objects.append(tmp_object); tmp_object = new CEntity(CIwSVec2(width/2, height), &m_Verts3[0], 4, 0xFFff0000); tmp_object->SetAngle(IW_ANGLE_PI/2); arr_objects.append(tmp_object); /*     */ int time_between_frames = 1000/FPS; /*    */ uint32 timer = (uint32)s3eTimerGetMs(); while(result == S3E_RESULT_SUCCESS) { /*    */ s3eKeyboardUpdate(); /*     .    . */ if (s3eDeviceCheckQuitRequest()) break; /*       .      */ uint32 now_time = (uint32)s3eTimerGetMs(); int delta = now_time - timer; if (delta < 0) delta = 0; /*        */ main_object->Move(CIwSVec2::g_Zero); main_object->Rotate(0); /*             */ if ( (s3eKeyboardGetState(s3eKeyLeft) & S3E_KEY_STATE_DOWN) ) { main_object->Move(CIwSVec2(-MOVE_SPEED, 0)); } else if ( (s3eKeyboardGetState(s3eKeyRight) & S3E_KEY_STATE_DOWN) ) { main_object->Move(CIwSVec2(MOVE_SPEED, 0)); } else if ( (s3eKeyboardGetState(s3eKeyUp) & S3E_KEY_STATE_DOWN) ) { main_object->Move(CIwSVec2(0, -MOVE_SPEED)); } else if ( (s3eKeyboardGetState(s3eKeyDown) & S3E_KEY_STATE_DOWN) ) { main_object->Move(CIwSVec2(0, MOVE_SPEED)); } if ( (s3eKeyboardGetState(s3eKey1) & S3E_KEY_STATE_DOWN) ) { main_object->Rotate(-IW_ANGLE_PI / 2); } else if ( (s3eKeyboardGetState(s3eKey2) & S3E_KEY_STATE_DOWN) ) { main_object->Rotate(IW_ANGLE_PI / 2); } /*    */ Iw2DSurfaceClear(0xffffffff); /*    */ for(int i=0; i < (int)arr_objects.size(); ++i) { arr_objects[i]->Update(delta); } /*     ().      . */ main_object->SetColour(0xff00ff00); /*      ,   . */ int try_count = 10; bool b_collide; do{ b_collide = false; /*      */ for(int i = 0; i < (int)arr_objects.size(); ++i) { /*       */ if(arr_objects[i] != main_object){ /*  .  vec_reaction  ,   . */ CIwVec2 vec_reaction = main_object->CollideRect(arr_objects[i], true); if(!vec_reaction.IsZero()){ main_object->SetColour(0xff000000); b_collide = true; } } } --try_count; /*      ,   ""  ,      . */ } while(b_collide && try_count > 0); /*    */ for(int i=0; i < (int)arr_objects.size(); ++i) { arr_objects[i]->Render(); } /*     */ Iw2DSurfaceShow(); /*        . */ int32 wait_time = (uint32)time_between_frames - ((uint32)s3eTimerGetMs() - now_time); if(wait_time<0)wait_time = 0; timer = now_time; s3eDeviceYield(wait_time); } /*      */ for(int i=0; i < (int)arr_objects.size(); ++i) { delete arr_objects[i]; } /*   */ arr_objects.clear_optimised(); /*       2d . */ Iw2DTerminate(); return 0; }

ऐसा लगता है कि कुछ भी जटिल नहीं है। अब आइए वस्तुओं को स्वयं देखें, जिसमें निम्नलिखित विशेषताएं लागू की जाएंगी:

वस्तु का एक आकार और रंग है;
ऑब्जेक्ट स्थिति (चाल) को बदल सकता है और घुमा सकता है;
एक वस्तु अन्य वस्तुओं के साथ टकराव का जवाब दे सकती है;
वस्तु ही आकर्षित कर सकती है;

आइए हमारी वस्तुओं के वर्ग (इकाई.ह फ़ाइल) के विवरण को देखें। यह स्पष्ट रूप से वस्तु की क्षमताओं का वर्णन करता है।

  #pragma once #include "iw2d.h" #include "iwArray.h" #include "IwMath.h" class CEntity{ private: CIwMat2D m_MatLocal; /*    */ iwangle angle; /*    */ iwangle angle_velocity; /*    */ CIwSVec2 m_MoveVelocity; /*   */ uint32 m_NumPoints; /*   */ CIwSVec2 *m_Points; /*   */ CIwVec2 *m_PointsMod; /*  */ CIwVec2 *m_Axis; /*   */ uint32 colour; public: /*  */ CEntity(CIwSVec2 position, CIwSVec2 *verts, int num_verts, uint32 colour = 0xff000000); /*  */ virtual ~CEntity(); /*   */ void Update(int speed); /*   */ void Render(); /*     */ void SetAngle(iwangle angle) {this->angle = angle % IW_ANGLE_PI;}; /*     */ void Rotate(iwangle rot_angle) { angle_velocity = rot_angle; } /*     */ void Move(CIwSVec2 move_velocity) { m_MoveVelocity = move_velocity; } /*    */ void SetColour(int colour){this->colour = colour;} /*      */ const CIwVec2 *GetVerts(){ return m_PointsMod; } /*   */ int GetNumVerts() {return m_NumPoints;} /*   .         */ CIwVec2 CollideRect(CEntity *other, bool b_uncollide = false); private: /*    */ void UpdateVerts(); /*      */ /*         */ /* b_revert -   . */ bool TestOverlaps(CEntity *other, CIwVec2 &min_axis, int &min_t, int b_revert); /*          */ void GetInterval(const CIwVec2 *verts, int count, CIwVec2 axis, int &min, int &max); };

आइए वर्ग के कार्यान्वयन को देखें। विधियों पर विशेष ध्यान दिया जाना चाहिए: CollideRect और TestOverlaps ।

  #include "entity.h" CEntity::CEntity(CIwSVec2 position, CIwSVec2 *verts, int num_verts, uint32 colour ): m_MatLocal(CIwMat2D::g_Identity), m_MoveVelocity(CIwSVec2::g_Zero), angle(0), angle_velocity(0) { this->colour = colour; this->m_NumPoints = num_verts; m_Points = NULL; m_PointsMod = new CIwVec2[m_NumPoints]; m_Axis = new CIwVec2[num_verts]; m_MatLocal.t = position; m_Points = verts; } CEntity::~CEntity() { if(m_PointsMod)delete m_PointsMod; delete m_Axis; } void CEntity::Update(int speed) { angle += (angle_velocity * speed) / 1000; angle = angle % IW_ANGLE_2PI; m_MatLocal.SetRot(angle, false); if(!m_MoveVelocity.IsZero()) { m_MatLocal.t += ( m_MoveVelocity * speed) / 1000; } UpdateVerts(); } void CEntity::UpdateVerts() { if(!m_Points) return; /*    */ for(uint32 i = 0; i < m_NumPoints; ++i) { m_PointsMod[i] = m_MatLocal.TransformVec(m_Points[i]); } /*   */ for(uint32 i = 0; i < m_NumPoints; ++i) { /*      */ m_Axis[i] = m_PointsMod[(i + 1) % m_NumPoints] - m_PointsMod[i]; /*  */ m_Axis[i].Normalise(); /*     */ m_Axis[i] = CIwVec2(-m_Axis[i].y, m_Axis[i].x); } } void CEntity::Render() { /*    */ Iw2DSetColour(colour); if(!m_Points)return; /*      */ Iw2DSetTransformMatrix(m_MatLocal); /*   */ Iw2DFillPolygon(m_Points, m_NumPoints); /*   */ Iw2DSetColour(0xff00ffff); Iw2DFillArc(CIwSVec2::g_Zero, CIwSVec2(5,5), 0, IW_ANGLE_2PI); } CIwVec2 CEntity::CollideRect(CEntity *other, bool b_uncollide) { /*   ,       */ int min_t(0); CIwVec2 min_axis(CIwFVec2::g_Zero); /*         ,   */ /*   ..      ,      */ /*        ,  ,    . */ if(!TestOverlaps(other, min_axis, min_t, false))return CIwVec2::g_Zero; if(!other->TestOverlaps(this, min_axis, min_t, true))return CIwVec2::g_Zero; /*   ,      */ if(b_uncollide){ CIwVec2 fvec = min_axis * min_t; /*   */ m_MatLocal.t += fvec; /*  . */ UpdateVerts(); } return min_axis * min_t; } bool CEntity::TestOverlaps(CEntity *other, CIwVec2 &min_axis, int &min_t, int b_revert) { /*   ,     */ const CIwVec2 *other_corner = other->GetVerts(); int other_corner_count = other->GetNumVerts(); /*       */ for (uint32 i = 0; i < m_NumPoints; ++i) { int aMin; int aMax; int bMin; int bMax; /*           */ GetInterval(m_PointsMod, m_NumPoints, m_Axis[i], aMin, aMax); GetInterval(other_corner, other_corner_count, m_Axis[i], bMin, bMax); /* ,       */ if ((aMax <= bMin) || (bMax <= aMin)) { /*   .  */ return false; } /*   .  ,   ,      */ /*               */ int t = 0; if(aMax >= bMin) { t = bMin - aMax ; if(min_axis.IsZero() || ABS(min_t) > ABS(t)){ min_t = t * (b_revert?-1:1); min_axis = m_Axis[i]; } } if(bMax >= aMin) { t = bMax - aMin; if(min_axis.IsZero() || ABS(min_t) > ABS(t)){ min_t = t * (b_revert?-1:1); min_axis = m_Axis[i]; } } } return true; } void CEntity::GetInterval(const CIwVec2 *verts, int count, CIwVec2 axis, int &min, int &max) { min = max = axis.Dot(verts[0]); for (int i = 1; i < count; i++) { int value = axis.Dot(verts[i]); min = MIN(min, value); max = MAX(max, value); } }

ठीक है, यह हमारा आवेदन तैयार है। अब इसे संकलित करें और परिणाम देखें।

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

किसी भी आलोचना, टिप्पणी, परिवर्धन और सुधार का स्वागत है।

इस लेख को लिखते समय, टकराव का पता लगाने वाले एल्गोरिदम पर एक संसाधन बहुत उपयोगी निकला। अच्छे दृश्य फ्लैश उदाहरण के साथ।

मुरब्बा एसडीके में 2 डी ऑब्जेक्ट कोलिज़ेशन का पता लगाना

More articles: