KO UO Topic scripts runtime

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

스크립트 및 런타임

홈 · C# · IDE · UO API · A–Z · 예 · 언어

시작, 일시 중지, 중지 스크립트 및 프로시저, 인스턴스 정보, 이벤트 및 대기. 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(이름, 핸들러)를 통해 현재 실행에 이전에 등록된 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# 파일

로컬 대리자 외에도 현재 관리자는 Child.csx::Main과 같은 키를 사용하여 명시적으로 로드된 C# 항목을 지원합니다. SubExists 및 FunRunning는 이러한 키를 허용합니다. CallSub는 Args 없이 파일을 실행하고 Exec("exec Child.csx::Main 'northgate' 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는 아래 절차의 이름입니다. 3개의 샘플을 기다리지 않고 주요 반품 77; 77는 CallSub이 아니라 Main의 결과입니다.
• 예제를 별도의 파일로 저장하고 IDE/manager에 로드한 다음 Main을 실행하여 나머지 절차가 디렉터리에 있도록 합니다. WeightWatch/ManaWatch - 여기에 완전히 정의된 훈련 절차: UO.Wait(1000) 간격, 즉 1000ms 간격으로 3개의 무게/마나 측정값, 세계에 들어갈 때만 출력됩니다. 이는 지속적인 모니터링이 아닙니다. 잠시 멈추면 시간이 길어질 수 있습니다. 두 개의 작업이 있는 예에서는 프로시저의 동시 실행이 허용되어야 합니다.

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) 간격, 즉 1000ms 간격으로 3개의 무게/마나 측정값, 세계에 들어갈 때만 출력됩니다. 이는 지속적인 모니터링이 아닙니다. 잠시 멈추면 시간이 길어질 수 있습니다. 두 개의 작업이 있는 예에서는 프로시저의 동시 실행이 허용되어야 합니다.

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) 간격, 즉 1000ms 간격으로 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 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.

호출 시:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.CallSub.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exec: bridge.Exec(subrutineName).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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를 사용하여 컴퓨터의 현지 달력 날짜를 읽습니다. 일련의 일일 활동 이름을 지정하거나 날짜 변경을 감지하는 데 유용합니다.

매개변수

매개변수가 없습니다.

반환값

int YYMMDD: 2026-09-30 -> 260930. 구분 기호나 선행 0이 저장되어 있지 않습니다. 기간도 아니고 Unix 시간도 아니고 true/false도 아닙니다.

동작

• 매개변수도 없고 인수가 포함된 형식도 없습니다. 빈 괄호는 시간만 읽습니다. 호출은 기다리지 않고 타이머를 시작하거나 게임에 패킷을 보내지 않습니다.
• RealTimeSource.이제 DateTime로 표시됩니다.이제: 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는 Harvest-260930와 같은 문자열입니다. Print 이름만 표시됩니다. 파일이 생성되지 않으며 리소스 수집이 시작되지 않습니다.

var dateStamp = UO.Date();
var sessionLabel = "harvest-" + Convert.ToString(dateStamp);
UO.Print(sessionLabel);

2. 현지 날짜가 변경되면 시리즈 종료 - 스크립트 기능

매개변수와 실행 흐름:

• originalDate는 원래 날짜를 저장합니다. Timer는 관찰을 60초로 제한하고, UO.Wait(1000)는 대략 초당 한 번씩 확인합니다. 날짜 변경으로 메인이 종료됩니다. 이 예에서는 자정까지 무기한 기다리지 않으며 서버에서 날짜가 변경되었다고 주장하지 않습니다.

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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.Date.

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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 'northgate' 42". 문자열 내부의 2+3와 같은 표현식 C#은 자동으로 평가되지 않습니다.

반환값

void: 결과가 없습니다. 제어권을 반환한다고 해서 게임 시작이 종료되거나 서버에서 게임 작업이 확인되는 것은 아닙니다.

동작

UO.FunRunning(name) == 0은 취소 요청 직후에도 나타날 수 있습니다. 이전 callback의 finally 블록이 끝났다는 뜻은 아닙니다. 이전 작업자가 실제로 종료할 때까지 같은 로컬 이름에 대한 다른 CallSub 또는 Exec는 건너뜁니다.

