private static string[] CommandWords(string command)
    {
        var words = new List<string>(); var word = new System.Text.StringBuilder(); char quote = '\0'; bool started = false;
        foreach (char letter in command)
        {
            if (quote != '\0') { if (letter == quote) quote = '\0'; else word.Append(letter); started = true; }
            else if (letter is '\'' or '"') { quote = letter; started = true; }
            else if (char.IsWhiteSpace(letter)) { if (started) { words.Add(word.ToString()); word.Clear(); started = false; } }
            else { word.Append(letter); started = true; }
        }
        if (quote != '\0') throw new ArgumentException("Unclosed quote in callback command.");
        if (started) words.Add(word.ToString());
        return words.ToArray();
    }

public bool IsRunning(string name)
    {
        Verify();
        lock (sync) return active.Any(call => call.Name.Equals((name ?? "").Trim(), StringComparison.OrdinalIgnoreCase)
            && !call.Cancellation.IsCancellationRequested);
    }

public static void Attack(World world, uint serial)
        {
            if (ProfileManager.CurrentProfile.EnabledCriminalActionQuery)
            {
                Mobile m = world.Mobiles.Get(serial);

                if (m != null && (world.Player.NotorietyFlag == NotorietyFlag.Innocent || world.Player.NotorietyFlag == NotorietyFlag.Ally) && m.NotorietyFlag == NotorietyFlag.Innocent && m != world.Player)
                {
                    QuestionGump messageBox = new QuestionGump
                    (
                        world,
                        ResGeneral.ThisMayFlagYouCriminal,
                        s =>
                        {
                            if (s)
                            {
                                Socket.Send_AttackRequest(serial);
                            }
                        }
                    );

                    UIManager.Add(messageBox);

                    return;
                }
            }

            world.TargetManager.NewTargetSystemSerial = serial;
            world.TargetManager.LastAttack = serial;
            Socket.Send_AttackRequest(serial);
        }

public static void RequestPartyQuit(PlayerMobile player)
        {
            Socket.Send_PartyRemoveRequest(player.Serial);
        }

public static void RequestPartyRemoveMember(uint serial)
        {
            Socket.Send_PartyRemoveRequest(serial);
        }

public static void UseSecondaryAbility(World world)
        {
            if (world?.Player == null)
                return;

            ref Ability ability = ref world.Player.Abilities[1];

            if (((byte) ability & 0x80) == 0)
            {
                for (int i = 0; i < 2; i++)
                {
                    world.Player.Abilities[i] &= (Ability) 0x7F;
                }

                SendAbility(world, (byte)ability, false);
            }
            else
            {
                SendAbility(world, 0, false);
            }

            ability ^= (Ability) 0x80;
        }

public int ActivateGumpButton(int gumpId, int buttonId)

            => Invoke(() => ActivateGumpButtonUnsafe(ResolveGumpUnsafe(gumpId), buttonId));

private static int ActivateGumpButtonUnsafe(Gump gump, int buttonId)

        {

            if (gump == null)

                return 0;



            if (gump is SessionServerGump logical)

            {

                var field = logical.Fields.FirstOrDefault(f => f.IsButton && f.ButtonId == buttonId);

                if (field == null || logical.IsDisposed) return 0;

                if (field.Action == ButtonAction.SwitchPage) logical.ChangePage(field.ToPage);

                else logical.OnButtonClick(field.ButtonId);

                return 1;

            }

            Button button = Descendants(gump).OfType<Button>()

                .FirstOrDefault(control => control.ButtonID == buttonId);

            if (button == null)

                return 0;



            if (button.ButtonAction == ButtonAction.SwitchPage)

                gump.ChangePage(button.ToPage);

            else

                gump.OnButtonClick(button.ButtonID);



            return 1;

        }

