Question

我有这个问题，我一直试图弄清楚已经有一段时间了。我下面的代码几乎完成了。我只需要添加这个额外的功能，它应该如何工作。

所以我想在代码中实现的是当在！withinRange时，make alertsLock为false。但出于某种原因无论我怎么做。它不起作用。因为我遇到的问题是，当我实现某种代码时，一切都恢复正常。

提前致谢。

修改脚本应该这样做：

如果玩家！在范围内＆amp;＆amp;在敌人的内部，敌人.color.blue;

如果玩家不在范围内供敌人侦测并且玩家不在某个角度内供敌人侦测。这意味着，敌人没有发现玩家。所以我们使用Color.Blue来表示。

如果玩家！在范围内＆amp;＆amp;在敌人的角度里，敌人.color.blue;

如果玩家不在范围内供敌人侦测并且玩家在角度范围内供敌人侦测。这意味着，玩家仍未被敌人发现。所以我们使用Color.Blue来表示。

如果玩家在范围内＆amp;＆amp;在敌人的内部，敌人.color.red; 如果玩家在范围内供敌人检测并且玩家不在角度内，敌人可以检测到玩家。这意味着，敌人已经在Range范围内检测到某些内容，但不符合所有要求，即在anngle = true内。所以在这种情况下我们使用Color.Red来表示。
如果玩家在范围内＆amp;＆amp;在敌人的角度里，敌人.color.green;

如果玩家在范围内供敌人侦测并且玩家处于角度范围内以便敌人侦测玩家。这意味着，玩家已经成功杀死了敌人。因此，使用Color.Green来表示。

如果玩家在范围内＆amp;＆amp; touchRestrictedRaycast of enemy then，enemy.color.magenta（forever）除非！withinRange＆amp;＆amp; ！withinAnge

如果玩家在范围内供敌人侦测并且玩家不在角度内以便敌人侦测玩家。但是然后点击了光线投射，touchRestrictedRaycast。这将锁定。所以玩家无法从无效位置杀死敌人。所以当这种情况发生时，玩家就不能再杀死敌人了。除非玩家完全超出了敌人的范围。

问题是5.我不知道如何编码5。的修改当我试图在forloop之外编码时，就是

if (alertedLock && !withinRange) {

    alertedLock = false;        

}

不解决问题。它将解决方案返回到alertsLock始终为false的位置即使我尝试在for循环中应用它。如此，

if(withinRange) {
        // Inside
        if(alertedLock) {
            gameObject.renderer.material.color = Color.magenta;
        }
        if(!alertedLock) {
            if(enemyAngleTLUP || enemyAngleTLLEFT) {
                alertedLock = true;
            }
            if(withinAngle) {
                gameObject.renderer.material.color = Color.green;
            }
            if(!withinAngle) {
                gameObject.renderer.material.color = Color.red;
            }

        }

}
if (!withinRange){
        if(alteredLock) {
                alertedLock = false;
        }
}

执行此操作时出现问题，因为一旦检测到第一次光线投射检测。它忽略了其余的，因此它有这种颜色状态问题。我在之前的问题中发现了这个问题，这里： https://gamedev.stackexchange.com/questions/90329/raycast-flashing-problem

修改 alertsLock只是一个bool，它决定了玩家何时触摸了受限制的光线投射。由于玩家只能从特定范围和角度杀死敌人（在范围内和范围内）。这就是为什么我们已经警告了锁定。

然而，当alertsLock为真时。它只能在玩家不在敌人的杀戮范围内时关闭（！withinRange）

using UnityEngine;
using System.Collections;

