/// <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 ProgrammingElement Clone()
{
ClassificationFilter clone = new ClassificationFilter();
CopyTo(clone);
return(clone);
}
public override void ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
List <Filter> filters = reflex.Filters;
// add normal sightSet of items to the targetset
//
senseSetIter.Reset();
while (senseSetIter.MoveNext())
{
SensorTarget target = (SensorTarget)senseSetIter.Current;
bool match = true;
bool cursorFilterPresent = false;
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
ClassificationFilter cursorFilter = filter as ClassificationFilter;
if (cursorFilter != null && cursorFilter.classification.IsCursor)
{
cursorFilterPresent = true;
}
if (!filter.MatchTarget(reflex, target))
{
match = false;
break;
}
}
if (match)
{
if (!target.Classification.IsCursor || cursorFilterPresent)
{
reflex.targetSet.Add(target);
}
}
}
if (ListeningForMusic(filters))
{
if (HearMusic(filters))
{
SensorTarget sensorTarget = SensorTargetSpares.Alloc();
sensorTarget.Init(gameActor, Vector3.UnitZ, 0.0f);
reflex.targetSet.AddOrFree(sensorTarget);
}
}
reflex.targetSet.Action = TestObjectSet(reflex);
if (reflex.targetSet.Action)
{
foreach (SensorTarget targ in reflex.targetSet)
{
gameActor.AddSoundLine(targ.GameThing);
}
}
}
public override void ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
List <Filter> filters = reflex.Filters;
// add normal senseSet of items to the targetset
//
senseSetIter.Reset();
while (senseSetIter.MoveNext())
{
SensorTarget target = (SensorTarget)senseSetIter.Current;
bool match = true;
bool cursorFilterPresent = false;
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
ClassificationFilter cursorFilter = filter as ClassificationFilter;
if (cursorFilter != null && cursorFilter.classification.IsCursor)
{
cursorFilterPresent = true;
}
if (!filter.MatchTarget(reflex, target))
{
match = false;
break;
}
}
if (match)
{
if (!target.Classification.IsCursor || cursorFilterPresent)
{
reflex.targetSet.Add(target);
}
}
}
reflex.targetSet.Finialize();
if (reflex.targetSet.Nearest == null)
{
/// Didn't come up with anything, try searching our memory
if (SearchMemory(gameActor, reflex))
{
/// Find nearest again, but don't check LOS. This matches old
/// behavior, which assumes that if we remember it, we could see it.
reflex.targetSet.Finialize();
}
}
else
{
/// We got something, memorize it.
gameActor.Brain.Memory.MemorizeThing(reflex.targetSet.Nearest.GameThing);
}
reflex.targetSet.Action = TestObjectSet(reflex);
} // end of ComposeSensorTargetSet()
public override void ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
List <Filter> filters = reflex.Filters;
foreach (SensorTarget target in sightSet)
{
// Don't see things we are holding.
if (target.GameThing == gameActor.ThingBeingHeldByThisActor)
{
continue;
}
bool match = true;
bool cursorFilterPresent = false;
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
ClassificationFilter cursorFilter = filter as ClassificationFilter;
if (cursorFilter != null && cursorFilter.classification.IsCursor)
{
cursorFilterPresent = true;
}
if (!filter.MatchTarget(reflex, target))
{
match = false;
break;
}
}
if (match)
{
if (!target.Classification.IsCursor || cursorFilterPresent)
{
reflex.targetSet.Add(target);
}
}
}
reflex.targetSet.Action = TestObjectSet(reflex);
if (reflex.targetSet.Action)
{
SensorTarget nearest = reflex.targetSet.Nearest;
if (nearest != null)
{
gameActor.AddSightLine(nearest.GameThing);
}
}
else
{
reflex.targetSet.Clear();
}
} // end of ComposeSensorTargetSet()
public override void ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
List <Filter> filters = reflex.Filters;
SensorTargetSet.Enumerator beamedSetIter = gameActor.BeamedSetIter;
beamedSetIter.Reset();
while (beamedSetIter.MoveNext())
{
SensorTarget target = (SensorTarget)beamedSetIter.Current;
bool match = true;
bool cursorFilterPresent = false;
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
ClassificationFilter cursorFilter = filter as ClassificationFilter;
if (cursorFilter != null && cursorFilter.classification.IsCursor)
{
cursorFilterPresent = true;
}
if (!filter.MatchTarget(reflex, target))
{
match = false;
break;
}
}
if (match)
{
if (!target.Classification.IsCursor || cursorFilterPresent)
{
reflex.targetSet.Add(target);
}
}
}
reflex.targetSet.Action = TestObjectSet(reflex);
}
public override SensorTargetSet ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
List <Filter> filters = reflex.Filters;
targetSet.Clear();
for (int iSet = 0; iSet < heardSet.Count; iSet++)
{
bool match = true;
bool cursorFilterPresent = false;
SensorTarget target = heardSet[iSet];
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
ClassificationFilter cursorFilter = filter as ClassificationFilter;
if (cursorFilter != null && cursorFilter.classification.IsCursor)
{
cursorFilterPresent = true;
}
if (!filter.MatchTarget(reflex, target, this.category))
{
match = false;
break;
}
}
if (match)
{
if (!target.Classification.IsCursor || cursorFilterPresent)
{
targetSet.Add(target.Ref());
}
}
}
targetSet.Finialize();
targetSet.Action = TestObjectSet(reflex);
return(targetSet);
}
private bool ListeningForMusic(List <Filter> filters)
{
bool listenForMusic = false;
foreach (Filter f in filters)
{
ClassificationFilter classFilter = f as ClassificationFilter;
if (classFilter != null)
{
/// Don't mess around, a class filter disqualifies the whole process.
return(false);
}
SoundFilter soundFilter = f as SoundFilter;
if (soundFilter != null)
{
if (!BokuGame.Audio.IsSpatial(soundFilter.sound))
{
listenForMusic = true;
}
}
}
return(listenForMusic);
}
protected void CopyTo(ClassificationFilter clone)
{
base.CopyTo(clone);
clone.classification = this.classification;
clone.MatchType = this.MatchType;
}