public void AddObject(string name)

        {

            if (string.IsNullOrWhiteSpace(name) || _csharpState == null)

            {

                Error("UO.AddObject: object name is empty");

                return;

            }



            State.Objects.Remove(name);

            GameObject result = SelectObject();

            if (result is Entity entity)

            {

                State.Objects.Set(name, (int)entity.Serial);

                ReportStatus($"Object '{name}' = 0x{entity.Serial:X8}");

            }

            else if (result != null)

                Error("UO.AddObject: select an item or mobile, not a map tile");

        }

public string BookGetPageText(int page) => Invoke(() => GetOpenBook()?.YokoGetPageText(page) ?? string.Empty);

public void CharPrintEx(int id, int color, int font, string msg) => Invoke(() =>

        {

            using var journalContext = new JournalMessageContext("script");

            Entity target = _world.Get(unchecked((uint)id));

            if (target == null || target.IsDestroyed || string.IsNullOrEmpty(msg))

            {

                ReportStatus($"UO.ClientPrintEx target is unavailable: 0x{(uint)id:X8}");

                return;

            }



            byte selectedFont = (byte)Math.Clamp(font, byte.MinValue, byte.MaxValue);

            GameActions.Print(_world, target, msg, unchecked((ushort)color),

                GameActions.LOCAL_OVERHEAD_MESSAGE_TYPE, selectedFont, true);

            ReportStatus($"UO.ClientPrintEx delivered over 0x{(uint)id:X8} with font {selectedFont}");

        });

public int Count(int type, int color, int containerId)

        {

            FindType(type, color, containerId, State.FindDistance, true);

            return _findFullQuantity;

        }

private ISessionTrade FindTrade(int index) => index < 0 ? null : _world.Trades.Snapshot().ElementAtOrDefault(index);

public string GetAbilityName(int abilityId) => abilityId >= 1 && abilityId <= AbilityData.Abilities.Length

            ? AbilityData.Abilities[abilityId - 1].Name

            : string.Empty;

public string[] GetCharactersForCurrentShard() => Invoke(() =>

        {

            if (_world.SessionControl is { } session)

                return session.Characters;

            string account = !string.IsNullOrEmpty(LoginScene.Account)

                ? LoginScene.Account

                : Settings.GlobalSettings.Username;

            string server = _world.ResolveProfileServerName();

            string[] known = LastCharacterManager.GetKnownCharacters(account, server);

            if (known.Length != 0)

                return known;



            LoginScene loginScene = Client.Game?.GetScene<LoginScene>();

            if (loginScene?.Characters != null)

            {

                string[] current = loginScene.Characters

                    .Where(name => !string.IsNullOrWhiteSpace(name))

                    .ToArray();

                if (current.Length != 0)

                    return current;

            }



            string currentName = _world.Player?.Name ?? string.Empty;

            return string.IsNullOrWhiteSpace(currentName)

                ? Array.Empty<string>()

                : new[] { currentName };

        });

public int GetDir(int id) => Invoke(() => (_world.Get(unchecked((uint)id)) as Mobile) is Mobile m ? (int)(m.Direction & Direction.Mask) : 0);

public string[] GetGumpFullLines(int index) => Invoke(() =>

        {

            Gump gump = ServerGumpsUnsafe().ElementAtOrDefault(index);

            return gump == null ? Array.Empty<string>() : Descendants(gump).Select(DescribeControl).ToArray();

        });

public string[] GetGumpTextLines(int index) => Invoke(() =>

        {

            Gump gump = ServerGumpsUnsafe().ElementAtOrDefault(index);

            return gump == null ? Array.Empty<string>() : Descendants(gump).Select(GetControlText).Where(text => !string.IsNullOrWhiteSpace(text)).ToArray();

        });

public string GetLastMenuIdentity() => Invoke(() =>

        {

            SessionMenu menu = _world.ServerMenus.Snapshot().LastOrDefault();

            if (menu == null)

                return string.Empty;

            string items = string.Join("\u001F", menu.GetYokoItemsEx());

            return $"{menu.LocalSerial:X8}:{menu.ServerSerial:X8}:{menu.YokoCaption}:{items}";

        });

public int GetMaxMana(int id) => Invoke(() => (_world.Get(unchecked((uint)id)) as Mobile)?.ManaMax ?? 0);

