/// <summary>
/// Starts chasing the player
/// </summary>
private void ChasePlayer()
{
Vector2 curentPosition = rigidbody.position;
float differenceX = transform.position.x - player.transform.position.x;
float differenceY = transform.position.y - player.transform.position.y;
if (!Mathf.Approximately(Round(differenceX, 2), 0.0f))
{
if (transform.position.x < player.transform.position.x)
{
//if player is at the right side of the enemy, the enemy will move right
possibleDirectionX = PossibleDirections.Rigth;
}
else if (transform.position.x > player.transform.position.x)
{
//if player is at the left side of the enemy, the enemy will move left
possibleDirectionX = PossibleDirections.Left;
}
}
if (!Mathf.Approximately(Round(differenceY, 2), 0.0f))
{
if (transform.position.y < player.transform.position.y)
{
//if player is over the enemy, the enemy will move upwards
possibleDirectionY = PossibleDirections.Up;
}
else if (transform.position.y > player.transform.position.y)
{
//if player is under the enemy, the enemy will move downwards
possibleDirectionY = PossibleDirections.Down;
}
}
rigidbody.MovePosition(movementService.CalculateNewPosition(curentPosition, movementSpeed, false, possibleDirectionX, possibleDirectionY));
}
public static int CountPossibleDirections(PossibleDirections directions)
{
var count = 0;
if ((directions & PossibleDirections.Up) == PossibleDirections.Up)
{
count++;
}
if ((directions & PossibleDirections.Down) == PossibleDirections.Down)
{
count++;
}
if ((directions & PossibleDirections.Left) == PossibleDirections.Left)
{
count++;
}
if ((directions & PossibleDirections.Right) == PossibleDirections.Right)
{
count++;
}
return(count);
}
public void GenerateDirectionPossibilities(PossibleDirections possibleDirections)
{
ClearState();
var directionsCount = MonsterDirection.CountPossibleDirections(possibleDirections);
var equalPosibility = 1f / directionsCount;
if ((possibleDirections & PossibleDirections.Up) == PossibleDirections.Up)
{
_possibilities.Add(PossibleDirections.Up, equalPosibility);
}
if ((possibleDirections & PossibleDirections.Down) == PossibleDirections.Down)
{
_possibilities.Add(PossibleDirections.Down, equalPosibility);
}
if ((possibleDirections & PossibleDirections.Left) == PossibleDirections.Left)
{
_possibilities.Add(PossibleDirections.Left, equalPosibility);
}
if ((possibleDirections & PossibleDirections.Right) == PossibleDirections.Right)
{
_possibilities.Add(PossibleDirections.Right, equalPosibility);
}
}
private void UpdateQTableVals(State state, PossibleDirections action, double reward, double stepFactor)
{
double biggestNextReward = learner.Q(state.AgentPosition.Last()).Values.ToArray().Max();
int[] previousState = state.AgentPosition[state.AgentPosition.Count - 2];
learner.Q(previousState)[action] =
(1 - LearningConstants.Alpha) * learner.Q(previousState)[action] +
LearningConstants.Alpha *
(reward + stepFactor * LearningConstants.Gamma * biggestNextReward);
}
private void RaycastToDirectionToFindWall(Vector3 rayDirection, PossibleDirections movementDirection)
{
RaycastHit2D hit = Physics2D.Raycast(transform.position, rayDirection, 1.0f);
if (hit.collider == null)
{
_monsterDirection.PossibleDirections = _monsterDirection.PossibleDirections | movementDirection;
}
else if (!hit.transform.tag.Equals("Wall"))
{
_monsterDirection.PossibleDirections = _monsterDirection.PossibleDirections | movementDirection;
}
}
public bool Act(State state, PossibleDirections action, double stepFactor)
{
// move Agent
Move(state, action);
int reward = UpdateRewards(state);
UpdateQTableVals(state, action, reward, stepFactor);
state.Map
.GetTileByCoordinates(state.AgentPosition.Last()[0], state.AgentPosition.Last()[1])
.LearningHistory
.Add(reward);
return(reward == rewards[Rewards.EXIT]);
}
/// <summary>
/// Chase the player if in range
/// </summary>
private void Update()
{
float distanceToPlayer = Vector2.Distance(transform.position, player.transform.position);
possibleDirectionX = PossibleDirections.None;
possibleDirectionY = PossibleDirections.None;
if (distanceToPlayer < aggroRange)
{
ChasePlayer();
}
else
{
StopChasingPlayer();
}
}
private void ToggleWall(Button cellButton, PossibleDirections wallPosition)
{
this.act.IsEnabled = false;
UIGridTile tile = ((ObservableCollection <UIGridTile>)cellButton.DataContext)
[((cellButton.Parent as System.Windows.Controls.Grid).TemplatedParent as DataGridCell).TabIndex];
if (tile.Wall == wallPosition)
{
tile.Wall = null;
cellButton.Background = Brushes.LightGray;
}
else
{
tile.Wall = wallPosition;
cellButton.Background = Brushes.IndianRed;
ClearWallsInCell((System.Windows.Controls.Grid)cellButton.Parent, cellButton);
ClearWallsInCellsAround((System.Windows.Controls.Grid)cellButton.Parent);
}
}
public Vector2 GetTargetPosition(PossibleDirections currentDirection, Vector2 currentTarget, Transform objectTransform)
{
switch (currentDirection)
{
case PossibleDirections.Up:
return(currentTarget + Vector2.up * _gridSize);
case PossibleDirections.Down:
return(currentTarget + Vector2.down * _gridSize);
case PossibleDirections.Left:
return(currentTarget + Vector2.left * _gridSize);
case PossibleDirections.Right:
return(currentTarget + Vector2.right * _gridSize);
default:
throw new ArgumentException("No such direction exists!");
}
}
/// <summary>
/// changes moving direction of NPC
/// </summary>
private void RandomDirection()
{
int anzahlLoops = 0;
int rndDirection = Random.Range(1, 5);
while (rndDirection == currentDirection)
{
rndDirection = Random.Range(1, 5);
anzahlLoops = anzahlLoops + 1;
}
if (rndDirection != currentDirection)
{
switch (rndDirection)
{
case 1:
possibleDirections = PossibleDirections.Up;
break;
case 2:
possibleDirections = PossibleDirections.Down;
break;
case 3:
possibleDirections = PossibleDirections.Left;
break;
case 4:
possibleDirections = PossibleDirections.Rigth;
break;
}
}
currentDirection = rndDirection;
timerDirection = CreateRandomRange();
}
private void Move(State state, PossibleDirections action)
{
int[] pos = state.AgentPosition.Last();
int[] newPos = { pos[0], pos[1] };
int dimension = state.Map.Dimension;
switch (action)
{
case PossibleDirections.UP:
if (
newPos[1] > 0
&&
state.Map.GetTileByCoordinates(pos[0], pos[1]).Wall != PossibleDirections.UP
&&
state.Map.GetTileByCoordinates(pos[0], pos[1] - 1).Wall != PossibleDirections.DOWN
)
{
newPos[1]--;
}
break;
case PossibleDirections.DOWN:
if (
newPos[1] < dimension - 1
&&
state.Map.GetTileByCoordinates(pos[0], pos[1]).Wall != PossibleDirections.DOWN
&&
state.Map.GetTileByCoordinates(pos[0], pos[1] + 1).Wall != PossibleDirections.UP
)
{
newPos[1]++;
}
break;
case PossibleDirections.LEFT:
if (
newPos[0] > 0
&&
state.Map.GetTileByCoordinates(pos[0], pos[1]).Wall != PossibleDirections.LEFT
&&
state.Map.GetTileByCoordinates(pos[0] - 1, pos[1]).Wall != PossibleDirections.RIGHT
)
{
newPos[0]--;
}
break;
case PossibleDirections.RIGHT:
if (
newPos[0] < dimension - 1
&&
state.Map.GetTileByCoordinates(pos[0], pos[1]).Wall != PossibleDirections.RIGHT
&&
state.Map.GetTileByCoordinates(pos[0] + 1, pos[1]).Wall != PossibleDirections.LEFT
)
{
newPos[0]++;
}
break;
}
state.AgentPosition.Add(newPos);
}
/// <summary>
/// Calculates new position based on current position and movementspeed
/// </summary>
/// <param name="currentPosition"></param>
/// <param name="movementSpeed"></param>
/// <param name="enteredCollision"></param>
/// <param name="possibleDirectionX"></param>
/// <param name="possibleDirectionY"></param>
/// <returns></returns>
public virtual Vector2 CalculateNewPosition(Vector2 currentPosition, float movementSpeed, bool enteredCollision, PossibleDirections possibleDirectionX, PossibleDirections possibleDirectionY)
{
throw new System.NotImplementedException();
}
/// <summary>
/// Calculates new position based on current position and movementspeed
/// </summary>
/// <param name="currentPosition"></param>
/// <param name="movementSpeed"></param>
/// <param name="enteredCollision"></param>
/// <returns>new actual position</returns>
public override Vector2 CalculateNewPosition(Vector2 currentPosition, float movementSpeed, bool enteredCollision, PossibleDirections possibleDirectionX, PossibleDirections possibleDirectionY)
{
float horizontalValue = 0;
float verticalValue = 0;
if (possibleDirectionX == PossibleDirections.Rigth)
{
horizontalValue = 1;
}
else if (possibleDirectionX == PossibleDirections.Left)
{
horizontalValue = -1;
}
if (possibleDirectionY == PossibleDirections.Up)
{
verticalValue = 1;
}
else if (possibleDirectionY == PossibleDirections.Down)
{
verticalValue = -1;
}
Vector2 move = new Vector2(horizontalValue, verticalValue);
currentPosition = CalculateBoth(currentPosition, movementSpeed, move);
CalculateAnimation(animator, move);
return(currentPosition);
}
public void UpdateTheDirectionPossibilities(PossibleDirections directionToPlayer)
{
_possibilities[directionToPlayer] -= _possibilityChange;
}
public static TopDownDirection FromDirection(float x, float y, PossibleDirections possibleDirections, TopDownDirection?lastDirection = null)
{
if (x == 0 && y == 0)
{
throw new System.Exception("Can't convert 0,0 to a direction");
}
switch (possibleDirections)
{
case PossibleDirections.LeftRight:
if (x > 0)
{
return(TopDownDirection.Right);
}
else if (x < 0)
{
return(TopDownDirection.Left);
}
break;
case PossibleDirections.FourWay:
var absXVelocity = System.Math.Abs(x);
var absYVelocity = System.Math.Abs(y);
if (absXVelocity > absYVelocity)
{
if (x > 0)
{
return(TopDownDirection.Right);
}
else if (x < 0)
{
return(TopDownDirection.Left);
}
}
else if (absYVelocity > absXVelocity)
{
if (y > 0)
{
return(TopDownDirection.Up);
}
else if (y < 0)
{
return(TopDownDirection.Down);
}
}
else // absx and absy are equal:
{
// The first two if-checks preserve the direction the user was facing when
// moving diagonal, instead of making the right direction the dominant direction.
if (lastDirection == TopDownDirection.Up && y > 0)
{
return(TopDownDirection.Up);
}
else if (lastDirection == TopDownDirection.Down && y < 0)
{
return(TopDownDirection.Down);
}
else if (x > 0)
{
return(TopDownDirection.Right);
}
else
{
return(TopDownDirection.Left);
}
}
break;
case PossibleDirections.EightWay:
if (x != 0 || y != 0)
{
var angle = FlatRedBall.Math.MathFunctions.RegulateAngle(
(float)System.Math.Atan2(y, x));
var ratioOfCircle = angle / Microsoft.Xna.Framework.MathHelper.TwoPi;
var eights = FlatRedBall.Math.MathFunctions.RoundToInt(ratioOfCircle * 8) % 8;
return((TopDownDirection)eights);
}
break;
}
throw new System.Exception();
}
public static TopDownDirection FromDirection(float x, float y, PossibleDirections possibleDirections)
{
if (x == 0 && y == 0)
{
throw new System.Exception("Can't convert 0,0 to a direction");
}
switch (possibleDirections)
{
case PossibleDirections.LeftRight:
if (x > 0)
{
return(TopDownDirection.Right);
}
else if (x < 0)
{
return(TopDownDirection.Left);
}
break;
case PossibleDirections.FourWay:
var absXVelocity = System.Math.Abs(x);
var absYVelocity = System.Math.Abs(y);
if (absXVelocity > absYVelocity)
{
if (x > 0)
{
return(TopDownDirection.Right);
}
else if (x < 0)
{
return(TopDownDirection.Left);
}
}
else if (absYVelocity > absXVelocity)
{
if (y > 0)
{
return(TopDownDirection.Up);
}
else if (y < 0)
{
return(TopDownDirection.Down);
}
}
else // absx and absy are equal:
{
if (x > 0)
{
return(TopDownDirection.Right);
}
else
{
return(TopDownDirection.Left);
}
}
break;
case PossibleDirections.EightWay:
if (x != 0 || y != 0)
{
var angle = FlatRedBall.Math.MathFunctions.RegulateAngle(
(float)System.Math.Atan2(y, x));
var ratioOfCircle = angle / Microsoft.Xna.Framework.MathHelper.TwoPi;
var eights = FlatRedBall.Math.MathFunctions.RoundToInt(ratioOfCircle * 8) % 8;
return((TopDownDirection)eights);
}
break;
}
throw new System.Exception();
}
public static TopDownDirection FromDirection(Microsoft.Xna.Framework.Vector3 direction, PossibleDirections possibleDirections)
{
return(FromDirection(direction.X, direction.Y, possibleDirections));
}
public void UpdateTheDirectionPossibilities(PossibleDirections directionToPlayer)
{
_randomDirectionGenerator.UpdateTheDirectionPossibilities(directionToPlayer);
}
