動くシューターから動くターゲットを導く方法

私はこの質問を見ました：オブジェクトをそのターゲットに導くために敵の位置を予測しました。私の状況は少し異なりますが。

ターゲットが動き、射手が動きます。また、シューターの速度は弾丸の速度に追加されます。つまり、右にスライドしている間に発射された弾丸は、右に向かうほど大きな速度になります。

私がやろうとしていることは、敵に、プレイヤーを攻撃するために撃つ必要がある場所を決定させることです。リンクされたSOソリューションを使用すると、プレイヤーと敵が静止していない限り、速度の違いによりミスが発生します。どうすればそれを防ぐことができますか？

スタックオーバーフローの回答から提示されたソリューションは次のとおりです。要約すると、次の形式の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は等しいことに注意してください。

さて、これに正気を入れましょう。私はあなたがまったく簡単にしていないと思います、あなたのコードはコンパイルせず、変数名に関して一貫性がなく（数行後にplayerVelocityXなりplayerXvelocityますか？何xVelocityですか？）、そして冗長すぎます。かなりの労力を費やさない限り、デバッグは基本的に不可能です。

だから、ここに修正するものがあります：

弾丸の速度

弾丸の速度は30、期間でなければなりません。計算を行う必要はありません。複雑さを回避するために、参照フレームの変更が正確に行われます。メインリファレンスフレームに戻ったときに、解決策を見つけた後にのみ敵の速度を追加します。

ソリューションの妥当性

timeソリューションがポジティブであることを確認していません。

多数のコーディングエラー

あなたはテストtime1してtime2いますが、常にtime1結果で使用しています。

あなたはplayerXvelocity - yVelocityどちらが矛盾していますか。

の/ 2 * a代わりにやっています/ (2.f * a)。これは最悪のエラーであり、すべてがうまくいかない理由です。

あなたが計算shootxし、弾丸のshooty最終的な位置として、あなたが探しているのは弾丸の速度です。

固定コード

float const bulletSpeed = 30.f;
/* Relative player position */
float const dx = playerX - enemyX;
float const dy = playerY - enemyY;
/* Relative player velocity */
float const vx = playerVelocityX - enemyVelocityX;
float const vy = playerVelocityY - enemyVelocityY;

float const a = vx * vx + vy * vy - bulletSpeed * bulletSpeed;
float const b = 2.f * (vx * dx + vy * dy);
float const c = dx * dx + dy * dy;
float const disc = b * b - 4.f * a * c;

shouldShoot = false;

if (disc >= 0.f)
{
    float t0 = (-b - std::sqrt(disc)) / (2.f * a);
    float t1 = (-b + std::sqrt(disc)) / (2.f * a);
    /* If t0 is negative, or t1 is a better solution, use t1 */
    if (t0 < 0.f || (t1 < t0 && t1 >= 0.f))
        t0 = t1;
    if (t0 >= 0.f)
    {
        /* Compute the ship's heading */
        shootx = vx + dx / t0;
        shooty = vy + dy / t0;
        heading = std::atan2(shooty, shootx) * RAD2DEGREE;
        /* Compute the bullet's velocity by adding the enemy's velocity */
        bulletVelocityX = shootx + enemyVelocityX;
        bulletVelocityY = shooty + enemyVelocityY;

        shouldShoot = true;
    }
}

シューターを動かすことは、シューターを静止させることと同じです。ターゲットの動きベクトルから射手の動きベクトルを引くだけです。

Target [-5,0]
Shooter [4,1]
Target - Shooter = [-5,0] - [4,1] = [-9,-1]

発砲ベクトル/初期角度を計算してから、通常のようにターゲットの移動ベクトルを弾丸に追加します。

再帰アルゴリズムを使用した予測ターゲティングの問題の解決策を考案して実装した例を次に示します。http：//www.newarteest.com/flash/targeting.html （私は静止したシューティングゲームを持っていますが、同じアプローチがムービングシューター）

1ステップで計算する方が効率的であるため、他のいくつかの解決策を試してみる必要がありますが、私が思いついた解決策は、目標位置を推定し、その結果をアルゴリズムにフィードバックして新しいものを作成することでしたより正確な推定、数回繰り返す。

最初の推定では、ターゲットの現在の位置で「発砲」し、三角法を使用して、ショットが発砲した位置に到達したときにターゲットがどこにあるかを決定します。次に、次のイテレーションでその新しい位置で「発砲」し、今度はターゲットがどこになるかを決定します。約4回繰り返した後、1ピクセル以内の精度になりました。

2D物理演算（Z速度なし）のみを使用しているため、この問題は大幅に簡略化できます。これを行う簡単な方法は、ワールド座標に対して相対的に動くソースとターゲットの両方について考えるのをやめ、ソースに対して相対的に動くターゲットだけを考えることです（そしてソースを静止したままにします）。

Vector TargetInitialPosition = new Vector ( target.X - source.X ,
                                            target.Y - source.Y );