public int[][] GetMultiAllParts(int multiId) => Invoke(() =>

        {

            if (!_world.HouseManager.TryGetHouse(unchecked((uint)multiId), out House house))

                return Array.Empty<int[]>();



            return house.Components

                .Where(component => component != null && !component.IsDestroyed)

                .Select(component => new[]

                {

                    (int)component.Graphic,

                    (int)component.Hue,

                    (int)component.X,

                    (int)component.Y,

                    (int)component.Z,

                    component.MultiOffsetX,

                    component.MultiOffsetY,

                    component.MultiOffsetZ,

                    multiId

                })

                .ToArray();

        });

public string[] GetShopList() => Invoke(() => _world.Shops.Last?.GetItems()

            ?? UIManager.Gumps.OfType<ShopGump>().LastOrDefault(g => g.World == _world && !g.IsDisposed && g.ShopState == null)?.GetYokoShopItems() ?? Array.Empty<string>());

public int GetSkillLockState(string name) => Invoke(() => FindSkillUnsafe(name) is Skill skill ? (int)skill.Lock : -1);

public int GetStamina(int id) => Invoke(() => (_world.Get(unchecked((uint)id)) as Mobile)?.Stamina ?? 0);

public int Gold => Invoke(() => (int)(CurrentPlayer?.Gold ?? 0));

public void IgnoreReset() => State.IgnoredSerials.Clear();

public int InJournalFiltered(string pattern, int serial, int color, int startTime, int endTime, bool newestOnly, bool caseSensitive)

        {

            DateTime? start = null;

            DateTime? end = null;

            if (startTime > 0 || endTime > 0)

            {

                DateTime now = DateTime.Now;

                start = now.AddMilliseconds(-Math.Max(startTime, endTime));

                end = now.AddMilliseconds(-Math.Min(startTime, endTime));

            }

            return FindJournal(pattern, start, end, -1, false, !caseSensitive, serial, color, newestOnly);

        }

public int JournalMessageType(int index) => GetJournalEntry(index) is JournalEntry entry ? (int)entry.MessageType : 0;

public string JournalName(int index) => GetJournalEntry(index)?.Name ?? string.Empty;

private bool MatchesFindIdentity(Entity gameObject, HashSet<ushort> wantedTypes, HashSet<ushort> wantedColors, IgnoreTypeFilter ignoredTypes)

        {

            return gameObject != null

                && !gameObject.IsDestroyed

                && !State.IgnoredSerials.Contains(unchecked((int)gameObject.Serial))

                && !ignoredTypes.Matches(gameObject.Graphic, gameObject.Hue)

                && (wantedTypes.Count == 0 || wantedTypes.Contains(gameObject.Graphic))

                && (wantedColors.Count == 0 || wantedColors.Contains(gameObject.Hue));

        }

private void RegisterFound(Item item)

        {

            _findCount++;

            _findFullQuantity += Math.Max(1, (int)item.Amount);

            RegisterFoundSerial(unchecked((int)item.Serial));

        }

public int RequestInteractiveHideTarget()

        {

            return Invoke(() =>

            {

                _world.TargetManager.SetTargeting(selected =>

                {

                    if (selected is not Entity entity || entity.IsDestroyed)

                    {

                        PrintInteractiveResult("UO.Hide: select a loaded item or mobile.");

                        return;

                    }



                    if (entity.Serial == _world.Player?.Serial)

                    {

                        PrintInteractiveResult("UO.Hide: the player cannot be hidden locally.");

                        return;

                    }



                    HideLocally(entity);

                    PrintInteractiveResult($"UO.Hide: hidden 0x{entity.Serial:X8} locally.");

                }, 0, TargetType.Neutral);

                PrintInteractiveResult("UO.Hide: target an item or mobile to hide locally.");

                return 1;

            });

        }

