public void SetRoadCell(int hash, RoadCell rc) { bool changed = false; if (rc.type > 0) { if (m_Road.ContainsKey(hash)) { RoadCell old = m_Road[hash]; if (!rc.Equals(old)) { m_Road[hash] = rc; changed = true; } } else { m_Road.Add(hash, rc); changed = true; } } else { if (m_Road.ContainsKey(hash)) { m_Road.Remove(hash); changed = true; } } if (changed && OnTileDot != null) { OnTileDot(hash, rc); } }
public void AlterRoadCell(Vector3 world_pos, RoadCell rc) { int tile_hash = RSTile.QueryTile(world_pos).hash; int cell_hash = RSTile.WorldPosToRoadCellPos_s(tile_hash, world_pos).hash; AlterRoadCell(tile_hash, cell_hash, rc); }
private void RenderPathToMap(RoadCell pathCell) { while (pathCell != null) { RenderVectorSquare(pathCell, 255, 0, 0); pathCell = pathCell.Previous; } }
private void GenerateRoad(RoadCell pointA, RoadCell pointB, RoadCellMap roadMap) { var end = roadMap.BuildPath(pointA, pointB).Result; //var path = roadMap.BuildPathUsingAStar(pointA, pointB); RenderPathToMap(pointB); RenderVectorSquare(pointA, 0, 255, 0); RenderVectorSquare(pointB, 0, 255, 0); }
private bool ConsiderRoute( RoadCell pointA, RoadCell pointB) { try { if (pointA.Previous == pointB) { return(false); //We've backtracked completely } if ((int)pointB.DistanceFromOrigin == 0) { pointB.DistanceFromOrigin = GetDirectLineDistance(_origin, pointB); } if (pointB != _destination && pointB.DistanceFromOrigin <= pointA.DistanceFromOrigin) { return(false); //We're circling back } //_logger.Info($"At [{pointB.X},{pointB.Z}] {pointB.DistanceFromOrigin} from Origin"); var costFromOrigin = pointA.CostFromOrigin + _getPathCost(pointA, pointB); if (costFromOrigin > _destination.CostFromOrigin) { return(false); } // PointB has already been hit on different route, only redirect when the // cost is lower. if (pointB.Previous != null && pointB.CostFromOrigin <= costFromOrigin) { return(false); } // PointA already has a route assigned, only update it when the cost is lower if (pointA.Next != null && pointA.Next.CostFromOrigin <= costFromOrigin) { return(false); } pointB.Previous = pointA; pointA.Next = pointB; pointB.CostFromOrigin = costFromOrigin; if (pointB == _destination) { _maximumCost = costFromOrigin; //_logger.Warn($"Found a faster route to destination [{pointA.X},{pointA.Z}] Cost: {_maximumCost}"); return(false); } return(pointA != pointB); } catch (Exception exp) { _logger.Error(exp); throw; } }
public void DotTextures(int hash, RoadCell rc) { if (!m_Started) { return; } int mask = WriteRoadCellToTextures(hash, rc); ApplyTexturesChange(mask); }
public async Task <RoadCell> BuildPath(RoadCell from, RoadCell to) { _origin = from; _destination = to; _getPathCost = (cell, roadCell) => WalkDirectEstimate(cell, roadCell, GetWeightedUnitDistance); _destination.CostFromOrigin = double.MaxValue; _maximumCost = _getPathCost(_origin, _destination); _getNeighbours = Get4RadiusNeighbours; await PathFindingUsingLinkedCells(from); return(to); }
RoadCell CreateCell(Cell cellData) { RoadCell roadcell = DataController.Instance.GetRoadCell(); roadcell.transform.SetParent(grid.transform, false); roadcell.setMaterial(cellData.material); roadcell.name = cellData.name; roadDirections = new bool[cellData.directions.Length]; Array.Copy(cellData.directions, roadDirections, roadDirections.Length); return(roadcell); }
private Vector2 <float> GetWalkerFactors(RoadCell origin, RoadCell destination) { var xDistance = destination.X - origin.X; var zDistance = destination.Z - origin.Z; var factors = new Vector2 <float>(Math.Sign(xDistance), Math.Sign(zDistance)); if (Math.Abs(xDistance) > Math.Abs(zDistance)) { factors.Z = (float)zDistance / (float)Math.Abs(xDistance); } if (Math.Abs(zDistance) > Math.Abs(xDistance)) { factors.X = (float)xDistance / (float)Math.Abs(zDistance); } return(factors); }
public override bool Equals(object obj) { if (null == obj) { return(false); } if (obj is RoadCell) { RoadCell rc = (RoadCell)obj; return(color_type.r == rc.color_type.r && color_type.g == rc.color_type.g && color_type.b == rc.color_type.b && color_type.a == rc.color_type.a); } return(false); }
private IEnumerable <RoadCell> GetRadiusNeighbours(RoadCell origin, List <Vector2 <int> > offSets, double backTrackDistanceCheck) { try { var neighbours = offSets .Select(vector2 => new Vector2 <int>(vector2.X + origin.X, vector2.Z + origin.Z)); return(neighbours .Where(vector2 => vector2.X > 0 && vector2.X < _size && vector2.Z > 0 && vector2.Z < _size) .Select(vector2 => _map[vector2.X, vector2.Z])); } catch (Exception exp) { _logger.Error(exp); throw; } }
void SetCellToTheGrid() { if (isAvailableToSet) { //set up previous cell currentCell.Location.name = currentCell.name; currentCell.Location.SetAchievableNeighbors(roadDirections); ActivateLocationsIfNeeded(); //get new cell currentCell = GetRandomCell(); if (currentCell == null) { GameManager.Instance.RunNextStrategy(); } } }
public RoadCell GetCellMetrics(int x, int z) { var mapX = x * _cellSize; var mapZ = z * _cellSize; var cellBoundary = _cellSize - 1; var metrics = new RoadCell() { Avg = (( _heightMap[mapX + cellBoundary, mapZ] + _heightMap[mapX + cellBoundary, mapZ + cellBoundary] + _heightMap[mapX, mapZ + cellBoundary] + _heightMap[mapX, mapZ]) / 4), X = x, Z = z }; return(metrics); }
private double GetWeightedUnitDistance(RoadCell pointA, RoadCell pointB) { //var directLineDistance = GetDirectLineDistance(pointA, pointB); var heightDifference = Math.Abs(pointA.Avg - pointB.Avg); //return heightDifference; /* * var weightedDifference = Math.Pow(2, Math.Min(32, heightDifference / 124)); * return weightedDifference;// * (directLineDistance / distanceFactor); */ if (heightDifference < _elevationFactor) { return(heightDifference); } var heightFactor = 1 + Math.Min(8, Math.Floor(heightDifference / 256)); return(heightFactor * heightDifference); }
private IEnumerable <RoadCell> Get8Neighbours(RoadCell fromCell) { var neighbours = new List <RoadCell>(); if (fromCell.X > 0) { neighbours.Add(_map[fromCell.X - 1, fromCell.Z]); if (fromCell.Z > 0) { neighbours.Add(_map[fromCell.X - 1, fromCell.Z - 1]); } if (fromCell.Z < _size - 1) { neighbours.Add(_map[fromCell.X - 1, fromCell.Z + 1]); } } if (fromCell.X < _size - 1) { neighbours.Add(_map[fromCell.X + 1, fromCell.Z]); if (fromCell.Z > 0) { neighbours.Add(_map[fromCell.X + 1, fromCell.Z - 1]); } if (fromCell.Z < _size - 1) { neighbours.Add(_map[fromCell.X + 1, fromCell.Z + 1]); } } if (fromCell.Z > 0) { neighbours.Add(_map[fromCell.X, fromCell.Z - 1]); } if (fromCell.Z < _size - 1) { neighbours.Add(_map[fromCell.X, fromCell.Z + 1]); } return(neighbours); }
public async Task PathFindingUsingLinkedCells( RoadCell waypoint ) { try { if (waypoint.CostFromOrigin > _maximumCost) { _logger.Info("Too Costly - Bailing out"); } else if (GetDirectLineDistance(waypoint, _destination) < distanceFactor) { ConsiderRoute(waypoint, _destination); } else { var neighbors = _getNeighbours(waypoint).ToList(); foreach (var neighbor in neighbors) { if (neighbor != null) { if (ConsiderRoute(waypoint, neighbor)) { await PathFindingUsingLinkedCells(neighbor); } } else { _logger.Info("Neighbor is null?"); } } } } catch (Exception exp) { _logger.Error(exp); throw; } }
private double WalkDirectEstimate(RoadCell arg, RoadCell destination, Func <RoadCell, RoadCell, double> getRouteCost) { try { var walker = new Vector2 <int>(arg.X, arg.Z); var previousCell = arg; var factors = GetWalkerFactors(arg, destination); double totalWalkingCost = 0; int stepCounter = 1; do { walker.X = previousCell.X + (int)Math.Round(factors.X * stepCounter, 0); walker.Z = previousCell.Z + (int)Math.Round(factors.Z * stepCounter, 0); totalWalkingCost += getRouteCost(previousCell, _map[walker.X, walker.Z]); stepCounter++; } while (walker.X != destination.X && walker.Z != destination.Z); return(totalWalkingCost); } catch (Exception exp) { _logger.Error(exp); } return(double.MaxValue); }
public void AlterRoadCell(int tile_hash, int cell_hash, RoadCell rc) { if (rc.type > 0) { if (!m_Tiles.ContainsKey(tile_hash)) { m_Tiles.Add(tile_hash, new RSTile(tile_hash, true)); } m_Tiles[tile_hash].SetRoadCell(cell_hash, rc); } else { if (m_Tiles.ContainsKey(tile_hash)) { RSTile tile = m_Tiles[tile_hash]; tile.SetRoadCell(cell_hash, rc); if (tile.Road.Count == 0) { tile.Destroy(); m_Tiles.Remove(tile_hash); } } } }
public override void Start() { base.Start(); currentCell = GetRandomCell(); }
private void RenderVectorSquare(RoadCell vector, byte Red, byte Green, byte Blue) { RenderVectorSquare(new Vector2 <int> { X = vector.X * cellSize, Z = vector.Z * cellSize }, Red, Green, Blue); }
public void SetRoadCell(Vector3 world_pos, RoadCell rc) { int hash = WorldPosToRoadCellPos(world_pos).hash; SetRoadCell(hash, rc); }
public Path <RoadCell> BuildPathUsingAStar(RoadCell from, RoadCell to) { _getPathCost = (cell, roadCell) => WalkDirectEstimate(cell, roadCell, GetWeightedUnitDistance); return(PathFinding.AStarPathFindingUsingPriorityQueue(from, to, Get4RadiusNeighbours, _getPathCost, _getPathCost)); }
private int WriteRoadCellToTextures(int hash, RoadCell rc) { INTVECTOR3 rcpos = new INTVECTOR3(); rcpos.hash = hash; byte h = (byte)(rcpos.y + 1); if (rc.type > 0) { m_RoadGraph.SetPixel(rcpos.x, rcpos.z, (Color)(rc.color_type)); Color32 hc = new Color32(0, 0, 0, 0); hc = SafeColorConvert(m_HeightGraph0.GetPixel(rcpos.x, rcpos.z)); if (hc.r == h || hc.g == h || hc.b == h) { return(-1); } if (hc.r == 0) { hc.r = h; m_HeightGraph0.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(0); } if (hc.g == 0) { hc.g = h; m_HeightGraph0.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(0); } if (hc.b == 0) { hc.b = h; m_HeightGraph0.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(0); } hc = SafeColorConvert(m_HeightGraph1.GetPixel(rcpos.x, rcpos.z)); if (hc.r == h || hc.g == h || hc.b == h) { return(-1); } if (hc.r == 0) { hc.r = h; m_HeightGraph1.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(1); } if (hc.g == 0) { hc.g = h; m_HeightGraph1.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(1); } if (hc.b == 0) { hc.b = h; m_HeightGraph1.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(1); } return(-1); } else { m_RoadGraph.SetPixel(rcpos.x, rcpos.z, new Color(0, 0, 0, 0)); Color32 hc = new Color32(0, 0, 0, 0); hc = SafeColorConvert(m_HeightGraph0.GetPixel(rcpos.x, rcpos.z)); if (hc.r == h) { hc.r = 0; m_HeightGraph0.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(0); } if (hc.g == h) { hc.g = 0; m_HeightGraph0.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(0); } if (hc.b == h) { hc.b = 0; m_HeightGraph0.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(0); } hc = SafeColorConvert(m_HeightGraph1.GetPixel(rcpos.x, rcpos.z)); if (hc.r == h) { hc.r = 0; m_HeightGraph1.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(1); } if (hc.g == h) { hc.g = 0; m_HeightGraph1.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(1); } if (hc.b == h) { hc.b = 0; m_HeightGraph1.SetPixel(rcpos.x, rcpos.z, (Color)(hc)); return(1); } return(-1); } }
private IEnumerable <RoadCell> Get12RadiusNeighbours(RoadCell origin) { return(GetRadiusNeighbours(origin, PathFinding.TwelveRadius16Points, 23)); }
public void SetRoadCell(INTVECTOR3 rcpos, RoadCell rc) { int hash = rcpos.hash; SetRoadCell(hash, rc); }
private double GetUnitDistance(RoadCell pointA, RoadCell pointB, int heightFactor) { var heightDifference = Math.Abs(pointA.Avg - pointB.Avg); return(heightFactor * heightDifference); }