public void GetCenterPointXYOfHexagon(int u, int v, double x, double y)
{
var pointXY = HexagonUtils.GetCenterPointXYOfHexagonLocationUV(new HexagonLocationUV(u, v), _hexagonDefinition);
Assert.Equal(x, Math.Round(pointXY.X, 2));
Assert.Equal(y, Math.Round(pointXY.Y, 2));
}
public static IEnumerable <HexagonLocationUV> GetHexagonsIntersectedByLine(PointXY startPoint, PointXY endPoint, HexagonDefinition hexagonDefinition)
{
var startHexagon = HexagonUtils.GetHexagonLocationUVForPointXY(startPoint, hexagonDefinition);
var endHexagon = HexagonUtils.GetHexagonLocationUVForPointXY(endPoint, hexagonDefinition);
var minU = new[] { startHexagon.U, endHexagon.U }.Min() - 1;
var maxU = new[] { startHexagon.U, endHexagon.U }.Max() + 1;
var minV = new[] { startHexagon.V, endHexagon.V }.Min() - 1;
var maxV = new[] { startHexagon.V, endHexagon.V }.Max() + 1;
var matchingHexagons = new List <HexagonLocationUV>();
for (var u = minU; u <= maxU; u++)
{
for (var v = minV; v <= maxV; v++)
{
var points = HexagonUtils.GetPointsXYOfHexagon(new HexagonLocationUV(u, v), hexagonDefinition);
for (var k = 0; k < points.Count() - 1; k++)
{
var p0 = points[k];
var p1 = points[k + 1];
if (GetLineIntersection(p0, p1, startPoint, endPoint) != null)
{
matchingHexagons.Add(new HexagonLocationUV(u, v));
break;
}
}
}
}
return(matchingHexagons);
}
public void GetHexagonsInsideBoundingBox()
{
IList <HexagonLocationUV> resultsA = HexagonUtils
.GetHexagonsInsideBoundingBox(new PointXY(0, -20), new PointXY(450, 100), _hexagonDefinition).ToList();
Assert.Equal(resultsA[0], new HexagonLocationUV(0, 0));
Assert.Equal(resultsA[1], new HexagonLocationUV(0, 1));
Assert.Equal(resultsA[2], new HexagonLocationUV(1, -1));
Assert.Equal(resultsA[3], new HexagonLocationUV(1, 0));
Assert.Equal(resultsA[4], new HexagonLocationUV(2, -1));
Assert.Equal(resultsA[5], new HexagonLocationUV(2, 0));
Assert.Equal(resultsA[6], new HexagonLocationUV(3, -2));
Assert.Equal(resultsA[7], new HexagonLocationUV(3, -1));
IList <HexagonLocationUV> resultsB = HexagonUtils
.GetHexagonsInsideBoundingBox(new PointXY(0, -20), new PointXY(320, 20), _hexagonDefinition).ToList();
Assert.Equal(resultsB[0], new HexagonLocationUV(0, 0));
Assert.Equal(resultsB[1], new HexagonLocationUV(1, -1));
Assert.Equal(resultsB[2], new HexagonLocationUV(1, 0));
Assert.Equal(resultsB[3], new HexagonLocationUV(2, -1));
IList <HexagonLocationUV> resultsC = HexagonUtils
.GetHexagonsInsideBoundingBox(new PointXY(150, -20), new PointXY(320, 20), _hexagonDefinition).ToList();
Assert.Equal(resultsC[0], new HexagonLocationUV(1, -1));
Assert.Equal(resultsC[1], new HexagonLocationUV(1, 0));
Assert.Equal(resultsC[2], new HexagonLocationUV(2, -1));
}
public IEnumerable <Hexagon> ProcessPath(GeoData geoData, LayersLoaderTarget[] targets = null)
{
foreach (var coordinates in geoData.Points)
{
for (var i = 0; i < coordinates.Length - 1; i++)
{
var currentPoint = coordinates[i];
var nextPoint = coordinates[i + 1];
//for each segment check intersection with the edges from the hexagons
var hexagonLocations = PathHelper.GetHexagonsIntersectedByLine(currentPoint, nextPoint, hexagonDefinition);
foreach (var hexagonLocation in hexagonLocations)
{
var hexagonPoints = HexagonUtils.GetPointsXYOfHexagon(hexagonLocation, hexagonDefinition);
for (var j = 0; j < hexagonPoints.Count - 1; j++)
{
var hexagonCurrentPoint = hexagonPoints[j];
var hexagonNextPoint = hexagonPoints[j + 1];
if (PathHelper.GetLineIntersection(currentPoint, nextPoint, hexagonCurrentPoint,
hexagonNextPoint) != null)
{
yield return(CreateHexagon(geoData, targets, hexagonLocation, (geo, target) => (int)Math.Pow(2, j)));
}
}
}
}
}
}
public async Task <bool> ExportResults(IEnumerable <Hexagon> hexagons, HexagonDefinition hexagonDefinition, MergeStrategy mergeStrategy)
{
foreach (Hexagon hexagon in hexagons)
{
string insertCommand = @"INSERT INTO HexagonLocation (U,V,PIXELX,PIXELY) VALUES (@U,@V,@PixelX,@PixelY) ON CONFLICT(U,V) DO UPDATE SET PixelX=excluded.PixelX,PixelY=excluded.PixelY";
PointXY hexagonCenter = HexagonUtils.GetCenterPointXYOfHexagonLocationUV(hexagon.LocationUV, hexagonDefinition);
await _connection.ExecuteAsync(insertCommand,
new
{
hexagon.LocationUV.U,
hexagon.LocationUV.V,
PixelX = hexagonCenter.X,
PixelY = hexagonCenter.Y
});
foreach (var key in hexagon.HexagonData.Data.Keys)
{
object dataValue = hexagon.HexagonData.Data[key];
string insertDataCommand = @"INSERT INTO HexagonData (U,V,FIELD,VALUE) VALUES (@U,@V,@Field,@Value) ON CONFLICT(U,V,FIELD) DO ";
switch (mergeStrategy)
{
case MergeStrategy.BitMask:
insertDataCommand += "UPDATE SET VALUE=VALUE|excluded.Value";
break;
case MergeStrategy.Ignore:
insertDataCommand += "NOTHING";
break;
case MergeStrategy.Replace:
insertDataCommand += "UPDATE Set Value=excluded.Value";
break;
case MergeStrategy.Max:
insertDataCommand += "UPDATE Set Value=max(excluded.Value,Value)";
break;
case MergeStrategy.Min:
insertDataCommand += "UPDATE Set Value=min(excluded.Value,Value)";
break;
}
await _connection.ExecuteAsync(insertDataCommand,
new
{
hexagon.LocationUV.U,
hexagon.LocationUV.V,
Field = key,
Value = dataValue
});
}
}
return(true);
}
public Vector3 GetMountPosition(HexCoord coord)
{
if (hexagons.ContainsKey(coord))
{
return(GetMountPosition(hexagons[coord]));
}
return(HexagonUtils.Coord2Pos(coord));
}
public void UpdateRange()
{
HexCoord c = HexagonUtils.Pos2Coord(curPosition);
var r = RangeUtils.GetRangeClient(c, range);
r.Add(c);
indicator.SetRange(r);
}
public static HashSet <HexCoord> GetRangeOfTower(TowerInfo tower, HashSet <HexCoord> vision)
{
var range = HexagonUtils.NeighborHexagons(tower.coord, tower.range);
range.IntersectWith(vision);
MapManager.Instance.RemoveHexagonsNotExists(range);
return(range);
}
public static HashSet <HexCoord> GetRange(HexCoord center, int range, HashSet <HexCoord> vision)
{
var ret = HexagonUtils.NeighborHexagons(center, range);
ret.IntersectWith(vision);
MapManager.Instance.RemoveHexagonsNotExists(ret);
return(ret);
}
void Update()
{
if (lastPosition != transform.position)
{
lastPosition = transform.position;
coord = HexagonUtils.Pos2Coord(transform.position);
}
}
public string GenerateMap(List <object> hexagons, HexagonDefinition hexagonDefinition, int hexagonReferenceZoom)
{
GeoJsonWriter writer = new GeoJsonWriter();
FeatureCollection hexagonCollection = new FeatureCollection();
foreach (IDictionary <string, object> hexagon in hexagons)
{
HexagonLocationUV locationUV = new HexagonLocationUV(Convert.ToInt32(hexagon["U"]), Convert.ToInt32(hexagon["V"]));
IList <PointXY> points = HexagonUtils.GetPointsXYOfHexagon(locationUV, hexagonDefinition);
LinearRing ring = new LinearRing(points.Select(pixelCoordinate =>
{
var(latitude, longitude) = TileSystem.PixelXYToLatLong((int)pixelCoordinate.X, (int)pixelCoordinate.Y, hexagonReferenceZoom);
return(new Coordinate(longitude, latitude));
}).ToArray());
Polygon hexagonPolygon = new Polygon(ring);
AttributesTable attributes = new AttributesTable(
new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("U", locationUV.U),
new KeyValuePair <string, object>("V", locationUV.V),
});
foreach (var key in hexagon.Keys)
{
switch (key)
{
case "U":
case "V":
break;
default:
object value = hexagon[key];
attributes.Add(key, value);
break;
}
}
Feature hexagonFeature = new Feature(hexagonPolygon, attributes);
hexagonCollection.Add(hexagonFeature);
}
//4. Export Geojson just for the hexagons in this particular tile
string result = writer.Write(hexagonCollection);
return(result);
}
public Vector2i?RegisterPawn(PawnControler pawnControler)
{
Vector2i gridCoordinate = HexagonUtils.ConvertOrthonormalToHexaSpace(pawnControler.transform.position);
if (HexData.Contains(gridCoordinate))
{
HexData[gridCoordinate].LocalPawns.Add(pawnControler);
return(gridCoordinate);
}
return(null);
}
void UpdateCampVision()
{
campVision = HexagonUtils.NeighborHexagons(campCoord, 2);
campVision.Add(campCoord);
MapManager.Instance.RemoveHexagonsNotExists(campVision);
if (isLocalPlayer)
{
visionController.SetCampVision(campVision);
visionController.RecalcVision();
}
}
void Start()
{
if (HexTerrain.Instance != null)
{
_gridPosition = HexTerrain.Instance.RegisterPawn(this);
if (_gridPosition.HasValue)
{
Vector3 newPosition = HexagonUtils.ConvertHexaSpaceToOrthonormal(_gridPosition.Value);
newPosition.y = HexTerrain.Instance.HexData[_gridPosition.Value].Height;
transform.position = newPosition;
}
}
}
public IActionResult Get(int z, int x, int y)
{
using (var destinationImage = new Image <Rgba32>(TileSize, TileSize))
{
if (z >= 7)
{
var hexSize = 500;
var size = (int)(hexSize / Math.Pow(2, 10 - z));
var hexagonDefinition = new HexagonDefinition(size, 10);
//Tile offset
var pixelX = x * TileSize;
var pixelY = y * TileSize;
var topLeft = new PointXY(pixelX - size, pixelY - size);
var bottomRight = new PointXY(pixelX + TileSize + size, pixelY + TileSize + size);
foreach (HexagonLocationUV hexagon in HexagonUtils.GetHexagonsInsideBoundingBox(topLeft, bottomRight, hexagonDefinition))
{
PointXY center = HexagonUtils.GetCenterPointXYOfHexagonLocationUV(hexagon, hexagonDefinition);
IList <PointXY> hexagonPoints = HexagonUtils
.GetHexagonPixels(size, new PointXY(center.X - pixelX, center.Y - pixelY)).ToList();
PointF[] points = hexagonPoints.Select(p => new PointF((float)p.X, (float)p.Y)).ToArray();
destinationImage.Mutate(ctx => ctx
.DrawLines(
new Rgba32(200, 200, 200, 200),
5,
points)
.DrawLines(
new Rgba32(100, 100, 100, 200),
2,
points));
}
}
Stream outputStream = new MemoryStream();
destinationImage.Save(outputStream, new PngEncoder());
outputStream.Seek(0, SeekOrigin.Begin);
return(this.File(outputStream, "image/png"));
}
}
public void BuildChunks()
{
Debug.Log("Build chunk array");
// Create Chunk array
_chunks = new Chunk[ChunkCol * ChunkRow];
for (int i = 0; i < ChunkCol; i++)
{
for (int j = 0; j < ChunkRow; j++)
{
_chunks[i * ChunkRow + j] = MakeNewChunk(HexagonUtils.ConvertHexaSpaceToOrthonormal(new Vector2i(j * chunkWidth, i * chunkLength)),
new Vector2i(j * chunkWidth, i * chunkLength));
}
}
}
public bool EditHexagon(Vector3 initialWorldCoordinate, Vector3 endWorldCoordinate,
int typeID, float height, PaintLayer paintLayer)
{
bool isDirty = false;
Vector2i initialGridCoordinate = HexagonUtils.ConvertOrthonormalToHexaSpace(initialWorldCoordinate);
Vector2i endGridCoordinate = HexagonUtils.ConvertOrthonormalToHexaSpace(endWorldCoordinate);
IEnumerable <Vector2i> line = HexagonUtils.GetLine(initialGridCoordinate, endGridCoordinate);
foreach (Vector2i gridCoordinate in line)
{
isDirty |= EditHexagon(gridCoordinate, typeID, height, paintLayer);
}
return(isDirty);
}
/// <summary>
/// Add the geometry of this Hexagon inside the MeshData structure of the calling Chunk.
/// </summary>
/// <param name="meshData">MeshData structure to be filed </param>
/// <param name="chunkOffSet">world offset of the parent chunk </param>
/// <param name="coordinate">2d grid coordinate of this hexa relative to its chunk </param>
/// <param name="neighbours"> Array containing the 6 neighbours of this hex, some can be null</param>
public void AddToChunk(ref Chunk.MeshData meshData, Vector3 chunkOffSet, Vector2i coordinate,
Hexagon[] neighbours, HexagonTypeData types)
{
//TODO: compute top vertex position of this hexagon at start to avoid multiple recomputation.
// Compute hexagon position.
Vector3 coordinateOffset = HexagonUtils.ConvertHexaSpaceToOrthonormal(coordinate) + chunkOffSet;
GenerateTop(ref meshData, coordinateOffset, types, neighbours);
for (int i = 0; i < 6; i++)
{
if (IsSideVisible(neighbours[i], types))
{
GenerateSide(ref meshData, coordinateOffset, i, neighbours, types);
}
}
}
public void AddTower(TowerInfo t)
{
if (t.type != TowerType.VisionTower)
{
return;
}
if (!visionTowers.Contains(t))
{
visionTowers.Add(t);
}
var v = HexagonUtils.NeighborHexagons(t.coord, t.vision);
v.Add(t.coord);
MapManager.Instance.RemoveHexagonsNotExists(v);
Vision.UnionWith(v);
}
public HashSet <HexCoord> GetHexagonsInRange(int playerSlotId, TowerType type, Func <TowerInfo, int> rangeFunc)
{
HashSet <HexCoord> ret = new HashSet <HexCoord>();
var towerList = GetTowersOfType(playerSlotId, type);
foreach (var t in towerList)
{
if (MapManager.Instance.Exists(t.coord))
{
ret.Add(t.coord);
}
var set = HexagonUtils.NeighborHexagons(t.coord, rangeFunc(t));
MapManager.Instance.RemoveHexagonsNotExists(set);
ret.UnionWith(set);
}
return(ret);
}
public IEnumerable <Hexagon> ProcessArea(GeoData geoData, LayersLoaderTarget[] targets = null)
{
foreach (PointXY[] geoCoordinates in geoData.Points)
{
var topLeftCoordinate = new PointXY(geoCoordinates.Min(c => c.X), geoCoordinates.Min(c => c.Y));
var bottomRightCoordinate = new PointXY(geoCoordinates.Max(c => c.X), geoCoordinates.Max(c => c.Y));
var hexagonLocations = HexagonUtils.GetHexagonsInsideBoundingBox(topLeftCoordinate, bottomRightCoordinate, hexagonDefinition);
foreach (var hexagonLocation in hexagonLocations)
{
var center = HexagonUtils.GetCenterPointXYOfHexagonLocationUV(hexagonLocation, hexagonDefinition);
if (AreaHelper.IsPointInsidePolygon(center.X, center.Y, geoCoordinates))
{
yield return(CreateHexagon(geoData, targets, hexagonLocation, (geo, target) => geo.Values[target.SourceField]));
}
}
}
}
void GenerateGeometry()
{
//Debug.Log("Generate geometry " + gameObject.name + ".");
MeshData meshData = new MeshData();
meshData.Init(_hexTerrain.Types.Count * 2);
for (int yi = 0; yi < _height; yi++)
{
for (int xi = 0; xi < _width; xi++)
{
if (_hexTerrain.HexData.Contains(xi + _chunkGridOffset.x, yi + _chunkGridOffset.y))
{
if (_hexTerrain.HexData[yi + _chunkGridOffset.y, xi + _chunkGridOffset.x] != null)
{
Vector2i coordinate = new Vector2i(xi, yi);
Hexagon hexa = _hexTerrain.HexData[yi + _chunkGridOffset.y, xi + _chunkGridOffset.x];
hexa.AddToChunk(ref meshData, Vector3.zero, coordinate,
HexagonUtils.GetNeighbours(coordinate + _chunkGridOffset, _hexTerrain.HexData),
_hexTerrain.Types);
}
}
}
}
// Setup meshFilter.
_mesh.Clear();
_mesh.subMeshCount = meshData.triangles.Length;
_mesh.vertices = meshData.vertices.ToArray();
//_mesh.normals = _meshData.normals.ToArray();
_mesh.uv = meshData.uvs.ToArray();
for (int i = 0; i < meshData.triangles.Length; i++)
{
_mesh.SetTriangles(meshData.triangles[i].ToArray(), i);
}
_mesh.colors32 = meshData.colors.ToArray();
_mesh.RecalculateNormals();
IsDirty = false;
}
void OnPlayerInfoUpdate(PlayerInfo value)
{
bool campChanged = (playerInfo.camp != value.camp);
playerInfo = value;
if (campCoord != playerInfo.camp)
{
campCoord = playerInfo.camp;
UpdateCampVision();
}
if (isLocalPlayer)
{
UIController.Instance.SetResource(playerInfo.resource);
UIController.Instance.SetProduction(playerInfo.production);
UIController.Instance.SetCost(playerInfo.cost);
var towerTemplates = TowerManager.Instance.towerList;
for (int i = 0; i < towerTemplates.Length; i++)
{
UIController.Instance.SetBuildButtonEnable(i, towerTemplates[i].price <= playerInfo.resource);
}
if (campChanged)
{
StartCoroutine(WaitForAndThen(
delegate()
{
return(FindObjectOfType <CameraPanner>() != null);
},
delegate()
{
FindObjectOfType <CameraPanner>().setCameraFocus(HexagonUtils.Coord2Pos(value.camp));
}
));
}
}
}
public void GetPointsXYOfHexagon()
{
IList <PointXY> points = HexagonUtils.GetPointsXYOfHexagon(new HexagonLocationUV(0, 0), _hexagonDefinition);
Assert.Equal(-100, points[0].X);
Assert.Equal(0, points[0].Y);
Assert.Equal(-50, points[1].X);
Assert.Equal(-86.6, Math.Round(points[1].Y, 2));
Assert.Equal(50, points[2].X);
Assert.Equal(-86.6, Math.Round(points[2].Y, 2));
Assert.Equal(100, points[3].X);
Assert.Equal(0, points[3].Y);
Assert.Equal(50, points[4].X);
Assert.Equal(86.6, Math.Round(points[4].Y, 2));
Assert.Equal(-50, points[5].X);
Assert.Equal(86.6, Math.Round(points[5].Y, 2));
}
private IEnumerable <Hexagon> ProcessPixel(GeoData geoData, LayersLoaderTarget[] targets)
{
foreach (PointXY[] coordinates in geoData.Points)
{
if (coordinates.Length == 1)
//Single point mode
{
var hexagonLocation = HexagonUtils.GetHexagonLocationUVForPointXY(coordinates[0], hexagonDefinition);
yield return(CreateHexagon(geoData, targets, hexagonLocation, (geo, target) => target.Handler == null ? 1 : valueHandlerFactory.GetInstance(target.Handler).GetValue(geo)));
}
else
//Square mode
{
IList <HexagonLocationUV> hexagons = HexagonUtils.GetHexagonsInsideBoundingBox(coordinates[0], coordinates[1], hexagonDefinition).ToList();
foreach (var hexagonLocation in hexagons)
{
yield return(CreateHexagon(geoData, targets, hexagonLocation, (geo, target) => target.Handler == null ? 1 : valueHandlerFactory.GetInstance(target.Handler).GetValue(geo)));
}
}
}
}
public void GetHexagonLocationUVForPointXY(double x, double y, int u, int v)
{
var hexagonLocationUV = HexagonUtils.GetHexagonLocationUVForPointXY(new PointXY(x, y), _hexagonDefinition);
Assert.Equal(new HexagonLocationUV(u, v), hexagonLocationUV);
}
void Start()
{
renderer = GetComponent <Renderer>();
coord = HexagonUtils.Pos2Coord(transform.position);
lastPosition = transform.position;
}
public bool EditHexagon(Vector3 worldCoordinate, int typeID, float height, PaintLayer paintLayer)
{
Vector2i gridCoordinate = HexagonUtils.ConvertOrthonormalToHexaSpace(worldCoordinate);
return(EditHexagon(gridCoordinate, typeID, height, paintLayer));
}
public void IsPointXYInsideHexagonLocationUV(double x, double y, int u, int v, bool isInside)
{
var result = HexagonUtils.IsPointXYInsideHexagonLocationUV(new PointXY(x, y), new HexagonLocationUV(u, v), _hexagonDefinition);
Assert.Equal(isInside, result);
}
public void UpdateCoord()
{
coord = HexagonUtils.Pos2Coord(transform.position);
transform.position = HexagonUtils.Coord2Pos(coord);
}