internal static int ResolveClassicUOAbilityId(string abilityNameOrId)

        {

            string requested = (abilityNameOrId ?? string.Empty).Trim();

            if (int.TryParse(requested, NumberStyles.Integer, CultureInfo.InvariantCulture, out int numericId))

                return numericId >= 1 && numericId <= AbilityData.Abilities.Length ? numericId : 0;



            string normalized = NormalizeAbilityName(requested);

            if (normalized.Length == 0)

                return 0;



            for (int index = 0; index < AbilityData.Abilities.Length; index++)

            {

                if (NormalizeAbilityName(AbilityData.Abilities[index].Name) == normalized

                    || NormalizeAbilityName(((Ability)(index + 1)).ToString()) == normalized)

                    return index + 1;

            }



            return 0;

        }

public int ShowGumpInspector(int gumpId = -1) => Invoke(() =>

        {

            bool found = TryBuildGumpInspectorUnsafe(gumpId, out string title, out string document);

            OpenInteractiveInfoGump(found ? title : "C# Gump Inspector", document);

            if (!found && _interactiveCommands) Error(document);

            return found ? 1 : 0;

        });

public void ShowJournal() => Invoke(() => GameActions.OpenJournal(_world));

private static string TileName(GameObject tile)

        {

            if (tile is Land land)

                return land.TileData.Name ?? string.Empty;

            return tile.Graphic < Client.UO.FileManager.TileData.StaticData.Length

                ? Client.UO.FileManager.TileData.StaticData[tile.Graphic].Name ?? string.Empty

                : string.Empty;

        }

public void ToggleFly() => Invoke(() => NetClient.Socket.Send_ToggleGargoyleFlying());

public int TryOpenDoorForStep(int direction) => Invoke(() =>

        {

            if (_world.Player == null || direction < 0 || direction > 7)

                return 0;

            return _world.Player.TryOpenDoor((Direction)direction, true) ? 1 : 0;

        });

public int Weight => Invoke(() => CurrentPlayer?.Weight ?? 0);

internal static string TranslateUi(string text)

        {

            if (string.IsNullOrEmpty(text))

                return text ?? string.Empty;



            Dictionary<string, string> translations = _uiTranslations;

            if (translations.Count == 0)

                return text;



            if (translations.TryGetValue(text, out string translated))

                return translated;



            string trimmed = text.Trim();

            if (trimmed.Length == text.Length ||

                !translations.TryGetValue(trimmed, out translated))

            {

                return text;

            }



            int start = text.IndexOf(trimmed, StringComparison.Ordinal);

            return text.Substring(0, start) + translated +

                   text.Substring(start + trimmed.Length);

        }

internal static void SetYokoHistoryLimit(int length)
        {
            _yokoHistoryLimit = Math.Clamp(length, 1, Constants.MAX_JOURNAL_HISTORY_COUNT);
            while (Entries.Count > _yokoHistoryLimit)
                Entries.RemoveFromFront();
        }

internal void BeginScriptControlledDisconnect(string scriptKey)

        {

            if (scriptKey != null && _running.TryGetValue(scriptKey, out YokoRunningScript script))

                script.BeginControlledDisconnect();

        }

internal YokoProcedureInfo FindProcedureByName(string name)

        {

            if (string.IsNullOrWhiteSpace(name)) return null;

            // Every top-level file is indexed, including backups. Named calls

            // follow the character selection; explicit keys keep IDE snapshots.

            string selectedPath = RequestedAutoloadPath();

            YokoProcedureInfo[] matches;

            HashSet<string> loadedFiles;

            lock (_proceduresLock)

            {

                if (_proceduresByKey.TryGetValue(name, out YokoProcedureInfo qualified))

                    return qualified;

                matches = _procedures.Where(p => p.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).ToArray();

                loadedFiles = new HashSet<string>(_ideLoadedFiles, StringComparer.OrdinalIgnoreCase);

            }

            if (!string.IsNullOrWhiteSpace(selectedPath))

            {

                string fullPath = Path.GetFullPath(selectedPath);

                if (TryGetSelectedAutoloadActionProcedures(fullPath, out var freshDeclarations))

                {

                    // Load/Reload validates a disk snapshot without replacing

                    // unsaved IDE documents. Names must use that fresh view;

                    // deleted names must not resolve to a cached backup.

                    YokoProcedureInfo[] fresh = freshDeclarations.Where(p =>

                        p.Name.Equals(name, StringComparison.OrdinalIgnoreCase)).ToArray();

                    if (fresh.Length != 0) return fresh.Length == 1

                        && !IsSelectedAutoloadExplicitlyUnloaded(fullPath) ? fresh[0] : null;

                    if (matches.Any(p => string.Equals(Path.GetFullPath(p.FilePath),

                            fullPath, StringComparison.OrdinalIgnoreCase)))

                        return null;

                    matches = matches.Where(p => !string.Equals(Path.GetFullPath(p.FilePath),

                            fullPath, StringComparison.OrdinalIgnoreCase)

                        && (!IsTopLevelAutoloadFile(p.FilePath)

                            || loadedFiles.Contains(Path.GetFullPath(p.FilePath)))).ToArray();

                }

                YokoProcedureInfo[] selected = matches.Where(p => string.Equals(

                    Path.GetFullPath(p.FilePath), fullPath, StringComparison.OrdinalIgnoreCase)).ToArray();

                if (selected.Length != 0) return selected.Length == 1

                    && !IsSelectedAutoloadExplicitlyUnloaded(fullPath) ? selected[0] : null;

            }

            // Unique separately loaded helpers remain callable. Ambiguous names

            // need an explicit key; never choose an arbitrary sorted backup.

            return matches.Length == 1 && !IsSelectedAutoloadExplicitlyUnloaded(Path.GetFullPath(matches[0].FilePath))

                ? matches[0] : null;

        }

private bool IsTopLevelAutoloadFile(string filePath) => string.Equals(

            Path.GetDirectoryName(Path.GetFullPath(filePath)),

            Path.TrimEndingDirectorySeparator(Path.GetFullPath(AutoloadPath)),

            StringComparison.OrdinalIgnoreCase);

internal void SetScriptName(int index, string value)

        {

            YokoRunningScript script = ElementAt(RunningScripts(), index);

            string nextName = value ?? string.Empty;

            if (script != null && !string.Equals(script.Name, nextName, StringComparison.Ordinal))

            {

                script.Name = nextName;

                MarkRuntimeStateChanged();

            }

        }

internal void SetSpeechFilter(bool enabled) => _speechFilterEnabled = enabled;

internal int StartScript(string scriptPath)

        {

            if (string.IsNullOrWhiteSpace(scriptPath))

                return 0xFFFF;



            string fullPath;

            string content;

            try

            {

                fullPath = Path.IsPathRooted(scriptPath)

                    ? Path.GetFullPath(scriptPath)

                    : Path.GetFullPath(Path.Combine(AutoloadPath, scriptPath));

                if (!File.Exists(fullPath)) return 0xFFFF;

                content = ReadScriptContent(fullPath);

            }

            catch { return 0xFFFF; }



            YokoProcedureInfo procedure = SelectFileEntryPoint(

                DiscoverProcedures(content, fullPath, Path.GetFileName(fullPath)), fullPath);

            if (procedure == null || !RunProcedure(procedure, Array.Empty<string>()))

                return 0xFFFF;



            return GetScriptsCount();

        }

internal bool TryGetSelectedAutoloadActionProcedures(string path, out IReadOnlyList<YokoProcedureInfo> procedures)

    {

        lock (_selectedAutoloadActionLock)

        {

            procedures = string.Equals(path, _selectedAutoloadStatePath, StringComparison.OrdinalIgnoreCase)

                ? _selectedAutoloadDeclarations : null;

            return procedures != null;

        }

    }

internal static YokoTheiaIdeGump Open(World world, string filePath = null) => YokoTheiaIdeGump.Open(world, filePath);

public void AlwaysRun(int enabled) => bridge.AlwaysRun(enabled);

private InjectionValue BuildPortablePath(int startX, int startY, int startZ, int finishX, int finishY, int finishZ,
            int map, int accuracy, int accuracyZ = 255, bool optimized = true, bool run = false,
            int maxSteps = 0, int maxDistance = 0, bool avoidMobiles = false, bool avoidStatics = false,
            bool allowDoors = false, bool allowDiagonal = true)
        {
            if (!PortablePathSearch.ValidPoint(startX, startY, startZ)
                || !PortablePathSearch.ValidPoint(finishX, finishY, finishZ) || map < 0 || map > byte.MaxValue)
                return new InjectionValue(Array.Empty<InjectionValue>());
            if (map != bridge.WorldNumber) return new InjectionValue(Array.Empty<InjectionValue>());
            int safeAccuracy = Math.Max(0, Math.Min(20, accuracy));
// …
            if (maxDistance > 0 && requestedDistance > maxDistance)
                return new InjectionValue(Array.Empty<InjectionValue>());
// …
            if (state.BadLocations.Count != 0 || state.BadObjects.Count != 0)
// …
                if (bridge is IApiPathQueryScheduler snapshotScheduler)
// …
                if (forbidden?.Invoke(nextX, nextY) == true
                    || occupiedByMobiles != null && occupiedByMobiles.Contains((nextX, nextY))) return null;
                if (forbidden != null && x != nextX && y != nextY)
// …
                    if (blockedSides == 1 && state.MoveThroughCorner == 0
                        || blockedSides == 2 && state.MoveBetweenTwoCorners == 0) return null;
// …
                if (allowDoors && !doorCells.TryGetValue((nextX, nextY, z), out doorAtCell))
// …
                if (avoidStatics)
// …
                    if (!staticCells.TryGetValue((nextX, nextY), out bool hasStatics))
// …
                    if (hasStatics && !doorAtCell) return null;
// …
                if (step.Length == 0 || step[0] == 0)
// …
                    return doorAtCell ? z : (int?)null;
// …
                return step.Length > 1 ? step[1] : z;
// …
                    if (bridge is IApiPathQueryScheduler scheduler) scheduler.ExecutePathQuerySlice(slice);
// …
            return new InjectionValue(points.Select(point => new InjectionValue(new[] {
// …

public void CallSub(string subrutineName) => bridge.Exec(subrutineName);

private int CompactMoveXYZ(InjectionValue[] values)

        {

            if (values == null || values.Length < 6 || values.Length > 10)

                throw new NativeSubrutineException("UO.MoveXYZ expects x,y,z,accuracyXY,accuracyZ,running[,timeout[,maxSteps[,avoidMobiles[,openDoors]]]].");

            int timeout = values.Length > 6 ? Math.Max(0, NumberConversions.ToInt(values[6])) : 0;

            int maxSteps = values.Length > 7 ? Math.Max(0, NumberConversions.ToInt(values[7])) : 0;

            bool? avoidMobiles = values.Length > 8 ? ToBoolean(values[8]) : (bool?)null;

            bool? openDoors = values.Length > 9 ? ToBoolean(values[9]) : (bool?)null;

            return MoveToCanonical(NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]), NumberConversions.ToInt(values[2]),

                NumberConversions.ToInt(values[3]), ToBoolean(values[5]), NumberConversions.ToInt(values[4]), true, null,

                timeout, maxSteps, 0, avoidMobiles, openDoors, false);

        }

private int ConvertContainer(string id)

        {

            if (NumberConversions.TryStr2Int(id, out int numeric) && numeric == 0)

                return 1;

            if (id.Equals("my", StringComparison.OrdinalIgnoreCase))

                return -1;

            else if (id.Equals("ground", StringComparison.OrdinalIgnoreCase))

                return 1;



            return GetObject(id);

        }

private static InjectionValue ConvertGumpValue(string identifier, string value)

        {

            switch ((identifier ?? string.Empty).ToLowerInvariant())

            {

                case "buttonlen":

                case "button":

                case "textlen":

                case "injid":

                case "replyed":

                case "inclient":

                case "objectcount":

                    return new InjectionValue(NumberConversions.TryStr2Int(value ?? string.Empty, out int number) ? number : 0);

                default:

                    return new InjectionValue(value ?? string.Empty);

            }

        }

public int Disarm()

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

public void Dress(string name)

            => Equip(name, dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress.");

case "booksettext":

                {

                    string bookText = Text(0) ?? string.Empty;

                    state.BookPages.Clear();

                    state.BookPages.AddRange(bookText.Split(new[] { '\f' }, StringSplitOptions.None));

                    bridge.BookSetText(bookText);

                    return InjectionValue.Unit;

                }

case "bow": bridge.Bow(); return InjectionValue.Unit;

case "getname":

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

case "consoleentryreply":

                case "consoleentryunicodereply": bridge.ReplyServerPrompt(Text(0)); return InjectionValue.Unit;

case "euo2id":

                case "euo2type": return new InjectionValue(DecodeEasyUoId(Text(0)));

case "findfullquantity": return new InjectionValue(bridge.FindFullQuantity());

case "gameserveripstring": return new InjectionValue(bridge.GameServerAddress);

case "getcontent":

                case "getequipment":

                {

                    InjectionValue selection = arguments[0];

                    bool ground = false, explicitZero;

                    int container;

                    if (selection.Kind == InjectionValueKind.String)

                    {

                        string text = Text(0).Trim();

                        ground = text.Equals("ground", StringComparison.OrdinalIgnoreCase);

                        explicitZero = NumberConversions.TryStr2Int(text, out int literal) && literal == 0;

                        container = ground ? 0 : text.Equals("my", StringComparison.OrdinalIgnoreCase)

                            ? bridge.Backpack : GetObject(text);

                    }

                    else

                    {

                        if (selection.Kind != InjectionValueKind.Integer && selection.Kind != InjectionValueKind.Decimal)

                            return new InjectionValue(Array.Empty<InjectionValue>());

                        container = Arg(0);

                        explicitZero = selection.Kind == InjectionValueKind.Integer ? selection.Integer == 0 : selection.Decimal == 0d;

                    }

                    // Only an explicit ground/zero selector may query world items.

                    if (container < 0 || container == 0 && !ground && !explicitZero)

                        return new InjectionValue(Array.Empty<InjectionValue>());

                    bool equipment = name.Equals("GetEquipment", StringComparison.OrdinalIgnoreCase);

                    int[] items = equipment

                        ? container == 0 ? Array.Empty<int>() : bridge.GetEquipment(container)

                        : bridge.GetContent(container);

                    return new InjectionValue(items.Select(serial => new InjectionValue(serial)).ToArray());

                }

case "getmultis":

                    return new InjectionValue(bridge.GetWorldItems().Where(id => bridge.IsHouse(id) != 0).Select(id => new InjectionValue(id)).ToArray());

case "getstaticart":

                    return new InjectionValue(bridge.GetStaticArt(ResolveType(arguments[0]), Arg(1)).Select(value => new InjectionValue(value)).ToArray());

case "gety": return new InjectionValue(bridge.GetY(Arg(0, bridge.Self)));

case "gumpautotextentry": QueueGumpControl("textentry", Arg(0), Text(1)); return InjectionValue.Unit;

case "lineid": return new InjectionValue(selectedJournalEntry?.Serial ?? 0);

case "salute": bridge.Salute(); return InjectionValue.Unit;

case "setwalkunmounttimer":

                    state.WalkUnmountTimer = ClampMoveTimer(Arg(0), 400);

                    bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer);

                    return InjectionValue.Unit;

case "targetbyresource":

                {

                    int found = bridge.FindType(ResolveType(arguments[1]), -1, 0, -1, true);

                    if (found != 0) { bridge.WaitTargetObject(Arg(0)); bridge.UseObject(found); }

                    return InjectionValue.Unit;

                }

case "uosaycolor": bridge.Say(Text(0), Arg(1)); return InjectionValue.Unit;

case "waittextentry": bridge.SetGumpValue(-1, "textentry", -1, Text(0)); return InjectionValue.Unit;