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); }