तीन आयामी गतिशील दुनिया में वर्णों के लिए ऐ, पाथफाइन, पाथफॉल (भाग 1)

इस लेख ने मुझे एक लेख लिखने के लिए प्रेरित किया , साथ ही इस तथ्य को भी बताया कि फिलहाल मैं अपने सर्वर के लिए एक काफी उन्नत AI के विकास को पूरा कर रहा हूं। यहाँ वर्णित सब कुछ मैं पहले से ही सर्वर पर उपयोग करता हूं और यह काम करता है।

चक्र के अंत में (मुझे उम्मीद है कि मेरे पास कुछ लेखों के लिए पर्याप्त है), मैं महल के रक्षकों और उस पर हमलावरों के लिए एक ऐआई बनाने की कोशिश करूंगा, और यह महल के बारे में पहले से कुछ भी नहीं जानता होगा, यह किसी भी तरह से नहीं जीता है, और हमलावर संयोग से दिखाई देंगे।

आइए थोड़ा बाहर शुरू करें - पाथफॉल के साथ, अर्थात्। पहले से ही पाए गए पथ के साथ आगे बढ़ना और आम तौर पर राक्षसों / एनपीसी के आंदोलन से। हम बाद में इस पथ को खोजने के तरीके के बारे में बात करेंगे ... और इसलिए, चलें।

स्थिति

हम तीन आयामी दुनिया में काम करेंगे। सिद्धांत रूप में, कुछ एल्गोरिदम विशेष रूप से क्यूब थ्री-डायमेंशनल दुनिया (मिनीक्राफ्ट) पर लागू हो सकते हैं, लेकिन मैं एल्गोरिथ्म को बदलने के लिए जानकारी को पूरक करने का प्रयास करूंगा ताकि यह एक चिकनी दुनिया में काम करे। Y निर्देशांक ऊपर की ओर है, अगर अचानक किसी को पता नहीं है या एक अलग समन्वय प्रणाली का उपयोग करता है।

मैं एक एल्गोरिथ्म का वर्णन करता हूं, जिसके साथ आप किसी वस्तु को सीधे लाल बिंदु से नीले रंग की एक नीली आकृति में ले जा सकते हैं, इससे पहले कि वह पीले बिंदु पर न लाए।

वस्तु स्वयं "कोने के चारों ओर" जाएगी। इसके अलावा, एक ही चीज ऊर्ध्वाधर बाधाओं के साथ काम करती है, जबकि ऑब्जेक्ट उछलता है और एक बाधा पर चढ़ने की कोशिश करता है। यही है, वर्णित एल्गोरिथ्म ऑब्जेक्ट को उस बिंदु पर ला सकता है जिसे पहुंचा जा सकता है यदि आप सीधे जाते हैं और कूदते हैं; प्रत्येक बाधा के चारों ओर एक रास्ता देखना आवश्यक नहीं है और इस पथ पर लेट जाना है जहाँ आपको कूदने की आवश्यकता है।

वस्तु

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

• टकराव में तुरंत नहीं रुकना चाहिए। उदाहरण के लिए, यदि हम वेक्टर (0.3, 0.0, 0.5) (x, y, z, क्रमशः) के साथ एक वस्तु को स्थानांतरित करते हैं, तो यदि 0.2 से x गुजरने के बाद वस्तु एक बाधा का सामना करती है, तो यह रुकना नहीं चाहिए, लेकिन y और z के साथ आगे बढ़ना जारी रखना चाहिए। यह आवश्यक है, अन्यथा दीवारों के पास आंदोलन पर्याप्त रूप से चिकना नहीं होगा।
• अपने काम के अंत में, फ़ंक्शन को 2 झंडे सेट करना चाहिए: ऑनग्राउंड और स्टैहोर क्षैतिज रूप से । पहला झंडा कहता है कि उसके आंदोलन के बाद, एंटिटी एक ठोस सतह पर थी, आमतौर पर जमीन पर, लेकिन शायद दूसरे एंटिटी पर। इसकी गणना सरलता से की जाती है:

  if(dy != 0.0D) onGround = dy < 0.0D && dy != movedY; 

  
  कहां डाई कितनी वस्तु y अक्ष के साथ चलना चाहती थी, कहां स्थानांतरित किया गया था वास्तव में कितना योग y अक्ष के साथ स्थानांतरित किया गया है। जैसा कि आप देख सकते हैं, onGround = true अगर इकाई नीचे चल रही थी और सभी वांछित दूरी (बाधा को रोका) नहीं जा सका। दूसरा झंडा अधिक जटिल है:
  

   stuckHorizontally = false; if(Math.abs(dz) > Math.abs(dx)) { if(movedZ == 0.0D) stuckHorizontally = true; } else { if(movedX == 0.0D) stuckHorizontally = true; } 

  
  dx , dz , स्थानांतरितZ और मूलाधार , पिछले उदाहरण से उम्मीद के मुताबिक समझा जा सकता है। फ़ंक्शन टकराव को वास्तव में "बड़ी" अक्ष के साथ मानता है, क्योंकि यह हमारी वस्तु के अनावश्यक "कूद" से बचने में मदद करता है। इसे बड़ी संख्या में प्रयोगों की मदद से विकसित किया गया था, मैं बेहतर विचारों के सुझावों को सुनने के लिए तैयार हूं। शुरुआत में, ध्वज झूठे पर रीसेट हो जाता है।

