public IMap<TPoint> AlignBottomRight(IGridSpace<TPoint> grid)
{
return
AlignRight(grid)
.WithWindow(window)
.AlignBottom(grid);
}
public IMap<TPoint> AlignTopLeft(IGridSpace<TPoint> grid)
{
return
AlignLeft(grid)
.WithWindow(window)
.AlignTop(grid);
}
public IMap<TPoint> AlignMiddleCenter(IGridSpace<TPoint> grid)
{
return
AlignCenter(grid)
.WithWindow(window)
.AlignMiddle(grid);
}
public IMap <TPoint> AlignTopRight(IGridSpace <TPoint> grid)
{
return
(AlignRight(grid)
.WithWindow(window)
.AlignTop(grid));
}
public IMap<TPoint> AlignMiddleRight(IGridSpace<TPoint> grid)
{
return
AlignMiddle(grid)
.WithWindow(window)
.AlignRight(grid);
}
public IMap <TPoint> AlignBottomLeft(IGridSpace <TPoint> grid)
{
return
(AlignLeft(grid)
.WithWindow(window)
.AlignBottom(grid));
}
public IMap <TPoint> AlignTop(IGridSpace <TPoint> grid)
{
var gridSize = leftMap.CalcGridDimensions(grid);
var anchorPosition = leftMap.CalcBottomLeft(grid);
return(TranslateY(window.y + window.height - gridSize.y - anchorPosition.y + leftMap.GetAnchorTranslation().y));
}
public Vector2 CalcAnchorDimensions(IGridSpace <TPoint> grid)
{
if (!grid.Any())
{
return(Vector2.zero);
}
var rawGrid = grid.Select(point => InverseGridPointTransform(point));
var rawGridAsList = rawGrid as IList <TPoint> ?? rawGrid.ToList();
var firstPoint = rawGridAsList.First();
var worldPoint = GridToWorld(firstPoint);
var minX = worldPoint.x;
var maxX = worldPoint.x;
var minY = worldPoint.y;
var maxY = worldPoint.y;
foreach (var point in rawGridAsList.ButFirst())
{
worldPoint = GridToWorld(point);
minX = Mathf.Min(minX, worldPoint.x);
maxX = Mathf.Max(maxX, worldPoint.x);
minY = Mathf.Min(minY, worldPoint.y);
maxY = Mathf.Max(maxY, worldPoint.y);
}
var width = maxX - minX;
var height = maxY - minY;
return(new Vector2(width, height));
}
public ArchimedeanSpiralMap(Vector2 cellDimensions, IGridSpace <LinePoint> grid)
: base(cellDimensions)
{
lookUpWorld = grid.Select(p => this[p]).ToArray();
lookUpGrid = grid.ToArray();
notInGrid = grid.Last().Translate(LinePoint.Right);
}
public IMap<TPoint> AlignBottomCenter(IGridSpace<TPoint> grid)
{
return
AlignCenter(grid)
.WithWindow(window)
.AlignBottom(grid);
}
public IMap <TPoint> AlignTopCenter(IGridSpace <TPoint> grid)
{
return
(AlignCenter(grid)
.WithWindow(window)
.AlignTop(grid));
}
virtual public Vector2 CalcBottomLeft(IGridSpace <TPoint> grid)
{
if (!grid.Any())
{
return(Vector2.zero);
}
var rawGrid = grid.Select(point => InverseGridPointTransform(point));
var rawGridAsList = rawGrid as IList <TPoint> ?? rawGrid.ToList();
var firstPoint = rawGridAsList.First();
var halfCellDimensions = GetCellDimensions(firstPoint) / 2;
var worldPoint = GridToWorld(firstPoint);
var minX = worldPoint.x - halfCellDimensions.x;
var minY = worldPoint.y - halfCellDimensions.y;
foreach (var point in rawGridAsList.ButFirst())
{
halfCellDimensions = GetCellDimensions(point) / 2;
worldPoint = GridToWorld(point);
minX = Mathf.Min(minX, worldPoint.x - halfCellDimensions.x);
minY = Mathf.Min(minY, worldPoint.y - halfCellDimensions.y);
}
return(new Vector2(minX, minY));
}
public IMap <TPoint> AlignRight(IGridSpace <TPoint> grid)
{
var gridSize = leftMap.CalcGridDimensions(grid);
var anchorPosition = leftMap.CalcBottomLeft(grid);
return(TranslateX(window.x + window.width - gridSize.x - anchorPosition.x + leftMap.GetAnchorTranslation().x));
}
public IMap <TPoint> AlignMiddleLeft(IGridSpace <TPoint> grid)
{
return
(AlignMiddle(grid)
.WithWindow(window)
.AlignLeft(grid));
}
public IMap <TPoint> AlignMiddle(IGridSpace <TPoint> grid)
{
var gridSize = leftMap.CalcGridDimensions(grid);
var anchorPosition = leftMap.CalcBottomLeft(grid);
var offsetY = window.y + (window.height - gridSize.y) / 2 - anchorPosition.y + leftMap.GetAnchorTranslation().y;
return(TranslateY(offsetY));
}
public ImageMap(Rect imageRect, IGridSpace<TPoint> grid, IMap<TPoint> map)
{
this.imageRect = imageRect;
this.map = map;
gridDimensions = map.CalcGridDimensions(grid);
anchorPoint = map.GetAnchorTranslation();
}
public static GridType GetGridType(this IGridSpace space)
{
if (space == null)
{
return(GridType.NULL);
}
return(space.Type);
}
public IMap <TPoint> AlignCenter(IGridSpace <TPoint> grid)
{
var gridSize = leftMap.CalcGridDimensions(grid);
var anchorPosition = leftMap.CalcBottomLeft(grid);
var offsetX = window.x + (window.width - gridSize.x) / 2 - anchorPosition.x + leftMap.GetAnchorTranslation().x;
return(TranslateX(offsetX));
}
public void Initialize()
{
_levels = new Level[_maxLevels];
ArrayExt.Converters[typeof(GridType)] = (b) => { return(GridTypeEnum.Convert((GridType)b)); };
ArrayExt.Converters[typeof(GridSpace)] = (b) =>
{
GridSpace s = b as GridSpace;
if (s == null)
{
return(GridTypeEnum.Convert(GridType.NULL));
}
return(GridTypeEnum.Convert(s.Type));
};
ArrayExt.Converters[typeof(GenSpace)] = (b) =>
{
GenSpace s = b as GenSpace;
if (s == null)
{
return(GridTypeEnum.Convert(GridType.NULL));
}
return(s.GetChar());
};
ArrayExt.Converters[typeof(IGridSpace)] = (b) =>
{
IGridSpace s = b as IGridSpace;
if (s == null)
{
return(GridTypeEnum.Convert(GridType.NULL));
}
if (s is GenSpace)
{
return(((GenSpace)s).GetChar());
}
return(GridTypeEnum.Convert(s.Type));
};
if (Seed == -1)
{
Seed = Probability.Rand.Next();
}
System.Random rand = new System.Random(Seed);
for (int i = 0; i < _maxLevels; i++)
{
_levelSeeds[i] = rand.Next();
}
LevelBuilder.Initialize();
foreach (IInitializable init in this.FindAllDerivedObjects <IInitializable>())
{
init.Init();
}
#region DEBUG
if (BigBoss.Debug.logging(Logs.LevelGenMain))
{
BigBoss.Debug.w(Logs.LevelGenMain, "Random seed int: " + Seed);
}
#endregion
}
public IMap <TPoint> Stretch(IGridSpace <TPoint> grid)
{
var gridDimensions = CalcGridDimensions(grid);
var anchorPoint = GetAnchorTranslation();
return
(Translate(-anchorPoint)
.Scale((window.width / gridDimensions.x), (window.height / gridDimensions.y))
.Translate(window.xMin, window.yMin));
}
public override Vector2 CalcGridDimensions(IGridSpace <PointyHexPoint> grid)
{
return(new Vector2(2 * OuterRadius, 2 * OuterRadius));
}
public static IMap <TPoint> AlignMiddelLeft <TPoint>(WindowedMap <TPoint> map, IGridSpace <TPoint> grid)
where TPoint : IGridPoint <TPoint>
{
return(map.AlignMiddleLeft(grid));
}
public static IMap <TPoint> AlignMiddelCenter <TPoint>(this WindowedMap <TPoint> map, IGridSpace <TPoint> grid)
where TPoint : IGridPoint <TPoint>
{
return(map.AlignMiddleCenter(grid));
}
public override Vector2 CalcBottomLeft(IGridSpace <PointyHexPoint> grid)
{
return(Center - new Vector2(OuterRadius, OuterRadius));
}
public IMap <TPoint> AlignBottom(IGridSpace <TPoint> grid)
{
var anchorPosition = leftMap.CalcBottomLeft(grid);
return(TranslateY(window.y - anchorPosition.y + leftMap.GetAnchorTranslation().y));
}
public IMap <TPoint> AlignLeft(IGridSpace <TPoint> grid)
{
var anchorPosition = leftMap.CalcBottomLeft(grid);
return(TranslateX(window.x - anchorPosition.x + leftMap.GetAnchorTranslation().x));
}
