// Navigates in the current room only
public bool WalkTo(Vector2 destination)
{
// Find and draw the navigational path
if (wayPoints == null)
{
wayPoints = FindPathToLocation(destination);
if (wayPoints.Count != 0)
{
WayPoint point = wayPoints.First();
foreach (WayPoint w in wayPoints)
{
Debug.DrawLine(point.position, w.position, Color.red, 10.0f);
point = w;
}
transform.position = wayPoints.First().position;
}
return(false);
}
if (wayPoints.Count == 0)
{
wayPoints = null;
return(true);
}
// Direction in terms of the direction walked
Vector2 direction = wayPoints.First().position - (Vector2)transform.position;
PixelCollider pixelCollider = transform.GetComponentInChildren <PixelCollider>();
Debug.Assert(pixelCollider != null);
PixelRoom pixelRoom = pixelCollider.GetPixelRoom();
int stepSize = pixelRoom.stepSize;
if (direction.sqrMagnitude < 2.5f)
{
wayPointVelocity = Vector2.zero;
wayPoints.RemoveAt(0);
return(false);
}
if (direction.x > 0 && direction.y > 0)
{
wayPointVelocity = new Vector2(2, 1);
}
else if (direction.x < 0 && direction.y > 0)
{
wayPointVelocity = new Vector2(-2, 1);
}
else if (direction.x > 0 && direction.y < 0)
{
wayPointVelocity = new Vector2(2, -1);
}
else if (direction.x < 0 && direction.y < 0)
{
wayPointVelocity = new Vector2(-2, -1);
}
return(false);
}
// Walking in a room
public void WalkInRoom(PixelRoom room, Vector2 walkFromPosition, Vector2 walkToPosition = default(Vector2))
{
if (walkToPosition == default(Vector2))
{
walkToPosition = room.center;
}
PixelCollider pixelCollider = GetComponentInChildren <PixelCollider>();
if (room != pixelCollider.GetPixelRoom())
{
room.gameObject.SetActive(true);
}
HashSet <WayPoint> navigationMesh = room.GetNavigationalMesh(pixelCollider, walkFromPosition);
WayPoint closest = navigationMesh.Aggregate((i1, i2) => Vector2.Distance(i1.position, walkToPosition) < Vector2.Distance(i2.position, walkToPosition) ? i1 : i2);
if (room != pixelCollider.GetPixelRoom())
{
room.gameObject.SetActive(false);
}
Debug.DrawLine(transform.position, closest.position, Color.magenta, 10.0f);
CharacterTask characterTask = new CharacterTask(GameTask.TaskType.WALKTO, closest.position);
characterTasks.Enqueue(characterTask);
}
private void OnEnable()
{
StartCoroutine("UpdateCharacterAction");
PixelRoom room = transform.parent.GetComponent <PixelRoom>();
InvokeRepeating("Movement", 0.0f, 1.0f / room.RoomWalkingSpeed);
}
public IEnumerator PlayerMovementAll()
{
SceneManager.LoadScene("Game");
yield return(null);
GameObject[] rootObjects = SceneManager.GetActiveScene().GetRootGameObjects();
List <PixelRoom> allRooms = new List <PixelRoom>();
foreach (GameObject go in rootObjects)
{
PixelRoom room = go.GetComponent <PixelRoom>();
if (room != null)
{
allRooms.Add(room);
}
}
// Reorganize list
System.Random rand = new System.Random();
List <PixelRoom> randomizedRooms = allRooms.OrderBy(c => rand.Next()).Select(c => c).ToList();
foreach (PixelRoom room in randomizedRooms)
{
string name = room.name;
GameObject.Find("Game Manager").SendMessage("AddGameTask", "goto '" + name + "' 'Bed'");
yield return(new WaitForSeconds(15.0f));
string parent = GameObject.Find("Player").transform.parent.name;
Assert.AreEqual(parent, name);
}
}
// Navigate the entire world. Uses breath first search
List <PixelDoor> FindPathToRoom(PixelRoom destination)
{
// Variables
Queue <PixelRoom> OpenSet = new Queue <PixelRoom>();
HashSet <PixelRoom> ClosedSet = new HashSet <PixelRoom>();
Dictionary <PixelRoom, List <PixelDoor> > Meta = new Dictionary <PixelRoom, List <PixelDoor> >();
// Initalization
PixelCollider pixelCollider = transform.GetComponentInChildren <PixelCollider>();
PixelRoom start = pixelCollider.GetPixelRoom();
Debug.Assert(start != null);
OpenSet.Enqueue(start);
while (OpenSet.Count > 0)
{
PixelRoom subtreeRoot = OpenSet.Dequeue();
if (subtreeRoot == destination)
{
List <PixelDoor> actionList = new List <PixelDoor>();
PixelRoom state = subtreeRoot;
while (Meta.ContainsKey(state) && Meta[state].Count() >= 0)
{
actionList.Add(Meta[state].First());
state = Meta[state].First().source;
}
actionList.Reverse();
return(actionList);
}
foreach (PixelDoor pixeldoor in subtreeRoot.pixelDoors)
{
if (ClosedSet.Contains(pixeldoor.destination))
{
continue;
}
if (!OpenSet.Contains(pixeldoor.destination))
{
if (!Meta.ContainsKey(pixeldoor.destination))
{
Meta.Add(pixeldoor.destination, new List <PixelDoor>());
}
Meta[pixeldoor.destination].Add(pixeldoor);
OpenSet.Enqueue(pixeldoor.destination);
}
}
ClosedSet.Add(subtreeRoot);
}
return(null);
}
public void EnterDoor(PixelDoor door)
{
PixelRoom room = door.destination;
Transform originalroom = transform.parent;
Vector2 originalposition = transform.position;
transform.parent = null; // Prevents disabling the player
originalroom.gameObject.SetActive(false);
room.transform.gameObject.SetActive(true);
Vector2 destinationOffset = door.dropOffWorldLocation;
facingDirection = destinationOffset - (Vector2)transform.position;
if (!(door is PixelStair))
{
transform.position = destinationOffset;
}
transform.parent = room.transform;
room.OnEnable();
UpdateSortingLayer();
CancelInvoke("Movement");
AnimateMovement();
InvokeRepeating("Movement", 0.0f, 1.0f / room.RoomWalkingSpeed);
if (door is PixelStair)
{
transform.position = originalposition;
}
return;
}
public static List <GameTask> CreateGameTasks(string actionString)
{
List <GameTask> gameTasks = new List <GameTask>();
List <string> actionStrings = BreakUpString(actionString);
Character taskCharacter;
TaskType type = IdentifyTaskType(actionStrings, out taskCharacter);
if (type == TaskType.NAVIGATE)
{
GameTask gameTask = new GameTask();
gameTask.taskType = TaskType.NAVIGATE;
Debug.Assert(taskCharacter != null);
if (actionStrings.Count == 3)
{
PixelCollider pc = taskCharacter.GetComponentInChildren <PixelCollider>();
string roomName = pc.GetPixelRoom().name;
actionStrings.Insert(2, roomName);
}
string locationString = actionStrings[2];
PixelRoom room = GetObjectOfType <PixelRoom>(locationString);
gameTask.arguments.Add(room);
string objectString = actionStrings[3];
PixelCollider pixelCollider = GetObjectOfType <PixelCollider>(objectString, room.transform);
gameTask.arguments.Add(pixelCollider);
gameTask.character = taskCharacter;
Direction direction = Direction.All;
if (actionStrings.Count > 4)
{
string directionString = actionStrings[4];
if (directionString == "NE")
{
direction = Direction.NE;
}
if (directionString == "SE")
{
direction = Direction.SE;
}
if (directionString == "SW")
{
direction = Direction.SW;
}
if (directionString == "NW")
{
direction = Direction.NW;
}
}
GameTask faceTask = new GameTask();
faceTask.taskType = TaskType.FACEDIRECTION;
faceTask.duration = 0.1f;
faceTask.arguments.Add(direction);
faceTask.character = taskCharacter;
gameTasks.Add(gameTask);
gameTasks.Add(faceTask);
}
else if (type == TaskType.CREATE)
{
GameTask createItemTask = new GameTask();
createItemTask.taskType = TaskType.CREATE;
createItemTask.duration = 0.0f;
GameObject itemObj = null;
int number = 1;
bool hasNumber = int.TryParse(actionStrings[2], out number);
if (!hasNumber)
{
number = 1;
actionStrings.Insert(2, number.ToString());
}
Debug.Assert(number >= 1 && number <= 4);
itemObj = Resources.Load("Items/" + actionStrings[3]) as GameObject;
if (itemObj == null)
{
Debug.LogWarning(actionStrings[3] + " is not an item");
}
Debug.Assert(itemObj != null);
createItemTask.arguments.Add(number);
createItemTask.arguments.Add(itemObj);
createItemTask.character = taskCharacter;
gameTasks.Add(createItemTask);
}
else if (type == TaskType.PUTS || type == TaskType.TAKES)
{
// Navigate first
int number = 1;
bool hasNumber = int.TryParse(actionStrings[2], out number);
if (!hasNumber)
{
number = 1;
actionStrings.Insert(2, "1");
}
if (actionStrings.Count == 5)
{
PixelCollider pc = taskCharacter.GetComponentInChildren <PixelCollider>();
string roomName = pc.GetPixelRoom().name;
actionStrings.Insert(4, roomName);
}
PixelInventory inv = taskCharacter.GetComponentInChildren <PixelInventory>();
Debug.Assert(inv != null);
string locationString = actionStrings[4];
PixelRoom room = GetObjectOfType <PixelRoom>(locationString);
string objectString = actionStrings[5];
PixelCollider pixelCollider = GetObjectOfType <PixelCollider>(objectString, room.transform);
PixelStorage storage = pixelCollider.transform.parent.GetComponent <PixelStorage>();
if (storage == null)
{
Debug.LogWarning("Cannot Place Item in " + actionStrings[5]);
return(gameTasks);
}
// Navigate First
GameTask navigateTask = new GameTask();
navigateTask.taskType = TaskType.NAVIGATE;
navigateTask.character = taskCharacter;
navigateTask.arguments.Add(room);
navigateTask.arguments.Add(pixelCollider);
gameTasks.Add(navigateTask);
// Then Put
GameTask putsItemTask = new GameTask();
putsItemTask.taskType = type;
putsItemTask.arguments.Add(number);
putsItemTask.arguments.Add(actionStrings[3]);
putsItemTask.arguments.Add(storage);
putsItemTask.character = taskCharacter;
gameTasks.Add(putsItemTask);
}
else if (type == TaskType.GIVES || type == TaskType.STEALS) // player gives hamen key
{
string characterName = actionStrings[2];
Character toCharacter = GetCharacter(characterName);
if (toCharacter == null)
{
Debug.LogWarning("Character: " + toCharacter.name + " does not exist");
}
PixelInventory fromInventory = taskCharacter.GetComponentInChildren <PixelInventory>();
PixelInventory toInventory = toCharacter.GetComponentInChildren <PixelInventory>();
Debug.Assert(fromInventory != null && toInventory != null);
PixelCollider toCharacterCollider = toCharacter.GetComponentInChildren <PixelCollider>();
PixelRoom room = toCharacterCollider.GetPixelRoom();
Debug.Assert(toCharacterCollider != null && room != null);
int count = 1;
bool hasNumber = int.TryParse(actionStrings[3], out count);
if (!hasNumber)
{
count = 1;
actionStrings.Insert(3, "1");
}
string itemName = actionStrings[4];
// Navigate to the player
GameTask navigateTask = new GameTask();
navigateTask.taskType = TaskType.NAVIGATE;
navigateTask.character = taskCharacter;
navigateTask.arguments.Add(room);
navigateTask.arguments.Add(toCharacterCollider);
gameTasks.Add(navigateTask);
// Then Gives
GameTask givesItemTask = new GameTask();
givesItemTask.taskType = type;
givesItemTask.arguments.Add(count);
givesItemTask.arguments.Add(itemName);
givesItemTask.arguments.Add(toCharacter);
givesItemTask.character = taskCharacter;
gameTasks.Add(givesItemTask);
}
else if (type == TaskType.MOUNT) // player gives hamen key
{
// TODO 1. create a gametask for mounting an object. Must pass in the correct arguments in the gametask that
// gets passed into the character task
}
return(gameTasks);
}
public bool NavigateObject(PixelRoom room, PixelCollider pixelCollider, Direction direction = Direction.All)
{
PixelRoom pixelRoom = pixelCollider.GetPixelRoom();
PixelCollider playerCollider = GetComponentInChildren <PixelCollider>();
// Find last location
// Closest from the door or the players position
List <PixelDoor> path = FindPathToRoom(room);
Vector2 startPosition;
if (path.Count != 0)
{
room.gameObject.SetActive(true);
room.GetNavigationalMesh(playerCollider, path.Last().dropOffWorldLocation);
room.gameObject.SetActive(false);
startPosition = path.Last().dropOffWorldLocation;
}
else
{
startPosition = transform.position;
}
// Navigate from the last location to find the pixel pose
PixelPose pixelPose;
if (pixelCollider != null)
{
pixelRoom.GetNavigationalMesh(playerCollider, startPosition);
// Object is movable
if (pixelCollider.transform.parent.GetComponent <MovableObject>())
{
if (direction != Direction.All)
{
WayPoint wayPoint = pixelCollider.FindWayPointInDirection(direction);
pixelPose = new PixelPose(pixelRoom, direction, wayPoint.position);
}
else
{
// Player moves to the characters position first
KeyValuePair <PixelPose, float> bestPlayerMovementWayPoint = pixelCollider.FindBestWayPoint();
pixelPose = bestPlayerMovementWayPoint.Key;
Debug.DrawLine(transform.position, pixelPose.position, Color.red, 10.0f);
// Character enqueues a movement to the best place for that position
Character character = pixelCollider.GetComponentInParent <Character>();
if (character != null)
{
PixelPose translatedPose = pixelPose.TranslatePose(2 * (pixelCollider.navigationMargin + playerCollider.navigationMargin));
PixelPose flippedPose = translatedPose.Flip();
GameTask characterNavTask = new GameTask(GameTask.TaskType.NAVIGATE);
characterNavTask.character = character;
characterNavTask.arguments.Add(flippedPose);
character.characterTasks.Enqueue(characterNavTask);
}
}
}
else
{
if (direction != Direction.All)
{
WayPoint wayPoint = pixelCollider.FindWayPointInDirection(direction);
pixelPose = new PixelPose(pixelRoom, direction, wayPoint.position);
}
else
{
PixelCollider characterCollider = GetComponentInChildren <PixelCollider>();
pixelPose = pixelCollider.FindBestWayPointPosition(startPosition);
}
}
Navigate(pixelPose);
}
return(true);
}
List <WayPoint> FindPathToLocation(Vector2 destination)
{
PixelCollider pixelCollider = transform.GetComponentInChildren <PixelCollider>();
Debug.Assert(pixelCollider != null);
PixelRoom pixelRoom = pixelCollider.GetPixelRoom();
Debug.Assert(pixelRoom != null);
// Dijkstra's Algorithm Parameters
int stepSize = pixelRoom.stepSize;
float minDistanceToTarget = stepSize * 2;
// Initialization
HashSet <WayPoint> Q = pixelRoom.GetNavigationalMesh(pixelCollider);
WayPoint target = new WayPoint
{
position = destination,
distance = float.MaxValue,
previous = null
};
WayPoint current = Q.Aggregate((i1, i2) => (i1.position - (Vector2)transform.position).sqrMagnitude < (i2.position - (Vector2)transform.position).sqrMagnitude ? i1 : i2);
current.distance = 0;
// Propogation
while (Q.Count > 0)
{
WayPoint u = Q.Aggregate((i1, i2) => i1.distance < i2.distance ? i1 : i2);
Q.Remove(u);
if (WayPoint.Distance(u, target) < minDistanceToTarget)
{
target.previous = u;
List <WayPoint> path = new List <WayPoint>();
if (u.previous == null)
{
return(path);
}
while (u.previous != null)
{
path.Add(u);
u = u.previous;
}
path.Add(u);
path.Reverse();
return(path);
}
foreach (WayPoint v in u.neighbours)
{
float alt = u.distance + WayPoint.Distance(u, v);
if (alt < v.distance)
{
v.distance = alt;
v.previous = u;
}
}
}
return(new List <WayPoint>());
}
void MouseClicked()
{
if (DebugWindowOpen)
{
return;
}
if (Input.GetMouseButtonDown(0))
{
Vector3 castStart = mousePosition;
castStart.z = -10.0f;
RaycastHit2D[] raycastHits = Physics2D.CircleCastAll(mousePosition, 30.0f, Vector2.zero);
// Detected inspected objects
foreach (var hit in raycastHits)
{
GameObject obj = hit.collider.gameObject;
if (obj == this)
{
continue;
}
PixelCollider pixelCollider = obj.GetComponent <PixelCollider>();
if (pixelCollider != null)
{
if (pixelCollider.inspectChildObjects)
{
continue;
}
PixelCollider characterCollider = this.GetComponentInChildren <PixelCollider>();
if (pixelCollider.GetPixelRoom() != characterCollider.GetPixelRoom())
{
continue;
}
if (pixelCollider.transform.parent.name == "VirtualObject")
{
continue;
}
if (pixelCollider.transform.parent.name == "Player")
{
continue;
}
bool withinCollider = pixelCollider.CheckForWithinCollider(mousePosition);
if (withinCollider)
{
Debug.Log(pixelCollider.transform.parent.name);
NavigateObject(pixelCollider.GetPixelRoom(), pixelCollider);
// Inspect Object
PixelCollision pc = new PixelCollision();
pc.pixelCollider = pixelCollider;
pc.direction = Direction.All;
CharacterTask inspectTask = new CharacterTask(GameTask.TaskType.INSPECT, pc);
characterTasks.Enqueue(inspectTask);
return;
}
}
}
// Detected inspected rooms (for navigation)
foreach (var hit in raycastHits)
{
GameObject obj = hit.collider.gameObject;
if (obj == this)
{
continue;
}
PixelRoom pixelRoom = obj.GetComponent <PixelRoom>();
if (pixelRoom != null)
{
PixelCollider pixelCollider = gameObject.GetComponentInChildren <PixelCollider>();
if (pixelCollider == null)
{
continue;
}
if (pixelCollider.GetPixelRoom() != pixelRoom)
{
continue;
}
Debug.Log(pixelRoom.name);
// Navigate Maze Room
CharacterTask characterTask = new CharacterTask(GameTask.TaskType.WALKTO, mousePosition);
characterTasks.Enqueue(characterTask);
}
}
}
}
