ฉันจะหมุนวัตถุโดยอิงจากอ็อฟเซ็ตของวัตถุอื่นได้อย่างไร?


25

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

ภาพต่อไปนี้แสดงให้เห็นถึงปัญหาของฉัน:ป้อนคำอธิบายรูปภาพที่นี่

หากฉันมีป้อมปืน "LookAt ()" เป้าหมายเลเซอร์ที่มาจากปืนใหญ่จะพลาดเป้าหมายที่กล่าวไปทั้งหมด

ถ้านี่เป็นสถานการณ์จากบนลงล่างอย่างสมบูรณ์และปืนใหญ่ขนานกับป้อมปืนแล้วตรรกะของฉันบอกฉันว่าเป้าหมายปลอมควรอยู่ในตำแหน่งที่เท่ากับเป้าหมายจริงบวกกับออฟเซ็ตที่เท่ากับระหว่าง ป้อมปืนและปืนใหญ่ อย่างไรก็ตามในสถานการณ์จริงของฉันกล้องของฉันมีมุม60ºและปืนใหญ่มีการหมุนเล็กน้อย

ภาพต่อไปนี้แสดงให้เห็นถึงสถานการณ์: สถานการณ์จำลอง

ฉันไม่แน่ใจอย่างแน่นอนว่าทำไม แต่ถ้าฉันใช้การชดเชยแบบเดียวกันดูเหมือนว่าจะทำงานได้ในขณะที่เล็งไปที่ระยะทางจากป้อมปืน

ตรรกะของฉันมีข้อบกพร่องหรือไม่ ฉันขาดพื้นฐานบางอย่างที่นี่หรือไม่?

การแก้ไขขั้นสุดท้าย: โซลูชันที่ได้รับจาก @JohnHamilton อัพเดตล่าสุดแก้ไขปัญหานี้ได้อย่างแม่นยำ ตอนนี้ฉันได้ลบรหัสและรูปภาพที่ฉันใช้เพื่อแสดงการใช้งานที่ไม่ถูกต้องของฉัน


จากมุมมองของการออกแบบอาวุธคุณก็สามารถแก้ไขปืนของคุณ ;)
เวย์นเวอร์เนอร์

@WayneWerner นี่ไม่ใช่ตัวเลือกในกรณีของฉัน มันเป็นตัวเลือกการออกแบบที่ให้มันคด แต่ใช้งานได้
Franconstein

1
ฉันได้เพิ่มเป็นตัวอย่างการทำงานเพื่อให้คำตอบของฉัน
ens

ดูเหมือนว่าคำตอบจะสมบูรณ์แบบ ... คุณช่วยพูดถึงรายละเอียดที่คุณต้องการได้อย่างแน่นอน?
Seyed Morteza Kamali

คำตอบ:


31

คำตอบนั้นง่ายมากถ้าคุณคิดเลข คุณมีระยะทางคงที่ของ Y และระยะทางตัวแปร X (ดูรูปที่ 1) คุณต้องหามุมระหว่าง Z และ X และหมุนป้อมปืนของคุณให้มากขึ้น ป้อนคำอธิบายรูปภาพที่นี่

ขั้นตอนที่ 1 - หาระยะห่างระหว่างแนวป้อมปืน (V) และแนวปืน (W) ซึ่งเป็น Y (นี่คงที่ แต่ไม่เจ็บในการคำนวณ) รับระยะทางจากป้อมปืนไปยังเป้าหมาย (ซึ่งก็คือ X)

ขั้นตอนที่ 2 - หาร Y ด้วย X จากนั้นรับค่าไฮเพอร์โบลิกไซน์ของค่า

double turnRadians = Mathf.Asin(Y/X);
double angle = Mathf.Rad2Deg * turnRadians;

//where B is the red dot, A is a point on the X line and C is a point on the Z line.

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

gameObject.transform.Rotate(Vector3.up, turnAngle);

แน่นอนในกรณีนี้คุณจำเป็นต้องใช้มันเพื่อเปิดทวนเข็มนาฬิกาดังนั้นคุณอาจต้องเพิ่มลบในด้านหน้าของ turnAngle -turnAngleมีในขณะที่

แก้ไขบางส่วน ขอบคุณ @ens ที่ชี้ให้เห็นความแตกต่างของระยะทาง