Vector TargetApparentVelocity = new Vector( target.velocityX - source.velocityX ,
                                            target.velocityY - source.velocityY );

通常、弾丸の速度は射手の速度よりもはるかに速いため、通常、弾丸は独立していると想定されますが、ヘリコプターや戦闘機から発砲するなど、これが当てはまらない場合もあります。

次に、弾丸の速度を計算する必要があります。

// Your directional vector MUST be normalized...
Vector BulletVelocity = new Vector( source.directionX * Bullet::StaticSpeed + source.velocityX ,
                                     source.directionY * Bullet::StaticSpeed + source.velocityY );

あなたが抱えている問題は、弾丸がそれらに到達するまでにターゲットが動いていることです。

TargetPosition = TargetInitialPosition + TargetApparentVelocity * t
BulletPosition = BulletInitialPosition + BulletVelocity * t
               = BulletVelocity * t

TargetPosition == BulletPositionを解くと、弾丸がターゲットに当たるはずです。これで、未知数は3つ、方程式は2つだけになりました。一次導関数を取ることで「t」を削除できます。

TargetInitialPosition + ( TargetApparentVelocity - BulletVelocity ) * t == 0
dV / dt = TargetApparentVelocity - BulletVelocity

目標を達成するために、あなたは望みdV/dt == -TargetInitialPosition * kます。定数はX座標とY座標で同じである必要があり、弾丸がターゲットに当たるまでにかかる秒数です。

TargetApparentVelocity.X - BulletVelocity.X == k * -TargetInitialPosition.X
k = ( BulletVelocity.X - TargetApparentVelocity.X ) / TargetInitialPosition.X
----------------------
TargetApparentVelocity.Y - BulletVelocity.Y == k * -TargetInitialPosition.Y
k = ( BulletVelocity.Y - TargetApparentVelocity.Y ) / TargetInitialPosition.Y

それらを等しくする：

( BulletVelocity.X - TargetApparentVelocity.X ) / TargetInitialPosition.X
= ( BulletVelocity.Y - TargetApparentVelocity.Y ) / TargetInitialPosition.Y

または変数を展開するには：

( source.directionX * Bullet::StaticSpeed + source.velocityX - target.velocityX + source.velocityX ) / ( target.X - source.X )
 == ( source.directionY * Bullet::StaticSpeed + source.velocityY - target.velocityY + source.velocityY ) / ( target.Y - source.Y )

次に代数はあなたにあなたの最終的な方程式を与えます：

source.directionY = ( target.velocityY * ( source.X - target.X ) - 2 * source.velocityY * ( source.X - target.X ) + ( Bullet::Speed * source.directionX + 2 * source.velocityX - target.velocityX ) * ( source.Y - target.Y ) ) / ( Bullet::Speed * ( source.X - target.X ) )

次の部分は乱雑で、コードにどのように実装するかはあなた次第ですが、これを代入してベクトルを正規化するだけです。

sqrt( source.directionX ^ 2 + source.directionY ^ 2 ) == 1

結局、未知数が1つだけの方程式（source.directionX）になり、directionXの代わりにそれを解いて、代入してdirectionYを取得できます。

私はこのコードのいずれもテストしていませんし、私が行った数学上の間違いを指摘していただいてもかまいませんが、理論は正しいはずです:)。

幸運を。

これは3Dジオメトリの問題です。

まず、シューターとターゲットの相対位置と相対速度が必要です。

Pos = TargetPos - ShooterPos
Vel = TargetVel - ShooterVel

次に、方程式を解く必要があります。

Pos + t * Vel = t * FireSpeed * [x , +-sqrt(1-x^2)]

以下のためtとx。

それは：

x = ( PosX + t * VelX ) / ( t * FireSpeed )

( PosY + t * VelY ) / ( t * FireSpeed ) = +-sqrt(1 - (( PosX + t * VelX ) / ( t * FireSpeed ))^2 )
=>
( PosY + t * VelY )^2 / ( t * FireSpeed )^2 = 1 - (( PosX + t * VelX ) / ( t * FireSpeed ))^2
=>
( PosY + t * VelY )^2 + ( PosX + t * VelX )^2 = ( t * FireSpeed )^2
<=>
( Dot(Vel,Vel) - FireSpeed^2 ) * t^2 + 2 * Dot(Vel,Pos) * t + Dot(Pos,Pos) = 0

これらの方程式の最後は、簡単な2次方程式であり、解く必要があります。肯定的な結果ごとに、結果を方程式に挿入します。

FireVector = Vel + Pos / t

これにより、可能な射撃ベクトルがすべて得られるはずですt。は、ショットにかかる時間です。

注あればそれFireSpeedの大きさよりも大きいVelだけで一つの解決策があるだろうが、あればFireSpeedあるだけ小さいシングル、ダブルソリューション2つのソリューションまたはnoneすべてで、あるいは特殊なケースでがあるかもしれません。

編集：数学を正しく行うと、この答えはあまり良くありません。