public void CanGetOppositeDirection() { // Assert helper.GetOppositeDirection(Direction.S).ShouldBeEqual(Direction.N); helper.GetOppositeDirection(Direction.E).ShouldBeEqual(Direction.W); helper.GetOppositeDirection(Direction.NE).ShouldBeEqual(Direction.SW); }
protected void Walk() { if ((DateTime.Now - _lastTimeWalked).TotalMilliseconds <= Server.MobWalkInterval) { return; } _lastTimeWalked = DateTime.Now; var room = RoomHelper.GetPlayerRoom(Location); // get allowed exits var allowedExits = room.Exits.Where(e => AllowedRooms.Contains(e.Value.LeadsTo) && e.Value.IsOpen).ToList(); if (allowedExits.Any() && Server.Current.Random.NextDouble() < 0.5) { var exit = allowedExits.Skip(Server.Current.Random.Next(allowedExits.Count())).FirstOrDefault(); room.RemoveNpc(this); var newRoom = RoomHelper.GetPlayerRoom(exit.Value.LeadsTo); newRoom.AddNpc(this); Location = newRoom.Key; room.SendPlayers(string.Format("{0} heads {1}.", Name, DirectionHelper.GetDirectionWord(exit.Key)), null, null, null); newRoom.SendPlayers( string.Format("{0} arrives from the {1}.", Name, DirectionHelper.GetOppositeDirection(exit.Key)), null, null, null); } }
/* * Iterating through the nodes to see which is closer to targetTile (Pac-man) */ private Direction ChooseNewDirection() { if (_reverseDirection) { _reverseDirection = false; return(DirectionHelper.GetOppositeDirection(currentDirection)); } Direction chosenDirection = currentDirection; var currentTile = gameManager.GetEntityCurrentTileCoordinates(entityId, currentDirection); var validDirections = levelManager.GetValidDirectionsForTile(currentTile, currentState == GhostState.LeavingBox || currentState == GhostState.Consumed); if (validDirections.Count == 1) { return(validDirections[0]); } if (currentState == GhostState.LeavingBox) { chosenDirection = ChooseDirection(currentTile, levelManager.BoxDoorEntranceCoordinates, validDirections); } else if (currentState == GhostState.Consumed) { consumedBoxTile = levelManager.GetRandomBoxTileCoordinates(); chosenDirection = ChooseDirection(currentTile, consumedBoxTile, validDirections); } else if (currentState == GhostState.Roaming) { var mode = modeManager.currentMode; switch (mode) { case ModeManager.Mode.Chase: Vector2Int targetTile = ChooseTargetTile(); chosenDirection = ChooseDirection(currentTile, targetTile, validDirections); break; case ModeManager.Mode.Scatter: chosenDirection = ChooseDirection(currentTile, levelManager.GetOwnCorner(entityId), validDirections); break; case ModeManager.Mode.Frightened: chosenDirection = ChooseFrightenedModeDirection(validDirections); break; default: throw new ArgumentOutOfRangeException(); } } return(chosenDirection); }
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(); }
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 override bool Update() { bool finish = false; var world = EntityManager.Instance.World; var destination = Entity.Position.NextPosition(direction); if (world.CanMove(destination)) { world.MoveEntity(Entity, destination); if (Entity.Position.Equals(EntityManager.Instance.Player.Position)) { finish = true; EntityManager.Instance.AddDeadEntity(EntityManager.Instance.Player); } } if (!world.CanMove(destination.NextPosition(direction))) { direction = DirectionHelper.GetOppositeDirection(direction); } return(finish); }
/* Trying to move checker * Calculating the movement * ------------------------------------------------------------------------------ */ private void DoMovement(BaseChecker previouslySelectedChecker, Point toPosition) { string logMessage = Constants.localized.logTurn + ' '; PathPoint turns; // Erase highlighting on all checkers DeselectAllCheckers(); // If the move does not start if (state.ActiveCheckerPathPoint == null) { turns = previouslySelectedChecker.GetPossibleTurns(); // Calculation of all possible chains of moves for a checker state.ActiveCheckerPathPoint = turns; } else { turns = state.ActiveCheckerPathPoint; // Continuation of the movement } // If the position is not a deadlock if (!turns.IsDeadEnd()) { state.ActiveChecker = previouslySelectedChecker; // Movement for (int i = 0; i < 4; i++) { foreach (PathPoint point in turns[i]) { if (toPosition == point.Position) { Point fromPosition = new Point() { X = previouslySelectedChecker.Position.BoardPosition.X, Y = previouslySelectedChecker.Position.BoardPosition.Y }; logMessage += previouslySelectedChecker.GetPrintablePosition() + $" {Constants.localized.logMoveTo} "; // Moving the checker to the selected position previouslySelectedChecker.MoveTo(new Point(toPosition.X, toPosition.Y)); logMessage += previouslySelectedChecker.GetPrintablePosition(); Game.userLogController.WriteMessage(logMessage); // Defining the direction of movement Point moveDirection = new Point() { X = toPosition.X - fromPosition.X > 0 ? 1 : -1, Y = toPosition.Y - fromPosition.Y > 0 ? 1 : -1 }; // Determination of the eaten checkers TryEatEnemyCheckers(previouslySelectedChecker, toPosition, fromPosition, moveDirection); // If the checker can become a king if (previouslySelectedChecker is Pawn && previouslySelectedChecker.Position.BoardPosition.Y == (previouslySelectedChecker.Direction == CheckerMoveDirection.Upstairs ? 0 : 7)) { // Replacement of a checker by a king King newKing = new King(previouslySelectedChecker.Side, previouslySelectedChecker.Position); state.AllCheckers.Remove(previouslySelectedChecker); state.AllCheckers.Add(newKing); // Adding to the list of drawings Game.drawingController.AddToDrawingList(newKing); previouslySelectedChecker.Destroy(); // Calculation of the further path for a king state.ActiveChecker = newKing; if (state.ActiveCheckerPathPoint.afterAggression) { state.ActiveCheckerPathPoint = newKing.GetPossibleTurns(DirectionHelper.GetOppositeDirection(DirectionHelper.GetDirection(moveDirection))); if (state.ActiveCheckerPathPoint.TryGetAggresiveDirections().Count == 0) { // End of turn EndTurn(); return; } else { DeselectAllCheckers(); state.ActiveChecker.selected = true; HighlightPossibleTurns(state.ActiveChecker); } } else { EndTurn(); return; } } // Find the point he went to // Calculate whether it is possible to continue the movement foreach (PathPoint waypoint in state.ActiveCheckerPathPoint[DirectionHelper.GetDirection(moveDirection)]) { if (waypoint.Position == toPosition) { if (!waypoint.IsOnlyFinalTraces()) { // Continuation of the movement state.ActiveCheckerPathPoint = waypoint; DeselectAllCheckers(); state.ActiveChecker.selected = true; HighlightPossibleTurns(state.ActiveChecker); } else { // End of turn EndTurn(); } } } return; } } } } else { // Deadlock position, end of turn if (state.ActiveChecker != null || state.ActiveCheckerPathPoint != null) { state.ActiveChecker = null; state.ActiveCheckerPathPoint = null; } } }
private void TryExecuteCommand(string input) { if (input.ToLower() == "exitmapping") { Session.PopState(); return; } var room = RoomHelper.GetPlayerRoom(Session.Player); if (_status == MappingStatus.Walking) { var direction = DirectionHelper.GetDirectionWord(input); if (string.IsNullOrEmpty(direction)) { Session.WriteLine("That's not a direction."); return; } if (room.HasExit(direction)) { var commandInfo = Server.Current.CommandLookup.FindCommand(direction, Session.Player); commandInfo.Command.Execute(Session, CommandContext.Create(direction)); return; } // set mode to request title Session.WriteLine("`RCreating exit, Please enter a title..."); _status = MappingStatus.NeedsTitle; _direction = direction; } else { // user is inputting a title var checkRoom = Server.Current.Database.Get <Room>(input.ToLower()); var calculatedKey = input.ToLower(); if (checkRoom != null) { calculatedKey = RoomHelper.GenerateKey(input); Session.WriteLine("`RRoom already exists. Using title: `G{0}`R.", calculatedKey); } var newRoom = new Room() { Area = room.Area, Description = RoomHelper.GetDefaultRoomDescription(), Key = calculatedKey.ToLower(), Title = input, }; newRoom.Exits.Add(DirectionHelper.GetOppositeDirection(_direction), new RoomExit() { IsDoor = false, IsOpen = true, LeadsTo = room.Key }); Server.Current.Database.Save(newRoom); room.Exits.Add(_direction, new RoomExit() { IsDoor = false, IsOpen = true, LeadsTo = newRoom.Key }); Server.Current.Database.Save(room); var commandInfo = Server.Current.CommandLookup.FindCommand(_direction, Session.Player); commandInfo.Command.Execute(Session, CommandContext.Create(_direction)); _status = MappingStatus.Walking; } }
public override void Execute(Session session, CommandContext context) { var currentRoom = RoomHelper.GetRoom(session.Player.Location); if (currentRoom != null) { try { string direction = context.Arguments[0]; context.Arguments.Remove(direction); if (!DirectionHelper.isValidDirection(direction)) { session.WriteLine("{0} is not a valid direction", direction); PrintSyntax(session); } if (currentRoom.HasExit(direction)) { session.WriteLine("Room already has {0} exit", direction); PrintSyntax(session); return; } // handle doors string openClose = context.Arguments[0]; bool isDoor; bool isOpen; if (openClose == "<open>" || openClose == "<close>") { isDoor = true; isOpen = openClose == "<open>"; context.Arguments.Remove(openClose); } else { isDoor = false; isOpen = true; } // at this point, direction has been removed. all that remains if the new room key/name string dstRoomKey = string.Join(" ", context.Arguments).Trim().ToLower(); var dstRoom = RoomHelper.GetRoom(dstRoomKey); if (dstRoom == null) { session.WriteLine("Room key not found: {0}", dstRoomKey); PrintSyntax(session); return; } // fixme: confirm dstRoom doesn't already have the opposite exit e.g. if creating // north exit, dstRoom should not already have south exit currentRoom.Exits.Add(direction, new RoomExit() { LeadsTo = dstRoomKey, IsDoor = isDoor, IsOpen = isOpen }); string oppositeDirection = DirectionHelper.GetOppositeDirection(direction); dstRoom.Exits.Add(oppositeDirection, new RoomExit() { LeadsTo = currentRoom.Key, IsDoor = isDoor, IsOpen = isOpen }); RoomHelper.SaveRoom(currentRoom); RoomHelper.SaveRoom(dstRoom); } catch { PrintSyntax(session); } } }
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)); } } }