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;
}
}
}
