कंप्यूटर वर्णों के चलने के तरीके (भाग 2)

पिछले लेख में मैंने टाइलों की दुनिया में आंदोलनों और आंदोलनों के प्रकारों के बारे में बात की थी। आज मैं आपको वेक्टर विधियों के बारे में अधिक बताऊंगा। जैसा कि पिछली बार मैं सिद्धांत को बताऊंगा, सार को समझाऊंगा और C ++ में आंदोलनों के कार्यान्वयन का एक उदाहरण दिखाऊंगा।

एक वेक्टर के साथ बढ़ना आंदोलन को लागू करने के तरीकों में से एक है। दुनिया अब कोशिकाओं में विभाजित नहीं है, और आंदोलन के लिए बहुत अधिक स्वतंत्रता प्रदान करती है। निर्देशांक बड़ी सटीकता (न केवल पूर्णांक, बल्कि फ्लोट मान) के साथ सेट किए जा सकते हैं, जो आपको बहुत यथार्थवादी आंदोलनों को लागू करने की अनुमति देता है। वेक्टर वह दिशा है जिसमें हमारा एजेंट आगे बढ़ेगा। सबसे आसान तरीका इसे दो मूल्यों के साथ सेट करना है, उदाहरण के लिए, वी (10.5)। इसका मतलब है कि जब आप वेक्टर V (10.5) के साथ समन्वय A (1,1) में स्थित बिंदु को स्थानांतरित करते हैं, तो वस्तु की स्थिति A + V = C (1 + 10.1 + 5) = C (11.6) में होगी । वेक्टर मान नकारात्मक भी हो सकते हैं।

आंदोलन की दिशा बदलने के लिए, वर्तमान वेक्टर को एक नए के साथ जोड़ने के लिए पर्याप्त है। उदाहरण के लिए, वेक्टर V1 (2,6) वाले, हम वेक्टर V2 (3, -3) को जोड़कर इसे बदलना चाहते हैं, नई गति वेक्टर V1 + V2 = V3 (2 + 3), 6 + (- 3)) = 3 होगी 5.3)। इसे इस प्रकार दर्शाया जा सकता है:

आइए वेक्टर के चारों ओर घूमने के लिए वापस जाएं। जैसा कि पहले ही कहा गया है, किसी ऑब्जेक्ट को किसी विशिष्ट वेक्टर में ले जाने के लिए, आपको वेक्टर के मूल्यों के साथ ऑब्जेक्ट के निर्देशांक को जोड़ना होगा: Pos (x, y) + V (a, b) = NewPos (x + a, y + b)। वेक्टर जितना बड़ा होगा, हमारी वस्तु उतनी ही दूर जाएगी। यह फिसलन बाधाओं से जुड़ी कई कठिनाइयां पैदा कर सकता है। एक पर्याप्त बड़े कदम के बाद, एक वस्तु आसानी से छोटी वस्तुओं को याद कर सकती है। इस कमी को दूर करने के कई अलग-अलग तरीके हैं, लेकिन वे लेख का हिस्सा नहीं हैं।

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

class Vector { public: float x, y; }; class Mob { public: float x,y;// float,      Vector Way;//  void AddVector(Vector NewWay); void Move(); }; void Mob::AddVector(Vector NewWay) {//   Way.x+=NewWay.x;//   Way.y+=NewWay.y; } void Mob::Move() {//    x+=Way.x; y+=Way.y; } 

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

1. वेक्टर को एक सामान्यीकृत रूप में परिवर्तित करें (गति द्वारा वेक्टर के मूल्यों को गुणा करें)।
2. नए वेक्टर के साथ ऐसा ही करें, अगर यह पहले नहीं किया गया है।
3. सामान्य तरीके से वैक्टर जोड़ें।
4. परिणामी वेक्टर की लंबाई की गणना हमारी नई गति है।
5. वेक्टर को सामान्य करें।

इस स्थिति में, हमारी कक्षा और वेक्टर और गति को जोड़ने के कार्य रूप लेते हैं:

 class Mob { public: float x,y;// float,      float Speed; Vector Way;//  void Normalize(); void AddVector(Vector NewWay); void Move(); }; void Mob::Normalize() { Speed = sqrt(Way.x*Way.x + Way.y*Way.y);//   Way.x *= 1/Speed;//  Way.y *= 1/Speed; } void Mob::AddVector(Vector NewWay, float NewSpeed) { Vector MobVec, NewVec;//   MobVe.x = Way.x * Speed;//   MobVe.y = Way.y * Speed; NewVec.x = Way.x * NewSpeed;//   NewVec.y = Way.y * NewSpeed; Way.x = MobVe.x + NewVec.x;//  Way.y = MobVe.y + NewVec.y;//    Normalize();//  } void Mob::Move() {//    x += Way.x * Speed; y += Way.y * Speed; } 

मैं जोर देता हूं कि यह कार्यान्वयन के संभावित विकल्पों में से एक है, पूरी तरह से कार्यान्वयन के तरीकों की बेहतर समझ के लिए प्रदान किया गया है। पिछले लेख में, मैंने बताया कि गति के दो मुख्य तरीके हैं - स्थितिजन्य और लक्ष्य। वेक्टर गति के मामले में उनके कार्यान्वयन की सुविधाओं पर विचार करें।

परिस्थितिजन्य तरीका

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

 void Mob::Move() { if(CanMove()==true) {//   -  x += Way.x * Speed; y += Way.y * Speed; } else {//   -  Vector Turn;//   Turn.x = 1;//    Turn.y = 0; AddVector(Turn, DistanceToBarrier());//  } } 

बेशक, मेरे उदाहरण में रोटेशन वेक्टर पूरी तरह से सही नहीं है, क्योंकि वेक्टर वी (1,0) को जोड़ते समय रोटेशन की दिशा आंदोलन की वर्तमान दिशा पर निर्भर करेगी। लेकिन सार, मुझे लगता है, समझ में आता है।

लक्ष्य के तरीके

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

 class Mob { public: float x,y;// float,      float Speed; Vector Way;//  Vector Points[10];//   Vector PointsVec[10];//    int Position;//    void Normalize(); void AddVector(Vector NewWay); void Move(); }; void Mob::Move() { if(x==Points[Position].x && y==Points[Position].y) {//    Position++;//    Way.x = PointsVec[Position].x;//    Way.y = PointsVec[Position].y; } else{//   -   x += Way.x * Speed; y += Way.y * Speed; } } 

वेक्टर विधि के कई फायदे हैं:

1. चिकनी चाल
2. प्राकृतिक आंदोलनों
3. भौतिकी को लागू करने की क्षमता (घर्षण, त्वरण, घूर्णन, गुरुत्वाकर्षण, ...)

लेकिन इसके कई नुकसान हैं:

1. कभी-कभी बहुत संसाधन-गहन (सामान्यीकरण में जड़ की गणना करना, आदि)
2. जटिल कार्य जो मूल बातें (विशेष रूप से भौतिकी के कार्यान्वयन के संबंध में) की अच्छी समझ की आवश्यकता होती है
3. आसपास की दुनिया के बारे में जानकारी प्राप्त करने में कठिनाई (आपको सभी संभावित वस्तुओं के साथ टकराव की गणना करने की आवश्यकता है)

इस पद्धति का व्यापक रूप से उपयोग किया जाता है, खासकर जहां यह अधिक सटीक और खूबसूरती से संप्रेषित करने के लिए आवश्यक है। और यह आधुनिक 3 डी गेम का बहुमत है। अगले, और अंतिम, लेख में, मैं आंदोलन को लागू करने के लिए मिश्रित तरीकों के बारे में बात करूंगा, दोनों टाइल और वेक्टर आंदोलनों का संयोजन।