public static void OnEnter(ref int frame, Resettable obj)
{
#if !AL_THREAD_SAFE
RoR.OnResume(ref frame, obj.Reset);
ReCon.instance.Add(obj);
#endif
}
public Gate? this[int duration] {
get{
RoR.OnResume(ref frame, Reset);
return((++elapsed > duration) ? done(log && $"[0]")
: cont(log && $"[{duration-elapsed}]"));
}
}
[Test] public void Exit_match_frame()
{
int φ = 10;
RoR.Enter("Nemo", 8, leniency: 1);
Assert.Throws <InvOp>(() => RoR.Exit("Nemo", ref φ));
}
[Test] public void Exit_match_context()
{
int φ = 10;
RoR.Enter("Nemo", φ);
Assert.Throws <InvOp>(() => RoR.Exit("Foo", ref φ));
}
// disabled mode -----------------------------------------------
[Test] public void Enter_disabled()
{
RoR.enabled = false;
RoR.Enter(this, 0, leniency: 1);
o(RoR.owner, null);
o(RoR.frame, 0);
}
public Gate? this[float duration] {
get{
RoR.OnResume(ref frame, Reset);
return(((elapsed += UnityEngine.Time.deltaTime) >= duration)
? done(log && $"[0.0]")
: cont(log && $"[{duration-elapsed:0.0}]"));
}
}
[Test] public void Exit()
{
int φ = 10;
RoR.Enter(this, φ, leniency: 1);
RoR.Exit(this, ref φ);
o(RoR.owner, null);
o(φ, 11);
}
[Test] public void Exit_disabled()
{
int φ = 10;
RoR.enabled = false;
RoR.Exit(this, ref φ);
o(RoR.owner, null);
o(RoR.frame, 0);
}
[Test] public void OnResume_disabled()
{
RoR.enabled = false;
int frame = 12;
RoR.OnResume(ref frame, null);
o(RoR.owner, null);
o(RoR.frame, 0);
o(frame, 12);
}
[Test] public void OnResume_reset()
{
int φ = 15;
int γ = 10;
bool flag = true;
RoR.Enter("Nemo", φ);
RoR.OnResume(ref γ,
() => { flag = false; return(status.@void()); });
o(flag, false);
}
[Test] public void OnResume_continue()
{
int φ = 10;
int γ = 9;
bool flag = true;
RoR.Enter("Nemo", φ, leniency: 1);
RoR.OnResume(ref γ,
() => { flag = false; return(action.done()); });
o(flag, true);
}
[Test] public void OnResume_continue()
{
int φ = 10;
int γ = 9;
bool flag = true;
RoR.Enter("Nemo", φ);
RoR.OnResume(ref γ,
() => { flag = false; return(status.@void()); });
o(flag, true);
}
[Test] public void OnResume_reset([Values(0, 1)] int offset,
[Range(1, 5)] int leniency)
{
int φ = 15;
int γ = φ - (leniency + offset);
bool flag = true;
RoR.Enter("Nemo", φ, leniency);
RoR.OnResume(ref γ,
() => { flag = false; return(action.done()); });
o(flag, offset == 0 ? true : false);
}
public status Step()
{
status s = fail();
#if !AL_OPTIMIZE
status.log = enableLogging;
#endif
if (command != DoSuspend && command != DoPause)
{
if (root)
{
RoR.Enter(this, frame, leniency);
try{
s = root;
}catch (Exception) {
RoR.Exit(this, ref frame);
throw;
}
RoR.Exit(this, ref frame);
}
else
{
throw new Exception($"Rootless: {gameObject.name}");
}
if (!s.running)
{
enabled = shouldReenable;
}
#if !AL_OPTIMIZE
if (enableLogging)
{
Log(s);
}
#endif
}
if (command != null)
{
command(); command = null;
}
return(s);
}
// enabled mode ------------------------------------------------
[Test] public void Enter()
{
RoR.Enter(this, 10, leniency: 1);
o(RoR.owner, this);
o(RoR.frame, 10);
}
public Gate?this[bool cond] {
get{
RoR.OnResume(ref frame, Reset);
return((passing |= cond) ? done() : fail());
}
}
public Gate?this[bool @in, bool @out] {
get{
RoR.OnResume(ref frame, Reset);
return((passing = passing ? !@out : @in) ? done() : fail());
}
}
[Test] public void Enter_no_reassign()
{
RoR.owner = "Nemo";
Assert.Throws <InvOp>(() => RoR.Enter("Foo", 0, leniency: 1));
}
[Test] public void Enter_reject_null_context() => Assert.Throws <InvOp>(() => RoR.Enter(null, 0, leniency: 1));
[Test] public void OnResume_reject_null_context()
{
int γ = 10;
Assert.Throws <InvOp>(() => RoR.OnResume(ref γ, null));
}
