Skip to content

ZH TW UO Topic scripts runtime

Jump to bottom
Codex edited this page Oct 12, 2026 · 4 revisions

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

腳本和運行時

家 · C# · IDE · UO API · A–Z · 範例 · Languages

啟動、暫停、停止腳本和程序、實例資訊、事件和等待。 Terminate和StopScript在不同的執行等級上運行。

部分

主題 命令與解釋
StartScript UO.StartScript
StopScript UO.StopScript
StopAllScripts UO.StopAllScripts
PauseResumeScript UO.PauseResumeScript
Script State UO.GetScriptState
Script List UO.GetScriptsList · UO.GetScriptsCount
Script Name UO.GetScriptName · UO.SetScriptName
Script Path UO.GetScriptPath
CallSub UO.CallSub
SubExists UO.SubExists
Events UO.SetEvent · UO.SetEventProc
Timers UO.Timer · UO.Wait
Disconnect Behaviour UO.GetPauseScriptOnDisconnectStatus · UO.SetPauseScriptOnDisconnectStatus

所有主題命令

腳本生命週期

UO.StartScript · UO.StopScript · UO.StopAllScripts · UO.PauseResumeScript · UO.GetScriptName · UO.SetScriptName · UO.GetScriptPath · UO.GetScriptsCount · UO.GetScriptsList · UO.GetScriptState · UO.Exec · UO.Launch

程序/活動

UO.CallSub · UO.SubExists · UO.FunRunning · UO.Terminate · UO.TerminateAll · UO.SetEvent · UO.SetEventProc

定時器 / Waiting

UO.Wait · UO.Waiting · UO.Timer · UO.Time · UO.Date

Disconnect 行為

UO.GetPauseScriptOnDisconnectStatus · UO.SetPauseScriptOnDisconnectStatus

關於該主題的範例

每個命令卡都有幾個獨立的場景：直接程式碼、函數和類別。以下是精選的簡短場景；限制和全面分析是有可能的。

UO.GetScriptsList

參數、結果及所有場景

var indices = UO.GetScriptsList();
foreach (var index in indices)
{
    UO.Print(Convert.ToString(index) + ": " + UO.GetScriptName(index));
}

UO.TerminateAll

參數、結果及所有場景

for (int cycle = (int)(1); cycle <= 10; cycle += (int)(1))
{
    if (Truth(UO.Dead()))
    {
        UO.Print("Character is dead: stopping all C# scripts");
        UO.TerminateAll();
    }
    await Delay(250);
}

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;

完整指令說明

UO.CallSub

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.CallSub(object? subrutineName);

啟動前透過 RegisterRoutine(name, handler) 在目前執行中註冊的 C# 委託。呼叫在助手完成之前返回控制權；一項已註冊的任務不能強加給自己。

參數

  • subrutineName 是RegisterRoutine 給出的字串名稱。邊緣周圍的空白被刪除；註冊名稱搜尋不區分大小寫。

傳回值

void - 無結果；未知名稱 CallSub 會導致錯誤，並且會跳過重新運行已啟動的名稱。

行為

UO.FunRunning(name) == 0 也可能在提出取消要求後立即出現，並不表示上一個 callback 的 finally 區塊已結束。在上一個工作實際結束前，同一個本地名稱的另一個 CallSub 或 Exec 會被略過。

  • 註冊和任務屬於同一個執行。另一個角色、個人資料或後續運行都有自己的註冊表。
  • RegisterRoutine 接受 Action、Func<Task> 或帶有Exec 字串參數陣列的委託。刪除註冊不會運行程式碼並阻止進一步搜尋該名稱。
  • 主腳本在需要輔助程序時必須保持活動狀態：完成後，任務將被取消，註冊和訂閱將被釋放。
  • FunRunning 不是管理者索引。 GetScriptsList和GetScriptState描述獨立檔案啟動；本地回呼不會收到單獨的索引。
  • 回調錯誤將在下次檢查時傳遞給主腳本。 WaitAsync、UO.Wait 和偵測的 C# 循環支援暫停、取消和事件佇列處理。

已上傳C#-文件

除了本地委託之外，當前管理器還支援明確加載 C#- 使用 Child.csx::Main 等鍵進行輸入。 SubExists 和 FunRunning 接受這樣的密鑰； CallSub 運行文件，無需 Args, 一個 Exec("exec Child.csx::Main 'north gate' 42") 傳輸 Args。帶空格的鍵在裡面的引號裡 Exec。唯一的短名稱是可以接受的，模糊的名稱不會選擇隨機檔案。本地註冊優先。文件啟動在當前世界/管理器中擁有自己的上下文和生命週期；本地代表屬於註冊它們的執行。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

RegisterRoutine("Hello", () => UO.Print("Hello from a routine"));
UO.CallSub("Hello");
while (UO.FunRunning("Hello") != 0) await WaitAsync(25);

1。啟動觀察者並繼續Main - 直接腳本

參數與執行流程：

  • WeightWatch 是下列過程的名稱。主返回77，無需等待三個樣本；77是Main的結果，而不是CallSub。
  • 將範例儲存為單獨的文件，將其載入到 IDE/manager 並執行 Main，以便其餘過程最終位於該目錄中。 WeightWatch/ManaWatch - 訓練程序在這裡完整定義：三次重量/法力測量，間隔為UO.Wait(1000)，即1000毫秒，僅在進入世界時輸出。這不是持續監控；停頓可以延長時間。對於具有兩個任務的範例，必須允許同時啟動流程。
var registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
UO.CallSub("WeightWatch");
while (UO.FunRunning("WeightWatch") != 0) await WaitAsync(25);
return 77;

void WeightWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Weight: " + Convert.ToString(UO.Weight()));
        }
        UO.Wait(1000);
    }
}

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

2。不要重新啟動活動或掛起的任務 - 腳本功能

參數與執行流程：

  • StartIfIdle 先檢查定義，然後檢查活動。 false表示請求未發送。 true 表示仅发送了请求CallSub，未确认开始或完成。
  • 將範例儲存為單獨的文件，將其載入到 IDE/manager 並執行 Main，以便其餘過程最終位於該目錄中。 WeightWatch/ManaWatch - 訓練程序在這裡完整定義：三次重量/法力測量，間隔為UO.Wait(1000)，即1000毫秒，僅在進入世界時輸出。這不是持續監控；停頓可以延長時間。對於具有兩個任務的範例，必須允許同時啟動流程。
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
    var launched = StartIfIdle("WeightWatch");
    while (UO.FunRunning("WeightWatch") != 0)
        await WaitAsync(25);
    return launched;
    return null;
}

dynamic StartIfIdle(dynamic name)
{
    if (!(Truth(UO.SubExists(name))))
    {
        return false;
    }

    if (Truth(UO.FunRunning(name)))
    {
        return false;
    }

    UO.CallSub(name);
    return true;
}

void WeightWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Weight: " + Convert.ToString(UO.Weight()));
        }

        UO.Wait(1000);
    }
}

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

3。兩個獨立觀察者 - 場景類

參數與執行流程：

  • 第一個CallSub從WeightWatch開始，第二個ManaWatch開始。運行是獨立的，不交換局部變數；不保證它們的輸出順序。
  • 將範例儲存為單獨的文件，將其載入到 IDE/manager 並執行 Main，以便其餘過程最終位於該目錄中。 WeightWatch/ManaWatch - 訓練程序在這裡完整定義：三次重量/法力測量，間隔為UO.Wait(1000)，即1000毫秒，僅在進入世界時輸出。這不是持續監控；停頓可以延長時間。對於具有兩個任務的範例，必須允許同時啟動流程。
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 registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
        var registrationManaWatch = RegisterRoutine("ManaWatch", ManaWatch);
        UO.CallSub("WeightWatch");
        UO.CallSub("ManaWatch");
        while (UO.FunRunning("WeightWatch") != 0 || UO.FunRunning("ManaWatch") != 0)
            await WaitAsync(25);
        return null;
    }

    void WeightWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Weight: " + Convert.ToString(UO.Weight()));
            }

            UO.Wait(1000);
        }
    }

    void ManaWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Mana: " + Convert.ToString(UO.Mana()));
            }

            UO.Wait(1000);
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.CallSub(subrutineName) — UO.CallSub(String)

參數: subrutineName (String)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "CallSub":
                string called = Convert.ToString(arguments[0]) ?? "";
                if (Exists(called)) Start(called);
                else if (events is ICSharpScriptHost host && host.HasCSharpScript(called)) host.ExecuteCSharpScript("exec \"" + called + "\"");
                else throw new ArgumentException($"Register the C# routine or load a C# script entry named '{called}' before calling it.");
                return true;

內部實作程式碼，不能作為獨立腳本執行。

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

UO.Date

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.Date();

讀取編號為YYMMDD的電腦本地日曆日期。對於命名一系列日常活動或偵測日期變更很有用。

參數

沒有參數。

傳回值

intYYMMDD：2026-09-30->260930。沒有儲存分隔符號或前導零。它不是持續時間，不是 Unix 時間，也不是 true/false。

行為

  • 沒有參數，沒有帶參數的形式。空括號僅讀取時間：呼叫不會等待、啟動計時器或向遊戲發送資料包。
  • RealTimeSource。現在讀取DateTime。 Now：電腦的本地日期/時間，不是UTC，不是分片時間，也不是遊戲時鐘。時區、夏令時和手動時鐘變更都會影響結果。每次通話都會捕捉到不同的時刻。
  • 僅保留年份的最後兩位數字：2000-01-01 和2100-01-01 都給出101。不同的世紀並沒有什麼不同。單獨呼叫 Date 和 Time 可能會在午夜的兩側降落。
  • 不要減去日曆程式碼來計算延遲。使用 Timer() 和一次運行的兩個標記。日曆時鐘可能會倒退。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。命名每日資源收集系列-直接腳本

參數與執行流程：

  • 不帶參數的呼叫結果保存一次。 sessionLabel 是類似 Harves-260930 的字串。 Print 僅顯示名稱：檔案未創建，資源收集未啟動。
var dateStamp = UO.Date();
var sessionLabel = "harvest-" + Convert.ToString(dateStamp);
UO.Print(sessionLabel);

2。當地時間變更時結束系列 - 腳本功能

參數與執行流程：

  • originalDate 儲存原始日期。 Timer 將觀察限制為 60 秒，UO.Wait(1000) 大約每秒檢查一次。更改日期結束 Main。該範例不會無限期地等待午夜，也不會聲明伺服器上的日期已更改。
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var originalDate = UO.Date();
    var started = Environment.TickCount;
    while (Truth(Environment.TickCount - started < 60.0))
    {
        if (Truth(UO.Date() != originalDate))
        {
            UO.Print("Local date changed; end this batch");
            return null;
        }

        await Delay(1000);
    }

    UO.Print("No date change observed within one minute");
    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;

3。選擇年月日-腳本類

參數與執行流程：

  • MonthPart（戳記）完整顯示：除法向下捨入，MOD 100 提取月份。天——最後兩位數字； shortYear——不完整的年份。對於260930，我們得到26，9，30。
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 stamp = UO.Date();
        var month = MonthPart(stamp);
        var day = stamp % 100;
        var shortYear = stamp / 10000;
        UO.Print(Convert.ToString(shortYear) + "/" + Convert.ToString(month) + "/" + Convert.ToString(day));
        return null;
    }

    dynamic MonthPart(dynamic stamp)
    {
        return stamp / 100 % 100;
    }
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.Date() — UO.Date()

參數: 沒有參數。

結果: int / Integer.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

public int Date()

        {

            var now = timeSource.Now;

            return (now.Year % 100) * 10000 + now.Month * 100 + now.Day;

        }

UO.Exec

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.Exec(object? parameters);

執行文字遊戲指令或執行註冊的 C# 委託或載入的 C# 檔案。

參數

  • parameters - 指令字串：例如「useskill Hiding」、「exec Worker 42」或「exec Child.csx::Main '北門'42」。字串內的表達式 C#（如 2+3）不會自動求值。

傳回值

void：沒有結果。返回控制權並不意味著伺服器啟動或確認遊戲操作的結束。

行為

UO.FunRunning(name) == 0 也可能在提出取消要求後立即出現，並不表示上一個 callback 的 finally 區塊已結束。在上一個工作實際結束前，同一個本地名稱的另一個 CallSub 或 Exec 會被略過。

  • 首先檢查本地註冊表RegisterRoutine。支援“Name args”、“exec Name args”和“_exec Name args”。委託接收string[]：參數42保留字串“42”，“00123”保留前導零。單引號或雙引號將參數與空格連接起來； '' 指定一個空字串。未閉合的引用會導致錯誤。在這條路線中，反斜線按字面意思保留；不要在預先編寫的命令文本中使用 C# 轉義語法。
  • 本地委託異步運行。要等待它完成，請使用FunRunning和WaitAsync。重新啟動活動名稱不會建立副本，也不會消除暫停。幫助程式錯誤在檢查點傳遞到主腳本。
  • 明確載入的檔案條目由目前管理器啟動，具有自己的 Args 和生命週期。僅接受啟動請求並不表示文件已完成工作。
  • 常規遊戲指令會傳遞到本機調度程式。對應的 UO指令的參數契約存放在那裡；Print/Msg/Say/ConsolePrint/TextPrint 將行的其餘部分合併為文字。對於精確的 C# 類型和表達式，請使用像 UO.UseSkill("Hiding") 這樣的直接呼叫。未知指令、無效參數或引號可能會導致 try/catch 擷取異常。
  • 控制台別名：sayu → Say, closeuo → CloseHandle, CountOnGround → CountGround, clearignorelist → IgnoreReset, canceltarget → CancelTarget, cancelmove → MoveOff.

已上傳C#-文件

除了本地委託之外，當前管理器還支援明確加載 C#- 使用 Child.csx::Main 等鍵進行輸入。 SubExists 和 FunRunning 接受這樣的密鑰； CallSub 運行文件，無需 Args, 一個 Exec("exec Child.csx::Main 'north gate' 42") 傳輸 Args。帶空格的鍵在裡面的引號裡 Exec。唯一的短名稱是可以接受的，模糊的名稱不會選擇隨機檔案。本地註冊優先。文件啟動在當前世界/管理器中擁有自己的上下文和生命週期；本地代表屬於註冊它們的執行。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

RegisterRoutine("Hello", () => UO.Print("Hello from a routine"));
UO.Exec("exec Hello");
while (UO.FunRunning("Hello") != 0) await WaitAsync(25);

1。使用選定的技能-直接腳本

