//set the direction that the player object is facing
private void SetDirection(float x, float y)
{
//set the current direction of player
if (x < 0)
{
CurrentDirection = DIRECTIONS.Left;
flip.flipX = true;
}
else if (x > 0)
{
CurrentDirection = DIRECTIONS.Right;
flip.flipX = false;
}
else if (y < 0)
{
CurrentDirection = DIRECTIONS.Down;
flip.flipX = false;
}
else if (y > 0)
{
CurrentDirection = DIRECTIONS.Up;
flip.flipX = false;
}
//check to see if player is currently moving
CheckIsMoving();
//set direction
animator.SetInteger("direction", (int)CurrentDirection);
}
// Interface of Player Control from Individual
public void UpdatePositionsForIndividuals(byte direct, int index)
{
DIRECTIONS newDirection = (DIRECTIONS)direct;
// With Rigidbody
// allIndividuals[index].velocity = Vector3.zero;
// allIndividuals[index].angularVelocity = Vector3.zero;
switch (newDirection)
{
case DIRECTIONS.RIGHT:
// With Rigidbody
allIndividuals[index].velocity = (Vector3.right * ForceMagnitude);
break;
case DIRECTIONS.FRONT:
// With Rigidbody
allIndividuals[index].velocity = (Vector3.forward * ForceMagnitude);
break;
case DIRECTIONS.LEFT:
// With Rigidbody
allIndividuals[index].velocity = (Vector3.left * ForceMagnitude);
break;
case DIRECTIONS.BACK:
// With Rigidbody
allIndividuals[index].velocity = (Vector3.back * ForceMagnitude);
break;
}
}
/// <summary>
///
/// </summary>
public void SetViewDirection(DIRECTIONS movingDirection)
{
switch (movingDirection)
{
// If it's moving up
// look down
case DIRECTIONS.UP:
viewDir = DIRECTIONS.DOWN;
break;
// if its moving down
// look up
case DIRECTIONS.DOWN:
viewDir = DIRECTIONS.UP;
break;
// if its moving eft
// look right
case DIRECTIONS.LEFT:
viewDir = DIRECTIONS.RIGHT;
break;
// if its moving right
// look left
case DIRECTIONS.RIGHT:
viewDir = DIRECTIONS.LEFT;
break;
case DIRECTIONS.NONE:
break;
default:
break;
}
}
public override void AddOptions(string[] fullString)
{
base.AddOptions(fullString);
string[] directions = Enum.GetNames(typeof(DIRECTIONS));
bool shouldBreak = false;
for (int optIndex = 0; optIndex < fullString.Length; ++optIndex)
{
for (int dirIndex = 0; dirIndex < directions.Length; ++dirIndex)
{
if (directions[dirIndex].ToLower() == fullString[optIndex].ToLower())
{
direction = (DIRECTIONS)Enum.Parse(typeof(DIRECTIONS), directions[dirIndex]);
shouldBreak = true;
break;
}
}
if (shouldBreak)
{
break;
}
}
visual.transform.rotation = Quaternion.AngleAxis(45.0f * (int)direction, Vector3.forward);
}
/// <summary>
/// Constructs a Command with the parameters it's given.
/// </summary>
public Command(COMMANDS mainCommand, DIRECTIONS direction, int magnitude, int id)
{
MainCommand = mainCommand;
Direction = direction;
Magnitude = magnitude;
ID = id;
}
public void move(PlayerMemento playerMemento, DIRECTIONS direction)
{
if (direction == DIRECTIONS.RIGHT)
{
playerMemento.XIndex += 1;
}
if (direction == DIRECTIONS.UP)
{
playerMemento.YIndex -= 1;
}
if (direction == DIRECTIONS.LEFT)
{
playerMemento.XIndex -= 1;
}
if (direction == DIRECTIONS.DOWN)
{
playerMemento.YIndex += 1;
}
if (playerMemento.XIndex < 0 || playerMemento.XIndex > 5 || playerMemento.YIndex < 0 || playerMemento.YIndex > 5)
{
PlayerMemento p = LoadPrev(playerMemento);
if (p.XIndex < 0 || p.XIndex > 5 || p.YIndex < 0 || p.YIndex > 5)
{
exitSimulation();
}
else
{
playerMemento.value = p.value;
playerMemento.XIndex = p.XIndex;
playerMemento.YIndex = p.YIndex;
}
}
}
//private bool CheckDeath()
//{
//
// if (Parameters.Parameters.Instance.autoMove)
// {
// return false;
// }
// return transform.position.y < TileManager.Instance.KillHeight();
//}
private static bool AllowedDirection(DIRECTIONS dir)
{
switch (dir)
{
case DIRECTIONS.NORTH:
return(Parameters.Parameters.Instance.moveNorth);
case DIRECTIONS.SOUTH:
return(Parameters.Parameters.Instance.moveSouth);
case DIRECTIONS.EAST:
return(Parameters.Parameters.Instance.moveEast);
case DIRECTIONS.WEST:
return(Parameters.Parameters.Instance.moveWest);
case DIRECTIONS.NORTH_EAST:
return(Parameters.Parameters.Instance.moveNorthEast);
case DIRECTIONS.NORTH_WEST:
return(Parameters.Parameters.Instance.moveNorthWest);
case DIRECTIONS.SOUTH_EAST:
return(Parameters.Parameters.Instance.moveSouthEast);
case DIRECTIONS.SOUTH_WEST:
return(Parameters.Parameters.Instance.moveSouthWest);
default:
throw new ArgumentOutOfRangeException("dir", dir, null);
}
}
/// <summary>
///
/// </summary>
/// <param name="character">The character to check for</param>
/// <returns>true if it is within a tile spacing</returns>
public bool IsEnemyNearby(CHARACTERS character)
{
Vector2Int characterTilePosition = Vector2Int.zero;
Vector2 characterPosition = Vector2.zero;
// it is already targetting the player
if (targetObject == playerObject)
{
return(false);
}
if (character == CHARACTERS.PLAYER)
{
characterPosition = playerObject.transform.position;
characterTilePosition = MapManager.Instance.GetWorldToTilePos(playerObject.transform.position);
}
Vector2Int currentTilePosition = MapManager.Instance.GetWorldToTilePos(transform.position);
DIRECTIONS characterDirection = GetTargetDirection(characterPosition);
// it is within 1 tile
if (Vector2Int.Distance(currentTilePosition, characterTilePosition) <= 1)
{
// check if its through the wall
if (CheckIfClear(characterDirection, characterPosition))
{
return(true);
}
}
return(false);
}
/*
* private void Update()
* {
* clickableObj.SetActive(TilePlayer.Instance.IsTileCickable(this));
*
* if (Parameters.Parameters.Instance.swipeControl == false)
* {
* if (TilePlayer.Instance.IsTileCickable(this))
* {
* if (HasInput())
* {
* Vector3 worldPoint = Camera.main.ScreenToWorldPoint(InputPos());
*
* if (coll.OverlapPoint(worldPoint))
* {
* TilePlayer.Instance.QueueTile(this);
* }
* }
* }
* }
* }*/
public static float DirectionToAngle(DIRECTIONS dir)
{
switch (dir)
{
case DIRECTIONS.NORTH:
return(0.0f);
case DIRECTIONS.NORTH_WEST:
return(45.0f);
case DIRECTIONS.WEST:
return(90.0f);
case DIRECTIONS.SOUTH_WEST:
return(135.0f);
case DIRECTIONS.SOUTH:
return(180.0f);
case DIRECTIONS.SOUTH_EAST:
return(225.0f);
case DIRECTIONS.EAST:
return(270.0f);
case DIRECTIONS.NORTH_EAST:
return(315.0f);
default:
return(float.MinValue);
}
}
/// <summary>
/// Checks the direc tion before moving in it if the kitten is there
/// </summary>
/// <param name="dirToCheck"></param>
/// <returns></returns>
public bool CheckForKitten(DIRECTIONS dirToCheck)
{
Vector2Int currentTilePos = MapManager.Instance.GetWorldToTilePos(transform.position);
Vector2Int kittenTilePos = MapManager.Instance.GetWorldToTilePos(kittenObject.transform.position);
int counter = 0;
// Dont check for the kitten if its being chased by the kitten
if (targetObject == kittenObject)
{
return(false);
}
while (MapManager.Instance.IsThereTileOnMap(currentTilePos) == false)
{
counter++;
switch (dirToCheck)
{
case Detection.DIRECTIONS.UP:
currentTilePos.y++;
break;
case Detection.DIRECTIONS.DOWN:
currentTilePos.y--;
break;
case Detection.DIRECTIONS.LEFT:
currentTilePos.x--;
break;
case Detection.DIRECTIONS.RIGHT:
currentTilePos.x++;
break;
case Detection.DIRECTIONS.NONE:
break;
default:
break;
}
if (counter >= SightDistance)
{
break;
}
// the kitten is along that direction
if (currentTilePos == kittenTilePos)
{
return(true);
}
}
return(false);
}
MAZE TryStep(Coords coords, DIRECTIONS direction)
{
string responseString = string.Empty;
string requestString = GetCurrentPathString(coords);
switch (direction)
{
case DIRECTIONS.UP:
requestString += "U";
break;
case DIRECTIONS.DOWN:
requestString += "D";
break;
case DIRECTIONS.LEFT:
requestString += "L";
break;
case DIRECTIONS.RIGHT:
requestString += "R";
break;
}
HttpWebRequest webRequest = WebRequest.CreateHttp(requestUrl + requestString);
using (WebResponse webResponse = webRequest.GetResponse()) {
using (Stream responseStream = webResponse.GetResponseStream()) {
using (StreamReader reader = new StreamReader(responseStream)) {
responseString = reader.ReadToEnd();
if (DEBUG)
{
Console.Write(requestString + " ");
}
else
{
Console.Write("#");
}
}
}
}
if (Regex.IsMatch(responseString, "keep moving"))
{
return(MAZE.POSSIBLE);
}
if (Regex.IsMatch(responseString, "boom"))
{
return(MAZE.BLOCKED);
}
if (Regex.IsMatch(responseString, "off the edge of the world"))
{
return(MAZE.EDGE);
}
Console.WriteLine(responseString);
return(MAZE.END);
}
public virtual void Start()
{
ObjectsInRange = new List <GameObject>();
// get the player object at start
playerObject = GameObject.FindGameObjectWithTag("Player");
ratObject = GameObject.FindGameObjectWithTag("Prey");
kittenObject = GameObject.FindGameObjectWithTag("Kitten");
viewDir = startingDir;
}
/// <summary>
/// Call this to check if they detected a target through the wall
/// If the direction to the target is not empty
/// It means it was through the wall
/// </summary>
/// <param name="dirToCheck">The direction to check</param>
/// <returns> returns true if its clear </returns>
public bool CheckIfClear(DIRECTIONS dirToCheck, Vector2 targetPosition)
{
Vector2Int currentTilePos = MapManager.Instance.GetWorldToTilePos(transform.position);
Vector2Int targetTilePos = MapManager.Instance.GetWorldToTilePos(targetPosition);
// Debug.Log("Distance between : " + Vector2Int.Distance(targetTilePos, currentTilePos));
if (Vector2Int.Distance(targetTilePos, currentTilePos) <= 1)
{
if (MapManager.Instance.IsThereTileOnMap(currentTilePos) == false && MapManager.Instance.IsThereTileOnMap(targetTilePos) == false)
{
return(true);
}
}
//Debug.Log("Direction" + dirToCheck);
//Debug.Log("Original Position : " + currentTilePos);
switch (dirToCheck)
{
case Detection.DIRECTIONS.UP:
currentTilePos.y++;
break;
case Detection.DIRECTIONS.DOWN:
currentTilePos.y--;
break;
case Detection.DIRECTIONS.LEFT:
currentTilePos.x--;
break;
case Detection.DIRECTIONS.RIGHT:
currentTilePos.x++;
break;
case Detection.DIRECTIONS.NONE:
break;
default:
break;
}
//Debug.Log("Check Position" + currentTilePos);
if (MapManager.Instance.IsThereTileOnMap(currentTilePos) == false)
{
return(true);
}
return(false);
}
/// <summary>
/// The player has hit the edge of the screen
/// this will set up this script to start moving the camera
/// </summary>
/// <param name="a_Dir">Which direction to move</param>
public void hitEdge(DIRECTIONS a_Dir)
{
//if it's already moving then it's probably a mistake
if (m_CameraMoving)
{
return;
}
//set up script
Time.timeScale = 0.0f; //stop player/AI from moving
m_CameraDirection = a_Dir;
m_CameraMoving = true;
}
void OnMouseUp()
{
if(mLastLoc == transform.position)
{
if(mDirection == DIRECTIONS.WEST)
mDirection = DIRECTIONS.NORTH;
else
mDirection++;
transform.rotation *= Quaternion.AngleAxis(-90, Vector3.forward);
}
}
//Use this for intialization
void Start()
{
//get the player object's animator component
animator = GetComponent <Animator>();
//get the player object's sprite renderer component
flip = GetComponent <SpriteRenderer>();
//starting direction
CurrentDirection = DIRECTIONS.Down;
lastPos = transform.position;
}
private bool canIMove(Vector2 newPosition, DIRECTIONS direction)
{
bool result = true;
if ((newPosition.x <= 0 && direction == DIRECTIONS.WEST) || (newPosition.x >= worldBoundaries.x && direction == DIRECTIONS.EAST))
{
result = false;
}
if ((newPosition.y <= 0 && direction == DIRECTIONS.NORTH) || (newPosition.y >= worldBoundaries.y && direction == DIRECTIONS.SOUTH))
{
result = false;
}
return(result);
}
void OnTriggerExit2D(Collider2D other)
{
if(other.tag.Contains("Conveyor"))
mColliderCount--;
if(mColliderCount <= 0 && other.tag != "DestroyedPackage")
{
gameObject.tag = "DestroyedPackage";
mDirection = DIRECTIONS.NONE;
mDestination = DESTINATION.NONE;
updateSprite();
}
}
public void ListCheck(DIRECTIONS direction, List <BoxScript> list)
{
if (!FreePlace)
{
if (!list.Contains(this))
{
list.Add(this);
}
switch (direction)
{
case DIRECTIONS.X:
if (BoxX != null)
{
BoxX.GetComponent <BoxScript>().ListCheck(direction, list);
}
break;
case DIRECTIONS.MINUS_X:
if (BoxMinusX != null)
{
BoxMinusX.GetComponent <BoxScript>().ListCheck(direction, list);
}
break;
case DIRECTIONS.Z:
if (BoxZ != null)
{
BoxZ.GetComponent <BoxScript>().ListCheck(direction, list);
}
break;
case DIRECTIONS.MINUS_Z:
if (BoxMinusZ != null)
{
BoxMinusZ.GetComponent <BoxScript>().ListCheck(direction, list);
}
break;
default:
break;
}
}
}
public override void TileReached()
{
Quaternion quat = Quaternion.FromToRotation(Vector3.up, transform.position - TilePlayer.Instance.lastPosition);
DIRECTIONS dir = AngleToDirection(quat.eulerAngles.z);
TilePlayer.Instance.ForceTile(neighbors[(int)dir]);
base.TileReached();
/*
* Array directions = Enum.GetValues(typeof(DIRECTIONS));
* for (int direction = 0; direction < directions.Length; ++direction)
* {
* if (TilePlayer.Instance.LastTile(1).neighbors[direction] == this)
* {
* TilePlayer.Instance.ForceTile(neighbors[direction]);
* return;
* }
* }*/
}
private TileBase MoveDirection(string dir, bool force = false)
{
DIRECTIONS direction = (DIRECTIONS)Enum.Parse(typeof(DIRECTIONS), dir);
TileBase rootTile = GetRootTile();
if (rootTile == false)
{
return(null);
}
TileBase target = rootTile.neighbors[(int)direction];
if (target == null)
{
return(null);
}
if (!force && !clickableTiles.Contains(target))
{
return(null);
}
QueueTile(target);
return(target);
}
private void move()
{
Random rndDirection = new Random();
canMove = false;
DIRECTIONS wayDir = (DIRECTIONS)rndDirection.Next(5);
switch (wayDir)
{
case DIRECTIONS.NORTH:
dir.x = 0;
dir.y = -speed;
break;
case DIRECTIONS.EAST:
dir.x = speed;
dir.y = 0;
break;
case DIRECTIONS.WEST:
dir.x = -speed;
dir.y = 0;
break;
case DIRECTIONS.SOUTH:
dir.x = 0;
dir.y = speed;
break;
}
cooldown.WaitTime = 1;
cooldown.Start();
canMove = canIMove(this.Position + this.dir, wayDir);
if (!canMove)
{
this.dir = -dir;
}
}
private void sendUdpMessageNAVZONES(DIRECTIONS d)
{
string msgToSend = "NAV ROTATE ";
switch (d)
{
case DIRECTIONS.DIRECTIONS_LEFT:
msgToSend += "left";
break;
case DIRECTIONS.DIRECTIONS_RIGHT:
msgToSend += "right";
break;
case DIRECTIONS.DIRECTIONS_UP:
msgToSend += "up";
break;
case DIRECTIONS.DIRECTIONS_DOWN:
msgToSend += "down";
break;
}
sendUdpMessage(msgToSend);
}
public void deplaceJoueur(DIRECTIONS dir)
{
int direction = 0;
switch (dir)
{
case DIRECTIONS.LEFT:
if (!CurrentRoom.WallLeft)
direction = -1;
break;
case DIRECTIONS.UP:
if (!CurrentRoom.WallUp)
direction = -5;
break;
case DIRECTIONS.RIGHT:
if (!CurrentRoom.WallRight)
direction = -1;
break;
case DIRECTIONS.DOWN:
if (!CurrentRoom.WallDown)
direction = 5;
break;
}
if (direction == 0)
{
SoundManager.playSound(@"media\invalid.wav");
Thread.Sleep(700);
}
CurrentRoom = CurrentLevel.Rooms[CurrentRoom.Position + direction];
CurrentRoom.Echo();
}
/// <summary>
/// turns DIRECTIONS enum into a unit vector with the direction of the enum
/// </summary>
/// <param name="a_Dir">direction to transfer into a vector</param>
/// <returns>vector of a_Dir</returns>
public Vector2 getDirectionFromDirection(DIRECTIONS a_Dir)
{
Vector3 direction = Vector2.zero;
switch (a_Dir)
{
case DIRECTIONS.LEFT:
direction.x = -1;
break;
case DIRECTIONS.RIGHT:
direction.x = 1;
break;
case DIRECTIONS.DOWN:
direction.y = -1;
break;
case DIRECTIONS.UP:
direction.y = 1;
break;
}
return(direction);
}
public void SetDir(DIRECTIONS dir)
{
lookingDir = dir;
}
public void SetViewDirection(DIRECTIONS movingDirection)
{
viewDir = movingDirection;
}
public bool DetectPlayer()
{
// get the tile position
Vector2Int playerTilePosition = MapManager.Instance.GetWorldToTilePos(playerObject.transform.position);
// get the current tile position
Vector2Int kittenTilePosition = MapManager.Instance.GetWorldToTilePos(transform.position);
DIRECTIONS playerDirection = GetTargetDirection(playerObject.transform.position);
if (CheckIfClear(playerDirection, playerObject.transform.position))
{
// if within 1 tiles
if (Vector2Int.Distance(playerTilePosition, kittenTilePosition) <= 1)
{
if (MapManager.Instance.IsThereTileOnMap(playerTilePosition) == false)
{
DetectPlayerBehvaiour();
return(true);
}
}
// Checking for the diagonal
else if (Vector2Int.Distance(playerTilePosition, kittenTilePosition) <= 2)
{
// Check if its above or below
// if player is less than the kitten y pos
if (playerTilePosition.y < kittenTilePosition.y)
{
// player is below
// Check if the tile below is empty
Vector2Int tileToCheck = kittenTilePosition;
tileToCheck.y -= 1;
if (MapManager.Instance.IsThereTileOnMap(tileToCheck) == false)
{
// if that tile is clear
// check if the player tile is clear
if (MapManager.Instance.IsThereTileOnMap(playerTilePosition) == false)
{
DetectPlayerBehvaiour();
return(true);
}
}
}
if (playerTilePosition.y > kittenTilePosition.y)
{
// it is ontop
Vector2Int tileToCheck = kittenTilePosition;
tileToCheck.y += 1;
if (MapManager.Instance.IsThereTileOnMap(tileToCheck) == false)
{
// if that tile is clear
// check if the player tile is clear
if (MapManager.Instance.IsThereTileOnMap(playerTilePosition) == false)
{
DetectPlayerBehvaiour();
return(true);
}
}
}
if (playerTilePosition.x < kittenTilePosition.x)
{
// it is ontop
Vector2Int tileToCheck = kittenTilePosition;
tileToCheck.x -= 1;
if (MapManager.Instance.IsThereTileOnMap(tileToCheck) == false)
{
// if that tile is clear
// check if the player tile is clear
if (MapManager.Instance.IsThereTileOnMap(playerTilePosition) == false)
{
DetectPlayerBehvaiour();
return(true);
}
}
}
if (playerTilePosition.x > kittenTilePosition.x)
{
// it is ontop
Vector2Int tileToCheck = kittenTilePosition;
tileToCheck.x += 1;
if (MapManager.Instance.IsThereTileOnMap(tileToCheck) == false)
{
// if that tile is clear
// check if the player tile is clear
if (MapManager.Instance.IsThereTileOnMap(playerTilePosition) == false)
{
DetectPlayerBehvaiour();
return(true);
}
}
}
Debug.Log("its 2");
}
}
return(false);
}
void OnTriggerStay2D(Collider2D other)
{
if(other.tag.Contains("Conveyor"))
{
ConveyorMover con = other.GetComponent<ConveyorMover>();
if(mDirection == DIRECTIONS.NORTH)
{
if(transform.position.y >= other.transform.position.y && transform.position.x > other.transform.position.x-0.5 && transform.position.x < other.transform.position.x+0.5)
mDirection = con.getDirection();
}
else if(mDirection == DIRECTIONS.EAST)
{
if(transform.position.x >= other.transform.position.x && transform.position.y > other.transform.position.y-0.5 && transform.position.y < other.transform.position.y+0.5)
mDirection = con.getDirection();
}
else if(mDirection == DIRECTIONS.SOUTH)
{
if(transform.position.y <= other.transform.position.y && transform.position.x > other.transform.position.x-0.5 && transform.position.x < other.transform.position.x+0.5)
mDirection = con.getDirection();
}
else if(mDirection == DIRECTIONS.WEST)
{
if(transform.position.x <= other.transform.position.x && transform.position.y > other.transform.position.y-0.5 && transform.position.y < other.transform.position.y+0.5)
mDirection = con.getDirection();
}
}
}
public override bool DetectRadius()
{
// Clear the objects in range
if (ObjectsInRange.Count > 0)
{
ObjectsInRange.Clear();
}
// If it detects any objects in it's radius
if (base.DetectRadius())
{
// if both are in the list at the same time
// check if they are both within range to chase the cat
if (ObjectsInRange.Contains(playerObject) && ObjectsInRange.Contains(kittenObject))
{
DIRECTIONS playerDirection = GetTargetDirection(playerObject.transform.position);
DIRECTIONS kittenDirection = GetTargetDirection(kittenObject.transform.position);
// if both are clear
// then both can chase the cat
if (CheckIfClear(playerDirection, playerObject.transform.position) && CheckIfClear(kittenDirection, kittenObject.transform.position))
{
// set the kitten object as the target
// it should prioritise the kitten
targetObject = kittenObject;
targetDir = GetTargetDirection();
// is shocked should only trigger once
// to stop it from repeating multiple times
if (isTrapped == false)
{
isShocked = true;
TrappedTilePosition = MapManager.Instance.GetWorldToTilePos(transform.position);
}
if (m_ShockUI != null)
{
m_ShockUI.gameObject.SetActive(true);
}
isTrapped = true;
}
else
{
isTrapped = false;
}
}
else
{
isTrapped = false;
}
// if it is trapped, it shouldnt be able to do anything else
if (isTrapped)
{
return(false);
}
//// If it already has a target that it is running from
//if (targetObject != null)
// return false;
// Loop through the detected objects
string successfulTag = "";
foreach (GameObject detectedObj in ObjectsInRange)
{
// It will only look for these two objects
if (detectedObj.tag == "Player" || detectedObj.tag == "Kitten")
{
// Only detect when its idle
if (characterState == STATE.IDLE)
{
//THIS IS A HACK, STORE PREV DATA
GameObject PREVtargetObject = targetObject;
DIRECTIONS prevTargetDir = targetDir;
// Get the target object
targetObject = detectedObj;
// Check for the target direction
targetDir = GetTargetDirection();
// Check if the path to the detected object is clear
if (CheckIfClear(targetDir, targetObject.transform.position) == false)
{
// that target isnt available a danger to the mouse
if (successfulTag == "") //if theres nothing just reset
{
StopMovement();
}
//reset the data
targetObject = PREVtargetObject;
targetDir = prevTargetDir;
// check the next if there is
continue;
}
isShocked = true;
if (detectedObj.tag == "Kitten")
{
if (m_ShockUI != null)
{
m_ShockUI.gameObject.SetActive(true);
}
}
else
{
elapsedTime = 0.0f;
}
////HACK PRIROTIZE KITTEN
//if (successfulTag == "Kitten" && detectedObj.tag == "Player")
//{
// targetObject = PREVtargetObject;
// targetDir = prevTargetDir;
//}
//else
//{
// // reset it if it tracks the player
// if (detectedObj.tag == "Player")
// elapsedTime = 0.0f;
//}
// Debug.Log("Mouse IsShocked Changed in line 197" + isShocked);
successfulTag = detectedObj.tag;
}
// if it is a running state when it detects a enemy
else if (characterState == STATE.RUNNING)
{
// if it detects a new enemy while running from the player
if (detectedObj != targetObject && targetObject.tag == "Player")
{
DIRECTIONS detectedObjDir = GetTargetDirection(detectedObj.transform.position);
// if the object detected is behind a wall
// skip this object because it's not a threat
if (CheckIfClear(detectedObjDir, detectedObj.transform.position) == false)
{
continue;
}
// it has to be shocked
isShocked = true;
// Debug.Log("Mouse IsShocked Changed in line 219" + isShocked);
StartCoroutine(PlayerShockUITime());
StopMovement();
mouseMovement.StopMovement();
mouseMovement.ResetMovementList();
}
}
}
// If it spots the player or kitten
// it will try to run away
//if (detectedObj.tag == "Player" || detectedObj.tag == "Kitten" )
//{
// // if it already has a target
// if (targetObject != null)
// {
// // If it detects the kitten while being chased by the player
// if (targetObject != detectedObj && targetObject.tag == "Player")
// {
// // Make it shocked
// isShocked = true;
// // stop both the movement
// StopMovement();
// mouseMovement.StopMovement();
// mouseMovement.ResetMovementList();
// }
// }
// // Set the player object as it's current target
// targetObject = detectedObj;
// targetDir = GetTargetDirection();
// // Check the direction if its clear
// // if it isn't then they detected an enemy through the wall
// //if (CheckIfClear(targetDir) == false && targetObject.tag != "Player")
// //{
// // if (characterState == STATE.RUNNING)
// // {
// // mouseMovement.ResetMovementList();
// // mouseMovement.StopMovement();
// // }
// // StopMovement();
// // continue;
// //}
// // shocked
// if (characterState != STATE.RUNNING)
// isShocked = true;
//}
}
//if (isShocked && characterState == STATE.IDLE)
//{
// if (targetObject.tag == "Player")
// StartCoroutine(PlayerShockUITime());
//}
}
else
{
isShocked = false;
}
//else
//{
// characterState = STATE.IDLE;
// targetObject = null;
// targetDir = DIRECTIONS.NONE;
//}
return(false);
}
public void setDirection(DIRECTIONS direction)
{
mDirection = direction;
}
private TileBase MoveDirection(DIRECTIONS dir, bool force = false)
{
return(MoveDirection(dir.ToString(), force));
}
// Use this for initialization
void Start()
{
mDirection = DIRECTIONS.NORTH;
}
Vector3 getRandomDir()
{
DIRECTIONS dir = (DIRECTIONS)Random.Range(0, 4);
return(directions [(int)dir]);
}
