/ / 2 डी खेल आंदोलन इंजन बनाने में अटक गया - 2 डी

2 डी गेम आंदोलन इंजन बनाने में फंस गया - 2 डी

मैं अपने टॉप-डाउन 2 डी गेम के लिए एक आंदोलन इंजन बना रहा हूं, लेकिन मैं निम्नलिखित समस्या को हल करने की कोशिश कर रहा हूं:

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

छद्म के बिना, पहली बिंदु के लिए स्यूडोकोड:

gameTick(){

tempX += LeftKeyHeld ? -1 : 0;
tempX += RightKeyHeld ? 1 : 0;
tempY += UpKeyHeld ? -1 : 0;
tempY += DownKeyHeld ? 1 : 0;
ratio = 0.71;

if( |tempX| == |tempY| ) {
tempX =tempX* ratio;
tempY =tempY* ratio;
}
player.x += tempX;
player.y += tempY;
}

मैं घर्षण को हल कर सकता हूं (लंबाई प्राप्त करनाआंदोलन वेक्टर, घर्षण द्वारा इसे कम करने, इसे एक ही एक्स: वाई अनुपात के साथ वापस पेश करने), हालांकि, मैं maxSpeed ​​किए जाने के आसपास अपने सिर को लपेट नहीं सकता।

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

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

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

आपकी सहायताके लिए धन्यवाद!

उत्तर:

उत्तर № 1 के लिए 1

आपको इस बारे में एक दिन से अधिक समय तक नहीं सोचने के लिए खेद है, लेकिन मैंने इसे हल करने में कामयाब रहा, और यह कोड की दो पंक्तियों में नहीं है। (हालांकि विचारों के लिए सभी के लिए अभी भी धन्यवाद)

क्योंकि मैं आलसी और थक गया हूं, मैंने इसे दो स्यूडोकोड को छोड़कर छद्म कोड में नहीं बदला:

updateGame(){
player.walk();
player.move();
}
player.move(){
player.x += player.speedX
player.y += player.speedY
}

और कोड (जावा):

public void walk() {
float tempX = 0;
float tempY = 0;
float accelX;
float accelY;
float nextSpeedX;
float nextSpeedY;
float nextSpeed;
float speed;
tempX += walkLeft ? -1 : 0;
tempX += walkRight ? 1 : 0;
tempY += walkUp ? -1 : 0;
tempY += walkDown ? 1 : 0;

if (Math.abs(tempX) == Math.abs(tempY)) {
tempX = (float) tempX * rat;
tempY = (float) tempY * rat;
}

accelX = tempX * (float) runSpeed;
accelY = tempY * (float) runSpeed;
speed = (float) Math.sqrt(speedX * speedX + speedY * speedY);
nextSpeedX = speedX + accelX;
nextSpeedY = speedY + accelY;
nextSpeed = (float) Math.sqrt(nextSpeedX * nextSpeedX + nextSpeedY * nextSpeedY);

if (nextSpeed > maxSpeed) { //can"t accelerate by running
if (nextSpeed > speed) {  //wants to accelerate
if (speed > maxSpeed) {  //the current speed is larger than maximum.
float diff = (float)(speed / nextSpeed);
float greenX = nextSpeedX*diff;
float greenY = nextSpeedY*diff;
accelX = greenX-speedX;
accelY = greenY-speedY;
} else { //speed <= maxspeed
float diff = (float)(maxSpeed / nextSpeed);
float greenX = nextSpeedX*diff;
float greenY = nextSpeedY*diff;
accelX = greenX-speedX;
accelY = greenY-speedY;
}
} else { //wants to slow! allow it!
//acceleration doesn"t need to be changed
}
} else { //no problem, allow it!
//acceleration doesn"t need to be changed
}
speedX += accelX;
speedY += accelY;
}

छोटा हो सकता है, थोड़ा और अनुकूलित हो सकता है, लेकिन यह काम करता है। मुझे आशा है कि यह "भविष्य में इस समस्या पर ठोकर खाएगा।


जवाब के लिए 0 № 2

नीचे जोड़ें:

 If (|tempX|>maxSpeed)
tempX=maxSpeed*sign(tempX);

If (|tempY|>maxSpeed)
tempY=maxSpeed*sign(tempX);

कहा पे int संकेत (एक्स) { अगर एक्स <0 वापसी -1; }


जवाब के लिए 0 № 3

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

यदि वेग अधिकतम स्पीड से अधिक हो जाता है, लेकिन विपरीत तरफ से तीर कुंजियां दबाई जा रही हैं, तो आप अधिकतम वेग को अधिकतम स्पीड से ऊपर रखें और केवल नकारात्मक त्वरण लागू करें।