參數與執行流程：

  • 隱藏是UseSkill的唯一參數。進入世界後，客戶端發送使用該技能的請求；隱藏成功與否由伺服器決定。直接呼叫同樣的操作：UO.UseSkill("Hiding")。
UO.Exec("useskill Hiding");

2。將字串標籤傳遞給本地過程 - 腳本函數

參數與執行流程：

  • SelectSavedRoute定義如下，記錄所選路由的名稱。 00123 周圍的引號保留前導零。 Exec 非同步運行註冊的委託。具有 FunRunning 和 WaitAsync 的循環明確等待其完成，然後腳本返回字串 00123。這是訓練名稱保存，不是移動指令。
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var registration = RegisterRoutine("SelectSavedRoute", (Action<string[]>)(arguments =>
    {
        if (arguments.Length == 1)
            SelectSavedRoute(arguments[0]);
    }));
    UO.Exec("SelectSavedRoute '00123'");
    while (UO.FunRunning("SelectSavedRoute") != 0)
        await WaitAsync(25);
    return UO.GetGlobal("manual", "savedRoute");
    return null;
}

void SelectSavedRoute(dynamic name)
{
    UO.SetGlobal("manual", "savedRoute", name);
}

3。運行單獨的觀察者 - 腳本類

參數與執行流程：

  • 執行此C#腳本：RegisterRoutine將名稱WeightWatch與目前執行的宣告函數相關聯。 exec WeightWatch 以1000 ms 的間隔開始三個重量測量，並且不等待它們完成。當本地助手運行時，主腳本保持活動狀態；助理沒有單獨的經理索引。如果任務已經暫停，Exec 不會再次恢復它。
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 registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
        UO.Exec("exec WeightWatch");
        while (UO.FunRunning("WeightWatch") != 0)
            await WaitAsync(25);
        return null;
    }

    void WeightWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Weight: " + Convert.ToString(UO.Weight()));
            }

            UO.Wait(1000);
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

4。從帶有空格的資料夾載入腳本 - 直接腳本

參數與執行流程：

  • 將路徑替換為 Main 程式中現有的 C# 檔案。 startscript 載入檔案並要求 Main 運行。引號屬於文字指令；路徑反斜線被保留。請參閱IDE以了解啟動錯誤，因為 Exec 不會回傳確認。
UO.Exec("startscript 'C:\\UO Scripts\\Gather.csx'");

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.Exec(parameters) — UO.Exec(String)

參數: parameters (String)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "Exec":
                var words = CommandWords(Convert.ToString(arguments[0]) ?? "");
                if (words.Length == 0) return false;
                int offset = words[0].Equals("exec", StringComparison.OrdinalIgnoreCase) || words[0].Equals("_exec", StringComparison.OrdinalIgnoreCase) ? 1 : 0;
                if (words.Length > offset && Exists(words[offset]))
                { Start(words[offset], words.Skip(offset + 1).ToArray()); return true; }
                if (words.Length > offset && events is ICSharpScriptHost scriptHost
                    && (offset == 1 || scriptHost.HasCSharpScript(words[offset])))
                {
                    string command = Convert.ToString(arguments[0]) ?? "";
                    if (words[0].Equals("_exec", StringComparison.OrdinalIgnoreCase)) command = "exec" + command.TrimStart()[5..];
                    scriptHost.ExecuteCSharpScript(command); return true;
                }
                return false;

內部實作程式碼，不能作為獨立腳本執行。

public void Exec(string parameters)
        {
            ConsoleToken[] parts = Tokenize(parameters).ToArray();
            if (parts.Length == 0)
                return;

            string command = parts[0].Text;
            if (command.Equals("exec", StringComparison.OrdinalIgnoreCase))
            {
                if (parts.Length != 2 || string.IsNullOrWhiteSpace(parts[1].Text))
                    throw new NativeSubrutineException("Usage: exec script_function");
                bridge.Exec(parts[1].Text);
                return;
            }

            ConsoleToken[] arguments = parts.Skip(1).ToArray();
            string[] rawArguments = arguments.Select(token => token.Text).ToArray();
            if (TryHandleLegacyConsoleCommand(command, rawArguments))
                return;

            command = NormalizeConsoleAlias(command);
            if (IsRemainderTextCommand(command) && rawArguments.Length > 0)
                arguments = new[] { new ConsoleToken(string.Join(" ", rawArguments), true) };
            else if (command.Equals("ColorPrint", StringComparison.OrdinalIgnoreCase) && rawArguments.Length > 1)
                arguments = new[] { arguments[0], new ConsoleToken(string.Join(" ", rawArguments.Skip(1)), true) };
            else if (command.Equals("CharPrint", StringComparison.OrdinalIgnoreCase) && rawArguments.Length > 2)
                arguments = new[] { arguments[0], arguments[1], new ConsoleToken(string.Join(" ", rawArguments.Skip(2)), true) };

            InjectionValue[] args = arguments.Select(token => token.Quoted
                ? new InjectionValue(token.Text) : ToConsoleValue(token.Text)).ToArray();
            CallNativeSubrutine(command, args);
        }

UO.FunRunning

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.FunRunning(object? subrutineName);

檢查是否執行已註冊的指定名稱的C#回呼。結果1啟用手動暫停；完成或取消的任務給出0。

參數

  • subrutineName 是RegisterRoutine 給出的字串名稱。邊緣周圍的空白被刪除；註冊名稱搜尋不區分大小寫。

傳回值

int：1 - 滿足條件，0 - 不滿足。如果多項檢查需要，則儲存一次呼叫的結果。

行為

UO.FunRunning(name) == 0 也可能在提出取消要求後立即出現，並不表示上一個 callback 的 finally 區塊已結束。在上一個工作實際結束前，同一個本地名稱的另一個 CallSub 或 Exec 會被略過。

  • 註冊和任務屬於同一個執行。另一個角色、個人資料或後續運行都有自己的註冊表。
  • RegisterRoutine 接受 Action、Func<Task> 或帶有Exec 字串參數陣列的委託。刪除註冊不會運行程式碼並阻止進一步搜尋該名稱。
  • 主腳本在需要輔助程序時必須保持活動狀態：完成後，任務將被取消，註冊和訂閱將被釋放。
  • FunRunning 不是管理者索引。 GetScriptsList和GetScriptState描述獨立檔案啟動；本地回呼不會收到單獨的索引。
  • 回調錯誤將在下次檢查時傳遞給主腳本。 WaitAsync、UO.Wait 和偵測的 C# 循環支援暫停、取消和事件佇列處理。

已上傳C#-文件

除了本地委託之外，當前管理器還支援明確加載 C#- 使用 Child.csx::Main 等鍵進行輸入。 SubExists 和 FunRunning 接受這樣的密鑰； CallSub 運行文件，無需 Args, 一個 Exec("exec Child.csx::Main 'north gate' 42") 傳輸 Args。帶空格的鍵在裡面的引號裡 Exec。唯一的短名稱是可以接受的，模糊的名稱不會選擇隨機檔案。本地註冊優先。文件啟動在當前世界/管理器中擁有自己的上下文和生命週期；本地代表屬於註冊它們的執行。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

RegisterRoutine("Hello", async () => await WaitAsync(100));
UO.CallSub("Hello");
UO.Print("Running flag: " + UO.FunRunning("Hello"));
while (UO.FunRunning("Hello") != 0) await WaitAsync(25);

1。運行註冊的觀察者而不覆蓋 - 直接腳本

參數與執行流程：

  • 首先，RegisterRoutine將名稱與C#函數關聯起來。 FunRunning 檢查本次執行的任務，包括暫停。主腳本保持活動狀態，直到助手完成。
var registration = RegisterRoutine("WeightWatch", WatchWeight);
if (UO.FunRunning("WeightWatch") == 0) UO.CallSub("WeightWatch");
while (UO.FunRunning("WeightWatch") != 0) await WaitAsync(25);

async Task WatchWeight()
{
    for (int sample = 0; sample < 3; sample++)
    {
        UO.Print($"Weight: {UO.Weight()}");
        await WaitAsync(250);
    }
}

2。等待完成並讀取背景工作結果-腳本函數

參數與執行流程：

  • 非同步委託透過Interlocked更改共享計數器。 FunRunning=0之後，透過Volatile讀取結果。這是本地回調；它沒有單獨的索引GetScriptsList。
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    int completed = 0;
    var registration = RegisterRoutine("Worker", async () =>
    {
        await WaitAsync(150);
        Interlocked.Exchange(ref completed, 1);
    });
    UO.CallSub("Worker");
    UO.Print($"Worker active: {UO.FunRunning("Worker") != 0}");
    while (UO.FunRunning("Worker") != 0)
        await WaitAsync(25);
    return Volatile.Read(ref completed) == 1;
    return null;
}

3。取消註冊的非同步助手 - 腳本類

參數與執行流程：

  • Terminate 選擇目前執行的註冊任務。等待WaitAsync使用她的取消令牌。 finally進行清潔；不允許對已取消的任務進行進一步的遊戲操作。
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()
    {
        int cleanupDone = 0;
        var registration = RegisterRoutine("Worker", async () =>
        {
            try
            {
                await WaitAsync(5000);
            }
            finally
            {
                Interlocked.Exchange(ref cleanupDone, 1);
            }
        });
        UO.CallSub("Worker");
        await WaitAsync(100);
        if (UO.FunRunning("Worker") != 0)
            UO.Terminate("Worker");
        while (UO.FunRunning("Worker") != 0)
            await WaitAsync(25);
        while (Volatile.Read(ref cleanupDone) == 0)
            await WaitAsync(25);
        return true;
        return null;
    }

    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.FunRunning(subrutineName) — UO.FunRunning(String)

參數: subrutineName (String)

結果: int / Integer.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "FunRunning":
                string runningName = Convert.ToString(arguments[0]) ?? "";
                result = IsRunning(runningName) || events is ICSharpScriptHost runningHost && runningHost.IsCSharpScriptRunning(runningName) ? 1 : 0;
                return true;

內部實作程式碼，不能作為獨立腳本執行。

public int FunRunning(string subrutineName) => bridge.FunRunning(subrutineName) ? 1 : 0;

UO.GetPauseScriptOnDisconnectStatus

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

dynamic UO.GetPauseScriptOnDisconnectStatus();

停用管理員時讀取腳本暫停設定。

參數

沒有參數。

傳回值

int 1 — PauseScriptsOnDisconnect 已啟用； 0 - 停用。

行為

  • 讀取管理器標誌，而不是單一腳本的目前暫停。通話本身不會暫停或取消暫停。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。讀取設定-直接腳本

參數與執行流程：

  • 該值描述了管理器設定。
var enabled = UO.GetPauseScriptOnDisconnectStatus();
UO.Print(Convert.ToString(enabled));

2。單獨檢查連接-腳本函數

參數與執行流程：

  • 配置標誌和連接是獨立讀取的。
return  RunScenario();
 object? RunScenario()
{
    var pauseOnDisconnect = UO.GetPauseScriptOnDisconnectStatus();
    var online = UO.Connected();
    UO.Print(Convert.ToString(pauseOnDisconnect) + " " + Convert.ToString(online));
    return null;
}

3。儲存值 - 腳本類

參數與執行流程：

  • 此變數包含讀取時設定的快照。
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 saved = UO.GetPauseScriptOnDisconnectStatus();
        await Delay(100);
        UO.Print(Convert.ToString(saved));
        return null;
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.GetPauseScriptOnDisconnectStatus() — UO.GetPauseScriptOnDisconnectStatus()

參數: 沒有參數。

結果: dynamic / Any.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "getpausescriptondisconnectstatus": return new InjectionValue(bridge.GetPauseScriptOnDisconnectStatus());

UO.GetScriptName

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

string UO.GetScriptName(object? scriptIndex);

讀取活動運行的顯示名稱。

參數

  • scriptIndex - 強制 ScriptIndex - 整數，索引從零開始，從新鮮GetScriptsList開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞主題的serial、過程名稱或從IDE啟動的ID。

傳回值

string：顯示名稱，如果沒有索引則為「」。現有啟動也可以將其名稱明確設定為空字串。

行為

  • 考虑正在运行和暂停的启动；那些已完成并收到取消请求的人不包括在内。正在運行的腳本通常會考慮自身。仅仅加载 IDE 选项卡并不被视为启动。
  • 索引是啟動順序中的目前位置。啟動/停止腳本可以改變位置。不同的呼叫不會形成共同的原子快照；在下一個控制命令之前重新讀取列表。
  • GetScriptsList 給出索引，GetScriptsCount 數量，GetScriptState 三態碼。不要用一個替換另一個或將任何非空結果視為 true。
  • ScriptIndex=0 - 目前第一次啟動，不一定呼叫腳本。 SetScriptName 更改顯示名稱而不重新命名檔案。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。第一次呼叫和結果 - 直接腳本

參數與執行流程：

  • 運行給定的C#腳本。傳遞的數字0表示索引；空括號表示沒有參數。文字 Print 僅是範例訊息。
  • ScriptIndex=0 - 目前第一次啟動，不一定呼叫腳本。 SetScriptName 更改顯示名稱而不重新命名檔案。
  • string：顯示名稱，如果沒有索引則為「」。現有啟動也可以將其名稱明確設定為空字串。
  • 強制ScriptIndex是一個整數，從新的GetScriptsList開始索引從零開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞專案的serial、流程名稱或從IDE啟動的ID。
var index = 0;
var name = UO.GetScriptName(index);
UO.Print(name);

2。在循環或條件中使用 - 腳本函數

參數與執行流程：

  • 這是命令共享的具體範例。陣列索引從零開始；處理前請檢查長度。 UO.Wait(250)，在使用它的地方，等待250毫秒。
  • ScriptIndex=0 - 目前第一次啟動，不一定呼叫腳本。 SetScriptName 更改顯示名稱而不重新命名檔案。
  • string：顯示名稱，如果沒有索引則為「」。現有啟動也可以將其名稱明確設定為空字串。
  • 強制ScriptIndex是一個整數，從新的GetScriptsList開始索引從零開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞專案的serial、流程名稱或從IDE啟動的ID。
return  RunScenario();
 object? RunScenario()
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        var name = UO.GetScriptName(index);
        UO.Print(Convert.ToString(index) + " = " + name);
    }

    return null;
}

3。完整的輔助函數 - 腳本類

