Raycasting unknown error

See more:

Unity3D

vector

detection

I have this problem which I have been trying to figure out for quite some time already. The code I have below is almost complete. I just need to add this additional feature it should work how I want it to work.

So what I want to implement into the code is the make alertedLock false when !withinRange.
But for some reason no matter how i do it. It doesnt work. Because the problem i have is that, when i implement some kind of code to do that, everything goes back to normal.

Thanks in advance.

**Edit**
The script should be doing this:

1. If player !withinRange && !withinAngle of enemy then, enemy.color.blue;
2. If player !withinRange && withinAngle of enemy then, enemy.color.blue;

3. If player withinRange && !withinAngle of enemy then, enemy.color.red;
4. If player withinRange && withinAngle of enemy then, enemy.color.green;

5. If player withinRange && touchRestrictedRaycast of enemy then, enemy.color.magenta (forever) unless !withinRange && !withinAnge

The problem is 5. I dont know how to code 5.
**Edit**
When i tried to code it outside the forloop , that is,

if (alertedLock && !withinRange) {

    alertedLock = false;

}

Does doesnt solve the problem. It returns the solution to where alertedLock is always false
Even when i try to apply it inside the for loop. Such like,

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;
        }
}

There is a problem when i do this, its because once it detects the first raycast detection. It ignores the rest, and so it has this color state problem.
I found out this problem on my earlier questions, here:
http://gamedev.stackexchange.com/questions/90329/raycast-flashing-problem

    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");
		}
		
		
	}
	
}