private int x, y; //position
#endregion Fields
#region Constructors
public Building()
{
name = "";
x = 0;
y = 0;
width = 0;
height = 0;
buildingType = BuildingType.NULL;
door = new Position();
lit = true;
roofType = WOOD_ROOF;
}
public void placeBrother(Quinoa quinoa)
{
String caveID = caveBottomIDs[RandomNumber.RandomInteger(caveBottomIDs.Count)];
RegionHeader header = quinoa.getMap().getRegionHeaderByID(caveID);
header.recallRegion();
Position pos = new Position();
List<Position> tempPos = MapGenerator.getTerrainPositions(TerrainCode.STONE_FLOOR, header.getRegion(), false);
if (tempPos.Count > 0)
{
pos = tempPos[RandomNumber.RandomInteger(tempPos.Count)];
}
Monster monster = new Monster();
monster.monsterCode = MonsterCode.HUMAN;
MonsterActionManager.initialize(monster);
monster.role = MonsterRole.BROTHER;
monster.setPosition(pos.x, pos.y);
Item lantern = new Item();
lantern.itemClass = ItemClass.LANTERN;
monster.inventory.equipItem(lantern, ItemSlot.BELT_1);
header.getRegion().getMonsters().Add(monster);
header.storeRegion(true);
}
public List<Position> findPath(Region region, int maxSearchDistance, Monster mover, int sx, int sy, int tx, int ty)
{
//Initialize
this.region = region;
nodes = new PathNode[region.getWidth(),region.getHeight()];
for (int x=0;x<region.getWidth();x++) {
for (int y=0;y<region.getHeight();y++) {
nodes[x,y] = new PathNode(x,y);
}
}
// easy first check, if the destination is blocked, we can't get there
if(!TerrainManager.allowsMonsterToPass(region.getTerrain(tx, ty), mover))
{
return null;
}
// initial state for A*. The closed group is empty. Only the starting
// tile is in the open list and it's cost is zero, i.e. we're already there
nodes[sx,sy].cost = 0;
nodes[sx,sy].depth = 0;
closed.Clear();
open.clear();
open.add(nodes[sx,sy]);
nodes[tx,ty].parent = null;
// while we haven't found the goal and haven't exceeded our max search depth
int maxDepth = 0;
while ((maxDepth < maxSearchDistance) && (open.size() != 0))
{
// pull out the first node in our open list, this is determined to
// be the most likely to be the next step based on our heuristic
PathNode current = getFirstInOpen();
if (current == nodes[tx,ty])
{
break;
}
removeFromOpen(current);
addToClosed(current);
// search through all the neighbours of the current node evaluating
// them as next steps
for (int x=-1;x<2;x++)
{
for (int y=-1;y<2;y++)
{
// not a neighbour, its the current tile
if ((x == 0) && (y == 0))
{
continue;
}
// if we're not allowing diaganol movement then only
// one of x or y can be set
if ((x != 0) && (y != 0))
{
continue;
}
// determine the location of the neighbour and evaluate it
int xp = x + current.x;
int yp = y + current.y;
if (isValidLocation(mover,sx,sy,xp,yp))
{
// the cost to get to this node is cost the current plus the movement
// cost to reach this node. Note that the heursitic value is only used
// in the sorted open list
float nextStepCost = current.cost + getMovementCost(mover, current.x, current.y, xp, yp);
PathNode neighbour = nodes[xp,yp];
// if the new cost we've determined for this node is lower than
// it has been previously makes sure the node hasn't been discarded. We've
// determined that there might have been a better path to get to
// this node so it needs to be re-evaluated
if (nextStepCost < neighbour.cost)
{
if (inOpenList(neighbour))
{
removeFromOpen(neighbour);
}
if (inClosedList(neighbour))
{
removeFromClosed(neighbour);
}
}
// if the node hasn't already been processed and discarded then
// reset it's cost to our current cost and add it as a next possible
// step (i.e. to the open list)
if (!inOpenList(neighbour) && !(inClosedList(neighbour)))
{
neighbour.cost = nextStepCost;
neighbour.heuristic = getHeuristicCost(mover, xp, yp, tx, ty);
maxDepth = Math.Max(maxDepth, neighbour.setParent(current));
addToOpen(neighbour);
}
}
}
}
}
// since we've got an empty open list or we've run out of search
// there was no path. Just return null
if (nodes[tx,ty].parent == null)
{
return null;
}
// At this point we've definitely found a path so we can uses the parent
// references of the nodes to find out way from the target location back
// to the start recording the nodes on the way.
List<Position> path = new List<Position>();
PathNode target = nodes[tx,ty];
while (target != nodes[sx,sy])
{
Position pos = new Position(target.x, target.y);
path.Insert(0, pos);
target = target.parent;
}
Position pos2 = new Position(sx, sy);
path.Insert(0, pos2);
// thats it, we have our path
return path;
}