參數與執行流程：

  • Main 下面是整個函數。它的參數和結果與其所呼叫的 API 指令分開解釋。
  • DescribeScript 檢查狀態並將名稱與路徑連接。通話之間可以暫停； 「missing」是我們函數的值，而不是GetScriptName的結果。
  • string：顯示名稱，如果沒有索引則為「」。現有啟動也可以將其名稱明確設定為空字串。
  • 強制ScriptIndex是一個整數，從新的GetScriptsList開始索引從零開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞專案的serial、流程名稱或從IDE啟動的ID。
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.Print(DescribeScript(0));
        return null;
    }

    dynamic DescribeScript(dynamic index)
    {
        if (Truth(UO.GetScriptState(index) == 0))
        {
            return "missing";
        }

        return UO.GetScriptName(index) + " | " + UO.GetScriptPath(index);
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.GetScriptName(scriptIndex) — UO.GetScriptName(Any)

參數: scriptIndex (Any)

結果: string / String.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "getscriptname": return new InjectionValue(bridge.GetScriptName(Arg(0)));

UO.GetScriptPath

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

string UO.GetScriptPath(object? scriptIndex);

讀取活動啟動來源檔案路徑。

參數

  • scriptIndex - 強制 ScriptIndex - 整數，索引從零開始，從新鮮GetScriptsList開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞主題的serial、過程名稱或從IDE啟動的ID。

傳回值

string：來源檔案的儲存路徑，如果沒有索引則為「」。運行檔案時，這通常是完整路徑；命令或來源在記憶體中可能沒有常規檔案。

行為

  • 考虑正在运行和暂停的启动；那些已完成并收到取消请求的人不包括在内。正在運行的腳本通常會考慮自身。仅仅加载 IDE 选项卡并不被视为启动。
  • 索引是啟動順序中的目前位置。啟動/停止腳本可以改變位置。不同的呼叫不會形成共同的原子快照；在下一個控制命令之前重新讀取列表。
  • GetScriptsList 給出索引，GetScriptsCount 數量，GetScriptState 三態碼。不要用一個替換另一個或將任何非空結果視為 true。
  • ScriptIndex=0 選擇第一個目前運行。結果顯示其來源；該命令不會開啟、儲存或執行該檔案。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。第一次呼叫和結果 - 直接腳本

參數與執行流程：

  • 運行給定的C#腳本。傳遞的數字0表示索引；空括號表示沒有參數。文字 Print 僅是範例訊息。
  • ScriptIndex=0 選擇第一個目前運行。結果顯示其來源；該命令不會開啟、儲存或執行該檔案。
  • string：來源檔案的儲存路徑，如果沒有索引則為「」。運行檔案時，這通常是完整路徑；命令或來源在記憶體中可能沒有常規檔案。
  • 強制ScriptIndex是一個整數，從新的GetScriptsList開始索引從零開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞專案的serial、流程名稱或從IDE啟動的ID。
var index = 0;
var path = UO.GetScriptPath(index);
if (Truth(path!=""))
{
    UO.Print(path);
}

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

2。在循環或條件中使用 - 腳本函數

參數與執行流程：

  • 這是命令共享的具體範例。陣列索引從零開始；處理前請檢查長度。 UO.Wait(250)，在使用它的地方，等待250毫秒。
  • ScriptIndex=0 選擇第一個目前運行。結果顯示其來源；該命令不會開啟、儲存或執行該檔案。
  • string：來源檔案的儲存路徑，如果沒有索引則為「」。運行檔案時，這通常是完整路徑；命令或來源在記憶體中可能沒有常規檔案。
  • 強制ScriptIndex是一個整數，從新的GetScriptsList開始索引從零開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞專案的serial、流程名稱或從IDE啟動的ID。
return  RunScenario();
 object? RunScenario()
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        UO.Print(UO.GetScriptName(index) + " -> " + UO.GetScriptPath(index));
    }

    return null;
}

3。完整的輔助函數 - 腳本類

參數與執行流程：

  • Main 下面是整個函數。它的參數和結果與其所呼叫的 API 指令分開解釋。
  • 僅當路徑為空時，ReadScriptPath 才會替換後備參數。這是一個單獨的函數，而不是新的 GetScriptPath 重載。
  • string：來源檔案的儲存路徑，如果沒有索引則為「」。運行檔案時，這通常是完整路徑；命令或來源在記憶體中可能沒有常規檔案。
  • 強制ScriptIndex是一個整數，從新的GetScriptsList開始索引從零開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞專案的serial、流程名稱或從IDE啟動的ID。
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.Print(ReadScriptPath(0, "path unavailable"));
        return null;
    }

    dynamic ReadScriptPath(dynamic index, dynamic fallback)
    {
        var path = UO.GetScriptPath(index);
        if (Truth(path == ""))
        {
            return fallback;
        }

        return path;
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.GetScriptPath(scriptIndex) — UO.GetScriptPath(Any)

參數: scriptIndex (Any)

結果: string / String.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "getscriptpath": return new InjectionValue(bridge.GetScriptPath(Arg(0)));

UO.GetScriptState

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.GetScriptState(object? scriptIndex);

透過索引讀取執行狀態。

參數

  • scriptIndex - 強制 ScriptIndex - 整數，索引從零開始，從新鮮GetScriptsList開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞主題的serial、過程名稱或從IDE啟動的ID。

傳回值

int - 狀態碼：0 = 否/未知，1 = 正在運行，2 = 暫停。這不是bool：明確與1或2進行比較。

行為

  • 考虑正在运行和暂停的启动；那些已完成并收到取消请求的人不包括在内。正在運行的腳本通常會考慮自身。仅仅加载 IDE 选项卡并不被视为启动。
  • 索引是啟動順序中的目前位置。啟動/停止腳本可以改變位置。不同的呼叫不會形成共同的原子快照；在下一個控制命令之前重新讀取列表。
  • GetScriptsList 給出索引，GetScriptsCount 數量，GetScriptState 三態碼。不要用一個替換另一個或將任何非空結果視為 true。
  • 考慮手動/調試暫停和配置的關閉暫停。 1狀態並不能保證腳本目前正在消耗CPU或接收伺服器資料。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。第一次呼叫和結果 - 直接腳本

參數與執行流程：

  • 運行給定的C#腳本。傳遞的數字0表示索引；空括號表示沒有參數。文字 Print 僅是範例訊息。
  • 考慮手動/調試暫停和配置的關閉暫停。 1狀態並不能保證腳本目前正在消耗CPU或接收伺服器資料。
  • int - 狀態碼：0 = 否/未知，1 = 正在運行，2 = 暫停。這不是bool：明確與1或2進行比較。
  • 強制ScriptIndex是一個整數，從新的GetScriptsList開始索引從零開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞專案的serial、流程名稱或從IDE啟動的ID。
int state = UO.GetScriptState(0);
string text = state switch
{
    1 => "running",
    2 => "paused",
    _ => "unknown"
};
UO.Print(text);

2。在循環或條件中使用 - 腳本函數

參數與執行流程：

  • 這是命令共享的具體範例。陣列索引從零開始；處理前請檢查長度。 UO.Wait(250)，在使用它的地方，等待250毫秒。
  • 考慮手動/調試暫停和配置的關閉暫停。 1狀態並不能保證腳本目前正在消耗CPU或接收伺服器資料。
  • int - 狀態碼：0 = 否/未知，1 = 正在運行，2 = 暫停。這不是bool：明確與1或2進行比較。
  • 強制ScriptIndex是一個整數，從新的GetScriptsList開始索引從零開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞專案的serial、流程名稱或從IDE啟動的ID。
return  RunScenario();
 object? RunScenario()
{
    var paused = 0;
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptState(index) == 2))
        {
            paused += 1;
        }
    }

    UO.Print(Convert.ToString(paused));
    return null;
}

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

3。完整的輔助函數 - 腳本類

參數與執行流程：

  • Main 下面是整個函數。它的參數和結果與其所呼叫的 API 指令分開解釋。
  • IsScriptActive 將 1 和 2 轉換為 true，將 0 轉換為 false。 GetScriptState本身仍然回傳一個數字狀態碼。
  • int - 狀態碼：0 = 否/未知，1 = 正在運行，2 = 暫停。這不是bool：明確與1或2進行比較。
  • 強制ScriptIndex是一個整數，從新的GetScriptsList開始索引從零開始。對於負數或缺失索引，將傳回所描述的空/未知結果。不要傳遞專案的serial、流程名稱或從IDE啟動的ID。
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(IsScriptActive(0)) == true))
        {
            UO.Print("running or paused");
        }
        else
        {
            UO.Print("not active");
        }

        return null;
    }

    dynamic IsScriptActive(dynamic index)
    {
        var state = UO.GetScriptState(index);
        return Truth(state == 1) || Truth(state == 2);
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.GetScriptState(scriptIndex) — UO.GetScriptState(Any)

參數: scriptIndex (Any)

結果: int / Integer.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "getscriptstate": return new InjectionValue(bridge.GetScriptState(Arg(0)));

UO.GetScriptsCount

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.GetScriptsCount();

計算此客戶端中的活動運行。

參數

沒有參數。

傳回值

int >= 0：活動運行的數量，包括暫停的運行。這是一個數量，而不是 bool 或腳本索引。

行為

  • 考虑正在运行和暂停的启动；那些已完成并收到取消请求的人不包括在内。正在運行的腳本通常會考慮自身。仅仅加载 IDE 选项卡并不被视为启动。
  • 索引是啟動順序中的目前位置。啟動/停止腳本可以改變位置。不同的呼叫不會形成共同的原子快照；在下一個控制命令之前重新讀取列表。
  • GetScriptsList 給出索引，GetScriptsCount 數量，GetScriptState 三態碼。不要用一個替換另一個或將任何非空結果視為 true。
  • 沒有爭論。計數不會對清單進行排序，也不會更改運行的狀態。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。第一次呼叫和結果 - 直接腳本

參數與執行流程：

  • 運行給定的C#腳本。傳遞的數字0表示索引；空括號表示沒有參數。文字 Print 僅是範例訊息。
  • 沒有爭論。計數不會對清單進行排序，也不會更改運行的狀態。
  • int >= 0：活動運行的數量，包括暫停的運行。這是一個數量，而不是 bool 或腳本索引。
var count = UO.GetScriptsCount();
UO.Print(Convert.ToString(count));

2。在循環或條件中使用 - 腳本函數

參數與執行流程：

  • 這是命令共享的具體範例。陣列索引從零開始；處理前請檢查長度。 UO.Wait(250)，在使用它的地方，等待250毫秒。
  • 沒有爭論。計數不會對清單進行排序，也不會更改運行的狀態。
  • int >= 0：活動運行的數量，包括暫停的運行。這是一個數量，而不是 bool 或腳本索引。
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetScriptsCount();
    await Delay(250);
    var after = UO.GetScriptsCount();
    UO.Print(Convert.ToString(after - before));
    return null;
}

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

3。完整的輔助函數 - 腳本類

參數與執行流程：

  • Main 下面是整個函數。它的參數和結果與其所呼叫的 API 指令分開解釋。
  • HasOtherScripts 與1 比較計數：呼叫腳本通常佔用一個條目。與 GetScriptsCount 不同，輔助函數傳回 true/false。
  • int >= 0：活動運行的數量，包括暫停的運行。這是一個數量，而不是 bool 或腳本索引。
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(HasOtherScripts()))
        {
            UO.Print("Other executions are active");
        }
        else
        {
            UO.Print("No other active executions");
        }

        return null;
    }

    dynamic HasOtherScripts()
    {
        var count = UO.GetScriptsCount();
        return count > 1;
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.GetScriptsCount() — UO.GetScriptsCount()

參數: 沒有參數。

結果: int / Integer.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "getscriptscount": return new InjectionValue(bridge.GetScriptsCount());

UO.GetScriptsList

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

dynamic UO.GetScriptsList();

傳回目前數字腳本索引。

參數

沒有參數。

傳回值

int 陣列：索引 0..N-1 或空數組。這些元素是數字，而不是名稱或文字條目。

行為

  • 考虑正在运行和暂停的启动；那些已完成并收到取消请求的人不包括在内。正在運行的腳本通常會考慮自身。仅仅加载 IDE 选项卡并不被视为启动。
  • 索引是啟動順序中的目前位置。啟動/停止腳本可以改變位置。不同的呼叫不會形成共同的原子快照；在下一個控制命令之前重新讀取列表。
  • GetScriptsList 給出索引，GetScriptsCount 數量，GetScriptState 三態碼。不要用一個替換另一個或將任何非空結果視為 true。
  • 沒有爭論。將每個數字傳遞給名稱、路徑或狀態的相應 getter。產生的陣列是一個單獨的快照；更改它不會控制腳本。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。第一次呼叫和結果 - 直接腳本

參數與執行流程：

  • 運行給定的C#腳本。傳遞的數字0表示索引；空括號表示沒有參數。文字 Print 僅是範例訊息。
  • 沒有爭論。將每個數字傳遞給名稱、路徑或狀態的相應 getter。產生的陣列是一個單獨的快照；更改它不會控制腳本。
  • int 陣列：索引 0..N-1 或空數組。這些元素是數字，而不是名稱或文字條目。
var indices = UO.GetScriptsList();
foreach (var index in indices)
{
    UO.Print(Convert.ToString(index) + ": " + UO.GetScriptName(index));
}

2。在循環或條件中使用 - 腳本函數

參數與執行流程：

  • 這是命令共享的具體範例。陣列索引從零開始；處理前請檢查長度。 UO.Wait(250)，在使用它的地方，等待250毫秒。
  • 沒有爭論。將每個數字傳遞給名稱、路徑或狀態的相應 getter。產生的陣列是一個單獨的快照；更改它不會控制腳本。
  • int 陣列：索引 0..N-1 或空數組。這些元素是數字，而不是名稱或文字條目。
return  RunScenario();
 object? RunScenario()
{
    var indices = UO.GetScriptsList();
    if (Truth(ArrayLength(indices) > 0))
    {
        var firstIndex = indices[0];
        UO.Print(UO.GetScriptPath(firstIndex));
    }

    return null;
}

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;

3。完整的輔助函數 - 腳本類

參數與執行流程：

  • Main 下面是整個函數。它的參數和結果與其所呼叫的 API 指令分開解釋。
  • FindNamedScript 迭代目前索引並傳回顯示名稱或 -1 的第一個完全符合項目。名稱可能會重複，索引可能會稍後移動。
  • int 陣列：索引 0..N-1 或空數組。這些元素是數字，而不是名稱或文字條目。
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 index = FindNamedScript("Mining");
        if (Truth(index >= 0))
        {
            UO.Print(Convert.ToString(index));
        }
        else
        {
            UO.Print("Name not found");
        }

        return null;
    }

    dynamic FindNamedScript(dynamic wanted)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(UO.GetScriptName(index) == wanted))
            {
                return index;
            }
        }

        return -1;
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.GetScriptsList() — UO.GetScriptsList()

