/// <inheritdoc/>
public override IEnumerator Apply(PlaybackPanel playbackPanel, TriggerEffector triggerEffector,
ITriggerAgent triggerAgent)
{
ScenarioManager.Instance.logPanel.EnqueueInfo(
$"{OverriddenEffectorType.Name} is omitted in the playback mode.");
yield break;
}
public override IEnumerator Apply(ITriggerAgent agent)
{
if (Loader.IsInScenarioEditor)
{
Debug.LogWarning(
$"Visual Scenario Editor does not support the {GetType().Name}.");
yield break;
}
//Make parent npc wait until any ego is closer than the max distance
float lowestDistance;
do
{
yield return(null);
lowestDistance = float.PositiveInfinity;
var egos = SimulatorManager.Instance.AgentManager.ActiveAgents;
foreach (var ego in egos)
{
var distance = Vector3.Distance(agent.AgentTransform.position, ego.AgentGO.transform.position);
if (distance < lowestDistance)
{
lowestDistance = distance;
}
}
yield return(null);
} while (lowestDistance > MaxDistance);
}
public override IEnumerator Apply(ITriggerAgent agent)
{
if (Loader.IsInScenarioEditor)
{
Debug.LogWarning(
$"Visual Scenario Editor does not support the {GetType().Name}.");
yield break;
}
var egos = SimulatorManager.Instance.AgentManager.ActiveAgents;
IAgentController collisionEgo = null;
var lowestTTC = TimeToCollisionLimit;
foreach (var ego in egos)
{
var controller = ego.AgentGO.GetComponentInChildren <IAgentController>();
var ttc = CalculateTTC(controller, agent, agent.MovementSpeed);
if (ttc >= lowestTTC || ttc < 0.0f)
{
continue;
}
lowestTTC = ttc;
collisionEgo = controller;
}
yield return(agent.StartCoroutine(Apply(lowestTTC, collisionEgo, agent)));
}
/// <inheritdoc/>
public override IEnumerator Apply(PlaybackPanel playbackPanel, TriggerEffector triggerEffector,
ITriggerAgent triggerAgent)
{
if (!(triggerEffector is WaitingPointEffector waitingPointEffector))
{
ScenarioManager.Instance.logPanel.EnqueueError(
$"Invalid trigger effector passed to the {GetType().Name}.");
yield break;
}
var egos = ScenarioManager.Instance.GetExtension <ScenarioAgentsManager>().Agents
.Where(a => a.Source.AgentType == AgentType.Ego).ToArray();
//Make parent npc wait until any ego is closer than the max distance
var lowestDistance = float.PositiveInfinity;
do
{
foreach (var ego in egos)
{
var distance = Vector3.Distance(waitingPointEffector.ActivatorPoint, ego.TransformForPlayback.position);
if (distance < lowestDistance)
{
lowestDistance = distance;
}
}
yield return(null);
} while (lowestDistance > waitingPointEffector.PointRadius);
}
/// <inheritdoc/>
public override IEnumerator Apply(PlaybackPanel playbackPanel, TriggerEffector triggerEffector,
ITriggerAgent triggerAgent)
{
if (!(triggerEffector is TimeToCollisionEffector ttcEffector))
{
ScenarioManager.Instance.logPanel.EnqueueError(
$"Invalid trigger effector passed to the {GetType().Name}.");
yield break;
}
var egos = ScenarioManager.Instance.GetExtension <ScenarioAgentsManager>().Agents
.Where(a => a.Source.AgentType == AgentType.Ego);
ScenarioAgent collisionEgo = null;
var lowestTTC = TimeToCollisionEffector.TimeToCollisionLimit;
foreach (var ego in egos)
{
var ttc = ttcEffector.CalculateTTC(ego, triggerAgent, triggerAgent.MovementSpeed);
if (ttc >= lowestTTC || ttc < 0.0f)
{
continue;
}
lowestTTC = ttc;
collisionEgo = ego;
}
yield return(playbackPanel.StartCoroutine(ttcEffector.Apply(lowestTTC, collisionEgo, triggerAgent)));
}
public override IEnumerator Apply(ITriggerAgent agent)
{
if (ControllablesUIDs == null || ControllablesUIDs.Count == 0)
{
yield break;
}
foreach (var uid in ControllablesUIDs)
{
if (!SimulatorManager.Instance.ControllableManager.TryGetControllable(uid, out var controllable))
{
continue;
}
controllable.Control(ControlPolicy);
}
}
public IEnumerator Apply(ITriggerAgent triggerAgent, Action callback = null)
{
//Run effectors parallel and wait for all of them to finish
var coroutines = new Coroutine[Effectors.Count];
for (int i = 0; i < Effectors.Count; i++)
{
coroutines[i] = triggerAgent.StartCoroutine(Effectors[i].Apply(triggerAgent));
}
for (int i = 0; i < coroutines.Length; i++)
{
yield return(coroutines[i]);
}
callback?.Invoke();
}
private float CalculateTTC(AgentController ego, ITriggerAgent agent)
{
//Calculate intersection point, return infinity if vehicles won't intersect
if (!GetLineIntersection(ego.transform.position, ego.transform.forward, agent.AgentTransform.position, agent.AgentTransform.forward,
out var intersection))
{
return(float.PositiveInfinity);
}
var egoDistance = Distance2D(ego.transform.position, intersection);
var npcDistance = Distance2D(agent.AgentTransform.position, intersection);
var egoTimeToIntersection = CalculateTimeForAccelerated(ego.Velocity.magnitude, ego.Acceleration.magnitude, egoDistance);
var npcTimeToIntersection = CalculateTimeForAccelerated(agent.MovementSpeed, agent.Acceleration.magnitude, npcDistance);
//If npc will reach intersection quicker, ttc will be positive
//If agent cannot reach collision point before ego, ttc will be negative
return(egoTimeToIntersection - npcTimeToIntersection);
}
public override IEnumerator Apply(ITriggerAgent agent)
{
//Make parent npc wait until any ego is closer than the max distance
var lowestDistance = float.PositiveInfinity;
do
{
var egos = SimulatorManager.Instance.AgentManager.ActiveAgents;
foreach (var ego in egos)
{
var distance = Vector3.Distance(ActivatorPoint, ego.AgentGO.transform.position);
if (distance < lowestDistance)
{
lowestDistance = distance;
}
}
yield return(null);
} while (lowestDistance > PointRadius);
}
public override IEnumerator Apply(ITriggerAgent agent)
{
if (ControllablesUIDs == null || ControllablesUIDs.Count == 0)
{
yield break;
}
if (Loader.IsInScenarioEditor)
{
Debug.LogWarning(
$"Visual Scenario Editor does not support the {GetType().Name}.");
yield break;
}
foreach (var uid in ControllablesUIDs)
{
if (!SimulatorManager.Instance.ControllableManager.TryGetControllable(uid, out var controllable))
{
continue;
}
controllable.Control(ControlPolicy);
}
}
public override IEnumerator Apply(ITriggerAgent agent)
{
var lowestTTC = TimeToCollisionLimit;
var egos = SimulatorManager.Instance.AgentManager.ActiveAgents;
AgentController collisionEgo = null;
foreach (var ego in egos)
{
var agentController = ego.AgentGO.GetComponentInChildren <AgentController>();
var ttc = CalculateTTC(agentController, agent);
if (ttc >= lowestTTC || ttc < 0.0f)
{
continue;
}
lowestTTC = ttc;
collisionEgo = agentController;
}
//If there is no collision detected don't wait
if (lowestTTC >= TimeToCollisionLimit || collisionEgo == null)
{
yield break;
}
//Agent will adjust waiting time while waiting
do
{
yield return(null);
lowestTTC = CalculateTTC(collisionEgo, agent);
//Check if TTC is valid, for example ego did not change the direction
if (lowestTTC >= TimeToCollisionLimit)
{
yield break;
}
} while (lowestTTC > 0.0f);
}
public float CalculateTTC(ITriggerAgent ego, ITriggerAgent agent, float agentMovementSpeed)
{
//Calculate intersection point, return infinity if vehicles won't intersect
var egoTransform = ego.AgentTransform;
if (!GetLineIntersection(egoTransform.position, egoTransform.forward, agent.AgentTransform.position,
agent.AgentTransform.forward,
out var intersection))
{
return(float.PositiveInfinity);
}
var egoDistance = Distance2D(egoTransform.position, intersection);
var agentDistance = Distance2D(agent.AgentTransform.position, intersection);
var egoTimeToIntersection =
CalculateTimeForAccelerated(ego.MovementSpeed, ego.Acceleration.magnitude, egoDistance);
var agentTimeToIntersection =
CalculateTimeForAccelerated(agentMovementSpeed, agent.Acceleration.magnitude, agentDistance);
//If ego agent will reach intersection quicker, ttc will be positive
//If agent cannot reach collision point before ego, ttc will be negative
return(egoTimeToIntersection - agentTimeToIntersection);
}
public IEnumerator Apply(float lowestTTC, ITriggerAgent collisionEgo, ITriggerAgent agent)
{
//If there is no collision detected don't wait
if (lowestTTC >= TimeToCollisionLimit || collisionEgo == null)
{
yield break;
}
//Agent will adjust waiting time while waiting
var initialMovementSpeed = agent.MovementSpeed;
do
{
yield return(null);
lowestTTC = CalculateTTC(collisionEgo, agent, initialMovementSpeed);
//Check if TTC is valid, for example ego did not change the direction
if (lowestTTC >= TimeToCollisionLimit)
{
yield break;
}
} while (lowestTTC > 0.0f);
}
public override IEnumerator Apply(ITriggerAgent agent)
{
//Make parent npc wait for "value" time
yield return(new WaitForSeconds(Value));
}
/// <summary> /// Overridden apply method for the playback mode /// </summary> /// <param name="playbackPanel">Playback panel that will run coroutines</param> /// <param name="triggerEffector">Trigger effector that was overridden by this script</param> /// <param name="triggerAgent">Trigger agent affected by the effector</param> /// <returns>Coroutine IEnumerator</returns> public abstract IEnumerator Apply(PlaybackPanel playbackPanel, TriggerEffector triggerEffector, ITriggerAgent triggerAgent);
public abstract IEnumerator Apply(ITriggerAgent triggerAgent);
