UO.CancelWaitTarget();
if (Truth(UO.Cast("Cure")))
{
    UO.Print("Choose the character with the spell cursor");
}
else
{
    UO.Print("Cure request rejected");
}

bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

var accepted = UO.CastToObject("Heal", "self");
UO.Print(Convert.ToString(accepted));

void UO.AddGate(object? bookSerial);

UO.Print("Calling UO.AddGate");
UO.AddGate("0x40012345");

UO.AddGate("0x40012345");

return  RunScenario();
 object? RunScenario()
{
    var bookSerial = "0x40012345";
    UO.AddGate(bookSerial);
    return null;
}

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        RememberGateBook("0x40012345");
        return null;
    }

    void RememberGateBook(dynamic bookSerial)
    {
        UO.AddGate(bookSerial);
    }
}

case "adddir":

                case "addfindlist":

                case "addgate":

                case "addrecall":

                case "addstep":

                    LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));

                    break;

void UO.AddRecall(object? bookSerial);

UO.Print("Calling UO.AddRecall");
UO.AddRecall("0x40012345");

UO.AddRecall("0x40012345");

return  RunScenario();
 object? RunScenario()
{
    var bookSerial = "0x40012345";
    UO.AddRecall(bookSerial);
    return null;
}

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.AddRecall("0x40012345");
        UO.AddRecall("0x40012346");
        return null;
    }
}

case "adddir":

                case "addfindlist":

                case "addgate":

                case "addrecall":

                case "addstep":

                    LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));

                    break;

int UO.Cast(object? spellName);

var result = UO.Cast("Cure");
UO.Print("Cast: " + Convert.ToString(result));

UO.CancelWaitTarget();
if (Truth(UO.Cast("Cure")))
{
    UO.Print("Choose the character with the spell cursor");
}
else
{
    UO.Print("Cure request rejected");
}

bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    UO.CancelWaitTarget();
    try
    {
        UO.WaitTargetObject("self");
        if (Truth(UO.Cast("Heal")))
        {
            await Delay(3000);
        }
    }
    finally
    {
        UO.CancelWaitTarget();
    }

    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var target = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(await CastAtObject("Greater Heal", target, 4000)))
        {
            UO.Print("Request sent; verify healing in the game");
        }

        return null;
    }

    async Task<dynamic> CastAtObject(dynamic spellName, dynamic target, dynamic cleanupDelayMs)
    {
        if (!(Truth(UO.Connected())) || Truth(UO.Dead()) || Truth(target <= 0) || !(Truth(UO.Exists(target))))
        {
            return false;
        }

        dynamic accepted = false;
        UO.CancelWaitTarget();
        try
        {
            UO.WaitTargetObject(target);
            accepted = UO.Cast(spellName);
            if (Truth(accepted))
            {
                await Delay(cleanupDelayMs);
            }
        }
        finally
        {
            UO.CancelWaitTarget();
        }

        return accepted;
    }

    int Asc(object? value, int fallback = 0)
    {
        string text = Convert.ToString(value) ?? "";
        if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
            return int.TryParse(text[2..], System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out int hex) ? hex : fallback;
        return int.TryParse(text, out int number) ? number : fallback;
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}

public int Cast(string spellName)

        {

            if (NumberConversions.TryStr2Int((spellName ?? string.Empty).Trim(), out _))

            {

                SystemMessage("UO.Cast: use one spell name, for example UO.Cast(\"Heal\").");

                return 0;

            }

            return CastCore(spellName) ? 1 : 0;

        }

int UO.CastAbility(object? abilityId);

var result = UO.CastAbility(UO.GetAbilityID("Armor Ignore"));
UO.Print("CastAbility: " + Convert.ToString(result));

var id = UO.GetAbilityID("Armor Ignore");
if (Truth(id > 0))
{
    var accepted = UO.CastAbility(id);
    UO.Print(Convert.ToString(accepted));
}

bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

return  RunScenario();
 object? RunScenario()
{
    var accepted = UO.CastAbility("Armor Ignore");
    UO.Print(Convert.ToString(accepted));
    return null;
}

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var accepted = UO.CastAbility(0);
        UO.Print(Convert.ToString(accepted));
        return null;
    }
}

public int UseAbility(int abilityId) => bridge.UseAbility(abilityId);

public int UseAbility(string abilityName)

        {

            int abilityId = bridge.ResolveAbility(abilityName);

            return abilityId > 0 ? bridge.UseAbility(abilityId) : 0;

        }

dynamic UO.CastToObject(object? spellName, object? objID);

object? result = UO.CastToObject("Heal", "self");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

var accepted = UO.CastToObject("Heal", "self");
UO.Print(Convert.ToString(accepted));

return  RunScenario();
 object? RunScenario()
{
    var accepted = UO.CastToObject(4, UO.Self());
    UO.Print(Convert.ToString(accepted));
    return null;
}

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var target = UO.LastTarget();
        if (Truth(UO.Exists(target)))
        {
            var accepted = UO.CastToObject("Greater Heal", target);
            UO.Print(Convert.ToString(accepted));
        }

        return null;
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}

case "casttoobject":

                    if (arguments[0].Kind == InjectionValueKind.String)

                        return CastAtTarget(arguments[0], arguments[1]) != 0 ? InjectionValue.True : InjectionValue.False;



                    WaitTargetObject(Arg(1));

                    int castAccepted = bridge.Cast(Arg(0));

                    if (castAccepted != 0)

                    {

                        ticksSpell = Timer();

                        return InjectionValue.True;

                    }



                    bridge.CancelTarget();

                    return InjectionValue.False;

dynamic UO.IsActiveSpellAbility(object? spellName);

object? result = UO.IsActiveSpellAbility(402);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

var active = UO.IsActiveSpellAbility(402);
if (Truth(Truth(active) == true))
{
    UO.Print("Confidence is active");
}
else
{
    UO.Print("No active Confidence state received");
}

bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.IsActiveSpellAbility("Confidence") == 0))
    {
        UO.Cast("Confidence");
    }

    return null;
}

bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(WaitAbilityState("Confidence", true, 500)))
        {
            UO.Print("Active state received");
        }
        else
        {
            UO.Print("No active state before timeout");
        }

        return null;
    }

    dynamic WaitAbilityState(dynamic spell, dynamic expected, dynamic timeoutMs)
    {
        var elapsed = 0;
        while (Truth(elapsed < timeoutMs))
        {
            if (Truth((UO.IsActiveSpellAbility(spell) == 1) == expected))
            {
                return true;
            }

            UO.Wait(25);
            elapsed = elapsed + 25;
        }

        return Truth((UO.IsActiveSpellAbility(spell) == 1) == expected);
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}

case "isactivespellability":

                {

                    int? spellId = arguments[0].Kind == InjectionValueKind.String

                        ? ConvertSpellName(Text(0).Replace('_', ' '))

                        : (int?)Arg(0);

                    return new InjectionValue(spellId.HasValue ? bridge.IsActiveSpell(spellId.Value) : 0);

                }

int UO.TicksSpell();

var result = UO.TicksSpell();
UO.Print("TicksSpell: " + Convert.ToString(result));

var stamp = UO.TicksSpell();
UO.Print(stamp);

return  RunScenario();
 object? RunScenario()
{
    var stamp = UO.TicksSpell();
    var ageTenths = UO.Timer() - stamp;
    UO.Print(ageTenths);
    return null;
}

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var before = UO.TicksSpell();
        UO.Wait(250);
        var after = UO.TicksSpell();
        UO.Print(before = after);
        return null;
    }
}

public int TicksSpell() => ticksSpell;