參數: 沒有參數。

結果: dynamic / Array.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "getscriptslist": return new InjectionValue(bridge.GetScriptsList().Select(value => new InjectionValue(value)).ToArray());

UO.Launch

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.Launch(object? file);
int UO.Launch(object? file, object? parameters);
int UO.Launch(object? file, object? parameters, object? workingDirectory);
int UO.Launch(object? file, object? parameters, object? workingDirectory, object? hidden);

參數

  • file — 程式或文件的強制路徑/名稱；轉換為文本，外部空格被刪除。空值給出 0 和錯誤訊息。若要選擇確切的程序，請使用完整路徑；無需向檔案本身添加外部引號。
  • workingDirectory — 進程的可選工作資料夾。如果有遺漏或空行，則取目前腳本的資料夾。如果執行時沒有這樣的資料夾，bridge 將使用客戶端的目前工作資料夾。這並不總是遊戲資料夾或EXE客戶端資料夾。
  • hidden — 可选布尔值，默认false。 true 停用透過 OS shell 開啟並請求在沒有控制台視窗的情況下啟動；你需要一個可執行檔。 false 允许文档关联。 GUI-程式本身仍可顯示其視窗。

傳回值

int: 1 (true) 若 Process.Start 回傳一個進程物件；否則0（false）。在C#中檢查結果==1或結果！ =0；int 不能直接與true 比較。這不是 PID、退出程式碼或工作完成確認。如果發生異常，則輸出錯誤並回傳0。當透過已經執行的程式開啟文件時，作業系統有時不會回傳新進程：在這種情況下0並不能證明文件沒有被開啟。

行為

  • 僅允許以指定順序重載一到四個參數。若要指定隱藏並保留預設工作資料夾，請傳遞空字串作為第三個參數。檔案/參數/workingDirectory 到文字的轉換不會事先檢查檔案是否存在。
  • 預設資料夾由目前正在執行的腳本決定。當hidden=true時，先根據workingDirectory檢查相對程式路徑。部分作業系統名稱查找和關聯是特定於系統的；完整路徑消除了歧義。如果工作資料夾或程式不可用，啟動可能會失敗。
  • 外部進程獨立運作。 Launch 不等待它完成，不讀取 stdout/stderr，並且在腳本停止時不會終止它。 true 隱藏是對啟動方法的請求，並不能保證任何視窗不可見。 Process物件在請求後被釋放；正在運行的程式本身繼續運作。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

var result = UO.Launch("loot-report.txt");
UO.Print("Launch: " + Convert.ToString(result));

1。打開現成的挖礦報告-直接腳本

參數與執行流程：

  • 將現有的 loot-report.txt 放在劇本旁邊。作業系統使用分配給 .txt 的應用程式來開啟它。 Main 回傳Launch 請求的結果，而不是報告的內容，也不確認其已被讀取。
var started = UO.Launch("loot-report.txt");
return started;

2。將帶有空格的路徑傳遞給編輯器 - 腳本函數

參數與執行流程：

  • 資料夾和報告必須存在；用你自己的替換它們。 Chr(34) ​​在參數內用雙引號將報告的完整路徑括起來。 notepad.exe 必須可供系統存取。 false 啟用普通編輯器視窗。
return  RunScenario();
 object? RunScenario()
{
    var report = "C:\\UO Scripts\\loot report.txt";
    var arguments = Chr(34) + report + Chr(34);
    return UO.Launch("notepad.exe", arguments, "C:\\UO Scripts", false);
    return null;
}

string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();

3。準備沒有控制台視窗的本機日誌清單 - 腳本類

參數與執行流程：

  • Windows 範例執行內建的 cmd.exe。在腳本資料夾中，將建立或覆寫包含 *.logs 清單的 log-files.txt。空的第三個參數保存腳本資料夾，true隱藏控制台。 Main 中的true 表示僅啟動：文件可能尚未準備好，並且缺少 *.log 或實用程式錯誤不會更改已獲得的結果Launch。
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 started = UO.Launch("cmd.exe", "/d /c dir /b *.log > log-files.txt", "", true);
        if (Truth(started == 0))
        {
            return false;
        }

        return true;
        return null;
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.Launch(file) — UO.Launch(Any)

參數: file (Any)

結果: int / Integer.

呼叫時:

呼叫時執行已儲存的處理函式 delegate。註冊方法在建立 API 時建立此 delegate。

內部實作程式碼，不能作為獨立腳本執行。

values => new InjectionValue(CompactLaunch(values))

UO.Launch(file, parameters) — UO.Launch(Any,Any)

參數: file (Any), parameters (Any)

結果: int / Integer.

呼叫時:

呼叫時執行已儲存的處理函式 delegate。註冊方法在建立 API 時建立此 delegate。

內部實作程式碼，不能作為獨立腳本執行。

values => new InjectionValue(CompactLaunch(values))

UO.Launch(file, parameters, workingDirectory) — UO.Launch(Any,Any,Any)

參數: file (Any), parameters (Any), workingDirectory (Any)

結果: int / Integer.

呼叫時:

呼叫時執行已儲存的處理函式 delegate。註冊方法在建立 API 時建立此 delegate。

內部實作程式碼，不能作為獨立腳本執行。

values => new InjectionValue(CompactLaunch(values))

UO.Launch(file, parameters, workingDirectory, hidden) — UO.Launch(Any,Any,Any,Any)

參數: file (Any), parameters (Any), workingDirectory (Any), hidden (Any)

結果: int / Integer.

呼叫時:

呼叫時執行已儲存的處理函式 delegate。註冊方法在建立 API 時建立此 delegate。

內部實作程式碼，不能作為獨立腳本執行。

values => new InjectionValue(CompactLaunch(values))

UO.PauseResumeScript

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.PauseResumeScript(object? scriptIndex);

手動暫停一項活動運行。用於暫時停止採礦或其他過程，而不丟失當前進度。

參數

  • scriptIndex - 必需的 ScriptIndex — 目前啟動指數： 0 表示第一個，然後 1, 2……透過獲取它 GetScriptsList;它不是 serial，檔名而不是結果 StartScript。負數/缺失索引不會改變任何東西。

傳回值

void - 無回傳值。不要將呼叫與 true/1 進行比較。透過單獨讀取GetScriptState檢查情況；這樣讀取的結果是0（無開始）、1（運行）、2（暫停）。

行為

  • 僅適用於目前會話的運行。未執行的開啟選項卡不是主動啟動。停止不會刪除原始檔案或斷開與伺服器的連線。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
  • 這是一個開關，而不是“始終繼續”命令。手動和自動暫停是獨立的：切換到手動不會消除連線中斷暫停。代碼2沒有解釋暫停的原因。如果你以這種方式停止自己的啟動，它將無法進行下一次呼叫來繼續它；從 IDE/manager 或其他腳本恢復。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

for (int index = 0; index < UO.GetScriptsCount(); index++)
    if (UO.GetScriptName(index) == "Worker")
    { UO.PauseResumeScript(index); break; }

1。按名稱切換暫停 - 直接腳本

參數與執行流程：

  • MineOre 是已運行過程的顯示名稱範例。 FindNamedRun 傳回第一個符合的索引或-1。從另一個控制器呼叫；再次呼叫會將手動暫停變更回來。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
var index = FindNamedRun("MineOre");
if (Truth(index >= 0))
{
    UO.PauseResumeScript(index);
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }
    return -1;
}

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

2。暫停正在運行的啟動 - 腳本函數

參數與執行流程：

  • Check == 1 將操作限制為正在執行的觸發器。值2不用作「清除手動暫停」指示，因為它可能指示沒有通訊。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
return  RunScenario();
 object? RunScenario()
{
    var index = FindNamedRun("MineOre");
    if (Truth(index >= 0))
    {
        if (Truth(UO.GetScriptState(index) == 1))
        {
            UO.PauseResumeScript(index);
        }
    }

    return null;
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }

    return -1;
}

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

3。選擇按檔案運行-腳本類

參數與執行流程：

  • 將絕對路徑替換為您的路徑。 FindFileRun 以不區分大小寫的方式比較路徑並返回該檔案的第一次運行；可以在一個檔案中執行多個過程。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
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 wantedPath = "D:/Game/AutoLoad/Scripts/Worker.csx";
        var index = FindFileRun(wantedPath);
        if (Truth(index >= 0))
        {
            UO.PauseResumeScript(index);
        }

        return null;
    }

    dynamic FindFileRun(dynamic wantedPath)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(Convert.ToString(ReplaceText(UO.GetScriptPath(index), Chr(92), "/")) == Convert.ToString(ReplaceText(wantedPath, Chr(92), "/"))))
            {
                return index;
            }
        }

        return -1;
    }

    string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    string ReplaceText(object? value, object? oldValue, object? newValue) => (Convert.ToString(value) ?? "").Replace(Convert.ToString(oldValue) ?? "", Convert.ToString(newValue) ?? "");
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.PauseResumeScript(scriptIndex) — UO.PauseResumeScript(Any)

參數: scriptIndex (Any)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "pauseresumescript": bridge.PauseResumeScript(Arg(0)); return InjectionValue.Unit;

UO.SetEvent

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.SetEvent(object? name, object? stateValue);
void UO.SetEvent(object? name, object? stateValue, object? repeatOrHandler);
void UO.SetEvent(object? nameValue, object? stateValue, object? repeatValue, object? subNameValue);

啟用或停用對角色狀態變化的監控，並允許您選擇一次性或重複反應。例如，您可以在死亡後取消一次剩餘目標，或收到有關耐力不足的警告。處理程序與條件分開指定；主腳本應該繼續執行UO.Wait。

參數

  • name — 具有以下五個名稱之一的字串：ChangeHitPoints、ChangeMana、ChangeStamina、Death、SeeNewPlayer。大小寫並不重要；前綴 ev 是可以接受的，例如 evChangeMana。邊緣周圍的空白被刪除。沒有事件的數字目錄；任意名稱不會建立新事件。
  • nameValue — 事件名稱與名稱相同；這是四參數形式中第一個參數的名稱，而非可選值。
  • stateValue - true/1 開啟監聽，false/0 取消訂閱。傳遞不帶引號的布林值。在數值轉換中，任何非零整數都包含觀察值。停用不會等待或停止已執行的處理程序。
  • repeatOrHandler — 第三個參數有兩個目的。非數字非空字串（例如“OnManaChanged”）指定自動重複處理程序。 Number/bool 設定僅重複：false/0 — 一次操作，true/1 — 重複；此表單中未指派任何處理程序。字串“1”也是數字，不是過程名稱。對於一次性處理程序，請使用四個參數。
  • repeatValue - 採用具有四個參數的形式： false/0 - 在第一次偵測到轉換後刪除訂閱，true/1 - 將其保留以供下一次變更。當找不到處理程序或管理器拒絕其啟動時，一次性訂閱也會被取消；不要將事件的偵測與程式的成功完成混為一談。

傳回值

void - 無值。在单独的行上调用，没有 var 结果 = 并且不与 true/1 进行比较。完成注册并不确认处理程序已找到、启动，或者服务器已采取操作。如果在事件中找不到过程名称，则不会发生调用。

行為

  • 兩個參數： false 停用該事件； true 涉及在沒有處理程序的情況下重複觀察。任何具有匹配名稱的過程都不會被自動替換。此表格不會回傳結果，也不會取代 HP/Mana/Dead 測試。
  • 這四個參數明確指定事件名稱、啟用、重複和處理程序。兩個布林參數均不含引號寫入。 false/0 = 一次：在偵測到第一個轉換後而不是在處理程序結束後取消訂閱。
  • 重新註冊一個事件會取代其先前的設置，並將當前狀態記住為新的參考點。對一個腳本中的一個規範化名稱的訂閱 SetEvent 和 SetEventProc 使用一筆記錄並且不會累積。
  • ChangeHitPoints 將目前HP self 與先前的快照進行比較；在失去和恢復生命值時都會觸發。 ChangeMana 和 ChangeStamina 在兩個方向上的反應類似。這不僅僅是傷害、法力消耗或疲勞。
  • 當生→死的轉變時會觸發死亡。註冊一個已經死亡的角色不會立即呼叫處理程序；復活後再次死亡可以再次觸發。
  • SeeNewPlayer 比較已下載的手機集（不包括 0 和 self）。這個名字並不意味著測試實際的玩家：這包括NPC和生物。每次檢查一個或多個新的 serial 會導致一次啟動嘗試。離開的mobile從加載組中回歸也可以被認為是新的外觀。 ID 不會傳遞給處理程序 - 必須單獨找到必要的物件。
  • UO.Wait 和 WaitAsync 將等待分為最多25 ms 的時間間隔，並在每個時間間隔後檢查事件； UO.Wait(0) 也執行檢查。這是輪詢可用狀態而不是攔截每個網路封包：可能會錯過檢查之間的快速變更和返回。在沒有UO.Wait或主腳本完成後的計算週期中沒有持續的監控。
  • 處理程序名稱透過 RegisterRoutine 與 C# 委託預先關聯。回調在本次會話中非同步執行；一項任務不會與其自身疊加。主腳本結束後，禁止她進一步的行動。
  • 訂閱是指正在運行的腳本的實例。在創建它的 Main 中將其刪除：單獨啟動的處理程序內的同名命令將更改其自己的訂閱。取消註冊不會停止已經執行的處理程序。使用 try/finally 來正常退出或可處理的錯誤；強制停止也會停止對此腳本的進一步輪詢。
  • 註冊時，未知的非空事件名稱將被拒絕，並顯示系統訊息。空名稱沒有任何作用。僅在觸發時才檢查處理程序是否存在；最好透過SubExists提前檢測其名稱錯誤，並檢查IDE中的腳本。

在 C# 中，必須明確註冊處理程序：RegisterRoutine("Handler", Handler)。 HP、法力和耐力的更改透過本機事件隊列進行；死亡和SeeNewPlayer與當地世界的快照進行檢查。帶參數的直接訂閱可以透過 SubscribeEvent("UO.JournalEntry", handler) 和類似的本機名稱取得。當此執行完成或取消時，所有訂閱都會被釋放。

已上傳C#-文件

