private void MoveTowardsNextPoint()
{
float direction;
if (nextPoint == currentPosition.segment.point2)
{
direction = 1.0f; //moving from point1 to point2
}
else
{
direction = -1.0f; //moving from point2 to point1
}
currentPosition.offset += direction * (agentType.speed / Simulation.TICKS_PER_SECOND) / currentPosition.segment.length;
if (currentPosition.offset < 0.0f)
{
currentPosition.offset = 0.0f;
//Reached point1
lastPoint = currentPosition.segment.point1;
nextPoint = null;
}
else if (currentPosition.offset > 1.0f)
{
currentPosition.offset = 1.0f;
//Reached point2
lastPoint = currentPosition.segment.point2;
nextPoint = null;
}
worldPosition = currentPosition.WorldPosition;
}
public void RemovePoint(SimPoint point)
{
point.Destroy();
points.Remove(point);
pathListener.OnPointRemoved(this, point);
}
public void ChangePoint2(SimPoint newPoint2)
{
point2.segments.Remove(this);
this.point2 = newPoint2;
point2.segments.Add(this);
UpdateLength();
}
public void OnPointAdded(SimPath path, SimPoint point)
{
GameObject goPoint = new GameObject();
goPoint.transform.parent = transform;
SimPointUnity pointUnity = goPoint.AddComponent <SimPointUnity>();
pointUnity.Init(point);
pointsUnity.Add(pointUnity);
}
public SimUnit AddUnit(SimUnitType unitType, SimPoint position)
{
SimUnit unit = new SimUnit();
unit.Init(unitType, nextUnitId++, position);
units.Add(unit);
boxListener.OnUnitAdded(unit);
return(unit);
}
public SimSegment GetSegmentToPoint(SimPoint point)
{
for (int i = 0; i < segments.Count; i++)
{
if (segments[i].point1 == point || segments[i].point2 == point)
{
return(segments[i]);
}
}
return(null);
}
public void Init(SimAgentType agentType, int id, SimPoint position, SimUnit owner, SimResourceBinCollection resources, string searchTarget)
{
this.agentType = agentType;
this.id = id;
this.owner = owner;
this.searchTarget = searchTarget;
this.resources.AddResources(resources);
this.worldPosition = position.worldPosition;
this.lastPoint = position;
}
public SimAgent AddAgent(SimAgentType agentType, SimPoint position, SimUnit owner, SimResourceBinCollection resources, string searchTarget)
{
SimAgent agent = new SimAgent();
agent.Init(agentType, nextAgentId++, position, owner, resources, searchTarget);
agents.Add(agent);
boxListener.OnAgentAdded(agent);
return(agent);
}
public void Init(SimPoint point)
{
this.point = point;
gameObject.name = "Point-" + point.id;
p = GameObject.CreatePrimitive(PrimitiveType.Sphere).transform;
p.parent = transform;
p.renderer.sharedMaterial = MaterialsFactory.CreateDiffuseColor(0xFF0000);
p.localPosition = point.worldPosition;
}
public void OnPointRemoved(SimPath path, SimPoint point)
{
for (int i = 0; i < pointsUnity.Count; i++)
{
if (pointsUnity[i].point == point)
{
GameObject.Destroy(pointsUnity[i].gameObject);
pointsUnity.RemoveAt(i);
break;
}
}
}
public SimSegment AddSegment(SimSegmentType segmentType, SimPoint p1, SimPoint p2)
{
SimSegment segment = new SimSegment();
segment.Init(this, segmentType, nextSegmentId++, p1, p2);
segments.Add(segment);
pathListener.OnSegmentAdded(this, segment);
return(segment);
}
public SimPoint AddPoint(SimVector3 worldPosition)
{
SimPoint point = new SimPoint();
point.Init(this, nextPointId++, worldPosition);
points.Add(point);
pathListener.OnPointAdded(this, point);
return(point);
}
public void Init(SimPath path, SimSegmentType segmentType, int id, SimPoint point1, SimPoint point2)
{
this.path = path;
this.segmentType = segmentType;
this.id = id;
this.point1 = point1;
this.point2 = point2;
point1.segments.Add(this);
point2.segments.Add(this);
UpdateLength();
}
private void FindNextPoint()
{
nextPoint = lastPoint.path.FindNextPoint(lastPoint, searchTarget, resources);
if (nextPoint != null)
{
currentPosition.segment = lastPoint.GetSegmentToPoint(nextPoint);
if (lastPoint == currentPosition.segment.point1)
{
currentPosition.offset = 0;
}
else
{
currentPosition.offset = 1;
}
}
}
public void Init(SimUnitType unitType, int id, SimPoint position)
{
this.unitType = unitType;
this.id = id;
this.position = position;
position.units.Add(this);
resources.SetCapacities(unitType.caps);
resources.AddResources(unitType.resources);
context.localResources = resources;
context.unit = this;
context.box = position.path.box;
context.globalResources = context.box.globals;
context.mapPositionRadius = unitType.mapRadius;
}
// Use this for initialization
void Start()
{
Simulation sim = new Simulation();
sim.simulationDefinition = new SimulationDefinitionLoader().LoadDefinitionFromString(cityToTest.text);
Init(sim);
SimBox city = sim.AddBox("city", Vector3.zero, 32, 32);
SimPath road = city.GetPath("Road");
SimPoint p1 = road.AddPoint(new Vector3(20, 0, 20));
SimPoint p2 = road.AddPoint(new Vector3(50, 0, 50));
SimPoint p3 = road.AddPoint(new Vector3(20, 0, 50));
SimSegment s1 = road.AddSegment(sim.simulationDefinition.GetSegmentType("Dirt"), p1, p2);
SimSegment s2 = road.AddSegment(sim.simulationDefinition.GetSegmentType("Dirt"), p2, p3);
SimSegment s3 = road.AddSegment(sim.simulationDefinition.GetSegmentType("Dirt"), p3, p1);
SimSegmentPosition unitPos;
unitPos.segment = s1;
unitPos.offset = 0.66f;
city.AddUnit(sim.simulationDefinition.GetUnitType("Home"), unitPos);
unitPos.segment = s1;
unitPos.offset = 0.5f;
city.AddUnit(sim.simulationDefinition.GetUnitType("Home"), unitPos);
unitPos.segment = s2;
unitPos.offset = 0.5f;
city.AddUnit(sim.simulationDefinition.GetUnitType("Work"), unitPos);
unitPos.segment = s3;
unitPos.offset = 0.5f;
city.AddUnit(sim.simulationDefinition.GetUnitType("Work"), unitPos);
}
private SimPoint GetPointWithLowestScorePlusHeuristicFromStart()
{
float lowestValue = float.MaxValue;
SimPoint lowestPoint = null;
foreach (KeyValuePair <SimPoint, float> entry in scorePlusHeuristicFromStart)
{
if (entry.Value < lowestValue)
{
lowestValue = entry.Value;
lowestPoint = entry.Key;
}
}
if (lowestPoint != null)
{
scorePlusHeuristicFromStart.Remove(lowestPoint);
}
return(lowestPoint);
}
public SimPoint SplitSegment(SimSegmentPosition positionToSplit)
{
if (positionToSplit.offset == 0)
{
return(positionToSplit.segment.point1);
}
else if (positionToSplit.offset == 1)
{
return(positionToSplit.segment.point2);
}
SimPoint newPoint = AddPoint(positionToSplit.WorldPosition);
AddSegment(positionToSplit.segment.segmentType, newPoint, positionToSplit.segment.point2);
positionToSplit.segment.ChangePoint2(newPoint);
pathListener.OnSegmentModified(this, positionToSplit.segment);
return(newPoint);
}
public void OnPointAdded(SimPath path, SimPoint point)
{
}
public void OnPointModified(SimPath path, SimPoint point)
{
}
public SimUnit AddUnit(SimUnitType unitType, SimSegmentPosition position)
{
SimPoint newPoint = position.segment.path.SplitSegment(position);
return(AddUnit(unitType, newPoint));
}
private float Heuristic(SimPoint p1, SimPoint p2)
{
return((p2.worldPosition - p1.worldPosition).Len);
}
public void OnPointRemoved(SimPath path, SimPoint point)
{
}
public SimPoint FindNextPoint(SimPoint fromPoint, string searchTarget, SimResourceBinCollection resources)
{
//This implementation MUST be replaced with something that is really fast.. right now
//we are not even using a priority queue!!
//We should store as much information as possible in each SimPoint to make this search as
//fast as possible.
closedSet.Clear();
openSet.Clear();
cameFrom.Clear();
scoreFromStart.Clear();
scorePlusHeuristicFromStart.Clear();
openSet.Add(fromPoint);
scoreFromStart[fromPoint] = 0;
scorePlusHeuristicFromStart[fromPoint] = scoreFromStart[fromPoint] + Heuristic(fromPoint, fromPoint);
while (openSet.Count > 0)
{
SimPoint current = GetPointWithLowestScorePlusHeuristicFromStart();
if (current.GetUnitWithTargetAndCapacity(searchTarget, resources) != null)
{
if (current == fromPoint)
{
return(current);
}
while (cameFrom[current] != fromPoint)
{
current = cameFrom[current];
}
return(current);
}
openSet.Remove(current);
closedSet.Add(current);
foreach (SimSegment segment in current.segments)
{
SimPoint neighbor;
if (segment.point1 == current)
{
neighbor = segment.point2;
}
else
{
neighbor = segment.point1;
}
float neighborScoreFromStart = scoreFromStart[current] + segment.length;
if (closedSet.Contains(neighbor))
{
if (neighborScoreFromStart >= scoreFromStart[neighbor])
{
continue;
}
}
if (!openSet.Contains(neighbor) || neighborScoreFromStart < scoreFromStart[neighbor])
{
cameFrom[neighbor] = current;
scoreFromStart[neighbor] = neighborScoreFromStart;
scorePlusHeuristicFromStart[neighbor] = neighborScoreFromStart + Heuristic(neighbor, fromPoint);
if (!openSet.Contains(neighbor))
{
openSet.Add(neighbor);
}
}
}
}
//No path found.. return random point!
if (fromPoint.segments.Count > 0)
{
SimSegment randomSegment = fromPoint.segments[rnd.Next(0, fromPoint.segments.Count)];
if (randomSegment.point1 == fromPoint)
{
return(randomSegment.point2);
}
else if (randomSegment.point2 == fromPoint)
{
return(randomSegment.point1);
}
}
return(null);
}
