Point HexOrigin(SizeF gridSize, ICoordsUser coords)
{
return(new Point(
(int)(GridSize.Width * coords.X),
(int)(GridSize.Height * coords.Y + GridSize.Height / 2 * (coords.X + 1) % 2)
));
}
} // TODO: Set this to FOVRange perhaps?
public static IPath2 FindPath(
ICoordsUser start,
ICoordsUser goal,
INavigableBoard board
)
{
return(FindPath(start, goal, board.StepCost, board.Heuristic, board.IsOnBoard));
}
public bool this[ICoordsUser coords] {
get { return(Board.IsOnBoard(coords) && FovBacking[coords.X, coords.Y]); }
set { if (Board.IsOnBoard(coords))
{
FovBacking[coords.X, coords.Y] = value;
}
}
} bool[,] FovBacking;
private Path2(Path2 previousSteps, ICoordsUser thisStep, Hexside direction, uint totalCost, int count)
{
_previousSteps = previousSteps;
LastDirection = direction;
LastStep = thisStep;
Count = count;
TotalCost = totalCost;
TotalSteps = previousSteps == null ? 0 : previousSteps.TotalSteps + 1;
}
/// <summary>Returns ScrollPosition that places given hex in the upper-Left of viewport.</summary>
/// <param name="coordsNewULHex">User (ie rectangular) hex-coordinates for new upper-left hex</param>
/// <returns>Pixel coordinates in Client reference frame.</returns>
public Point HexCenterPoint(ICoordsUser coordsNewULHex)
{
if (coordsNewULHex == null)
{
return(new Point());
}
var offset = new Size((int)(GridSize.Width * 2F / 3F), (int)GridSize.Height);
var margin = Size.Round(MapMargin.Scale(MapScale));
return(TransposePoint(HexOrigin(GridSize, coordsNewULHex) + margin + offset));
}
public static IFieldOfView GetFieldOfView(IBoard <IGridHex> board, ICoordsUser origin, int range,
FovTargetMode targetMode)
{
DebugTracing.LogTime(TraceFlag.FieldOfView, "FieldOfView - begin");
var fov = new FieldOfView(board);
if (board.IsPassable(origin))
{
Func <ICoordsCanon, int> target;
int observer;
switch (targetMode)
{
case FovTargetMode.EqualHeights:
observer = board[origin].ElevationASL + 1;
target = canon => board[canon.User].ElevationASL + 1;
break;
case FovTargetMode.TargetHeightEqualZero:
observer = board[origin].HeightObserver;
target = canon => board[canon.User].ElevationASL;
break;
default:
case FovTargetMode.TargetHeightEqualActual:
observer = board[origin].HeightObserver;
target = canon => board[canon.User].HeightTarget;
break;
}
ShadowCasting.ComputeFieldOfView(
origin.Canon,
range,
observer,
canon => board.IsOnBoard(canon.User),
target,
canon => board[canon.User].HeightTerrain,
canon => fov[canon.User] = true
);
}
DebugTracing.LogTime(TraceFlag.FieldOfView, "FieldOfView - end");
return(fov);
}
public static TerrainGridHex GetGridHex(char value, ICoordsUser coords)
{
switch (value)
{
default: return(new ClearTerrainGridHex(value, coords));
case '2': return(new RoadTerrainGridHex(value, coords));
case '3': return(new TrailTerrainGridHex(value, coords));
case 'R': return(new RiverTerrainGridHex(value, coords));
case 'W': return(new WoodsTerrainGridHex(value, coords));
case 'F': return(new FordTerrainGridHex(value, coords));
case 'H': return(new HillTerrainGridHex(value, coords));
case 'M': return(new MountainTerrainGridHex(value, coords));
}
}
public abstract IMapGridHex this[ICoordsUser coords] {
get;
}
IGridHex IBoard <IGridHex> .this[ICoordsUser coords] {
get { return(this[coords]); }
}
public static IPath2 FindPath(
ICoordsUser start,
ICoordsUser goal,
Func <ICoordsCanon, Hexside, int> stepCost,
Func <int, int> heuristic,
Func <ICoordsUser, bool> isOnBoard
)
{
var vectorGoal = goal.Canon.Vector - start.Canon.Vector;
var closed = new HashSet <ICoordsUser>();
var queue = goal.Range(start) > RangeCutoff
? (IPriorityQueue <uint, Path2>) new HeapPriorityQueue <uint, Path2>()
: (IPriorityQueue <uint, Path2>) new DictPriorityQueue <uint, Path2>();
#if DEBUG
TraceFlag.FindPath.Trace(true, "Find path from {0} to {1}; vectorGoal = {0}",
start.Canon, goal.Canon, vectorGoal);
#endif
queue.Enqueue(0, new Path2(start));
while (!queue.IsEmpty)
{
var oldPref = queue.Peek().Key & 0xFFFF;
var path = queue.Dequeue();
if (closed.Contains(path.LastStep))
{
continue;
}
#if DEBUG
var previous = (path.PreviousSteps) == null ? HexCoords.EmptyUser : path.PreviousSteps.LastStep;
TraceFlag.FindPath.Trace("Dequeue Path at {0} from {3} w/ cost={1,4}:{2,3}.",
path.LastStep, path.TotalCost, oldPref, previous);
#endif
if (path.LastStep != null && path.LastStep.Equals(goal))
{
return(path);
}
closed.Add(path.LastStep);
foreach (var neighbour in path.LastStep.GetNeighbours(~Hexside.None))
{
if (isOnBoard(neighbour.Coords.User))
{
var cost = stepCost(path.LastStep.Canon, neighbour.Direction);
if (cost > 0)
{
var preference = (ushort)Math.Abs(vectorGoal ^ (goal.Canon.Vector - neighbour.Coords.Vector));
var newPath = path.AddStep(neighbour.Coords.User, (ushort)cost, neighbour.Direction);
var estimate = ((uint)heuristic(goal.Range(neighbour.Coords.User))
+ (uint)newPath.TotalCost) << 16;
queue.Enqueue(estimate + preference, newPath);
#if DEBUG
TraceFlag.FindPath.Trace(" Enqueue {0}: {1,4}:{2,3}",
neighbour.Coords, estimate >> 16, preference);
#endif
}
}
}
}
return(null);
}
/// <summary>Returns the scroll position to center a specified hex in viewport.</summary>
/// <param name="coordsNewCenterHex">ICoordsUser for the hex to be centered in viewport.</param>
/// <returns>Pixel coordinates in Client reference frame.</returns>
protected Point ScrollPositionToCenterOnHex(ICoordsUser coordsNewCenterHex)
{
return(HexCenterPoint(HexCoords.NewUserCoords(
coordsNewCenterHex.Vector - (new IntVector2D(VisibleRectangle.Size.Vector) / 2)
)));
}
public HillTerrainGridHex(char value, ICoordsUser coords) : base(value, coords)
{
}
public string HexText(ICoordsUser coords)
{
return(HexText(coords.X, coords.Y));
}
public override bool IsPassable(ICoordsUser coords)
{
return(IsOnBoard(coords) && this[coords].Elevation == 0);
}
private Path2(Path2 previousSteps, ICoordsUser thisStep, Hexside direction, uint totalCost)
: this(previousSteps, thisStep, direction, totalCost, 0)
{
}
public MapGridHex(char value, ICoordsUser coords)
{
Value = value; Coords = coords;
}
public override IMapGridHex this[ICoordsUser coords] {
get {
return(new GridHex(Board[coords.Y][coords.X], coords));
}
}
public bool IsOnBoard(ICoordsUser coords)
{
return(0 <= coords.X && coords.X < SizeHexes.Width &&
0 <= coords.Y && coords.Y < SizeHexes.Height);
}
public static IFieldOfView GetFieldOfView(IBoard <IGridHex> board, ICoordsUser origin, int range)
{
return(GetFieldOfView(board, origin, range, FovTargetMode.EqualHeights));
}
public virtual bool IsPassable(ICoordsUser coords)
{
return(IsOnBoard(coords));
}
public Path2 AddStep(ICoordsUser step, uint stepCost, Hexside direction)
{
return(new Path2(this, step, direction, TotalCost + stepCost));
}
public UserCoordsRectangle(ICoordsUser location, ICoordsUser size)
: this(new Rectangle(location.Vector, size.Vector))
{
}
public Path2(ICoordsUser start) : this(null, start, Hexside.None, 0)
{
}
public HexEventArgs(ICoordsUser coords, MouseEventArgs e, Keys modifierKeys)
: base(e.Button, e.Clicks, e.X, e.Y, e.Delta)
{
Coords = coords;
ModifierKeys = modifierKeys;
}
public HexEventArgs(ICoordsUser coords)
: this(coords, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0))
{
}
public MountainTerrainGridHex(char value, ICoordsUser coords) : base(value, coords)
{
}
public GridHex(char value, ICoordsUser coords) : this()
{
Value = value; Coords = coords;
}
public HexEventArgs(ICoordsUser coords, Keys modifierKeys)
: this(coords, new MouseEventArgs(MouseButtons.None, 0, 0, 0, 0), modifierKeys)
{
}
int ICoordsUser.Range(ICoordsUser coords)
{
return(Range(coords.Canon));
}
public HexEventArgs(ICoordsUser coords, MouseEventArgs e)
: this(coords, e, Keys.None)
{
}
