इलाके के खिलाफ खिलाड़ी को कैसे सुचारू रूप से स्लाइड करना है

Question

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

मुझे लगता है कि मैं लगभग वहाँ हूँ, लेकिन मैं आखिरी टुकड़ा नहीं रख सकता।

अपडेट: सभी को अच्छी खबर! मेरे पास काम है। लेकिन ... मैं थोड़ा भ्रमित हूं कि मुझे क्या सामान्य होना चाहिए और क्या नहीं। सामान्य को सिर्फ एक इकाई वेक्टर होने की आवश्यकता है, है ना? लेकिन फिर मैं अपने इनपुट के साथ मिश्रण कर रहा हूं ताकि मैं इसे सामान्य कर रहा हूं - क्या मैं गलत हूं?

वैसे, मैंने यह भी पाया है कि मुझे खिलाड़ी 1 पिक्सेल को सामान्य की दिशा में धकेलने की आवश्यकता है, ताकि वे चीजों पर अटक न जाए - अच्छा काम करता है।

Answer 1

प्लेन पर अपनी वेक्टर की गति को सामान्य रखें और फिर अपने वेक्टर ऑफ़ मोशन से परिणाम को घटाएं।

Vector undesiredMotion = normal * (dotProduct(input, normal));
Vector desiredMotion = input - undesiredMotion;

वैसे भी कुछ। यद्यपि आपके प्यारे आरेख में इनपुट दीवार से दूर लगता है इसलिए मैं थोड़ा भ्रमित हूं।

Comments

खेद है कि वह वहाँ एक खड़ी दीवार के सामने रहने वाला है। भयानक चित्रण

— Iain

मैं डॉट प्रोडक्ट को लेकर थोड़ा भ्रमित हूं। क्या डॉट उत्पाद एक अदिश राशि नहीं है?

— इयान

हां, लेकिन आप अपने अवांछित गति के वेक्टर को प्राप्त करने के लिए इसे सामान्य (एक वेक्टर) से गुणा करते हैं। एक सदिश (x, y, z) अदिश गुणा से आपको सदिश (sx, sy, sz) मिलता है।

— क्रिस होवे

हो गया, चर को उम्मीद से बदलकर आरेख से मेल करें। :)

— क्रिस होवे

@ मैं वास्तव में यह समझने की कोशिश कर रहा हूं कि इस उत्तर का उपयोग कैसे किया जाए लेकिन मैं इसे समझ नहीं सकता। जब मैं यह सटीक कोड बनाता हूं तो मुझे वास्तव में अजीब desiredMotionपरिणाम मिलते हैं। क्या आपको कभी यह काम मिला?

— परीक्षण

Answer 2

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

// assume that 'normal' is unit length
Vector GetDesired(Vector input, Vector normal) {
   // tune this to get where you stop when you're running into the wall,
   // vs. bouncing off of it
   static float k_runningIntoWallThreshold = cos(DEG2RAD(45));

   // tune this to "fudge" the "push away" from the wall
   static float k_bounceFudge = 1.1f;

   // normalize input, but keep track of original size
   float inputLength = input.GetLength();
   input.Scale(1.0f / inputLength);

   float dot = DotProduct(input, normal);

   if (dot < 0)
   {
      // we're not running into the wall
      return input;
   }
   else if (dot < k_runningIntoWallThreshold)
   {
      Vector intoWall = normal.Scale(dot);
      intoWall.Scale(k_bounceFudge);

      Vector alongWall = (input - intoWall).Normalize();
      alongWall.Scale(inputLength);

      return alongWall;
   }
   else
   {
      // we ran "straight into the wall"
      return Vector(0, 0, 0);
   }
}

Comments

अच्छा लगा। लेकिन अगर आप एक ठगना कारक द्वारा पैमाने पर करते हैं जो आपको दीवार के साथ टकराता है बनाम इसके साथ फिसल जाता है, या यह सिर्फ इसे ट्विक करने का मामला है?

— क्रिस होवे

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

— डैश-टॉम-बैंग