/// <summary>
/// find the closest cell from the specified destination
/// </summary>
/// <param name="point">Destination</param>
/// <returns>Closest cell</returns>
private CellComponent findClosestCell(PointF point)
{
double distanceSquared = Math.Pow(map.GetWidth(), 2.0) + Math.Pow(map.GetHeight(), 2.0);
CellComponent cell = null;
for (int i = Math.Max((int)building.PointLocation.X - 1, 0); i <= building.PointLocation.X + building.Width + 1; i++)
{
for (int j = Math.Max((int)building.PointLocation.Y - 1, 0); j <= building.PointLocation.Y + building.Height + 1; j++)
{
// Ignore cases in the middle of the proposed building site.
if (!(i >= (int)building.PointLocation.X && i < (int)building.PointLocation.X + building.Width && j >= (int)building.PointLocation.Y && j < (int)building.PointLocation.Y + building.Height))
{
double calculatedDistanceSquared = findDistanceSquared(point.X, point.Y, i, j);
if (calculatedDistanceSquared <= distanceSquared)
{
if (map.GetCellAt(i, j) != null)
{
cell = map.GetCellAt(i, j);
distanceSquared = calculatedDistanceSquared;
}
}
}
}
}
return(cell);
}
private void stopListeningToCells(PointF oldPoint)
{
// Get the Correct Bounds.
int startX = getStartX();
int endX = getEndX();
int startY = getStartX();
int endY = getEndY();
// Get the Map object for this game.
ModelComponent gameWorldComponent = location;
while (!(gameWorldComponent is Gameworld))
{
gameWorldComponent = gameWorldComponent.Parent;
}
Map map = ((Gameworld)(gameWorldComponent)).GetMap();
for (int i = startX; i < endX; i++)
{
for (int j = startY; j < endY; j++)
{
CellComponent cell = map.GetCellAt(i, j);
cell.UnitAddedEvent -= new EntityInCellChangedHandler(handleUnitAddedToCell);
}
}
}
private void listenToCellsWithinVisibilityRange()
{
// Get the Correct Bounds.
int startX = getStartX();
int endX = getEndX();
int startY = getStartY();
int endY = getEndY();
// Get the Map object.
ModelComponent gameWorldComponent = location;
while (!(gameWorldComponent is Gameworld))
{
gameWorldComponent = gameWorldComponent.Parent;
}
Map map = ((Gameworld)(gameWorldComponent)).GetMap();
for (int i = startX; i <= endX; i++)
{
for (int j = startY; j <= endY; j++)
{
CellComponent cell = map.GetCellAt(i, j);
cell.UnitAddedEvent += new EntityInCellChangedHandler(handleUnitAddedToCell);
}
}
}
/*
* public functions
*/
/// <summary>
/// The core function; calls all valid auxiliary functions and returns the path (advanced features can be toggled)
/// Includes a boolean toggle for use of advanced pathfinding functions
/// </summary>
/// <param name="map">The Map</param>
/// <param name="start">The starting Cell</param>
/// <param name="end">The ending Cell</param>
/// <param name="advanced"> A boolean toggle for advanced functions</param>
/// <returns>The path as a list of waypoints</returns>
public static List<CellComponent> between(Map map, CellComponent start, CellComponent end, bool advanced)
{
// begin timing the operation
DateTime startTime = DateTime.Now;
// convert the given Cell-based data to Node-based data
NodeMap nodeMap = new NodeMap(map);
Node nodeStart = nodeMap.getNode(start.X, start.Y);
Node nodeEnd = nodeMap.getNode(end.X, end.Y);
// perform advanced pre-calculation tasks
if (advanced)
{
// if the end Node is invalid, replace it with the nearest valid Node
if (!nodeEnd.isValid)
{
nodeEnd = Advanced.nearestValidEnd(nodeMap, nodeStart, nodeEnd);
}
}
// find the path
List<Node> nodePath = Basic.findPath(nodeMap, nodeStart, nodeEnd);
// convert the path from List<Node> format back to List<Cell> format
List<CellComponent> path = new List<CellComponent>(nodePath.Count);
for (int i = 0; i < nodePath.Count; i++)
path.Add(map.GetCellAt(nodePath[i].X, nodePath[i].Y));
// grab and print path data
float dist = (float)(nodePath[nodePath.Count - 1].Gscore);
span = DateTime.Now - startTime;
//printPath(path, dist);
return path;
}
public void render()
{
TileFactory tf = TileFactory.Instance;
Bitmap pg = new Bitmap(800, 600);
Graphics gr = Graphics.FromImage(pg);
ZRTSModel.Map map = gameworld.GetMap();
// TODO: Change to include the scrolling model.
for (int x = 0; x < map.GetWidth(); x++)
{
for (int y = 0; y < map.GetHeight(); y++)
{
ZRTSModel.Tile tile = map.GetCellAt(x, y).GetTile();
if (tile != null)
{
gr.DrawImage(tf.getBitmapImproved(tile), x * 16, y * 16, 16, 16);
}
//if (map.cells[x, y] != null && map.cells[x, y].tile != null && map.cells[x, y].tile.tileType != null)
//gr.DrawImage(tf.getBitmap(map.cells[x, y].tile.tileType), x * 16, y * 16, 16, 16);
else
{
gr.DrawRectangle(new Pen(Color.Black), x * 16, y * 16, 16, 16);
}
}
}
pictureBox1.Image = pg;
}
/// <summary>
/// Variation of the takeStep method. The unit will move to the center of the targetCell. (x + 0.5f, y + 0.5f)
/// </summary>
/// <returns>true if at the end of the path, false otherwise.</returns>
private bool takeStepMiddle(UnitComponent unit)
{
bool completed = false;
// Check if we are at the center of the target Cell
if (unit.PointLocation.X == path[0].X + CENTER && unit.PointLocation.Y == path[0].Y + CENTER)
{
// Remove the next Cell in the path. If that was the last Cell, we're done
path.RemoveAt(0);
if (path.Count == 0)
{
completed = true;
}
}
// If we aren't at the center of the next Cell, and that Cell is vacant, move towards it
else if (isNextCellVacant(unit))
{
if (waiting)
{
waiting = false;
ticksWaiting = 0;
}
moveMiddle(unit);
}
// Otherwise, the next Cell in our path is not vacant; wait for a while or compute a new path
else
{
waiting = true;
ticksWaiting++;
// We've been waiting long enough, compute a new path.
if (ticksWaiting % WAIT_TICKS == 0)
{
path = FindPath.between(map, map.GetCellAt((int)unit.PointLocation.X, (int)unit.PointLocation.Y), map.GetCellAt((int)targetX, (int)targetY));
}
}
return(completed);
}
protected override void onDraw(XnaDrawArgs e)
{
// Determine all of the cells in view
ZRTSModel.Map map = ((XnaUITestGame)Game).Model.GetScenario().GetGameWorld().GetMap();
Point upperLeftCell = new Point(ScrollX / CellDimension, ScrollY / CellDimension);
Point lowerRightCell = new Point(Math.Min((ScrollX + DrawBox.Width) / CellDimension, map.GetWidth() - 1), Math.Min((ScrollY + DrawBox.Height) / CellDimension, map.GetHeight() - 1));
Point offset = new Point(ScrollX % CellDimension, ScrollY % CellDimension);
// Draw all of the tiles
for (int x = upperLeftCell.X; x <= lowerRightCell.X; x++)
{
for (int y = upperLeftCell.Y; y <= lowerRightCell.Y; y++)
{
CellComponent cell = map.GetCellAt(x, y);
Tile tile = cell.GetTile();
DrawTileVisitor drawer = new DrawTileVisitor(e.SpriteBatch, ((XnaUITestGame)Game).SpriteSheet, new Rectangle((x - upperLeftCell.X) * CellDimension - offset.X, (y - upperLeftCell.Y) * CellDimension - offset.Y, CellDimension, CellDimension));
tile.Accept(drawer);
}
}
}
private void RealizeView()
{
// Get the indices of the upper left hand cell that is visible.
int xPos = HorizontalScroll.Value / PIXELS_PER_COORDINATE;
int yPos = this.VerticalScroll.Value / PIXELS_PER_COORDINATE;
HashSet <Object> componentsToVirtualize = new HashSet <Object>();
foreach (Object o in realizedComponents.Keys)
{
componentsToVirtualize.Add(o);
}
mapPanel.SuspendLayout();
if (context != null)
{
ZRTSModel.Map map = context.GetGameWorld().GetMap();
int maxXPos = xPos + (Width / PIXELS_PER_COORDINATE) + 1;
int mapMaxX = map.GetWidth();
int maxX = Math.Min(maxXPos, mapMaxX);
int maxYPos = yPos + (Height / PIXELS_PER_COORDINATE) + 1;
int mapMaxY = map.GetHeight();
int maxY = Math.Min(maxYPos, mapMaxY);
List <Control> controlsToAdd = new List <Control>();
for (int i = xPos; i < maxX; i++)
{
for (int j = yPos; j < maxY; j++)
{
CellComponent cell = map.GetCellAt(i, j);
if (!realizedComponents.Contains(cell))
{
TileUI ui = new TileUI(controller, cell);
realizedComponents.Add(cell, ui);
ui.Location = new Point(cell.X * PIXELS_PER_COORDINATE, cell.Y * PIXELS_PER_COORDINATE);
ui.Size = new Size(PIXELS_PER_COORDINATE, PIXELS_PER_COORDINATE);
controlsToAdd.Add(ui);
}
else
{
componentsToVirtualize.Remove(cell);
}
foreach (ModelComponent m in cell.EntitiesContainedWithin)
{
if (m is Building)
{
Building building = (Building)m;
if (!realizedComponents.Contains(m))
{
BuildingUI b = new BuildingUI(controller, building);
b.Location = new Point((int)building.PointLocation.X * PIXELS_PER_COORDINATE, (int)building.PointLocation.Y * PIXELS_PER_COORDINATE);
b.Size = new Size(building.Width * PIXELS_PER_COORDINATE, building.Height * PIXELS_PER_COORDINATE);
realizedComponents.Add(building, b);
// Don't bundle the buildings or else BringToFront won't work
mapPanel.Controls.Add(b);
b.BringToFront();
}
else
{
componentsToVirtualize.Remove(m);
}
}
}
}
}
mapPanel.Controls.AddRange(controlsToAdd.ToArray());
foreach (Object o in componentsToVirtualize)
{
Control c = (Control)realizedComponents[o];
if (c is TileUI)
{
// TileUIs are set up to allow drop - turn this off so that the handle to it is destroyed and so the tileUI can be destroyed by the GC.
c.AllowDrop = false;
((TileUI)c).UnregisterFromEvents();
}
mapPanel.Controls.Remove(c);
realizedComponents.Remove(o);
}
mapPanel.ResumeLayout();
}
}
