// Creates totalNumberofLoops amount of loops in the given level private void CreateLoops(Dictionary <Vector2, Room> level) { // Get a list of all Positions, and then randomize it Vector2[] roomPool = level.Keys.ToArray <Vector2>(); RandomizeArray <Vector2>(roomPool); int loopCounter = 0; int firstDirection; int randDirection; Direction attemptDirection; foreach (Vector2 current in roomPool) { if (loopCounter >= totalNumberOfLoops) { break; } firstDirection = r.Next(4); randDirection = firstDirection; // necessary for compiling properly. Is literally changed immediately (we love c#) for (int i = 0; i < 4; i++) { randDirection = (firstDirection + i) % 4; attemptDirection = DirectionMethods.NumberToDirection(randDirection); if (IsRoomHere(level, current, attemptDirection)) { if (!IsConnected(level, current, attemptDirection)) { AddConnection(level, current, attemptDirection); loopCounter++; } } } } }
/// <summary> /// Moves the agent to threshhold distance from target at speed /// </summary> public bool MoveTo(Vector2 target, float speed, float threshold) { AiData.currentBehavior = AIData.Behave.Chase; Vector2 current = transform.position; if (Vector2.Distance(current, target) <= threshold || current == target) { AnimatorBody.Play("Idle"); //AiData.path.Clear(); return(true); } else { #region Move AnimatorBody.Play("Move"); target = (target - current); target = Vector2.ClampMagnitude(target, speed); controller.Direction = DirectionMethods.FromVec2(target); if (!AiData.updateBehavior) { return(false); } RigidBody.velocity = Vector2.ClampMagnitude(RigidBody.velocity + target, speed); #endregion return(false); } }
/// <summary> /// Moves the agent away from threshold distance - 1 from target at speed /// </summary> public bool MoveFrom(Vector2 target, float speed, float threshold) { Vector2 current = transform.position; if (target == current) { return(true); } if (Vector2.Distance(current, target) < threshold) { #region Move AiData.currentBehavior = AIData.Behave.Flee; AnimatorBody.Play("Move"); target = (current - target); target = Vector2.ClampMagnitude(target, speed); controller.Direction = DirectionMethods.FromVec2(target); if (!AiData.updateBehavior) { return(false); } RigidBody.velocity = target; #endregion return(false); } else { AnimatorBody.Play("Idle"); return(true); } }
public void TestJsonSerialize() { Direction[] allDirections = DirectionMethods.GetAllDirections(); int w = 10; int h = 15; Map map = new SimpleMapGenerator().GenerateMap(w, h, IMapGeneratorConstants.NO_SEED); IMapSerializer <string, string> jsonSerializer = new JsonMapSerializer(); string jsonString = jsonSerializer.Serialize(map); Assert.IsFalse(jsonString.Length == 0, "Empty string returned!"); Map deserialized = jsonSerializer.Deserialize(jsonString); // compare pre-serialization vs post-serialization Assert.AreEqual(map.Width, deserialized.Width, "Wrong width!"); Assert.AreEqual(map.Height, deserialized.Height, "Wrong width!"); for (int i = 0; i < map.Width; i++) { for (int j = 0; j < map.Height; j++) { MapBlock orig = map.Grid[i, j]; MapBlock deser = deserialized.Grid[i, j]; Assert.AreEqual(orig, deser, $"Blocks at [{i},{j}] have wrong coordinates!"); foreach (Direction d in allDirections) { Assert.AreEqual(orig.EntranceInDirection(d), deser.EntranceInDirection(d), $"Blocks at [{i},{j}] have different entrance in direction {d}!"); } } } }
public void RotateLeft_on_up_should_return_left() { var direction = Direction.Up; var result = DirectionMethods.RotateLeft(direction); Assert.AreEqual(Direction.Left, result); }
public void RotateLeft_on_right_should_return_up() { var direction = Direction.Right; var result = DirectionMethods.RotateLeft(direction); Assert.AreEqual(Direction.Up, result); }
private void ExecuteCommand(Tank tank, string command, FightStat fitnessStat) { switch (command) { case "Forward": CheckAndMove(tank, tank.Coord + Movements[tank.Direction]); return; case "Backward": CheckAndMove(tank, tank.Coord - Movements[tank.Direction]); return; case "TurnRight": tank.Direction = DirectionMethods.RotateRight(tank.Direction); return; case "TurnLeft": tank.Direction = DirectionMethods.RotateLeft(tank.Direction); return; case "Shoot": ShootAction(tank, fitnessStat); return; case "Finish": tank.IsAlive = false; return; default: throw new Exception("Unknown command"); } }
/// <summary> /// Decides whether to choose direction of next block or to switch backwardFlag. /// </summary> /// <return>Next direction. May be null.</return> private Direction GoForward() { Direction nextDirection = Direction.NO_DIRECTION; Direction[] allDirections = DirectionMethods.GetAllDirections(); if (pathStack.Count != stackCapacity) { // stack is not full, pick next direction // keep trying random directions until one (different from the last one) is selected or max attempt count is reached int attempt = 0; while ((nextDirection.IsNoDirection() || (pathStack.Count > 0 && nextDirection == pathStack.Peek())) && attempt < DEF_MAX_RANDOM_TRIES) { Direction randomDirection = allDirections[randomizer.Next(allDirections.Length)]; MapBlock possibleNextBlock = Position.NextOpenBlock(randomDirection); if (possibleNextBlock != null && !possibleNextBlock.Occupied) { nextDirection = randomDirection; } attempt++; } // some direction was picked -> add it to stack if (!nextDirection.IsNoDirection()) { pathStack.Push(nextDirection); } } else { // stack is full set backward flag and do nothing goBackwardFlag = true; } return(nextDirection); }
public void Flip_on_up_should_return_down() { var direction = Direction.Up; var result = DirectionMethods.Flip(direction); Assert.AreEqual(Direction.Down, result); }
public void Flip_on_right_should_return_left() { var direction = Direction.Right; var result = DirectionMethods.Flip(direction); Assert.AreEqual(Direction.Left, result); }
//Flip it around if it's too far from room center private void IdleWalkCheckBounds() { if (Vector2.Distance(transform.position, currentRoom.transform.position) > currentRoom.RoomWidth / 2) { desiredDirection = DirectionMethods.OppositeDirection(desiredDirection); rb.velocity = new Vector2(walkSpeed * (desiredDirection == Direction.Right ? 1 : -1) * 2, 0); } }
// Creates mainPathLength amount of rooms. Labels the last one created as the end room private void CreateMainPath(Dictionary <Vector2, Room> level) { Stack <Vector2> stack = new Stack <Vector2>(); stack.Push(Vector2.zero); Vector2 current; Vector2 next; string roomTemplate; int firstDirection; Direction attemptDirection; while (roomCounter <= mainPathLength) { current = stack.Peek(); next = current; // Dummy assignment - I literally have to set next to something so the code compiles. firstDirection = r.Next(4); attemptDirection = Direction.N; // necessary for compiling properly. Is literally changed immediately (we love c#) for (int i = 0; i < 4; i++) { attemptDirection = DirectionMethods.NumberToDirection((firstDirection + i) % 4); if (!IsRoomHere(level, current, attemptDirection)) { next = GetPositionInDirection(current, attemptDirection); break; } } // If next is still equal to current we know we weren't able to find a new room and must go back a room and try again if (next == current) { stack.Pop(); } else { if (roomCounter == mainPathLength) { roomTemplate = endRoomTemplate; } else { int templateIndex = r.Next(availableTemplates.Count); roomTemplate = availableTemplates[templateIndex]; availableTemplates.RemoveAt(templateIndex); if (availableTemplates.Count == 0) { availableTemplates = GetTemplates(); } } Room nextRoom = CreateRoom(roomTemplate); level.Add(next, nextRoom); stack.Push(next); AddConnection(level, current, attemptDirection); roomCounter++; } } }
// Creates branches until we have satisfied totalNumberOfRooms. Branches stop either at desiredBranchLength or until they get 'stuck' private void CreateBranches(Dictionary <Vector2, Room> level) { Vector2[] roomPool = level.Keys.ToArray <Vector2>(); Vector2 current; Vector2 next; int firstDirection; Direction attemptDirection; while (roomCounter <= totalNumberOfRooms) { // Pick a random room current = roomPool[r.Next(0, roomPool.Length)]; next = current; // Create a branch for (int i = 0; i < desiredBranchLength; i++) { firstDirection = r.Next(4); attemptDirection = Direction.N; // necessary for compiling properly. Is literally changed immediately (we love c#) for (int j = 0; j < 4; j++) { attemptDirection = DirectionMethods.NumberToDirection((firstDirection + i) % 4); if (!IsRoomHere(level, current, attemptDirection)) { next = GetPositionInDirection(current, attemptDirection); break; } } // room cannot be created - just stop the branch if (next == current) { break; } else { int templateIndex = r.Next(availableTemplates.Count); Room nextRoom = CreateRoom(availableTemplates[templateIndex]); availableTemplates.RemoveAt(templateIndex); if (availableTemplates.Count == 0) { availableTemplates = GetTemplates(); } level.Add(next, nextRoom); AddConnection(level, current, attemptDirection); current = next; roomCounter++; if (roomCounter > totalNumberOfRooms) { break; } } } } }
private void calculateNeighborsForRow(int row) { for (int col = 0; col < boardSize; col++) { Tile currentTile = tiles[row, col]; Dictionary <Direction, Tile> currentTileNeighbors = new Dictionary <Direction, Tile>(); foreach (Direction d in Enum.GetValues(typeof(Direction))) { int[] indeces = DirectionMethods.getNeighborIndex(row, col, d); currentTileNeighbors[d] = areValid(indeces) ? tiles[indeces[0], indeces[1]] : null; } currentTile.setNeighbors(currentTileNeighbors); } }
public override string Run(string command, string[] args, string argStr) { McTcpClient handler = tcpClientRetriever.GetTcpClient(); if (args.Length == 1) { string dirStr = args[0].Trim().ToLower(); Direction direction = DirectionMethods.FromString(dirStr); if (direction == Direction.None) { return("Invalid direction: " + dirStr); } player.UpdateLocation(player.GetCurrentLocation(), direction); return("Looking " + dirStr); } else if (args.Length == 2) { try { float yaw = Single.Parse(args[0]); float pitch = Single.Parse(args[1]); player.UpdateLocation(player.GetCurrentLocation(), yaw, pitch); return(String.Format("Looking at YAW: {0} PITCH: {1}", yaw.ToString("0.00"), pitch.ToString("0.00"))); } catch (FormatException) { return(CMDDesc); } } else if (args.Length == 3) { try { int x = int.Parse(args[0]); int y = int.Parse(args[1]); int z = int.Parse(args[2]); Location block = new Location(x, y, z); player.UpdateLocation(player.GetCurrentLocation(), block); return("Looking at " + block); } catch (FormatException) { return(CMDDesc); } } else { return(CMDDesc); } }
public void onPlayerMove(PlayerMoveEvent ev) { Location location = ev.getLocation(); World world = location.getWorld(); Vector3 movement = ev.getMovement(); Direction moveDirection = DirectionMethods.getDominantDirection(movement); Location ordinalMovement = moveDirection.ordinal(world) * Chunk.chunkSize; ChunkLocation playerChunkLocation = ChunkLocation.asChunkLocation(location + ordinalMovement); loadChunksInRange(playerChunkLocation); unloadChunksOutOfRange(playerChunkLocation); }
/// <summary> /// Attack an enemy unit /// </summary> /// <param name="enemyUnit">unitcontroller of enemy unit</param> public void Attack(UnitController enemyUnit) { //rotate towards enemy Direction directionToEnemy = DirectionMethods.GetOrientation(GetUnitCoords(), enemyUnit.GetUnitCoords()); RotateTowards(directionToEnemy); //trigger attack animation _animator.SetTrigger("Attack"); //deal damage to enemy enemyUnit.TakeDamage(attackDamage); //rotate back StartCoroutine(ResetRotation()); }
public void TestOpenMapGenerator() { IMapGenerator openMapGenerator = MapGeneratorFactory.CreateOpenMapGenerator(); int w = 10; int h = 15; Direction[] allDirections = DirectionMethods.GetAllDirections(); MapBlock[,] grid = openMapGenerator.GenerateGrid(w, h, 0); Assert.IsNotNull(grid, "Null grid returned!"); Assert.AreEqual(w, grid.GetLength(0), "Wrong width of map grid!"); Assert.AreEqual(h, grid.GetLength(1), "Wrong height of map grid!"); for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { foreach (Direction dir in allDirections) { Assert.IsTrue(grid[i, j].EntranceInDirection(dir).IsOpen(), $"Entrance in direction {dir} of block [{i},{j}] should be open!"); } } } Map map = openMapGenerator.GenerateMap(w, h, 0); Assert.IsNotNull(map, "Null map returned!"); Assert.AreEqual(w, map.Width, "Wrong map width!"); Assert.AreEqual(h, map.Height, "Wrong map height!"); MapBlock[,] grid2 = map.Grid; Assert.AreEqual(grid.GetLength(0), grid.GetLength(0), "Widths of grids don't match!"); Assert.AreEqual(grid.GetLength(1), grid.GetLength(1), "Widths of grids don't match!"); Assert.IsNotNull(map.WinningBlock, "Winning block is null!"); Assert.AreEqual((w - 1) / 2, map.WinningBlock.X, "Wrong X coordinate of winning block."); Assert.AreEqual((h - 1) / 2, map.WinningBlock.Y, "Wrong Y coordinate of winning block."); for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { foreach (Direction dir in allDirections) { Assert.IsTrue(grid2[i, j].EntranceInDirection(dir).IsOpen(), $"Entrance in direction {dir} of block [{i},{j}] should be open!"); } } } }
void Update() { Direction direction = Direction.None; if (Input.GetKeyDown("q")) { direction = Direction.NW; } if (Input.GetKeyDown("w")) { direction = Direction.N; } if (Input.GetKeyDown("e")) { direction = Direction.NE; } if (Input.GetKeyDown("a")) { direction = Direction.W; } if (Input.GetKeyDown("d")) { direction = Direction.E; } if (Input.GetKeyDown("z")) { direction = Direction.SW; } if (Input.GetKeyDown("x")) { direction = Direction.S; } if (Input.GetKeyDown("c")) { direction = Direction.SE; } if(direction != Direction.None) { Vector3 nextPos = transform.position + DirectionMethods.GetVector3(direction); Vector2Int nextPosXY = new Vector2Int(Mathf.RoundToInt(nextPos.x), Mathf.RoundToInt(nextPos.z)); // shit but eh who cares if (world.IsWalkable(nextPosXY.x, nextPosXY.y)) { transform.Translate(DirectionMethods.GetVector3(direction)); } } }
/// <summary> /// Find the friendly unit nearest to a given enemy unit /// </summary> /// <param name="enemyUnitController">unitcontroller of enemy unit</param> /// <returns>unitcontroller of nearest friendly unit</returns> private UnitController FindNearestFriendlyUnit(UnitController enemyUnitController) { //loop over each friendly unit and check for the shortest distance int shortestDistance = Int32.MaxValue; //distance to unit with shortest distance UnitController shortestDistanceUnitController = null; //unitcontroller of unit with shortest distance foreach (var friendlyUnitController in playerArmy) { Coords friendlyUnitCoords = friendlyUnitController.GetUnitCoords(); if (enemyUnitController.CanAttack(friendlyUnitCoords)) { //if enemy unit can attack friendly, return the attackable unit return(friendlyUnitController); } foreach (var direction in DirectionMethods.GetClockwise()) { BFS bfs = new BFS(); Coords coordsToCheck = friendlyUnitCoords.Get(direction); //coords right next to unit in direction //check if enemy unit has path to friendly unit if (enemyUnitController.HasPath(coordsToCheck, ref bfs)) { //get length of solution and check if shorter than the previous shortest distance int solutionLength = bfs.GetSolutionLength(); if (solutionLength < shortestDistance) { shortestDistance = solutionLength; shortestDistanceUnitController = friendlyUnitController; } } } } if (shortestDistanceUnitController == null) { //there is no path to any friendly unit //just select the first enemy shortestDistanceUnitController = playerArmy[0]; } return(shortestDistanceUnitController); }
public override string Run(string command, string[] args, string argStr) { McTcpClient handler = tcpClientRetriever.GetTcpClient(); if (args.Length == 1) { if (argStr == "get") { return(handler.player.GetCurrentLocation().ToString()); } Direction direction = DirectionMethods.FromString(argStr); if (Movement.CanMove(handler.GetWorld(), handler.player.GetCurrentLocation(), direction)) { //handler.player.MoveTo(Movement.Move(handler.player.GetCurrentLocation(), direction)); return("Moving " + argStr + '.'); } else { return("Cannot move in that direction."); } } else if (args.Length == 3) { try { int x = int.Parse(args[0]); int y = int.Parse(args[1]); int z = int.Parse(args[2]); Location goal = new Location(x, y, z); //if (handler.player.MoveTo(goal)) //return "Walking to " + goal; return("Failed to compute path to " + goal); } catch (FormatException) { return(CMDDesc); } } else { return(CMDDesc); } }
public void TestSimpleMapGeneratorSeed() { IMapGenerator simpleMapGenerator = MapGeneratorFactory.CreateSimpleMapGenerator(); int w = 5; int h = 10; int seed = 87452; Direction[] allDirections = DirectionMethods.GetAllDirections(); MapBlock[,] grid = simpleMapGenerator.GenerateGrid(w, h, seed); MapBlock[,] grid2 = simpleMapGenerator.GenerateGrid(w, h, seed); Assert.IsNotNull(grid, "Grid 1 is null!"); Assert.IsNotNull(grid2, "Grid 2 is null!"); Assert.AreEqual(w, grid.GetLength(0), "Wrong width of map grid!"); Assert.AreEqual(h, grid.GetLength(1), "Wrong height of map grid!"); Assert.AreEqual(w, grid2.GetLength(0), "Wrong width of map grid 2!"); Assert.AreEqual(h, grid2.GetLength(1), "Wrong height of map grid 2!"); // all map block should be same for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { int entrances = 0; foreach (Direction dir in allDirections) { Assert.AreEqual(grid[i, j].EntranceInDirection(dir).Exists(), grid2[i, j].EntranceInDirection(dir).Exists(), $"Map block at position [{i},{j}] has different entrance in direction {dir}."); if (grid[i, j].EntranceInDirection(dir).Exists()) { entrances++; } } Assert.IsTrue(entrances > 0, $"Block at [{i},{j}] has no entrance!"); } } }
public void TestSimpleMapGenerator() { IMapGenerator simpleMapGenerator = MapGeneratorFactory.CreateSimpleMapGenerator(); int w = 5; int h = 10; Direction[] allDirections = DirectionMethods.GetAllDirections(); Map map = simpleMapGenerator.GenerateMap(w, h, IMapGeneratorConstants.NO_SEED); MapBlock[,] grid = map.Grid; Assert.IsNotNull(grid, "Null grid returned!"); Assert.AreEqual(w, grid.GetLength(0), "Wrong width of map grid!"); Assert.AreEqual(h, grid.GetLength(1), "Wrong height of map grid!"); Assert.IsNotNull(map.WinningBlock, "Winning block is null!"); Assert.AreEqual((w - 1) / 2, map.WinningBlock.X, "Wrong X coordinate of winning block."); Assert.AreEqual((h - 1) / 2, map.WinningBlock.Y, "Wrong Y coordinate of winning block."); // test that no map block has all entrances closed for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { int entrances = 0; foreach (Direction dir in allDirections) { if (grid[i, j].EntranceInDirection(dir).Exists()) { entrances++; } } Assert.IsTrue(entrances > 0, $"Block at [{i},{j}] has no entrance!"); } } }
public MapBlock[,] GenerateGrid(int width, int height, int seed) { // start with open maze MapBlock[,] grid = new MapBlock[width, height]; // array to hold information about cells which were already visited by algorithm bool[,] visitedGrid = new bool[width, height]; Direction[] allDirections = DirectionMethods.GetAllDirections(); for (int i = 0; i < width; i++) { for (int j = 0; j < height; j++) { visitedGrid[i, j] = false; grid[i, j] = new MapBlock(i, j); } } // go through maze and demolish walls to create paths Stack <MapBlock> stack = new Stack <MapBlock>(); Random r; if (seed == IMapGeneratorConstants.NO_SEED) { r = new Random(); } else { r = new Random(seed); } MapBlock start = grid[r.Next(width), r.Next(height)]; stack.Push(start); while (stack.Count > 0) { MapBlock current = stack.Peek(); // select neighbours of current block which were not visited yet List <MapBlock> notVisited = new List <MapBlock>(); if (current.Y > 0 && !visitedGrid[current.X, current.Y - 1]) { notVisited.Add(grid[current.X, current.Y - 1]); } if (current.Y < height - 1 && !visitedGrid[current.X, current.Y + 1]) { notVisited.Add(grid[current.X, current.Y + 1]); } if (current.X > 0 && !visitedGrid[current.X - 1, current.Y]) { notVisited.Add(grid[current.X - 1, current.Y]); } if (current.X < width - 1 && !visitedGrid[current.X + 1, current.Y]) { notVisited.Add(grid[current.X + 1, current.Y]); } // there are some neighbours which were not visited // choose one a create entrance between current block and neighbour block if (notVisited.Count > 0) { int neighbourIndex = r.Next(notVisited.Count); MapBlock neighbour = notVisited[neighbourIndex]; notVisited.RemoveAt(neighbourIndex); DemolishWalls(current, neighbour); // add neighbour to the stack so the path creation will continue this way stack.Push(neighbour); // mark current cell and neighbour as visited visitedGrid[current.X, current.Y] = true; visitedGrid[neighbour.X, neighbour.Y] = true; } else { // every neighbour was visited, pop current block and continue with next block in the stack stack.Pop(); } } return(grid); }
public TraversableNode getNeighbour(Direction direction) { return(movableNodes[DirectionMethods.directionToArrayIndex(direction)]); }
//Insert a Traversable node in the direction slot this node can get to it by moving public void insertAt(Direction direction, TraversableNode node) { movableNodes[DirectionMethods.directionToArrayIndex(direction)] = node; }
public void TestSerializeMaze() { int w = 4; int h = 4; Map map = MapGeneratorFactory.CreateSimpleMapGenerator().GenerateMap(w, h, IMapGeneratorConstants.NO_SEED); map.MapName = "Test map"; // add creatures to map Monster origMonster = new Monster("Test monster", map.Grid[0, 0], 4, 3654123, 87621235); map.AddCreature(origMonster); SimpleAIPlayer aiPlayer = new SimpleAIPlayer("Test player", map.Grid[3, 2]); map.AddCreature(aiPlayer); HumanPlayer hPlayer = new HumanPlayer("Příliš žluťoučký kůň úpěl ďábelské ódy", map.Grid[1, 3]) { BaseHitPoints = 98432156, BaseAttack = 112348, BaseDeffense = 41226987 }; map.AddCreature(hPlayer); // add items to map AbstractWeapon weapon = ItemFactory.CreateAxe(map.Grid[1, 3]); map.AddItem(weapon); AbstractArmor armor = ItemFactory.CreateLeatherArmor(map.Grid[1, 1]); map.AddItem(armor); AbstractInventoryItem item = new BasicItem("Příliš žluťoučký kůň úpěl ďábelské ódy.!?_/()':123456789<>&@{}[]", map.Grid[2, 2], 514) { UniqueId = 6284 }; map.AddItem(item); // serialize - deserialize IMapSerializer <byte[], byte[]> byteSerializer = new BinaryMapSerializer(); byte[] serializedMap = byteSerializer.Serialize(map); Map deserializedMap = byteSerializer.Deserialize(serializedMap); // check map Assert.AreEqual(map.MapName, deserializedMap.MapName, "Wrong map name!"); Assert.AreEqual(w, deserializedMap.Width, "Wrong width after deserialization!"); Assert.AreEqual(h, deserializedMap.Width, "Wrong height after deserialization!"); Assert.AreEqual(map.WinningBlock.X, deserializedMap.WinningBlock.X, "Wrong x coordinate of winning block!"); Assert.AreEqual(map.WinningBlock.Y, deserializedMap.WinningBlock.Y, "Wrong Y coordinate of winning block!"); // check map blocks for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { MapBlock origBlock = map.Grid[i, j]; MapBlock testedBlock = deserializedMap.Grid[i, j]; foreach (Direction dir in DirectionMethods.GetAllDirections()) { Assert.AreEqual(origBlock.EntranceInDirection(dir).IsOpen(), testedBlock.EntranceInDirection(dir).IsOpen(), $"Wrong entrance in direction {dir} in block [{i},{j}]."); } } } // check creatures Monster m = (Monster)deserializedMap.Grid[0, 0].Creature; CheckCreature(origMonster, m); SimpleAIPlayer p = (SimpleAIPlayer)deserializedMap.Grid[3, 2].Creature; CheckCreature(aiPlayer, p); HumanPlayer hp = (HumanPlayer)deserializedMap.Grid[1, 3].Creature; CheckCreature(hPlayer, hp); // check items AbstractWeapon weap = (AbstractWeapon)map.Grid[1, 3].Item; CheckItem(weap, weapon); AbstractArmor arm = (AbstractArmor)map.Grid[1, 1].Item; CheckItem(arm, armor); AbstractInventoryItem itm = (AbstractInventoryItem)map.Grid[2, 2].Item; CheckItem(item, itm); }
public override void Think() { // TODO: algorithm is not optimal because when returning from child to parent, child nodes will be listed again (not so big problem, but it something to improve) // timing double currentTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond; double mspa = 1000 / aiSpeed; if (!IgnoreSpeed) { if ((currentTime - lastActionTime) < mspa) { return; } } Map.Map map = Position.ParentMap; // if the stack is empty AI may be in dead end // put its current position to the stack and run the DFS again if (blockStack.Count == 0) { blockStack.Push(new VisitedBlock(Position)); } // get current node and his neighbours VisitedBlock currVisitedBlock = blockStack.Peek(); currVisitedBlock.state = BlockState.OPEN; visitedBlocks.Add(currVisitedBlock); MapBlock curr = map.Grid[currVisitedBlock.x, currVisitedBlock.y]; List <MapBlock> neighbours = curr.AccessibleNeighbours(); // choose the next neighbour to go to // those neighbours must not be in CLOSED state and should not contain monster MapBlock nextBlock = null; foreach (MapBlock neighbour in neighbours) { // check if the neighbour wasn't already visited and is not occupied // visited block hash code is calculated only by its coordinates so this can be used VisitedBlock neighbourVb = new VisitedBlock(neighbour); if (!visitedBlocks.Contains(neighbourVb) && !neighbour.Occupied) { // get the last not-visited, unoccupied neighbour // add it to the stack later nextBlock = neighbour; } } // if some neighbours were found, create move action to the last block on the stack if (nextBlock != null) { blockStack.Push(new VisitedBlock(nextBlock)); Direction nextDirection = DirectionMethods.GetDirection(Position, nextBlock); NextAction = new Move() { Actor = this, Direction = nextDirection }; } else { // no possible neighbours were found // this opens up two possibilities // 1. assume current block is a dead end // 2. check if there are monster to fight in neighbour blocks and try to fight them // for now lets just pick the first one // mark current block as closed and pop it from the stack currVisitedBlock.state = BlockState.CLOSED; blockStack.Pop(); // move one step back if (blockStack.Count > 0) { VisitedBlock prevBlock = blockStack.Peek(); nextBlock = map.Grid[prevBlock.x, prevBlock.y]; NextAction = new Move() { Actor = this, Direction = DirectionMethods.GetDirection(Position, nextBlock) }; } } lastActionTime = currentTime; }
public static Tile[] GenerateRoom(RoomTemplate roomTemplate, bool[] doors, bool hasTreasure, bool hasPOI) { // Extract dimension data from json object var dimensions = roomTemplate.dimensions; var width = dimensions.width; var height = dimensions.height; var tiles = new Tile[width * height]; // Initialize the tiles for (uint z = 0, i = 0; z < height; ++z) { for (uint x = 0; x < width; ++x) { tiles[i] = new Tile(i); tiles[i].Type = TileType.Floor; ++i; } } // Fill Walls foreach (var wall in roomTemplate.walls) { tiles[wall.index].IsWall = true; } // Fill Doors foreach (var door in roomTemplate.doors) { Direction direction = (Direction)System.Enum.Parse(typeof(Direction), door.direction); if (doors[DirectionMethods.DirectionToNumber(direction)]) { tiles[door.index].IsDoor = true; tiles[door.index].DoorDirection = direction; } else { tiles[door.index].IsWall = true; } //tiles[door.index].IsDoor = true; } // Fill nones foreach (var none in roomTemplate.nones) { tiles[none.index].IsNone = true; } // Fill all enemy nests foreach (var nest in roomTemplate.enemyNests) { tiles[nest.index].IsEnemyNest = true; } // Fill treasures bool treasureAssigned = false; foreach (var treasure in roomTemplate.treasures) { if (hasTreasure) { if (!treasureAssigned) { tiles[treasure.index].IsTreasure = true; treasureAssigned = true; } } } // fill pois foreach (var poi in roomTemplate.pois) { if (hasPOI) { tiles[poi.index].IsPOI = true; } //tiles[poi.index].POIType = (POIType)assignedPOI; } // Fill lavas if (roomTemplate.lavas != null) { foreach (var lava in roomTemplate.lavas) { tiles[lava.index].Type = TileType.Lava; } } // Fill portal, if it exists if (roomTemplate.portal != null) { tiles[roomTemplate.portal.index].Type = TileType.Portal; } return(tiles); }
public void CreateConnection(Direction direction) { Neighbors[DirectionMethods.DirectionToNumber(direction)] = true; }