public bool Run(ref RSQuery query, RSManager manager, GameObject gameObject)
{
if (this.disabled)
{
return(false);
}
foreach (var critereonName in this.criteria)
{
if (!manager.criteria.ContainsKey(critereonName))
{
return(false);
}
RSCriterion critereon = manager.criteria[critereonName];
if (query.Matches(critereon) || critereon.Optional)
{
continue;
}
return(false);
}
if (this.Flags.HasFlag(RSRuleFlags.NoRepeat))
{
this.disabled = true;
}
return(manager.RunResponses(this.responses, ref query, gameObject));
}
public virtual void DispatchResponse(RSResponse response, ref RSQuery query, GameObject gameObject)
{
// just dispatch it to the entity who's having the response. if
// managers want to they can override this later.
RSEntity entity = gameObject.GetComponent(typeof(RSEntity)) as RSEntity;
entity.DispatchResponse(response, ref query);
}
void RunResponse(RSResponse response, RSManager manager, ref RSQuery query, GameObject gameObject)
{
// update response's dontResayBefore timer and disabled bool
// based on response's norepeat flag
response.JustFired();
if (this.flags.HasFlag(RSResponseGroupFlags.PermitRepeats))
{
//TODO(dan): if this response is First, we should have a
// special bool on the response called CanBeFirst, which we
// set to false here, so that this response is no longer
// marked as the 'first' response to call. because it
// already has been.
// maybe it'd be worth just disabling the response right now
// if it has the first flag, but I'd need to try out the system
// to figure out whether that's the most intuiative way to
// handle this certain combination of flags:
// group[PermitRepeats] response[First]
//
// though to be honest, having a NoRepeat flag on the response
// would deliver the above proposed functionality, so it
// instead probably makes sense to do the CanBeFirst thing.
return;
}
bool anyResponsesYetToFire = false;
foreach (var ri in this.responses)
{
if (!ri.Disabled)
{
anyResponsesYetToFire = true;
break;
}
}
if (!anyResponsesYetToFire)
{
if (this.flags.HasFlag(RSResponseGroupFlags.NoRepeat))
{
this.disabled = true;
return;
}
// reset all resettable responses because we're bloody out
foreach (var ri in this.responses)
{
if (!ri.Flags.HasFlag(RSResponseFlags.NoRepeat))
{
ri.Disabled = false;
}
}
}
// actually run the response and do response-like things for it.
manager.DispatchResponse(response, ref query, gameObject);
}
public void Run(ref RSQuery query, RSManager manager, GameObject gameObject)
{
// simple, run the first rule that matches.
// this will always be the most specific rule because of how we
// insert rules into our bucket.
foreach (var rule in this.rules)
{
if (rule.Run(ref query, manager, gameObject))
{
break;
}
}
}
IEnumerator IdleLoop()
{
GameObject nextIdlingEntity = null;
while (true)
{
if (nextIdlingEntity != null)
{
RSEntity entity = nextIdlingEntity.GetComponent(typeof(RSEntity)) as RSEntity;
// update idle time
var nextIdleTime = DateTime.Now.AddSeconds(entity.secondsBetweenIdle + UnityEngine.Random.Range(entity.idleJitter * -1, entity.idleJitter));
this.entityNextIdleTime[nextIdlingEntity] = nextIdleTime;
// actually make the entity idle
Debug.Log("entity " + entity.Name + " is idling");
var query = new RSQuery();
query.Set("concept", "idle");
query.Set("who", entity.Name);
entity.UpdateFacts();
query.AddFactDictionary(ref entity.Facts);
this.UpdateFacts();
query.AddFactDictionary(ref this.Facts);
this.Run(ref query, nextIdlingEntity);
}
// find next idling entity
DateTime idleTime = DateTime.MaxValue;
foreach (KeyValuePair <GameObject, DateTime> val in this.entityNextIdleTime)
{
if (val.Value.CompareTo(idleTime) < 0)
{
idleTime = val.Value;
nextIdlingEntity = val.Key;
}
}
float idleSecs = (float)idleTime.Subtract(DateTime.Now).TotalSeconds;
if (this.idleMungeSeconds < idleSecs)
{
yield return(new WaitForSeconds(idleSecs));
}
else
{
yield return(null);
}
}
}
public bool RunResponses(List <string> responses, ref RSQuery query, GameObject gameObject)
{
bool responseRun = false;
foreach (var response in responses)
{
if (!this.responseGroups.ContainsKey(response))
{
continue;
}
var trr = this.responseGroups[response].Run(this, ref query, gameObject);
if (responseRun == false)
{
responseRun = trr;
}
}
return(responseRun);
}
public bool Run(RSManager manager, ref RSQuery query, GameObject gameObject)
{
// we've got NoRepeat and have been disabled
if (this.disabled)
{
return(false);
}
Debug.Log("Running ResponseGroup called " + this.Name);
if (this.firstResponse != null)
{
RSResponse firstResponse = this.responses[(int)this.firstResponse];
if (firstResponse.CanFire())
{
this.RunResponse(firstResponse, manager, ref query, gameObject);
return(true);
}
}
RSResponse lastResponse = null;
if (this.lastResponse != null)
{
lastResponse = this.responses[(int)this.lastResponse];
// confirm that no other un-disabled responses can be run
bool anyOtherResponsesCanFire = false;
foreach (var response in this.responses)
{
if (!response.Disabled)
{
anyOtherResponsesCanFire = true;
break;
}
}
if (!anyOtherResponsesCanFire && lastResponse.CanFire())
{
this.RunResponse(lastResponse, manager, ref query, gameObject);
return(true);
}
// going forward in this function, lastResponse is one that we
// shouldn't call because if we were to call it it would've
// already happened above ^
}
if (this.flags.HasFlag(RSResponseGroupFlags.Sequential))
{
// run responses sequentially
foreach (var response in this.responses)
{
if (response.CanFire())
{
this.RunResponse(response, manager, ref query, gameObject);
return(true);
}
}
}
else
{
// get a random response, weighted appropriately, and fire it.
float totalWeight = 0;
RSResponse finalResponseWeSaw = null;
foreach (var response in this.responses)
{
if (response != lastResponse && response.CanFire())
{
totalWeight += response.Weight;
finalResponseWeSaw = response;
}
}
if (finalResponseWeSaw == null)
{
// no valid responses
return(false);
}
float weight = UnityEngine.Random.Range(0F, totalWeight);
foreach (var response in this.responses)
{
if (response == lastResponse)
{
continue;
}
if (response.CanFire())
{
weight -= response.Weight;
}
if (weight <= 0 || response == finalResponseWeSaw)
{
this.RunResponse(response, manager, ref query, gameObject);
return(true);
}
}
}
return(false);
}
public virtual void DispatchResponse(RSResponse response, ref RSQuery query)
{
Debug.Log("resp:: " + response.ResponseValue);
}
public void Run(ref RSQuery query, GameObject gameObject)
{
this.lazyAllRules.Run(ref query, this, gameObject);
}
