public override void Move()
{
time_start += Time.deltaTime;
if (time_start >= 1.0f)
{
time_start = 0;
switch (dir)
{
case CurrentDirection.Horizontal:
vertical_dir = -vertical_dir;
dir = CurrentDirection.Vertical;
break;
case CurrentDirection.Vertical:
dir = CurrentDirection.Horizontal;
break;
}
}
switch (dir)
{
case CurrentDirection.Horizontal:
base.Move();
break;
case CurrentDirection.Vertical:
mPosition.y += mVelocity.y * mSpeed.y * Time.deltaTime * vertical_dir;
mPosition.x = transform.position.x;
transform.position = mPosition;
break;
}
}
private void moveGhost()
{
// on deplace le fantome
switch (CurrentDirection.ToEnum())
{
case DirectionEnum.Up:
Y -= Constants.GRID_HEIGHT_4;
break;
case DirectionEnum.Right:
X += Constants.GRID_WIDTH_4;
if (X >= (Labyrinth.WIDTH * Constants.GRID_HEIGHT + Constants.GRID_WIDTH_X2))
{
X = -Constants.GRID_WIDTH_X2;
}
break;
case DirectionEnum.Down:
Y += Constants.GRID_HEIGHT_4;
break;
case DirectionEnum.Left:
X -= Constants.GRID_WIDTH_4;
if (X <= -Constants.GRID_WIDTH_X2)
{
X = (Labyrinth.WIDTH * Constants.GRID_WIDTH + Constants.GRID_WIDTH_X2);
}
break;
}
}
void CreateFirstLayout()
{
int randomNum = Random.Range(0, LevelGenerator.upwardPossibilities.Length);
CurrentDirection randomDirection = LevelGenerator.upwardPossibilities[randomNum];
GameObject firstLayout = Instantiate(GameAssets.i.GetDesiredLevelLayout(CurrentDirection.UP, levelType).levelLayOutPrefab, new Vector3(firstLayoutPos.transform.position.x, firstLayoutPos.transform.position.y), Quaternion.identity);
Transform pivotAnchor = firstLayout.transform.Find("PivotAnchor").transform;
GameObject generator = pivotAnchor.Find("LevelGenerator").transform.gameObject;
LevelGenerator firstGenerator = generator.GetComponent <LevelGenerator>();
//firstGenerator.AdjustLayoutSizes();
Transform positionBeforeSettingActive = pivotAnchor.GetComponentInChildren <LevelGenerator>().nextLayoutAnchor.transform;
generator.SetActive(false);
pivotAnchor.transform.position = firstLayout.transform.position;
GameObject secondLayout = Instantiate(GameAssets.i.GetDesiredLevelLayout(randomDirection, levelType).levelLayOutPrefab, new Vector3(firstLayoutPos.transform.position.x, firstLayoutPos.transform.position.y), Quaternion.identity);
Transform pivotAnchor2 = secondLayout.transform.Find("PivotAnchor").transform;
pivotAnchor2.transform.position = positionBeforeSettingActive.position;
LevelGenerator levelGenerator = secondLayout.GetComponentInChildren <LevelGenerator>();
levelGenerator.borderCollider.size = new Vector2(levelGenerator.borderCollider.size.x, levelGenerator.borderCollider.size.y + 30f);
//////////////////
GameObject backgroundFirstLayer = pivotAnchor.transform.Find("BrownBackground").gameObject;
for (int i = 0; i < backgroundFirstLayer.transform.childCount; i++)
{
backgroundFirstLayer.transform.GetChild(i).GetComponent <SpriteRenderer>().sortingOrder += -10;
}
}
/// <see cref="IForwardMoveCommand.TryMoveForward(int)"/>
public bool TryMoveForward(int steps)
{
PerformValidationBeforeMove(steps);
Position newPosition = CurrentDirection.MoveForward(CurrentPosition);
return(TryMoveChessPiece(newPosition));
}
private void OnMazeChange(CurrentDirection current)
{
hasShownCurrentPrompt = true;
HideInteractionPrompt();
currentMaze = (currentMaze + (current == CurrentDirection.DOWN ? 1 : mazeLevels.Length - 1)) % mazeLevels.Length;
SetCurrentMazeActive();
SetLightRadius();
}
/// <summary>
/// Applies sequential command.
/// </summary>
/// <param name="commands">Rover.Commands.L, Rover.Commands.M, ...</param>
/// <returns>CurrentX, CurrentY, CurrentDirection</returns>
public (int, int, Direction) Execute(params Commands[] commands)
{
foreach (Commands command in commands)
{
switch (command)
{
case Commands.R:
CurrentDirection++;
break;
case Commands.L:
CurrentDirection--;
break;
case Commands.M:
switch (CurrentDirection.ToValue())
{
case Direction.Values.N:
if (CurrentY < BoundaryY)
{
CurrentY++;
}
break;
case Direction.Values.E:
if (CurrentX < BoundaryX)
{
CurrentX++;
}
break;
case Direction.Values.S:
if (CurrentY > 0)
{
CurrentY--;
}
break;
case Direction.Values.W:
if (CurrentX > 0)
{
CurrentX--;
}
break;
default:
break;
}
break;
default:
break;
}
}
return(CurrentX, CurrentY, CurrentDirection);
}
public void MoveFoward()
{
Coordinates newCoordinates = CurrentDirection.MoveFrom(CurrentPosition);
if (grid.IsWithinGrid(newCoordinates))
{
CurrentPosition = newCoordinates;
}
}
/// <summary>
/// Moves the specified blocks.
/// </summary>
/// <param name="blocks">The blocks.</param>
private void Move(int blocks)
{
// Store starting point.
string startPoint = Coordinates();
for (var i = 0; i < blocks; i++)
{
// Move 1 block at a time - required for Part 2
int x = CurrentPoint.X;
int y = CurrentPoint.Y;
switch (CurrentDirection)
{
case Direction.East:
x++;
break;
case Direction.West:
x--;
break;
case Direction.North:
y++;
break;
case Direction.South:
y--;
break;
default:
Console.WriteLine(
$"Huh? It seems that you're trying to move in a non-standard direction. ({CurrentDirection})");
break;
}
// Set current position.
CurrentPoint = new Point(x, y);
// If there are any points in our log of previously visited points (X and Y coordinates match),
// and we have not found a previously-visited block, set this block as our first revisited block.
if (Points.Any(point => CurrentPoint.X == point.X && CurrentPoint.Y == point.Y) &&
FirstRevisitedPoint.X == 0 &&
FirstRevisitedPoint.Y == 0)
{
FirstRevisitedPoint = CurrentPoint;
}
// Add the current point to our log of positions.
Points.Add(CurrentPoint);
}
// Add the current movement to our log.
Sb.AppendLine(string.Join(",", CurrentDirection.ToString(), blocks.ToString(), CurrentPoint.X.ToString(),
CurrentPoint.Y.ToString()));
Console.WriteLine(
$"Travelled {blocks.ToString().PadLeft(6)} blocks {CurrentDirection.ToString().PadRight(10)} from {startPoint.PadRight(5)} to {Coordinates().PadRight(8)}");
}
public override void Update(GameTime gameTime, Level level)
{
base.Update(gameTime, level);
if (Parent == null)
{
return;
}
var lookDirection = VectorHelper.AngleToV2(Angle + (float)(Math.PI / 2), 1);
Position = Parent.CenterPosition + lookDirection * new Vector2(15);
foreach (var ent in GetCollisionRects().SelectMany(e => level.CollidesWith(e, true)).Distinct())
{
if (ent is Arrow && ((Arrow)ent).HitEntity == null)
{
ent.CurrentDirection = CurrentDirection.Rotate(-_swingedAngle / 4).Normalized();
ent.Parent = Parent;
}
else if (ent != this && ent != Parent && (ent.Health != null || ent is Boomerang))
{
var direction = VectorHelper.AngleToV2(Angle, 5);
direction = new Vector2(-direction.Y, direction.X);
ent.Hit(this, gameTime, level, direction);
}
}
if (!_rotationCompleted || _keepRotating > 0)
{
var oldAngle = _swingedAngle;
_swingedAngle += (float)(_swingDirection * _swingSpeed * gameTime.ElapsedGameTime.TotalMilliseconds / 1000);
if (!_rotationCompleted && (_swingDirection > 0 == _swingedAngle > 0))
{
_rotationCompleted = true;
if (!_removeOnComplete)
{
_swingedAngle = 0;
}
}
if (_rotationCompleted)
{
_keepRotating--;
if (_removeOnComplete && _keepRotating <= 0)
{
level.RemoveEntity(this);
_removeOnComplete = false;
}
}
}
Angle = _desiredAngle + _swingedAngle;
Parent.Look(lookDirection, updateDirection: false);
}
/// <summary>
/// Halts movement.
/// </summary>
/// <seealso cref="Resume"/>
public void Wait()
{
_allowedDirections = AllowReverse ? new Utility.EDirection4[2] : new Utility.EDirection4[1];
_allowedDirections[0] = CurrentDirection;
if (AllowReverse)
{
_allowedDirections[1] = CurrentDirection.Opposite();
}
CurrentDirection = Utility.EDirection4.None;
}
/// <see cref="IDiagonalForwardMoveCommand.TryMoveDiagonalRightForward(int)"/>
public bool TryMoveDiagonalRightForward(int steps)
{
PerformValidationBeforeMove(steps);
Position newPosition = CurrentDirection.MoveForward(CurrentPosition);
newPosition = CurrentDirection.MoveRight(newPosition);
return(Capture(newPosition));
}
public string Report()
{
try
{
return("Output: " + XPosition + "," + YPosition + "," + CurrentDirection.ToString());
}
catch (Exception ex)
{
//TODO : Exception to be logged
return(UNKNOWN_ERROR);
}
}
public void ChangeDirection_Direction11_ShouldReturnNextDirection()
{
// Arrange
CurrentDirection direction = new CurrentDirection(1, 1);
// Act
Directions.ChangeDirection(direction);
CurrentDirection expectedDirection = new CurrentDirection(1, 0);
// Assert
Assert.IsTrue(expectedDirection.X == direction.X && expectedDirection.Y == direction.Y);
}
/**
* Sets direction to a new direction. This changes the path of the ghosts.
*/
void SetCurrentDirection()
{
canMove = false;
CurrentDirection newDir = GetRandDirection();
while (newDir == direction)
{
newDir = GetRandDirection();
}
direction = newDir;
DetermineNextDirection();
canMove = true;
}
void SetThisLevelTypeDirection()
{
if (transform.parent.parent.tag == "UpLayout")
{
thisLevelDirection = CurrentDirection.UP;
}
else if (transform.parent.parent.tag == "LeftLayout")
{
thisLevelDirection = CurrentDirection.LEFT;
}
else if (transform.parent.parent.tag == "RightLayout")
{
thisLevelDirection = CurrentDirection.RIGHT;
}
}
public LevelLayouts GetCorrectOrRandomDirectionLayout(CurrentDirection direction, LevelType type)
{
List <LevelLayouts> possibleLayout = new List <LevelLayouts>();
foreach (LevelLayouts obj in levelLayoutsAArray)
{
if (obj.direction == direction && obj.type == type)
{
possibleLayout.Add(obj);
}
}
int randomNum = Random.Range(0, possibleLayout.Count);
return(possibleLayout[randomNum]);
}
// Start is called before the first frame update
/**
* Upon start, this sets the initial position and direction for the ghost
*/
void Start()
{
destination = GetFirstDestination();
if (Random.Range(0, 2) > 0)
{
direction = CurrentDirection.left;
DetermineNextDirection();
}
else
{
direction = CurrentDirection.right;
DetermineNextDirection();
}
canMove = true;
}
public override void Switch()
{
BaseTrack temp = NextTrack;
NextTrack = SecondNextTrack;
SecondNextTrack = temp;
if (CurrentDirection.Equals(Direction.UP))
{
CurrentDirection = Direction.DOWN;
}
else
{
CurrentDirection = Direction.UP;
}
}
/// <summary>
/// Causes this Entity to being walking in the given direction, either Left or Right.
/// Walking may then be stopped through the StopWalking method.
/// </summary>
public void BeginWalking(Direction dir)
{
if (dir != Direction.Left && dir != Direction.Right)
{
throw new ArgumentException("Walk only applies to the Left and Right directions.");
}
_WalkDirection = dir;
CurrentDirection = _WalkDirection;
IsWalking = true;
var Animation = SpriteComponent.Sprite.Animations["Walk" + CurrentDirection.ToString()];
if (SpriteComponent.Sprite.ActiveAnimation != Animation)
{
SpriteComponent.Sprite.PlayAnimation(Animation.Name);
}
}
public override void Switch()
{
BaseTrack previousTrack = null;
PreviousTracks.TryGetValue(CurrentDirection, out previousTrack);
if (CurrentDirection.Equals(Direction.UP))
{
CurrentDirection = Direction.DOWN;
}
else
{
CurrentDirection = Direction.UP;
}
PreviousTracks.TryGetValue(CurrentDirection, out previousTrack);
previousTrack.NextTrack = this; //Tell track in current direction it has a next track }
}
private int getYeuxNum()
{
int res = 9;
switch (CurrentDirection.ToEnum())
{
case DirectionEnum.Up:
res = 10;
break;
case DirectionEnum.Right:
res = 9;
break;
case DirectionEnum.Down:
res = 12;
break;
case DirectionEnum.Left:
res = 11;
break;
}
return(res);
}
//
public CurrentDirection CheckDirection(Vector3 analogDirection)
{
if (analogDirection.z >= 0.9f)
{
currentDirection = CurrentDirection.Up;
}
else if (analogDirection.z <= -0.9f)
{
currentDirection = CurrentDirection.Down;
}
else if (analogDirection.x <= -0.9f)
{
currentDirection = CurrentDirection.Left;
}
else if (analogDirection.x >= 0.9f)
{
currentDirection = CurrentDirection.Right;
}
else
{
currentDirection = CurrentDirection.Neutral;
}
return(currentDirection);
}
public override string ToString()
{
return(string.Format("{0}\n{1}", CurrentPosition, CurrentDirection.ToStringDirection()));
}
public void RightTurn()
{
CurrentDirection = CurrentDirection.OneStepRight();
}
public void LeftTurn()
{
CurrentDirection = CurrentDirection.OneStepLeft();
}
public LevelLayouts GetDesiredLevelLayout(CurrentDirection direction, LevelType type)
{
return(GetCorrectOrRandomDirectionLayout(direction, type));
}
public override string ToString()
{
return($"{CurrentLocation.ToString()} {CurrentDirection.ToString()}");
}
private void RealFishMove(GameTime gt, List <Items.FoodPellet> pList)
{
hungerTimer -= gt.ElapsedGameTime.TotalSeconds;
if (closestPellet != null && closestPellet._CurrentState == SpriteState.kStateInActive)
{
closestPellet = null;
fishStatus = FishStatus.kStatusRoam;
}
if (hungerTimer < 0)
{
Hunger++;
hungerTimer = 0.5f;
if (fishStatus == FishStatus.kStatusRoam)
{
if (hunger > 40)
{
fishStatus = FishStatus.kStatusFood;
}
}
}
if (fishStatus == FishStatus.kStatusRoam)
{
moveTimer -= gt.ElapsedGameTime.TotalSeconds;
if (moveTimer <= 0)
{
moving = true;
Random ran = new Random();
moveTimer = ran.Next(0, 8);
targetPos.X = ran.Next(10, 750);
targetPos.Y = ran.Next(85, 450);
}
}
else if (fishStatus == FishStatus.kStatusFood)
{
if (pList.FindAll(x => x._CurrentState == SpriteState.kStateActive).Count > 0)
{
float closestDistance = 100000;
foreach (Items.FoodPellet p in pList.FindAll(x => x._CurrentState == SpriteState.kStateActive))
{
//find closest pellet.
if (p._Position.Y < 70)
{
continue;
}
float currentDistance = Vector2.Distance(this.FishMouth.Location.ToVector2(), p._Position);
if (currentDistance < closestDistance)
{
closestPellet = p;
closestDistance = currentDistance;
}
}
}
if (closestPellet != null)
{
targetPos = closestPellet._Position;
moving = true;
if (closestPellet._CurrentState == SpriteState.kStateInActive || closestPellet._Position.Y < 70)
{
moving = false;
if (_FlipX)
{
MyDir = CurrentDirection.kDirectionLeft;
}
else
{
MyDir = CurrentDirection.kDirectionRight;
}
}
if (closestPellet._BoundingBox.Intersects(this.FishMouth))
{
closestPellet.Deactivate();
closestPellet = null;
Hunger -= 50;
moving = false;
fishStatus = FishStatus.kStatusRoam;
this._Scale.X += 0.3f;
this._Scale.Y += 0.3f;
if (this._Scale.X > 2.0f)
{
this._Scale.X = 2.0f;
this._Scale.Y = 2.0f;
}
}
}
else
{
fishStatus = FishStatus.kStatusRoam;
}
}
//else if(fishStatus == FishStatus.kStatusDead)
//{
// this._Rotation = MathHelper.ToRadians(180);
// if(this._Position.Y > 70)
// {
// float speed = 100f;
// this._Position.Y -= (float)(speed * gt.ElapsedGameTime.TotalSeconds);
// }
//}
//if (InputHelper.LeftButtonClicked)
//{
// moving = true;
// targetPos = InputHelper.MouseScreenPos;
//}
//if(Hunger >= 100)
//{
// this.fishStatus = FishStatus.kStatusDead;
//}
if (moving)
{
float speed = 100f;
if (Math.Abs((this.FishMouth.Location.ToVector2().X - targetPos.X)) > 5)
{
if (this.FishMouth.Location.ToVector2().X < targetPos.X)
{
this._Position.X += speed * (float)gt.ElapsedGameTime.TotalSeconds;
if (Math.Abs((this.FishMouth.Location.ToVector2().X - targetPos.X)) > 20)
{
this._FlipX = false;
MyDir = CurrentDirection.kDirectionRight;
}
}
else if (this.FishMouth.Location.ToVector2().X > targetPos.X)
{
this._Position.X -= speed * (float)gt.ElapsedGameTime.TotalSeconds;
if (Math.Abs((this.FishMouth.Location.ToVector2().X - targetPos.X)) > 20)
{
this._FlipX = true;
MyDir = CurrentDirection.kDirectionLeft;
}
}
}
if (Math.Abs((this.FishMouth.Location.ToVector2().Y - targetPos.Y)) > 5)
{
if (this.FishMouth.Location.ToVector2().Y < targetPos.Y)
{
this._Position.Y += speed * (float)gt.ElapsedGameTime.TotalSeconds;
if (Math.Abs((this.FishMouth.Location.ToVector2().Y - targetPos.Y)) > 15)
{
if (_FlipX)
{
//this._Rotation = MathHelper.ToRadians(-45);
MyDir = CurrentDirection.kDirectionLeft;
}
else
{
//this._Rotation = MathHelper.ToRadians(45);
MyDir = CurrentDirection.kDirectionRight;
}
}
}
else if (this.FishMouth.Location.ToVector2().Y > targetPos.Y)
{
this._Position.Y -= speed * (float)gt.ElapsedGameTime.TotalSeconds;
if (Math.Abs((this.FishMouth.Location.ToVector2().Y - targetPos.Y)) > 15)
{
if (_FlipX)
{
//this._Rotation = MathHelper.ToRadians(45);
MyDir = CurrentDirection.kDirectionLeft;
}
else
{
//this._Rotation = MathHelper.ToRadians(-45);
MyDir = CurrentDirection.kDirectionRight;
}
}
}
}
else
{
this._Rotation = 0;
}
if (Vector2.Distance(this.FishMouth.Location.ToVector2(), targetPos) < 10)
{
moving = false;
this._Rotation = 0;
if (_FlipX)
{
MyDir = CurrentDirection.kDirectionLeft;
}
else
{
MyDir = CurrentDirection.kDirectionRight;
}
}
}
if (closestPellet != null)
{
pelletLastFrame = true;
}
else
{
pelletLastFrame = false;
}
}
private void DebugMove()
{
this._Rotation = 0;
if (InputHelper.IsKeyDown(Keys.Left))
{
_FlipX = true;
if (InputHelper.IsKeyDown(Keys.Down))
{
//this._Rotation = MathHelper.ToRadians(-45);
MyDir = CurrentDirection.kDirectionLeft;
}
else if (InputHelper.IsKeyDown(Keys.Up))
{
//this._Rotation = MathHelper.ToRadians(45);
MyDir = CurrentDirection.kDirectionLeft;
}
else
{
MyDir = CurrentDirection.kDirectionLeft;
}
}
else if (InputHelper.IsKeyDown(Keys.Right))
{
_FlipX = false;
if (InputHelper.IsKeyDown(Keys.Up))
{
//this._Rotation = MathHelper.ToRadians(-45);
MyDir = CurrentDirection.kDirectionRight;
}
else if (InputHelper.IsKeyDown(Keys.Down))
{
//this._Rotation = MathHelper.ToRadians(45);
MyDir = CurrentDirection.kDirectionRight;
}
else
{
MyDir = CurrentDirection.kDirectionRight;
}
}
if (InputHelper.IsKeyDown(Keys.A))
{
this._Scale.X -= 0.03f;
if (this._Scale.X < 0.1f)
{
this._Scale.X = 0.1f;
}
}
else if (InputHelper.IsKeyDown(Keys.D))
{
this._Scale.X += 0.03f;
if (this._Scale.X > 2f)
{
this._Scale.X = 2f;
}
}
if (InputHelper.IsKeyDown(Keys.W))
{
this._Scale.Y -= 0.03f;
if (this._Scale.Y < 0.1f)
{
this._Scale.Y = 0.1f;
}
}
else if (InputHelper.IsKeyDown(Keys.S))
{
this._Scale.Y += 0.03f;
if (this._Scale.Y > 2f)
{
this._Scale.Y = 2f;
}
}
if (InputHelper.RightButtonClicked)
{
this._Position = InputHelper.MouseScreenPos;
}
if (InputHelper.IsKeyPressed(Keys.Space))
{
this._Scale = Vector2.One;
this._Rotation = 0;
}
if (InputHelper.IsKeyPressed(Keys.LeftControl))
{
this._Scale.X = 0.5f;
this._Scale.Y = 0.5f;
}
//if(InputHelper.IsKeyDown(Keys.R))
//{
// this._Rotation += 0.05f;
//}
}
/// <summary>
/// Has the car arrived at its destination?
/// </summary>
/// <returns>true if arrived, false if still transitioning.</returns>
private bool ArrivedDestination()
{
bool arrived = false;
// Are we heading in a direction, but servicing the opposite list (i.e. heading up to service the downList - or vice versa)
Direction currentListDirection = (CurrentList == upList) ? Direction.up : Direction.down;
if (currentListDirection != CurrentDirection)
{
// We are servicing opposing list / direction case. We have only arrived if we are at the head of the list.
if ((CurrentList.Count > 0) && (CurrentList[0] != CurrentFloor))
{
return(arrived);
}
}
if (CurrentList.Contains(CurrentFloor))
{
Console.WriteLine("Car is on floor {0}, loading/unloading passengers, and {1}.", CurrentFloor, (CurrentDirection == Direction.idle) ? "is idle" : "is heading " + CurrentDirection.ToString());
Console.WriteLine("You have {0} seconds to choose your destination. Otherwise, you may loose your turn.", ElevatorTimer.TheTimer.Interval / 1000);
CurrentList.Remove(CurrentFloor);
arrived = true;
}
return(arrived);
}
