/// <summary>
/// Initializes a new instance of the <see cref="BasePathScenario" /> class.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
protected BasePathScenario(int width, int height)
{
Width = width;
Height = height;
int volume = Width * Height;
Directions = DirectionHelper.GetValues().ToList();
Cache = UseCache ? new BitArray(volume) : null;
DistanceMap = new ushort[volume];
IsFirstRun = true;
AreHollowAreasMinimized = true;
ObstacleDetectionMethod = BlockMethodType.Precise;
}
private IEnumerator FireProjectile()
{
while (Health > 0)
{
yield return(new WaitForSecondsRealtime(timeBetweenAttacks));
if (!playerSensor.playerInRange)
{
continue;
}
EnemyProjectile projectile = Instantiate(projectilePrefab, transform.position, Quaternion.identity).GetComponent <EnemyProjectile>();
Vector2 playerDirection = DirectionHelper.GetDirectionVector((player.transform.position - transform.position).x > 0 ? EDirection.Right : EDirection.Left);
projectile.TargetPosition = transform.position + new Vector3(playerDirection.x, playerDirection.y, 0);
}
}
public void DoTurn()
{
if (DOTween.IsTweening(MakeUniqueId(TurnTweenId)))
{
DOTween.Kill(MakeUniqueId(TurnTweenId));
OnTurnNotCompleted();
}
var targetDirection = DirectionHelper.SwapHorizontalDirection(Direction);
var rot = targetDirection == HorizontalDirection.Left ? LeftRotation : RightRotation;
Direction = DirectionHelper.SwapHorizontalDirection(Direction);
StartTurnMotionAndPlayTurnSound(rot, TurnTime, TurnEase, TurnTweenId, OnTurnCompleted, OnTurnStarted);
}
/* Highlighting of all possible moves
*/
private void HighlightPossibleTurns(BaseChecker currentSelectedChecker)
{
PathPoint turns = currentSelectedChecker.GetPossibleTurns();
if (!turns.IsDeadEnd())
{
foreach (TurnDirection direction in DirectionHelper.GetAllDirections())
{
foreach (PathPoint point in turns[direction])
{
board[point.Position.X, point.Position.Y].Highlighted = true;
}
}
}
}
private static ProgressLine[] GetProgressLines(
Point origin,
Direction entranceDirection,
Direction exitDirection)
{
var lines = new List <ProgressLine>();
var combinedDirection = DirectionHelper.GetCombinedDirection(
entranceDirection,
exitDirection);
switch (combinedDirection)
{
case Direction.Right:
lines.AddRange(GetRightProgressLines(origin));
break;
case Direction.Left:
lines.AddRange(GetLeftProgressLines(origin));
break;
case Direction.Top:
lines.AddRange(GetTopProgressLines(origin));
break;
case Direction.Bottom:
lines.AddRange(GetBottomProgressLines(origin));
break;
case Direction.BottomLeft:
lines.AddRange(GetBottomLeftProgressLines(origin));
break;
case Direction.BottomRight:
lines.AddRange(GetBottomRightProgressLines(origin));
break;
case Direction.TopLeft:
lines.AddRange(GetTopLeftProgressLines(origin));
break;
case Direction.TopRight:
lines.AddRange(GetTopRightProgressLines(origin));
break;
}
return(lines.ToArray());
}
private void UpdateVelocity()
{
if (executed)
{
return;
}
if (Health > 0)
{
enemyRigidbody.velocity = (DirectionHelper.GetDirectionVector(moveDirection) * moveSpeed) + new Vector2(0, enemyRigidbody.velocity.y);
}
else
{
enemyRigidbody.velocity = new Vector2();
}
}
void doMouseMovement(double frameMS)
{
var player = (Mobile)WorldModel.Entities.GetPlayerEntity();
if (player == null)
{
return;
}
// if the move button is pressed, change facing and move based on mouse cursor direction.
if (ContinuousMouseMovementCheck)
{
var resolution = UltimaGameSettings.UserInterface.PlayWindowGumpResolution;
var centerScreen = new Vector2Int(resolution.Width / 2, resolution.Height / 2);
var mouseDirection = DirectionHelper.DirectionFromPoints(centerScreen, MouseOverWorldPosition);
_timeSinceMovementButtonPressed += frameMS;
if (_timeSinceMovementButtonPressed >= c_PauseBeforeMouseMovementMS)
{
// Get the move direction.
var moveDirection = mouseDirection;
// add the running flag if the mouse cursor is far enough away from the center of the screen.
var distanceFromCenterOfScreen = Utility.DistanceBetweenTwoPoints(centerScreen, MouseOverWorldPosition);
if (distanceFromCenterOfScreen >= 150.0f || UltimaGameSettings.UserInterface.AlwaysRun)
{
moveDirection |= Direction.Running;
}
player.PlayerMobile_Move(moveDirection);
}
else
{
// Get the move direction.
var facing = mouseDirection;
if (player.Facing != facing)
{
// Tell the player entity to change facing to this direction.
player.PlayerMobile_ChangeFacing(facing);
// reset the time since the mouse cursor was pressed - allows multiple facing changes.
_timeSinceMovementButtonPressed = 0d;
}
}
}
else
{
_timeSinceMovementButtonPressed = 0d;
// Tell the player to stop moving.
player.PlayerMobile_Move(Direction.Nothing);
}
}
private void UpdateMeshAndDirection()
{
// Count number of connections along cardinal (which is all that we use atm)
var cardinalInfo = adjacents.GetCardinalInfo();
// Determine rotation and mesh specially for every single case.
// TODO: add meshes mentioned in header to script
float rotation = 0.0f;
Mesh mesh;
if (cardinalInfo.IsO())
{
mesh = o;
}
else if (cardinalInfo.IsC())
{
mesh = c;
rotation = DirectionHelper.AngleBetween(Direction.North, cardinalInfo.GetOnlyPositive());
}
else if (cardinalInfo.IsI())
{
mesh = i;
rotation = OrientationHelper.AngleBetween(Orientation.Vertical, cardinalInfo.GetFirstOrientation());
}
else if (cardinalInfo.IsL())
{
mesh = l;
rotation = DirectionHelper.AngleBetween(Direction.NorthEast, cardinalInfo.GetCornerDirection());
}
else if (cardinalInfo.IsT())
{
mesh = t;
rotation = DirectionHelper.AngleBetween(Direction.South, cardinalInfo.GetOnlyNegative());
}
else // Must be X
{
mesh = xAll;
}
if (filter == null)
{
filter = GetComponent <MeshFilter>();
}
filter.mesh = mesh;
transform.localRotation = Quaternion.Euler(transform.localRotation.eulerAngles.x, rotation, transform.localRotation.eulerAngles.z);
}
private Direction ChooseDirection(Vector2Int currentTile, Vector2Int targetTile, List <Direction> validDirections)
{
Direction chosenDirection = currentDirection; // Dummy value
var leastDistance = float.MaxValue;
foreach (var direction in validDirections)
{
if (DirectionHelper.DirectionsAreOpposite(currentDirection, direction))
{
continue;
}
var xCoord = currentTile.x;
var yCoord = currentTile.y;
switch (direction)
{
case Direction.Down:
yCoord += 1;
break;
case Direction.Up:
yCoord -= 1;
break;
case Direction.Right:
xCoord += 1;
break;
case Direction.Left:
xCoord -= 1;
break;
default:
throw new ArgumentOutOfRangeException();
}
Vector2Int projectedTile = new Vector2Int(xCoord, yCoord);
var distance = Vector2Int.Distance(targetTile, projectedTile);
if (distance < leastDistance)
{
chosenDirection = direction;
leastDistance = distance;
}
}
return(chosenDirection);
}
private void CloseWall(Wall wallEntity, Wall wall)
{
wallEntity.Row = wall.Row;
wallEntity.Column = wall.Column;
wallEntity.Direction = wall.Direction;
var nextPosition = PositionHelper.GetNextPosition(wall.Row, wall.Column, wall.Direction);
var reverseDirection = DirectionHelper.GetReverseDirection(wall.Direction);
GameObject wallObject = null;
GameObject reverseWallObject = null;
foreach (var wallObj in _wallGameObjects)
{
var wallElement = wallObj.transform.GetComponent <WallElement>();
if (
wallElement.Row == wall.Row &&
wallElement.Column == wall.Column &&
wallElement.Direction == wall.Direction
)
{
wallObject = wallObj;
}
if (
wallElement.Row == nextPosition.Row &&
wallElement.Column == nextPosition.Column &&
wallElement.Direction == reverseDirection
)
{
reverseWallObject = wallObj;
}
}
wallEntity.Transforms = new List <Transform>();
if (wallObject != null)
{
wallEntity.Transforms.Add(wallObject.transform);
wallObject.SetActive(true);
}
if (reverseWallObject != null)
{
wallEntity.Transforms.Add(reverseWallObject.transform);
reverseWallObject.SetActive(true);
}
}
public ArrowThreeWayCell(int col, int row) : base(col, row)
{
CellType = CellType.ArrowThreeWay;
Terminal = false;
directionHelper = new DirectionHelper();
direction = directionHelper.RandomizeDirection();
var dirs = new List <Direction> {
Direction.N,
Direction.E,
Direction.SW
};
turnListTo = directionHelper.TurnListTo(direction, dirs);
}
public void ManageMovement()
{
Vector2 input = GetInput();
BaseConstants.Direction direction = DirectionHelper.VectorToDirection(input);
if (direction != BaseConstants.Direction.None)
{
Move(direction);
// Animate walking if receiving input
if (!currentDirection.Equals(BaseConstants.Direction.None))
{
AnimateMovement();
}
}
}
/// <summary>
/// Shoots projectile in given direction
/// </summary>
/// <param name="vector">Vector</param>
/// <param name="actor">Actor that shot projectile</param>
public void Shoot(Vector2 vector, Actor actor)
{
// Set velocity
GetComponent <Rigidbody2D>().velocity = vector * speed;
GameController.Log("Trajectory: " + vector, GameController.LogPhysics);
// Set rotation (flip 90 degrees if needed)
if (!DirectionHelper.IsVertical(DirectionHelper.VectorToDirection(vector)))
{
Quaternion rotation = transform.rotation;
rotation.eulerAngles = new Vector3(0, 0, 90F);
transform.rotation = rotation;
}
// Save reference to actor so his bullets don't damage him
this.actor = actor;
}
private bool IsElementAvailable(int column, int row, int round, int number, DirectionEnum direction)
{
var position = PositionHelper.GetNextPosition(column, row, direction);
var element = GetBoardElement(position);
var wall = GetWall(position, DirectionHelper.GetReverseDirection(direction));
if (
wall != null ||
(element.ContainsSnakeStep && element.Round == round) ||
(element.ContainsTarget && element.Round == round && !TargetHelper.CanGetTargetElement(number))
)
{
return(false);
}
return(true);
}
protected override void Awake()
{
if (this.SetDirectionAutomatically)
{
this.AllowedDirection = DirectionHelper.FromRotation(this.Rotation2D, Direction2D.Down);
}
_previousScaleY = this.Scale2D.Y;
_previousPositionY = this.Position2D.Y;
var boxCollider = this.Get <BoxCollider2D>();
if (boxCollider != null)
{
_scaleMultiplier = boxCollider.size.y;
}
}
public void JumpPressed()
{
if ((!IsGrounded || !CanMove) && !IsWallclimbing)
{
return;
}
if (IsWallclimbing)
{
playerRigidbody.AddForce(new Vector2(JumpPower * -2 * DirectionHelper.GetDirectionVector(forwardDirection).x, JumpPower));
}
else
{
playerRigidbody.AddForce(new Vector2(0, JumpPower));
}
playerRigidbody.gravityScale = jumpGravityScale;
jumpHeld = true;
}
private Sequence OnTurnInternal()
{
Sequence sequence = DOTween.Sequence();
// Store the previous location
prevPos = pos.GetVector2i();
// Move the projectile based on the position
var moveDir = DirectionHelper.ToVector2i(MovingDirection);
sequence.Append(pos.AnimatedMove(pos.X + moveDir.x, pos.Y + moveDir.y, 0.2f));
OnTurn(sequence);
CheckAndDestroy(sequence);
return(sequence);
}
public void Update(double deltaTime)
{
_player.Update(deltaTime);
if (_player.Dead)
{
MainWindow.SetGameState(new GameStateGameOver((int)_player.Score));
}
_scoreText.Str = $"Score: {(int)_player.Score}";
_world.Update();
var playerPosition = _player.PositionForCamera;
_camera.Target = playerPosition + new Vector3(0, 2.5f, 0);
_camera.UpdateCameraPosition(playerPosition + (-DirectionHelper.GetVectorFromDirection(_player.CurrentDirection) * 4f) + new Vector3(0, 3, 0), (float)deltaTime, 5f);
_coinsRotation += 0.1f;
}
public Map GenerateRandomMap()
{
while (true)
{
var mapBuilder = CreateMapBuilder();
var directions = new List <Direction>();
var seenPoints = new HashSet <Point>();
var repeatedFailureCount = 0;
var currentDirection = Direction.Top;
while (repeatedFailureCount < 100)
{
var previousDirection = currentDirection;
var newDirection = directionHelper.GetRandomDirectionOtherThan(
previousDirection,
DirectionHelper.GetOppositeDirection(
previousDirection));
mapBuilder.MoveInDirection(newDirection);
repeatedFailureCount = 0;
var currentPoint = mapBuilder.CurrentPoint;
currentDirection = newDirection;
directions.Add(newDirection);
seenPoints.Add(currentPoint);
if (currentPoint.X == 0 && currentPoint.Y == 0)
{
if (directions.Count == 4)
{
break;
}
return(mapBuilder.Build());
}
}
}
throw new NotImplementedException();
}
/// <summary>
/// 更新一帧
/// </summary>
/// <param name="input">用户在这一帧内的输入。当前来说，如果玩家在一帧内按下了多个按钮，我们只处理第一个</param>
/// <returns>地图上被改变了的点的坐标集合</returns>
public IEnumerable <Point> Update(params GameKey[] input)
{
// 如果没有输入的话，那么蛇继续沿着之前的方向移动
if (input.Length == 0)
{
return(this.ProcessPlayerMove());
}
var key = input[0];
switch (key)
{
case GameKey.A:
break;
case GameKey.B:
// 更新间隔在5帧和3帧之间切换
this.frameSkipper.FramePerUpdate = this.frameSkipper.FramePerUpdate == 5 ? 3 : 5;
break;
// 如果输入了方向键的话
case GameKey.Up:
case GameKey.Down:
case GameKey.Left:
case GameKey.Right:
// ToDirection是扩展方法，返回的是带问号（Nullable）的Direction，也就是【Direction?】。需要用强制类型转换转成Direction
var newDirection = (Direction)key.ToDirection();
// 蛇只能转向，不能掉头
if (!DirectionHelper.IsOpposite(this.currentDirection, newDirection))
{
this.currentDirection = newDirection;
}
return(ProcessPlayerMove());
default:
break;
}
// 什么情况下会执行到这行呢？
// 答案：当用户有输入，但是输入的不是方向键的情况下
return(ProcessPlayerMove());
}
public void Grow()
{
_logger.Debug($"Snake.Grow()");
if (Head == null)
{
Head = new SnakeSegment(new Vector2((float)_gameSettings.TileSize), new Size2(_gameSettings.TileSize, _gameSettings.TileSize), Direction.Left); //GenerateRandomSegment();
}
else
{
var last = Tail.Any() ? Tail.LastOrDefault() : Head;
if (last != null)
{
var position = last.Position + DirectionHelper.RotateVector(_unitVector, DirectionHelper.GetOppositeDirection(last.Direction));
_tail.Add(new SnakeSegment(position, last.Size, last.Direction));
}
}
}
protected override void WhenDestroyed()
{
base.WhenDestroyed();
Direction firstDir = DirectionHelper.GetRandom();
List <Direction> dirs = new List <Direction>()
{
Direction.Down, Direction.Left, Direction.Right, Direction.Up
}
.Where(dir => dir != firstDir)
.Where(dir => CheckTileIsNormal(pos.GetVector2i() + dir.ToVector2i())).ToList();
Direction secondDir = Direction.None;
if (dirs.Any())
{
secondDir = dirs.GetRandom();
}
SpawnMonster("ZacBaby", pos.X, pos.Y, firstDir);
SpawnMonster("ZacBaby", pos.X, pos.Y, secondDir);
/*
* if (CheckTileIsNormal (pos.X + 2, pos.Y) && CheckTileIsNormal (pos.X - 2, pos.Y))
* {
* SpawnMonster ("ZacBaby", pos.X + 2, pos.Y);
* SpawnMonster ("ZacBaby", pos.X - 2, pos.Y);
* }
* else if (CheckTileIsNormal (pos.X, pos.Y - 2) && CheckTileIsNormal (pos.X, pos.Y + 2))
* {
* SpawnMonster ("ZacBaby", pos.X, pos.Y - 2);
* SpawnMonster ("ZacBaby", pos.X, pos.Y + 2);
* }
* else if (CheckTileIsNormal (pos.X + 2, pos.Y) && CheckTileIsNormal (pos.X, pos.Y + 2))
* {
* SpawnMonster ("ZacBaby", pos.X + 2, pos.Y);
* SpawnMonster ("ZacBaby", pos.X, pos.Y + 2);
* }
* else if (CheckTileIsNormal (pos.X - 2, pos.Y) && CheckTileIsNormal (pos.X, pos.Y - 2))
* {
* SpawnMonster ("ZacBaby", pos.X - 2, pos.Y);
* SpawnMonster ("ZacBaby", pos.X, pos.Y - 2);
* }
*/
}
public override void Move(int registerOffset)
{
if (Robot == null)
{
return;
}
Debug.WriteLine(this + " move");
var newConveyorBeltTile = Game.MoveRobot(Robot, Direction) as ConveyorBeltTile;
if (newConveyorBeltTile == null)
{
return;
}
var rotationDirection = DirectionHelper.GetRotationDirection(Direction, newConveyorBeltTile.Direction);
Game.RotateRobot(newConveyorBeltTile.Robot, rotationDirection);
}
private Wall GetWall(PositionModel position, DirectionEnum direction)
{
var nextPosition = PositionHelper.GetNextPosition(position.Row, position.Column, direction);
var reverseDirection = DirectionHelper.GetReverseDirection(direction);
return(_wallsFilter
.ToEntitiesList()
.FirstOrDefault(e =>
(
e.Row == position.Row &&
e.Column == position.Column &&
e.Direction == direction
) ||
(
e.Row == nextPosition.Row &&
e.Column == nextPosition.Column &&
e.Direction == reverseDirection
)
));
}
public MapBuilder MoveInDirection(Direction direction)
{
var node = GenerateMapSegmentNode(
nodes.Count,
origin,
DirectionHelper.GetOppositeDirection(previousDirection),
direction);
var offset = DirectionHelper.GetDirectionalOffset(direction);
var newPoint = new Point(
origin.X + offset.X,
origin.Y + offset.Y);
origin = newPoint;
previousDirection = direction;
nodes.Add(node);
return(this);
}
public void IsPointInDirectionOfSensorLineWorks()
{
Assert.IsTrue(DirectionHelper
.IsPointInDirectionOfSensorLine(
new Line()
{
Start = new Point(-1, -1),
End = new Point(1, 1)
},
new Point(0.5m, 0.5m)));
Assert.IsTrue(DirectionHelper
.IsPointInDirectionOfSensorLine(
new Line()
{
Start = new Point(0, 0),
End = new Point(0.1m, 0.1m)
},
new Point(0.5m, 0.5m)));
}
public bool Move(Direction direction, bool closePrev = false)
{
//Sadly AoC uses different int values than I do
int dirCode = 4;
if (direction == Direction.North)
{
dirCode = 1;
}
if (direction == Direction.South)
{
dirCode = 2;
}
if (direction == Direction.West)
{
dirCode = 3;
}
int response = (int)brain.Run(new List <BigInteger> {
dirCode
})[0];
if (response > 0)
{
if (mentalMap[X, Y] == "D")
{
SetMapTiles(X, Y, closePrev ? "#" : " ");
}
(X, Y) = DirectionHelper.NeighbourInDirection(direction, X, Y);
Finished = response == 2;
SetMapTiles(X, Y, Finished ? "O" : "D");
return(true);
}
else
{
var(mentalX, mentalY) = DirectionHelper.NeighbourInDirection(direction, X, Y);
SetMapTiles(mentalX, mentalY, "\u2588");
return(false);
}
}
private void DrawSegment(SpriteBatch spriteBatch, ISnakeSegment segment)
{
var selectedTexture = SelectTexture(segment);
var rotation = DirectionHelper.GetRotation(segment.Direction);
var origin = new Vector2(selectedTexture.Bounds.Width / 2f, selectedTexture.Bounds.Height / 2f);
var scale = CalculateScale(segment, selectedTexture);
spriteBatch.Draw(
texture: selectedTexture.Texture,
position: segment.Position,
sourceRectangle: selectedTexture.Bounds,
color: Color.White,
rotation: rotation,
scale: scale,
origin: origin,
effects: SpriteEffects.None,
layerDepth: LayerDepths.Snake
);
}
public void TestNeighbourInDirection()
{
var(x, y) = (0, 0);
var north = DirectionHelper.NeighbourInDirection(Direction.North, x, y);
var northEast = DirectionHelper.NeighbourInDirection(Direction.NorthEast, x, y);
var east = DirectionHelper.NeighbourInDirection(Direction.East, x, y);
var southEast = DirectionHelper.NeighbourInDirection(Direction.SouthEast, x, y);
var south = DirectionHelper.NeighbourInDirection(Direction.South, x, y);
var southWest = DirectionHelper.NeighbourInDirection(Direction.SouthWest, x, y);
var west = DirectionHelper.NeighbourInDirection(Direction.West, x, y);
var northWest = DirectionHelper.NeighbourInDirection(Direction.NorthWest, x, y);
Assert.AreEqual((x, y + 1), north);
Assert.AreEqual((x + 1, y + 1), northEast);
Assert.AreEqual((x + 1, y), east);
Assert.AreEqual((x + 1, y - 1), southEast);
Assert.AreEqual((x, y - 1), south);
Assert.AreEqual((x - 1, y - 1), southWest);
Assert.AreEqual((x - 1, y), west);
Assert.AreEqual((x - 1, y + 1), northWest);
}
public void Execute(Puzzle puzzle, int arg)
{
Point oldPosition = puzzle.Player.Position;
Point newPosition = DirectionHelper.ShiftPoint(oldPosition, arg);
bool moved = false;
if (puzzle.Timelines[puzzle.Player.Timeline].IsWalkableOrPushable(newPosition))
{
Element pushable = puzzle.Timelines[puzzle.Player.Timeline].GetPushable(newPosition);
if (pushable != null)
{
if (puzzle.Timelines[puzzle.Player.Timeline].IsUnwalkableOrPushable(DirectionHelper.ShiftPoint(newPosition, arg)))
{
moved = false;
}
else
{
Pushed = pushable;
DirectionHelper.ShiftPoint(ref pushable.Position, arg);
moved = true;
}
}
else
{
moved = true;
}
}
if (moved)
{
PlayerMovement = DirectionHelper.ToPoint(arg);
puzzle.Player.Position = newPosition;
}
else
{
PlayerMovement = Point.Zero;
}
}
