public override bool Equals(object obj)
{
if (!(obj is IntPoint2D))
{
return(false);
}
else
{
IntPoint2D rhs = (IntPoint2D)obj;
if (this.xCoord == rhs.xCoord)
{
if (this.yCoord == rhs.yCoord)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
}
public Stack <IntPoint2D> GetRoadPath(IntPoint2D startLoc, IntPoint2D endLoc)
{
List <IntPoint2D> startList = GetAdjacentRoadTiles(startLoc);
List <IntPoint2D> endList = GetAdjacentRoadTiles(endLoc);
return(ShortestPath(startList, endList, true));
}
public GameObject GetActualTile(IntPoint2D tileLoc)
{
GameObject tile = this.CreateRoadTile(actualRoadPrefab, tileLoc);
tile.SetActive(true);
return(tile);
}
public GameObject GetRedGhost(IntPoint2D tileLoc)
{
GameObject tile = this.CreateRoadTile(redPrefab, tileLoc);
tile.SetActive(true);
return(tile);
}
public GameObject GetActualHouse(IntPoint2D tileLoc)
{
GameObject house = this.CreateHouse(actualHousePrefab, tileLoc);
house.SetActive(true);
return(house);
}
public void DistributeWater(IntPoint2D tileIndex)
{
if (IsValidTile(tileIndex))
{
tileArray [tileIndex.xCoord, tileIndex.yCoord].DistributeWater();
}
}
public void CalculatesPathEfficiently()
{
bool[,] map = new bool[5, 5];
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
map[i, j] = true;
}
}
IntPoint2D from = new IntPoint2D()
{
X = 0, Y = 0
};
IntPoint2D to = new IntPoint2D()
{
X = 4, Y = 4
};
int visitedNodesCount;
var pathLength = AStarPathFinder.AStarPathFinder.GetBestPathLength(from, to, map, out visitedNodesCount);
Assert.IsTrue(pathLength > 5 && pathLength < 6, "Wrong Path Calculated");
Assert.IsTrue(visitedNodesCount >= 4 && visitedNodesCount <= 8, "Path Calculated Inefficiently");
}
public GameObject GetWellWalker(IntPoint2D tileLoc, ScenarioMgr.Direction facing)
{
//Debug.Log ("Retrieving well walker");
Vector3 topLeft = scenario.ComputeTopLeftPointOfTile(tileLoc);
GameObject walker;
walker = (GameObject)Instantiate(wellWalkerPrefab);
walker.transform.position = topLeft + new Vector3(walkerHorizOffset, walkerVertOffset, walkerHorizOffset);
walker.transform.rotation = Quaternion.identity;
if (facing == ScenarioMgr.Direction.Up)
{
walker.transform.Rotate(0, 90, 0);
}
else if (facing == ScenarioMgr.Direction.Left)
{
walker.transform.Rotate(0, 180, 0);
}
else if (facing == ScenarioMgr.Direction.Down)
{
walker.transform.Rotate(0, 270, 0);
}
walker.SetActive(true);
return(walker);
}
void DragRoad(Vector3 mouseLoc)
{
IntPoint2D curTile = this.ConvertPointToTileIndex(mouseLoc);
FixFirstDirection(curTile);
if (firstDir == Direction.Undefined)
{
IntPoint2D[] keys = new IntPoint2D[tempObjects.Count];
tempObjects.Keys.CopyTo(keys, 0);
// clean up all but first tile
foreach (IntPoint2D curKey in keys)
{
if (curKey != curTile)
{
Destroy(tempObjects [curKey]);
tempObjects.Remove(curKey);
}
}
}
else
{
int xLeft, xRight, yUp, yDown, horizY, vertX;
DetermineEndPoints(curTile, out xLeft, out xRight, out yUp, out yDown, out horizY, out vertX);
// deal with the interesting problem
AdjustRoadTiles(xLeft, xRight, yUp, yDown, horizY, vertX);
}
}
public Stack <IntPoint2D> ComputePath(IntPoint2D start, IntPoint2D end, bool openTravel)
{
//Debug.Log ("Computing path from "+start.ToString()+ " to " + end.ToString());
HashSet <IntPoint2D> closed = new HashSet <IntPoint2D> ();
closed.Add(start);
int queueSize = (this.gridHeight * this.gridWidth) * 16;
HeapPriorityQueue <SearchNode> searchList = new HeapPriorityQueue <SearchNode> (queueSize);
Stack <IntPoint2D> path = new Stack <IntPoint2D> ();
SearchNode root = new SearchNode(null, start, 0, Math.Abs(start.xCoord - end.xCoord) + Math.Abs(start.yCoord - end.yCoord));
searchList.Enqueue(root, root.Priority);
SearchNode curNode = null;
bool found = false;
List <SearchNode> children;
while (!found && searchList.Count > 0)
{
curNode = searchList.Dequeue();
//Debug.Log("checking node: "+curNode.data.ToString());
if (curNode.AtGoal(end))
{
found = true;
}
else
{
children = curNode.GetChildren(end, this, openTravel);
foreach (SearchNode child in children)
{
if (searchList.Count == queueSize)
{
Debug.Log("Priority queue size: " + queueSize.ToString() + " exceeded");
}
//Debug.Log("enqueueing node: "+child.data.ToString());
//Debug.Log (" Priority: "+child.Priority.ToString());
if (!closed.Contains(child.data))
{
searchList.Enqueue(child, child.cost + child.heuristic);
closed.Add(child.data);
}
}
}
}
if (found)
{
//Debug.Log ("pushing path");
while (curNode != null)
{
path.Push(curNode.data);
// Debug.Log(curNode.data.ToString());
curNode = curNode.parent;
}
path.Pop();
}
else
{
//Debug.Log ("no path found");
}
return(path);
}
// private int searchLimit = 100;
public void SetUp(ScenarioData scenario, IntPoint2D startTile, ScenarioMgr.Direction startingDir, bool wandering,
IntPoint2D dest, HouseManager house, bool movingIn)
{
Debug.Log("in citizen set up");
scenarioInfo = scenario;
facing = startingDir;
curTile = startTile;
this.wandering = wandering;
this.destTile = dest;
Debug.Log("start tile: " + startTile.ToString());
Debug.Log("dest tile: " + destTile.ToString());
this.myHouse = house;
this.movingIn = movingIn;
havePath = false;
startPath = false;
if (!wandering)
{
Debug.Log("Starting TakePath Coroutine from SetUp");
StartCoroutine(TakePath());
}
else
{
StartCoroutine(Wander());
}
}
void SetUpHouseGhost()
{
Vector3 mouseLoc;
IntPoint2D tileLoc = IntPoint2D.zero;
bool disableObject = false;
if (this.MouseLocationOnGround(out mouseLoc))
{
tileLoc = this.ConvertPointToTileIndex(mouseLoc);
if (this.scenarioInfo.CanBuildHere(tileLoc))
{
curObject = housePool.GetGreenGhost(tileLoc);
this.curObjectIsGreen = true;
}
else
{
curObject = housePool.GetRedGhost(tileLoc);
this.curObjectIsGreen = false;
}
}
else
{
// making a disabled green one
curObject = housePool.GetGreenGhost(tileLoc);
this.curObjectIsGreen = true;
disableObject = true;
}
// need to make it
curObject.SetActive(disableObject);
this.curObjectSizeInTiles = 1;
}
public StateType[] GetNeighboursStates(IntPoint2D coordinates)
{
StateType[] states = new StateType[8];
sbyte index = 0;
foreach (var i in signs)
{
foreach (var j in signs)
{
if (i == 0 && j == 0)
{
continue;
}
else
{
var newCoords = AdjustCoordinates(new IntPoint2D()
{
x = coordinates.x + i, y = coordinates.y + j
});
states[index] = GetState(newCoords);
++index;
}
}
}
return(states);
}
public void CanCalculateComplexPath()
{
bool[,] map = new bool[5, 5];
map[0, 0] = true;
map[0, 1] = true;
map[0, 2] = true;
map[0, 3] = true;
map[1, 2] = true;
map[2, 0] = true;
map[2, 1] = true;
map[2, 2] = true;
map[2, 3] = true;
map[3, 0] = true;
map[3, 1] = true;
map[3, 2] = true;
map[3, 3] = true;
IntPoint2D from = new IntPoint2D()
{
X = 0, Y = 0
};
IntPoint2D to = new IntPoint2D()
{
X = 3, Y = 0
};
var pathLength = AStarPathFinder.AStarPathFinder.GetBestPathLength(from, to, map);
Assert.IsTrue(pathLength > 5 && pathLength < 6);
}
void CompleteDelete(bool goodMouseLoc, Vector3 mouseLoc)
{
bool actuallyDeleting = false;
if (goodMouseLoc)
{
// we're on the ground, so figure out which tile we're on
IntPoint2D tile = ConvertPointToTileIndex(mouseLoc);
// and see if we have an object there
GameObject delEndObj = scenarioInfo.GetBuilding(tile);
if (delEndObj == curObject)
{ // if the two objects are the same
if (scenarioInfo.IsHouse(tile))
{
popMgr.RemoveHouse(tile);
}
actuallyDeleting = true;
scenarioInfo.DeleteBuilding(tile);
Destroy(delEndObj);
}
}
if (!actuallyDeleting)
{
// fix the mat back
curObject.GetComponent <MeshRenderer> ().material = savedMat;
}
curObject = null;
}
public GameObject GetRedGhost(IntPoint2D tileLoc)
{
GameObject house = this.CreateHouse(redPrefab, tileLoc);
house.SetActive(true);
return(house);
}
public void MakeOther(GameObject building, int size, IntPoint2D topLeft)
{
mobility = Moveability.Impassable;
clear = false;
this.building = building;
buildingSize = size;
this.buildingTopLeft = topLeft;
}
public void MakeRoad(GameObject tile, IntPoint2D topLeft)
{
mobility = Moveability.Road;
clear = false;
building = tile;
buildingSize = 1;
this.buildingTopLeft = topLeft;
}
public GameObject GetActualObject(int arrayIndex, IntPoint2D tileLoc)
{
Vector3 topLeft = scenario.ComputeTopLeftPointOfTile(tileLoc);
GameObject obj = (GameObject)Instantiate(actualPrefabs[arrayIndex]);
obj.transform.position = topLeft + GetObjTransform(arrayIndex);
return(obj);
}
private static IntPoint2D VectorToIntPoint(Vector3 vector)
{
var point = new IntPoint2D();
point.X = (int)vector.X;
point.Y = (int)vector.Y;
return(point);
}
/// <summary>
/// コンストラクター
/// </summary>
/// <param name="a">A</param>
/// <param name="b">B</param>
public IntRectangle(IntPoint2D a, IntPoint2D b)
{
Initialize();
A.X = a.X;
A.Y = a.Y;
B.X = b.X;
B.Y = b.Y;
}
public SearchNode(SearchNode prev, IntPoint2D data, int cost, int heuristic)
{
parent = prev;
this.data = data;
this.cost = cost;
this.heuristic = heuristic;
this.Priority = cost + heuristic;
}
private void MakeRoadTile(IntPoint2D tileLoc)
{
if (scenarioInfo.CanBuildHere(tileLoc))
{
GameObject tile = roadPool.GetActualTile(tileLoc);
scenarioInfo.MakeRoad(tileLoc, tile);
}
}
public void MakeHouse(GameObject house, IntPoint2D topLeft)
{
mobility = Moveability.Impassable;
clear = false;
building = house;
isHouse = true;
buildingSize = 1;
this.buildingTopLeft = topLeft;
}
public Vector3 ComputeTopLeftPointOfTile(IntPoint2D tileIndex)
{
//Debug.Log ("In ComputeTopLeftPointOfTile");
Vector3 point = new Vector3(tileIndex.xCoord - gridWidth / 2, 0, tileIndex.yCoord - gridHeight / 2);
//Debug.Log(tileIndex);
//Debug.Log (point);
return(point);
}
public void SetUp(GameObject ground, ScenarioData scenario, IntPoint2D tileLoc)
{
scenarioInfo = scenario;
centerTile = tileLoc;
popMgr = ground.GetComponent("PopulationManager") as PopulationManager;
numWorkers = 0;
amountStored = 0;
StartCoroutine("GetWorkers");
}
public List <SearchNode> GetChildren(IntPoint2D dest, ScenarioData scenario, bool openTravel)
{
List <SearchNode> children = new List <SearchNode>();
int childCost = this.cost + 1;
int childHeuristic = 0;
IntPoint2D childData = new IntPoint2D(data.xCoord - 1, data.yCoord);
if (scenario.IsValidTile(childData) && !InAncestorNode(childData) &&
(scenario.IsRoadTile(childData) || (openTravel && scenario.IsPassableTile(childData)) || childData.Equals(dest)))
{
childCost = this.cost + 1;
if (!scenario.IsRoadTile(childData))
{
childCost = childCost + 2;
}
childHeuristic = Math.Abs(childData.xCoord - dest.xCoord) + Math.Abs(childData.yCoord - dest.yCoord);
children.Add(new SearchNode(this, childData, childCost, childHeuristic));
}
childData = new IntPoint2D(data.xCoord + 1, data.yCoord);
if (scenario.IsValidTile(childData) && !InAncestorNode(childData) &&
(scenario.IsRoadTile(childData) || (openTravel && scenario.IsPassableTile(childData)) || childData.Equals(dest)))
{
childCost = this.cost + 1;
if (!scenario.IsRoadTile(childData))
{
childCost = childCost + 2;
}
childHeuristic = Math.Abs(childData.xCoord - dest.xCoord) + Math.Abs(childData.yCoord - dest.yCoord);
children.Add(new SearchNode(this, childData, childCost, childHeuristic));
}
childData = new IntPoint2D(data.xCoord, data.yCoord - 1);
if (scenario.IsValidTile(childData) && !InAncestorNode(childData) &&
(scenario.IsRoadTile(childData) || (openTravel && scenario.IsPassableTile(childData)) || childData.Equals(dest)))
{
childCost = this.cost + 1;
if (!scenario.IsRoadTile(childData))
{
childCost = childCost + 2;
}
childHeuristic = Math.Abs(childData.xCoord - dest.xCoord) + Math.Abs(childData.yCoord - dest.yCoord);
children.Add(new SearchNode(this, childData, childCost, childHeuristic));
}
childData = new IntPoint2D(data.xCoord, data.yCoord + 1);
if (scenario.IsValidTile(childData) && !InAncestorNode(childData) &&
(scenario.IsRoadTile(childData) || (openTravel && scenario.IsPassableTile(childData)) || childData.Equals(dest)))
{
childCost = this.cost + 1;
if (!scenario.IsRoadTile(childData))
{
childCost = childCost + 2;
}
childHeuristic = Math.Abs(childData.xCoord - dest.xCoord) + Math.Abs(childData.yCoord - dest.yCoord);
children.Add(new SearchNode(this, childData, childCost, childHeuristic));
}
return(children);
}
public bool MakeRoad(IntPoint2D tileIndex, GameObject tile)
{
bool canMake = IsValidTile(tileIndex) && tileArray [tileIndex.xCoord, tileIndex.yCoord].IsClear();
if (canMake)
{
tileArray [tileIndex.xCoord, tileIndex.yCoord].MakeRoad(tile, tileIndex);
}
return(canMake);
}
public bool MakeHouse(IntPoint2D houseTile, GameObject house)
{
bool canMake = IsValidTile(houseTile) && tileArray [houseTile.xCoord, houseTile.yCoord].IsClear();
if (canMake)
{
tileArray [houseTile.xCoord, houseTile.yCoord].MakeHouse(house, houseTile);
}
return(canMake);
}
private IntPoint2D AdjustCoordinates(IntPoint2D coords)
{
int x = ((coords.x % width) + width) % width;
int y = ((coords.y % height) + height) % height;
return(new IntPoint2D()
{
x = x, y = y
});
}
public void Expand(IntPoint2D point)
{
if (point.X < _min.X)
_min.X = point.X;
if (point.Y < _min.Y)
_min.Y = point.Y;
if (point.X > _max.X)
_max.X = point.X;
if (point.Y > _max.Y)
_max.Y = point.Y;
}
public Box2D(IntPoint2D min, IntPoint2D max)
{
_min = min;
_max = max;
}
public static PerspectiveCamera CreateFromBounds(AxisAlignedBox3D bounds, Viewport3D viewport,
float fieldOfView, float yaw = 0.0f, float pitch = 0.0f, float zoom = 1.0f)
{
// Calculate initial guess at camera settings.
Matrix3D transform = Matrix3D.CreateFromYawPitchRoll(yaw, pitch, 0);
Vector3D cameraDirection = Vector3D.Normalize(transform.Transform(Vector3D.Forward));
PerspectiveCamera initialGuess = new PerspectiveCamera
{
FieldOfView = fieldOfView,
NearPlaneDistance = 1.0f,
FarPlaneDistance = bounds.Size.Length() * 10,
Position = bounds.Center - cameraDirection * bounds.Size.Length() * 2,
LookDirection = cameraDirection,
UpDirection = Vector3D.Up
};
Matrix3D projection = initialGuess.GetProjectionMatrix(viewport.AspectRatio);
Matrix3D view = initialGuess.GetViewMatrix();
// Project bounding box corners onto screen, and calculate screen bounds.
float closestZ = float.MaxValue;
Box2D? screenBounds = null;
Point3D[] corners = bounds.GetCorners();
foreach (Point3D corner in corners)
{
Point3D screenPoint = viewport.Project(corner,
projection, view, Matrix3D.Identity);
if (screenPoint.Z < closestZ)
closestZ = screenPoint.Z;
IntPoint2D intScreenPoint = new IntPoint2D((int) screenPoint.X, (int) screenPoint.Y);
if (screenBounds == null)
screenBounds = new Box2D(intScreenPoint, intScreenPoint);
else
{
Box2D value = screenBounds.Value;
value.Expand(intScreenPoint);
screenBounds = value;
}
}
// Now project back from screen bounds into scene, setting Z to the minimum bounding box Z value.
IntPoint2D minScreen = screenBounds.Value.Min;
IntPoint2D maxScreen = screenBounds.Value.Max;
Point3D min = viewport.Unproject(new Point3D(minScreen.X, minScreen.Y, closestZ),
projection, view, Matrix3D.Identity);
Point3D max = viewport.Unproject(new Point3D(maxScreen.X, maxScreen.Y, closestZ),
projection, view, Matrix3D.Identity);
// Use these new values to calculate the distance the camera should be from the AABB centre.
Vector3D size = Vector3D.Abs(max - min);
float radius = size.Length();
float dist = radius / (2 * MathUtility.Tan(fieldOfView * viewport.AspectRatio / 2));
Point3D closestBoundsCenter = (min + (max - min) / 2);
Point3D position = closestBoundsCenter - cameraDirection * dist * (1 / zoom);
return new PerspectiveCamera
{
FieldOfView = fieldOfView,
NearPlaneDistance = 1.0f,
FarPlaneDistance = dist * 10,
Position = position,
LookDirection = cameraDirection,
UpDirection = Vector3D.Up
};
}