• 로컬 레지스트리 RegisterRoutine가 먼저 확인됩니다. "Name args", "exec Name args" 및 "_exec Name args"가 지원됩니다. 대리자는 string[]를 받습니다. 인수 42는 문자열 "42"로 유지되고 '00123'은 선행 0을 유지합니다. 작은따옴표나 큰따옴표는 인수를 공백으로 연결합니다. ''는 빈 문자열을 지정합니다. 닫히지 않은 견적으로 인해 오류가 발생합니다. 이 경로에서는 백슬래시가 그대로 유지됩니다. 미리 작성된 명령 텍스트 내에서는 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# 파일

로컬 대리자 외에도 현재 관리자는 Child.csx::Main과 같은 키를 사용하여 명시적으로 로드된 C# 항목을 지원합니다. SubExists 및 FunRunning는 이러한 키를 허용합니다. CallSub는 Args 없이 파일을 실행하고 Exec("exec Child.csx::Main 'northgate' 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 주위의 따옴표는 선행 0을 유지합니다. 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 간격으로 3개의 가중치 측정을 시작하고 완료될 때까지 기다리지 않습니다. 로컬 어시스턴트가 실행되는 동안 기본 스크립트는 활성 상태로 유지됩니다. 보조자는 별도의 관리자 색인을 가지고 있지 않습니다. 작업이 이미 일시 중지된 경우 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에게 실행을 요청합니다. 따옴표는 text 명령에 속합니다. 경로 백슬래시는 유지됩니다. 시작 오류의 경우 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.

호출 시:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionRuntime.Exec.
• InjectionScript.Runtime.InjectionRuntime.Tokenize: Tokenize(parameters).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exec: bridge.Exec(parts[1].Text).
• InjectionScript.Runtime.InjectionRuntime.TryHandleLegacyConsoleCommand: TryHandleLegacyConsoleCommand(command, rawArguments).
• InjectionScript.Runtime.InjectionRuntime.NormalizeConsoleAlias: NormalizeConsoleAlias(command).
• InjectionScript.Runtime.InjectionRuntime.IsRemainderTextCommand: IsRemainderTextCommand(command).
• InjectionScript.Runtime.InjectionRuntime.ToConsoleValue: ToConsoleValue(token.Text).
• InjectionScript.Runtime.InjectionRuntime.CallNativeSubrutine: CallNativeSubrutine(command, args).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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# 파일

로컬 대리자 외에도 현재 관리자는 Child.csx::Main과 같은 키를 사용하여 명시적으로 로드된 C# 항목을 지원합니다. SubExists 및 FunRunning는 이러한 키를 허용합니다. CallSub는 Args 없이 파일을 실행하고 Exec("exec Child.csx::Main 'northgate' 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.

호출 시:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.FunRunning.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FunRunning: bridge.FunRunning(subrutineName).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetPauseScriptOnDisconnectStatus: bridge.GetPauseScriptOnDisconnectStatus().

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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에서 0부터 시작하는 인덱스. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 주제의 serial, 절차의 이름 또는 IDE에서 실행의 ID를 전달하지 마십시오.

반환값

string: 표시 이름 또는 색인이 없는 경우 ""입니다. 기존 실행의 이름은 명시적으로 빈 문자열로 설정될 수도 있습니다.

동작

• 실행 중 및 일시 중지된 실행이 고려됩니다. 완료 후 취소요청을 받은 경우는 제외됩니다. 실행 중인 스크립트는 일반적으로 자체를 고려합니다. 단순히 IDE 탭을 로드하는 것은 실행으로 간주되지 않습니다.
• 인덱스는 시작 순서의 현재 위치입니다. 시작/중지 스크립트는 위치를 이동할 수 있습니다. 서로 다른 호출은 공통 원자 스냅샷을 형성하지 않습니다. 다음 제어 명령 전에 목록을 다시 읽으십시오.
• GetScriptsList는 지수, GetScriptsCount 수량, GetScriptState 3가지 상태 코드를 제공합니다. 하나를 다른 것으로 대체하거나 0이 아닌 결과를 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에서 0부터 시작하는 인덱스입니다. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 항목의 serial, 절차 이름 또는 IDE에서 실행의 ID를 전달하지 마세요.