除了本地委託之外，當前管理器還支援明確加載 C#- 使用 Child.csx::Main 等鍵進行輸入。 SubExists 和 FunRunning 接受這樣的密鑰； CallSub 運行文件，無需 Args, 一個 Exec("exec Child.csx::Main 'north gate' 42") 傳輸 Args。帶空格的鍵在裡面的引號裡 Exec。唯一的短名稱是可以接受的，模糊的名稱不會選擇隨機檔案。本地註冊優先。文件啟動在當前世界/管理器中擁有自己的上下文和生命週期；本地代表屬於註冊它們的執行。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

RegisterRoutine("HealthChanged", () => UO.Print("HP changed"));
UO.SetEvent("ChangeHitPoints", true, false, "HealthChanged");
await WaitAsync(5000);

1。死亡後取消一次不完整的目標 - 直接腳本

參數與執行流程：

  • 觀察持續八秒。已經死亡的角色的死亡不會立即呼叫處理程序。本例不再處理復活後的第二次死亡事件。
  • 處理程序在執行時檢查目標的活動遊標，然後呼叫CancelTarget。在此範例中，沒有取消沒有活動遊標的準備佇列。腳本不復活角色，停止所有腳本，也不結束主線。如果您想讓目標保持活動狀態，請不要執行該範例。
var registrationOnFirstDeath = RegisterRoutine("OnFirstDeath", OnFirstDeath);
UO.SetEvent("Death", true, false, "OnFirstDeath");
try
{
    UO.Wait(8000);
}
finally
{
    UO.SetEvent("Death", false);
}

void OnFirstDeath()
{
    if (Truth(UO.Targeting()))
    {
        UO.CancelTarget();
        UO.Print("Death detected: active targeting cancelled");
    }
    else
    {
        UO.Print("Death detected: no active target");
    }
}

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

2。重複耐力警告：簡短形式 - 腳本功能

參數與執行流程：

  • 24 × 250 毫秒 – 六秒。 10 是處理程序中的閾值，而不是附加參數SetEvent。耐力的增加也是由處理程序引起的，但對於 10 的值，不會顯示該訊息。
  • true、「OnFatigue」與true、true不同：後一個選項指定重複而無需過程。該腳本不會增加耐力或改變伺服器速度。
return  RunScenario();
 object? RunScenario()
{
    var registrationOnFatigue = RegisterRoutine("OnFatigue", OnFatigue);
    UO.SetEvent("evChangeStamina", true, "OnFatigue");
    try
    {
        for (int tick = (int)(1); tick <= 24; tick += (int)(1))
        {
            UO.Wait(250);
        }
    }
    finally
    {
        UO.SetEvent("ChangeStamina", false);
    }

    return null;
}

void OnFatigue()
{
    var staminaNow = UO.Stamina();
    if (Truth(staminaNow < 10))
    {
        UO.Print("Stamina is " + Convert.ToString(staminaNow) + ": consider resting");
    }
}

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

3。在不累積訂閱的情況下切換法力處理程序 - 腳本類

參數與執行流程：

  • 在前兩秒，每個偵測到的變化都會觸發 OnManaLog。在接下來的三秒內，使用OnLowMana。註冊第二個處理程序本身不會觸發它。
  • 替換不會中斷已經運行的舊過程。這些短處理程序不使用 Main 局部變數。如果禁止實施程序，則管理員可以拒絕啟動 - 對於此模式，請直接在 Main 檢查 Mana。
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 registrationOnManaLog = RegisterRoutine("OnManaLog", OnManaLog);
        var registrationOnLowMana = RegisterRoutine("OnLowMana", OnLowMana);
        UO.SetEvent("ChangeMana", true, true, "OnManaLog");
        try
        {
            UO.Wait(2000);
            UO.SetEvent("ChangeMana", true, true, "OnLowMana");
            UO.Wait(3000);
        }
        finally
        {
            UO.SetEvent("ChangeMana", false);
        }

        return null;
    }

    void OnManaLog()
    {
        UO.Print("Mana now: " + Convert.ToString(UO.Mana()));
    }

    void OnLowMana()
    {
        if (Truth(UO.Mana() < 20))
        {
            UO.Print("Mana below 20: check the cost before casting");
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.SetEvent(name, stateValue) — UO.SetEvent(Any,Any)

參數: name (Any), stateValue (Any)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "SetEvent": SetStateEvent(arguments); return true;

內部實作程式碼，不能作為獨立腳本執行。

public void SetEvent(InjectionValue name, InjectionValue stateValue)

            => SetEvent(name, stateValue, InjectionValue.True, new InjectionValue(string.Empty));

UO.SetEvent(name, stateValue, repeatOrHandler) — UO.SetEvent(Any,Any,Any)

參數: name (Any), stateValue (Any), repeatOrHandler (Any)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "SetEvent": SetStateEvent(arguments); return true;

內部實作程式碼，不能作為獨立腳本執行。

public void SetEvent(InjectionValue name, InjectionValue stateValue, InjectionValue repeatOrHandler)

        {

            string raw = repeatOrHandler.ToString() ?? string.Empty;

            if (!string.IsNullOrWhiteSpace(raw) && !NumberConversions.TryStr2Int(raw, out _))

                SetEvent(name, stateValue, InjectionValue.True, repeatOrHandler);

            else

                SetEvent(name, stateValue, repeatOrHandler, new InjectionValue(string.Empty));

        }

UO.SetEvent(nameValue, stateValue, repeatValue, subNameValue) — UO.SetEvent(Any,Any,Any,Any)

參數: nameValue (Any), stateValue (Any), repeatValue (Any), subNameValue (Any)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "SetEvent": SetStateEvent(arguments); return true;

內部實作程式碼，不能作為獨立腳本執行。

public void SetEvent(InjectionValue nameValue, InjectionValue stateValue, InjectionValue repeatValue, InjectionValue subNameValue)

        {

            string name = NormalizeLegacyEventName(nameValue.ToString());

            if (string.IsNullOrEmpty(name))

                return;



            bool enabled = NumberConversions.ToInt(stateValue) != 0;

            eventStates[name] = enabled ? 1 : 0;

            if (!enabled)

            {

                legacyEvents.Remove(name);

                return;

            }



            if (!IsSupportedLegacyEventName(name))

            {

                eventStates[name] = 0;

                legacyEvents.Remove(name);

                SystemMessage($"SetEvent: unsupported event '{name}'. Supported: SeeNewPlayer, Death, ChangeHitPoints, ChangeMana, ChangeStamina.");

                return;

            }



            var subscription = new LegacyEventSubscription

            {

                Name = name,

                Repeat = NumberConversions.ToInt(repeatValue) != 0,

                Handler = NormalizeLegacyEventHandler(subNameValue.ToString())

            };

            CaptureLegacyEventSnapshot(subscription);

            legacyEvents[name] = subscription;

        }

UO.SetEventProc

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.SetEventProc(object? eventname, object? procname);

指定當觀察到的狀態改變時客戶端將運作的過程：例如，當生命值遺失、法力變化或出現新的mobile時。讓您將反應與主循環分開。註冊本身不運行任何東西：主腳本必須保持活動狀態； C#-控制點，WaitAsync和UO.Wait處理事件。

參數

  • eventname — 具有以下五個名稱之一的字串：ChangeHitPoints、ChangeMana、ChangeStamina、Death、SeeNewPlayer。大小寫並不重要；前綴 ev 是可以接受的，例如 evChangeMana。邊緣周圍的空白被刪除。沒有事件的數字目錄；任意名稱不會建立新事件。

傳回值

void - 無值。在单独的行上调用，没有 var 结果 = 并且不与 true/1 进行比较。完成注册并不确认处理程序已找到、启动，或者服务器已采取操作。如果在事件中找不到过程名称，则不会发生调用。

行為

  • 兩個參數都是必需的。訂閱是重複的：新偵測到的變更會導致新的啟動嘗試。在一個正在執行的腳本中，一個處理程序被指派給一個規範化的事件名稱；重新註冊會取代它並更新初始快照。 SetEventProc(event, "") 在同一腳本中取消訂閱。一次性反應，請使用 SetEvent(event, true, false, "Handler")。
  • ChangeHitPoints 將目前HP self 與先前的快照進行比較；在失去和恢復生命值時都會觸發。 ChangeMana 和 ChangeStamina 在兩個方向上的反應類似。這不僅僅是傷害、法力消耗或疲勞。
  • 當生→死的轉變時會觸發死亡。註冊一個已經死亡的角色不會立即呼叫處理程序；復活後再次死亡可以再次觸發。
  • SeeNewPlayer 比較已下載的手機集（不包括 0 和 self）。這個名字並不意味著測試實際的玩家：這包括NPC和生物。每次檢查一個或多個新的 serial 會導致一次啟動嘗試。離開的mobile從加載組中回歸也可以被認為是新的外觀。 ID 不會傳遞給處理程序 - 必須單獨找到必要的物件。
  • UO.Wait 和 WaitAsync 將等待分為最多25 ms 的時間間隔，並在每個時間間隔後檢查事件； UO.Wait(0) 也執行檢查。這是輪詢可用狀態而不是攔截每個網路封包：可能會錯過檢查之間的快速變更和返回。在沒有UO.Wait或主腳本完成後的計算週期中沒有持續的監控。
  • 處理程序名稱透過 RegisterRoutine 與 C# 委託預先關聯。回調在本次會話中非同步執行；一項任務不會與其自身疊加。主腳本結束後，禁止她進一步的行動。
  • 訂閱是指正在運行的腳本的實例。在創建它的 Main 中將其刪除：單獨啟動的處理程序內的同名命令將更改其自己的訂閱。取消註冊不會停止已經執行的處理程序。使用 try/finally 來正常退出或可處理的錯誤；強制停止也會停止對此腳本的進一步輪詢。
  • 註冊時，未知的非空事件名稱將被拒絕，並顯示系統訊息。空名稱沒有任何作用。僅在觸發時才檢查處理程序是否存在；最好透過SubExists提前檢測其名稱錯誤，並檢查IDE中的腳本。

在 C# 中，必須明確註冊處理程序：RegisterRoutine("Handler", Handler)。 HP、法力和耐力的更改透過本機事件隊列進行；死亡和SeeNewPlayer與當地世界的快照進行檢查。帶參數的直接訂閱可以透過 SubscribeEvent("UO.JournalEntry", handler) 和類似的本機名稱取得。當此執行完成或取消時，所有訂閱都會被釋放。

已上傳C#-文件

除了本地委託之外，當前管理器還支援明確加載 C#- 使用 Child.csx::Main 等鍵進行輸入。 SubExists 和 FunRunning 接受這樣的密鑰； CallSub 運行文件，無需 Args, 一個 Exec("exec Child.csx::Main 'north gate' 42") 傳輸 Args。帶空格的鍵在裡面的引號裡 Exec。唯一的短名稱是可以接受的，模糊的名稱不會選擇隨機檔案。本地註冊優先。文件啟動在當前世界/管理器中擁有自己的上下文和生命週期；本地代表屬於註冊它們的執行。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

RegisterRoutine("HealthChanged", () => UO.Print("HP changed"));
UO.SetEventProc("ChangeHitPoints", "HealthChanged");
await WaitAsync(5000);

1。监控10秒的健康变化 - 直接脚本

參數與執行流程：

  • ChangeHitPoints觀察HP的性格。 OnHealthChanged - 同一載入檔案中 Main 下方/上方的方法名稱。 UO.Wait 處理事件；第二個參數為空將禁用重複。
  • 處理程序僅發出警告，不會自動選擇治療。當改變HP60→50→70時，會進行兩個反應；這不是點擊計數器。
var registrationOnHealthChanged = RegisterRoutine("OnHealthChanged", OnHealthChanged);
UO.SetEventProc("ChangeHitPoints", "OnHealthChanged");
try
{
    for (int tick = (int)(1); tick <= 40; tick += (int)(1))
    {
        UO.Wait(250);
    }
}
finally
{
    UO.SetEventProc("ChangeHitPoints", "");
}

void OnHealthChanged()
{
    var hp = UO.HP();
    if (Truth(hp < 40))
    {
        UO.Print("Low health: " + Convert.ToString(hp) + ". Check healing or retreat.");
    }
    else
    {
        UO.Print("Health changed: " + Convert.ToString(hp));
    }
}

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

2。在準備過程中監控法力和耐力是腳本功能

參數與執行流程：

  • evChangeMana 和 ChangeMana 是一個事件。有兩個獨立的訂閱和兩個不同的處理程序，而不是同名的兩個處理程序。閾值 20 和 10 可以更改。
  • 等待持續5秒。也會偵測資源回收，但當該值已高於閾值時不會發出警告。
return  RunScenario();
 object? RunScenario()
{
    var registrationOnManaChanged = RegisterRoutine("OnManaChanged", OnManaChanged);
    var registrationOnStaminaChanged = RegisterRoutine("OnStaminaChanged", OnStaminaChanged);
    UO.SetEventProc("evChangeMana", "OnManaChanged");
    UO.SetEventProc("ChangeStamina", "OnStaminaChanged");
    try
    {
        for (int tick = (int)(1); tick <= 20; tick += (int)(1))
        {
            UO.Wait(250);
        }
    }
    finally
    {
        UO.SetEventProc("ChangeMana", "");
        UO.SetEventProc("ChangeStamina", "");
    }

    return null;
}

void OnManaChanged()
{
    if (Truth(UO.Mana() < 20))
    {
        UO.Print("Mana below 20: postpone expensive spells");
    }
}

void OnStaminaChanged()
{
    if (Truth(UO.Stamina() < 10))
    {
        UO.Print("Stamina below 10: consider a movement break");
    }
}

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

3。注意新手機，然後停用監控 - 腳本類

參數與執行流程：

  • SeeNewPlayer 偵測載入的行動裝置集中serial 的出現，包括NPC。一次加載五個生物並不能保證五個召喚。
  • GetMobiles() - 單獨讀取實際集合，而不是從事件中讀取ID。選擇敵人需要明確的條件；此範例無意攻擊任何人。
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 registrationOnMobileAppeared = RegisterRoutine("OnMobileAppeared", OnMobileAppeared);
        UO.SetEventProc("SeeNewPlayer", "OnMobileAppeared");
        try
        {
            UO.Wait(5000);
        }
        finally
        {
            UO.SetEventProc("SeeNewPlayer", "");
        }

        UO.Wait(1000);
        return null;
    }

    void OnMobileAppeared()
    {
        var mobiles = UO.GetMobiles();
        UO.Print("Loaded mobiles now: " + Convert.ToString(ArrayLength(mobiles)));
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.SetEventProc(eventname, procname) — UO.SetEventProc(Any,Any)

參數: eventname (Any), procname (Any)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "SetEventProc":
                SetStateEvent([arguments[0], !string.IsNullOrWhiteSpace(Convert.ToString(arguments[1])), true, arguments[1]]);
                return true;

內部實作程式碼，不能作為獨立腳本執行。

case "seteventproc":

                {

                    if (string.IsNullOrWhiteSpace(Text(1)))

                        SetEvent(arguments[0], InjectionValue.False);

                    else

                        SetEvent(arguments[0], InjectionValue.True, InjectionValue.True, arguments[1]);

                    return InjectionValue.Unit;

                }

UO.SetPauseScriptOnDisconnectStatus

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.SetPauseScriptOnDisconnectStatus(object? value);

更改腳本在連線遺失時暫停的規則。

參數

  • value - 0 關閉；任何非零整數包括。

傳回值

void - 沒有值。使用單獨的線路撥打電話；完成並不確認伺服器的操作。

行為

  • SetPauseScriptOnDisconnectStatus 設定 _manager。 PauseScriptsOnDisconnect = 啟用！ = 0。已經執行的腳本不會在此處收到 PauseResumeScript 命令。
  • 更改客戶端設定。該值不是連接測試的結果，並且不確認伺服器的處理。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

指令是獨立的陳述式。前面的訊息表示呼叫開始，並非伺服器已完成動作的確認。

UO.Print("Calling UO.SetPauseScriptOnDisconnectStatus");
UO.SetPauseScriptOnDisconnectStatus(1);

1。直接呼叫-直接腳本

參數與執行流程：

  • 更改腳本在連線遺失時暫停的規則。
UO.SetPauseScriptOnDisconnectStatus(1);

2。明確選項 - 腳本函數

參數與執行流程：

  • SetPauseScriptOnDisconnectStatus 設定 _manager。 PauseScriptsOnDisconnect = 啟用！ = 0。已經執行的腳本不會在此處收到 PauseResumeScript 命令。
return  RunScenario();
 object? RunScenario()
{
    UO.SetPauseScriptOnDisconnectStatus(0);
    return null;
}

3。完整的輔助函數 - 腳本類

參數與執行流程：

  • 更改客戶端設定。該值不是連接測試的結果，並且不確認伺服器的處理。
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()
    {
        ApplyMode(1);
        return null;
    }

    void ApplyMode(dynamic mode)
    {
        UO.SetPauseScriptOnDisconnectStatus(mode);
    }
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.SetPauseScriptOnDisconnectStatus(value) — UO.SetPauseScriptOnDisconnectStatus(Any)

參數: value (Any)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "setpausescriptondisconnectstatus": bridge.SetPauseScriptOnDisconnectStatus(Arg(0)); return InjectionValue.Unit;

UO.SetScriptName

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.SetScriptName(object? scriptIndex, object? value);

變更一項活動運行的顯示名稱。幫助區分清單中和通過GetScriptName正在運行的任務。

參數

  • scriptIndex - 必需的 ScriptIndex — 目前啟動指數： 0 表示第一個，然後 1, 2……透過獲取它 GetScriptsList;它不是 serial，檔名而不是結果 StartScript。負數/缺失索引不會改變任何東西。
  • value - 必需值 - 新名稱，轉換為字串。允許有空格；空字串也是可以接受的。這是當前運行的簽名，而不是來源中文件或過程的新名稱。

傳回值

void - 無回傳值。不要將呼叫與 true/1 進行比較。透過單獨讀取GetScriptState檢查情況；這樣讀取的結果是0（無開始）、1（運行）、2（暫停）。

行為

  • 僅適用於目前會話的運行。未執行的開啟選項卡不是主動啟動。停止不會刪除原始檔案或斷開與伺服器的連線。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

for (int index = 0; index < UO.GetScriptsCount(); index++)
    if (UO.GetScriptName(index) == "Worker")
    { UO.SetScriptName(index, "Worker renamed"); break; }

1。給任務一個清晰的名字－直接腳本

參數與執行流程：

  • 在活躍運行中搜尋MineOre，挖礦是新的簽名。引號內的名稱是使用者建立的並且可以替換。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
var index = FindNamedRun("MineOre");
if (Truth(index >= 0))
{
    UO.SetScriptName(index, "Mining");
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }
    return -1;
}

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

2。區分不同檔案中的任務—腳本函數

參數與執行流程：

  • 將 wantedPath 替換為您的絕對路徑。該檔案第一次主動啟動的簽章發生變化，但磁碟上的檔案仍保留在同一位置。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
return  RunScenario();
 object? RunScenario()
{
    var wantedPath = "D:/Game/AutoLoad/Scripts/Worker.csx";
    var index = FindFileRun(wantedPath);
    if (Truth(index >= 0))
    {
        UO.SetScriptName(index, "Worker A");
    }

    return null;
}

dynamic FindFileRun(dynamic wantedPath)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(Convert.ToString(ReplaceText(UO.GetScriptPath(index), Chr(92), "/")) == Convert.ToString(ReplaceText(wantedPath, Chr(92), "/"))))
        {
            return index;
        }
    }

    return -1;
}

