public DungeonRoom AddRandomRoom(int id) { if (Rooms.Count == 0) { return(AddStartingRoom()); } DungeonRoom parentRoom = GetRandomParentRoom(); var dir = DirectionUtility.GetRandom(); // Get a coordinate that isn't taken up by an existing room DungeonRoom roomInDirection; do { dir = dir.GetClockwise(); roomInDirection = GetRoomInDirection(parentRoom, dir); } while (roomInDirection != null); // Create new room, connect newRoom to parentRoom var coord = parentRoom.Coordinate + dir.ToVector(); var width = Rand.NextGaussian(RoomWidthMean, RoomWidthStd); var height = Rand.NextGaussian(RoomHeightMean, RoomHeightStd); var newRoom = new DungeonRoom(id, Level, coord, width, height); parentRoom.AddConnection(dir, id); newRoom.AddConnection(dir.GetOpposite(), parentRoom.Id); Rooms.Add(newRoom); return(newRoom); }
private void moveKinematic() { if (Input.GetMouseButtonDown(0)) { destination = DirectionUtility.getMouseDirection(); destination.y = transform.position.y; go = true; calculating = true; inizializeTree(destination); draw.clean(); } else { if (go && path.Count > 0) { destination = (Vector3)path[path_index]; float d = Vector3.Distance(transform.position, destination); if (d > 0.5) { Vector3 direction = (destination - transform.position).normalized; DirectionUtility.makeKinematicMove(rigidbody, direction, speed); } else { rigidbody.velocity = Vector3.zero; transform.position = destination; path_index++; if (path_index == path.Count) { go = false; path_index = 0; } } } } }
public void AddRandomConnection() { bool connectionMade = false; do { var room = GetRandomRoom(); var dir = DirectionUtility.GetRandom(); for (int i = 0; i < 4; i++) { var secondRoom = GetRoomInDirection(room, dir); if (secondRoom != null && !room.Connections.ContainsKey(dir)) { room.AddConnection(dir, secondRoom.Id); secondRoom.AddConnection(dir.GetOpposite(), room.Id); connectionMade = true; } else { dir = dir.GetClockwise(); } } } while(!connectionMade); }
public void UpdateAction() { if (_actionCount == 0) { _agentStatus = AgentStateUtility.RandomFrom(ValidAgentStates); switch (_agentStatus) { case AgentState.Moving: _actionCount = 4; break; case AgentState.Halted: case AgentState.Knocked: case AgentState.Ready: _actionCount = 1; break; } } _actionCount--; if (_agentStatus == AgentState.Moving) { _currentDirection = IsWithinCircularBounds(_playerLocation, Location, 192) ? DirectionUtility.GetDirectionTowardsPoint(Location, _playerLocation) : DirectionUtility.RandomDirection(); } _agentClock = ActionDelay; }
public void Transition(Direction roomDirection, bool unlock) { var newRoom = CurrentRoom; switch (roomDirection) { case Direction.Up: newRoom.Y--; break; case Direction.Down: newRoom.Y++; break; case Direction.Left: newRoom.X--; break; case Direction.Right: newRoom.X++; break; default: throw new ArgumentOutOfRangeException(); } if (unlock) { _rooms[newRoom.Y][newRoom.X].Doors[DirectionUtility.Flip(roomDirection)]?.Unblock(); } Scene?.DestroyProjectiles(); Pan(CurrentRoom, newRoom, roomDirection); }
/// <summary> /// Get the green ray direction according to a prism. /// </summary> /// <param name="direction"></param> /// <returns></returns> private Direction GetGreenRayDirection(Direction direction) { var greenRayDirection = DirectionUtility.GetDirectionAsVector3(direction); greenRayDirection = Quaternion.AngleAxis(-90, Vector3.up) * greenRayDirection; return(DirectionUtility.ToDirection(greenRayDirection)); }
/// <summary> /// Get the blue ray direction according to a prism. /// </summary> /// <param name="direction"></param> /// <returns></returns> private Direction GetBlueRayDirection(Direction direction) { var blueRayDirection = DirectionUtility.GetDirectionAsVector3(direction); blueRayDirection = Quaternion.AngleAxis(90, Vector3.up) * blueRayDirection; return(DirectionUtility.ToDirection(blueRayDirection)); }
public void DisableAllConnections() { foreach (var dir in DirectionUtility.GetDirections()) { SetConnectionEnable(dir, false); } }
public void UpdateAction() { _agentStatus = AgentStateUtility.RandomFrom(ValidAgentStates); switch (_agentStatus) { case AgentState.Moving: UpdateDirection(DirectionUtility.RandomDirection()); _agentClock = ActionDelay; break; case AgentState.Halted: _agentClock = 2 * ActionDelay; break; case AgentState.Attacking: UseAttack(); _agentClock = BoomerangDuration; break; case AgentState.Ready: break; case AgentState.Knocked: break; default: _agentClock = ActionDelay; break; } }
/// <summary> /// Get the red ray direction according to a prism. /// </summary> /// <param name="direction"></param> /// <returns></returns> private Direction GetRedRayDirection(Direction direction) { var redRayDirection = DirectionUtility.GetDirectionAsVector3(direction); redRayDirection = Quaternion.AngleAxis(0, Vector3.up) * redRayDirection; return(DirectionUtility.ToDirection(redRayDirection)); }
public override void Halt() { _agentStatus = AgentState.Halted; _agentClock = ActionDelay; _statusDirection = DirectionUtility.Flip(_statusDirection); Move(_statusDirection, 2); }
//Specialized FindDirections for specialRooms. Because it's a specialroom, its algorithm is simpler public static bool[] FindDirections(int x, int y, Room[,] floorLayout, bool[] constraints) { bool[] exits = new bool[4]; bool noExit = true; List <int> goingDirections = new List <int> { 0, 1, 2, 3 }; for (int i = 0; i < 4; i++) { if (constraints[i] == false) { goingDirections.Remove(i); } } do { foreach (int i in goingDirections) { int _x = x + DirectionUtility.getX(i); int _y = y + DirectionUtility.getY(i); //Make sure we're inside the bounds of the loop and not overlapping with an already existing room if (_x < floorLayout.GetLength(0) && _x >= 0 && _y < floorLayout.GetLength(1) && _y >= 0) { if (floorLayout[_x, _y] == null) { //Randomize whether this exit will be used if (Random.Range(0, 100) < ROOM_CHANCE) { exits[i] = true; noExit = false; } } else { //If the room seen is opening into this room, it's OK! if (floorLayout[_x, _y].CheckExit(DirectionUtility.opposite(i))) { exits[i] = true; noExit = false; } else { //Otherwise, yeah, remove it goingDirections.Remove(i); break; } } } else { //Remove directions that are blocked off by other walls goingDirections.Remove(i); break; } } } while(noExit && goingDirections.Count > 0); return(exits); }
public void UpdateAction() { _agentStatus = AgentStateUtility.RandomFrom(ValidAgentStates); if (_agentStatus == AgentState.Moving) { _currentDirection = DirectionUtility.RandomDirection(); } _agentClock = ActionDelay; }
public override bool AddExit(Direction dir, Room[,] floorLayout) { if (exits[DirectionUtility.getIndex(dir)] == true) { DisableWall(dir); return(true); } return(false); }
public virtual bool AddExit(Direction dir, Room[,] floorLayout) { if (exits[DirectionUtility.getIndex(dir)] == false) { exits[DirectionUtility.getIndex(dir)] = true; RoomManager.instance.ReplaceRoom(this, exits, floorLayout); } Debug.Log("Replacing Room " + x + " and " + y); return(true); }
public void ReopenRoom() { for (int i = 0; i < 4; i++) { if (storedExits[i]) { DisableWall(DirectionUtility.getDirection(i)); } } }
public void CloseRoom() { for (int i = 0; i < 4; i++) { if (storedExits[i]) { EnableWall(DirectionUtility.getDirection(i)); } } }
public void UpdateAction() { _agentStatus = AgentStateUtility.RandomFrom(ValidAgentStates); if (_agentStatus == AgentState.Moving) { _currentDirection = Rng.Next(2) == 0 ? DirectionUtility.GetDirectionTowardsPoint(Location, _playerLocation) : DirectionUtility.RandomDirection(); } _agentClock = ActionDelay; }
public void DirectionUtilityReturnsValidDirectionFromVector3Passes() { Assert.AreEqual(Direction.East, DirectionUtility.ToDirection(new Vector3(1, 0, 0))); Assert.AreEqual(Direction.NorthEast, DirectionUtility.ToDirection(new Vector3(1, 1, 0))); Assert.AreEqual(Direction.North, DirectionUtility.ToDirection(new Vector3(0, 1, 0))); Assert.AreEqual(Direction.NorthWest, DirectionUtility.ToDirection(new Vector3(-1, 1, 0))); Assert.AreEqual(Direction.West, DirectionUtility.ToDirection(new Vector3(-1, 0, 0))); Assert.AreEqual(Direction.SouthWest, DirectionUtility.ToDirection(new Vector3(-1, -1, 0))); Assert.AreEqual(Direction.South, DirectionUtility.ToDirection(new Vector3(0, -1, 0))); Assert.AreEqual(Direction.SouthEast, DirectionUtility.ToDirection(new Vector3(1, -1, 0))); }
public void ExecuteAction() { if (_agentClock > 0) { _agentClock--; } switch (_agentStatus) { case AgentState.Ready: //determine next action UpdateAction(); break; case AgentState.Stunned: case AgentState.Halted: if (_agentClock == 0) { _agentStatus = AgentState.Ready; } break; case AgentState.Knocked: if (_agentClock == 0) { Speed = 1; _agentStatus = AgentState.Ready; } else { Move(DirectionUtility.Flip(_currentDirection)); } break; case AgentState.Moving: if (_agentClock != 0) { Move(_currentDirection); } else { _agentStatus = AgentState.Ready; } break; case AgentState.Attacking: break; default: throw new NotImplementedException(); } }
public void DirectionUtilityReturnsValidDirectionAsVector3Passes() { Assert.AreEqual(new Vector3(1, 0, 0), DirectionUtility.GetDirectionAsVector3(Direction.East)); Assert.AreEqual(new Vector3(1, 1, 0), DirectionUtility.GetDirectionAsVector3(Direction.NorthEast)); Assert.AreEqual(new Vector3(0, 1, 0), DirectionUtility.GetDirectionAsVector3(Direction.North)); Assert.AreEqual(new Vector3(-1, 1, 0), DirectionUtility.GetDirectionAsVector3(Direction.NorthWest)); Assert.AreEqual(new Vector3(-1, 0, 0), DirectionUtility.GetDirectionAsVector3(Direction.West)); Assert.AreEqual(new Vector3(-1, -1, 0), DirectionUtility.GetDirectionAsVector3(Direction.SouthWest)); Assert.AreEqual(new Vector3(0, -1, 0), DirectionUtility.GetDirectionAsVector3(Direction.South)); Assert.AreEqual(new Vector3(1, -1, 0), DirectionUtility.GetDirectionAsVector3(Direction.SouthEast)); }
public void DirectionUtilityThrowsExceptionIfInvalidVector3Supplied() { Assert.Throws <ArgumentException>(() => DirectionUtility.ToDirection(new Vector3(0, 0, 0))); Assert.Throws <ArgumentException>(() => DirectionUtility.ToDirection(new Vector3(2, 0, 0))); Assert.Throws <ArgumentException>(() => DirectionUtility.ToDirection(new Vector3(0, 2, 0))); Assert.Throws <ArgumentException>(() => DirectionUtility.ToDirection(new Vector3(-2, 0, 0))); Assert.Throws <ArgumentException>(() => DirectionUtility.ToDirection(new Vector3(0, -2, 0))); Assert.Throws <ArgumentException>(() => DirectionUtility.ToDirection(new Vector3(2, 2, 0))); Assert.Throws <ArgumentException>(() => DirectionUtility.ToDirection(new Vector3(-2, -2, 0))); Assert.Throws <ArgumentException>(() => DirectionUtility.ToDirection(new Vector3(2, -2, 0))); Assert.Throws <ArgumentException>(() => DirectionUtility.ToDirection(new Vector3(-2, 2, 0))); }
static public bool freePath(ArrayList list) { bool free = true; for (int i = 0; i < list.Count - 1 && free; i++) { if (!DirectionUtility.freePath((Vector3)list[i], (Vector3)list[i + 1])) { free = false; } } return(free); }
public virtual void BuildTowards(Room target, Room _source, Room[,] floorLayout) { List <int> goingDirections = new List <int> { 0, 1, 2, 3 }; foreach (int i in goingDirections) { int _x = x + DirectionUtility.getX(i); int _y = y + DirectionUtility.getY(i); int dist = Mathf.Abs(x - target.x) + Mathf.Abs(y - target.y); int directDist = Mathf.Abs(_x - target.x) + Mathf.Abs(_y - target.y); if (directDist < dist && _x < floorLayout.GetLength(0) && _x >= 0 && _y < floorLayout.GetLength(1) && _y >= 0) { //Build Towards that direction if (floorLayout[_x, _y] == null) { Debug.Log("Tunneling " + x + ", " + y + " into " + _x + ", " + _y); //If there is no room here, Tunnel! RoomManager.instance.Tunnel(_x, _y, floorLayout, DirectionUtility.opposite(i), _source); bool status = AddExit(DirectionUtility.getDirection(i), floorLayout); if (status == true) { return; } } else if (TestExit(i) == true) { Debug.Log("Building towards " + _x + ", " + _y); floorLayout[_x, _y].BuildTowards(target, _source, floorLayout); return; } else { //If there is a room there, connect them! if (floorLayout[_x, _y].getBaseRoom() != _source) { floorLayout[_x, _y].Connect(_source); } RoomManager.instance.FuseRooms(this, floorLayout[_x, _y], floorLayout); return; } //End return; } } //If we've made it here, no direction is closer to the target, which means THIS IS THE TARGET! _source.Connect(target); }
private void Move() { if (_movementTimer > 0) { _movementTimer--; for (var scale = 2; scale > 0; scale--) { Move(_direction); } } else { Move(DirectionUtility.Flip(_direction)); _restored = Location.Equals(_origin); } }
private void moveKinematic() { if (Input.GetMouseButtonDown(0)) { destination = DirectionUtility.getMouseDirection(); destination.y = transform.position.y; go = true; draw.clean(); path_index = 2; calculating = true; inizializeTree(transform.position, destination); } else { if (go && path.Count > 0) { Vector3 dest = (Vector3)path[path_index]; //Debug.Log(path.Count+" "+path_index+" "+path[path_index]); //makeMove(dest); float d = Vector3.Distance(transform.position, dest); if (d > 1f) { Vector3 direction = (dest - transform.position).normalized; //correctAngle(direction); //DirectionUtility.makeKinematicMove (rigidbody, direction, speed); DirectionUtility.makeCarMove(rigidbody, transform, direction, speed); } else { rigidbody.velocity = Vector3.zero; //transform.position = dest; //Debug.Log(path.Count+" "+path_index); path_index++; if (path_index == path.Count) { go = false; } } } } }
public void UpdatePlayerPosition(Direction d) { //Get the current player position var playerPos = m_player.Position; var newPos = DirectionUtility.GetPoint(d, playerPos); Debug.Log(newPos); if (this.m_map.GetTileData(newPos.X, newPos.Y) == TileType.Floor || this.m_map.GetTileData(newPos.X, newPos.Y) == TileType.Stone) { this.m_map.UpdateEntity(this.m_player, newPos.X, newPos.Y); this.m_map.UpdateLighting(playerPos, newPos, m_player.LineOfSight); this.m_entityMap.UpdateEntity(this.m_player, newPos.X, newPos.Y); //TODO This call should just take an IEnumerable to set the lighting this.m_lightingMap.UpdateLighting(Lighting.NotVisible, this.m_map.GetNeighboringPoints(playerPos, this.m_player.LineOfSight)); this.m_lightingMap.UpdateLighting(Lighting.Visible, this.m_map.GetNeighboringPoints(newPos, this.m_player.LineOfSight)); this.m_player.Position = newPos; Camera.main.transform.position = new Vector3(newPos.X * TileSize, 10, (SizeY - newPos.Y) * -TileSize); } }
private void Update() { Vector2 movementVector = rb.velocity.normalized; moving = !movementVector.Equals(Vector2.zero); if (moving && calculateDirection) //First check if movement is even happening { direction = DirectionUtility.VectorToDirection(movementVector); } if (direction == Direction.Left) { transform.localScale = new Vector3(-1, 1, 1); } else { transform.localScale = new Vector3(1, 1, 1); } }
private void UpdateAction() { const int attackScalar = 4; _agentStatus = AgentStateUtility.RandomFrom(ValidAgentStates); _agentClock = ActionDelay; // ReSharper disable once SwitchStatementMissingSomeCases switch (_agentStatus) { case AgentState.Moving: _currentDirection = DirectionUtility.RandomVerticalDirection(); break; case AgentState.Attacking: _agentClock *= attackScalar; _sprite = EnemySpriteFactory.Instance.CreateAquamentusFiring(); break; } }
public void FuseRooms(Room roomA, Room roomB, Room[,] floorLayout) { Debug.Log("Fusing " + roomA.x + ", " + roomA.y + " and " + roomB.x + ", " + roomB.y); List <int> goingDirections = new List <int> { 0, 1, 2, 3 }; foreach (int i in goingDirections) { if (roomA.x + DirectionUtility.getX(i) == roomB.x && roomA.y + DirectionUtility.getY(i) == roomB.y) { bool[] roomAexits = roomA.getExits(); roomAexits[i] = true; bool[] roomBexits = roomB.getExits(); roomBexits[DirectionUtility.getIndex(DirectionUtility.opposite(i))] = true; ReplaceRoom(roomA, roomAexits, floorLayout); ReplaceRoom(roomB, roomBexits, floorLayout); return; } } }