var index = 0;
var name = UO.GetScriptName(index);
UO.Print(name);

2. 루프 또는 조건에서 사용 - 스크립트 기능

매개변수와 실행 흐름:

• 이는 명령 공유의 구체적인 예입니다. 배열 인덱싱은 0부터 시작됩니다. 취급하기 전에 길이를 확인하십시오. UO.Wait(250)가 사용되는 경우 250 밀리초를 기다립니다.
• ScriptIndex=0 - 첫 번째 현재 실행, 반드시 스크립트를 호출할 필요는 없습니다. SetScriptName는 파일 이름을 바꾸지 않고 표시 이름을 변경합니다.
• string: 표시 이름 또는 색인이 없는 경우 ""입니다. 기존 실행의 이름은 명시적으로 빈 문자열로 설정될 수도 있습니다.
• 필수 ScriptIndex는 정수이며, 새로운 GetScriptsList에서 0부터 시작하는 인덱스입니다. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 항목의 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는 상태를 확인하고 이름과 경로를 연결합니다. 통화 사이에 일시 중지가 가능합니다. "누락"은 GetScriptName의 결과가 아니라 함수의 값입니다.
• string: 표시 이름 또는 색인이 없는 경우 ""입니다. 기존 실행의 이름은 명시적으로 빈 문자열로 설정될 수도 있습니다.
• 필수 ScriptIndex는 정수이며, 새로운 GetScriptsList에서 0부터 시작하는 인덱스입니다. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 항목의 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetScriptName: bridge.GetScriptName(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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에서 0부터 시작하는 인덱스. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 주제의 serial, 절차의 이름 또는 IDE에서 실행의 ID를 전달하지 마십시오.

반환값

string: 원본 파일의 저장된 경로 또는 색인이 없는 경우 ""입니다. 파일을 실행할 때 이는 일반적으로 전체 경로입니다. 명령이나 소스가 메모리에 일반 파일을 갖고 있지 않을 수 있습니다.

동작

• 실행 중 및 일시 중지된 실행이 고려됩니다. 완료 후 취소요청을 받은 경우는 제외됩니다. 실행 중인 스크립트는 일반적으로 자체를 고려합니다. 단순히 IDE 탭을 로드하는 것은 실행으로 간주되지 않습니다.
• 인덱스는 시작 순서의 현재 위치입니다. 시작/중지 스크립트는 위치를 이동할 수 있습니다. 서로 다른 호출은 공통 원자 스냅샷을 형성하지 않습니다. 다음 제어 명령 전에 목록을 다시 읽으십시오.
• GetScriptsList는 지수, GetScriptsCount 수량, GetScriptState 3가지 상태 코드를 제공합니다. 하나를 다른 것으로 대체하거나 0이 아닌 결과를 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에서 0부터 시작하는 인덱스입니다. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 항목의 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. 루프 또는 조건에서 사용 - 스크립트 기능

매개변수와 실행 흐름:

• 이는 명령 공유의 구체적인 예입니다. 배열 인덱싱은 0부터 시작됩니다. 취급하기 전에 길이를 확인하십시오. UO.Wait(250)가 사용되는 경우 250 밀리초를 기다립니다.
• ScriptIndex=0는 첫 번째 현재 실행을 선택합니다. 결과는 소스를 나타냅니다. 명령은 이 파일을 열거나 저장하거나 실행하지 않습니다.
• string: 원본 파일의 저장된 경로 또는 색인이 없는 경우 ""입니다. 파일을 실행할 때 이는 일반적으로 전체 경로입니다. 명령이나 소스가 메모리에 일반 파일을 갖고 있지 않을 수 있습니다.
• 필수 ScriptIndex는 정수이며, 새로운 GetScriptsList에서 0부터 시작하는 인덱스입니다. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 항목의 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는 경로가 비어 있는 경우에만 fallback 매개변수를 대체합니다. 이는 새로운 GetScriptPath 오버로드가 아닌 별도의 기능입니다.
• string: 원본 파일의 저장된 경로 또는 색인이 없는 경우 ""입니다. 파일을 실행할 때 이는 일반적으로 전체 경로입니다. 명령이나 소스가 메모리에 일반 파일을 갖고 있지 않을 수 있습니다.
• 필수 ScriptIndex는 정수이며, 새로운 GetScriptsList에서 0부터 시작하는 인덱스입니다. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 항목의 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetScriptPath: bridge.GetScriptPath(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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에서 0부터 시작하는 인덱스. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 주제의 serial, 절차의 이름 또는 IDE에서 실행의 ID를 전달하지 마십시오.

반환값

int - 상태 코드: 0 = 알 수 없음/알 수 없음, 1 = 실행 중, 2 = 일시 중지. 이는 bool이 아닙니다. 1 또는 2와 명시적으로 비교하세요.

동작

• 실행 중 및 일시 중지된 실행이 고려됩니다. 완료 후 취소요청을 받은 경우는 제외됩니다. 실행 중인 스크립트는 일반적으로 자체를 고려합니다. 단순히 IDE 탭을 로드하는 것은 실행으로 간주되지 않습니다.
• 인덱스는 시작 순서의 현재 위치입니다. 시작/중지 스크립트는 위치를 이동할 수 있습니다. 서로 다른 호출은 공통 원자 스냅샷을 형성하지 않습니다. 다음 제어 명령 전에 목록을 다시 읽으십시오.
• GetScriptsList는 지수, GetScriptsCount 수량, GetScriptState 3가지 상태 코드를 제공합니다. 하나를 다른 것으로 대체하거나 0이 아닌 결과를 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에서 0부터 시작하는 인덱스입니다. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 항목의 serial, 절차 이름 또는 IDE에서 실행의 ID를 전달하지 마세요.

int state = UO.GetScriptState(0);
string text = state switch
{
    1 => "running",
    2 => "paused",
    _ => "unknown"
};
UO.Print(text);

2. 루프 또는 조건에서 사용 - 스크립트 기능

매개변수와 실행 흐름:

• 이는 명령 공유의 구체적인 예입니다. 배열 인덱싱은 0부터 시작됩니다. 취급하기 전에 길이를 확인하십시오. UO.Wait(250)가 사용되는 경우 250 밀리초를 기다립니다.
• 수동/디버그 일시 중지 및 구성된 종료 일시 중지가 고려됩니다. 1 상태는 스크립트가 현재 CPU를 사용하고 있거나 서버 데이터를 수신하고 있음을 보장하지 않습니다.
• int - 상태 코드: 0 = 알 수 없음/알 수 없음, 1 = 실행 중, 2 = 일시 중지. 이는 bool이 아닙니다. 1 또는 2와 명시적으로 비교하세요.
• 필수 ScriptIndex는 정수이며, 새로운 GetScriptsList에서 0부터 시작하는 인덱스입니다. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 항목의 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에서 0부터 시작하는 인덱스입니다. 음수 또는 누락된 인덱스의 경우 설명된 빈/알 수 없는 결과가 반환됩니다. 항목의 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetScriptState: bridge.GetScriptState(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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 3가지 상태 코드를 제공합니다. 하나를 다른 것으로 대체하거나 0이 아닌 결과를 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. 루프 또는 조건에서 사용 - 스크립트 기능

매개변수와 실행 흐름:

• 이는 명령 공유의 구체적인 예입니다. 배열 인덱싱은 0부터 시작됩니다. 취급하기 전에 길이를 확인하십시오. 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetScriptsCount: bridge.GetScriptsCount().

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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 3가지 상태 코드를 제공합니다. 하나를 다른 것으로 대체하거나 0이 아닌 결과를 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. 루프 또는 조건에서 사용 - 스크립트 기능

매개변수와 실행 흐름:

• 이는 명령 공유의 구체적인 예입니다. 배열 인덱싱은 0부터 시작됩니다. 취급하기 전에 길이를 확인하십시오. 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetScriptsList: bridge.GetScriptsList().

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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 — 프로세스의 선택적 작업 폴더입니다. 누락된 부분이나 빈 줄이 있는 경우 현재 스크립트의 폴더를 가져옵니다. 런타임에 해당 폴더가 없으면 브리지는 클라이언트의 현재 작업 폴더를 사용합니다. 항상 게임 폴더나 EXE 클라이언트 폴더는 아닙니다.
• hidden — 선택적 부울 값, 기본값은 false입니다. true는 OS 셸을 통한 열기를 비활성화하고 콘솔 창 없이 실행을 요청합니다. 실행 파일이 필요합니다. false는 문서 연결을 허용합니다. GUI 프로그램 자체는 여전히 창을 표시할 수 있습니다.

반환값

int: 1 (true) Process.Start가 프로세스 객체를 반환한 경우; 그렇지 않으면 0 (false). C#에서 결과 확인 == 1 또는 결과 != 0; int는 true와 직접 비교할 수 없습니다. 이는 PID, 종료 코드, 작업 완료 확인이 아닙니다. 예외가 발생하면 오류가 출력되고 0가 반환됩니다. 이미 실행 중인 프로그램을 통해 문서를 열 때 OS가 때때로 새 프로세스를 반환하지 않는 경우가 있습니다. 0 이 경우 문서가 열리지 않았음을 증명하지 않습니다.

동작

• 지정된 순서대로 1~4개 인수의 오버로드만 허용됩니다. 숨김을 지정하고 기본 작업 폴더를 그대로 두려면 빈 문자열을 세 번째 인수로 전달합니다. 파일/매개변수/workingDirectory를 텍스트로 변환할 때 파일의 존재 여부를 미리 확인하지 않습니다.
• 기본 폴더는 현재 실행 중인 스크립트에 따라 결정됩니다. Hidden=true을 사용하면 상대 프로그램 경로가 먼저 workingDirectory에 대해 확인됩니다. 부분적인 OS 이름 조회 및 연결은 시스템마다 다릅니다. 전체 경로는 모호성을 제거합니다. 작업 폴더나 프로그램을 사용할 수 없는 경우 시작이 실패할 수 있습니다.
• 외부 프로세스는 독립적으로 실행됩니다. 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를 스크립트 옆에 배치하세요. OS는 .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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.Register [Launch].
• InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

호출 시 저장된 처리기 delegate를 실행합니다. 등록 메서드는 API를 구성할 때 이 delegate를 만듭니다.

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

values => new InjectionValue(CompactLaunch(values))

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

매개변수: file (Any), parameters (Any)

결과: int / Integer.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.Register [Launch].
• InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

호출 시 저장된 처리기 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.Register [Launch].
• InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

호출 시 저장된 처리기 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.Register [Launch].
• InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

호출 시 저장된 처리기 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. 실행 중인 시작 일시 중지 - 스크립트 기능

매개변수와 실행 흐름:

• 확인 == 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.PauseResumeScript: bridge.PauseResumeScript(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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 — 이름과 동일한 이벤트 이름; 이는 선택적 값이 아닌 4개 인수 형식의 첫 번째 매개변수 이름입니다.
• stateValue - true/1 감시 기능을 켜고, false/0 구독을 취소합니다. 따옴표 없이 부울 값을 전달합니다. 숫자 변환에서는 0이 아닌 모든 정수에 관측치가 포함됩니다. 비활성화해도 이미 실행 중인 핸들러를 기다리거나 중지하지 않습니다.
• repeatOrHandler — 세 번째 인수에는 두 가지 목적이 있습니다. "OnManaChanged"와 같이 숫자가 아닌 비어 있지 않은 문자열은 자동 반복 핸들러를 지정합니다. Number/bool는 반복만 설정합니다: false/0 — 한 번의 작업, true/1 — 반복; 이 양식에는 핸들러가 할당되지 않습니다. 문자열 "1"도 숫자이며 프로시저 이름이 아닙니다. 일회성 핸들러의 경우 4개의 인수를 사용하십시오.
• repeatValue - 4개의 인수가 있는 형식: 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# 파일

로컬 대리자 외에도 현재 관리자는 Child.csx::Main과 같은 키를 사용하여 명시적으로 로드된 C# 항목을 지원합니다. SubExists 및 FunRunning는 이러한 키를 허용합니다. CallSub는 Args 없이 파일을 실행하고 Exec("exec Child.csx::Main 'northgate' 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. 사망 후 불완전한 대상을 한 번 취소 - 직접 스크립트

매개변수와 실행 흐름:

• 관찰은 8초 동안 지속됩니다. 이미 죽은 캐릭터의 죽음은 핸들러를 즉시 호출하지 않습니다. 이 예에서는 부활 후 두 번째 사망 이벤트가 더 이상 처리되지 않습니다.
• 핸들러는 실행 시 대상의 활성 커서를 확인한 다음 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 ms – 6초. 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. 구독을 누적하지 않고 Mana 핸들러 전환 - 스크립트 클래스

매개변수와 실행 흐름:

• 처음 2초 동안 감지된 각 변경 사항은 OnManaLog를 트리거합니다. 다음 3초 동안은 OnLowMana이 사용됩니다. 두 번째 핸들러를 등록한다고 해서 그 자체가 트리거되는 것은 아닙니다.
• 교체는 이미 실행 중인 이전 프로시저를 중단하지 않습니다. 이러한 짧은 처리기는 기본 지역 변수를 사용하지 않습니다. 절차의 부과를 금지하는 경우 관리자는 실행을 거부할 수 있습니다. 이 모드의 경우 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.

호출 시:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.SetEvent.
• InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(name, stateValue, InjectionValue.True, new InjectionValue(string.Empty)).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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.

호출 시:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.SetEvent.
• InjectionScript.Runtime.InjectionValue.ToString: repeatOrHandler.ToString().
• InjectionScript.Runtime.NumberConversions.TryStr2Int: NumberConversions.TryStr2Int(raw, out _).
• InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(name, stateValue, InjectionValue.True, repeatOrHandler).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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.

호출 시:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.SetEvent.
• InjectionScript.Runtime.InjectionApiUO.NormalizeLegacyEventName: NormalizeLegacyEventName(nameValue.ToString()).
• InjectionScript.Runtime.InjectionValue.ToString: nameValue.ToString().
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(stateValue).
• InjectionScript.Runtime.InjectionApiUO.IsSupportedLegacyEventName: IsSupportedLegacyEventName(name).
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"SetEvent: unsupported event '{name}'. Supported: SeeNewPlayer, Death, ChangeHitPoints, ChangeMana, ChangeStamina.").
• InjectionScript.Runtime.InjectionApiUO.NormalizeLegacyEventHandler: NormalizeLegacyEventHandler(subNameValue.ToString()).
• InjectionScript.Runtime.InjectionApiUO.CaptureLegacyEventSnapshot: CaptureLegacyEventSnapshot(subscription).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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# 파일

로컬 대리자 외에도 현재 관리자는 Child.csx::Main과 같은 키를 사용하여 명시적으로 로드된 C# 항목을 지원합니다. SubExists 및 FunRunning는 이러한 키를 허용합니다. CallSub는 Args 없이 파일을 실행하고 Exec("exec Child.csx::Main 'northgate' 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는 이벤트를 처리합니다. 두 번째 인수가 비어 있으면 반복이 비활성화됩니다.
• 핸들러는 경고만 하고 자동으로 치료를 선택하지 않습니다. HP 60 → 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는 NPC을 포함하여 로드된 모바일 세트에서 serial의 발생을 감지합니다. 한 번에 다섯 마리의 생물을 로드한다고 해서 다섯 마리의 소환이 보장되는 것은 아닙니다.
• 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.

호출 시:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(1).
• InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(arguments[0], InjectionValue.False).
• InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(arguments[0], InjectionValue.True, InjectionValue.True, arguments[1]).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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가 꺼집니다. 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetPauseScriptOnDisconnectStatus: bridge.SetPauseScriptOnDisconnectStatus(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetScriptName: bridge.SetScriptName(Arg(0), Text(1)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(1).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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 3가지 상태 코드를 제공합니다. 하나를 다른 것으로 대체하거나 0이 아닌 결과를 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. 루프 또는 조건에서 사용 - 스크립트 기능

매개변수와 실행 흐름:

• 이는 명령 공유의 구체적인 예입니다. 배열 인덱싱은 0부터 시작됩니다. 취급하기 전에 길이를 확인하십시오. 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.StartScript: bridge.StartScript(Text(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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. 5초 후 일반 중지 - 스크립트 클래스

매개변수와 실행 흐름:

• 5000는 StopAllScripts 매개변수가 아니라 UO.Wait의 밀리초입니다. 수동 또는 자동 컨트롤러 일시 중지로 인해 실행이 지연될 수 있습니다. 이것은 독립된 타이머가 아닙니다.
• 인덱스는 동적입니다. 다른 실행이 완료된 후 위치가 이동할 수 있습니다. 다중 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.StopAllScripts: bridge.StopAllScripts().

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.StopScript: bridge.StopScript(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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# 파일

로컬 대리자 외에도 현재 관리자는 Child.csx::Main과 같은 키를 사용하여 명시적으로 로드된 C# 항목을 지원합니다. SubExists 및 FunRunning는 이러한 키를 허용합니다. CallSub는 Args 없이 파일을 실행하고 Exec("exec Child.csx::Main 'northgate' 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) 간격, 즉 1000ms 간격으로 3개의 무게/마나 측정값, 세계에 들어갈 때만 출력됩니다. 이는 지속적인 모니터링이 아닙니다. 잠시 멈추면 시간이 길어질 수 있습니다. 두 개의 작업이 있는 예에서는 프로시저의 동시 실행이 허용되어야 합니다.

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) 간격, 즉 1000ms 간격으로 3개의 무게/마나 측정값, 세계에 들어갈 때만 출력됩니다. 이는 지속적인 모니터링이 아닙니다. 잠시 멈추면 시간이 길어질 수 있습니다. 두 개의 작업이 있는 예에서는 프로시저의 동시 실행이 허용되어야 합니다.

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) 간격, 즉 1000ms 간격으로 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 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.

호출 시:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.SubExists.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SubExists: bridge.SubExists(subrutineName).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.Terminate.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Terminate: bridge.Terminate(string.Empty).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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

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

매개변수: subrutineName (String)

결과: void / Unit.

호출 시:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.Terminate.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Terminate: bridge.Terminate(subrutineName).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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()은 다음 반복 전에 캐릭터의 죽음을 확인합니다.
• 조건이 충족되면 현재 메인 실행과 나머지 실행 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. 모두 호환되는 형태 - 스크립트 기능

매개변수와 실행 흐름:

• 이 대체 표기법은 하나의 매개변수 subrutineName="all"과 함께 UO.Terminate를 사용합니다. 이는 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.TerminateAll.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Terminate: bridge.Terminate("all").

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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. 0은 오류나 논리 플래그 false가 아닌 유효한 시간입니다.

동작

• 매개변수도 없고 인수가 포함된 형식도 없습니다. 빈 괄호는 시간만 읽습니다. 호출은 기다리지 않고 타이머를 시작하거나 게임에 패킷을 보내지 않습니다.
• RealTimeSource.이제 DateTime로 표시됩니다.이제: UTC가 아닌 컴퓨터의 현지 날짜/시간, 샤드 시간 및 게임 시계가 아닙니다. 시간대, 일광 절약 시간 및 수동 시계 변경이 결과에 영향을 미칩니다. 각 통화는 다른 순간을 포착합니다.
• 선행 0은 보존되지 않으며 밀리초도 보존되지 않습니다. 수치적으로 13:00:00 빼기 12:59:59 는 1초가 지났음에도 불구하고 4041를 제공합니다. 자정에 값은 다시 0이 됩니다.
• 지연을 계산하기 위해 달력 코드를 빼지 마십시오. 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 – 초. 단순 문자열은 필드를 0으로 채우지 않습니다.

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(스탬프,첫 번째,마지막)은 유효한 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.Time.

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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();

현재 런타임의 실행 시간을 10분의 1초 단위로 읽습니다. 자신의 지연 및 동작 표시에 적합합니다.

매개변수

매개변수가 없습니다.

반환값

int 0..2147483647; 단위는 100 ms입니다. 399ms 3에서 반환됩니다. 이것은 true/false나 남은 충전량이 아닌 시계 판독값입니다.

동작

• 매개변수도 없고 인수가 포함된 형식도 없습니다. 빈 괄호는 시간만 읽습니다. 호출은 기다리지 않고 타이머를 시작하거나 게임에 패킷을 보내지 않습니다.
• 원본은 이 런타임 인스턴스에 속합니다. 새로운 실행 프로시저는 새로운 시계를 받을 수 있습니다. 서로 다른 실행의 값을 비교하거나 절대 날짜로 저장할 수 없습니다. UO.Wait 및 스크립트 일시중지 중에 실시간이 계속 표시됩니다.
• 10분의 1의 소수 부분은 삭제됩니다. 약 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 ms; 실제 지연 시간은 더 길어질 수 있습니다. 두 표시의 차이를 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. 이미 요청된 십자선 대기 시간을 3초로 제한 - 스크립트 기능

매개변수와 실행 흐름:

• 한계 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(시작됨,현재,간격)은 Main 아래에 완전히 정의되어 있습니다. 간격=5 — 이 시계 단위의 0.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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.Timer.

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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 = 1초. 0..2147483647를 사용하세요. 이는 단계 수가 아니고 초도 아니며 서버 확인 시간 초과도 아닙니다.

반환값

void - 결과가 없습니다. 별도의 회선으로 전화하세요. 지연이 끝났다고 해서 물체가 이동했거나, 주문이 완료되었거나, 연결이 설정되었음을 의미하는 것은 아닙니다. 원하는 상태를 별도로 확인하세요.

동작

• 0은 실제 지연을 생성하지 않으며 빠른 루프의 일시 중지로 적합하지 않습니다. 음수 시간은 무한대를 의미하지 않습니다. 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 - 1/4초. 대기 후 다음 줄이 실행됩니다. 지연 완료 메시지는 반환된 결과가 아니라 예시의 텍스트입니다.

UO.Wait(250);
UO.Print("Delay complete");

2. UO.Wait — 2 — 스크립트 기능

매개변수와 실행 흐름:

• WaitForOnline는 이 스크립트에서 완전히 선언되었습니다. 20 인수는 250ms의 최대 20번의 일시 중지를 의미합니다. 연결은 일시 중지되기 전에 확인되고 마지막 연결 후에 다시 확인됩니다. 도우미는 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 - 시나리오 수업

매개변수와 실행 흐름:

• 루프는 정확히 3개의 중량 판독값을 만듭니다. 판독값 사이에는 500 ms의 두 번의 일시 중지가 있으며, 마지막 이후에는 일시 중지가 없습니다. 메시지를 처음 읽을 때와 무게가 변경될 때 메시지가 인쇄됩니다. 이전 변수는 게임 가중치를 조정하는 것이 아니라 비교할 값을 저장합니다.

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.

호출 시:

• ClassicUO.CSharp.CSharpScriptGlobals.WaitAsync.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.WaitWithEvents: WaitWithEvents(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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 result = command(...) 후에 (결과 != 0) 또는 (결과 == 0)인지 확인하세요. 한 번의 호출 결과를 저장합니다. 반복된 호출을 통해 해당 작업을 다시 수행하거나 이미 변경된 상태를 읽을 수 있습니다.

동작

• 전체 클라이언트의 대기열을 읽습니다. 여러 프로시저가 동시에 실행되는 경우 각 프로시저의 응답이 고려됩니다.
• 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=50ms, 최대 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.

호출 시:

• InjectionScript.Runtime.InjectionApiUO.Waiting.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetWaitTargetQueue: bridge.GetWaitTargetQueue().

내부 구현 코드이며 독립 스크립트로 실행할 수 없습니다.

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