var value = UO.HP();
UO.Print("HP: " + Convert.ToString(value));

object? hand = UO.ObjAtLayer("Rhand");
if (hand is string serial)
{
    UO.Print("Right hand serial: " + serial);
}
else
{
    UO.Print("Right hand is empty or unavailable");
}

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

int UO.Alive();
int UO.Alive(object? value);

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

var active = UO.Alive();
if (Truth(Truth(active) == true))
{
    UO.Print("State is active");
}
else
{
    UO.Print("State is inactive or unavailable");
}

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.Exists("lasttarget")))
    {
        var observed = ReadState("lasttarget");
        UO.Print("State 1/0: " + Convert.ToString(observed));
    }

    return null;
}

dynamic ReadState(dynamic obj)
{
    return UO.Alive(obj);
}

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 before = UO.Alive();
        await Delay(500);
        var after = UO.Alive();
        if (Truth(before != after))
        {
            UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
        }

        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;
}

serial => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

() => getter(bridge.Self)

serial => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

value => getter(GetObject(value))

void UO.Arm(object? name);

UO.Print("Calling UO.Arm");
UO.Arm("battle");

UO.Arm("battle");

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    UO.Arm("battle");
    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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        UO.Arm("battle");
        return AwaitSlot(1, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

    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;
    }

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

public void Arm(string name)

            => Equip(name, armSets, weaponLayers, "Weapon set requests processed.", "No weapons set with setarm.");

int UO.Armor();

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

var value = UO.Armor();
UO.Print("PhysicalResistance: " + Convert.ToString(value));

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.Armor();
    await Delay(500);
    var after = UO.Armor();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

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(Truth(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic ResistanceAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.Armor();
        return value >= minimum;
    }

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

case "armor": return new InjectionValue(bridge.Armor);

dynamic UO.CharName();

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

var text = UO.CharName();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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 text = UO.CharName();
    UO.Print("Player имя: " + text);
    return null;
}

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 previous = UO.CharName();
        await Delay(1000);
        var current = UO.CharName();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

        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;
}

case "getname":

                case "charname": return new InjectionValue(bridge.GetName(Arg(0, bridge.Self)));

dynamic UO.CharTitle();

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

var text = UO.CharTitle();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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 text = UO.CharTitle();
    UO.Print("Player титул: " + text);
    return null;
}

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 previous = UO.CharTitle();
        await Delay(1000);
        var current = UO.CharTitle();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

        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;
}

case "chartitle": return new InjectionValue(bridge.CharacterTitle);

string UO.CharacterTitle();

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

var text = UO.CharacterTitle();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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 text = UO.CharacterTitle();
    UO.Print("Player титул: " + text);
    return null;
}

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 previous = UO.CharacterTitle();
        await Delay(1000);
        var current = UO.CharacterTitle();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

        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;
}

() => bridge.CharacterTitle

int UO.ColdResist();

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

var value = UO.ColdResist();
UO.Print("ColdResistance: " + Convert.ToString(value));

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.ColdResist();
    await Delay(500);
    var after = UO.ColdResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

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(Truth(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic ResistanceAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.ColdResist();
        return value >= minimum;
    }

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

case "coldresist": return new InjectionValue(bridge.ColdResistance);

int UO.Dead();
int UO.Dead(object? id);

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

var active = UO.Dead();
if (Truth(Truth(active) == true))
{
    UO.Print("State is active");
}
else
{
    UO.Print("State is inactive or unavailable");
}

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.Exists("lasttarget")))
    {
        var observed = ReadState("lasttarget");
        UO.Print("State 1/0: " + Convert.ToString(observed));
    }

    return null;
}

dynamic ReadState(dynamic obj)
{
    return UO.Dead(obj);
}

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 before = UO.Dead();
        await Delay(500);
        var after = UO.Dead();
        if (Truth(before != after))
        {
            UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
        }

        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;
}

public int Dead() => bridge.Dead();

public int Dead(InjectionValue id)

        {

            int serial = GetObject(id);

            if (serial == bridge.Self)

                return Dead();

            return serial > 0 ? bridge.IsDead(serial) : 0;

        }

int UO.Dex();

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

var value = UO.Dex();
UO.Print("Dexterity: " + Convert.ToString(value));

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.Dex();
    await Delay(1000);
    var after = UO.Dex();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

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(Truth(AttributeAtLeast(80)) == true))
        {
            UO.Print("Requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic AttributeAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.Dex();
        return value >= minimum;
    }

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

case "dex": return new InjectionValue(bridge.Dexterity);

int UO.Dexterity();

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

var value = UO.Dexterity();
UO.Print("Dexterity: " + Convert.ToString(value));

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.Dexterity();
    await Delay(1000);
    var after = UO.Dexterity();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

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(Truth(AttributeAtLeast(80)) == true))
        {
            UO.Print("Requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic AttributeAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.Dexterity();
        return value >= minimum;
    }

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

() => bridge.Dexterity

int UO.Disarm();

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

return UO.Disarm();

return  RunScenario();
 object? RunScenario()
{
    var first = UO.ObjAtLayerEx(1, UO.Self());
    var second = UO.ObjAtLayerEx(2, UO.Self());
    if (Truth(first == 0) || Truth(second == 0))
    {
        return 0;
    }

    UO.AddObject("saved_first", first);
    UO.AddObject("saved_second", second);
    return UO.Disarm();
    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()
    {
        return ChangeAndConfirm();
        return null;
    }

    dynamic ChangeAndConfirm()
    {
        if (!(Truth(UO.Disarm())))
        {
            return 0;
        }

        dynamic[] layers = new dynamic[checked((int)(1) + 1)];
        layers[0] = 1;
        layers[1] = 2;
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            dynamic empty = true;
            for (int i = (int)(0); i <= ArrayLength(layers) - 1; i += (int)(1))
            {
                if (Truth(UO.ObjAtLayerEx(layers[i], UO.Self()) != 0))
                {
                    empty = false;
                }
            }

            if (Truth(empty))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

public int Disarm()

            => Unequip(weaponLayers, "Weapons disarmed.");

int UO.Dismount();

int mountLayerSerial = UO.Dismount();
UO.Print(UO.Int2Hex(mountLayerSerial));

var before = UO.ObjAtLayer("Mount");
int currentSerial = UO.Dismount();
UO.Print($"{before} -> {UO.Int2Hex(currentSerial)}");

UO.Dismount();
await WaitAsync(250);
UO.Print(Convert.ToString(UO.ObjAtLayer("Mount")));

new CommandSample().Execute(UO);

sealed class CommandSample
{
    public void Execute(global::ClassicUO.CSharp.CSharpGameApi api)
    {
        int mountLayerSerial = api.Dismount();
        api.Print(api.Int2Hex(mountLayerSerial));
    }
}

void UO.Dress(object? name);

UO.Print("Calling UO.Dress");
UO.Dress("travel");

UO.Dress("travel");

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    UO.Dress("travel");
    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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        UO.Dress("travel");
        return AwaitSlot(3, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

    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;
    }

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