private void checkEngagement()
{
allTargets.Clear(); // clear the target list, incase another target is added or removed etc...
for (int i = 0; i < EngageOn.Length; i++)
{
allTargets.AddRange(GameObject.FindGameObjectsWithTag(EngageOn[i]));
}
float tempDistance = AggroRange;
GameObject tempTarget = null;
for (int i = 0; i < allTargets.Count; i++)
{
float distance = Vector2.Distance(transform.position, allTargets[i].transform.position);
if (distance > AggroRange)
{
continue;
}
if (distance <= tempDistance)
{
tempDistance = distance;
tempTarget = allTargets[i];
}
}
target = tempTarget;
if (target != null)
{
engaged = true;
currentState = EngagedState;
}
}
public override MovementEnum ReturnMove(MovementEnum move)
{
// check vision!
if (move == MovementEnum.North)
{
HMove = MovementEnum.North;
}
else if (move == MovementEnum.South)
{
HMove = MovementEnum.South;
}
else if (move == MovementEnum.East)
{
HMove = MovementEnum.East;
}
else if (move == MovementEnum.West)
{
HMove = MovementEnum.West;
}
else
{
HMove = MovementEnum.NoMovement;
}
return(HMove);
}
private void SendDirectionalButtonUpEvent(MovementEnum inputDirection)
{
DirectionalButtonUpEvent?.Invoke(this, new DirectionalButtonPressedEventArgs()
{
direction = inputDirection
});
}
public override MovementEnum ReturnMove(MovementEnum move = 0)
{
int random1 = rand.Next(0, 5);
// check vision!
if (random1 == 0)
{
GMove = MovementEnum.North;
}
else if (random1 == 1)
{
GMove = MovementEnum.South;
}
else if (random1 == 2)
{
GMove = MovementEnum.East;
}
else if (random1 == 3)
{
GMove = MovementEnum.West;
}
else
{
GMove = MovementEnum.NoMovement;
}
return(GMove);
}
public void UnFreeze()
{
if (frozen)
{
currentState = savedState;
frozen = false;
}
}
public override MovementEnum ReturnMove(MovementEnum move)
{
int direction = random.Next(0, 5);
while (vision[direction] != null)
{
direction = random.Next(0, 5);
}
return((MovementEnum)direction);
}
} // Hp & Max HP not specified in brief
public override MovementEnum ReturnMove(MovementEnum move = 0)
{
if (isMoveValid(move))
{
return(move);
}
else
{
return(MovementEnum.No_Movement);
}
}
public override MovementEnum ReturnMove(MovementEnum move = 0)
{
R = new Random(Guid.NewGuid().GetHashCode());
int min = 0, max = 3, randomNumber = R.Next(min, max + 1);
while (!isMoveValid(randomNumber))
{
R = new Random(Guid.NewGuid().GetHashCode()); randomNumber = R.Next(min, max + 1);
}
return((MovementEnum)randomNumber);
}
void Start()
{
currentState = StartState;
rigidbody2D = GetComponent <Rigidbody2D>();
for (int i = 0; i < CheckPoints.Count; i++)
{
checkPointPos.Add(CheckPoints[i].transform.position);
checkPointCheck.Add(false);
}
directionMultiplier = new Vector2(1, 0);
}
//
protected virtual void Awake()
{
if (GetComponent <BasicAnimator>())
{
bAnim = GetComponent <BasicAnimator>();
}
currentState = startState;
if (GetComponent <Rigidbody2D>())
{
rigidbody2D = GetComponent <Rigidbody2D>();
}
for (int i = 0; i < checkPoints.Count; i++)
{
checkPointPos.Add(checkPoints[i].transform.position);
checkPointCheck.Add(false);
}
//Maxslope
maxSlope = Mathf.Sin((maxSlope * Mathf.PI) / 180);
directionMultiplier = new Vector2(1, 0);
// Raydistance
rayDistanceHypot = Mathf.Pow((GetComponent <BoxCollider2D>().size.y *GetComponent <Transform>().localScale.y), 2) + // X^2
Mathf.Pow((GetComponent <BoxCollider2D>().size.x *GetComponent <Transform>().localScale.x), 2); // Y^2
rayDistanceHypot = Mathf.Sqrt(rayDistanceHypot);
rayDistanceHypot += 0.0f; // offSet.
// rayDistanceHypot = 0.7f;
// SlopeRay
rayOffSetX = GetComponent <BoxCollider2D>().size.x *transform.localScale.x / 2;
rayOffSetY = GetComponent <BoxCollider2D>().size.y *transform.localScale.y / 2;
boxOffSetY = GetComponent <BoxCollider2D>().offset.y;
boxOffSetX = GetComponent <BoxCollider2D>().offset.x * -1;
slopeRayOffset = rayOffSetY;
//Xray
rayDistanceX = Mathf.Abs((GetComponent <BoxCollider2D>().size.x *transform.localScale.x / 2));
if (flipped)
{
Flip();
}
}
public void Move(MovementEnum move)
{
switch (move)
{
case MovementEnum.No_Movement: break;
case MovementEnum.Up: Y--; break;
case MovementEnum.Down: Y++; break;
case MovementEnum.Left: X--; break;
case MovementEnum.Right: X++; break;
}
}
public void Freeze(bool autoActivate, float time)
{
if (!frozen)
{
savedState = currentState;
Debug.Log(savedState);
currentState = MovementEnum.Idle;
frozen = true;
this.autoActivate = autoActivate;
}
if (time != 0)
{
StartCoroutine(FreezeWait(time));
}
}
public void MoveEnemies()
{
for (int index = 0; index < gameMap.Enemies.Length; index++)
{
if (!gameMap.Enemies[index].isDead())
{
MovementEnum randomMovementDirection = gameMap.Enemies[index].ReturnMove(); // Obtain randon direction
EmptyTile tempt = new EmptyTile(gameMap.Enemies[index].getX(), gameMap.Enemies[index].getY()); // Enemy's position to be occupied by empty tile
// update enemy position
if (randomMovementDirection != MovementEnum.No_Movement)
{
gameMap.Enemies[index].Move(randomMovementDirection);
switch (randomMovementDirection)
{
case MovementEnum.No_Movement: break;
case MovementEnum.Up:
gameMap.Mymap[gameMap.Enemies[index].getX(), gameMap.Enemies[index].getY()] = gameMap.Enemies[index]; // update the enemy on the map
gameMap.Mymap[tempt.getX(), tempt.getY()] = tempt; // update the empty tile on the map
gameMap.UpdateVision(); break; // update the vision of all objects
case MovementEnum.Down:
gameMap.Mymap[gameMap.Enemies[index].getX(), gameMap.Enemies[index].getY()] = gameMap.Enemies[index];
gameMap.Mymap[gameMap.Enemies[index].getX(), gameMap.Enemies[index].getY() - 1] = tempt;
gameMap.UpdateVision(); break;
case MovementEnum.Left:
gameMap.Mymap[gameMap.Enemies[index].getX(), gameMap.Enemies[index].getY()] = gameMap.Enemies[index];
gameMap.Mymap[gameMap.Enemies[index].getX() + 1, gameMap.Enemies[index].getY()] = tempt;
gameMap.UpdateVision(); break;
case MovementEnum.Right:
gameMap.Mymap[gameMap.Enemies[index].getX(), gameMap.Enemies[index].getY()] = gameMap.Enemies[index];
gameMap.Mymap[gameMap.Enemies[index].getX() - 1, gameMap.Enemies[index].getY()] = tempt;
gameMap.UpdateVision(); break;
}
}
}
}
}
internal Movement(Position position, MovementEnum movementType, IWorld world)
{
#region Validazioni
if (position == null)
{
throw new ArgumentNullException(nameof(position));
}
if (world == null)
{
throw new ArgumentNullException(nameof(world));
}
#endregion
this.position = position;
this.movementType = movementType;
this.world = world;
this.MovementsActuator = GenerateMovementActuator();
}
public void Move(MovementEnum move)
{
if (move == MovementEnum.North)
{
x = x - 1;
}
else if (move == MovementEnum.South)
{
x = x + 1;
}
else if (move == MovementEnum.East)
{
y = y + 1;
}
else if (move == MovementEnum.West)
{
y = y - 1;
}
}
public void Move(MovementEnum move)
{
if (move = MovementEnum.Up)
{
Y += 1;
}
else if (move = MovementEnum.Down)
{
Y -= 1;
}
else if (move = MovementEnum.Left)
{
X -= 1;
}
else
{
X += 1;
}
}
void Update()
{
var newSidewaysDirection = DetermineMovementDirection("Horizontal");
if (HasMovemnetDirectionChanged(SidewaysDirection, newSidewaysDirection))
{
SidewaysDirection = newSidewaysDirection;
TurnSpeed = SidewaysSpeeds[(int)newSidewaysDirection];
TurnVector.Set(0, TurnSpeed, 0);
}
var newForwardDirection = DetermineMovementDirection("Vertical");
if (HasMovemnetDirectionChanged(ForwardDirection, newForwardDirection))
{
ForwardDirection = newForwardDirection;
Speed = ForwardSpeeds[(int)newForwardDirection];
}
}
public bool isMoveValid(MovementEnum direction)
{
if (direction == MovementEnum.Down)
{
return(getVision(VisionPosition.South).I == TileType.empty_tile || getVision(VisionPosition.South).I == TileType.gold);
}
else if (direction == MovementEnum.Up)
{
return(getVision(VisionPosition.North).I == TileType.empty_tile || getVision(VisionPosition.North).I == TileType.gold);
}
else if (direction == MovementEnum.Left)
{
return(getVision(VisionPosition.West).I == TileType.empty_tile || getVision(VisionPosition.West).I == TileType.gold);
}
else
{
return(getVision(VisionPosition.East).I == TileType.empty_tile || getVision(VisionPosition.East).I == TileType.gold);
}
}
internal Position CalculatePositionByMovement(MovementEnum movement, Position position)
{
#region Validations
if (position == null)
{
throw new ArgumentNullException(nameof(position));
}
#endregion
Position newPosition = null;
if (MovementsActuator.ContainsKey(position.Direction) && MovementsActuator[position.Direction].ContainsKey(movement))
{
newPosition = MovementsActuator[position.Direction][movement].Invoke(position);
}
ValidateMove(newPosition);
return(newPosition);
}
public override MovementEnum ReturnMove(MovementEnum move = 0)
{
int answer = -1;
// 1. Move towards the target
int deltaX = target.getX() - getX(); // Start by matching the xPos first
if (deltaX > 0 && getVision(VisionPosition.East).I == TileType.empty_tile)
{
answer = 3;
} // Leader can move right
else if (deltaX < 0 && getVision(VisionPosition.West).I == TileType.empty_tile)
{
answer = 2;
} // Leader can move left
if (answer == -1) // Leader could not move left or right, priorities moving up or down
{
int deltaY = target.getY() - getY(); // now matching the yPos
if (deltaY > 0 && getVision(VisionPosition.South).I == TileType.empty_tile)
{
answer = 1;
} // Leader can move down
else if (deltaY < 0 && getVision(VisionPosition.North).I == TileType.empty_tile)
{
answer = 0;
} // Leader can move left
}
if (answer == -1) // Leader failed to move towards the hero, now has to move randomly in a valid direction
{
// 2. Move randomly
R = new Random(Guid.NewGuid().GetHashCode()); answer = R.Next(0, 4);
while (!isMoveValid(answer))
{
R = new Random(Guid.NewGuid().GetHashCode()); answer = R.Next(0, 4);
} // roll until a valid direction is obtained
}
return((MovementEnum)answer);
}
public bool MovePlayer (MovementEnum direction)
{
if (map.PObject.Char_Vision[1].GetType() == typeof(Empty_Tile))
{
return true;
}
else if (map.PObject.Char_Vision[2].GetType() == typeof(Empty_Tile))
{
return true;
}
else if (map.PObject.Char_Vision[3].GetType() == typeof(Empty_Tile))
{
return true;
}
else if (map.PObject.Char_Vision[4].GetType() == typeof(Empty_Tile))
{
return true;
}
else
return false;
}
public void changeMovement(MovementEnum movementEnum)
{
movement.cleanUp();
/*switch (movementEnum) {
* case MovementEnum.Crouch:
* movement = new CrouchingMovement(this);
* break;
* case MovementEnum.Ground:
* movement = new GroundMovement(this);
* break;
* case MovementEnum.Midair:
* movement = new MidairMovement(this);
* break;
* case MovementEnum.Slide:
* movement = new SlidingMovement(this);
* break;
* }*/
movement = movements[movementEnum];
movement.setUp();
}
public bool MovePlayer(MovementEnum direction)
{
if (direction == MovementEnum.North)
{
return(true);
}
else if (direction == MovementEnum.South)
{
return(true);
}
else if (direction == MovementEnum.West)
{
return(true);
}
else if (direction == MovementEnum.East)
{
return(true);
}
else
{
return(false);
}
}
public override MovementEnum ReturnMove(MovementEnum move)
{
bool canmove = false;
int direction = random.Next(0, 4);
for (int i = 0; i < vision.Length; i++)
{
if (vision[i]?.GetType() == typeof(Hero))
{
return(MovementEnum.NoMovement);
}
if (vision[i] == null)
{
canmove = true;
break;
}
if ((vision[i].GetType().BaseType != typeof(Character) && vision[i].GetType().BaseType.BaseType != typeof(Character) && vision[i]?.ThisTileType != TileType.Empty))
{
canmove = true;
break;
}
}
if (canmove == false)
{
return(MovementEnum.NoMovement);
}
while (vision[direction] != null)
{
if (vision[direction].GetType().BaseType != typeof(Character) && vision[direction].GetType().BaseType.BaseType != typeof(Character) && vision[direction]?.ThisTileType != TileType.Empty)
{
return((MovementEnum)direction + 1);
}
direction = random.Next(0, 4);
}
return((MovementEnum)direction + 1);
}
public override MovementEnum ReturnMove(MovementEnum move = Character.MovementEnum.No_Movement)
{
throw new NotImplementedException();
}
public static extern float GetMovement(MovementEnum mEnum);
public abstract MovementEnum ReturnMove(MovementEnum move = 0);
private bool HasMovemnetDirectionChanged(MovementEnum oldM, MovementEnum newM)
{
return(oldM != newM);
}
public static extern void SetMovement(MovementEnum mEnum, float value);
public void UpdateDesiredTargetSpeed(Vector2 input)
{
if (input == Vector2.zero) return;
if (input.x > 0 || input.x < 0)
{
//strafe
currEnum = MovementEnum.Strafe;
CurrentTargetSpeed = StrafeSpeed;
}
if (input.y < 0)
{
//backwards
currEnum = MovementEnum.Backwards;
CurrentTargetSpeed = BackwardSpeed;
}
if (input.y > 0)
{
//forwards
//handled last as if strafing and moving forward at the same time forwards speed should take precedence
currEnum = MovementEnum.Forwards;
CurrentTargetSpeed = ForwardSpeed;
}
if (Input.GetKey(RunKey))
{
CurrentTargetSpeed *= RunMultiplier;
m_Running = true;
}
else
{
m_Running = false;
}
}
public override MovementEnum ReturnMove(MovementEnum move)
{
return(move);
}
public void ChangeMovement(MovementEnum movement)
{
character.ChangeMovement(movement);
}
public bool MovePlayer(MovementEnum direction)
{
bool isValid = false;
switch (direction)
{
case MovementEnum.No_Movement: break;
case MovementEnum.Up:
if (gameMap._Hero.isMoveValid(MovementEnum.Up))
{
// accomodate pick up items
Item itemToBeConsumed = gameMap.GetItemAtPosition(gameMap._Hero.getX(), gameMap._Hero.getY() - 1);
if (itemToBeConsumed != null)
{
gameMap._Hero.Pickup(itemToBeConsumed);
}
Tile tempt = new EmptyTile(gameMap._Hero.getX(), gameMap._Hero.getY()); // store position before update
gameMap._Hero.setY(gameMap._Hero.getY() - 1);
gameMap.Mymap[gameMap._Hero.getX(), gameMap._Hero.getY()] = gameMap._Hero;
gameMap.Mymap[tempt.getX(), tempt.getY()] = tempt; gameMap.UpdateVision(); isValid = true;
}
break;
case MovementEnum.Down:
if (gameMap._Hero.isMoveValid(MovementEnum.Down))
{
Item itemToBeConsumed = gameMap.GetItemAtPosition(gameMap._Hero.getX(), gameMap._Hero.getY() + 1);
if (itemToBeConsumed != null)
{
gameMap._Hero.Pickup(itemToBeConsumed);
}
Tile tempt = new EmptyTile(gameMap._Hero.getX(), gameMap._Hero.getY());
gameMap._Hero.setY(gameMap._Hero.getY() + 1);
gameMap.Mymap[gameMap._Hero.getX(), gameMap._Hero.getY()] = gameMap._Hero;
gameMap.Mymap[gameMap._Hero.getX(), gameMap._Hero.getY() - 1] = tempt; gameMap.UpdateVision(); isValid = true;
}
break;
case MovementEnum.Left:
if (gameMap._Hero.isMoveValid(MovementEnum.Left))
{
Item itemToBeConsumed = gameMap.GetItemAtPosition(gameMap._Hero.getX() - 1, gameMap._Hero.getY());
if (itemToBeConsumed != null)
{
gameMap._Hero.Pickup(itemToBeConsumed);
}
Tile tempt = new EmptyTile(gameMap._Hero.getX(), gameMap._Hero.getY());
gameMap._Hero.setX(gameMap._Hero.getX() - 1);
gameMap.Mymap[gameMap._Hero.getX(), gameMap._Hero.getY()] = gameMap._Hero;
gameMap.Mymap[gameMap._Hero.getX() + 1, gameMap._Hero.getY()] = tempt; gameMap.UpdateVision(); isValid = true;
}
break;
case MovementEnum.Right:
if (gameMap._Hero.isMoveValid(MovementEnum.Right))
{
Item itemToBeConsumed = gameMap.GetItemAtPosition(gameMap._Hero.getX() + 1, gameMap._Hero.getY());
if (itemToBeConsumed != null)
{
gameMap._Hero.Pickup(itemToBeConsumed);
}
Tile tempt = new EmptyTile(gameMap._Hero.getX(), gameMap._Hero.getY());
gameMap._Hero.setX(gameMap._Hero.getX() + 1);
gameMap.Mymap[gameMap._Hero.getX(), gameMap._Hero.getY()] = gameMap._Hero;
gameMap.Mymap[gameMap._Hero.getX() - 1, gameMap._Hero.getY()] = tempt; gameMap.UpdateVision(); isValid = true;
}
break;
}
return(isValid);
}