एंटिटी में कुछ और चर जोड़ें जो इसके आंदोलन का वर्णन करेंगे:

• motX , motY , motZ - चर जो कि वस्तु की वर्तमान गति का संकेत देते हैं। यह गति नहीं है! ये अन्य वस्तुएं हैं जो इस वस्तु पर लागू होती हैं, अपने स्वयं के आंदोलन की गिनती नहीं!
• पिच और यव वस्तु के रोटेशन के कोण हैं। पहला ऊर्ध्वाधर झुकाव को निर्धारित करता है - -90 से (बिल्कुल नीचे दिखता है) से 90 तक (बिल्कुल ऊपर दिखता है), दूसरा क्षैतिज रूप से - 0 से 360 तक।
• MoveX और MoveZ - वस्तु के अगले "चरण" के बारे में जानकारी संग्रहीत करने के लिए एक जगह के रूप में काम करेगा।
• गति और जम्पस्पीड - मीटर प्रति सेकंड में वस्तु की गति और कूदते समय वस्तु को दी जाने वाली गति। ये ऐसे पैरामीटर हैं जो शुरुआत में निर्धारित होते हैं। ताकि वस्तु 1 मीटर ऊंची छलांग लगा सके। छलांग लगभग 6 मीटर / सेकेंड होनी चाहिए।
• lastTick - मिलीसेकंड में समय जब हम अंतिम संसाधित ऑब्जेक्ट आंदोलनों (सेकंड में गति के लिए, टिक नहीं)

एल्गोरिथ्म

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

 float secDiff = (System.currentTimeMillis() - lastTick) / 1000.0F; //    ,      if(secDiff > 0.5F) //   ,   ,       //  ,       ,       secDiff = 0.5F; lastTick = System.currentTimeMillis(); //    moveForward(speed * secDiff); if(stuckHorizontally) { //    if(onGround) { //     if(lastJumping + 500 < System.currentTimeMillis()) { jump(); //    lastJumping = System.currentTimeMillis(); //   .      :) } } } applyForces(secDiff); //  motX, motY  motZ   

