public override ActionSet ComposeActionSet(Reflex reflex, GameActor gameActor)
{
ClearActionSet(actionSet);
UpdateCanBlend(reflex);
if (!reflex.targetSet.AnyAction)
{
return(actionSet);
}
if (reflex.targetSet.Count > 0)
{
// falloff == Avoid, !falloff == Away
if (falloff)
{
// Avoid.
// We want to avoid all actors so we need to loop over the full set.
foreach (SensorTarget target in reflex.targetSet)
{
GameActor targetActor = target.GameThing as GameActor;
if (targetActor != null)
{
actionSet.AddAction(Action.AllocAvoidAction(reflex, targetActor));
}
}
}
else
{
// Away.
Vector3 actorPos = gameActor.Movement.Position;
Vector3 dir = Vector3.Zero; // The direction we want to flee.
// We want to move away from all actors so we need to loop over the full set.
foreach (SensorTarget target in reflex.targetSet)
{
GameActor targetActor = target.GameThing as GameActor;
if (targetActor != null)
{
Vector3 fromTarget = actorPos - targetActor.Movement.Position;
float dist = fromTarget.Length();
// Normalize fromTarget then divide again by dist. This gives us a linear
// falloff of strength based on distance so that a target that is twice as
// close will have twice the weight on the flee direction.
dir += fromTarget / dist / dist;
}
}
bool apply = reflex.ModifyHeading(gameActor, Modifier.ReferenceFrames.World, ref dir);
if (apply)
{
dir.Normalize();
actionSet.AddAction(Action.AllocVelocityAction(reflex, dir, autoTurn: true));
}
} // end else if falloff
} // end if targetSet not empty.
return(actionSet);
}
public override void Fixup(Reflex reflex)
{
base.Fixup(reflex);
radiusScale = 1.0f;
for (int imod = 0; imod < reflex.Modifiers.Count; ++imod)
{
CircleDistanceModifier cdMod = reflex.Modifiers[imod] as CircleDistanceModifier;
if (cdMod != null)
{
radiusScale *= cdMod.radiusScale;
}
}
Task task = reflex.Task;
controlZ = true;
for (int iref = 0; iref < task.reflexes.Count; ++iref)
{
Reflex otherReflex = task.reflexes[iref] as Reflex;
if ((otherReflex != null) && (otherReflex != reflex))
{
Selector otherSelector = otherReflex.Selector;
if ((otherSelector is MoveDownSelector) ||
(otherSelector is MoveUpDownSelector) ||
(otherSelector is MoveUpSelector) ||
(otherSelector is FollowWaypointsSelector))
{
controlZ = false;
break;
}
}
}
}
} // end of Free()
/// <summary>
/// Old-style action. Should be replaced? TargetDirectionAction?
///
/// We still use this for stuff like shooting.
///
/// WHEN See Apple DO Shoot
/// gameThing is the nearest apple
/// direction is the direction to shoot
/// distance is distance to apple
///
/// WHEN GamePad AButton DO Shoot
/// gameThing is null
/// direction is forward
/// distance is 1
///
/// </summary>
/// <param name="distance"></param>
/// <param name="direction"></param>
/// <param name="gameThing"></param>
/// <param name="reflex"></param>
/// <param name="canBlend"></param>
/// <param name="specialInstruction"></param>
/// <returns></returns>
static public Attractor AllocAttractor(float distance,
Vector3 direction,
GameThing gameThing,
Reflex reflex,
bool canBlend = false,
BaseAction.SpecialInstruction specialInstruction = BaseAction.SpecialInstruction.None)
{
Attractor attractor;
// Recycle an attractor if possible. If not, create a new one.
if (AttractorFreeList.Count > 0)
{
attractor = AttractorFreeList[AttractorFreeList.Count - 1];
AttractorFreeList.RemoveAt(AttractorFreeList.Count - 1);
}
else
{
attractor = new Attractor();
}
// Fill in the data.
attractor.Init(distance, direction, gameThing, reflex, canBlend, specialInstruction);
return(attractor);
} // end of AllocAttractor()
public override ActionSet ComposeActionSet(Reflex reflex, GameActor gameActor)
{
ClearActionSet(actionSet);
UpdateCanBlend(reflex);
if (!reflex.targetSet.AnyAction)
{
return(actionSet);
}
SensorTarget target = reflex.targetSet.Nearest;
if (target != null)
{
// Calculate a vector toward target.
Vector3 value = target.Direction;
bool apply = reflex.ModifyHeading(gameActor, Modifier.ReferenceFrames.World, ref value);
if (apply)
{
actionSet.AddAction(Action.AllocTargetLocationAction(reflex, target.Position, autoTurn: true));
}
}
return(actionSet);
}
/// <summary>
/// See if the gameActor
/// </summary>
/// <param name="gameActor"></param>
/// <param name="reflex"></param>
/// <returns></returns>
public override void ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
// Unlike water or terrain sensors, we don't filter on specific path types
// but we can filter on path color.
bool match = gameActor.Chassis.OverPath && !gameActor.Chassis.Jumping;
if (match)
{
List <Filter> filters = reflex.Filters;
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
ClassificationFilter classificationFilter = filter as ClassificationFilter;
if (classificationFilter != null && classificationFilter.classification.Color != gameActor.Chassis.PathColor)
{
match = false;
}
}
}
if (reflex.Data.GetFilterCountByType(typeof(NotFilter)) > 0)
{
match = !match;
}
reflex.targetSet.Action = match;
} // end of ComposeSensorTargetSet()
public override void ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
List <Filter> filters = reflex.Filters;
if (this.playerIndex == PlayerId.Dynamic)
{
PlayerId dynamicPlayerId = PlayerId.All;
// check filters for the player
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
PlayerFilter filter = filters[indexFilter] as PlayerFilter;
object param;
if (filter != null && filter.MatchAction(reflex, out param))
{
dynamicPlayerId = (PlayerId)param;
break;
}
}
reflex.targetSet.Param = dynamicPlayerId;
}
else
{
reflex.targetSet.Param = this.playerIndex;
}
reflex.targetSet.Action = TestObjectSet(reflex);
}
public override bool MatchAction(Reflex reflex, out object param)
{
param = null;
bool match = false;
int curr = reflex.Task.Brain.GameActor.HitPoints;
int prev = reflex.Task.Brain.GameActor.PrevHitPoints;
switch (op)
{
case HealthCompare.Is:
//match = (curr == triggerValue) && (prev != triggerValue);
match = (curr == triggerValue);
break;
case HealthCompare.Above:
//match = (curr > triggerValue) && (prev <= triggerValue);
match = (curr > triggerValue);
break;
case HealthCompare.Below:
//match = (curr < triggerValue) && (prev >= triggerValue);
match = (curr < triggerValue);
break;
}
return(match);
}
public static IObservable <TProp> WhenAny <TProp>(this IObservablePropertyChanged @this, Expression <Func <TProp> > prop)
{
var name = Reflex.PropertyName(prop);
var func = prop.CompileFast();
return(@this.PropertyChangedObservable.Where(s => s == name).Select(_ => func()));
}
/// <summary>
/// Look at whether something else is controlling vertical height, in which
/// case we become strictly 2D.
/// </summary>
/// <param name="myReflex"></param>
public override void Fixup(Reflex myReflex)
{
base.Fixup(myReflex);
/// Look over the reflex. If anything else wants to control vertical motion,
/// then we won't.
Task task = myReflex.Task;
controlZ = true;
for (int iref = 0; iref < task.reflexes.Count; ++iref)
{
Reflex otherReflex = task.reflexes[iref] as Reflex;
if ((otherReflex != null) && (otherReflex != myReflex))
{
Selector otherSelector = otherReflex.Selector;
if ((otherSelector is MoveDownSelector) ||
(otherSelector is MoveUpDownSelector) ||
(otherSelector is MoveUpSelector))
{
controlZ = false;
break;
}
}
}
}
public override void Reset(Reflex reflex)
{
frame = 0;
scores.Clear();
base.Reset(reflex);
}
public override bool MatchAction(Reflex reflex, out object param)
{
param = null; // doesn't effect match action
bool match = false;
if (reflex.targetSet.Nearest != null)
{
match = reflex.targetSet.Nearest.GameThing == reflex.Task.GameActor;
}
if (reflex.Data.Sensor is TouchSensor)
{
match |= reflex.TouchActor == reflex.Task.GameActor;
}
else
{
match |= reflex.MouseActor == reflex.Task.GameActor;
}
if (!match)
{
reflex.MousePosition = null;
reflex.TouchPosition = null;
}
return(match);
}
public override bool MatchAction(Reflex reflex, out object param)
{
param = null;
bool match = false;
if (reflex.targetSet != null && reflex.targetSet.Param != null)
{
GameScoredSensor sensor = reflex.Sensor as GameScoredSensor;
Classification.Colors color = (Classification.Colors)reflex.targetSet.Param;
int curr = 0, prev;
Scoreboard.Score score = sensor.GetScore(color);
if (score != null)
{
curr = score.Curr;
prev = score.Prev;
// If the score changed and jumped across or landed on the trigger score
if ((prev != curr) &&
((prev < scoreTriggerValue && curr >= scoreTriggerValue) ||
(prev > scoreTriggerValue && curr <= scoreTriggerValue)))
{
match = true;
}
}
}
return(match);
}
// helper method
protected bool TestObjectSet(Reflex reflex)
{
List <Filter> filters = reflex.Filters;
bool match = true;
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
object param;
if (!filter.MatchAction(reflex, out param))
{
match = false;
break;
}
if (param != null)
{
reflex.targetSet.Param = param;
}
}
// After everything is done, apply the not filter,
// if any, to negate the result.
if (reflex.Data.FilterExists("filter.not"))
{
match = !match;
}
match = PostProcessAction(match, reflex);
return(match);
} // end TestObjectSet()
public override ActionSet ComposeActionSet(Reflex reflex, GameActor gameActor)
{
ClearActionSet(actionSet);
UpdateCanBlend(reflex);
if (!reflex.targetSet.AnyAction)
{
return(actionSet);
}
if (reflex.targetSet.Count > 0)
{
if (reflex.targetSet.CullToFurthest(gameActor, BlockedFrom))
{
// the targetSet is in order by distance
SensorTarget target = reflex.targetSet.Furthest;
// calculate a vector toward target
Vector3 value = target.Direction;
bool apply = reflex.ModifyHeading(gameActor, Modifier.ReferenceFrames.World, ref value);
if (apply)
{
// radius should be from object
actionSet.AddAttractor(AllocAttractor(target.Range, value, target.GameThing, reflex), 0.4f);
}
}
}
return(actionSet);
}
public void InsertReflexAfter(Reflex reflexRef, Reflex reflexNew)
{
int indexInsert = reflexes.IndexOf(reflexRef);
indexInsert++;
reflexes.Insert(indexInsert, reflexNew);
}
public override void ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
List <Filter> filters = reflex.Filters;
_typeList.Clear();
/// We never fire until we have valid data to base a trigger on.
if (TerrainMaterial.IsValid(OverrideSenseMaterial, false, false))
{
_typeList.AddType(OverrideSenseMaterial);
reflex.targetSet.Param = _typeList;
reflex.targetSet.Action = TestObjectSet(reflex);
}
else if (gameActor.Chassis.TerrainDataValid)
{
gameActor.Chassis.GetTerrainMaterials(_typeList);
reflex.targetSet.Param = _typeList;
reflex.targetSet.Action = TestObjectSet(reflex);
}
else
{
reflex.targetSet.Action = false;
}
} // end of ComposeSensorTargetSet()
public override void Reset(Reflex reflex)
{
Fired = false;
applyCount = 0;
fireCount = 0;
base.Reset(reflex);
}
public Neuron(ProcessorContainer pc)
{
if (pc == null)
{
throw new ArgumentNullException();
}
if (pc.Count > char.MaxValue)
{
throw new ArgumentException();
}
_procNames = new Dictionary <char, char>(pc.Count);
ProcessorHandler ph = new ProcessorHandler();
StringBuilder sb = new StringBuilder(pc.Count);
for (char k = char.MinValue; k < pc.Count; ++k)
{
if (!ph.Add(ProcessorHandler.RenameProcessor(pc[k], new string(k, 1))))
{
continue;
}
char c = char.ToUpper(pc[k].Tag[0]);
_procNames[c] = k;
sb.Append(c);
}
_processorContainer = ph.Processors;
_workReflex = new Reflex(_processorContainer);
_stringQuery = sb.ToString();
}
public override ActionSet ComposeActionSet(Reflex reflex, GameActor gameActor)
{
ClearActionSet(actionSet);
UpdateCanBlend(reflex);
if (!reflex.targetSet.AnyAction)
{
return(actionSet);
}
Vector2 valueStick = Vector2.Zero;
if (reflex.targetSet.Param != null && reflex.targetSet.Param is Vector2)
{
// Read the gamepad input
valueStick = (Vector2)reflex.targetSet.Param;
valueStick.X = 0;
}
else
{
valueStick = new Vector2(0, 1.0f);
}
actionSet.AddAction(Action.AllocVerticalRateAction(reflex, valueStick.Y));
return(actionSet);
}
/// <summary>
/// Look and see if the terrains touuched (cached in reflex.Param) match the terrain type we're looking for (cached
/// in Reflex.MaterialType).
/// </summary>
/// <param name="reflex"></param>
/// <param name="targetSet"></param>
/// <param name="sensorCategory"></param>
/// <param name="param"></param>
/// <returns></returns>
public override bool MatchAction(Reflex reflex, out object param)
{
if (reflex.targetSet.Param is Terrain.TypeList)
{
Terrain.TypeList typeList = reflex.targetSet.Param as Terrain.TypeList;
if (typeList != null)
{
if (typeList.HasType(reflex.MaterialType))
{
param = reflex.MaterialType;
return(true);
}
}
}
else if (reflex.targetSet.Param is int)
{
ushort type = (ushort)reflex.targetSet.Param;
if (type == reflex.MaterialType)
{
param = reflex.MaterialType;
return(true);
}
}
param = null;
return(false);
}
private new bool TestObjectSet(Reflex reflex)
{
List <Filter> filters = reflex.Filters;
bool match = true;
object param;
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
// skip player filter
if (!(filter is PlayerFilter))
{
if (!filter.MatchAction(reflex, out param))
{
match = false;
break;
}
if (param != null)
{
reflex.targetSet.Param = param;
}
}
}
if (reflex.Data.GetFilterCountByType(typeof(NotFilter)) > 0)
{
match = !match;
}
match = PostProcessAction(match, reflex);
return(match);
}
public override void ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
List <Filter> filters = reflex.Filters;
SensorTargetSet.Enumerator senseSetIter = (SensorTargetSet.Enumerator)gameActor.GivenSet.GetEnumerator();
senseSetIter.Reset();
while (senseSetIter.MoveNext())
{
SensorTarget target = (SensorTarget)senseSetIter.Current;
bool match = true;
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
if (!filter.MatchTarget(reflex, target))
{
match = false;
break;
}
}
if (match)
{
reflex.targetSet.Add(target);
}
}
reflex.targetSet.Action = TestObjectSet(reflex);
}
public override bool MatchAction(Reflex reflex, out object param)
{
bool match = (reflex.targetSet == null || reflex.targetSet.Count == 0);
param = null;
return(match);
}
public override bool MatchAction(Reflex reflex, out object param)
{
param = null;
bool match = Compare(reflex.targetSet.Count);
return(match);
}
/// <summary>
/// Remove all invalid elements from reflexes
/// </summary>
internal void Validate()
{
for (int i = 0; i < reflexes.Count; ++i)
{
Reflex reflex = reflexes[i] as Reflex;
reflex.Validate();
}
}
public Neuron(ProcessorContainer pc)
{
ProcessorHandler ph = FromProcessorContainer(pc);
_workReflex = new Reflex(ph.Processors);
_procNames = ph.ToHashSet();
_stringOriginalUniqueQuery = ph.ToString();
}
} // end of FixUp()
public void Reset()
{
for (int indexReflex = 0; indexReflex < reflexes.Count; indexReflex++)
{
Reflex reflex = reflexes[indexReflex] as Reflex;
reflex.Reset();
}
}
public override ActionSet ComposeActionSet(Reflex reflex, GameActor gameActor)
{
ClearActionSet(actionSet);
UpdateCanBlend(reflex);
if (!reflex.targetSet.AnyAction)
{
return(actionSet);
}
Vector3 target = Vector3.Zero;
bool approachPoint = true;
if (!this.used)
{
approachPoint = FindClosestMatchingWaypointSetTarget(reflex, gameActor, out target);
}
if (approachPoint)
{
gameActor.followPathState.FollowTarget = target;
// Calc 2d dist to target.
Vector3 delta = gameActor.Movement.Position - target;
delta.Z = 0; // Force 2d.
// Test if we are close enough that we reached our follow target.
if (delta.Length() < accuracy)
{
if (ClosestNodeIsTarget(gameActor))
{
bool validTarget = ReachedWaypoint(gameActor, ref target);
if (validTarget)
{
gameActor.followPathState.FollowTarget = target;
}
else
{
// No valid target so just bail.
return(actionSet);
}
}
}
target = gameActor.followPathState.FollowTarget;
// If not controlling Z, we want movement to be 2D so set
// the target Z value to match the actor's current Z value.
if (!controlZ)
{
target.Z = gameActor.Movement.Altitude;
}
actionSet.AddAction(Action.AllocTargetLocationAction(reflex, target, autoTurn: true));
}
return(actionSet);
} // end of ComposeActionSet()
private new bool TestObjectSet(Reflex reflex)
{
bool match = true;
if (reflex.Data.GetFilterCountByType(typeof(KeyBoardKeyFilter)) > 0)
{
List <Filter> filters = reflex.Filters;
object param;
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
if (!filter.MatchAction(reflex, out param))
{
match = false;
break;
}
if (param != null)
{
reflex.targetSet.Param = param;
}
}
}
else if (reflex.Actuator is MovementActuator || reflex.Actuator is TurnActuator)
{
match = false;
// TODO All this boxing can't be a good thing. Try to refactor it out.
// For the built in keyboard args we need to blend their input. So, start with
// 0,0 and add in each active key. Finally, normalize the result.
reflex.targetSet.Param = Vector2.Zero;
object param;
for (int indexFilter = 0; indexFilter < movementBuiltins.Count; indexFilter++)
{
Filter filter = movementBuiltins[indexFilter] as Filter;
if (filter.MatchAction(reflex, out param))
{
match = true;
if (param != null)
{
reflex.targetSet.Param = (Vector2)(reflex.targetSet.Param) + (Vector2)param;
}
}
}
((Vector2)reflex.targetSet.Param).Normalize();
}
if (reflex.Data.GetFilterCountByType(typeof(NotFilter)) > 0)
{
match = !match;
}
match = PostProcessAction(match, reflex);
return(match);
}
public override bool MatchAction(Reflex reflex, out object param)
{
param = null;
// Previously the default here was false. But when I removed the hiddendefault comparison
// this started causing timers with random times to fail. HiddenDefault is evil and
// should never exist.
// At a deeper level there's something not quite right with the architecture if it doesn't
// allow scores to be used as timer inputs without adding hidden tiles. Need to understand
// this better.
bool match = true;
if (reflex.targetSet != null && reflex.targetSet.Param != null)
{
GameScoredSensorResult sensorResult = (GameScoredSensorResult)reflex.targetSet.Param;
Debug.Assert(sensorResult != null, "Why would this ever be null?");
// Just looking to see if that bucket has changed.
if (sensorResult.TestingForChange)
{
match = sensorResult.ScoreChanged;
}
else
{
// Actually doing a comparison.
switch (op)
{
case ScoreCompare.Is:
match = sensorResult.LeftValue == sensorResult.RightValue;
break;
case ScoreCompare.Above:
match = sensorResult.LeftValue > sensorResult.RightValue;
break;
case ScoreCompare.Below:
match = sensorResult.LeftValue < sensorResult.RightValue;
break;
case ScoreCompare.GTEQ:
match = sensorResult.LeftValue >= sensorResult.RightValue;
break;
case ScoreCompare.LTEQ:
match = sensorResult.LeftValue <= sensorResult.RightValue;
break;
case ScoreCompare.NotIs:
match = sensorResult.LeftValue != sensorResult.RightValue;
break;
}
}
} // if not null target set
return(match);
} // end of MatchAction()
//-----------------------------------------------------
public SceneModel()
{
m_cameraData = new List<Hlips>();
m_lightData = new List<Ahibp>();
m_shadowData = new List<Ahibp>();
m_redoCam = new List<Hlips>();
m_redoLight = new List<Ahibp>();
m_redoShadow = new List<Ahibp>();
m_reflex = new Reflex(6,0);
m_mode2D = new M2D();
//m_originalState = new Hlips(0,0,0,0,0);
}