OP กล่าวว่าปืนของเขามีมุมดังนั้นเราไปดูภาพก่อนอธิบายในภายหลัง: ป้อนคำอธิบายรูปภาพที่นี่

เรารู้อยู่แล้วจากการคำนวณก่อนหน้านี้ว่าจะเล็งไปที่เส้นสีแดงตามเส้นสีฟ้า ดังนั้นเล็งไปที่เส้นสีน้ำเงินก่อน:

float turnAngle = angleBetweenTurretAndTarget - angleBetweenTurretAndGun;
turret.transform.Rotate(Vector3.up, turnAngle);

การคำนวณเพียงอย่างเดียวที่แตกต่างกันที่นี่คือการคำนวณ "X Prime" (X ') เพราะมุมระหว่างปืนและป้อมปืน (มุม "a") เปลี่ยนระยะห่างระหว่างเส้น

//(this part had a mistake of using previous code inside new variable names, YPrime and Y are shown as X' and X in the 2nd picture.
float YPrime = Cos(a)*Y; //this part is what @ens is doing in his answer
double turnRadians = Mathf.Asin(YPrime/X);
double angle = Mathf.Rad2Deg * turnRadians;
turret.transform.Rotate(Vector3.up, angle);

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

มีสองวิธีในการหามุม "a" หนึ่งวิธีคือ transform.up:

float angleBetween = Vector3.Angle(turret.transform.up, gun.transform.up);

เทคนิคข้างต้นจะคำนวณในแบบ 3 มิติดังนั้นหากคุณต้องการผลลัพธ์แบบ 2 มิติคุณต้องกำจัดแกน Z (นั่นคือสิ่งที่ฉันคิดว่าแรงโน้มถ่วงอยู่ที่ใด แต่ถ้าคุณเปลี่ยนอะไรเลยในเอกภาพมันคือแกน Y ที่ขึ้นหรือลง ie แรงโน้มถ่วงอยู่บนแกน Y ดังนั้นคุณอาจต้องเปลี่ยนสิ่งต่าง ๆ ):

Vector2 turretVector = new Vector2(turret.transform.up.x, turret.transform.up.y);
Vector2 gunVector = new Vector2(gun.transform.up.x, gun.transform.up.y);
float angleBetween = Vector2.Angle(turretVector, gunVector);

วิธีที่สองคือวิธีการหมุน (ฉันกำลังคิดแบบ 2D ในกรณีนี้):

double angleRadians = Mathf.Asin(turret.transform.rotation.z - gun.transform.rotation.z);
double angle = 2 * Mathf.Rad2Deg * angleRadians;

อีกครั้งรหัสเหล่านี้จะให้ค่าที่เป็นบวกกับคุณดังนั้นคุณอาจต้องเพิ่มหรือลบจำนวนขึ้นอยู่กับมุม (มีการคำนวณด้วยเช่นกัน แต่ฉันจะไม่ไปในเชิงลึก) จุดเริ่มต้นที่ดีคือVector2.Dotวิธีการใน Unity

บล็อกสุดท้ายของรหัสสำหรับคำอธิบายเพิ่มเติมเกี่ยวกับสิ่งที่เรากำลังทำอยู่:

//turn turret towards target
turretTransform.up = targetTransform.position - turretTransform.position;
//adjust for gun angle
if (weaponTransform.localEulerAngles.z <180) //if the value is over 180 it's actually a negative for us
    turretTransform.Rotate(Vector3.forward, 90 - b - a);
else
    turretTransform.Rotate(Vector3.forward, 90 - b + a);

หากคุณทำทุกอย่างถูกต้องคุณควรได้ฉากเช่นนี้ ( ลิงก์สำหรับ unitypackage ): ป้อนคำอธิบายรูปภาพที่นี่ สิ่งที่ฉันหมายถึงโดยค่าบวกเสมอ:ป้อนคำอธิบายรูปภาพที่นี่

วิธี Z สามารถให้ค่าลบ:ป้อนคำอธิบายรูปภาพที่นี่

สำหรับฉากตัวอย่างรับunitypackage จากลิงค์นี้

นี่คือรหัสที่ฉันใช้ในฉาก (บนป้อมปืน):

public class TurretAimCorrection : MonoBehaviour
{
    public Transform targetTransform;
    public Transform turretTransform;
    public Transform weaponTransform;

    private float f, d, x, y, h, b, a, weaponAngle, turnAngle;
    private void Start()
    {
        TurnCorrection();
    }

    private void Update()
    {
        TurnCorrection();
    }
    void TurnCorrection()
    {
        //find distances and angles
        d = Vector2.Distance(new Vector2(targetTransform.position.x, targetTransform.position.y), new Vector2(turretTransform.position.x, turretTransform.position.y));
        x = Vector2.Distance(new Vector2(turretTransform.position.x, turretTransform.position.y), new Vector2(weaponTransform.position.x, weaponTransform.position.y));
        weaponAngle = weaponTransform.localEulerAngles.z;
        weaponAngle = weaponAngle * Mathf.Deg2Rad;
        y = Mathf.Abs(Mathf.Cos(weaponAngle) * x);
        b = Mathf.Rad2Deg * Mathf.Acos(y / d);
        a = Mathf.Rad2Deg * Mathf.Acos(y / x);
        //turn turret towards target
        turretTransform.up = targetTransform.position - turretTransform.position;
        //adjust for gun angle
        if (weaponTransform.localEulerAngles.z < 180)
            turretTransform.Rotate(Vector3.forward, 90 - b - a);
        else
            turretTransform.Rotate(Vector3.forward, 90 - b + a);
        //Please leave this comment in the code. This code was made by 
        //http://gamedev.stackexchange.com/users/93538/john-hamilton a.k.a. CrazyIvanTR. 
        //This code is provided as is, with no guarantees. It has worked in local tests on Unity 5.5.0f3.
    }
}

โค้ดดัดแปลง 3D พร้อม X และ Z เป็นระนาบ 2D:

public class TurretAimCorrection : MonoBehaviour
{
    public Transform targetTransform; //drag target here
    public Transform turretTransform; //drag turret base or turret top part here
    public Transform weaponTransform; //drag the attached weapon here

    private float d, x, y, b, a, weaponAngle, turnAngle;
    private void Start()
    {
        TurnAdjustment();
    }

    private void Update()
    {
        TurnAdjustment();
    }
    void TurnAdjustment()
    {

        d = Vector2.Distance(new Vector2(targetTransform.position.x, targetTransform.position.z), new Vector2(turretTransform.position.x, turretTransform.position.z));
        x = Vector2.Distance(new Vector2(turretTransform.position.x, turretTransform.position.z), new Vector2(weaponTransform.position.x, weaponTransform.position.z));
        weaponAngle = weaponTransform.localEulerAngles.y;
        weaponAngle = weaponAngle * Mathf.Deg2Rad;
        y = Mathf.Abs(Mathf.Cos(weaponAngle) * x);
        b = Mathf.Rad2Deg * Mathf.Acos(y / d);
        a = Mathf.Rad2Deg * Mathf.Acos(y / x);
        //turn turret towards target
        turretTransform.forward = new Vector3(targetTransform.position.x, 0, targetTransform.position.z) - new Vector3(turretTransform.position.x, 0, turretTransform.position.z);
        //adjust for gun angle
        if (weaponTransform.localEulerAngles.y < 180)
            turretTransform.Rotate(Vector3.up, - a +b-90);
        else
            turretTransform.Rotate(Vector3.up, + a+ b - 90);
        //Please leave this comment in the code. This code was made by 
        //http://gamedev.stackexchange.com/users/93538/john-hamilton a.k.a. CrazyIvanTR. 
        //This code is provided as is, with no guarantees. It has worked in local tests on Unity 5.5.0f3.
    }
}

ภาพแรกมีข้อบกพร่องเล็กน้อย Z คือความยาวของป้อมปืนต่อกล่อง X คือความยาวของป้อมปืนต่อกล่องหลังจากหมุน ... x = z ดังนั้นถ้า y เป็นด้านตรงข้ามมุมฉากที่ไม่ใช่สามเหลี่ยมมุมฉากและบาปใช้ไม่ได้
The Great Duck

@TheGreatDuck Z ไม่ใช่ระยะห่างระหว่างป้อมปืนกับกล่องมันคือ Vector2.forward ของป้อมปืนนั้น (มันเพิ่งจะแสดงให้เห็นว่ามีขอบเขต จำกัด แทนที่จะมีลูกศรที่ท้าย) แม้ว่า Z คือระยะทางรูปภาพก็มีหน่วยและคุณสามารถดู Z <X ได้โดยไม่ต้องคำนวณ
John Hamilton

2
@ Franconstein คุณไม่ต้องหมุนป้อมปืนก่อนจากนั้นใช้สิ่งเหล่านี้ คุณสามารถคำนวณสิ่งเหล่านี้ก่อนจากนั้นเพิ่มองศาที่คุณได้รับจากสมการเหล่านี้ไปยังระดับเทิร์นของป้อมปืน (ดังนั้นแทนที่จะเปลี่ยนป้อมปืน 20 องศาเป็นวัตถุจากนั้นปรับสำหรับปืนคุณจะเปลี่ยนป้อมปืนเป็น 20 องศา + การปรับสำหรับปืน)
John Hamilton

@Franconstein ดูรหัสที่ปรับใหม่ เนื่องจากเราเปลี่ยนระนาบรหัสจึงทำหน้าที่แตกต่างจากในรุ่นอื่น ฉันไม่รู้ว่าทำไมสิ่งนี้จึงเกิดขึ้น แต่ตอนนี้ฉันทำงานได้อย่างสมบูรณ์แบบแล้ว ดู: imgur.com/a/1scEH (ไม่จำเป็นต้องถอดป้อมปราการของคุณแบบจำลองง่ายๆเหล่านั้นก็ทำแบบเดียวกับที่คุณทำ)
John Hamilton

1
@JohnHamilton คุณทำมัน! ในที่สุดมันก็ได้รับการแก้ไขและด้วยความแม่นยำเหมือนเลเซอร์! ขอขอบคุณ! ขอขอบคุณ! ขอขอบคุณ! ตอนนี้ฉันจะแก้ไขโพสต์ของฉันว่ามันเป็นอย่างไรในตอนเริ่มต้นดังนั้นจึงสามารถเข้าใจได้ง่ายขึ้นสำหรับการอ้างอิงในอนาคต! ขอขอบคุณอีกครั้ง!
Franconstein

3

นอกจากนี้คุณยังสามารถใช้แนวทางทั่วไปเพิ่มเติมได้:

คณิตศาสตร์สำหรับปัญหาของคุณมีอยู่แล้วในรูปแบบของscalarproduct (หรือผลิตภัณฑ์ dot) คุณจะต้องได้รับทิศทางของอาวุธไปข้างหน้าแกนและทิศทางจากอาวุธของคุณไปยังเป้าหมาย

ให้ W เป็นเวกเตอร์ด้านหน้าของอาวุธของคุณ

ให้ D เป็นทิศทางจากอาวุธของคุณไปยังเป้าหมายของคุณ (Target.pos - Weapon.pos)

หากคุณแก้ไขสูตรของผลิตภัณฑ์ดอท

dot(A,B) = |A|*|B|*cos(alpha) with alpha = the angle between A and B

สำหรับอัลฟาคุณจะได้รับ:

              ( dot(W,D) )
alpha = arccos(--------- )
              ( |W|*|D|  )

คุณต้องแปลงเรเดียนเป็นองศาเท่านั้นและคุณมีมุมในการหมุนหุ่นยนต์ (ดังที่คุณกล่าวถึงอาวุธเป็นมุมของหุ่นยนต์ของคุณดังนั้นคุณต้องเพิ่มมุมเป็นอัลฟา)

ป้อนคำอธิบายรูปภาพที่นี่ป้อนคำอธิบายรูปภาพที่นี่


2

คำตอบทั้งหมดที่โพสต์ไปนั้นผิด (มากหรือน้อย) ดังนั้นนี่เป็นคำตอบที่ถูกต้องอย่างรวดเร็ว:

ป้อนคำอธิบายรูปภาพที่นี่

ในการเล็งปืนไปยังเป้าหมายให้หมุนเวกเตอร์ป้อมปืนไปยังเป้าหมายและเพิ่มมุมθ

ดังนั้นเรามาหาθ:

   d / sin(δ) = a / sin(α) # By the Law of Sines
=> α = asin(a * sin(δ) / d)

   β = 180° - α - δ
   θ = 90° - β
=> θ = α + δ - 90°
     = asin(a * sin(δ) / d) + δ - 90°
     = asin(a * cos') / d) - δ' # Where (δ' = 90° - δ) is the angle between 
                                  # the gun and the turret forward vector.

เมื่อδ' = 0สิ่งนี้ทำให้ง่ายขึ้นθ = asin(a / d)ขึ้นซึ่งตรงกับส่วนแรกของคำตอบของ John Hamilton

แก้ไข:

ฉันได้เพิ่มตัวอย่างการทำงาน

เปิดใน JSFiddleหรือใช้ตัวอย่างข้อมูลฝังตัวด้านล่าง:

var Degree = Math.PI / 180;
var showDebugOverlays = false;

var Turret = {
    gunAngle: -10 * Degree,
    maxGunAngle: 85 * Degree,
    adaptedGunXOffset: null,

    rotateToTarget: function (target) {
        var delta = Vec.subtract(this.position, target.position);
        var dist = Vec.length(delta);
        var angle = Vec.angle(delta);

        theta = Math.asin(this.adaptedGunXOffset / dist) + this.gunAngle;
        this.rotation = -(angle + theta);

        this.updateGunRay(target);
    },

    setGunAngle: function (angle) {
        var angle = this.clampGunAngle(angle);
        this.gunAngle = angle;
        this.gun.rotation = angle;
        // Account for the fact that the origin of the gun also has an y offset
        // relative to the turret origin
        var extraXOffset = this.gun.position.y * Math.tan(angle);
        var gunXOffset = this.gun.position.x + extraXOffset;
        // This equals "a * cos(δ')" in the angle formula
        this.adaptedGunXOffset = gunXOffset * Math.cos(-angle);

        if (showDebugOverlays) {
            // Show x offsets
            this.removeChild(this.xOffsetOverlay);
            this.removeChild(this.extraXOffsetOverlay);
            this.xOffsetOverlay = addRect(this, 0, 0, this.gun.position.x, 1, 0xf6ff00);
            this.extraXOffsetOverlay = addRect(this, this.gun.position.x, 0, extraXOffset, 1, 0xff00ae);
        }
    },

    rotateGun: function (angleDelta) {
        this.setGunAngle(this.gunAngle + angleDelta);
    },

    updateGunRay: function (target) {
        var delta = this.gun.toLocal(target.position);
        var dist = Vec.length(delta);
        this.gun.removeChild(this.gun.ray);
        this.gun.ray = makeLine(0, 0, 0, -dist);
        this.gun.addChildAt(this.gun.ray, 0);
    },

    clampGunAngle: function (angle) {
        if (angle > this.maxGunAngle) {
            return this.maxGunAngle;
        }
        if (angle < -this.maxGunAngle) {
            return -this.maxGunAngle;
        }
        return angle;
    }
}

function makeTurret() {
    var turret = new PIXI.Sprite.fromImage('http://i.imgur.com/gPtlPJh.png');
    var gunPos = new PIXI.Point(25, -25)

    turret.anchor.set(0.5, 0.5);

    var gun = new PIXI.Container();
    var gunImg = new PIXI.Sprite.fromImage('http://i.imgur.com/RE45GEY.png');
    gun.ray = makeLine(0, 0, 0, -250);
    gun.addChild(gun.ray);

    gunImg.anchor.set(0.5, 0.6);
    gun.addChild(gunImg);
    gun.position = gunPos;

    // Turret forward vector
    turret.addChild(makeLine(0, -38, 0, -90, 0x38ce2c));
    turret.addChild(gun);
    turret.gun = gun;

    Object.setPrototypeOf(Turret, Object.getPrototypeOf(turret));
    Object.setPrototypeOf(turret, Turret);

    turret.setGunAngle(turret.gunAngle);

    if (showDebugOverlays) {
        addRect(turret, 0, 0, 1, 1); // Show turret origin
        addRect(gun, -1, 1, 2, 2, 0xff0096); // Show gun origin
    }

    return turret;
}

function makeTarget() {
    var target = new PIXI.Graphics();
    target.beginFill(0xd92f8f);
    target.drawCircle(0, 0, 9);
    target.endFill();
    return target;
}

var CursorKeys = {
    map: { ArrowLeft: -1, ArrowRight: 1 },
    pressedKeyDirection: null,

    onKeyDown: function (keyEvent) {
        var key = this.map[keyEvent.key];
        if (key) {
            this.pressedKeyDirection = key;
        }
    },
    onKeyUp: function (keyEvent) {
        var key = this.map[keyEvent.key];
        if (key) {
            if (this.pressedKeyDirection == key) {
                this.pressedKeyDirection = null;
            }
        }
    }
}

document.body.addEventListener("keydown", CursorKeys.onKeyDown.bind(CursorKeys));
document.body.addEventListener("keyup", CursorKeys.onKeyUp.bind(CursorKeys));

function makeLine(x1, y1, x2, y2, color) {
    if (color == undefined) {
        color = 0x66CCFF;
    }
    var line = new PIXI.Graphics();
    line.lineStyle(1.5, color, 1);
    line.moveTo(x1, y1);
    line.lineTo(x2, y2);
    return line;
}

function addRect(parent, x, y, w, h, color) {
    if (color == undefined) {
        color = 0x66CCFF;
    }
    var rectangle = new PIXI.Graphics();
    rectangle.beginFill(color);
    rectangle.drawRect(x, y, w, h);
    rectangle.endFill();
    parent.addChild(rectangle);
    return rectangle;
}

var Vec = {
    subtract: function (a, b) {
        return { x: a.x - b.x,
                 y: a.y - b.y };
    },
    length: function (v) {
        return Math.sqrt(v.x * v.x + v.y * v.y);
    },
    angle: function (v) {
        return Math.atan2(v.x, v.y)
    }
}

Math.clamp = function(n, min, max) {
    return Math.max(min, Math.min(n, max));
}

var renderer;
var stage;
var turret;
var target;

function run() {
    renderer = PIXI.autoDetectRenderer(600, 300, { antialias: true });
    renderer.backgroundColor = 0x2a2f34;
    document.body.appendChild(renderer.view);
    stage = new PIXI.Container();
    stage.interactive = true;

    target = makeTarget();
    target.position = { x: renderer.width * 0.2, y: renderer.height * 0.3 };

    turret = makeTurret();
    turret.position = { x: renderer.width * 0.65, y: renderer.height * 0.3 };
    turret.rotateToTarget(target);

    stage.addChild(turret);
    stage.addChild(target);

    var message = new PIXI.Text(
        "Controls: Mouse, left/right cursor keys",
        {font: "18px Arial", fill: "#7c7c7c"}
    );
    message.position.set(10, 10);
    stage.addChild(message);

    stage.on('mousemove', function(e) {
        var pos = e.data.global;
        target.position.x = Math.clamp(pos.x, 0, renderer.width);
        target.position.y = Math.clamp(pos.y, 0, renderer.height);
        turret.rotateToTarget(target);
    })

    animate();
}

function animate() {
    requestAnimationFrame(animate);

    if (CursorKeys.pressedKeyDirection) {
        turret.rotateGun(3 * Degree * CursorKeys.pressedKeyDirection);
        turret.rotateToTarget(target);
    }

    renderer.render(stage);
}

run();
body {
    padding: 0;
    margin: 0;
}

#capture_focus {
  position: absolute;
  width: 100%;
  height: 100%;
  background-color: rgba(0, 0, 0, 0);
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/pixi.js/4.2.2/pixi.min.js"></script>
<div id="capture_focus" />


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

หากคำตอบอื่น ๆ "ผิดไปมาก" คุณไม่เข้าใจ / นำไปใช้อย่างถูกต้อง ก่อนหน้านี้ฉันเคยใช้ทั้งสองคำตอบอื่นเพื่อสร้างพฤติกรรมที่ต้องการ @ Franconstein ฉันเห็นความคิดเห็นของคุณเกี่ยวกับatleastเพื่อบอกว่าคุณได้ตรวจสอบแล้วว่ามันใช้งานได้ หากคุณได้ตรวจสอบวิธีการแก้ไขแล้วคุณยังมีปัญหาอยู่หรือไม่?
Gnemlock

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

@ Franconstein ในรูปแบบนี้มันสับสนมากเกินไป ฉันจะบอกว่าตัวอย่างนี้เป็นตัวอย่างที่ดีของสิ่งที่คุณคาดหวังจากการอ่านตำราเรียนคณิตศาสตร์แต่มันทำให้เกิดความสับสนอย่างมากเกี่ยวกับการเขียนโปรแกรมเกมทั่วไป องค์ประกอบที่สำคัญเพียงอย่างเดียวคือมุม (ซึ่งคำตอบเดิมที่ John Hamilton โพสต์ให้ไว้) ฉันเห็นสิ่งที่คุณหมายถึงโดยเฉพาะมุมในที่สุดคุณอาจทำอย่างไม่ถูกต้อง ผมพบว่ามีเป็นจำนวนมากของห้องพักในคำตอบนี้จะทำมันไม่ถูกต้อง
Gnemlock
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.