ฉันกำลังสร้างเกมอวกาศ 2 มิติและต้องทำให้ยานอวกาศดักจับดาวเคราะห์ ฉันมีรหัสการทำงานสำหรับการสกัดกั้นเส้นตรง แต่ไม่สามารถหาวิธีคำนวณตำแหน่งของดาวเคราะห์ในวงโคจรเป็นวงกลมได้

เกมไม่ถูกต้องทางวิทยาศาสตร์ดังนั้นฉันจึงไม่กังวลเกี่ยวกับความเฉื่อยแรงโน้มถ่วงวงโคจรรูปไข่ ฯลฯ

ฉันรู้ตำแหน่งยานอวกาศและความเร็วรวมถึงดาวเคราะห์วงโคจร (Radius) และความเร็ว

โซลูชันการวิเคราะห์สำหรับสิ่งนี้เป็นเรื่องยาก แต่เราสามารถใช้การค้นหาแบบไบนารีเพื่อค้นหาวิธีแก้ไขภายในความแม่นยำที่จำเป็น

เรือสามารถไปถึงจุดที่ใกล้ที่สุดบนวงโคจรในเวลาt_min :

shipOrbitRadius = (ship.position - planet.orbitCenter).length;
shortestDistance = abs(shipOrbitRadius - planet.orbitRadius);
t_min = shortestDistance/ship.maxSpeed;

เรือสามารถไปถึงจุดใดก็ได้บนวงโคจรในเวลาน้อยกว่าหรือเท่ากับt_max :

(ที่นี่เพื่อความเรียบง่ายฉันคิดว่าเรือสามารถขับผ่านดวงอาทิตย์ได้ถ้าคุณต้องการหลีกเลี่ยงสิ่งนี้คุณจะต้องเปลี่ยนไปใช้เส้นทางที่ไม่ใช่เส้นตรงอย่างน้อยในบางกรณี "วงจูบ" อาจดูดีและโคจร กลไก -y โดยไม่ต้องเปลี่ยนอัลกอริทึมมากกว่าปัจจัยคงที่)

if(shipOrbitRadius > planet.orbitRadius)
{
   t_max = planet.orbitRadius * 2/ship.maxSpeed + t_min;
}
else
{
   t_max = planet.orbitRadius * 2/ship.maxSpeed - t_min;
}

หากระยะเวลาการโคจรของเราสั้นเราอาจสามารถปรับปรุงขอบเขตบนนี้ได้โดยเลือกที่t_maxจะเป็นครั้งแรกหลังจากt_minนั้นดาวเคราะห์ก็เข้าใกล้จุดเริ่มต้นของเรือมากที่สุด ใช้ค่าใดของค่าสองค่าt_maxนี้ที่น้อยกว่า ดูคำตอบนี้ในภายหลังเพื่อหาสาเหตุของการทำงาน

ตอนนี้เราสามารถใช้การค้นหาแบบไบนารีระหว่างขั้วเหล่านี้t_minและt_max เราจะค้นหาค่า t ที่ทำให้เกิดข้อผิดพลาดใกล้กับศูนย์:

error = (planet.positionAtTime(t) - ship.position).squareMagnitude/(ship.maxSpeed*ship.maxSpeed) - t*t;

(การใช้โครงสร้างนี้ข้อผิดพลาด @ t_min> = 0 และข้อผิดพลาด @ t_max <= 0 ดังนั้นจะต้องมีอย่างน้อยหนึ่งจุดตัดที่มีข้อผิดพลาด = 0 สำหรับค่า t ในระหว่าง)

ฟังก์ชั่นตำแหน่งเป็นอะไรที่ ...

Vector2 Planet.positionAtTime(float t)
{
  angle = atan2(startPosition - orbitCenter) + t * orbitalSpeedInRadians;
  return new Vector2(cos(angle), sin(angle)) * orbitRadius + orbitCenter;
}

โปรดทราบว่าหากระยะเวลาการโคจรของดาวเคราะห์สั้นมากเมื่อเทียบกับความเร็วของเรือฟังก์ชั่นข้อผิดพลาดนี้อาจเปลี่ยนสัญญาณหลายครั้งในช่วงจาก t_min ถึง t_max ติดตามคู่ที่เร็วที่สุด & ve ได้ที่คุณพบและทำการค้นหาต่อไปเรื่อย ๆ จนกว่าข้อผิดพลาดจะใกล้ถึงศูนย์ ("ใกล้พอ" ที่ไวต่อหน่วยของคุณและบริบทการเล่นเกมตารางครึ่งระยะเวลาเฟรมอาจ ทำงานได้ดี - ช่วยให้มั่นใจว่าการสกัดกั้นนั้นแม่นยำภายในเฟรม)

