2Dゲーム：発射物とユニットの交差を予測することにより、移動するターゲットに向けて発砲します
さて、これはすべて素敵でシンプルな2Dの世界で行われます... :)
位置Aposに静的オブジェクトAがあり、BposにbVelocityの直線的に移動するオブジェクトBがあり、速度Avelocityの弾薬ラウンドがあるとします。
Bの線速度とAの弾薬の速度を考慮して、AがBを打つために撃たなければならない角度をどのように見つけることができますか？
現在、照準はオブジェクトの現在の位置にあります。つまり、発射物がそこに到達するまでに、ユニットはより安全な位置に移動しています:)
まず、ABが垂直になるように軸を回転させます（回転を実行することにより）
ここで、Bの速度ベクトルをx成分とy成分（たとえばBxとBy）に分割します。これを使用して、撮影する必要のあるベクトルのx成分とy成分を計算できます。
_B --> Bx
|
|
V
By
Vy
^
|
|
A ---> Vx
__Vx = Bx_とSqrt(Vx*Vx + Vy*Vy) = Velocity of Ammoが必要です。
これにより、新しいシステムで必要なベクトルが得られます。古いシステムに変換して戻すと、完了です（反対方向に回転することによって）。
xtank しばらく前に、照準サブルーチンを作成しました。私はそれをどのようにしたかをレイアウトしようとします。
免責事項：ここのどこかで1つ以上のばかげた間違いをした可能性があります。さびた数学のスキルで推論を再構築しようとしています。ただし、これは数学のクラスではなくプログラミングのQ＆Aであるため、最初に追いかけます:-)
どうやるか
つまり、次の形式の2次方程式を解くことになります。
_a * sqr(x) + b * x + c == 0
_sqrとは、平方根ではなく、平方を意味することに注意してください。次の値を使用します。
_a := sqr(target.velocityX) + sqr(target.velocityY) - sqr(projectile_speed)
b := 2 * (target.velocityX * (target.startX - cannon.X)
+ target.velocityY * (target.startY - cannon.Y))
c := sqr(target.startX - cannon.X) + sqr(target.startY - cannon.Y)
_これで、判別式を調べて、可能な解決策があるかどうかを判断できます。
_disc := sqr(b) - 4 * a * c
_判別式が0未満の場合は、ターゲットを攻撃することを忘れてください。発射物が時間内に到達することはありません。それ以外の場合は、2つの候補ソリューションを検討してください。
_t1 := (-b + sqrt(disc)) / (2 * a)
t2 := (-b - sqrt(disc)) / (2 * a)
__disc == 0_の場合、_t1_と_t2_は等しいことに注意してください。
障害物が介在するなど、他に考慮事項がない場合は、小さい方の正の値を選択してください。 （負のt値を使用するには、時間を逆方向に起動する必要があります！）
選択したt値をターゲットの位置方程式に代入して、狙うべきリーディングポイントの座標を取得します。
_aim.X := t * target.velocityX + target.startX
aim.Y := t * target.velocityY + target.startY
_導出
時間Tで、発射体は、経過時間に発射体の速度を掛けたものに等しい、大砲からの（ユークリッド）距離でなければなりません。これにより、経過時間のパラメトリックな円の方程式が得られます。
_sqr(projectile.X - cannon.X) + sqr(projectile.Y - cannon.Y)
== sqr(t * projectile_speed)
_同様に、時間Tで、ターゲットはベクトルに沿って時間×速度を掛けて移動しました。
_target.X == t * target.velocityX + target.startX
target.Y == t * target.velocityY + target.startY
_大砲からの距離が発射体の距離と一致すると、発射体はターゲットに命中する可能性があります。
_sqr(projectile.X - cannon.X) + sqr(projectile.Y - cannon.Y)
== sqr(target.X - cannon.X) + sqr(target.Y - cannon.Y)
_素晴らしい！ target.Xとtarget.Yの式を代入すると、次のようになります。
_sqr(projectile.X - cannon.X) + sqr(projectile.Y - cannon.Y)
== sqr((t * target.velocityX + target.startX) - cannon.X)
+ sqr((t * target.velocityY + target.startY) - cannon.Y)
_方程式の反対側を代入すると、次のようになります。
_sqr(t * projectile_speed)
== sqr((t * target.velocityX + target.startX) - cannon.X)
+ sqr((t * target.velocityY + target.startY) - cannon.Y)
_...両側からsqr(t * projectile_speed)を減算し、それを反転します。
_sqr((t * target.velocityX) + (target.startX - cannon.X))
+ sqr((t * target.velocityY) + (target.startY - cannon.Y))
- sqr(t * projectile_speed)
== 0
_...部分式を2乗した結果を解決します...
_sqr(target.velocityX) * sqr(t)
+ 2 * t * target.velocityX * (target.startX - cannon.X)
+ sqr(target.startX - cannon.X)
+ sqr(target.velocityY) * sqr(t)
+ 2 * t * target.velocityY * (target.startY - cannon.Y)
+ sqr(target.startY - cannon.Y)
- sqr(projectile_speed) * sqr(t)
== 0
_...そして同様の用語をグループ化する.。
_sqr(target.velocityX) * sqr(t)
+ sqr(target.velocityY) * sqr(t)
- sqr(projectile_speed) * sqr(t)
+ 2 * t * target.velocityX * (target.startX - cannon.X)
+ 2 * t * target.velocityY * (target.startY - cannon.Y)
+ sqr(target.startX - cannon.X)
+ sqr(target.startY - cannon.Y)
== 0
_...次にそれらを組み合わせる...
_(sqr(target.velocityX) + sqr(target.velocityY) - sqr(projectile_speed)) * sqr(t)
+ 2 * (target.velocityX * (target.startX - cannon.X)
+ target.velocityY * (target.startY - cannon.Y)) * t
+ sqr(target.startX - cannon.X) + sqr(target.startY - cannon.Y)
== 0
_...tで標準的な2次方程式を与えます。この方程式の正の実数ゼロを見つけると、（ゼロ、1、または2つの）可能なヒット位置が得られます。これは、2次方程式で実行できます。
_a * sqr(x) + b * x + c == 0
x == (-b ± sqrt(sqr(b) - 4 * a * c)) / (2 * a)
_ここでジェフリーハンティンの優れた答えに+1。私はグーグルで調べて、私が興味を持ったケース（2D空間での単純な定速発射体）について複雑すぎるか、具体的にはないソリューションを見つけました。
私が付け加えたい1つのポイントは、判別式が否定的であることに加えて、注意しなければならないいくつかの特別なケースがあるということです。
- "a == 0"：ターゲットと発射物が同じ速度で移動している場合に発生します。 （解は二次ではなく線形です）
- "a == 0およびb == 0"：ターゲットと発射物の両方が静止している場合。 （c == 0、つまりsrcとdstが同じ点でない限り、解決策はありません。）
コード：
/**
* Return the firing solution for a projectile starting at 'src' with
* velocity 'v', to hit a target, 'dst'.
*
* @param Object src position of shooter
* @param Object dst position & velocity of target
* @param Number v speed of projectile
* @return Object Coordinate at which to fire (and where intercept occurs)
*
* E.g.
* >>> intercept({x:2, y:4}, {x:5, y:7, vx: 2, vy:1}, 5)
* = {x: 8, y: 8.5}
*/
function intercept(src, dst, v) {
var tx = dst.x - src.x,
ty = dst.y - src.y,
tvx = dst.vx,
tvy = dst.vy;
// Get quadratic equation components
var a = tvx*tvx + tvy*tvy - v*v;
var b = 2 * (tvx * tx + tvy * ty);
var c = tx*tx + ty*ty;
// Solve quadratic
var ts = quad(a, b, c); // See quad(), below
// Find smallest positive solution
var sol = null;
if (ts) {
var t0 = ts[0], t1 = ts[1];
var t = Math.min(t0, t1);
if (t < 0) t = Math.max(t0, t1);
if (t > 0) {
sol = {
x: dst.x + dst.vx*t,
y: dst.y + dst.vy*t
};
}
}
return sol;
}
/**
* Return solutions for quadratic
*/
function quad(a,b,c) {
var sol = null;
if (Math.abs(a) < 1e-6) {
if (Math.abs(b) < 1e-6) {
sol = Math.abs(c) < 1e-6 ? [0,0] : null;
} else {
sol = [-c/b, -c/b];
}
} else {
var disc = b*b - 4*a*c;
if (disc >= 0) {
disc = Math.sqrt(disc);
a = 2*a;
sol = [(-b-disc)/a, (-b+disc)/a];
}
}
return sol;
}
ジェフリー・ハンティンは、この問題に対する優れた解決策を持っていますが、彼の派生は非常に複雑です。下部に結果のコードのいくつかを使用して、それを導出するよりクリーンな方法を次に示します。
X.yを使用してベクトルの内積を表します。ベクトルの量が二乗されている場合は、それ自体を点在させていることを意味します。
origpos = initial position of shooter
origvel = initial velocity of shooter
targpos = initial position of target
targvel = initial velocity of target
projvel = velocity of the projectile relative to the Origin (cause ur shooting from there)
speed = the magnitude of projvel
t = time
t時間に対する発射体とターゲットの位置は、いくつかの方程式で記述できることがわかっています。
curprojpos(t) = origpos + t*origvel + t*projvel
curtargpos(t) = targpos + t*targvel
これらをある点（交点）で互いに等しくしたいので、それらを互いに等しく設定して、自由変数projvelを解きましょう。
origpos + t*origvel + t*projvel = targpos + t*targvel
turns into ->
projvel = (targpos - origpos)/t + targvel - origvel
原点とターゲットの位置/速度の概念を忘れましょう。代わりに、あるものの動きは別のものに対して相対的であるため、相対的な用語で作業しましょう。この場合、現在の状態はrelpos = targetpos - originposとrelvel = targetvel - originvelです。
projvel = relpos/t + relvel
projvelが何であるかはわかりませんが、projvel.projvelをspeed^2と等しくする必要があることはわかっているので、両側を2乗して次のようにします。
projvel^2 = (relpos/t + relvel)^2
expands into ->
speed^2 = relvel.relvel + 2*relpos.relvel/t + relpos.relpos/t^2
これで、自由変数は時間tだけであることがわかります。次に、tを使用してprojvelを解きます。二次方程式でtを解きます。最初にそれをa、b、およびcに分離し、次に根を解きます。
ただし、解決する前に、tが最小である最良の解決策が必要であることを忘れないでください。ただし、tが負でないことを確認する必要があります（過去に何かをヒットすることはできません）。
a = relvel.relvel - speed^2
b = 2*relpos.relvel
c = relpos.relpos
h = -b/(2*a)
k2 = h*h - c/a
if k2 < 0, then there are no roots and there is no solution
if k2 = 0, then there is one root at h
if 0 < h then t = h
else, no solution
if k2 > 0, then there are two roots at h - k and h + k, we also know r0 is less than r1.
k = sqrt(k2)
r0 = h - k
r1 = h + k
we have the roots, we must now solve for the smallest positive one
if 0<r0 then t = r0
elseif 0<r1 then t = r1
else, no solution
ここで、tの値がある場合、tを元の方程式に戻し、projvelを解くことができます。
projvel = relpos/t + relvel
さて、発射体を撃つために、発射体の結果のグローバルな位置と速度は
globalpos = origpos
globalvel = origvel + projvel
これで完了です。
Luaでのソリューションの実装。vec* vecはベクトル内積を表します。
local function lineartrajectory(origpos,origvel,speed,targpos,targvel)
local relpos=targpos-origpos
local relvel=targvel-origvel
local a=relvel*relvel-speed*speed
local b=2*relpos*relvel
local c=relpos*relpos
if a*a<1e-32 then--code translation for a==0
if b*b<1e-32 then
return false,"no solution"
else
local h=-c/b
if 0<h then
return origpos,relpos/h+targvel,h
else
return false,"no solution"
end
end
else
local h=-b/(2*a)
local k2=h*h-c/a
if k2<-1e-16 then
return false,"no solution"
elseif k2<1e-16 then--code translation for k2==0
if 0<h then
return origpos,relpos/h+targvel,h
else
return false,"no solution"
end
else
local k=k2^0.5
if k<h then
return origpos,relpos/(h-k)+targvel,h-k
elseif -k<h then
return origpos,relpos/(h+k)+targvel,h+k
else
return false,"no solution"
end
end
end
end
以下は、C++の極座標ベースの照準コードです。
直交座標で使用するには、最初にターゲットの相対座標を角度/距離に変換し、ターゲットのx/y速度を角度/速度に変換する必要があります。
「速度」入力は、発射物の速度です。計算では速度の比率のみが使用されるため、速度とtargetSpeedの単位は関係ありません。出力は、発射物が発射される角度と衝突点までの距離です。
アルゴリズムは、 http://www.turtlewar.org/ で入手可能なソースコードからのものです。
// C++
static const double pi = 3.14159265358979323846;
inline double Sin(double a) { return sin(a*(pi/180)); }
inline double Asin(double y) { return asin(y)*(180/pi); }
bool/*ok*/ Rendezvous(double speed,double targetAngle,double targetRange,
double targetDirection,double targetSpeed,double* courseAngle,
double* courseRange)
{
// Use trig to calculate coordinate of future collision with target.
// c
//
// B A
//
// a C b
//
// Known:
// C = distance to target
// b = direction of target travel, relative to it's coordinate
// A/B = ratio of speed and target speed
//
// Use rule of sines to find unknowns.
// sin(a)/A = sin(b)/B = sin(c)/C
//
// a = asin((A/B)*sin(b))
// c = 180-a-b
// B = C*(sin(b)/sin(c))
bool ok = 0;
double b = 180-(targetDirection-targetAngle);
double A_div_B = targetSpeed/speed;
double C = targetRange;
double sin_b = Sin(b);
double sin_a = A_div_B*sin_b;
// If sin of a is greater than one it means a triangle cannot be
// constructed with the given angles that have sides with the given
// ratio.
if(fabs(sin_a) <= 1)
{
double a = Asin(sin_a);
double c = 180-a-b;
double sin_c = Sin(c);
double B;
if(fabs(sin_c) > .0001)
{
B = C*(sin_b/sin_c);
}
else
{
// Sin of small angles approach zero causing overflow in
// calculation. For nearly flat triangles just treat as
// flat.
B = C/(A_div_B+1);
}
// double A = C*(sin_a/sin_c);
ok = 1;
*courseAngle = targetAngle+a;
*courseRange = B;
}
return ok;
}
2D空間を狙うためにこのバージョンをハッキングしたばかりで、まだ十分にテストしていませんが、機能しているようです。その背後にある考え方はこれです：
銃口からターゲットを指すベクトルに垂直なベクトルを作成します。衝突が発生するためには、このベクトル（軸）に沿ったターゲットと発射体の速度が同じである必要があります！かなり単純なコサインのものを使用して、私はこのコードに到達しました：
private Vector3 CalculateProjectileDirection(Vector3 a_MuzzlePosition, float a_ProjectileSpeed, Vector3 a_TargetPosition, Vector3 a_TargetVelocity)
{
// make sure it's all in the horizontal plane:
a_TargetPosition.y = 0.0f;
a_MuzzlePosition.y = 0.0f;
a_TargetVelocity.y = 0.0f;
// create a normalized vector that is perpendicular to the vector pointing from the muzzle to the target's current position (a localized x-axis):
Vector3 perpendicularVector = Vector3.Cross(a_TargetPosition - a_MuzzlePosition, -Vector3.up).normalized;
// project the target's velocity vector onto that localized x-axis:
Vector3 projectedTargetVelocity = Vector3.Project(a_TargetVelocity, perpendicularVector);
// calculate the angle that the projectile velocity should make with the localized x-axis using the consine:
float angle = Mathf.Acos(projectedTargetVelocity.magnitude / a_ProjectileSpeed) / Mathf.PI * 180;
if (Vector3.Angle(perpendicularVector, a_TargetVelocity) > 90.0f)
{
angle = 180.0f - angle;
}
// rotate the x-axis so that is points in the desired velocity direction of the projectile:
Vector3 returnValue = Quaternion.AngleAxis(angle, -Vector3.up) * perpendicularVector;
// give the projectile the correct speed:
returnValue *= a_ProjectileSpeed;
return returnValue;
}
これは、再帰的アルゴリズムを使用して予測ターゲティングの問題の解決策を考案して実装した例です。 http://www.newarteest.com/flash/targeting.html
提示された他の解決策のいくつかを試してみる必要があります。1つのステップで計算する方が効率的だと思われるためですが、私が思いついた解決策は、ターゲット位置を推定し、その結果をアルゴリズムにフィードバックして新しいものを作成することでした。より正確な見積もり、数回繰り返す。
最初の見積もりでは、ターゲットの現在の位置で「発射」し、次に三角法を使用して、ショットが発射された位置に到達したときにターゲットがどこにあるかを決定します。次に、次の反復で、その新しい位置で「発砲」し、今回はターゲットがどこにあるかを決定します。約4回繰り返した後、1ピクセルの精度で取得できます。
この問題を数学的に解決する方法はたくさんありますが、これは私のクラスが高校で行う必要のあるプロジェクトに関連するコンポーネントであり、このプログラミングクラスの全員が微積分のバックグラウンドを持っているわけではありません。 、それで私はより多くのプログラミングアプローチでこの問題を解決する方法を作成しました。交点は正確ですが、数学的な計算よりも1フレーム遅れてヒットする可能性があります。
考えてみましょう：
S = shooterPos, E = enemyPos, T = targetPos, Sr = shooter range, D = enemyDir
V = distance from E to T, P = projectile speed, Es = enemy speed
この問題の標準的な実装では、[S、E、P、Es、D]がすべて与えられ、適切なタイミングでTを打つように、Tまたは射撃する角度を見つけるために解決しています。
この問題を解決する方法の主な側面は、シューターの範囲を、任意の時点で撃つことができるすべての可能なポイントを含む円と見なすことです。この円の半径は次のとおりです。
Sr = P*time
ここで、時間はループの反復として計算されます。
したがって、時間の反復を前提として敵が移動する距離を見つけるために、ベクトルを作成します。
V = D*Es*time
ここで、実際に問題を解決するために、ターゲット（T）からシューター（S）までの距離がシューター（Sr）の範囲よりも小さいポイントを見つけたいと思います。これは、この方程式の擬似コードの実装です。
iteration = 0;
while(TargetPoint.hasNotPassedShooter)
{
TargetPoint = EnemyPos + (EnemyMovementVector)
if(distanceFrom(TargetPoint,ShooterPos) < (ShooterRange))
return TargetPoint;
iteration++
}
ここでパブリックドメインのUnityC＃関数を作成しました：
http://ringofblades.com/Blades/Code/PredictiveAim.cs
これは3D用ですが、Vector3をVector2に置き換え、重力がある場合は重力に選択した下軸を使用することで、これを2D用に簡単に変更できます。
理論に興味がある場合は、ここで数学の導出について説明します。
http://www.gamasutra.com/blogs/KainShin/20090515/83954/Predictive_Aim_Mathematics_for_AI_Targeting.php
ここから解決策の1つを取得しましたが、いずれもシューターの動きを考慮していません。射手が動いている場合は、それを考慮に入れることをお勧めします（射撃時の弾丸の速度に射手の速度を追加する必要があるため）。本当にあなたがする必要があるのは、ターゲットの速度からあなたの射手の速度を引くことです。したがって、上記のbroofaのコード（私がお勧めします）を使用している場合は、行を変更してください
tvx = dst.vx;
tvy = dst.vy;
に
tvx = dst.vx - shooter.vx;
tvy = dst.vy - shooter.vy;
そして、あなたはすべて設定されている必要があります。
基本的に、ここでは交差点の概念は実際には必要ありません。発射体の動きを使用している限り、特定の角度でヒットし、撮影時にインスタンス化するだけで、ソースからターゲットまでの正確な距離を取得できます。距離が決まったら、ターゲットに命中するために撃つべき適切な速度を計算できます。
次のリンクは、概念を明確にし、役立つと考えられており、役立つ可能性があります。 常に移動するターゲットに当たる投射物の動き