string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
string ReplaceText(object? value, object? oldValue, object? newValue) => (Convert.ToString(value) ?? "").Replace(Convert.ToString(oldValue) ?? "", Convert.ToString(newValue) ?? "");

3。將狀態新增至簽名 - 腳本類

參數與執行流程：

  • GetScriptState = 2 將暫停的文字加入名稱中。這是一次性簽名：繼續後不會自動更新，本身不控制暫停。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
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 index = FindNamedRun("Mining");
        if (Truth(index >= 0))
        {
            var newName = "Mining";
            if (Truth(UO.GetScriptState(index) == 2))
            {
                newName = "Mining (paused)";
            }

            UO.SetScriptName(index, newName);
        }

        return null;
    }

    dynamic FindNamedRun(dynamic wanted)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(UO.GetScriptName(index) == wanted))
            {
                return index;
            }
        }

        return -1;
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.SetScriptName(scriptIndex, value) — UO.SetScriptName(Any,Any)

參數: scriptIndex (Any), value (Any)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

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

UO.StartScript

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.StartScript(object? scriptPath);

參數

傳回值

int：自接受運行以來的活動運行數； 65535 (0xFFFF) ​​= 啟動錯誤。這不是新腳本的索引，也不是 bool，也不是完成的結果。

行為

  • 考虑正在运行和暂停的启动；那些已完成并收到取消请求的人不包括在内。正在運行的腳本通常會考慮自身。仅仅加载 IDE 选项卡并不被视为启动。
  • 索引是啟動順序中的目前位置。啟動/停止腳本可以改變位置。不同的呼叫不會形成共同的原子快照；在下一個控制命令之前重新讀取列表。
  • GetScriptsList 給出索引，GetScriptsCount 數量，GetScriptState 三態碼。不要用一個替換另一個或將任何非空結果視為 true。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

var result = UO.StartScript("Scripts/Worker.csx");
UO.Print("StartScript: " + Convert.ToString(result));

1。第一次呼叫和結果 - 直接腳本

參數與執行流程：

  • 運行給定的C#腳本。傳遞的數字0表示索引；空括號表示沒有參數。文字 Print 僅是範例訊息。
  • 在範例之前，需要單獨建立指定的Worker.csx檔案。無效/不可存取的路徑、不適當的 Main、禁用的 C# 或並行運行停用將導致失敗。如果先前的運行仍然停止，則可以延遲重試；接受開始並不意味著完成。在讀取傳回的數量之前，可能會完成一個簡短的腳本。
  • int：自接受運行以來的活動運行數； 65535 (0xFFFF) ​​= 啟動錯誤。這不是新腳本的索引，也不是 bool，也不是完成的結果。
  • 強制 ScriptPath 是一個字串。相對路徑從該客戶端的AutoLoad資料夾開始；絕對路徑是可以接受的。用引號將有空格的路徑括起來。您需要帶有頂級程式碼的 .csx 或帶有受支援入口點 C# 的常規 .cs/.csproj。
var count = UO.StartScript("Scripts/Worker.csx");
if (Truth(count==65535))
{
    UO.Print("launch failed");
}
else
{
    UO.Print("Active executions: " + Convert.ToString(count));
}

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

2。在循環或條件中使用 - 腳本函數

參數與執行流程：

  • 這是命令共享的具體範例。陣列索引從零開始；處理前請檢查長度。 UO.Wait(250)，在使用它的地方，等待250毫秒。
  • 在範例之前，需要單獨建立指定的Worker.csx檔案。無效/不可存取的路徑、不適當的 Main、禁用的 C# 或並行運行停用將導致失敗。如果先前的運行仍然停止，則可以延遲重試；接受開始並不意味著完成。在讀取傳回的數量之前，可能會完成一個簡短的腳本。
  • int：自接受運行以來的活動運行數； 65535 (0xFFFF) ​​= 啟動錯誤。這不是新腳本的索引，也不是 bool，也不是完成的結果。
  • 強制 ScriptPath 是一個字串。相對路徑從該客戶端的AutoLoad資料夾開始；絕對路徑是可以接受的。用引號將有空格的路徑括起來。您需要帶有頂級程式碼的 .csx 或帶有受支援入口點 C# 的常規 .cs/.csproj。
return  RunScenario();
 object? RunScenario()
{
    var count = UO.StartScript("Scripts/My Worker.csx");
    if (Truth(count != 65535))
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            UO.Print(Convert.ToString(index) + ": " + UO.GetScriptPath(index));
        }
    }

    return null;
}

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

3。完整的輔助函數 - 腳本類

參數與執行流程：

  • Main 下面是整個函數。它的參數和結果與其所呼叫的 API 指令分開解釋。
  • TryStartCSharp 將結果與65535 進行比較並傳回 true/false。它不會等待完成，也不會將數量轉換為索引。
  • int：自接受運行以來的活動運行數； 65535 (0xFFFF) ​​= 啟動錯誤。這不是新腳本的索引，也不是 bool，也不是完成的結果。
  • 強制 ScriptPath 是一個字串。相對路徑從該客戶端的AutoLoad資料夾開始；絕對路徑是可以接受的。用引號將有空格的路徑括起來。您需要帶有頂級程式碼的 .csx 或帶有受支援入口點 C# 的常規 .cs/.csproj。
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(TryStartCSharp("Scripts/Worker.csx")))
        {
            UO.Print("launch accepted");
        }
        else
        {
            UO.Print("check file, Main and execution settings");
        }

        return null;
    }

    dynamic TryStartCSharp(dynamic fileName)
    {
        var count = UO.StartScript(fileName);
        return Truth(count != 65535);
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.StartScript(scriptPath) — UO.StartScript(Any)

參數: scriptPath (Any)

結果: int / Integer.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "startscript": return new InjectionValue(bridge.StartScript(Text(0)));

UO.StopAllScripts

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.StopAllScripts();

參數

沒有參數。

傳回值

void - 無回傳值。不要將呼叫與 true/1 進行比較。透過單獨讀取GetScriptState檢查情況；這樣讀取的結果是0（無開始）、1（運行）、2（暫停）。

行為

  • 僅適用於目前會話的運行。未執行的開啟選項卡不是主動啟動。停止不會刪除原始檔案或斷開與伺服器的連線。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
  • 沒有爭論。正在運行和掛起的過程、掛起的查詢以及重新運行隊列都將被取消。呼叫腳本也會取消：不要在此命令之後放置所需的儲存/報告。其他設定檔和進程不受影響。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

指令是獨立的陳述式。前面的訊息表示呼叫開始，並非伺服器已完成動作的確認。

UO.Print("Calling UO.StopAllScripts");
UO.StopAllScripts();

1。無條件一般停止-直接腳本

參數與執行流程：

  • 該命令有空括號。在調用之前執行所需的保存。控制器本身也將停止。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
UO.StopAllScripts();

2。在角色死亡時停止 - 腳本函數

參數與執行流程：

  • Connected檢查世界的入口，Dead檢查死亡。僅當兩個條件都滿足時才調用StopAllScripts；該範例檢查它們一次。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Connected()))
    {
        if (Truth(UO.Dead()))
        {
            UO.StopAllScripts();
        }
    }

    return null;
}

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

3。一般五秒後停止-腳本類

參數與執行流程：

  • 5000 是UO.Wait 中的毫秒，而不是StopAllScripts 參數。手動或自動控制器暫停可能會延遲執行；這不是一個獨立的計時器。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
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 delayMs = 5000;
        UO.Wait(delayMs);
        UO.StopAllScripts();
        return null;
    }
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.StopAllScripts() — UO.StopAllScripts()

參數: 沒有參數。

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "stopallscripts": bridge.StopAllScripts(); return InjectionValue.Unit;

UO.StopScript

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.StopScript(object? scriptIndex);

請求取消一項活動啟動，包括一項已暫停的啟動。當需要完成此運行而不是稍後繼續運行時使用。

參數

  • scriptIndex - 必需的 ScriptIndex — 目前啟動指數： 0 表示第一個，然後 1, 2……透過獲取它 GetScriptsList;它不是 serial，檔名而不是結果 StartScript。負數/缺失索引不會改變任何東西。

傳回值

void - 無回傳值。不要將呼叫與 true/1 進行比較。透過單獨讀取GetScriptState檢查情況；這樣讀取的結果是0（無開始）、1（運行）、2（暫停）。

行為

  • 僅適用於目前會話的運行。未執行的開啟選項卡不是主動啟動。停止不會刪除原始檔案或斷開與伺服器的連線。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
  • 取消是合作的：等待暫停並由引擎檢查；已發送到伺服器的操作不會被取消。取消的啟動會立即從活動清單中刪除，但資源釋放可能仍會持續。不要根據前一個索引檢查完成情況：它下面可能已經有另一個運行。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

for (int index = 0; index < UO.GetScriptsCount(); index++)
    if (UO.GetScriptName(index) == "Worker")
    { UO.StopScript(index); break; }

1。停止一個過程 - 直接腳本

參數與執行流程：

  • MineOre — 啟動名稱。 -1不轉移到StopScript。停止後，已儲存的索引將不再使用。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
var index = FindNamedRun("MineOre");
if (Truth(index >= 0))
{
    UO.StopScript(index);
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }
    return -1;
}

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

2。停止暫停的啟動 - 腳本函數

參數與執行流程：

  • 代碼2選擇暫停運行。 StopScript 結束它而不是取消暫停；其他任務繼續進行。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
return  RunScenario();
 object? RunScenario()
{
    var index = FindNamedRun("MineOre");
    if (Truth(index >= 0))
    {
        if (Truth(UO.GetScriptState(index) == 2))
        {
            UO.StopScript(index);
        }
    }