दो मुख्य कार्य हैं MoveForward (फ्लोट) और applyForces (फ्लोट)। पहला एक आंदोलन करता है, दूसरा वस्तु पर लागू बलों को लागू करता है।

 protected void moveForward(float distance) { /* *        . *   — distance — ,       */ moveSpeedX = (float) -Math.sin(this.yaw / 180.0F * (float) Math.PI) * distance; moveSpeedZ = (float) Math.cos(this.yaw / 180.0F * (float) Math.PI) * distance; //   —  Java,  -   Java,  -0.0F    ... if(moveSpeedX == -0.0F) moveSpeedX = 0.0F; if(moveSpeedZ == -0.0F) moveSpeedZ = 0.0F; //     ,    ... if(moveSpeedX != 0.0F || moveSpeedZ != 0.0F) this.move(moveSpeedX, 0.0D, moveSpeedZ); // ,   ,     .      ,   ,      Minecraft } 

जैसा कि मैंने पहले कहा था, कोड के इस टुकड़े को निष्पादित करने के बाद, कदम फ़ंक्शन को ऊपर दी गई शर्तों के अनुसार स्टैहोरहॉन्गली फ्लैग सेट करना होगा। यह onGround फ्लैग को नहीं बदलता है, क्योंकि डाई 0 है, तो applyForces इस फ्लैग से निपटेगा । यदि अटारी क्षैतिज रूप से सच और ऑनग्राउंड में भी सेट है, तो आपको कूदने की आवश्यकता है। कूद समारोह यह करेगा:

 protected void jump() { this.motY = jumpSpeed; } 

बस वस्तु को एक गति दें ... ठीक है, और बल का उपयोग करें । यहां आप रचनात्मकता दिखा सकते हैं, जो दुनिया पर निर्भर करता है, वह वातावरण जिसमें वस्तु स्थित है, घर्षण और अन्य दिलचस्प बन्स। मैं एक सरल उदाहरण दूंगा:

 private void applyForces(float secDiff) { //      ,        -. if(Math.abs(this.motX) < 0.1D) this.motX = 0.0F; if(Math.abs(this.motY) < 0.1D) this.motY = 0.0F; if(Math.abs(this.motZ) < 0.1D) this.motZ = 0.0F; /** *    .    , *     ,    *  .    . */ float friction = Constants.ENTITY_FLYING_FRICTION; //   0.98.   —   . 0.0 —  . if(this.motY * secDiff != 0.0D || this.motX * secDiff != 0.0D || this.motZ * secDiff != 0.0D) //  0,    ,  this.move(this.motX * secDiff, this.motY * secDiff, this.motZ * secDiff); this.motY -= Constants.GRAVITATION * secDiff; //       /* *   */ this.motX -= this.motX * friction * secDiff; this.motY -= this.motY * friction * secDiff; this.motZ -= this.motZ * friction * secDiff; } 

असल में, यह संपूर्ण एल्गोरिथ्म है। (घर्षण के साथ सावधान रहें ... मेरा फ़ंक्शन 1 से अधिक सेकंड या 1 से अधिक घर्षण के लिए डिज़ाइन नहीं किया गया है!)

MoveForward और applyForces में दो के बजाय एक बार मूव फंक्शन को कॉल क्यों न करें? वास्तव में, आप कर सकते हैं। आप सीधे callForces में स्थानांतरित करने के लिए कॉल में MoveX और MoveZ जोड़ सकते हैं। लेकिन तब टकराकर क्षैतिज रूप से यह गलत हो सकता है। अपने लिए तय करें कि कहां संतुलन बेहतर होगा।

संक्षेप में प्रस्तुत करना

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

 public class Entity { public float speed = 3.0F; public float jumpSpeed = 6.0F; private long lastJumping = 0; private boolean stuckHorizontally = false; public boolean onGround = true; protected float moveSpeedX; protected float moveSpeedZ; public float motX; public float motY; public float motZ; public void tick() { float secDiff = (System.currentTimeMillis() - lastTick) / 1000.0F; //    ,      if(secDiff > 0.5F) //   ,   ,       //  ,       ,       secDiff = 0.5F; lastTick = System.currentTimeMillis(); //    moveForward(speed * secDiff); if(stuckHorizontally) { //    if(onGround) { //     if(lastJumping + 500 < System.currentTimeMillis()) { jump(); //    lastJumping = System.currentTimeMillis(); //   .      :) } } } applyForces(secDiff); //  motX, motY  motZ } private void moveForward(float distance) { /* *        . *   — distance — ,       */ moveSpeedX = (float) -Math.sin(this.yaw / 180.0F * (float) Math.PI) * distance; moveSpeedZ = (float) Math.cos(this.yaw / 180.0F * (float) Math.PI) * distance; //   —  Java,  -   Java,  -0.0F    ... if(moveSpeedX == -0.0F) moveSpeedX = 0.0F; if(moveSpeedZ == -0.0F) moveSpeedZ = 0.0F; //     ,    ... if(moveSpeedX != 0.0F || moveSpeedZ != 0.0F) this.move(moveSpeedX, 0.0D, moveSpeedZ); // ,   ,     .      ,   ,      Minecraft } private void applyForces(float secDiff) { //      ,        -. if(Math.abs(this.motX) < 0.1D) this.motX = 0.0F; if(Math.abs(this.motY) < 0.1D) this.motY = 0.0F; if(Math.abs(this.motZ) < 0.1D) this.motZ = 0.0F; /** *    .    , *     ,    *  .    . */ float friction = Constants.ENTITY_FLYING_FRICTION; //   0.98.   —   . 0.0 —  . if(this.motY * secDiff != 0.0D || this.motX * secDiff != 0.0D || this.motZ * secDiff != 0.0D) //  0,    ,  this.move(this.motX * secDiff, this.motY * secDiff, this.motZ * secDiff); this.motY -= Constants.GRAVITATION * secDiff; //       /* *   */ this.motX -= this.motX * friction * secDiff; this.motY -= this.motY * friction * secDiff; this.motZ -= this.motZ * friction * secDiff; } public abstract void move(float dx, float dy, float dz); } 

और क्या चाहिए।

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

एक निष्कर्ष के बजाय

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

आप देख सकते हैं कि यह सब मेरे सर्वर पर कैसे काम करता है। प्रोफ़ाइल में लिंक करें।