public override void Read(BinaryReader br)
{
dataHead = new NodeBoundData(br);
flag = br.ReadUInt32();
distance = br.ReadByte();
roadNum = br.ReadUInt32();
matNum = br.ReadUInt32();
startIndex = br.ReadUInt32();
endIndex = br.ReadUInt32();
dataRight = new RoadData(br);
dataLeft = new RoadData(br);
centerNum = br.ReadUInt16();
tangent = br.ReadSingle();
unknown = br.ReadUInt32();
signCount = br.ReadUInt32();
if (signCount > 0)
{
signs = new SignData[signCount];
for (int i = 0; i < signCount; i++)
{
signs[i] = new SignData(br);
}
}
brushCount = br.ReadUInt32();
if (brushCount > 0)
{
brushs = new BrushData[brushCount];
for (int i = 0; i < brushCount; i++)
{
brushs[i] = new BrushData(br);
}
}
}
private IEnumerator RedirectAfterShipmentRefusal(HashSet <FreightAreaIn> toIgnore)
{
FreightAreaIn bestWarehouse = null;
for (int i = 0; i < 3 && bestWarehouse == null; i++) //TODO possibilité d'un peu de random sur ce 3, arbitraire
{
if (i > 0)
{
yield return(new WaitForSeconds(Random.Range(0.5f, 3.0f - i)));
}
Cell <FreightAreaIn> coroutineRslt = new Cell <FreightAreaIn>();
RoadData occupiedRoad = GetComponent <RoadRouteManager>().occupiedRoad;
yield return(StartCoroutine(occupiedRoad.FindNearestFreeWarehouseFor(shipment, coroutineRslt, toIgnore)));
bestWarehouse = coroutineRslt.value;
}
RoadRouteManager routeManager = GetComponent <RoadRouteManager>();
if (bestWarehouse != null)
{
routeManager.MoveTo(bestWarehouse.road);
destination = bestWarehouse.GetComponentInParent <BuildingStock>();
}
else
{
destination = origin;
routeManager.MoveTo(destination.freightAreaData.freightAreaIn.road);
}
yield return(null);
}
public static Stack <RoadData> RouteStarRebuild(SearchData searchData)
{
Stack <RoadData> rslt = null;
RoadData currentAccess = null;
if (searchData.accessRoads.TryGetValue(searchData.goal.transform.position, out currentAccess))
{
rslt = new Stack <RoadData>();
rslt.Push(searchData.goal);
int counter = 0; //TODO ajuster ça un peu mieux et mettre un random
while (currentAccess != searchData.start)
{
if (counter % searchData.keyPointsSpacing == 0)
{
rslt.Push(currentAccess);
}
currentAccess = searchData.accessRoads[currentAccess.transform.position];
counter++;
}
}
return(rslt);
}
private void Start()
{
_roadData = roadData;
_gameOverGo = gameOverGo;
_counterText = counterText;
_playerData = playerData;
}
public static float RealDistanceBetween(RoadData start, RoadData goal)
{
SearchData searchData = new SearchData(goal, start, 4, Orientation.SOUTH);//TODO Le 4 est ici totalement arbitraire, il n'est pas utilisé. + Orientation a définir en fonction de celle du bâtiment.
Stack <RoadData> path = RoadsPathfinding.AStar(searchData, -1, RouteStarNeighborhood, RouteStarCost, RouteStarRebuild, RouteStarGoal);
return(path == null ? -1.0f : (float)path.Count);
}
public static float RoadPathStarCost(SearchData searchData, RoadData toEvaluate, int step)
{
/*
* coût=
* distance au goal à vol d'oiseau
+
+ nombre (genre 2 ou 3) * nombre d'occupants
+
+ constante (aucune idée de combien...)
*
* nbre de réservations sur toEvaluate
* /
* distance entre la case à évaluer et la case courante (paramètre à ajouter, donc...)
*/
if (toEvaluate.transform.position != searchData.goal.transform.position)
{
return(Vector2.Distance(searchData.goal.transform.position, toEvaluate.transform.position)
+ 2 * toEvaluate.roadLock.locksNber
+ 2 * (toEvaluate.roadLock.reservationsNber / Vector2.Distance(toEvaluate.transform.position, searchData.start.transform.position))
+ step);
}
else
{
return(0.0f);
}
}
public SearchData(RoadData goal, RoadData start, int keyPointsSpacing, string startOrientation)
{
this.goal = goal;
this.start = start;
this.keyPointsSpacing = keyPointsSpacing;
this.startOrientation = startOrientation;
}
private IEnumerator MoveToWithMultipleTries(RoadData destination, float delay, RetryData retryData)
{
if (delay > 0.0f)
{
yield return(new WaitForSeconds(delay));
}
string currentOrientation = _moveManager.orientation;
Stack <RoadData> moveKeyPoints = null;
int tries = 0;
while (moveKeyPoints == null)
{
if (tries > 0)
{
yield return(new WaitForSeconds(UnityEngine.Random.Range(0.5f, 3.0f)));
}
moveKeyPoints = RoadsPathfinding.RouteStar(destination, occupiedRoad, _keyPointsModulo, currentOrientation);
tries++;
}
_moveManager.Move(FollowMoveKeyPoints(moveKeyPoints, destination, retryData));
}
private IEnumerator Start()
{
yield return(new WaitForEndOfFrame());
roadData = ManagerRunner.GetRoadData();
GoTo();
}
void OnTriggerEnter2D(Collider2D other)
{
RoadData roadData = other.GetComponent <RoadData>();
if (roadData != null)
{
roadData.roadLock.markedByPlayer = true;
}
}
public static float RouteStarCost(SearchData searchData, RoadData toEvaluate, int step)
{
if (toEvaluate == null || searchData.goal == null)//Car la route peut avoir été détruite, il faut donc vérifier!!
{
return(Single.PositiveInfinity);
}
return(Vector2.Distance(searchData.goal.transform.position, toEvaluate.transform.position)
+ step
+ 4 * Density(toEvaluate));
}
private static float Density(RoadData toEvaluate)
{
float rslt = toEvaluate.roadLock.locksNber;
foreach (RoadData neighbor in toEvaluate.Neighbors())
{
rslt += neighbor.roadLock.locksNber;
}
return(rslt);
}
/**
* Effectue une recherche d'itinéraire entre deux points du réseau routier.
**/
public static Stack <RoadData> RouteStar(RoadData goal, RoadData start, int keyPointsSpacing, string startOrientation)
{
if (goal == null)
{
return(null);
}
SearchData searchData = new SearchData(goal, start, keyPointsSpacing, startOrientation);
return(AStar(searchData, -1, RouteStarNeighborhood, RouteStarCost, RouteStarRebuild, RouteStarGoal));
}
public void DetachEastNeighbor()
{
RoadData detached = eastNeighboringRoad;
eastNeighboringRoad = null;
if (detached.westNeighboringRoad != null)
{
detached.DetachWestNeighbor();
detached.AdaptToNeighborhood();
}
}
public void DetachNorthNeighbor()
{
RoadData detached = northNeighboringRoad;
northNeighboringRoad = null;
if (detached.southNeighboringRoad != null)
{
detached.DetachSouthNeighbor();
detached.AdaptToNeighborhood();
}
}
/**
* Lance le mouvement de l'objet vers destination après delay secondes.
**/
public void MoveTo(RoadData destination, float delay, RetryData retryData)
{
if (destination == null)
{
onStuckEvent.Invoke(null);
}
if (occupiedRoad != destination)
{
StartCoroutine(MoveToWithMultipleTries(destination, delay, retryData));
}
}
/**
* Lance le mouvement de l'objet vers destination.
**/
public void MoveTo(RoadData destination)
{
if (destination == null)
{
onStuckEvent.Invoke(null);
}
if (occupiedRoad != destination)
{
StartCoroutine(MoveToWithMultipleTries(destination, 0.0f, null));
}
}
/**
* Recherche de chemin sur le réseau routier pour se déplacer entre deux points
* en évitant les autres personnages. Cette recherche est destinée à la réalisation
* effective de portions de mouvement, car elle est plus coûteuse que le RouteStar,
* et il ne serait dont pas une bonne idée de la faire tourner sur tout le réseau
* d'un coup à profondeur maximale.
**/
public static Stack <RoadData> RoadPathStar(RoadData goal, RoadData start, int keyPointsSpacing, string startOrientation, RoadData finalDestination)
{
if (goal == null)
{
return(null);
}
SearchData searchData = new SearchData(goal, start, keyPointsSpacing, startOrientation);
Func <RoadData, RoadData, bool> goalFunction = goal == finalDestination ? (Func <RoadData, RoadData, bool>)RouteStarGoal : (Func <RoadData, RoadData, bool>)NearlyAtGoal;
return(AStar(searchData, 7 * keyPointsSpacing, RoadPathStarNeighborhood, RoadPathStarCost, RoadPathStarRebuild, goalFunction));//TODO "7*" à ajuster si nécessaire, c'est arbitraire au possible.
}
//Si maxDepth vaut -1, pas de profondeur max
public static Stack <RoadData> AStar(SearchData searchData, int maxDepth, Func <SearchData, RoadData, List <RoadData> > neighborhoodFunction, Func <SearchData, RoadData, int, float> costFunction, Func <SearchData, Stack <RoadData> > rebuildFunction, Func <RoadData, RoadData, bool> goalFunction)
{
if (goalFunction(searchData.start, searchData.goal))
{
return(new Stack <RoadData>());
}
PriorityQueue <float, RoadData> priorityQueue = new PriorityQueue <float, RoadData>();
HashSet <RoadData> treated = searchData.visited;
Dictionary <Vector3, RoadData> accessRoads = new Dictionary <Vector3, RoadData>();
searchData.accessRoads = accessRoads;
treated.Add(searchData.start);
RoadData currentRoad = searchData.start;
bool stop = false;
int step = 1;
bool noMaxDepth = maxDepth == -1;
while (!goalFunction(currentRoad, searchData.goal) && !stop && (noMaxDepth || step <= maxDepth))
{
foreach (RoadData neighbor in neighborhoodFunction(searchData, currentRoad))
{
if (!treated.Contains(neighbor))
{
treated.Add(neighbor);
accessRoads.Add(neighbor.transform.position, currentRoad);
priorityQueue.Push(costFunction(searchData, neighbor, step), neighbor);
}
}
stop = priorityQueue.IsEmpty();
step++;
if (!stop)
{
currentRoad = priorityQueue.Pop();
}
}
if (currentRoad == searchData.goal)
{
return(rebuildFunction(searchData));
}
else
{
return(null);
}
}
public void AddTest()
{
RoadData recordRoadData = new RoadData("Test");
recordRoadData.AddBridge(new BridgeData(1, "Bridge"));
Assert.AreEqual(1, recordRoadData.Bridges.Count);
Assert.AreEqual("Bridge", recordRoadData.Bridges[0].Name);
Assert.AreEqual(1, recordRoadData.Bridges[0].IDBR);
recordRoadData = new RoadData("Test");
recordRoadData.Bridges = null;
recordRoadData.AddBridge(new BridgeData(1, "Bridge"));
Assert.AreEqual(1, recordRoadData.Bridges.Count);
Assert.AreEqual("Bridge", recordRoadData.Bridges[0].Name);
Assert.AreEqual(1, recordRoadData.Bridges[0].IDBR);
}
public void AddTest()
{
RoadData recordRoadData = new RoadData("Test");
recordRoadData.AddBridge(new BridgeData(1, "Bridge"));
Assert.AreEqual(1, recordRoadData.Bridges.Count);
Assert.AreEqual("Bridge", recordRoadData.Bridges[0].Name);
Assert.AreEqual(1, recordRoadData.Bridges[0].IDBR);
recordRoadData = new RoadData("Test");
recordRoadData.Bridges = null;
recordRoadData.AddBridge(new BridgeData(1, "Bridge"));
Assert.AreEqual(1, recordRoadData.Bridges.Count);
Assert.AreEqual("Bridge", recordRoadData.Bridges[0].Name);
Assert.AreEqual(1, recordRoadData.Bridges[0].IDBR);
}
/**
* Cette fonction est appelée par le PlacementListener associé à la route
* si celui-ci lui découvre un voisin au sud.
**/
public void southNeighborDetected(GameObject neighbor) //Lié via l'inspecteur au PlacementListener
{
RoadData neighborData = neighbor.GetComponent <RoadData>();
if (neighborData != null)
{
southNeighboringRoad = neighborData;
if (southNeighboringRoad.northNeighboringRoad == null)
{
southNeighboringRoad.northNeighborDetected(gameObject);
southNeighboringRoad.AdaptToNeighborhood();
}
}
}
void Start()
{
if (RoadDataManager.roadDatas == null)
{
RoadDataManager.roadDatas = new List <RoadData>();
}
if (roadData == null)
{
roadData = new RoadData();
RoadDataManager.roadDatas.Add(roadData);
}
roadData.roadId = this.gameObject.GetInstanceID();
}
public static List <RoadData> RoadPathStarNeighborhood(SearchData searchData, RoadData currentRoad)
{//TODO: diagonales!!
List <RoadData> rslt;
if (searchData.start == currentRoad)
{
rslt = currentRoad.AccessibleFreeNeighbors(searchData.startOrientation);
}
else
{
rslt = currentRoad.Neighbors();
}
return(rslt);
}
private void AnticipateNextOrientation(RoadData currentRoad, RoadData nextRoad, string currentOrientation)
{
if (currentRoad.roadLock.locksNber == 1)
{
string nextOrientation = "";
Orientation.ShiftsAndOrientation(currentRoad.transform.position, nextRoad.transform.position, out nextOrientation, 0.1f);
if (nextOrientation != currentOrientation)
{
currentRoad.roadLock.UnlockFor(currentOrientation, gameObject);
currentRoad.roadLock.LockFor(nextOrientation, gameObject);
_moveManager.orientation = nextOrientation;
}
}
}
public void CreateTest()
{
RoadData recordRoad = new RoadData();
Assert.AreEqual("", recordRoad.Name);
Assert.AreEqual(0, recordRoad.Bridges.Count);
recordRoad = new RoadData("Name");
Assert.AreEqual("Name", recordRoad.Name);
Assert.AreEqual(0, recordRoad.Bridges.Count);
List<BridgeData> recordsBridges = new List<BridgeData>();
recordsBridges.Add(new BridgeData());
recordsBridges.Add(new BridgeData(1, "Name"));
recordRoad = new RoadData("Name", recordsBridges);
Assert.AreEqual("Name", recordRoad.Name);
Assert.AreEqual(2, recordRoad.Bridges.Count);
Assert.AreEqual(1, recordRoad.Bridges[1].IDBR);
}
// private static void CreateRoadPrefab(RoadData roadData, GameObject parent, Vector2 worldCenter, Vector2 worldScale)
// {
// string objectId = "RoadEdge" + roadData.Id;
// float height = 0.01f + Random.Range(0, 100) * 0.0001f;
//
// if (roadData.Info.ContainsKey("natural"))
// {
// return;
// }
//
// if (roadData.Info.ContainsKey("waterway"))
// {
// return;
// }
//
// var mainPrefab = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/eWolfRoadBuilder/Prefabs/RoadNetwork_Main_pf.prefab");
// var mainPfObject = GameObject.Instantiate(mainPrefab);
// mainPfObject.name = objectId;
// var positions = roadData.ExteriorPositions.Select(pos =>
// {
// var lat = (pos.NorthLat - worldCenter.y) * worldScale.y;
// var lon = (pos.EastLon - worldCenter.x) * worldScale.x;
// return new Vector2((float)lon, (float)lat);
// }).ToArray();
// // Add
// var roadNetworkNodes = new List<RoadNetworkNode>();
//
// for (int i = 0; i < positions.Length; i++)
// {
// GameObject child = new GameObject(string.Format("child_{0}", i));
// child.transform.position = new Vector3(
// positions[i].x,
// height,
// positions[i].y
// );
// child.transform.parent = mainPfObject.transform;
// var roadNetworkNode = child.AddComponent<RoadNetworkNode>();
// roadNetworkNodes.Add(roadNetworkNode);
// }
//
// // セット
// {
// int i = 0;
// roadNetworkNodes[i].Details.Union = RoadNetworkNode.UNION_TYPE.END;
// roadNetworkNodes[i].Details.Roads = new List<RoadNetworkNode>()
// {
// roadNetworkNodes[i + 1]
// };
// }
//
// for (int i = 1; i < positions.Length - 1; i++)
// {
// roadNetworkNodes[i].Details.Union = RoadNetworkNode.UNION_TYPE.CORNER;
// roadNetworkNodes[i].Details.Roads = new List<RoadNetworkNode>()
// {
// roadNetworkNodes[i + 1],
// roadNetworkNodes[i - 1]
// };
// }
//
// {
// int i = positions.Length - 1;
// roadNetworkNodes[i].Details.Union = RoadNetworkNode.UNION_TYPE.END;
// roadNetworkNodes[i].Details.Roads = new List<RoadNetworkNode>()
// {
// roadNetworkNodes[i - 1]
// };
// }
//
// var roadBuilder = mainPfObject.GetComponent<RoadBuilder>();
// roadBuilder.CrossSectionDetails.RoadWidth = 13.0f;
// roadBuilder.CreateCollision = false;
// roadBuilder.MeshPerNode = false;
// // roadBuilder.DropToGround = false;
// mainPfObject.transform.parent = parent.transform;
// }
public static void CreateRoadMesh(RoadData roadData, GameObject parent, Vector2 worldCenter, Vector2 worldScale)
{
string objectId = "RoadEdge" + roadData.Id;
string materialId = "Black";
float height = 0.01f + Random.Range(0, 100) * 0.0001f;
float width = 10.0f;
if (roadData.Info.ContainsKey("natural"))
{
// if (!roadData.Info["natural"].Equals("coastline"))
// {
// return;
// }
//
// objectId = "Coastline" + roadData.Id;
// materialId = "WaterMaterial";
// height = 0.03f + Random.Range(0, 100) * 0.0001f;
// width = 10.0f;
return;
}
if (roadData.Info.ContainsKey("waterway"))
{
objectId = "Waterway" + roadData.Id;
materialId = "WaterMaterial";
height = 0.00f + Random.Range(0, 100) * 0.0001f;
width = 20.0f;
}
var obj = new GameObject(objectId);
var positions = roadData.ExteriorPositions.Select(pos =>
{
var lat = (pos.NorthLat - worldCenter.y) * worldScale.y;
var lon = (pos.EastLon - worldCenter.x) * worldScale.x;
return new Vector2((float)lon, (float)lat);
}).ToArray();
var meshFilter = obj.AddComponent<MeshFilter>();
var meshRenderer = obj.AddComponent<MeshRenderer>();
var meshCollider = obj.AddComponent<MeshCollider>();
meshFilter.sharedMesh = CreateMesh(positions, width);
meshRenderer.material = Resources.Load<Material>(materialId);
meshCollider.sharedMesh = meshFilter.sharedMesh;
obj.transform.localPosition = Vector3.up * height;
obj.transform.parent = parent.transform;
obj.isStatic = true;
}
/**
* Coroutine à lancer pour effectuer une recherche parmi les entrepôts disponibles
* quel est le plus proche remplissant une condition donnée. Pour les calculs
* de distance, ce sont ici les freight area d'ENTREE (in) qui sont utilisées, ATTENTION!
**/
public static IEnumerator FindNearestWarehouseSatisfyingCondition(RoadData startPoint, Func <Warehouse, bool> acceptanceFunction, Cell <Warehouse> rslt, HashSet <FreightAreaIn> toIgnore)
{
PriorityQueue <float, Warehouse> sortedWarehouses = new PriorityQueue <float, Warehouse>();
IEnumerator <Warehouse> allWarehouses = GameManager.instance.cityBuilderData.stockManager.AllWarehouses();
while (allWarehouses.MoveNext())
{
Warehouse warehouse = allWarehouses.Current;
if (warehouse != null)// Car il peut avoir été détruit depuis le début de la coroutine !
{
FreightAreaIn warehouseIn = warehouse.orderManager.freightAreaData.freightAreaIn;
if (!toIgnore.Contains(warehouseIn) && acceptanceFunction(warehouse))
{
float distanceToWarehouse = Vector2.Distance(warehouseIn.transform.position, startPoint.transform.position);
sortedWarehouses.Push(distanceToWarehouse, warehouse);
}
}
}
if (!sortedWarehouses.IsEmpty())
{
Warehouse bestWarehouse = sortedWarehouses.Pop();
float pathDistance = RoadsPathfinding.RealDistanceBetween(startPoint, bestWarehouse.orderManager.freightAreaData.freightAreaIn.road);
yield return(null);
while (!sortedWarehouses.IsEmpty() && (pathDistance > sortedWarehouses.LowestKey() || pathDistance < 0.0f))
{
Warehouse nearestAsTheCrowFlies = sortedWarehouses.Pop();
float newPathDistance = RoadsPathfinding.RealDistanceBetween(startPoint, nearestAsTheCrowFlies.orderManager.freightAreaData.freightAreaIn.road);
if (newPathDistance >= 0.0f && (newPathDistance < pathDistance || pathDistance < 0.0f))
{
pathDistance = newPathDistance;
bestWarehouse = nearestAsTheCrowFlies;
}
yield return(null);
}
if (pathDistance >= 0.0f)
{
rslt.value = bestWarehouse;
}
}
}
public Road Initialize(RoadData data)
{
var vec = data.End - data.Start;
var rot = Mathf.Atan2(vec.y, vec.x) * Mathf.Rad2Deg;
Line.SetPositions(new[]
{
new Vector3(data.Start.x, data.Start.y, 0),
new Vector3(data.Start.x, data.Start.y, 0),
});
DOTween.To(() => data.Start, end =>
Line.SetPositions(new[]
{
new Vector3(data.Start.x, data.Start.y, 0),
new Vector3(end.x, end.y, 0),
}), data.End, 0.5f)
.SetEase(Ease.InOutCubic);
Text.text = data.Name;
Text.transform.position = data.Start + vec / 2;
Text.transform.eulerAngles = new Vector3(
Text.transform.eulerAngles.x,
Text.transform.eulerAngles.y,
rot);
Text.DOFade(0, 2)
.From();
EndSignal.transform.position = data.End;
Data = data;
var length = (data.End - data.Start).magnitude;
var blockerLength = GameManager.Instance.TurretBlockerSize;
var blockIters = Mathf.CeilToInt(length / blockerLength);
var blockLerp = blockerLength / length;
for (var i = 0; i < blockIters; ++i)
{
var blocker = Instantiate(GameManager.Instance.TurretBlockerPrefab,
Vector2.Lerp(data.Start, data.End, i * blockLerp), Quaternion.identity);
}
return(this);
}
// Nathan wrote this
// saves the road in a binary file
// road is the script of the road object in the development environment
public static void saveRoad(Road road)
{
// create a binary formatter for file conversion
BinaryFormatter roadFormatter = new BinaryFormatter();
// create a path so we know where our saved file is being stored
string savePath = getDataPath("/" + getFileDate() + ".rvvr");
Debug.Log(savePath);
// create a file stream to save our file
FileStream roadStream = new FileStream(savePath, FileMode.Create);
// obtain the road data
RoadData roadData = new RoadData(road);
// store the road data as a binary file
roadFormatter.Serialize(roadStream, roadData);
// close the file stream
roadStream.Close();
}
public void CreateTest()
{
RoadData recordRoad = new RoadData();
Assert.AreEqual("", recordRoad.Name);
Assert.AreEqual(0, recordRoad.Bridges.Count);
recordRoad = new RoadData("Name");
Assert.AreEqual("Name", recordRoad.Name);
Assert.AreEqual(0, recordRoad.Bridges.Count);
List <BridgeData> recordsBridges = new List <BridgeData>();
recordsBridges.Add(new BridgeData());
recordsBridges.Add(new BridgeData(1, "Name"));
recordRoad = new RoadData("Name", recordsBridges);
Assert.AreEqual("Name", recordRoad.Name);
Assert.AreEqual(2, recordRoad.Bridges.Count);
Assert.AreEqual(1, recordRoad.Bridges[1].IDBR);
}
public static Stack <RoadData> RoadPathStarRebuild(SearchData searchData)
{
Stack <RoadData> rslt = null;
RoadData currentAccess = null;
if (searchData.accessRoads.TryGetValue(searchData.goal.transform.position, out currentAccess))
{
rslt = new Stack <RoadData>();
rslt.Push(searchData.goal);
while (currentAccess != searchData.start)
{
rslt.Push(currentAccess);
currentAccess = searchData.accessRoads[currentAccess.transform.position]; //Au cas où le goal est juste à côté.
}
}
return(rslt);
}