    return null;
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }

    return -1;
}

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

3。停止從特定檔案執行 - 腳本類

參數與執行流程：

  • 絕對路徑選擇檔案的第一個活動運行。這並不是刪除檔案或停止該檔案中的所有過程。
  • 指數是動態的：在另一次運行完成後，頭寸可能會改變。多個API呼叫不是原子操作。這些範例是為了避免對清單進行並行變更而設計的；在操作之前再次尋找所需的運行，並且不通過UO.Wait儲存索引。
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 wantedPath = "D:/Game/AutoLoad/Scripts/Worker.csx";
        var index = FindFileRun(wantedPath);
        if (Truth(index >= 0))
        {
            UO.StopScript(index);
        }

        return null;
    }

    dynamic FindFileRun(dynamic wantedPath)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(Convert.ToString(ReplaceText(UO.GetScriptPath(index), Chr(92), "/")) == Convert.ToString(ReplaceText(wantedPath, Chr(92), "/"))))
            {
                return index;
            }
        }

        return -1;
    }

    string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    string ReplaceText(object? value, object? oldValue, object? newValue) => (Convert.ToString(value) ?? "").Replace(Convert.ToString(oldValue) ?? "", Convert.ToString(newValue) ?? "");
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.StopScript(scriptIndex) — UO.StopScript(Any)

參數: scriptIndex (Any)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "stopscript": bridge.StopScript(Arg(0)); return InjectionValue.Unit;

UO.SubExists

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.SubExists(object? subrutineName);

檢查具有指定名稱的C#委託是否已在目前執行中註冊。這是給定會話的回調函數的註冊表，不會透過反射自動搜尋任意方法；明確載入的檔案輸入也可以透過按鍵存取。

參數

  • subrutineName 是RegisterRoutine 給出的字串名稱。邊緣周圍的空白被刪除；註冊名稱搜尋不區分大小寫。

傳回值

int：1 - 滿足條件，0 - 不滿足。如果多項檢查需要，則儲存一次呼叫的結果。

行為

  • 註冊和任務屬於同一個執行。另一個角色、個人資料或後續運行都有自己的註冊表。
  • RegisterRoutine 接受 Action、Func<Task> 或帶有Exec 字串參數陣列的委託。刪除註冊不會運行程式碼並阻止進一步搜尋該名稱。
  • 主腳本在需要輔助程序時必須保持活動狀態：完成後，任務將被取消，註冊和訂閱將被釋放。
  • FunRunning 不是管理者索引。 GetScriptsList和GetScriptState描述獨立檔案啟動；本地回呼不會收到單獨的索引。
  • 回調錯誤將在下次檢查時傳遞給主腳本。 WaitAsync、UO.Wait 和偵測的 C# 循環支援暫停、取消和事件佇列處理。

已上傳C#-文件

除了本地委託之外，當前管理器還支援明確加載 C#- 使用 Child.csx::Main 等鍵進行輸入。 SubExists 和 FunRunning 接受這樣的密鑰； CallSub 運行文件，無需 Args, 一個 Exec("exec Child.csx::Main 'north gate' 42") 傳輸 Args。帶空格的鍵在裡面的引號裡 Exec。唯一的短名稱是可以接受的，模糊的名稱不會選擇隨機檔案。本地註冊優先。文件啟動在當前世界/管理器中擁有自己的上下文和生命週期；本地代表屬於註冊它們的執行。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

RegisterRoutine("Hello", () => UO.Print("Hello"));
UO.Print("Registered flag: " + UO.SubExists("Hello"));

1。運行可用的可選過程 - 直接腳本

參數與執行流程：

  • 指令返回int：在C#中檢查結果！ =0或結果==1；與true直接比較是不可接受的。 WeightWatch 的定義如下，在呼叫指令之前透過RegisterRoutine 註冊。
  • 將範例儲存為單獨的文件，將其載入到 IDE/manager 並執行 Main，以便其餘過程最終位於該目錄中。 WeightWatch/ManaWatch - 訓練程序在這裡完整定義：三次重量/法力測量，間隔為UO.Wait(1000)，即1000毫秒，僅在進入世界時輸出。這不是持續監控；停頓可以延長時間。對於具有兩個任務的範例，必須允許同時啟動流程。
var registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
if (Truth(Truth(UO.SubExists("WeightWatch")) == true))
{
    UO.CallSub("WeightWatch");
}

while (UO.FunRunning("WeightWatch") != 0) await WaitAsync(25);

void WeightWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Weight: " + Convert.ToString(UO.Weight()));
        }
        UO.Wait(1000);
    }
}

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

2。選擇後備處理程序 - 腳本函數

參數與執行流程：

  • WeightWatch 可以從另一個檔案載入。如果不存在，則選擇此處聲明的ManaWatch。如果找到主資料庫但無法啟動，則不會自動轉換到輔助資料庫。
  • 將範例儲存為單獨的文件，將其載入到 IDE/manager 並執行 Main，以便其餘過程最終位於該目錄中。 WeightWatch/ManaWatch - 訓練程序在這裡完整定義：三次重量/法力測量，間隔為UO.Wait(1000)，即1000毫秒，僅在進入世界時輸出。這不是持續監控；停頓可以延長時間。對於具有兩個任務的範例，必須允許同時啟動流程。
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var registrationManaWatch = RegisterRoutine("ManaWatch", ManaWatch);
    if (Truth(UO.SubExists("WeightWatch") == 1))
    {
        UO.CallSub("WeightWatch");
    }
    else if (Truth(UO.SubExists("ManaWatch")))
    {
        UO.CallSub("ManaWatch");
    }

    while (UO.FunRunning("ManaWatch") != 0)
        await WaitAsync(25);
    return null;
}

void ManaWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Mana: " + Convert.ToString(UO.Mana()));
        }

        UO.Wait(1000);
    }
}

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

3。運行之前檢查兩個定義 - 腳本類

參數與執行流程：

  • HaveMonitors 使用 && 測試兩個名稱。如果至少缺少一個，Main 不會呼叫任何任務。測試了一組定義，但不能保證成功同時執行。
  • 將範例儲存為單獨的文件，將其載入到 IDE/manager 並執行 Main，以便其餘過程最終位於該目錄中。 WeightWatch/ManaWatch - 訓練程序在這裡完整定義：三次重量/法力測量，間隔為UO.Wait(1000)，即1000毫秒，僅在進入世界時輸出。這不是持續監控；停頓可以延長時間。對於具有兩個任務的範例，必須允許同時啟動流程。
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 registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
        var registrationManaWatch = RegisterRoutine("ManaWatch", ManaWatch);
        if (Truth(HaveMonitors()))
        {
            UO.CallSub("WeightWatch");
            UO.CallSub("ManaWatch");
        }

        while (UO.FunRunning("WeightWatch") != 0 || UO.FunRunning("ManaWatch") != 0)
            await WaitAsync(25);
        return null;
    }

    dynamic HaveMonitors()
    {
        return UO.SubExists("WeightWatch") != 0 && UO.SubExists("ManaWatch") != 0;
    }

    void WeightWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Weight: " + Convert.ToString(UO.Weight()));
            }

            UO.Wait(1000);
        }
    }

    void ManaWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Mana: " + Convert.ToString(UO.Mana()));
            }

            UO.Wait(1000);
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.SubExists(subrutineName) — UO.SubExists(String)

參數: subrutineName (String)

結果: int / Integer.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "SubExists":
                string requested = Convert.ToString(arguments[0]) ?? "";
                result = Exists(requested) || events is ICSharpScriptHost known && known.HasCSharpScript(requested) ? 1 : 0;
                return true;

內部實作程式碼，不能作為獨立腳本執行。

public int SubExists(string subrutineName) => bridge.SubExists(subrutineName) ? 1 : 0;

UO.Terminate

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.Terminate();
void UO.Terminate(object? subrutineName);

參數

  • subrutineName — 選用字串。省略參數或傳入空字串會選取最後啟動的檔案；"all" 會要求取消所有執行。C# 檔案請使用目錄中的確切鍵，例如 harvest.csx::Main。Harvest 這類本地 callback 名稱只有在使用 RegisterRoutine 明確註冊後才有效。一個檔案有一個 Main 入口；類別中的各個方法不會自動成為可獨立啟動的程序。

傳回值

void：此指令不傳回數字，也不等待工作執行緒終止。她立即​​要求取消。執行在下一次取消檢查時停止；暫停、斷點和內建等待會中斷。取消之前已分派的伺服器操作不會回滾。

行為

UO.FunRunning(name) == 0 也可能在提出取消要求後立即出現，並不表示上一個 callback 的 finally 區塊已結束。在上一個工作實際結束前，同一個本地名稱的另一個 CallSub 或 Exec 會被略過。

  • UO.Terminate() 按運行順序而不是按名稱、編輯器行、上次操作時間或顯示順序選擇過程。暫停的過程也被視為正在運行。
  • 屬於本次運行的本地目標被清除，剩餘的自動路徑被取消。運動取消是在遊戲線程上進行的；如果該路線已被其他跑步或用戶替​​換，則前所有者不會停止該路線。發送到伺服器的步驟不會被撤回。
  • 當啟用一次同時啟動的設定時，該命令仍然可用。取消的過程僅在其工作線程被清除後才釋放空間；在此之前，新的發布會被跳過。
  • 按名稱停止也會取消對應的掛起啟動。已完成的程序不會改變。客戶端報告狀態中沒有合適的啟動。對不支援取消的第三方本機插件的卡住呼叫無法透過強制終止執行緒來安全地中斷。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

C# 檔案請使用目錄中的確切鍵，例如 harvest.csx::Main。Harvest 這類本地 callback 名稱只有在使用 RegisterRoutine 明確註冊後才有效。一個檔案有一個 Main 入口；類別中的各個方法不會自動成為可獨立啟動的程序。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

UO.Terminate("harvest.csx::Main");
UO.Print("Cancellation requested for harvest.csx::Main");

1。停止按名字收割，留下其他程式－直接腳本

這會要求取消已在執行的 harvest.csx::Main。訊息不代表其 finally 已完成，也不會回復已執行的遊戲動作。

var procedureName = "harvest.csx::Main";
UO.Terminate(procedureName);
UO.Print("Cancellation requested for harvest.csx::Main");

2。僅從特定檔案中選擇 Main - 腳本函數

確切鍵 harvest.csx::Main 與 heal.csx::Main 不同。請換成已載入檔案的鍵。#2 等任意後綴不會建立另一個入口。

return  RunScenario();
 object? RunScenario()
{
    var procedureKey = "harvest.csx::Main";
    UO.Terminate(procedureKey);
    UO.Print("Cancellation requested: " + procedureKey);
    return null;
}

3。透過 Exec - 腳本類別相容控制台形式

字串 terminate harvest.csx::Main 透過 UO.Exec 傳入相同的鍵。含空白的鍵必須在指令字串中加上引號。

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 command = "terminate harvest.csx::Main";
        UO.Exec(command);
        UO.Print("Stop command sent");
        return null;
    }
}

4。當健康狀況較低時停止上次運行 - 直接腳本

參數與執行流程：

  • 不帶參數的表單選擇最後一個正在執行的腳本，包括暫停的腳本。這是一項以身作則的政策，而不是針對健康狀況不佳的強制性應對措施；在取消請求之前會顯示一條訊息。
if (UO.GetHP() <= 30)
{
    UO.Print("Low health: requesting cancellation of the most recent run");
    UO.Terminate();
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.Terminate() — UO.Terminate()

參數: 沒有參數。

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

public void Terminate() => bridge.Terminate(string.Empty);

UO.Terminate(subrutineName) — UO.Terminate(String)

參數: subrutineName (String)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

case "Terminate" when arguments.Length == 1:
                string routine = Convert.ToString(arguments[0]) ?? "";
                if (Exists(routine)) { Cancel(routine); return true; }
                if (Cancel(routine)) return true;
                return false;

內部實作程式碼，不能作為獨立腳本執行。

public void Terminate(string subrutineName) => bridge.Terminate(subrutineName);

UO.TerminateAll

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.TerminateAll();

參數

沒有參數。

傳回值

void：沒有結果。該命令請求取消所有當前運行，並將控制權傳回給呼叫程式碼（如果它本身尚未取消）。觸發取消檢查後，工作線程將被清理。

行為

  • 確切的語法是UO.TerminateAll()，名稱內沒有空格，也沒有參數。支援 UO.Terminate("all") 作為相容的替代表示法。
  • 停止運行過程、手動暫停和斷點過程、內建等待以及註冊的延遲運行。沒有工作時回電是安全的。
  • 刪除本地景點和自動路線會考慮到它們的所有者。已停止腳本的剩餘路線在遊戲線程上被取消；用戶替換它的新路線將被保存。已發送的動議包不會被取消。
  • 取消不會回滾已傳送到伺服器的操作。不支援取消的第三方本機外掛程式碼無法與串流一起安全銷毀。允許命令執行後新的明確啟動；當啟用該複選框時，它們會等待空間空閒，因為嘗試會被跳過，而不是排隊直到清理完成。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

指令是獨立的陳述式。前面的訊息表示呼叫開始，並非伺服器已完成動作的確認。

UO.Print("Calling UO.TerminateAll");
UO.TerminateAll();

1。停止所有腳本檢查工作腳本內部 - 直接腳本

參數與執行流程：

  • TerminateAll沒有參數。条件UO.Dead()在下一次迭代之前检查角色的死亡。
  • 當條件滿足時，目前的Main和剩餘的運行C#都被取消。訊息Print位於停止之前，因為在它之後該過程的程式碼停止。
  • 在此範例中，WaitAsync(250) ​​指定檢查之間的暫停250 毫秒。 stop 指令不會更改正常腳本暫停的長度。
for (int cycle = (int)(1); cycle <= 10; cycle += (int)(1))
{
    if (Truth(UO.Dead()))
    {
        UO.Print("Character is dead: stopping all C# scripts");
        UO.TerminateAll();
    }
    await Delay(250);
}

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;

2。與所有腳本功能相容的形式

參數與執行流程：

  • 此替代表示法使用 UO.Terminate 和一個參數 subrutineName="all"。這相當於UO.TerminateAll()。
  • 字串 all 是一個特殊值，而不是需要宣告的過程的名稱。 EmergencyStop也被取消。
  • 對於緊急遊戲鍵，請使用第一個範例中的單行命令：單獨的過程EmergencyStop本身受到並行運行禁止的約束。
return  RunScenario();
 object? RunScenario()
{
    UO.Print("Stopping all C# scripts");
    UO.Terminate("all");
    return null;
}

3。如果所需物件不可用，則停止常規操作 - 腳本類

參數與執行流程：

  • GetSerial 存放 serial 所需的對象，這裡是它自己的背包。 Exists=0表示該物件目前對客戶端來說是未知的。
  • 只有當違反所選條件時，才會不帶參數地呼叫TerminateAll。該政策停止了所有程序，而不僅僅是對特定背包的操作。
  • 首先，顯示停止原因。一旦提出取消請求，則當前流程也終止；不能指望下一步。
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 bag = UO.GetSerial("backpack");
        if (Truth(UO.Exists(bag) == 0))
        {
            UO.Print("Required backpack is unavailable: stopping all scripts");
            UO.TerminateAll();
        }

        return null;
    }

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

