public TraversalState(
TraversalState parent,
PipelineContextData data)
{
Parent = parent;
m_data = data;
}
public void Collect_OneModuleToCollectAndOnePath_Collected()
{
const string moduleNameToCollect = "moduleName";
var moduleNamesToCollect = new List <string> {
moduleNameToCollect
};
var traversalState = new TraversalState {
CurrentInstance = new Instance("netlist", "host", moduleNameToCollect, "instName")
};
var instancesPathTracker = new InstancesPathTracker().UpdateIn(traversalState.CurrentInstance);
traversalState.InstancesPathTracker = instancesPathTracker;
_target = new PhysicalPathAggregator(moduleNamesToCollect);
_target.Collect(traversalState);
var result = _target.Result();
Assert.That(result, Has.Count.EqualTo(1));
Assert.That(result, Has.Exactly(1).Matches <ModulePhysiclaPaths>(mpp =>
mpp.ModuleName == moduleNameToCollect &&
mpp.Paths.Count == 1 &&
mpp.Paths[0] == instancesPathTracker.ToString()
));
}
/// <summary>
/// Returns all context data objects (depth first)
/// </summary>
internal static IEnumerable <PipelineContextData> Traverse(
this PipelineContextData value,
Boolean omitKeys)
{
yield return(value);
if (value is ArrayContextData || value is DictionaryContextData)
{
var state = new TraversalState(null, value);
while (state != null)
{
if (state.MoveNext(omitKeys))
{
value = state.Current;
yield return(value);
if (value is ArrayContextData || value is DictionaryContextData)
{
state = new TraversalState(state, value);
}
}
else
{
state = state.Parent;
}
}
}
}
public void Collect(TraversalState traversalState)
{
if (IsModuleToTrack(traversalState.CurrentInstance))
{
AddPath(traversalState);
}
}
private static void EnsureHasNoCycles(IReadOnlyDictionary <string, string[]> adjacencyMap)
{
var state = new TraversalState(adjacencyMap);
var roots = adjacencyMap
.Where(kvp => kvp.Value.Length == 0)
.Select(kvp => kvp.Key)
.ToArray();
if (roots.Length == 0)
{
var startingNode = adjacencyMap.OrderBy(kvp => kvp.Value.Length).Select(kvp => kvp.Key).FirstOrDefault();
// no nodes = no cycles
if (startingNode == null)
{
return;
}
EnsureHasNoCycles(startingNode, state);
}
else
{
foreach (var node in roots)
{
EnsureHasNoCycles(node, state);
}
}
}
/// <summary>
/// Returns all tokens (depth first)
/// </summary>
public static IEnumerable <TemplateToken> Traverse(
this TemplateToken token,
bool omitKeys)
{
if (token != null)
{
yield return(token);
if (token is SequenceToken || token is MappingToken)
{
var state = new TraversalState(null, token);
while (state != null)
{
if (state.MoveNext(omitKeys))
{
token = state.Current;
yield return(token);
if (token is SequenceToken || token is MappingToken)
{
state = new TraversalState(state, token);
}
}
else
{
state = state.Parent;
}
}
}
}
}
public TraversalState(
TraversalState parent,
TemplateToken token)
{
Parent = parent;
m_token = token;
}
public void RoadNetworkTraversal_LaneSectionTraversalSmokeTest()
{
var roadNetwork = LoadTestFile("CircleCourse");
var firstRoad = roadNetwork.AllRoads.First();
var firstRoadId = new NativeString64(firstRoad.roadId);
var numLaneSections = 3;
var numLoops = 10;
var traversalState = new TraversalState(roadNetwork, firstRoad.roadId, 0, -1, TraversalDirection.Forward);
for (var step = 0; step < numLaneSections - 1; ++step)
{
Assert.IsTrue(RoadNetworkTraversal.TryAdvanceOneLaneSection(roadNetwork, ref traversalState, false),
$"Failed to advance to step #{step} - {numLaneSections} total");
Assert.AreEqual(-1, traversalState.LaneId);
}
// Without allowing looping, we shouldn't be allowed to go to the next lane section
Assert.IsFalse(RoadNetworkTraversal.TryAdvanceOneLaneSection(roadNetwork, ref traversalState, false));
Assert.IsTrue(RoadNetworkTraversal.TryAdvanceOneLaneSection(roadNetwork, ref traversalState, true));
Assert.AreEqual(firstRoadId, traversalState.RoadId);
for (var step = 0; step < numLaneSections * numLoops; ++step)
{
Assert.IsTrue(RoadNetworkTraversal.TryAdvanceOneLaneSection(roadNetwork, ref traversalState, true),
$"Failed to advance to step #{step} - {numLaneSections} total");
Assert.AreEqual(-1, traversalState.LaneId);
}
Assert.AreEqual(firstRoadId, traversalState.RoadId);
}
void fall()
{
Vector3 loc = this.transform.position;
platState = TraversalState.down;
desiredPosition = loc.y - (traversalDistance + 1140);
movementSpeed = 30;
Destroy(this.gameObject,2f);
}
internal static void AdvanceOneRoad(TraversalParameters traversalParam, TraversalState traversalState)
{
if (!TryAdvanceOneRoad(traversalParam, traversalState))
{
throw new InvalidOperationException(
"Failed to advance along road network - you may want TryAdvanceOneRoad instead.");
}
}
public void Collect(TraversalState traversalState)
{
if (traversalState.CurrentInstance.IsModule())
{
return;
}
_result.UpdateValue(traversalState.CurrentInstance.ModuleName, count => ++ count, 0);
}
public static void DisposeAll(TraversalState state)
{
foreach (var tileKvp in s_tileUsage)
{
var tile = tileKvp.Key;
s_tileUsage.Remove(tile);
tile.DisposeAndRemove(state);
}
}
//public static void Register(ISg sg, TraversalState state)
//{
// var replace = s_tileUsage.ContainsKey(sg) ? s_tileUsage[sg] : DateTime.MinValue;
// s_tileUsage[sg] = replace;
//}
// private static bool m_forceFreeMemory = false;
public static void Use(ISg sg, TraversalState state)
{
//if (s_tileUsage.ContainsKey(sg))
// s_tileUsage.Remove(sg);
s_tileUsage[sg] = (long)(DateTime.Now - s_startTime).TotalSeconds;
//if (GC.GetTotalMemory(false) > 600000000)
// m_forceFreeMemory = true;
}
static bool TryAdvanceThroughJunction(Junction junction, RoadNetworkDescription network,
ref TraversalState state, bool allowLooping = false)
{
var roadId = state.RoadId.ToString();
// TODO: This search currently terminates on the first found linked road/lane, but we may want to find
// all of them first and then select one based on some criteria
foreach (var connection in junction.connections)
{
if (roadId == connection.incomingRoadId)
{
if (!allowLooping && state.AllRoadIds.HasBeenTraversed(new NativeString64(connection.incomingRoadId)))
{
return(false);
}
foreach (var link in connection.laneLinks)
{
if (link.laneIdFrom != state.LaneId)
{
continue;
}
var direction = DetermineNewDirection(connection.contactPoint);
var idx = direction == TraversalDirection.Forward
? 0
: network.GetRoadById(connection.connectingRoadId).laneSections.Count - 1;
state.SetNewLocation(new NativeString64(connection.connectingRoadId), idx, link.laneIdTo, direction);
return(true);
}
}
else if (roadId == connection.connectingRoadId)
{
if (!allowLooping && state.AllRoadIds.HasBeenTraversed(new NativeString64(connection.connectingRoadId)))
{
return(false);
}
foreach (var link in connection.laneLinks)
{
if (link.laneIdTo != state.LaneId)
{
continue;
}
var nextRoad = network.GetRoadById(connection.incomingRoadId);
var sectionIdx = nextRoad.laneSections.Count - 1;
state.SetNewLocation(new NativeString64(connection.incomingRoadId), sectionIdx, link.laneIdFrom, TraversalDirection.Backward);
return(true);
}
}
}
return(false);
}
void OnTriggerEnter(Collider col)
{
if(col.gameObject.tag == "Player"){
if(isDestructible){
platState = TraversalState.right;
getDesiredPosition();
Invoke("fall",1f);
}
else if(this.gameObject.name == "Moving_Platform_Sides" ||
this.gameObject.name == "Moving_Platform_Upward"){
theHero = col.transform.parent.gameObject.GetComponent<CharacterMovement>();
}
}
}
// NOTE: Because this method advances by ROAD, any LANE information will be lost on traversal (reset to 0)
// Use TryAdvanceOneLaneSection to move along a selected lane
internal static bool TryAdvanceOneRoad(TraversalParameters traversalParam, TraversalState traversalState)
{
var roadCurrent = traversalParam.roadNetwork.GetRoadById(traversalState.RoadId);
var link = GetLinkToNextRoad(roadCurrent, traversalState.Direction);
if (link.linkType == RoadLinkType.None || traversalParam.shouldStopAtJunctions &&
!IsLinkOnGraphEdge(traversalParam.roadNetwork, link))
{
return(false);
}
var directionNext = DetermineNewDirection(link.contactPoint);
traversalState.SetNewLocation(new NativeString64(link.nodeId), 0, 0, directionNext);
return(true);
}
public void RoadNetworkTraversal_RoadGroupingSmokeTest()
{
var roadNetwork = LoadTestFile("Crossing8Course");
var traversalState = new TraversalState(roadNetwork);
var numGroups = 0;
while (traversalState.AllRoadIds.AnyNotTraversed())
{
var roadId = traversalState.AllRoadIds.GetNotTraversed();
if (roadNetwork.GetRoadById(roadId).junction != "-1")
{
traversalState.AllRoadIds.Traverse(roadId);
continue;
}
var roadGroup = RoadNetworkTraversal.IdentifyGraphEdgeGroup(roadNetwork,
traversalState, roadId);
numGroups++;
Assert.AreEqual(3, roadGroup.numRoads);
Assert.AreEqual(TraversalDirection.Forward, roadGroup.startingDirection);
}
Assert.AreEqual(2, numGroups);
}
public static void FreeMemory(TraversalState state)
{
Report.Line(1, "Free");
var x = (long)((DateTime.Now - s_startTime).TotalSeconds);
var tilesDescriptionsWhichCouldBeRemoved =
from tileKvp in s_tileUsage
where x - tileKvp.Value > MaximumLifeTime
select tileKvp;
var tdcbrArray = tilesDescriptionsWhichCouldBeRemoved.ToArray();
Report.Line(1, "USED TILES BEF: " + s_tileUsage.Count);
Report.Line(1, "REMOVING " + tdcbrArray.Length + "TILES");
foreach (var tileKvp in tdcbrArray)
{
// Report.Line(0, "Tile disposed " + (currentCycle - tileKvp.Value));
var tile = tileKvp.Key;
s_tileUsage.Remove(tile);
tile.DisposeAndRemove(state);
}
Report.Line(1, "USED TILES AFT: " + s_tileUsage.Count);
}
private static void EnsureHasNoCycles(string node, TraversalState state)
{
state.Visit(node);
var nextNodes = state.GetNext(node);
if (!nextNodes.Any())
{
state.Yield(node);
return;
}
foreach (var adjacentNode in nextNodes)
{
if (state.IsVisited(adjacentNode) && !state.IsYielded(adjacentNode))
{
var msg = $"Cyclic config dependency detected, visited undeleted node twice: '{adjacentNode}'";
throw new BadYamlException("configurations", msg);
}
EnsureHasNoCycles(adjacentNode, state);
}
state.Yield(node);
}
// Each non-junction road is effectively a segment of a graph edge - this function identifies which roads
// belong on the same edge as the input graph edge and return the information necessary to query this edge
internal static RoadGroup IdentifyGraphEdgeGroup(RoadNetworkDescription roadNetwork,
TraversalState state, NativeString64 roadId)
{
if (roadNetwork.GetRoadById(roadId).junction != "-1")
{
throw new ArgumentException(
"Cannot collect graph edge group for a road inside a junction - roads inside junctions" +
"are part of a graph node.");
}
// Because we want to limit traversal to this graph edge, we will always stop at junctions (nodes)
const bool stopAtJunctions = true;
var param = new TraversalParameters(roadNetwork, stopAtJunctions);
// Count how many Road elements are in this group, including the starting road
var numRoads = 1;
state.SetNewLocation(roadId, 0, 0, TraversalDirection.Backward);
while (TryAdvanceOneRoad(param, state))
{
numRoads++;
}
// We've moved all the way to the "front" of this collection of roads - store it as the starting location
var startingRoadId = state.RoadId;
// To get from the first Road to the second, we need to travel in the opposite direction we traversed to
// reach the first Road
var startDirection = (TraversalDirection)(-(int)state.Direction);
// Traverse forward to ensure we mark all the roads in this group as traversed
state.SetNewLocation(roadId, 0, 0, TraversalDirection.Forward);
while (TryAdvanceOneRoad(param, state))
{
numRoads++;
}
return(new RoadGroup(startDirection, startingRoadId, numRoads));
}
public void continueMoving()
{
Vector3 loc = this.transform.position;
if(pastState == TraversalState.up){
platState = TraversalState.down;
desiredPosition = loc.y - traversalDistance;
}
else if(pastState == TraversalState.right){
platState = TraversalState.left;
desiredPosition = loc.x - traversalDistance;
}
else if(pastState == TraversalState.left){
platState = TraversalState.right;
desiredPosition = loc.x + traversalDistance;
}
else if(pastState == TraversalState.down){
platState = TraversalState.up;
desiredPosition = loc.y + traversalDistance;
}
}
// TODO: This should be modified to take a TraversalParams struct instead of taking the network directly
internal static bool TryAdvanceOneLaneSection(RoadNetworkDescription network, ref TraversalState state,
bool allowLooping = false)
{
var roadCurrent = network.GetRoadById(state.RoadId);
var laneCurrent = roadCurrent.laneSections[state.LaneSectionIdx].GetLane(state.LaneId);
var laneIdNext = GetNextLaneId(laneCurrent, state.Direction);
// If there are more lane sections, we haven't reached the end of the road
if (HasMoreLaneSectionsInDirection(roadCurrent, state))
{
// Check that the current lane exists in this next road section
if (laneIdNext == 0)
{
Debug.Log($"Lane {state.LaneId} on Road {state.RoadId} ends after section {state.LaneSectionIdx}");
return(false);
}
var sectionIdxNext = state.LaneSectionIdx + (int)state.Direction;
// Debug.Log($"Moving to section {sectionIdxNext} lane {laneIdNext} in road {state.RoadId}");
// Since we're staying in the same road, we preserve the traverse travelDirection
state = new TraversalState(network, state.RoadId, sectionIdxNext, laneIdNext, state.Direction);
if (!roadCurrent.laneSections[state.LaneSectionIdx].HasLane(state.LaneId))
{
throw new Exception($"Expected road {state.RoadId} to have lane {state.LaneId}.");
}
return(true);
}
var roadLink = GetLinkToNextRoad(roadCurrent, state.Direction);
// Check to see if road terminates
if (roadLink.linkType == RoadLinkType.None)
{
Debug.Log($"Road {state.RoadId} ends in travelDirection {state.Direction}");
return(false);
}
if (roadLink.linkType == RoadLinkType.Road)
{
// If the road has a link, it should be guaranteed to have a valid LinkContactPoint as well
Debug.Assert(roadLink.contactPoint == LinkContactPoint.Start ||
roadLink.contactPoint == LinkContactPoint.End,
$"Road {state.RoadId} road link contact point was not set correctly.'");
if (laneIdNext == 0)
{
Debug.Log($"Lane {state.LaneId} on Road {state.RoadId} ends in travelDirection {state.Direction}");
return(false);
}
var roadIdNext = roadLink.nodeId;
var roadNext = network.GetRoadById(roadIdNext);
var directionNext = roadLink.contactPoint == LinkContactPoint.Start ? TraversalDirection.Forward : TraversalDirection.Backward;
var sectionIdxNext = directionNext == TraversalDirection.Forward ? 0 : roadNext.laneSections.Count - 1;
var laneSectionNext = roadNext.laneSections[sectionIdxNext];
if (!laneSectionNext.HasLane(laneIdNext))
{
throw new Exception($"Expected {roadNext.roadId} to have lane {laneIdNext}.");
}
if (state.AllRoadIds.HasBeenTraversed(new NativeString64(roadIdNext)) && !allowLooping)
{
return(false);
}
// Debug.Log($"Moving to road {roadIdNext} section {sectionIdxNext} lane {laneIdNext}");
state.SetNewLocation(new NativeString64(roadIdNext), sectionIdxNext, laneIdNext, directionNext);
}
else if (roadLink.linkType == RoadLinkType.Junction)
{
var junction = network.GetJunctionById(roadLink.nodeId);
if (!TryAdvanceThroughJunction(junction, network, ref state, allowLooping))
{
Debug.Log($"Found no connected lanes for lane {state.LaneId} on road {state.RoadId} in junction {junction.junctionId}");
return(false);
}
}
return(true);
}
private void AddPath(TraversalState traversalState)
{
_result[traversalState.CurrentInstance.ModuleName].Add(traversalState.InstancesPathTracker.ToString());
}
// Update is called once per frame
void Update()
{
Vector3 loc = this.transform.position;
if(platState == TraversalState.up){
if(loc.y < desiredPosition)
transform.Translate(Vector3.up * Time.deltaTime * movementSpeed);
else{
platState = TraversalState.stop;
pastState = TraversalState.up;
Invoke("continueMoving", stopTime);
}
}
if(platState == TraversalState.down){
if(loc.y > desiredPosition)
transform.Translate(Vector3.down * Time.deltaTime * movementSpeed);
else{
platState = TraversalState.stop;
pastState = TraversalState.down;
Invoke("continueMoving", stopTime);;
}
}
if(platState == TraversalState.right){
if(loc.x < desiredPosition)
transform.Translate(Vector3.right * Time.deltaTime * movementSpeed);
else{
platState = TraversalState.stop;
pastState = TraversalState.right;
Invoke("continueMoving", stopTime);
}
}
if(platState == TraversalState.left){
if(loc.x > desiredPosition)
transform.Translate(Vector3.left * Time.deltaTime * movementSpeed);
else{
platState = TraversalState.stop;
pastState = TraversalState.left;
Invoke("continueMoving", stopTime);
}
}
if(theHero != null){
if(platState == TraversalState.right)
theHero.NewPlatformSpeedX(movementSpeed, true);
else if(platState == TraversalState.up)
theHero.NewPlatformSpeedY(movementSpeed, true);
else if(platState == TraversalState.left)
theHero.NewPlatformSpeedX(movementSpeed, false);
else if(platState == TraversalState.down){
theHero.NewPlatformSpeedY(movementSpeed, false);
}
else if(platState == TraversalState.stop){
theHero.NewPlatformSpeedX(0f, false);
theHero.NewPlatformSpeedY(0f, false);
}
}
}
private static bool HasMoreLaneSectionsInDirection(Road road, TraversalState state)
{
var nextIndex = state.LaneSectionIdx + (int)state.Direction;
return(0 <= nextIndex && nextIndex < road.laneSections.Count);
}