เมื่อคุณมีข้อผิดพลาดในการลดความผิดพลาดได้ดีคุณสามารถชี้เรือไปที่ดาวเคราะห์ได้ตำแหน่งเวลา (t) และเร่งความเร็วเต็มที่มั่นใจว่าโลกจะไปถึงจุดนั้นในเวลาเดียวกันกับที่คุณทำ

คุณสามารถค้นหาวิธีแก้ปัญหาภายในการวนซ้ำ Log_2 ((2 * orbitRadius / ship.maxSpeed) / errorThreshold) ตัวอย่างเช่นถ้าเรือของฉันสามารถเคลื่อนที่วงโคจรใน 60 เฟรมและฉันต้องการการสกัดกั้นที่แม่นยำภายในหนึ่งเฟรมฉันจะต้องใช้การประมาณ 6 ครั้ง

อย่ามายุ่งกับเรื่องนี้ นี่ไม่ใช่วิธีการแก้ปัญหา "สมบูรณ์แบบ" แต่ควรใช้กับเกมส่วนใหญ่และความไม่สมบูรณ์ใด ๆ ที่ผู้เล่นมองไม่เห็น

if(!OldTargetPoint)
  TargetPoint = PlanetPosition;
else
  TargetPoint = OldTargetPoint;
Distance = CurPosition - TargetPoint;
TimeNeeded = Distance / Speed;
TargetPoint = PlanetPositionInFuture(TimeNeeded);
SteerTowards(TargetPoint);
[...repeat this every AI update, for example every second...]

1. คำนวณเวลาที่จำเป็นในการเข้าถึงจุดเป้าหมาย
2. คำนวณตำแหน่งของดาวเคราะห์ในเวลาที่คำนวณ
3. เลื่อนไปยังจุดที่คำนวณ
4. ทำซ้ำ

สิ่งนี้ใช้ได้ผลเพราะยานอวกาศใกล้เข้ามาถึงจุดต่ำสุดความผิดพลาดจะสูงขึ้น ดังนั้นการคำนวณจึงมีเสถียรภาพมากขึ้นเมื่อเวลาผ่านไป

ข้อผิดพลาดคือความแตกต่างระหว่างเวลาที่ต้องการจากการคำนวณเพื่อไปยังดาวเคราะห์ (TimeNeeded) และเวลาที่แท้จริงในการเข้าถึงโลก (หลังจากพิจารณา TargetPoint ใหม่)

เริ่มกันเลยโดยการดูคณิตศาสตร์ที่อยู่เบื้องหลังปัญหา

ขั้นตอนที่ 1:

การหาจุดตัดระหว่างเส้นและรูปร่างเป็นเพียงการแทรกสมการของเส้นตรงในสมการของรูปร่างซึ่งเป็นวงกลมในกรณีนี้

ใช้วงกลมที่มีศูนย์คและรัศมีR จุดpอยู่บนวงกลมถ้า

$$|p - c|^2 = r^2$$

$p = p0 + \mu v$

$$|p0 + \mu v - c|^2 = r^2$$

ระยะทางยกกำลังสองสามารถเขียนใหม่เป็นผลิตภัณฑ์แบบจุด ( http://en.wikipedia.org/wiki/Dot_product )

$$(p0 + \mu v - c)•(p0 + \mu v - c) = r^2$$

$a = c - p0$$(\mu v - a)•(\mu v - a) = r^2$

$\mu ^2(v•v) - 2\mu (a•v) + a•a = r^2$

$|v| = 1$

$$\mu ^2 - 2\mu (a•v) + |a|2 - r^2 = 0$$

ซึ่งเป็นสมการกำลังสองอย่างง่ายและเรามาถึงวิธีแก้ปัญหา

$$\mu = a • v +- sqrt((a • v)^2 *a^2 – r^2)$$

$\mu < 0$เส้นของเรือในกรณีของคุณไม่ได้ตัดกับวงโคจรของดาวเคราะห์

$\mu = 0$บรรทัดของเรือจะสัมผัสวงกลมในจุดเดียว

$\mu$ค่าที่สอดคล้องกับจุดสองจุดบนวงโคจร!

ขั้นตอนที่ 2:

$\mu$

เราสามารถทำอะไรกับเรื่องนี้? ทีนี้เรารู้ระยะทางที่เรือต้องเดินทางและจุดใดที่จะสิ้นสุดลง!

$p = p0 + \mu v$$\mu v$

ทีนี้สิ่งที่เหลือไว้ให้ทำก็คือการคำนวณว่าดาวเคราะห์ควรอยู่ที่ไหนเมื่อเรือเริ่มเข้าสู่วงโคจรของมัน สิ่งนี้คำนวณได้อย่างง่ายดายด้วยPolar coodinates ที่เรียกว่า( http://mathworld.wolfram.com/PolarCoordinates.html )

$$x = c + r*cos(θ)$$

$$y = c + r*sin(θ)$$

$t*angularVelocity$

สรุป

เลือกเส้นสำหรับเรือของคุณและรันคณิตศาสตร์เพื่อดูว่ามันชนกับดาวเคราะห์วงโคจรหรือไม่ หากเป็นเช่นนั้นให้คำนวณเวลาที่ใช้ในการไปยังจุดนั้น ใช้เวลานี้เพื่อกลับสู่วงโคจรจากจุดนี้กับดาวเคราะห์เพื่อคำนวณว่าดาวเคราะห์ควรอยู่ที่ใดเมื่อเรือเริ่มเคลื่อนที่

ต่อไปนี้เป็นวิธีแก้ปัญหา "ออกนอกกรอบ" เล็กน้อยสองรายการ

คำถามคือเมื่อเรือเคลื่อนที่เป็นเส้นตรงด้วยความเร็วที่กำหนดและดาวเคราะห์เคลื่อนที่เป็นวงกลมที่มีรัศมีที่ความเร็วเชิงมุมที่กำหนดและตำแหน่งเริ่มต้นของดาวเคราะห์และเรือกำหนดทิศทางของเวกเตอร์ของเรือ เส้นตรงควรอยู่ในการวางแผนการสกัดกั้น

แนวทางที่หนึ่ง: ปฏิเสธหลักฐานของคำถาม ปริมาณที่ "เลื่อนได้" ในคำถามคือมุม แต่แก้ไขให้ดี ชี้เรือตรงไปที่ศูนย์กลางของวงโคจร

• คำนวณตำแหน่งที่เรือจะเผชิญหน้ากับดาวเคราะห์ นั่นเป็นเรื่องง่าย
• คำนวณระยะทางจากเรือไปยังตำแหน่งสกัดกั้น ยังง่าย
• คำนวณเวลาที่ใช้จนกว่าดาวเคราะห์จะไปถึงตำแหน่งดัก ง่าย.
• แบ่งระยะทางจากเรือถึงจุดตัดตามเวลาจนกว่าดาวเคราะห์จะถึงจุดตัด
• ถ้ามันเล็กกว่าหรือเท่ากับความเร็วสูงสุดของเรือคุณก็เสร็จแล้ว ตั้งเรือที่เคลื่อนที่ด้วยความเร็วนั้นตรงเข้าหาดวงอาทิตย์
• มิฉะนั้นให้เพิ่มระยะเวลาการโคจรของดาวเคราะห์เข้ากับเวลาแล้วลองอีกครั้ง ทำเช่นนั้นต่อไปจนกว่าคุณจะได้ความเร็วที่เพียงพอสำหรับเรือ

แนวทางที่สอง: อย่าใช้งานกับระบบอัตโนมัติเลย สร้างมินิเกมที่ผู้เล่นจะต้องใช้เครื่องขับดันเพื่อเข้าหาดาวเคราะห์และหากพวกเขาตีมันด้วยความเร็วที่สูงเกินไปพวกเขาจะระเบิด แต่พวกเขาก็มีเชื้อเพลิง จำกัด เช่นกัน ทำให้ผู้เล่นเรียนรู้วิธีการแก้ปัญหาดักจับ!

หากคุณไม่ต้องการใช้พิกัดเชิงขั้วให้พิจารณาว่าตำแหน่งที่เป็นไปได้ทั้งหมดของเรือเป็นรูปกรวย $(x, y, t)$ช่องว่าง สมการนี้คือ

$$t \cdot v = \sqrt{x^2 + y^2}$$

ที่ไหน $v$คือความเร็วของเรือ จะถือว่าเรือเริ่มต้นที่ศูนย์

ตำแหน่งของดาวเคราะห์ในอวกาศและเวลาสามารถถูกทำให้เป็นจุดได้โดยเช่น

$$\begin{align} x &= x_0 + r \cdot cos(w \cdot u + a) \\ y &= y_0 + r \cdot sin(w \cdot u + a) \\ t &= u \end{align}$$

ที่ไหน $u$ ไปจาก $0$ สูงกว่า $w$ คือความเร็วเชิงมุมและ $a$คือมุมเริ่มต้นของดาวเคราะห์ ณ เวลาศูนย์ จากนั้นแก้ปัญหาที่เรือและดาวเคราะห์สามารถพบกันในเวลาและสถานที่ คุณได้สมการ$u$ เพื่อแก้ปัญหา:

$$\begin{align} u \cdot v &= \sqrt{ (x0 + r \cdot cos(w \cdot u + a))^2 + (y_0 + r \cdot sin(w \cdot u + a))^2 } \implies\\ u^2 \cdot v^2 &= (x_0 + r \cdot cos(w \cdot u + a))^2 + (y_0 + r \cdot sin(w \cdot u + a))^2 \implies\\ u^2 \cdot v^2 &= {x_0}^2 + {y_0}^2 + r^2 + 2 \cdot x_0 \cdot r \cdot cos(w \cdot u + a) + 2 \cdot y_0 \cdot r \cdot sin(w \cdot u + a) \end{align}$$

This equation needs to be solved numerically. It may have many solutions. By eyeballing it, it seems it always has a solution

Here's part of a solution. I didn't get to finish it in time. I'll try again later.

If I understand correctly, you have a planet's position & velocity, as well as a ship's position and speed. You want to get the ship's movement direction. I'm assuming the ship's and planet's speeds are constant. I also assume, without loss of generality, that the ship is at (0,0); to do this, subtract the ship's position from the planet's, and add the ship's position back onto the result of the operation described below.

Unfortunately, without latex, I can't format this answer very well, but we'll attempt to make do. Let:

• s_s = the ship's speed (s_s.x, s_s.y, likewise)
• s_a = the ship's bearing (angle of movement, what we want to calculate)
• p_p = the planet's initial position, global coords
• p_r = the planet's distance (radius) from the center of orbit, derivable from p_p
• p_a = the planet's initial angle in radians, relative to the center of orbit
• p_s = the planet's angular velocity (rad/sec)
• t = the time to collision (this turns out to be something we must calculate as well)

Here's the equations for the position of the two bodies, broken down into components:

ship.x = s_s.x * t * cos(s_a)
ship.y = s_s.y * t * sin(s_a)

planet.x = p_r * cos(p_a + p_s * t) + p_p.x
planet.y = p_r * sin(p_a + p_s * t) + p_p.y

Since we want ship.x = planet.x and ship.y = planet.y at some instant t, we obtain this equation (the y case is nearly symmetrical):

   s_s.x * t * cos(s_a) = p_r * cos(p_a + p_s * t) + p_p.x
   s_s.y * t * sin(s_a) = p_r * sin(p_a + p_s * t) + p_p.y

Solving the top equation for s_a:

   s_s.x * t * cos(s_a) = p_r * cos(p_a + p_s * t) + p_p.x
=> s_a = arccos((p_r * cos(p_a + p_s * t) + p_p.x) / (s_s.x * t))

Substituting this into the second equation results in a fairly terrifying equation that Wolfram alpha won't solve for me. There may be a better way to do this not involving polar coordinates. If anyone wants to give this method a shot, you're welcome to it; I've made this a wiki. Otherwise, you may want to take this to the Math StackExchange.

I would fix the location at which to intercept (graze the circle, at the "outgoing" side of the orbit.)

Now you just have to adjust the spaceship's speed so that planet and ship reach that point at the same time.

Note that the rendez-vous could be after N more orbits, depending how far away the ship is, and how fast the planet is orbiting the star.

Pick the N that in time, comes nearest to the ship's journey duration at current speed.

Then speed up or slow down ship to match the timestamp for those N orbits exactly.

In all this, the actual course is already known! Just not the speed.