4。失去連接後停止所有工作 - 直接腳本

參數與執行流程：

  • 如果沒有連接，所有啟動都會停止。該命令不會傳回已取消腳本的數量，並且也會取消目前執行。
if (UO.Connected() == 0)
{
    UO.Print("Disconnected: requesting cancellation of every active script");
    UO.TerminateAll();
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.TerminateAll() — UO.TerminateAll()

參數: 沒有參數。

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

public void TerminateAll() => bridge.Terminate("all");

UO.Time

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.Time();

使用數字 HHMMSS 讀取計算機的本地時間。方便選擇允許的操作時間，而不是測量持續時間。

參數

沒有參數。

傳回值

int HHMMSS、0..235959 具有有效的分鐘和秒。 07:29:35 -> 72935；午夜 -> 0。零是有效時間，不是錯誤或邏輯標誌false。

行為

  • 沒有參數，沒有帶參數的形式。空括號僅讀取時間：呼叫不會等待、啟動計時器或向遊戲發送資料包。
  • RealTimeSource。現在讀取DateTime。 Now：電腦的本地日期/時間，不是UTC，不是分片時間，也不是遊戲時鐘。時區、夏令時和手動時鐘變更都會影響結果。每次通話都會捕捉到不同的時刻。
  • 不保留前導零，不保留毫秒。數字上 13:00:00 減 12:59:59 給出 4041，雖然一秒鐘過去了。午夜時分，數值再次變為零。
  • 不要減去日曆程式碼來計算延遲。使用 Timer() 和一次運行的兩個標記。日曆時鐘可能會倒退。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。顯示各個時間欄位 - 直接腳本

參數與執行流程：

  • 標記被讀取一次，以免混淆不同的秒數。 Int(stamp/10000) — 小時； Int(stamp/100) MOD 100 — 分鐘； MOD 100 – 秒。簡單字串不會用零填充字段。
var stamp = UO.Time();
var hour = stamp / 10000;
var minute = stamp / 100 % 100;
var second = stamp % 100;
UO.Print(Convert.ToString(hour) + ":" + Convert.ToString(minute) + ":" + Convert.ToString(second));

2。僅允許在晚間時段播放劇集 - 腳本功能

參數與執行流程：

  • 180000 - 18:00:00（含）； 220000 - 22:00:00 不包括在內。一項檢查決定是否繼續 Main。日程未註冊，系列不會自動開始。
return  RunScenario();
 object? RunScenario()
{
    var stamp = UO.Time();
    if (Truth(stamp >= 180000) && Truth(stamp < 220000))
    {
        UO.Print("Evening batch permitted by local schedule");
    }
    else
    {
        UO.Print("Outside the local schedule");
        return null;
    }

    return null;
}

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

3。考慮午夜之後的間隔 - 場景類

參數與執行流程：

  • ClockInWindow(stamp,first,last) 接受有效的HHMMSS。 230000..20000 表示從 23:00（含）到 02:00（不含）：OR 考慮午夜。等邊界意味著空間隔。在安靜期間，主賽結束；該函數已完整給出。
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(ClockInWindow(UO.Time(), 230000, 20000)))
        {
            UO.Print("Local quiet period; do not start a new batch");
            return null;
        }

        UO.Print("Outside the local quiet period");
        return null;
    }

    dynamic ClockInWindow(dynamic stamp, dynamic first, dynamic last)
    {
        if (Truth(first == last))
        {
            return false;
        }

        if (Truth(first < last))
        {
            return Truth(stamp >= first) && Truth(stamp < last);
        }

        return Truth(stamp >= first) || Truth(stamp < last);
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.Time() — UO.Time()

參數: 沒有參數。

結果: int / Integer.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

public int Time()

        {

            var now = timeSource.Now;

            return now.Hour * 10000 + now.Minute * 100 + now.Second;

        }

UO.Timer

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.Timer();

讀取目前運轉時的運轉時間（以十分之一秒為單位）。適合您自己的延遲和動作標記。

參數

沒有參數。

傳回值

int0..2147483647；單位是100毫秒。在 399 毫秒3 將返回。這是時鐘讀數，不是true/false，也不是剩餘充值。

行為

  • 沒有參數，沒有帶參數的形式。空括號僅讀取時間：呼叫不會等待、啟動計時器或向遊戲發送資料包。
  • 起源屬於該運行時實例。一個新的運行程式可能會收到一個新的時鐘；您無法比較不同運行的值或將它們儲存為絕對日期。在 UO.Wait 和腳本暫停期間，即時繼續計時。
  • 十分之幾的小數部分被丟棄。大約2485.5天后，數量達到2147483647並保持在那裡，不會溢出。
  • 這是您的延遲，而不是技能/咒語的伺服器冷卻時間或成功確認。該命令不允許您繞過伺服器對移動、咒語或腳本的限制。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。測量操作的持續時間 - 直接腳本

參數與執行流程：

  • WaitAsync(250) 請求 250 毫秒；實際延遲可能會更長。兩個標記之間的差值除以10.0即可獲得秒數。指示步驟UO.Timer - 100 ms。
var started = UO.Timer();
await Delay(250);
var elapsed = UO.Timer() - started;
var seconds = elapsed / 10.0;
UO.Print("Elapsed seconds: " + Convert.ToString(seconds));

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

2。將等待已請求的十字線限制為三秒 - 腳本功能

參數與執行流程：

  • 極限30以該函數的單位給出。 UO.Wait(50) 在檢查之間釋放執行。 UO.Targeting 讀取視線的存在；範例不施放或瞄準。如果景象沒有出現，則循環結束。
  • 即使計數器已停止在限值int，對上限的額外檢查也會結束等待。示波器狀態會重複讀取，並且在讀數之間可能會發生變化。
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var started = UO.Timer();
    while (Truth(UO.Timer() - started < 30) && !(Truth(UO.Targeting())))
    {
        if (Truth(UO.Timer() >= 2147483647))
        {
            break;
        }

        await Delay(50);
    }

    if (Truth(UO.Targeting()))
    {
        UO.Print("Target cursor available");
    }
    else
    {
        UO.Print("Target wait ended");
    }

    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;

3。自訂重試間隔函數 - 腳本類

參數與執行流程：

  • IntervalPassed(started,current,interval)在Main下完全定義。 Interval=5 — 半秒（以此時鐘為單位）。負區間、反轉和上界上的int給出false；精確地達到該區間給出true。
  • 這是您的延遲，而不是技能/咒語的伺服器冷卻時間或成功確認。該命令不允許您繞過伺服器對移動、咒語或腳本的限制。
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 started = UO.Timer();
        await Delay(500);
        var ready = IntervalPassed(started, UO.Timer(), 5);
        if (Truth(ready))
        {
            UO.Print("Local retry interval passed");
        }

        return null;
    }

    dynamic IntervalPassed(dynamic started, dynamic current, dynamic interval)
    {
        if (Truth(interval < 0) || Truth(current < started))
        {
            return false;
        }

        if (Truth(current >= 2147483647))
        {
            return false;
        }

        return current - started >= interval;
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.Timer() — UO.Timer()

參數: 沒有參數。

結果: int / Integer.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

public int Timer() => (int)Math.Max(0d, Math.Min(int.MaxValue, timeSource.SinceStart.TotalMilliseconds / 100d));

UO.Wait

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

void UO.Wait(object? waitTimeMS);

將目前腳本暫停指定的毫秒數。在重複狀態檢查之間很有用，可防止腳本連續循環運行。

參數

  • waitTimeMS — 以毫秒為單位的整數時間：1000 = 一秒。使用0..2147483647。這不是步數，不是秒數，也不是伺服器確認逾時。

傳回值

void - 沒有結果。使用單獨的線路撥打電話。延遲結束並不意味著物體已經移動、法術已經完成、或連接已經建立：單獨檢查所需的狀態。

行為

  • 零不會產生真正的延遲，也不適合作為快速循環中的暫停。負時間並不意味著無限大：UO.Wait將其減少到0； UO.Wait/sleep 可以透過主動回調來拒絕它，並且在沒有它們的客戶端橋中它不會等待。對於可移植腳本，僅使用非負時間。

範例.csx

UO.Wait(100);
// For an asynchronous script, use the host helper:
await WaitAsync(100);

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

指令是獨立的陳述式。前面的訊息表示呼叫開始，並非伺服器已完成動作的確認。

UO.Print("Calling UO.Wait");
UO.Wait(250);

1。 UO.Wait - 1 - 直接脚本

參數與執行流程：

  • 250 - 四分之一秒。等待後執行下一行；延遲完成訊息是範例的文本，而不是返回的結果。
UO.Wait(250);
UO.Print("Delay complete");

2。 UO.Wait — 2 — 腳本函數

參數與執行流程：

  • WaitForOnline 已在此腳本中完整聲明。參數20表示最多二十個250毫秒的暫停。在暫停前檢查連接，並在最後一次暫停後再次檢查連接。助手返回狀態 Connected (1/0)； wait 指令本身不回傳任何內容，也不連接到伺服器。
return  RunScenario();
 object? RunScenario()
{
    return WaitForOnline(20);
    return null;
}

dynamic WaitForOnline(dynamic checks)
{
    while (Truth(checks > 0))
    {
        if (Truth(UO.Connected()))
        {
            return 1;
        }

        UO.Wait(250);
        checks = checks - 1;
    }

    return UO.Connected();
}

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

3。 UO.Wait - 3 - 場景類

參數與執行流程：

  • 此循環恰好讀取三個重量讀數。讀數之間有兩次 500 毫秒的暫停，最後一次之後沒有暫停。第一次讀取和重量發生變化時會列印一則訊息。前面的變數儲存要比較的值，而不是調整遊戲權重。
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 previous = -1;
        var checks = 0;
        while (Truth(checks < 3))
        {
            var weight = UO.Weight();
            if (Truth(weight != previous))
            {
                UO.Print("Weight: " + Convert.ToString(weight));
                previous = weight;
            }

            checks = checks + 1;
            if (Truth(checks < 3))
            {
                UO.Wait(500);
            }
        }

        return null;
    }

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

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.Wait(waitTimeMS) — UO.Wait(Any)

參數: waitTimeMS (Any)

結果: void / Unit.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

public async Task WaitAsync(int milliseconds)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(milliseconds);
        Checkpoint();
        // Short slices allow Pause to suspend further script progress promptly.
        int remaining = milliseconds;
        while (remaining > 0)
        {
            int slice = Math.Min(remaining, 25);
            await Task.Delay(slice, Cancellation).ConfigureAwait(false);
            Checkpoint(); remaining -= slice;
        }
    }

內部實作程式碼，不能作為獨立腳本執行。

case "wait": WaitWithEvents(Arg(0)); return InjectionValue.Unit;

UO.Waiting

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# 簽章

int UO.Waiting();

檢查準備好的回應是否保留在目標佇列中。

參數

沒有參數。

傳回值

int 1 - 存在未取消的物件、方塊的延遲目標或取消下一個瞄準； 0 - 隊列為空。它沒有打開的遊標；對於遊標，使用 TargetPresent/Targeting。

該命令的結果是一個數字標誌： 1 表示滿足條件， 0 - 未實現。後 var 結果=命令（...）檢查是否（結果！= 0) 或 if (結果 == 0）。儲存一次呼叫的結果：重複呼叫可以再次執行該操作或讀取已經變更的狀態。

行為

  • 讀取整個客戶端佇列。如果多個過程同時運行，則每個過程的回應都會被考慮在內。
  • 零僅表示沒有待處理的回應。它並不確認在伺服器上成功使用技能或咒語。

獨立的 C# 腳本

每個範例都可以儲存為單獨的檔案.csx並在IDE中運行。 UO物件和等待函數提供當前遊戲會話的主機。將演示 serial 名稱、座標和地址替換為您自己的。

簡單範例

將這段程式碼存為獨立的 .csx 檔案執行。參數直接出現在呼叫中；請將範例名稱、serial 和網址替換成自己的值。

將一次呼叫的結果輸出到日誌。數值不會轉換成 bool；若結果是陣列，則顯示元素數量。

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

1。檢查準備-直接腳本

參數與執行流程：

  • 預計在 WaitTargetSelf 之後和伺服器目標 1 之前。
  • CancelWaitTarget 清空隊列；下一個測試給出0。
UO.WaitTargetSelf();
UO.Print(Convert.ToString(UO.Waiting()));
UO.CancelWaitTarget();

2。有界地等待響應被花費 - 腳本函數

參數與執行流程：

  • 該檢查沒有參數。 UO.Wait=50毫秒，最大20期望。
  • 如果答案仍然存在，則取消。單獨新增對伺服器操作結果的檢查。
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var attempts = 0;
    while (Truth(UO.Waiting()) && Truth(attempts < 20))
    {
        await Delay(50);
        attempts = attempts + 1;
    }

    if (Truth(UO.Waiting()))
    {
        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;

3。顯示隊列和視線之間的差異 - 腳本類

參數與執行流程：

  • 第一行顯示延遲響應，第二行顯示視線狀態。
  • 沒有遊標的佇列和沒有佇列的遊標都是可以的；這些值不可互換。
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.Print("Queued: " + Convert.ToString(UO.Waiting()));
        UO.Print("Cursor: " + Convert.ToString(UO.TargetPresent()));
        return null;
    }
}

命令實作

C# 區分大小寫。請使用正確的 UO 名稱。數值旗標應與 0 比較；只有回傳型別為 bool 時才使用 bool。

UO.Waiting() — UO.Waiting()

參數: 沒有參數。

結果: int / Integer.

呼叫時:

內部實作程式碼，不能作為獨立腳本執行。

public int Waiting() => bridge.GetWaitTargetQueue().Length > 0 ? 1 : 0;

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally