/// <param name="id">what incident to execute the given procedure on</param>
/// <param name="procedure">what to do for each of the count iterations</param>
/// <param name="count">how many times to execute the given procedure</param>
/// <param name="onLast">special logic to do in addition to the standard procedure on the last iteration</param>
/// <exception cref="Exception"></exception>
public void OnIncident(Proc.Id id, Proc.edure procedure, int count = -1, Proc.edure onLast = null)
{
if (count == 0)
{
return;
}
List <Proc.edure> responses = incidentResponseTable[id.Value];
if (count < 0)
{
responses.Add(procedure);
return;
}
Proc.edure countLimitedProcedure = incident => {
if (count <= 0)
{
throw new Exception("how was count decremented outside of this function?");
}
Proc.Result result = procedure.Invoke(incident);
--count;
if (count > 0)
{
return(result);
}
if (onLast != null && result == Proc.Result.Success)
{
result = onLast.Invoke(incident);
}
RemoveIncident(id.Value, procedure);
return(result);
};
responseAilias[procedure] = countLimitedProcedure;
responses.Add(countLimitedProcedure);
}
public int GetResponseIndex(Proc.Id id, Proc.edure response)
{
if (!IsValidCode(id.Value))
{
throw new Exception("bad incident code");
}
return(incidentResponseTable[id.Value].IndexOf(response));
}
/// <summary>
/// keep executing procedure until it returns Proc.Result.Success.
/// </summary>
/// <param name="id"></param>
/// <param name="procedure">incident listener is removed if result is <see cref="Proc.Result.Success"/>. should return <see cref="Proc.Result.Halt"/> until it should stop</param>
public Strategy ThenWhileIncident(Proc.Id id, Proc.edure procedure = null)
{
Strategy deferringStrategy = null;
deferringStrategy = ThenImmediately("(defer)" + id, incident => {
Strategy deferredStrategy = new Strategy("(deferred)" + id, procedure, this);
deferredStrategy.Next = deferringStrategy.Next;
deferredStrategy.IsDeferred = true;
Proc.WhileIncident(id, deferredStrategy.Invoke, deferringStrategy.ContinueChain);
return(Proc.Result.Halt);
});
return(deferringStrategy);
}
public Strategy ThenDelay(string identifier, int ms, Proc.edure procedure = null)
{
Strategy deferringStrategy = null;
deferringStrategy = ThenImmediately("(wait)" + identifier, incident => {
Strategy deferredStrategy = new Strategy(identifier, procedure, this);
deferredStrategy.Next = deferringStrategy.Next;
deferredStrategy.IsDeferred = true;
Proc.Delay(ms, deferredStrategy.InvokeChain);
return(Proc.Result.Halt);
});
return(deferringStrategy);
}
/// <summary>
/// keep executing procedure until it returns Proc.Result.Success.
/// </summary>
/// <param name="id"></param>
/// <param name="procedure">incident listener is removed if result is <see cref="Proc.Result.Success"/>. should return <see cref="Proc.Result.Halt"/> until it should stop</param>
/// <param name="onFinish"></param>
public void WhileIncident(Proc.Id id, Proc.edure procedure, Proc.edure onFinish)
{
List <Proc.edure> responses = incidentResponseTable[id.Value];
Proc.edure resultLimitedProcedure = incident => {
Proc.Result result = procedure.Invoke(incident);
if (result == Proc.Result.Success || result == Proc.Result.Failure)
{
RemoveIncident(id, procedure);
onFinish.Invoke(incident);
return(Proc.Result.Success);
}
return(result);
};
responseAilias[procedure] = resultLimitedProcedure;
responses.Add(resultLimitedProcedure);
}
/// <summary>
/// if a non-<see cref="Proc.edure"/> is used as a response to the incident, this should clear it
/// </summary>
public bool RemoveIncident(Proc.Id id, object procedure)
{
Proc.edure r = procedure as Proc.edure;
bool removed = false;
if (r == null)
{
if (responseAilias.TryGetValue(procedure, out r))
{
removed = responseAilias.Remove(procedure);
}
else
{
// Debug.LogWarning("the given response is not in the response table");
}
}
removed |= RemoveIncident(id, r);
return(removed);
}
public bool RemoveIncident(Proc.Id id, Proc.edure procedure)
{
bool removed = false;
if (IsValidCode(id.Value) && !incidentResponseTable[id.Value].Remove(procedure))
{
if (responseAilias.TryGetValue(procedure, out Proc.edure alias))
{
//RemoveIncident(incidentCode, alias);
incidentResponseTable[id.Value].Remove(alias);
removed |= responseAilias.Remove(procedure);
}
else
{
// Debug.LogWarning("the given response is not in the response table");
}
}
return(removed);
}
public static Incident Delay(long delay, Proc.edure response)
{
return(SystemClock.Delay(delay, response));
}
public static bool RemoveIncident(Proc.Id id, Proc.edure procedure)
{
return(Main.RemoveIncident(id, procedure));
}
public static int GetResponseIndex(int incidentCode, Proc.edure procedure)
{
return(Main.GetResponseIndex(incidentCode, procedure));
}
public static void WhileIncident(Proc.Id id, Proc.edure procedure, Proc.edure onFinish)
{
Main.WhileIncident(id, procedure, onFinish);
}
public static Incident RemoveScheduled(Proc.edure action)
{
return(Instance().timer.RemoveScheduled(action));
}
public static Incident Delay(long delayMs, Proc.edure procedure)
{
return(Instance().timer.Delay(delayMs, procedure));
}
public Strategy(MeritHeuristicFunctionType merit, string identifier, Proc.edure action, Strategy prev = null)
: this(identifier, action, prev)
{
MeritHeuristic = merit;
}
public static Incident Enqueue(Proc.edure response)
{
return(SystemClock.Delay(0, response));
}
public Strategy ThenImmediately(string identifier, Proc.edure procedure)
{
return(Next = new Strategy(identifier, procedure, this));
}
public Strategy AndThen(string identifier, Proc.edure procedure)
{
Next = new Strategy(identifier, procedure, this);
Next.WaitForUpdate = true;
return(Next);
}
// functions so we don't need to include "return Procedure.Result.Success;" at the end of each lambda
public static void OnIncident(Proc.Id id, Proc.edure procedure, int count = -1, Proc.edure onLast = null)
{
Main.OnIncident(id, procedure, count, onLast);
}
public Strategy(string identifier, Proc.edure action, Strategy prev = null)
: this(identifier, prev)
{
Procedure = action;
}