public class Script_v2 : MonoBehaviour {

// Player Properties
private GameObject player;
public Vector3 playerSize;
private Vector3 playerTransform;
public Vector3 playerTransformTL;
public Vector3 playerTransformTR;
public Vector3 playerTransformBL;
public Vector3 playerTransformBR;

private Vector3 newPlayerTransformTL;
private Vector3 newPlayerTransformTR;

private Vector3[] playerRaycastPoints;


// Enemy Properties
private Vector3 enemyTransformTL;
private Vector3 enemyTransformTR;
private Vector3 enemyTransformBL;
private Vector3 enemyTransformBR;

public float distance;
public Vector3 enemySize;

// Detection Alerts
public bool outOfVision;
public bool alerted;
public bool alertedLock;

public bool withinRange;
public bool withinAngle;

public bool dead;

Ray ray;
RaycastHit hit;

// Use this for initialization
void Start () {

    playerRaycastPoints = new Vector3[4];

    distance = 3f;
    player = GameObject.FindGameObjectWithTag ("Player");


}

// Update is called once per frame
void Update () {

    enemyTransformTL = new Vector3 (transform.position.x - 0.5f, transform.position.y + 0.5f, transform.position.z);
    enemyTransformTR = new Vector3 (transform.position.x + 0.5f, transform.position.y + 0.5f, transform.position.z);


    enemyTransform_TL_TR ();
    Reference_Player_Transform_Points ();
    Player_Transform_Points_Detection ();

    Debug.Log (alerted + " " + alertedLock);

}

void OnDrawGizmos() {
    Gizmos.color = Color.blue;
    Gizmos.DrawWireSphere (new Vector3(transform.position.x - 0.5f, transform.position.y + 0.5f, transform.position.z), distance);
    //Gizmos.DrawWireSphere (new Vector3(transform.position.x + 0.5f, transform.position.y + 0.5f, transform.position.z), distance);
}

public void enemyTransform_TL_TR() {

    if (alertedLock && !withinRange) {

        alertedLock = false;        

    }
    if (!alertedLock) {
        gameObject.renderer.material.color = Color.blue;
    }



    for (int i = 0; i < playerRaycastPoints.Length; i++) {

        double enemyAngleTL = Mathf.Atan2(playerRaycastPoints[i].y - ( transform.position.y + 0.5f ),
                                          playerRaycastPoints[i].x - ( transform.position.x - 0.5f )) * 180f / 3.14159265f;
        //Debug.Log (enemyAngleTL);
        double enemyAngleTR = Mathf.Atan2 (playerRaycastPoints[i].y - (transform.position.y + 0.5f),
                                           playerRaycastPoints[i].x - (transform.position.x + 0.5f)) * 180f / 3.14159265f;

        Vector3 directionTL = (playerRaycastPoints[i] - enemyTransformTL).normalized;
        Ray rayTL = new Ray(enemyTransformTL, directionTL);
        RaycastHit hitTL;
        Vector3 directionTR = (playerRaycastPoints[i] - enemyTransformTR).normalized;
        Ray rayTR = new Ray (enemyTransformTR, directionTR);
        RaycastHit hitTR;

        withinRange = Physics.Raycast (rayTL, out hitTL, distance);
        withinAngle = enemyAngleTL > 90 && enemyAngleTL < 180;

        RaycastHit hitTPUP;
        RaycastHit hitTPLEFT;
        bool enemyAngleTLUP = Physics.Raycast(enemyTransformTL, Vector3.up, out hitTPUP, distance);
        bool enemyAngleTLLEFT = Physics.Raycast(enemyTransformTL, Vector3.left, out hitTPLEFT, distance);


        Debug.DrawRay(enemyTransformTL, Vector3.up * distance);
        Debug.DrawRay(enemyTransformTL, Vector3.left * distance);


        if(withinRange) {
            // Inside
            if(alertedLock) {
                gameObject.renderer.material.color = Color.magenta;
            }
            if(!alertedLock) {
                if(enemyAngleTLUP || enemyAngleTLLEFT) {
                    alertedLock = true;
                }
                if(withinAngle) {
                    gameObject.renderer.material.color = Color.green;
                }
                if(!withinAngle) {
                    gameObject.renderer.material.color = Color.red;
                }

            }

        }




    }



}

private void Reference_Player_Transform_Points() {

    playerSize = player.transform.localScale;

    playerTransformTL = new Vector3(player.transform.position.x - (playerSize.x / 2),
                                    player.transform.position.y + playerSize.y  / 2,
                                    player.transform.position.z);
    playerTransformTR = new Vector3(player.transform.position.x + (playerSize.x / 2),
                                    player.transform.position.y + playerSize.y  / 2,
                                    player.transform.position.z);
    playerTransformBL = new Vector3(player.transform.position.x - (playerSize.x / 2),
                                    player.transform.position.y - playerSize.y  / 2,
                                    player.transform.position.z);
    playerTransformBR = new Vector3(player.transform.position.x + (playerSize.x / 2),
                                    player.transform.position.y - playerSize.y  / 2,
                                    player.transform.position.z);

    playerRaycastPoints [0] = playerTransformTL;
    playerRaycastPoints [1] = playerTransformTR;
    playerRaycastPoints [2] = playerTransformBL;
    playerRaycastPoints [3] = playerTransformBR;

    /*
        Debug.Log (playerTransformTL);
        Debug.Log (playerTransformTR);
        Debug.Log (playerTransformBL);
        Debug.Log (playerTransformBR);
    */
}

private void Player_Transform_Points_Detection() {
    float eTLpTL = Vector3.Distance (enemyTransformTL, playerTransformTL);
    float eTLpTR = Vector3.Distance (enemyTransformTL, playerTransformTR);
    float eTLpBL = Vector3.Distance (enemyTransformTL, playerTransformBL);
    float eTLpBR = Vector3.Distance (enemyTransformTL, playerTransformBR);

    float eTRpTL = Vector3.Distance (enemyTransformTR, playerTransformTL);
    float eTRpTR = Vector3.Distance (enemyTransformTR, playerTransformTR);
    float eTRpBL = Vector3.Distance (enemyTransformTR, playerTransformBL);
    float eTRpBR = Vector3.Distance (enemyTransformTR, playerTransformBR);


    float eTLMin = Mathf.Min (eTLpTL, eTLpTR, eTLpBL, eTLpBR);

    if (eTLMin == eTLpTL) {
        newPlayerTransformTL = playerTransformTL;
        // Debug.Log("eTLpTL");     
    }
    else if(eTLMin == eTLpTR) {
        newPlayerTransformTL = playerTransformTR;
        // Debug.Log("eTLpTR");
    }
    else if(eTLMin == eTLpBL) {
        newPlayerTransformTL = playerTransformBL;
        // Debug.Log("eTLpBL");
    }
    else if(eTLMin == eTLpBR) {
        newPlayerTransformTL = playerTransformBR;
        // Debug.Log("eTLpBR");
    }

    float eTRMin = Mathf.Min (eTRpTL, eTRpTR, eTRpBL, eTRpBR);

    if(eTRMin == eTRpTL) {
        newPlayerTransformTR = playerTransformTL;
        // Debug.Log("eTRpTL");
    }
    else if(eTRMin == eTRpTR) {
        newPlayerTransformTR = playerTransformTR;
        // Debug.Log("eTRpTR");
    }
    else if(eTRMin == eTRpBL) {
        newPlayerTransformTR = playerTransformBL;
        // Debug.Log("eTRpBL");
    }
    else if(eTRMin == eTRpBR) {
        newPlayerTransformTR = playerTransformBR;
        // Debug.Log("eTRpBR");
    }


}

}

多个光线投射有限制

0 个答案: