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

Gump 창

서버 창 읽기 및 응답 보내기: 버튼, 확인란, 라디오 버튼 및 필드. ID 창, serial 소유자와 열린 창 인덱스는 서로 바뀔 수 없습니다.

섹션

주제	명령 및 설명
GetGump	UO.GetGump
GetGumpInfo	UO.GetGumpInfo
Gump ID / Serial	UO.GetGumpID · UO.GetGumpSerial
Text Lines	UO.GetGumpTextLines · UO.GetGumpFullLines · UO.GetGumpShortLines
Buttons	UO.GetGumpButtonsDescription · UO.NumGumpButton
CheckBox	UO.NumGumpCheckBox · UO.GumpAutoCheckBox
RadioButton	UO.NumGumpRadiobutton · UO.GumpAutoRadiobutton
TextEntry	UO.NumGumpTextEntry · UO.GumpAutoTextEntry
WaitGump	UO.WaitGump
SelectGump	UO.SelectGump
SendGumpSelect	UO.SendGumpSelect
Ignore 검스	UO.AddGumpIgnoreByID · UO.AddGumpIgnoreBySerial · UO.ClearGumpsIgnore
Close Gump	UO.IsGumpCanBeClosed · UO.CloseClientGump · UO.CancelGump

모든 테마 명령

주제에 대한 예

각 명령 카드에는 직접 코드, 함수 및 클래스 등 여러 가지 독립적인 시나리오가 있습니다. 다음은 선택된 짧은 시나리오입니다. 제한사항과 전체 분석이 카드에 포함되어 있습니다.

UO.GetGumpInfo

매개변수, 결과 및 모든 시나리오

var info = UO.GetGumpInfo(0);
if (Truth(ArrayLength(info) == 5))
{
    UO.Print("Serial=" + Hex(info[0]));
    UO.Print("GumpID=" + Hex(info[1]));
}

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

UO.WaitGump

매개변수, 결과 및 모든 시나리오

UO.WaitGump(100);
UO.UseObject("0x40001234");

전체 명령 참조

UO.AddGumpIgnoreByID

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

C# 시그니처

void UO.AddGumpIgnoreByID(object? id);

UO.GetGumpInfo에서 사용하는 로컬 예외 목록에 숫자 ID gump를 추가합니다.

매개변수

id는 UO.GetGumpInfo을 반환하는 숫자 ID 검프입니다.

반환값

void. ID을 추가해도 창이 닫히거나 서버가 처리했는지 확인하지 않습니다.

동작

독립 실행 C# 스크립트

각 예제는 별도의 파일 .csx로 저장하고 IDE에서 실행할 수 있습니다. UO 개체와 대기 기능은 현재 게임 세션의 호스트를 제공합니다. 데모 serial 이름, 좌표, 주소를 자신의 것으로 바꾸세요.

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.AddGumpIgnoreByID");
UO.AddGumpIgnoreByID(123);

1. UO.GetGumpInfo 결과에서 ID 123로 검프를 제거합니다. - 직접 스크립트

매개변수와 실행 흐름:

UO.GetGumpInfo 결과에서 ID 123로 검프를 제거합니다.

UO.AddGumpIgnoreByID(123);

2. 예외를 발생시키기 전에 ID를 변수에 저장하세요. - 스크립트 기능

매개변수와 실행 흐름:

예외를 발생시키기 전에 ID를 변수에 저장하세요.

return  RunScenario();
 object? RunScenario()
{
    var ignoredId = 123;
    UO.AddGumpIgnoreByID(ignoredId);
    return null;
}

3. ID를 추가하세요. 각 예외는 GetGumpInfo에 영향을 미칩니다. - 스크립트 클래스

매개변수와 실행 흐름:

ID를 추가하세요. 각 예외는 GetGumpInfo에 영향을 미칩니다.

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.AddGumpIgnoreByID(123);
        UO.AddGumpIgnoreByID(456);
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.AddGumpIgnoreByID(id)` — `UO.AddGumpIgnoreByID(Any)`

매개변수: id (Any)

결과: void / Unit.

호출 시:

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

case "addgumpignorebyid": state.IgnoredGumpIds.Add(Arg(0)); return InjectionValue.Unit;

UO.AddGumpIgnoreBySerial

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

C# 시그니처

void UO.AddGumpIgnoreBySerial(object? serial);

UO.GetGumpInfo에서 사용하는 로컬 예외 목록에 serial gump를 추가합니다.

매개변수

serial는 UO.GetGumpInfo을 반환하는 숫자 serial 검프입니다.

반환값

void. serial을 추가해도 창이 닫히거나 서버가 처리했는지 확인하지 않습니다.

동작

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.AddGumpIgnoreBySerial");
UO.AddGumpIgnoreBySerial(1073741824);

1. 결과 UO.GetGumpInfo에서 serial 1073741824로 검프를 제거합니다. - 직접 스크립트

매개변수와 실행 흐름:

결과 UO.GetGumpInfo에서 serial 1073741824로 검프를 제거합니다.

UO.AddGumpIgnoreBySerial(1073741824);

2. 변수에서 serial를 전달합니다. - 스크립트 기능

매개변수와 실행 흐름:

변수에서 serial를 전달합니다.

return  RunScenario();
 object? RunScenario()
{
    var ignoredSerial = 1073741824;
    UO.AddGumpIgnoreBySerial(ignoredSerial);
    return null;
}

3. GetGumpInfo 출력에서 두 개의 serial 덩어리를 제거합니다. - 스크립트 클래스

매개변수와 실행 흐름:

GetGumpInfo 출력에서 두 개의 serial 덩어리를 제거합니다.

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.AddGumpIgnoreBySerial(1073741824);
        UO.AddGumpIgnoreBySerial(1073741825);
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.AddGumpIgnoreBySerial(serial)` — `UO.AddGumpIgnoreBySerial(Any)`

매개변수: serial (Any)

결과: void / Unit.

호출 시:

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

case "addgumpignorebyserial": state.IgnoredGumpSerials.Add(Arg(0)); return InjectionValue.Unit;

UO.CancelGump

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

C# 시그니처

void UO.CancelGump();
void UO.CancelGump(object? gumpId);

호환 가능한 리졸버 CloseSimpleGump를 통해 선택한 서버 Gump를 닫습니다.

매개변수

gumpId - 선택사항 int/숫자 값. 리졸버는 먼저 일치하는 서버/로컬 serial를 찾은 다음 서버 검프 인덱스를 찾습니다. 인수가 없으면 -1가 전달되고 마지막 검프가 선택됩니다.

반환값

void - 반환 값이 없습니다.

동작

gumpId라는 인수는 ID만 검색한다고 보장하지 않습니다. CloseGumpUnsafe 서버 검프의 경우 0 버튼을 보낸 다음 로컬 창을 삭제합니다. Gump가 발견되지 않으면 아무런 조치도 취하지 않습니다. 이는 CancelMenu도 아니고 보류 중인 WaitGump를 지우는 것도 아닙니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

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

1. 마지막 검프 닫기 - 직접 스크립트

매개변수와 실행 흐름:

인수가 없는 양식은 사용 가능한 최신 서버 검프를 선택합니다.

UO.CancelGump();

2. 알려진 ID로 검프를 닫습니다 - 스크립트 기능

매개변수와 실행 흐름:

첫 번째 검프의 실제 ID가 사용됩니다. 목록은 통화 간에 변경될 수 있습니다.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetGumpID(0);
    if (Truth(id != 0))
    {
        UO.CancelGump(id);
    }

    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. 명시적 마지막 인덱스 - 스크립트 클래스

매개변수와 실행 흐름:

-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()
    {
        UO.CancelGump(-1);
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.CancelGump()` — `UO.CancelGump()`

매개변수: 매개변수가 없습니다.

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CloseSimpleGump: bridge.CloseSimpleGump(arguments.Length > 0 ? Arg(0) : -1).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0).

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

case "cancelgump": bridge.CloseSimpleGump(arguments.Length > 0 ? Arg(0) : -1); break;

`UO.CancelGump(gumpId)` — `UO.CancelGump(Any)`

매개변수: gumpId (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CloseSimpleGump: bridge.CloseSimpleGump(arguments.Length > 0 ? Arg(0) : -1).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0).

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

case "cancelgump": bridge.CloseSimpleGump(arguments.Length > 0 ? Arg(0) : -1); break;

UO.ClearGumpsIgnore

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

C# 시그니처

void UO.ClearGumpsIgnore();

무시된 gump ID 및 gump serial 런타임 세트를 모두 지웁니다.

매개변수

매개변수가 없습니다.

반환값

void - 반환 값이 없습니다.

동작

창문을 닫지 않습니다. 일단 지워지면 GetGumpInfo는 이전에 무시했던 검프의 스냅샷을 다시 반환할 수 있습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

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

1. 상태 지우기 - 직접 스크립트

매개변수와 실행 흐름:

무시된 gump ID 및 gump serial 런타임 세트를 모두 지웁니다.

UO.ClearGumpsIgnore();

2. 설정 후 지우기 - 스크립트 기능

매개변수와 실행 흐름:

추가된 무시 규칙을 제거합니다.

return  RunScenario();
 object? RunScenario()
{
    UO.AddGumpIgnoreByID(0x1234);
    UO.ClearGumpsIgnore();
    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()
    {
        UO.ClearGumpsIgnore();
        UO.ClearGumpsIgnore();
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.ClearGumpsIgnore()` — `UO.ClearGumpsIgnore()`

매개변수: 매개변수가 없습니다.

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.

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

case "cleargumpsignore":

                    state.IgnoredGumpIds.Clear(); state.IgnoredGumpSerials.Clear(); return InjectionValue.Unit;

UO.CloseClientGump

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

C# 시그니처

void UO.CloseClientGump(object? id);

ServerSerial가 전달된 ID와 일치하는 로컬 서버 검프를 제거합니다.

매개변수

id - int/숫자 ID ServerSerial와 비교해 볼 때. 이것은 목록 색인도 아니고 로컬 serial도 아닙니다.

반환값

void - 반환 값이 없습니다.

동작

ServerGumpsUnsafe를 반복하고 모든 일치 항목의 스냅샷을 생성하고 Dispose를 호출합니다. 0 버튼이나 양식 결과를 서버로 보내지 않습니다. 일치하는 항목이 없으면 아무것도 변경되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.CloseClientGump");
UO.CloseClientGump(UO.GetGumpID(0));

1. ID로 첫 번째 검프를 닫습니다 - 직접 스크립트

매개변수와 실행 흐름:

GetGumpID는 서버 ID를 제공합니다. CloseClientGump는 일치하는 로컬 창을 제거합니다.

if (Truth(UO.GetGumpsCount() > 0))
{
    var id = UO.GetGumpID(0);
    UO.CloseClientGump(id);
}

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

2. 변수의 ID - 스크립트 기능

매개변수와 실행 흐름:

원하는 서버 검프의 ID를 지정하세요. 일치하는 항목이 허용되지 않습니다.

return  RunScenario();
 object? RunScenario()
{
    var id = 0x12345678;
    UO.CloseClientGump(id);
    return null;
}

3. Reclose - 스크립트 클래스

매개변수와 실행 흐름:

첫 번째 Dispose 후 두 번째 닫기는 일반적으로 더 이상 창을 찾지 않습니다.

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 id = UO.GetGumpID(0);
        if (Truth(id != 0))
        {
            UO.CloseClientGump(id);
            UO.CloseClientGump(id);
        }

        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.CloseClientGump(id)` — `UO.CloseClientGump(Any)`

매개변수: id (Any)

결과: void / Unit.

호출 시:

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

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

case "closeclientgump": bridge.CloseClientGump(Arg(0)); return InjectionValue.Unit;

UO.GetGump

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

C# 시그니처

dynamic UO.GetGump(object? identifier);
dynamic UO.GetGump(object? gumpId, object? identifier);
dynamic UO.GetGump(object? gumpId, object? identifier, object? key);

선택한 서버 Gump의 한 필드를 읽습니다. 창 선택기를 명시적으로 설정할 수 있습니다.

매개변수

gumpId - (gumpId,식별자) 및 (gumpId,식별자, 키) 형식의 첫 번째 int 선택 사항입니다. int 또는 숫자 문자열: 먼저 정확한 GumpID/serial 일치를 찾은 다음 0로 색인을 찾습니다. -1은 이 스크립트에서 선택한 Gump이고, 없으면 현재 목록의 마지막 Gump입니다. 다른 부정적인 int는 32비트 ID를 유지합니다. 이는 NumGump*의 엄격한 GumpIndex와 반대되는 선택기입니다.
identifier - string 대소문자를 구분하지 않습니다. 지원되는 모든 값과 결과 유형은 반품 섹션에 나열되어 있습니다. 알 수 없는 이름은 빈 문자열을 반환합니다.
key - 선택 사항 int, 기본값 - 1. 버튼/텍스트/object/명령의 경우 0로 색인을 생성하세요. 이것은 ID 제어가 아닙니다. 음수 인덱스와 범위를 벗어나면 버튼의 경우 0이 되고 텍스트 필드의 경우 빈 문자열이 표시됩니다. 다른 식별자는 키를 사용하지 않습니다.

반환값

결과 유형은 식별자에 따라 다릅니다. int: Buttonlen — 일반 버튼 수; 버튼 — 인덱스 키별 ButtonID입니다. textlen — 사용 가능한 텍스트 요소 수; injid — 현재 창 인덱스; 회신 — 0 (응답 내역은 저장되지 않습니다); inclient — 발견된 라이브 창의 경우 1, 없는 경우 0; objectcount - 중첩된 컨트롤을 포함한 라이브 컨트롤의 수입니다. string: serial 및 gumpid - 16진수 문자열 0xXXXXXXXX; text — 인덱스 키의 요소 텍스트입니다. object — 컨트롤 유형 이름; 명령 — 컨트롤에 대한 설명(유형, 페이지, ID, 좌표, 크기 및 지원되는 필드) 창이 없으면 숫자 식별자는 0를 제공하고 문자열 식별자는 빈 문자열을 제공합니다. injid=0도 유효한 첫 번째 색인입니다. 0 자체만으로는 창이 없음을 증명하지 않습니다. 이것은 Array나 Pascal TGumpInfo가 아닙니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
SelectGump/InfoGump는 현재 런타임에서만 선택한 창을 지정합니다. 선택한 창이 닫히면 현재 목록의 마지막 항목이 사용됩니다. 이는 반드시 가장 최근 항목일 필요는 없습니다.
textlen/text는 서버 패키지의 원래 문자열 풀이 아닌 사용 가능한 텍스트 컨트롤을 참조합니다. object/command는 라이브 컨트롤의 전체 트리를 나타냅니다. 다른 목록의 인덱스는 혼합될 수 없습니다.
각 호출은 현재 상태를 개별적으로 읽습니다. 일치하는 serial, GumpID 및 목록의 경우 GetGumpInfo를 사용하세요.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 선택한 창의 ID 읽기 - 직접 스크립트

매개변수와 실행 흐름:

gumpid 및 serial는 이미 16진수로 형식화된 문자열을 반환합니다. 추가 16진수가 필요하지 않습니다. 빈 줄은 읽을 때 창이 없음을 의미합니다.

var id = UO.GetGump("gumpid");
var serial = UO.GetGump("serial");
UO.Print(id + " / " + serial);

2. ButtonID 열거 - 스크립트 함수

매개변수와 실행 흐름:

Buttonlen — 버튼 수; i는 0부터 count-1까지의 행 인덱스입니다. 버튼 - 그래픽이나 색인이 아닌 답변용 ID입니다. 창을 변경할 때 목록을 다시 읽으십시오.

return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGump("buttonlen");
    var i = 0;
    while (Truth(i < count))
    {
        var button = UO.GetGump("button", i);
        UO.Print(Convert.ToString(button));
        i = i + 1;
    }

    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. 선택 후 텍스트 읽기 - 스크립트 클래스

매개변수와 실행 흐름:

0x12345678는 GumpID/serial의 예입니다. ID를 원하는 형식으로 바꾸세요. key=0인 텍스트는 사용 가능한 첫 번째 텍스트 컨트롤을 읽습니다. 이것은 버튼과 다른 목록입니다.
SelectGump는 지정된 창이 없다고 보고하지만 후속 읽기를 차단하지 않습니다. 필요한 경우 반환된 gumpid를 별도로 확인하세요.

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.SelectGump(0x12345678);
        if (Truth(UO.GetGump("inclient")))
        {
            var count = UO.GetGump("textlen");
            if (Truth(count > 0))
            {
                UO.Print(UO.GetGump("text", 0));
            }
        }

        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.GetGump(identifier)` — `UO.GetGump(String)`

매개변수: identifier (String)

결과: dynamic / Any.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetGump.
InjectionScript.Runtime.InjectionApiUO.LastGump: LastGump(identifier, -1).

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

public InjectionValue GetGump(string identifier) => LastGump(identifier, -1);

`UO.GetGump(gumpId, identifier)` — `UO.GetGump(Integer,String)`

매개변수: gumpId (Integer/String), identifier (String/Integer)

결과: dynamic / Any.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetGump.
InjectionScript.Runtime.InjectionApiUO.GetGump: GetGump(gumpId, identifier, -1).

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

public InjectionValue GetGump(int gumpId, string identifier) => GetGump(gumpId, identifier, -1);

`UO.GetGump(gumpId, identifier)` — `UO.GetGump(String,Integer)`

매개변수: gumpId (Integer/String), identifier (String/Integer)

결과: dynamic / Any.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetGump.
InjectionScript.Runtime.InjectionApiUO.LastGump: LastGump(identifier, key).

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

public InjectionValue GetGump(string identifier, int key) => LastGump(identifier, key);

`UO.GetGump(gumpId, identifier, key)` — `UO.GetGump(Integer,String,Integer)`

매개변수: gumpId (Integer), identifier (String), key (Integer)

결과: dynamic / Any.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetGump.
InjectionScript.Runtime.InjectionApiUO.ConvertGumpValue: ConvertGumpValue(identifier, bridge.GetGumpValue(gumpId, identifier, key)).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpValue: bridge.GetGumpValue(gumpId, identifier, key).

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

public InjectionValue GetGump(int gumpId, string identifier, int key)

            => ConvertGumpValue(identifier, bridge.GetGumpValue(gumpId, identifier, key));

UO.GetGumpButtonsDescription

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

C# 시그니처

dynamic UO.GetGumpButtonsDescription(object? gumpIndex);

일반 서버 검프 버튼에 대한 설명을 반환합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.

반환값

Array - 일반 버튼에 대한 설명입니다. [] - 인덱스가 잘못되었거나 일치하는 요소가 없습니다. 행 인덱스는 0로 시작합니다. ID 컨트롤이 아닙니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
각 줄에는 ButtonID, 작업, toPage 및 그래픽이 포함됩니다. 라디오 버튼은 일반 응답 버튼이 아닙니다.
SilentMode=0이면 비어 있지 않은 결과도 텍스트 창에 추가되어 열립니다. SetSilentMode(1)는 배열만 반환합니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 첫 번째 줄 읽기 - 직접 스크립트

매개변수와 실행 흐름:

0 — 창 색인. ArrayLength는 라인[0]을 호출하기 전에 라인이 있는지 확인합니다.

var lines = UO.GetGumpButtonsDescription(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

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

2. 자동 창 없이 모든 라인을 순회 - 스크립트 기능

매개변수와 실행 흐름:

SetSilentMode(1)는 추가 텍스트 창을 비활성화합니다. 예제에서 명시적인 Print는 여전히 해당 행을 출력합니다.
i는 배열 인덱스입니다. 해당 설명에서 원하는 버튼/스위치의 ID를 선택하세요.

return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpButtonsDescription(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    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. 마지막으로 열린 서버 창 데이터 읽기 - 스크립트 클래스

매개변수와 실행 흐름:

개수는 마지막 창의 인덱스로 변환됩니다. 로드된 서버 Gump에서 데이터를 읽습니다. 로컬 창은 여기에 포함되지 않습니다.

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()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpButtonsDescription(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GetGumpButtonsDescription(gumpIndex)` — `UO.GetGumpButtonsDescription(Any)`

매개변수: gumpIndex (Any)

결과: dynamic / Array.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.GumpLinesResult: GumpLinesResult(bridge.GetGumpButtonsDescription(Arg(0))).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpButtonsDescription: bridge.GetGumpButtonsDescription(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "getgumpbuttonsdescription": return GumpLinesResult(bridge.GetGumpButtonsDescription(Arg(0)));

UO.GetGumpCount

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

C# 시그니처

int UO.GetGumpCount();

짧은 버전 GetGumpsCount: 활성 서버 검프 수.

매개변수

매개변수가 없습니다.

반환값

int >= 0 — 마지막 창의 인덱스가 아닌 창 수입니다. 0 — 목록이 비어 있습니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 서버 창 확인 - 직접 스크립트

매개변수와 실행 흐름:

이는 창 인덱스가 아닌 서버 검프 수입니다. 현지 배낭과 지도는 여기에 포함되어 있지 않습니다.

int count = UO.GetGumpCount();
UO.Print($"Active server gumps: {count}");

2. 열린 창 ID 읽기 - 스크립트 기능

매개변수와 실행 흐름:

인덱스는 0부터 시작합니다. 통화마다 목록이 바뀔 수 있으므로 읽기 전에 현재 수량을 확인하세요.

return  RunScenario();
 object? RunScenario()
{
    int count = UO.GetGumpCount();
    for (int index = 0; index < count; index++)
    {
        if (index >= UO.GetGumpCount())
            break;
        UO.Print($"Gump {index}: ID={UO.GetGumpID(index)}, serial={UO.GetGumpSerial(index)}");
    }

    return null;
}

3. 시간이 지정된 창을 기다립니다 - 스크립트 클래스

매개변수와 실행 흐름:

대기 시간은 시간 초과로 제한됩니다. 단지 창문이 존재한다고 해서 이것이 꼭 필요한 검프라는 것을 증명하는 것은 아닙니다. 선택하려면 확인하세요 ID.

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()
    {
        bool appeared = await WaitForGump(3000);
        UO.Print(appeared ? "A server gump appeared" : "No server gump within the timeout");
        return null;
    }

    async Task<bool> WaitForGump(int timeoutMs)
    {
        var timer = System.Diagnostics.Stopwatch.StartNew();
        while (timer.ElapsedMilliseconds < timeoutMs)
        {
            if (UO.GetGumpCount() > 0)
                return true;
            await WaitAsync(50);
        }

        return false;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GetGumpCount()` — `UO.GetGumpCount()`

매개변수: 매개변수가 없습니다.

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetGumpCount.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpCount: bridge.GetGumpCount().

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

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

UO.GetGumpFullLines

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

C# 시그니처

dynamic UO.GetGumpFullLines(object? gumpIndex);

중첩된 서버 검프를 포함하여 모든 살아있는 요소에 대한 설명을 반환합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.

반환값

Array - 중첩된 요소를 포함하여 모든 살아있는 요소에 대한 설명입니다. [] - 인덱스가 잘못되었거나 일치하는 요소가 없습니다. 행 인덱스는 0로 시작합니다. ID 컨트롤이 아닙니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
현재 제어 트리에 대한 설명: 유형, 페이지, ID, X/Y, 크기 및 지원되는 필드. 이것은 원시 서버 마크업 패키지가 아닙니다.
SilentMode=0이면 비어 있지 않은 결과도 텍스트 창에 추가되어 열립니다. SetSilentMode(1)는 배열만 반환합니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 첫 번째 줄 읽기 - 직접 스크립트

매개변수와 실행 흐름:

0 — 창 색인. ArrayLength는 라인[0]을 호출하기 전에 라인이 있는지 확인합니다.

var lines = UO.GetGumpFullLines(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

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

2. 자동 창 없이 모든 라인을 순회 - 스크립트 기능

매개변수와 실행 흐름:

SetSilentMode(1)는 추가 텍스트 창을 비활성화합니다. 예제에서 명시적인 Print는 여전히 해당 행을 출력합니다.
i는 배열 인덱스입니다. 해당 설명에서 원하는 버튼/스위치의 ID를 선택하세요.

return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpFullLines(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    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. 마지막으로 열린 서버 창 데이터 읽기 - 스크립트 클래스

매개변수와 실행 흐름:

개수는 마지막 창의 인덱스로 변환됩니다. 로드된 서버 Gump에서 데이터를 읽습니다. 로컬 창은 여기에 포함되지 않습니다.

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()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpFullLines(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GetGumpFullLines(gumpIndex)` — `UO.GetGumpFullLines(Any)`

매개변수: gumpIndex (Any)

결과: dynamic / Array.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.GumpLinesResult: GumpLinesResult(bridge.GetGumpFullLines(Arg(0))).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpFullLines: bridge.GetGumpFullLines(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "getgumpfulllines": return GumpLinesResult(bridge.GetGumpFullLines(Arg(0)));

UO.GetGumpID

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

C# 시그니처

int UO.GetGumpID(object? gumpIndex);

서버 검프 인덱스에서 GumpID 창 유형 ID를 읽습니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.

반환값

int — 32 비트 창 유형 식별자 GumpID. 0는 잘못된 색인입니다(serial=0가 창 자체에 있을 수도 있음). 최상위 비트가 설정되면 int는 음수입니다. Hex(값)을 사용하여 표시합니다. 이것은 주제의 type 또는 색인이 아닙니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
일치하는 serial/GumpID 쌍의 경우 하나의 GetGumpInfo(info[0] 및 info[1] 필드)를 사용하세요.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 16진수로 ID 표시 - 직접 스크립트

매개변수와 실행 흐름:

0은 서버 목록의 첫 번째 색인입니다. 16진수는 음수 int의 비트 표현을 저장합니다.

var value = UO.GetGumpID(0);
UO.Print(Hex(value));

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

2. 체크리스트 경계 - 스크립트 기능

매개변수와 실행 흐름:

변경할 수 없는 목록의 경우 개수는 마지막 인덱스 이후이므로 누락=0입니다. 마지막 유효한 인덱스는 count-1입니다.

return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGumpsCount();
    var missing = UO.GetGumpID(count);
    UO.Print(Hex(missing));
    return null;
}

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

3. 알려진 ID로 열린 창 찾기 - 스크립트 클래스

매개변수와 실행 흐름:

0x999는 ID의 예입니다. 원하는 창의 실제 ID로 바꾸세요. Index, ID 및 serial 소유자는 다른 값입니다.

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()
    {
        int wantedId = 0x00000999;
        int count = UO.GetGumpsCount();
        for (int index = 0; index < count; index++)
        {
            if (index >= UO.GetGumpsCount())
                break;
            if (UO.GetGumpID(index) == wantedId)
            {
                UO.Print($"Gump index {index}, serial {UO.GetGumpSerial(index)}");
                return index;
            }
        }

        return -1;
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GetGumpID(gumpIndex)` — `UO.GetGumpID(Any)`

매개변수: gumpIndex (Any)

결과: int / Integer.

호출 시:

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

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

case "getgumpid": return new InjectionValue(bridge.GetGumpId(Arg(0)));

UO.GetGumpInfo

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

C# 시그니처

dynamic UO.GetGumpInfo(object? gumpIndex);

단일 서버 Gump의 식별자 및 요소에 대한 일관된 스냅샷을 반환합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.

반환값

배열 - 정확히 5개의 요소: [0] int serial; [1] int GumpID; [2] 비어 있지 않은 텍스트 배열; [3] 일반 버튼의 배열 설명; [4] 중첩된 요소를 포함하여 모든 살아있는 요소에 대한 배열 설명입니다. 이 스크립트에 의해 유효하지 않거나 닫히거나 무시된 검프는 빈 배열 []을 생성합니다. 최상위 비트가 있는 ID는 음수 int로 표시됩니다. 빈 텍스트 배열 자체가 창이 없다는 의미는 아닙니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
전체 스냅샷은 하나의 게임 스레드 요청으로 복사됩니다. 반환 후 창을 변경/닫아도 저장된 배열은 변경되지 않습니다.
컨트롤 설명은 유형, 페이지, ID, X/Y, 크기를 나타냅니다. 버튼에는 ButtonID, 작업, toPage 및 graphic가 추가로 포함됩니다. 스위치 - ID, 선택됨, 비활성/활성. 텍스트에는 공백과 =가 포함될 수 있습니다. 문자열은 무조건 공백으로 구문 분석할 수 없습니다.
AddGumpIgnoreByID/AddGumpIgnoreBySerial 현재 스크립트에서 이 읽기 결과만 숨깁니다. ClearGumpsIgnore는 이러한 필터를 제거합니다. GetGumpsCount는 감소하지 않습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. ID 둘 다 읽기 - 직접 스크립트

매개변수와 실행 흐름:

GumpIndex=0 — 첫 번째 서버 검프. 길이 검사는 누락된 창 필드에 대한 액세스를 보호합니다.
info[0] — serial, info[1] — GumpID; 둘 다 동일한 녹음에 속합니다.

var info = UO.GetGumpInfo(0);
if (Truth(ArrayLength(info) == 5))
{
    UO.Print("Serial=" + Hex(info[0]));
    UO.Print("GumpID=" + Hex(info[1]));
}

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

2. 실제 ButtonID 나열 - 스크립트 기능

매개변수와 실행 흐름:

info[3] — 버튼 설명 배열; 해당 줄의 ButtonID 필드는 응답에 대해 ID를 지정합니다. i는 ButtonID가 아닌 행 인덱스일 뿐입니다.
라디오 버튼은 라디오 버튼이며 일반 버튼 목록이 아닌 정보[4]에 나타납니다.

return  RunScenario();
 object? RunScenario()
{
    var info = UO.GetGumpInfo(0);
    if (Truth(ArrayLength(info) == 5))
    {
        var buttons = info[3];
        var i = 0;
        while (Truth(i < ArrayLength(buttons)))
        {
            UO.Print(buttons[i]);
            i = i + 1;
        }
    }

    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. 닫을 때까지 텍스트 저장 - 스크립트 클래스

매개변수와 실행 흐름:

info[2] - 텍스트 사본. 닫는 것은 금지되지 않은 창 NoClose에만 허용됩니다.
닫아도 저장된 텍스트는 지워지지 않습니다. 기존 창에는 빈 텍스트 배열도 허용됩니다.

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 info = UO.GetGumpInfo(0);
        if (Truth(ArrayLength(info) == 5))
        {
            var texts = info[2];
            UO.CloseSimpleGump(0);
            if (Truth(ArrayLength(texts) > 0))
            {
                UO.Print(texts[0]);
            }
        }

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

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GetGumpInfo(gumpIndex)` — `UO.GetGumpInfo(Any)`

매개변수: gumpIndex (Any)

결과: dynamic / Array.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpId: bridge.GetGumpId(index).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpSerial: bridge.GetGumpSerial(index).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpTextLines: bridge.GetGumpTextLines(index).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpButtonsDescription: bridge.GetGumpButtonsDescription(index).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpFullLines: bridge.GetGumpFullLines(index).
InjectionScript.Runtime.InjectionApiUO.StringArray: StringArray(snapshot.Text).

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

case "getgumpinfo":

                {

                    int index = Arg(0);

                    GumpSnapshot snapshot;

                    if (bridge is IApiGumpAccess reader)

                        snapshot = reader.ReadGump(index);

                    else

                    {

                        int id = bridge.GetGumpId(index);

                        snapshot = id == 0 ? null : new GumpSnapshot(bridge.GetGumpSerial(index), id,

                            bridge.GetGumpTextLines(index), bridge.GetGumpButtonsDescription(index), bridge.GetGumpFullLines(index));

                    }

                    if (snapshot == null || state.IgnoredGumpIds.Contains(snapshot.Id)

                        || state.IgnoredGumpSerials.Contains(snapshot.Serial))

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

                    return new InjectionValue(new[]

                    {

                        new InjectionValue(snapshot.Serial), new InjectionValue(snapshot.Id), StringArray(snapshot.Text),

                        StringArray(snapshot.Buttons), StringArray(snapshot.Controls)

                    });

                }

UO.GetGumpSerial

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

C# 시그니처

int UO.GetGumpSerial(object? gumpIndex);

서버 검프 인덱스로 serial 인스턴스/창 소유자를 읽습니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.

반환값

int는 창 인스턴스/소유자의 32비트 serial입니다. 0는 잘못된 색인입니다(serial=0가 창 자체에 있을 수도 있음). 최상위 비트가 설정되면 int는 음수입니다. Hex(값)을 사용하여 표시합니다. 이것은 주제의 type도 아니고 색인도 아닙니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
일치하는 serial/GumpID 쌍의 경우 하나의 GetGumpInfo(info[0] 및 info[1] 필드)를 사용하세요.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 16진수로 ID 표시 - 직접 스크립트

매개변수와 실행 흐름:

0은 서버 목록의 첫 번째 색인입니다. 16진수는 음수 int의 비트 표현을 저장합니다.

var value = UO.GetGumpSerial(0);
UO.Print(Hex(value));

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

2. 체크리스트 경계 - 스크립트 기능

매개변수와 실행 흐름:

변경할 수 없는 목록의 경우 개수는 마지막 인덱스 이후이므로 누락=0입니다. 마지막 유효한 인덱스는 count-1입니다.

return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGumpsCount();
    var missing = UO.GetGumpSerial(count);
    UO.Print(Hex(missing));
    return null;
}

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

3. 로드된 모든 서버 창의 소유자 표시 - 스크립트 클래스

매개변수와 실행 흐름:

Serial은 서버 창 또는 명령 계약에 따른 소유자가 소유합니다. 검프 인덱스 대신 사용할 수 없습니다.

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()
    {
        int count = UO.GetGumpsCount();
        for (int index = 0; index < count; index++)
        {
            if (index >= UO.GetGumpsCount())
                break;
            int serial = UO.GetGumpSerial(index);
            UO.Print($"Window {index}: serial={UO.Int2Hex(serial)}, ID={UO.GetGumpID(index)}");
        }

        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GetGumpSerial(gumpIndex)` — `UO.GetGumpSerial(Any)`

매개변수: gumpIndex (Any)

결과: int / Integer.

호출 시:

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

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

case "getgumpserial": return new InjectionValue(bridge.GetGumpSerial(Arg(0)));

UO.GetGumpShortLines

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

C# 시그니처

dynamic UO.GetGumpShortLines(object? gumpIndex);

서버 Gump의 텍스트 요소 및 버튼에 대한 설명을 반환합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.

반환값

Array - 텍스트 요소 및 버튼에 대한 설명입니다. [] - 인덱스가 잘못되었거나 일치하는 요소가 없습니다. 행 인덱스는 0로 시작합니다. ID 컨트롤이 아닙니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
짧은 목록에는 텍스트가 없고 버튼 유형이 없는 장식이 제외됩니다. 라디오 버튼이 포함되어 있습니다.
SilentMode=0이면 비어 있지 않은 결과도 텍스트 창에 추가되어 열립니다. SetSilentMode(1)는 배열만 반환합니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 첫 번째 줄 읽기 - 직접 스크립트

매개변수와 실행 흐름:

0 — 창 색인. ArrayLength는 라인[0]을 호출하기 전에 라인이 있는지 확인합니다.

var lines = UO.GetGumpShortLines(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

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

2. 자동 창 없이 모든 라인을 순회 - 스크립트 기능

매개변수와 실행 흐름:

SetSilentMode(1)는 추가 텍스트 창을 비활성화합니다. 예제에서 명시적인 Print는 여전히 해당 행을 출력합니다.
i는 배열 인덱스입니다. 해당 설명에서 원하는 버튼/스위치의 ID를 선택하세요.

return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpShortLines(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    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. 마지막으로 열린 서버 창 데이터 읽기 - 스크립트 클래스

매개변수와 실행 흐름:

개수는 마지막 창의 인덱스로 변환됩니다. 로드된 서버 Gump에서 데이터를 읽습니다. 로컬 창은 여기에 포함되지 않습니다.

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()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpShortLines(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GetGumpShortLines(gumpIndex)` — `UO.GetGumpShortLines(Any)`

매개변수: gumpIndex (Any)

결과: dynamic / Array.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.GumpLinesResult: GumpLinesResult(bridge.GetGumpShortLines(Arg(0))).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpShortLines: bridge.GetGumpShortLines(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "getgumpshortlines": return GumpLinesResult(bridge.GetGumpShortLines(Arg(0)));

UO.GetGumpTextLines

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

C# 시그니처

dynamic UO.GetGumpTextLines(object? gumpIndex);

레이블, HTML, 입력 필드 및 서버 검프 스위치 레이블의 비어 있지 않은 텍스트를 반환합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.

반환값

Array — 라벨, HTML, 입력 필드 및 스위치 라벨의 비어 있지 않은 텍스트입니다. [] - 인덱스가 잘못되었거나 일치하는 요소가 없습니다. 행 인덱스는 0로 시작합니다. ID 제어가 아닙니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
텍스트만; ButtonID, 크기 및 구조는 포함되지 않습니다. 추가로 아무것도 인쇄하지 않습니다.
GetGumpTextLines는 텍스트 창을 열지 않습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 첫 번째 줄 읽기 - 직접 스크립트

매개변수와 실행 흐름:

0 — 창 색인. ArrayLength는 라인[0]을 호출하기 전에 라인이 있는지 확인합니다.

var lines = UO.GetGumpTextLines(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

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

2. 자동 창 없이 모든 라인을 순회 - 스크립트 기능

매개변수와 실행 흐름:

SetSilentMode(1)는 추가 텍스트 창을 비활성화합니다. 예제에서 명시적인 Print는 여전히 해당 행을 출력합니다.
i는 배열 인덱스입니다. 해당 설명에서 원하는 버튼/스위치의 ID를 선택하세요.

return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpTextLines(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    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. 마지막으로 열린 서버 창 데이터 읽기 - 스크립트 클래스

매개변수와 실행 흐름:

개수는 마지막 창의 인덱스로 변환됩니다. 로드된 서버 Gump에서 데이터를 읽습니다. 로컬 창은 여기에 포함되지 않습니다.

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()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpTextLines(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GetGumpTextLines(gumpIndex)` — `UO.GetGumpTextLines(Any)`

매개변수: gumpIndex (Any)

결과: dynamic / Array.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.StringArray: StringArray(bridge.GetGumpTextLines(Arg(0))).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpTextLines: bridge.GetGumpTextLines(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "getgumptextlines": return StringArray(bridge.GetGumpTextLines(Arg(0)));

UO.GetGumpsCount

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

C# 시그니처

int UO.GetGumpsCount();

활성 서버 검프 수를 반환합니다.

매개변수

매개변수가 없습니다.

반환값

int >= 0 — 마지막 창의 인덱스가 아닌 창 수입니다. 0 — 목록이 비어 있습니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 창 확인 - 직접 스크립트

매개변수와 실행 흐름:

논쟁이 없습니다. count=0는 현재 목록에 서버 창이 없음을 의미합니다.

var count = UO.GetGumpsCount();
if (Truth(count == 0))
{
    UO.Print("No server gumps");
}

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

2. 목록 ID - 스크립트 기능

매개변수와 실행 흐름:

i는 0의 색인입니다. 결과 ID는 목록의 위치가 아닌 창 유형을 식별합니다.
이동 중에 창이 변경되면 목록을 다시 읽어야 합니다. count는 인터페이스를 차단하지 않습니다.

return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGumpsCount();
    var i = 0;
    while (Truth(i < count))
    {
        UO.Print(Hex(UO.GetGumpID(i)));
        i = i + 1;
    }

    return null;
}

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

3. 목록의 마지막 요소 읽기 - 스크립트 클래스

매개변수와 실행 흐름:

count-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 count = UO.GetGumpsCount();
        if (Truth(count > 0))
        {
            var info = UO.GetGumpInfo(count - 1);
            UO.Print(ArrayLength(info));
        }

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

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GetGumpsCount()` — `UO.GetGumpsCount()`

매개변수: 매개변수가 없습니다.

결과: int / Integer.

호출 시:

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

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

case "getgumpscount": return new InjectionValue(bridge.GetGumpCount());

UO.GumpAutoCheckBox

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

C# 시그니처

void UO.GumpAutoCheckBox(object? checkBoxID, object? value);

첫 번째 적합한 서버 검프에서 요소의 값을 한 번 설정합니다. 요소가 아직 존재하지 않으면 대기 시간을 저장합니다.

매개변수

checkBoxID - int - 해당 유형 요소의 정확한 ID. 이것은 인덱스도 아니고 GumpID도 아니고 serial 창이 아닙니다. 0는 첫 번째 요소를 대체하지 않는 일반적인 ID입니다.
value - int - 1 활성화, 0 비활성화. 0이 아닌 숫자 값도 포함됩니다. 0/1를 권장합니다. 라디오 버튼을 선택하면 해당 그룹의 인접한 라디오 버튼이 선택 취소됩니다.

반환값

void - 아무것도 반환하지 않습니다. 성공도, 새 값도, 서버 확인도 반환되지 않습니다.

동작

먼저 현재 인터페이스 순서로 기존 창을 확인한 다음 새롭거나 업데이트된 서버 레이아웃을 확인합니다. 유형과 ID의 첫 번째 일치에서 한 번 실행됩니다. 특정 창의 경우 색인과 함께 NumGump*를 사용하세요.
보류 중인 모든 필드는 자동 버튼 응답 전에 적용됩니다. 하나의 스크립트에서 동일한 유형과 ID를 반복하면 아직 실행되지 않은 값을 대체합니다. 제한 — 1024 보류 중인 클라이언트 필드; 초과하면 스크립트 오류가 발생합니다.
절차가 정상적으로 완료되면 대기 시간이 절약됩니다. 소유자를 취소하거나 그의 이름으로 Terminate을 입력하면 대기 시간이 제거됩니다. TerminateAll는 절차 완료 후 남은 내용을 포함하여 모든 내용을 삭제합니다. 세상을 바꾸면 대기열이 지워집니다. 기대치는 프로필에 저장되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.GumpAutoCheckBox");
UO.GumpAutoCheckBox(33, 1);

1. 즉시 채우기 - 직접 스크립트

매개변수와 실행 흐름:

첫 번째 매개변수 33는 원하는 요소의 예시 ID입니다. InfoGump의 실제 ID로 바꾸세요. 두 번째는 설정할 값입니다. 요소가 없으면 작업은 보류 상태로 유지됩니다.

UO.GumpAutoCheckBox(33, 1);

2. 열기 전 채우기 - 스크립트 기능

매개변수와 실행 흐름:

33는 요소의 ID이고, 100는 확인 ButtonID의 예이며, 0x40001234는 양식을 여는 개체의 serial입니다. 세 가지 값을 모두 자신의 값으로 바꾸십시오. 창이 나중에 도착한 경우에도 답변 전에 필드가 채워집니다.

return  RunScenario();
 object? RunScenario()
{
    UO.GumpAutoCheckBox(33, 1);
    UO.WaitGump(100);
    UO.UseObject("0x40001234");
    return null;
}

3. 보류 중인 값 바꾸기 - 스크립트 클래스

매개변수와 실행 흐름:

두 호출 모두 ID 33를 사용합니다. 요소가 아직 나타나지 않은 경우 마지막 값이 적용됩니다. 창이 이미 열려 있으면 두 변경 사항이 모두 순서대로 즉시 수행됩니다.

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.GumpAutoCheckBox(33, 1);
        UO.GumpAutoCheckBox(33, 0);
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GumpAutoCheckBox(checkBoxID, value)` — `UO.GumpAutoCheckBox(Any,Any)`

매개변수: checkBoxID (Any), value (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.QueueGumpControl: QueueGumpControl("checkbox", Arg(0), Text(1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(1).

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

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

UO.GumpAutoRadiobutton

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

C# 시그니처

void UO.GumpAutoRadiobutton(object? radiobuttonID, object? value);

첫 번째 적합한 서버 검프에서 요소의 값을 한 번 설정합니다. 요소가 아직 존재하지 않으면 대기 시간을 저장합니다.

매개변수

radiobuttonID - int - 해당 유형 요소의 정확한 ID. 이것은 인덱스도 아니고 GumpID도 아니고 serial 창이 아닙니다. 0는 첫 번째 요소를 대체하지 않는 일반적인 ID입니다.
value - int - 1 활성화, 0 비활성화. 0이 아닌 숫자 값도 포함됩니다. 0/1를 권장합니다. 라디오 버튼을 선택하면 해당 그룹의 인접한 라디오 버튼이 선택 취소됩니다.

반환값

void - 아무것도 반환하지 않습니다. 성공도, 새 값도, 서버 확인도 반환되지 않습니다.

동작

먼저 현재 인터페이스 순서로 기존 창을 확인한 다음 새롭거나 업데이트된 서버 레이아웃을 확인합니다. 유형과 ID의 첫 번째 일치에서 한 번 실행됩니다. 특정 창의 경우 색인과 함께 NumGump*를 사용하세요.
보류 중인 모든 필드는 자동 버튼 응답 전에 적용됩니다. 하나의 스크립트에서 동일한 유형과 ID를 반복하면 아직 실행되지 않은 값을 대체합니다. 제한 — 1024 보류 중인 클라이언트 필드; 초과하면 스크립트 오류가 발생합니다.
절차가 정상적으로 완료되면 대기 시간이 절약됩니다. 소유자를 취소하거나 그의 이름으로 Terminate을 입력하면 대기 시간이 제거됩니다. TerminateAll는 절차 완료 후 남은 내용을 포함하여 모든 내용을 삭제합니다. 세상을 바꾸면 대기열이 지워집니다. 기대치는 프로필에 저장되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.GumpAutoRadiobutton");
UO.GumpAutoRadiobutton(33, 1);

1. 즉시 채우기 - 직접 스크립트

매개변수와 실행 흐름:

첫 번째 매개변수 33는 원하는 요소의 예시 ID입니다. InfoGump의 실제 ID로 바꾸세요. 두 번째는 설정할 값입니다. 요소가 없으면 작업은 보류 상태로 유지됩니다.

UO.GumpAutoRadiobutton(33, 1);

2. 열기 전 채우기 - 스크립트 기능

매개변수와 실행 흐름:

33는 요소의 ID이고, 100는 확인 ButtonID의 예이며, 0x40001234는 양식을 여는 개체의 serial입니다. 세 가지 값을 모두 자신의 값으로 바꾸십시오. 창이 나중에 도착한 경우에도 답변 전에 필드가 채워집니다.

return  RunScenario();
 object? RunScenario()
{
    UO.GumpAutoRadiobutton(33, 1);
    UO.WaitGump(100);
    UO.UseObject("0x40001234");
    return null;
}

3. 보류 중인 값 바꾸기 - 스크립트 클래스

매개변수와 실행 흐름:

두 호출 모두 ID 33를 사용합니다. 요소가 아직 나타나지 않은 경우 마지막 값이 적용됩니다. 창이 이미 열려 있으면 두 변경 사항이 모두 순서대로 즉시 수행됩니다.

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.GumpAutoRadiobutton(33, 1);
        UO.GumpAutoRadiobutton(33, 0);
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GumpAutoRadiobutton(radiobuttonID, value)` — `UO.GumpAutoRadiobutton(Any,Any)`

매개변수: radiobuttonID (Any), value (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.QueueGumpControl: QueueGumpControl("radio", Arg(0), Text(1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(1).

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

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

UO.GumpAutoTextEntry

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

C# 시그니처

void UO.GumpAutoTextEntry(object? textEntryID, object? value);

첫 번째 적합한 서버 검프에서 요소의 값을 한 번 설정합니다. 요소가 아직 존재하지 않으면 대기 시간을 저장합니다.

매개변수

textEntryID - int - 해당 유형 요소의 정확한 ID. 이것은 인덱스도 아니고 GumpID도 아니고 serial 창이 아닙니다. 0는 첫 번째 요소를 대체하지 않는 일반적인 ID입니다.
value - string - 지우기 위한 빈 줄을 포함한 필드 텍스트입니다. 필드 자체의 길이 및 허용되는 문자에 대한 제한은 유지됩니다.

반환값

void - 아무것도 반환하지 않습니다. 성공도, 새 값도, 서버 확인도 반환되지 않습니다.

동작

먼저 현재 인터페이스 순서로 기존 창을 확인한 다음 새롭거나 업데이트된 서버 레이아웃을 확인합니다. 유형과 ID의 첫 번째 일치에서 한 번 실행됩니다. 특정 창의 경우 색인과 함께 NumGump*를 사용하세요.
보류 중인 모든 필드는 자동 버튼 응답 전에 적용됩니다. 하나의 스크립트에서 동일한 유형과 ID를 반복하면 아직 실행되지 않은 값을 대체합니다. 제한 — 1024 보류 중인 클라이언트 필드; 초과하면 스크립트 오류가 발생합니다.
절차가 정상적으로 완료되면 대기 시간이 절약됩니다. 소유자를 취소하거나 그의 이름으로 Terminate을 입력하면 대기 시간이 제거됩니다. TerminateAll는 절차 완료 후 남은 내용을 포함하여 모든 내용을 삭제합니다. 세상을 바꾸면 대기열이 지워집니다. 기대치는 프로필에 저장되지 않습니다.
필드로 제한된 텍스트는 단축되거나 거부될 수 있습니다. 발견된 요소는 여전히 일회성 작업을 사용합니다. 이 명령은 버튼 응답을 보내지 않으며 서버를 기다리지 않습니다. 확인하려면 GetGumpInfo/NumGumpTextEntry를 사용하세요.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.GumpAutoTextEntry");
UO.GumpAutoTextEntry(33, "500");

1. 즉시 채우기 - 직접 스크립트

매개변수와 실행 흐름:

첫 번째 매개변수 33는 원하는 요소의 예시 ID입니다. InfoGump의 실제 ID로 바꾸세요. 두 번째는 설정할 값입니다. 요소가 없으면 작업은 보류 상태로 유지됩니다.

UO.GumpAutoTextEntry(33, "500");

2. 열기 전 채우기 - 스크립트 기능

매개변수와 실행 흐름:

33는 요소의 ID이고, 100는 확인 ButtonID의 예이며, 0x40001234는 양식을 여는 개체의 serial입니다. 세 가지 값을 모두 자신의 값으로 바꾸십시오. 창이 나중에 도착한 경우에도 답변 전에 필드가 채워집니다.

return  RunScenario();
 object? RunScenario()
{
    UO.GumpAutoTextEntry(33, "500");
    UO.WaitGump(100);
    UO.UseObject("0x40001234");
    return null;
}

3. 보류 중인 값 바꾸기 - 스크립트 클래스

매개변수와 실행 흐름:

두 호출 모두 ID 33를 사용합니다. 요소가 아직 나타나지 않은 경우 마지막 값이 적용됩니다. 창이 이미 열려 있으면 두 변경 사항이 모두 순서대로 즉시 수행됩니다.

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.GumpAutoTextEntry(33, "500");
        UO.GumpAutoTextEntry(33, "");
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GumpAutoTextEntry(textEntryID, value)` — `UO.GumpAutoTextEntry(Any,Any)`

매개변수: textEntryID (Any), value (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.QueueGumpControl: QueueGumpControl("textentry", Arg(0), Text(1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(1).

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

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

UO.GumpExists

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

C# 시그니처

int UO.GumpExists(object? id);
int UO.GumpExists(object? firstId, object? secondId);

하나의 선택기 또는 정확한 쌍 serial/GumpID를 사용하여 서버 Gump가 있는지 확인합니다.

매개변수

id — 단일 인수 형식: 숫자 serial, GumpID 또는 0가 포함된 인덱스. -1는 여기서 마지막 검프를 선택하지 않습니다.
firstId — 2개 인수 형식: 숫자 32비트 serial(최상위 비트가 있는 음수 int 포함).
secondId — 2인수 형식: 정확한 32비트 GumpID. 0는 와일드카드가 아닌 정확한 숫자입니다. -1만 serial/GumpID/index로 firstId의 단일 인수 확인으로 다시 전환됩니다.

반환값

int - 1, 해당 창이 현재 존재하는 경우; 0 그렇지 않으면. 색인, serial 또는 일치 항목 수를 반환하지 않습니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
수표는 창을 선택하지 않으며 예약하지도 않습니다. ID 쌍이 전체적으로 확인됩니다. 최상위 비트가 있는 ID은 필터를 비활성화하지 않습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 알려진 ID 확인 - 직접 스크립트

매개변수와 실행 흐름:

0x87654321 — 원하는 GumpID 또는 serial. 하나의 인수는 이러한 공백 ID을 구별하지 않습니다.

var exists = UO.GumpExists(0x87654321);
UO.Print(Convert.ToString(exists));

2. 정확한 쌍 확인 - 스크립트 기능

매개변수와 실행 흐름:

첫 번째 숫자는 serial이고 두 번째 숫자는 GumpID입니다. 둘 다 부호 있는 int에서는 음수이지만 비교에서는 모든 32 비트가 유지됩니다.

return  RunScenario();
 object? RunScenario()
{
    var exists = UO.GumpExists(0x87654321, 0x98765432);
    if (Truth(exists))
    {
        UO.Print("Matching pair exists");
    }

    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. 저장된 식별자 확인 - 스크립트 클래스

매개변수와 실행 흐름:

info[0]/info[1]는 동일한 이미지에 속합니다. 존재=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 info = UO.GetGumpInfo(0);
        if (Truth(ArrayLength(info) == 5))
        {
            var exists = UO.GumpExists(info[0], info[1]);
            UO.Print(Convert.ToString(exists));
        }

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

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.GumpExists(id)` — `UO.GumpExists(Any)`

매개변수: id (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GumpExists.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GumpExists: bridge.GumpExists(NumberConversions.ToInt(id), -1).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(id).

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

public int GumpExists(InjectionValue id) => bridge.GumpExists(NumberConversions.ToInt(id), -1);

`UO.GumpExists(firstId, secondId)` — `UO.GumpExists(Any,Any)`

매개변수: firstId (Any), secondId (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GumpExists.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GumpExists: bridge.GumpExists(NumberConversions.ToInt(firstId), NumberConversions.ToInt(secondId)).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(firstId).

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

public int GumpExists(InjectionValue firstId, InjectionValue secondId)

            => bridge.GumpExists(NumberConversions.ToInt(firstId), NumberConversions.ToInt(secondId));

UO.GumpObject

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

C# 시그니처

void UO.GumpObject(object? gumpId);

후속 호출을 위해 기존 서버 Gump를 선택합니다.

매개변수

gumpId - int: LocalSerial 또는 ServerSerial를 먼저 일치시킨 다음 현재 검프 목록에서 인덱스 0을 찾습니다. ID 버튼이 아닙니다.

반환값

void - 값이 없습니다. 별도의 회선으로 전화하세요. 완료는 서버의 작업을 확인하지 않습니다.

동작

Bridge.SelectGump는 _selectedServerGump를 저장합니다. serial이 일치하지 않으면 0..count-1 인덱스를 사용합니다. 찾을 수 없음 - 선택한 검프가 null가 되고 메시지가 표시됩니다.
Gump가 열리지 않고 서버에 응답이 전송되지 않습니다. 창이 열리거나 닫힐 때 인덱스가 변경됩니다. 안정적인 선택을 위해 현재 serial/id를 사용하세요.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.GumpObject");
UO.GumpObject(0);

1. 직접 통화 - 직접 스크립트

매개변수와 실행 흐름:

후속 호출을 위해 기존 서버 Gump를 선택합니다.

if (Truth(UO.GumpExists(0)))
{
    UO.GumpObject(0);
}

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

2. 명시적 옵션 - 스크립트 기능

매개변수와 실행 흐름:

Bridge.SelectGump는 _selectedServerGump를 저장합니다. serial이 일치하지 않으면 0..count-1 인덱스를 사용합니다. 찾을 수 없음 - 선택한 검프가 null가 되고 메시지가 표시됩니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        var serial = UO.GetGumpSerial(0);
        UO.GumpObject(serial);
    }

    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. 전체 도우미 기능 - 스크립트 클래스

매개변수와 실행 흐름:

Gump가 열리지 않고 서버에 응답이 전송되지 않습니다. 창이 열리거나 닫힐 때 인덱스가 변경됩니다. 안정적인 선택을 위해 현재 serial/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(UO.GetGumpsCount() > 0))
        {
            UO.GumpObject(0);
            UO.Print(UO.LastGump("gumpid"));
        }

        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.GumpObject(gumpId)` — `UO.GumpObject(Any)`

매개변수: gumpId (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SelectGump: bridge.SelectGump(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0).

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

case "gumpobject": bridge.SelectGump(Arg(0)); break;

UO.IsGump

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

C# 시그니처

int UO.IsGump();

활성 서버 검프가 하나 이상 있는지 확인합니다.

매개변수

매개변수가 없습니다.

반환값

int — 1, 목록이 비어 있지 않은 경우; 0 비어 있는 경우. 이는 창 수가 아니라 가용성을 나타내는 표시입니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 조건부 읽기 - 직접 스크립트

매개변수와 실행 흐름:

논쟁이 없습니다. GetGumpInfo(0)는 첫 번째 요소를 읽고 창이 이미 닫혀 있으면 빈 배열을 반환할 수 있습니다.

if (Truth(UO.IsGump()))
{
    var info = UO.GetGumpInfo(0);
    UO.Print(ArrayLength(info));
}

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;

2. 양과 존재를 구별 - 스크립트 기능

매개변수와 실행 흐름:

세 개의 안정적인 창이 있는 경우=1, 개수=3.

return  RunScenario();
 object? RunScenario()
{
    var present = UO.IsGump();
    var count = UO.GetGumpsCount();
    UO.Print(Convert.ToString(present) + "/" + Convert.ToString(count));
    return null;
}

3. 제한된 대기 - 스크립트 클래스

매개변수와 실행 흐름:

약 3000ms 이상 기다리지 말고 50ms마다 확인하세요. 최종 현재는 대기 후의 상태를 보여줍니다.

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 = Now();
        while (Truth(UO.IsGump() == 0) && Truth(Now() - started < 3000))
        {
            await Delay(50);
        }

        var present = UO.IsGump();
        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;
    private int Now() => global::ClassicUO.CSharp.CSharpScriptContext.Current.Now();
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.IsGump()` — `UO.IsGump()`

매개변수: 매개변수가 없습니다.

결과: int / Integer.

호출 시:

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

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

case "isgump": return new InjectionValue(bridge.GetGumpCount() > 0 ? 1 : 0);

UO.IsGumpCanBeClosed

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

C# 시그니처

int UO.IsGumpCanBeClosed(object? gumpIndex);

서버 검프의 로컬 마우스 오른쪽 버튼 클릭 닫기가 허용되는지 확인합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.

반환값

int — 1, 창이 존재하고 CanCloseWithRightClick가 활성화된 경우; 그렇지 않으면 0. 이는 닫았거나 취소 버튼이 있어서 발생하는 것이 아닙니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
NoClose는 CloseSimpleGump을 금지합니다. ButtonID를 서버에 보내는 기능은 별도의 작업입니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 조건부 닫기 - 직접 스크립트

매개변수와 실행 흐름:

0 — 창 색인. 검증과 종결은 서로 다른 과제입니다. 인덱스는 그들 사이에서 변경될 수 있습니다.

if (Truth(UO.IsGumpCanBeClosed(0)))
{
    UO.CloseSimpleGump(0);
}

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

2. 닫기 표시 비활성화 - 스크립트 기능

매개변수와 실행 흐름:

기존 창에서 closable=0는 창이 없는 것이 아니라 창을 닫을 수 없다는 의미입니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        var closable = UO.IsGumpCanBeClosed(0);
        UO.Print(Convert.ToString(closable));
    }

    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. 잘못된 인덱스 - 스크립트 클래스

매개변수와 실행 흐름:

-1는 이 인덱스 명령에 유효하지 않으며 0를 제공합니다. 이것은 마지막 창 선택이 아닙니다.

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

     public object? RunScenario()
    {
        var result = UO.IsGumpCanBeClosed(-1);
        UO.Print(Convert.ToString(result));
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.IsGumpCanBeClosed(gumpIndex)` — `UO.IsGumpCanBeClosed(Any)`

매개변수: gumpIndex (Any)

결과: int / Integer.

호출 시:

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

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

case "isgumpcanbeclosed": return new InjectionValue(bridge.IsGumpCanBeClosed(Arg(0)));

UO.LastGump

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

C# 시그니처

dynamic UO.LastGump(object? identifier);
dynamic UO.LastGump(object? identifier, object? key);

선택한 서버 Gump의 한 필드를 읽습니다. 이 스크립트에 의해 선택된 창이나 현재 목록의 마지막 요소를 사용합니다.

매개변수

identifier - string 대소문자를 구분하지 않습니다. 지원되는 모든 값과 결과 유형은 반품 섹션에 나열되어 있습니다. 알 수 없는 이름은 빈 문자열을 반환합니다.
key - 선택 사항 int, 기본값 - 1. 버튼/텍스트/object/명령의 경우 0로 색인을 생성하세요. 이것은 ID 제어가 아닙니다. 음수 인덱스와 범위를 벗어나면 버튼의 경우 0이 되고 텍스트 필드의 경우 빈 문자열이 표시됩니다. 다른 식별자는 키를 사용하지 않습니다.

반환값

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
SelectGump/InfoGump는 현재 런타임에서만 선택한 창을 지정합니다. 선택한 창이 닫히면 현재 목록의 마지막 항목이 사용됩니다. 이는 반드시 가장 최근 항목일 필요는 없습니다.
textlen/text는 서버 패키지의 원래 문자열 풀이 아닌 사용 가능한 텍스트 컨트롤을 참조합니다. object/command는 라이브 컨트롤의 전체 트리를 나타냅니다. 다른 목록의 인덱스는 혼합될 수 없습니다.
각 호출은 현재 상태를 개별적으로 읽습니다. 일치하는 serial, GumpID 및 목록의 경우 GetGumpInfo를 사용하세요.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 선택한 창의 ID 읽기 - 직접 스크립트

매개변수와 실행 흐름:

gumpid 및 serial는 이미 16진수로 형식화된 문자열을 반환합니다. 추가 16진수가 필요하지 않습니다. 빈 줄은 읽을 때 창이 없음을 의미합니다.

var id = UO.LastGump("gumpid");
var serial = UO.LastGump("serial");
UO.Print(id + " / " + serial);

2. ButtonID 열거 - 스크립트 함수

매개변수와 실행 흐름:

Buttonlen — 버튼 수; i는 0부터 count-1까지의 행 인덱스입니다. 버튼 - 그래픽이나 색인이 아닌 답변용 ID입니다. 창을 변경할 때 목록을 다시 읽으십시오.

return  RunScenario();
 object? RunScenario()
{
    var count = UO.LastGump("buttonlen");
    var i = 0;
    while (Truth(i < count))
    {
        var button = UO.LastGump("button", i);
        UO.Print(Convert.ToString(button));
        i = i + 1;
    }

    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. 선택 후 텍스트 읽기 - 스크립트 클래스

매개변수와 실행 흐름:

0x12345678는 GumpID/serial의 예입니다. ID를 원하는 형식으로 바꾸세요. key=0인 텍스트는 사용 가능한 첫 번째 텍스트 컨트롤을 읽습니다. 이것은 버튼과 다른 목록입니다.
SelectGump는 지정된 창이 없다고 보고하지만 후속 읽기를 차단하지 않습니다. 필요한 경우 반환된 gumpid를 별도로 확인하세요.

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.SelectGump(0x12345678);
        if (Truth(UO.LastGump("inclient")))
        {
            var count = UO.LastGump("textlen");
            if (Truth(count > 0))
            {
                UO.Print(UO.LastGump("text", 0));
            }
        }

        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.LastGump(identifier)` — `UO.LastGump(String)`

매개변수: identifier (String)

결과: dynamic / Any.

호출 시:

InjectionScript.Runtime.InjectionApiUO.LastGump.
InjectionScript.Runtime.InjectionApiUO.LastGump: LastGump(identifier, -1).

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

public InjectionValue LastGump(string identifier) => LastGump(identifier, -1);

`UO.LastGump(identifier, key)` — `UO.LastGump(String,Integer)`

매개변수: identifier (String), key (Integer)

결과: dynamic / Any.

호출 시:

InjectionScript.Runtime.InjectionApiUO.LastGump.
InjectionScript.Runtime.InjectionApiUO.ConvertGumpValue: ConvertGumpValue(identifier, bridge.GetGumpValue(-1, identifier, key)).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGumpValue: bridge.GetGumpValue(-1, identifier, key).

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

public InjectionValue LastGump(string identifier, int key) => ConvertGumpValue(identifier, bridge.GetGumpValue(-1, identifier, key));

UO.NumGumpButton

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

C# 시그니처

int UO.NumGumpButton(object? gumpIndex, object? value);

엄격한 창 인덱스와 정확한 ButtonID를 기반으로 기존 서버 검프 버튼을 활성화합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.
value - int - 일반 버튼 설명의 ButtonID입니다. 줄번호도 아니고, graphic 버튼도 아니고, GumpID도 아닙니다.

반환값

int (bool) - 1, 창과 버튼이 발견되고 로컬 작업이 수행되는 경우; 0 창/버튼이 없는 경우. 페이지를 변경하면 1도 반환됩니다. 이는 서버 처리에 대한 확인이 아닙니다.

명령의 결과는 숫자 플래그입니다. 1는 충족된 조건을 의미하고, 0는 충족되지 않은 조건을 의미합니다. var result = command(...) 후에 (결과 != 0) 또는 (결과 == 0)인지 확인하세요. 한 번의 호출 결과를 저장합니다. 반복된 호출을 통해 해당 작업을 다시 수행하거나 이미 변경된 상태를 읽을 수 있습니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
SwitchPage 버튼은 페이지를 로컬로 전환합니다. 활성화 버튼을 누르면 검프 응답이 발생합니다. 창문은 보통 닫힙니다. SendGumpSelect와 달리 이 명령에는 컨트롤 트리에 기존 ButtonID가 필요합니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

var result = UO.NumGumpButton(0, 77);
UO.Print("NumGumpButton: " + Convert.ToString(result));

1. 잘 알려진 버튼 누르기 - 직접 스크립트

매개변수와 실행 흐름:

0은 창 인덱스이고, 77는 검사기의 ButtonID 예시입니다. 귀하의 양식에는 실제 ID가 필요합니다.

var ok = UO.NumGumpButton(0, 77);
if (Truth(ok == 0))
{
    UO.Print("Button not found");
}

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

2. 창 유형을 먼저 확인하세요 - 스크립트 기능

매개변수와 실행 흐름:

0x12345678은 예상되는 GumpID이고, 100는 ButtonID입니다. 이 두 숫자는 서로 다른 공백 ID에 속합니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpID(0) == 0x12345678))
    {
        var ok = UO.NumGumpButton(0, 100);
    }

    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. 버튼 앞의 체크박스 변경 - 스크립트 클래스

매개변수와 실행 흐름:

33 - ID 확인란, 1 - 활성화, 100 - 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(UO.NumGumpCheckBox(0, 33, 1)))
        {
            var ok = UO.NumGumpButton(0, 100);
        }

        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.NumGumpButton(gumpIndex, value)` — `UO.NumGumpButton(Any,Any)`

매개변수: gumpIndex (Any), value (Any)

결과: int / Integer.

호출 시:

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

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

case "numgumpbutton": return (bridge is IApiGumpAccess buttons

                    ? buttons.ActivateGumpButtonAtIndex(Arg(0), Arg(1)) : bridge.ActivateGumpButton(Arg(0), Arg(1))) != 0 ? InjectionValue.True : InjectionValue.False;

UO.NumGumpCheckBox

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

C# 시그니처

int UO.NumGumpCheckBox(object? gumpIndex, object? cbid, object? value);

서버 검프의 플래그 상태를 인덱스별로 설정합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.
cbid - int - 검프 설명의 정확한 ID 요소입니다. 이는 요소의 일련번호가 아닙니다. 누락된 ID는 색인으로 대체되지 않습니다.
value — int — 1 활성화/선택, 0 비활성화. 0이 아닌 숫자 값, true 및 selected도 인식됩니다. 0 및 1를 권장합니다.

반환값

int (bool) — 1, 필요한 요소가 발견되고 최종 값이 지정된 요소와 일치하는 경우; 0 색인이 유효하지 않은 경우 ID/요소 유형이 누락되었거나 필드가 정확한 값을 사용하지 않은 경우입니다. 이미 설정된 값을 재설정해도 성공합니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
로컬 상태를 변경합니다. 필드와 선택된 라디오 버튼이 전송되고 버튼 응답이 이어집니다.
라디오 버튼을 선택하면 동일한 그룹의 인접한 라디오 버튼이 선택 취소됩니다. 일반 확인란은 독립적입니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

var result = UO.NumGumpCheckBox(0, 33, 1);
UO.Print("NumGumpCheckBox: " + Convert.ToString(result));

1. 값 설정 및 결과 확인 - 직접 스크립트

매개변수와 실행 흐름:

0 — 창 인덱스; 33 — 정확한 CBID; 1 - 새로운 값. 검프에서 33를 ID로 바꾸세요.

var ok = UO.NumGumpCheckBox(0, 33, 1);
if (Truth(ok == 0))
{
    UO.Print("Control missing or value rejected");
}

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

2. 값 지우기 - 스크립트 기능

매개변수와 실행 흐름:

0 필드를 지우거나 선택을 취소합니다. 필드의 새 값이 아닌 변경 성공이 반환됩니다.

return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NumGumpCheckBox(0, 33, 0);
    UO.Print(Convert.ToString(ok));
    return null;
}

3. 답장 전 채우기 - 스크립트 클래스

매개변수와 실행 흐름:

100 - 서버 ButtonID 확인 예시; 창문의 ID를 교체해야 합니다. 0 ~ SendGumpSelect(0,100)는 창 인덱스입니다.
대답은 검프를 닫고 인덱스를 변경할 수 있습니다. 전송됨은 로컬 전송을 의미하며, 서버에서 확인되지 않은 작업의 결과입니다.

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(UO.NumGumpCheckBox(0, 33, 1)))
        {
            var sent = UO.SendGumpSelect(0, 100);
            UO.Print(Convert.ToString(sent));
        }

        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.NumGumpCheckBox(gumpIndex, cbid, value)` — `UO.NumGumpCheckBox(Any,Any,Any)`

매개변수: gumpIndex (Any), cbid (Any), value (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.SetIndexedGumpValue: SetIndexedGumpValue(Arg(0), "checkbox", Arg(1), Text(2)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(2).

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

case "numgumpcheckbox": return SetIndexedGumpValue(Arg(0), "checkbox", Arg(1), Text(2));

UO.NumGumpRadiobutton

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

C# 시그니처

int UO.NumGumpRadiobutton(object? gumpIndex, object? radiobuttonID, object? value);

인덱스별로 서버 검프의 라디오 버튼 상태를 설정합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.
radiobuttonID - int - 검프 설명의 정확한 ID 요소입니다. 이는 요소의 일련번호가 아닙니다. 누락된 ID는 색인으로 대체되지 않습니다.
value — int — 1 활성화/선택, 0 비활성화. 0이 아닌 숫자 값, true 및 selected도 인식됩니다. 0 및 1를 권장합니다.

반환값

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
로컬 상태를 변경합니다. 필드와 선택된 라디오 버튼이 전송되고 버튼 응답이 이어집니다.
라디오 버튼을 선택하면 동일한 그룹의 인접한 라디오 버튼이 선택 취소됩니다. 일반 확인란은 독립적입니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

var result = UO.NumGumpRadiobutton(0, 33, 1);
UO.Print("NumGumpRadiobutton: " + Convert.ToString(result));

1. 값 설정 및 결과 확인 - 직접 스크립트

매개변수와 실행 흐름:

0 — 창 인덱스; 33 — 정확한 RadiobuttonID; 1 - 새로운 값. 검프에서 33를 ID로 바꾸세요.

var ok = UO.NumGumpRadiobutton(0, 33, 1);
if (Truth(ok == 0))
{
    UO.Print("Control missing or value rejected");
}

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

2. 값 지우기 - 스크립트 기능

매개변수와 실행 흐름:

0 필드를 지우거나 선택을 취소합니다. 필드의 새 값이 아닌 변경 성공이 반환됩니다.

return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NumGumpRadiobutton(0, 33, 0);
    UO.Print(Convert.ToString(ok));
    return null;
}

3. 답장 전 채우기 - 스크립트 클래스

매개변수와 실행 흐름:

100 - 서버 ButtonID 확인 예시; 창문의 ID를 교체해야 합니다. 0 ~ SendGumpSelect(0,100)는 창 인덱스입니다.
대답은 검프를 닫고 인덱스를 변경할 수 있습니다. 전송됨은 로컬 전송을 의미하며, 서버에서 확인되지 않은 작업의 결과입니다.

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(UO.NumGumpRadiobutton(0, 33, 1)))
        {
            var sent = UO.SendGumpSelect(0, 100);
            UO.Print(Convert.ToString(sent));
        }

        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.NumGumpRadiobutton(gumpIndex, radiobuttonID, value)` — `UO.NumGumpRadiobutton(Any,Any,Any)`

매개변수: gumpIndex (Any), radiobuttonID (Any), value (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.SetIndexedGumpValue: SetIndexedGumpValue(Arg(0), "radio", Arg(1), Text(2)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(2).

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

case "numgumpradiobutton": return SetIndexedGumpValue(Arg(0), "radio", Arg(1), Text(2));

UO.NumGumpTextEntry

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

C# 시그니처

int UO.NumGumpTextEntry(object? gumpIndex, object? textEntryID, object? value);

서버 검프의 입력 필드 텍스트를 인덱스별로 설정합니다.

매개변수

gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial가 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요.
textEntryID - int - 검프 설명의 정확한 ID 요소입니다. 이는 요소의 일련번호가 아닙니다. 누락된 ID는 색인으로 대체되지 않습니다.
value - string - 새 텍스트. 빈 문자열은 필드를 지웁니다. 필드 자체의 길이/문자 제한은 유지됩니다.

반환값

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
로컬 상태를 변경합니다. 필드와 선택된 라디오 버튼이 전송되고 버튼 응답이 이어집니다.
라디오 버튼을 선택하면 동일한 그룹의 인접한 라디오 버튼이 선택 취소됩니다. 일반 확인란은 독립적입니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

var result = UO.NumGumpTextEntry(0, 33, "500");
UO.Print("NumGumpTextEntry: " + Convert.ToString(result));

1. 값 설정 및 결과 확인 - 직접 스크립트

매개변수와 실행 흐름:

0 — 창 인덱스; 33 — 정확한 TextEntryID; '500'는 새로운 값입니다. 검프에서 33를 ID로 바꾸세요.

var ok = UO.NumGumpTextEntry(0, 33, "500");
if (Truth(ok == 0))
{
    UO.Print("Control missing or value rejected");
}

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

2. 값 지우기 - 스크립트 기능

매개변수와 실행 흐름:

''는 필드를 지우거나 선택을 취소합니다. 필드의 새 값이 아닌 변경 성공이 반환됩니다.

return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NumGumpTextEntry(0, 33, "");
    UO.Print(Convert.ToString(ok));
    return null;
}

3. 답장 전 채우기 - 스크립트 클래스

매개변수와 실행 흐름:

100 - 서버 ButtonID 확인 예시; 창문의 ID를 교체해야 합니다. 0 ~ SendGumpSelect(0,100)는 창 인덱스입니다.
대답은 검프를 닫고 인덱스를 변경할 수 있습니다. 전송됨은 로컬 전송을 의미하며, 서버에서 확인되지 않은 작업의 결과입니다.

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(UO.NumGumpTextEntry(0, 33, "500")))
        {
            var sent = UO.SendGumpSelect(0, 100);
            UO.Print(Convert.ToString(sent));
        }

        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.NumGumpTextEntry(gumpIndex, textEntryID, value)` — `UO.NumGumpTextEntry(Any,Any,Any)`

매개변수: gumpIndex (Any), textEntryID (Any), value (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.SetIndexedGumpValue: SetIndexedGumpValue(Arg(0), "textentry", Arg(1), Text(2)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(2).

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

case "numgumptextentry": return SetIndexedGumpValue(Arg(0), "textentry", Arg(1), Text(2));

UO.SelectGump

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

C# 시그니처

void UO.SelectGump(object? id);

후속 호출을 위해 기존 서버 Gump를 선택합니다.

매개변수

id - int: LocalSerial 또는 ServerSerial를 먼저 일치시킨 다음 현재 검프 목록에서 인덱스 0을 찾습니다. ID 버튼이 아닙니다.

반환값

void - 값이 없습니다. 별도의 회선으로 전화하세요. 완료는 서버의 작업을 확인하지 않습니다.

동작

Bridge.SelectGump는 _selectedServerGump를 저장합니다. serial이 일치하지 않으면 0..count-1 인덱스를 사용합니다. 찾을 수 없음 - 선택한 검프가 null가 되고 메시지가 표시됩니다.
Gump가 열리지 않고 서버에 응답이 전송되지 않습니다. 창이 열리거나 닫힐 때 인덱스가 변경됩니다. 안정적인 선택을 위해 현재 serial/id를 사용하세요.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.SelectGump");
UO.SelectGump(0);

1. 직접 통화 - 직접 스크립트

매개변수와 실행 흐름:

후속 호출을 위해 기존 서버 Gump를 선택합니다.

if (Truth(UO.GumpExists(0)))
{
    UO.SelectGump(0);
}

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

2. 명시적 옵션 - 스크립트 기능

매개변수와 실행 흐름:

Bridge.SelectGump는 _selectedServerGump를 저장합니다. serial이 일치하지 않으면 0..count-1 인덱스를 사용합니다. 찾을 수 없음 - 선택한 검프가 null가 되고 메시지가 표시됩니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        var serial = UO.GetGumpSerial(0);
        UO.SelectGump(serial);
    }

    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. 전체 도우미 기능 - 스크립트 클래스

매개변수와 실행 흐름:

Gump가 열리지 않고 서버에 응답이 전송되지 않습니다. 창이 열리거나 닫힐 때 인덱스가 변경됩니다. 안정적인 선택을 위해 현재 serial/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(UO.GetGumpsCount() > 0))
        {
            UO.SelectGump(0);
            UO.Print(UO.LastGump("gumpid"));
        }

        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.SelectGump(id)` — `UO.SelectGump(Any)`

매개변수: id (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.SelectGump.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SelectGump: bridge.SelectGump(NumberConversions.ToInt(id)).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(id).

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

public void SelectGump(InjectionValue id) => bridge.SelectGump(NumberConversions.ToInt(id));

UO.SendGumpSelect

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

C# 시그니처

int UO.SendGumpSelect(object? triggerId);
int UO.SendGumpSelect(object? gumpIndex, object? triggerId);
int UO.SendGumpSelect(object? serial, object? gumpId, object? triggerId);
int UO.SendGumpSelect(object? serial, object? gumpId, object? triggerId, object? timeout);

선택한 서버 Gump의 ButtonID를 보냅니다.

매개변수

triggerId - int 또는 숫자 문자열 - 서버 ButtonID. 0는 일반적으로 닫기/거부를 의미하지만 정확한 동작은 서버에 의해 결정됩니다. 트리에 표시되는 ButtonID는 필요하지 않습니다.
gumpIndex — 필수 int — 0부터 GetGumpsCount()-1까지 활성 서버 검프의 인덱스입니다. GumpID/serial이 아닙니다. 목록 외부의 음수와 인덱스는 유효하지 않습니다. 창을 열고 닫고 재정렬하면 색인이 변경될 수 있습니다. 행동하기 전에 GetGumpID/GetGumpSerial를 확인하세요. 두 개의 인수 형식(gumpIndex, triggerId)에서만 사용됩니다.
serial — 3/4 인수 형식에서 숫자 32비트 serial가 사용됩니다. 0 또는 -1는 필터 serial를 비활성화합니다. 최상위 비트의 음수를 포함한 나머지 숫자는 정확하게 비교됩니다.
gumpId — 3/4 인수 형식에서 숫자 32 비트 GumpID입니다. 0 또는 -1는 GumpID 필터를 비활성화합니다. 16진수 문자열이 허용됩니다. 여기에는 이름 AddObject이 허용되지 않습니다.
timeout — 선택적인 네 번째 인수, int 일치하는 ID 쌍을 기다리는 데 걸리는 시간(밀리초)입니다. 기본적으로 0는 즉각적인 시도 1회입니다. 부정은 0로 제한됩니다. 간격 20ms를 다시 확인하세요.

반환값

int — 1, 라이브 서버 Gump가 발견되고 응답이 호출되는 경우; 0 시간 초과가 만료되기 전에 창을 찾지 못한 경우. 선택한 ID를 반환하지 않으며 서버가 결과를 확인할 때까지 기다리지 않습니다.

동작

활성 서버 검프와 함께 작동합니다. 배낭, 지도, 설정 및 기타 로컬 창은 이 목록에 포함되지 않습니다. 한 번의 호출은 게임 스레드의 데이터를 읽습니다. 통화마다 목록의 상태가 다를 수 있습니다.
한 인수는 이 스크립트에서 이전에 선택한 검프를 선택합니다. 닫혀 있거나 선택되지 않은 경우 - 현재 목록의 마지막 요소입니다. 두 개의 인수가 엄격한 인덱스를 지정합니다. 3/4 - 필터가 있는 ID 쌍.
응답 선택 및 호출은 하나의 게임 스레드 요청에서 발생합니다. 절차를 중지하면 대기가 취소됩니다. 직접적인 서버 응답과 페이지 변경을 혼동하지 마십시오. SwitchPage 버튼에는 NumGumpButton이 필요합니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

한 번의 호출 결과를 저널에 표시합니다. 숫자를 bool로 변환하지 않으며, 배열이면 요소 수를 표시합니다.

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

1. 선택한 창에 답장 - 직접 스크립트

매개변수와 실행 흐름:

SelectGump 유형/serial 0x12345678을 선택하거나 부재를 신고합니다. 100 - 버튼ID.
더 이상 선택된 창이 없으면 단일 인수 형식은 사용 가능한 마지막 창을 사용합니다. 엄격한 신원 확인을 위해 ID 두 개가 포함된 양식을 사용하세요.

UO.SelectGump(0x12345678);
var sent = UO.SendGumpSelect(100);
UO.Print(Convert.ToString(sent));

2. 첫 번째 목록 항목에 응답 - 스크립트 기능

매개변수와 실행 흐름:

0 — 인덱스, 100 — 버튼ID. 이것은 serial=0도 아니고 GumpID=100도 아닙니다.

return  RunScenario();
 object? RunScenario()
{
    var sent = UO.SendGumpSelect(0, 100);
    if (Truth(sent == 0))
    {
        UO.Print("No gump at index zero");
    }

    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. 스냅샷에서 창에 구체적으로 응답 - 스크립트 클래스

매개변수와 실행 흐름:

info[0] - serial, info[1] - GumpID, 100 - ButtonID. 인덱스를 변경해도 응답이 다른 유형/소유자로 리디렉션되지 않습니다.
Serial/GumpID 값 0/-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 info = UO.GetGumpInfo(0);
        if (Truth(ArrayLength(info) == 5))
        {
            var sent = UO.SendGumpSelect(info[0], info[1], 100);
        }

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

4. 특정 유형을 기대합니다 - 직접 스크립트

매개변수와 실행 흐름:

0 필터 serial를 비활성화합니다. 0x87654321 — 최상위 비트가 있는 정확한 ID; 100 — 버튼; 2000 — 최대 대기 시간(ms) 무조건적인 와일드카드로 사용되지 않습니다.

var sent = UO.SendGumpSelect(0, 0x87654321, 100, 2000);
UO.Print(Convert.ToString(sent));

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.SendGumpSelect(triggerId)` — `UO.SendGumpSelect(Integer)`

매개변수: triggerId (Integer/String)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.SendGumpSelect.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SendGumpSelect: bridge.SendGumpSelect(triggerId).

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

public int SendGumpSelect(int triggerId) => bridge.SendGumpSelect(triggerId);

`UO.SendGumpSelect(triggerId)` — `UO.SendGumpSelect(String)`

매개변수: triggerId (Integer/String)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.SendGumpSelect.
InjectionScript.Runtime.InjectionApiUO.SendGumpSelect: SendGumpSelect(NumberConversions.ToInt(triggerId)).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(triggerId).

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

public int SendGumpSelect(string triggerId) => SendGumpSelect(NumberConversions.ToInt(triggerId));

`UO.SendGumpSelect(gumpIndex, triggerId)` — `UO.SendGumpSelect(Any,Any)`

매개변수: gumpIndex (Any), triggerId (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.SendGumpSelect.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SendGumpSelect: bridge.SendGumpSelect(NumberConversions.ToInt(gumpIndex), NumberConversions.ToInt(triggerId)).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(gumpIndex).

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

public int SendGumpSelect(InjectionValue gumpIndex, InjectionValue triggerId)

            => bridge.SendGumpSelect(NumberConversions.ToInt(gumpIndex), NumberConversions.ToInt(triggerId));

`UO.SendGumpSelect(serial, gumpId, triggerId)` — `UO.SendGumpSelect(Any,Any,Any)`

매개변수: serial (Any), gumpId (Any), triggerId (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.SendGumpSelect.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SendGumpSelect: bridge.SendGumpSelect(NumberConversions.ToInt(serial), NumberConversions.ToInt(gumpId), NumberConversions.ToInt(triggerId)).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(serial).

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

public int SendGumpSelect(InjectionValue serial, InjectionValue gumpId, InjectionValue triggerId)

            => bridge.SendGumpSelect(NumberConversions.ToInt(serial), NumberConversions.ToInt(gumpId), NumberConversions.ToInt(triggerId));

`UO.SendGumpSelect(serial, gumpId, triggerId, timeout)` — `UO.SendGumpSelect(Any,Any,Any,Any)`

매개변수: serial (Any), gumpId (Any), triggerId (Any), timeout (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.SendGumpSelect.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SendGumpSelect: bridge.SendGumpSelect(NumberConversions.ToInt(serial), NumberConversions.ToInt(gumpId), NumberConversions.ToInt(triggerId), Math.Max(0, NumberConversions.ToInt(timeout))).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(serial).

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

public int SendGumpSelect(InjectionValue serial, InjectionValue gumpId, InjectionValue triggerId, InjectionValue timeout)

            => bridge.SendGumpSelect(NumberConversions.ToInt(serial), NumberConversions.ToInt(gumpId),

                NumberConversions.ToInt(triggerId), Math.Max(0, NumberConversions.ToInt(timeout)));

UO.SetGump

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

C# 시그니처

void UO.SetGump(object? identifier, object? key, object? stateValue);
void UO.SetGump(object? gumpId, object? identifier, object? key, object? stateValue);

기존 서버 검프의 필드를 변경합니다.

매개변수

gumpId - 4개의 인수 형식만 해당: serial/id 또는 0 검프 인덱스. 세 가지 용도로 사용되는 형태 -1 - 선택/마지막 검프.
identifier — 문자열 "checkbox", "radio" 또는 "textentry", 대소문자는 중요하지 않습니다. 지원되지 않는 이름은 필드를 변경하지 않습니다.
key - int: 먼저 LocalSerial/ID 요소, 그 다음에는 지정된 종류의 요소 중 인덱스가 0입니다. 요소 없음 - 오류 메시지입니다.
stateValue — 체크박스/라디오의 경우: "checked", "true" 대소문자를 구분하지 않거나 0이 아닌 인식된 int 포함; 다른 하나는 꺼집니다. 텍스트 입력의 경우 - ToString까지의 모든 텍스트입니다.

반환값

void - 값이 없습니다. 별도의 회선으로 전화하세요. 완료는 서버의 작업을 확인하지 않습니다.

동작

SetGumpValue 전화 TrySetGumpValue; 0를 사용하면 메시지가 표시됩니다. 이미 존재하는 Gump의 로컬 필드를 변경하고 새 창을 기다리는 후크를 등록하지 않습니다.
체크박스/텍스트 항목을 변경해도 서버 자체에 응답이 전송되지 않습니다. 전화를 받으려면 SendGumpSelect/WaitGump 버튼을 선택하세요. 라디오 버튼은 별도의 보기에서 처리됩니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.SetGump");
UO.SetGump("checkbox", 0, 1);

1. 직접 통화 - 직접 스크립트

매개변수와 실행 흐름:

기존 서버 검프의 필드를 변경합니다.

if (Truth(UO.GetGumpsCount() > 0))
{
    UO.SetGump("checkbox", 0, 1);
}

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

2. 명시적 옵션 - 스크립트 기능

매개변수와 실행 흐름:

SetGumpValue 전화 TrySetGumpValue; 0를 사용하면 메시지가 표시됩니다. 이미 존재하는 Gump의 로컬 필드를 변경하고 새 창을 기다리는 후크를 등록하지 않습니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.SetGump(0, "textentry", 0, "Example");
    }

    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. 전체 도우미 기능 - 스크립트 클래스

매개변수와 실행 흐름:

체크박스/텍스트 항목을 변경해도 서버 자체에 응답이 전송되지 않습니다. 전화를 받으려면 SendGumpSelect/WaitGump 버튼을 선택하세요. 라디오 버튼은 별도의 보기에서 처리됩니다.

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(UO.GetGumpsCount() > 0))
        {
            UO.SetGump("radio", 0, "true");
            UO.SetGump("checkbox", 0, 0);
        }

        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.SetGump(identifier, key, stateValue)` — `UO.SetGump(Any,Any,Any)`

매개변수: identifier (Any), key (Any), stateValue (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.SetGump.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetGumpValue: bridge.SetGumpValue(-1, identifier.ToString(), NumberConversions.ToInt(key), stateValue.ToString()).
InjectionScript.Runtime.InjectionValue.ToString: identifier.ToString().
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(key).

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

public void SetGump(InjectionValue identifier, InjectionValue key, InjectionValue stateValue)

            => bridge.SetGumpValue(-1, identifier.ToString(), NumberConversions.ToInt(key), stateValue.ToString());

`UO.SetGump(gumpId, identifier, key, stateValue)` — `UO.SetGump(Any,Any,Any,Any)`

매개변수: gumpId (Any), identifier (Any), key (Any), stateValue (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.SetGump.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetGumpValue: bridge.SetGumpValue(NumberConversions.ToInt(gumpId), identifier.ToString(), NumberConversions.ToInt(key), stateValue.ToString()).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(gumpId).
InjectionScript.Runtime.InjectionValue.ToString: identifier.ToString().

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

public void SetGump(InjectionValue gumpId, InjectionValue identifier, InjectionValue key, InjectionValue stateValue)

            => bridge.SetGumpValue(NumberConversions.ToInt(gumpId), identifier.ToString(), NumberConversions.ToInt(key), stateValue.ToString());

UO.WaitGump

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

C# 시그니처

void UO.WaitGump(object? value);
void UO.WaitGump(object? trigger1, object? trigger2);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13, object? trigger14);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13, object? trigger14, object? trigger15);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13, object? trigger14, object? trigger15, object? trigger16);

버튼에 대한 일련의 일회성 응답을 등록합니다. 스크립트는 즉시 계속 실행됩니다. 창이 없어도 30초 지연이 발생하지 않습니다.

매개변수

value — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger1 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger2 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger3 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger4 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger5 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger6 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger7 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger8 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger9 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger10 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger11 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger12 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger13 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger14 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger15 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.
trigger16 — 시퀀스 요소: int ButtonID, 숫자 string, |/쉼표가 있는 문자열 또는 이러한 요소의 배열. 순서는 왼쪽에서 오른쪽입니다. 일반적인 경계 및 규칙 triggerId이 적용됩니다. 값은 배열도 허용하는 object? 형식의 유일한 매개변수 이름입니다.

반환값

void - 아무것도 반환하지 않습니다. 성공도, 새 값도, 서버 확인도 반환되지 않습니다.

동작

원하는 ButtonID가 있는 실제 활성화 버튼을 찾습니다. 필수 버튼이 없는 페이지 및 창 전환 버튼은 건너뜁니다. 후속 ID는 첫 번째 대기를 우회하지 않습니다. 하나의 마크업 전달의 경우 - 하나의 창에 하나 이상의 응답이 없습니다. 업데이트된 마크업은 동일한 창 개체를 사용할 수 있습니다.
동일한 스크립트의 다음 WaitGump는 보류 중인 시퀀스를 완료합니다. 검색은 GumpID에만 국한되지 않습니다. 정확한 선택을 위해 NumGumpButton 또는 SendGumpSelect를 사용하세요. ButtonID=0는 ID 0의 기존 활성화 버튼이 있는 경우에만 작동합니다. 이는 보편적인 폐쇄가 아닙니다.
절차가 정상적으로 완료되면 대기 시간이 절약됩니다. 소유자를 취소하거나 그의 이름으로 Terminate을 입력하면 대기 시간이 제거됩니다. TerminateAll는 절차 완료 후 남은 내용을 포함하여 모든 내용을 삭제합니다. 세상을 바꾸면 대기열이 지워집니다. 기대치는 프로필에 저장되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.WaitGump");
UO.WaitGump(100);

1. 하나의 답변 - 직접 스크립트

매개변수와 실행 흐름:

100 — 응답의 ButtonID입니다. WaitGump는 UseObject 이전에 등록합니다. 추가 실행이 서버가 이미 응답을 수락했다는 의미는 아닙니다.

UO.WaitGump(100);
UO.UseObject("0x40001234");

2. 여러 단계 - 스크립트 기능

매개변수와 실행 흐름:

7, 22 및 1는 순차 형식의 ButtonID입니다. ID는 순서대로 확인됩니다. 인수 수는 지연을 지정하지 않습니다. 호출은 전체 시퀀스를 기록합니다.

return  RunScenario();
 object? RunScenario()
{
    UO.WaitGump(7, 22, 1);
    UO.UseObject("0x40001234");
    return null;
}

3. 기대 취소 - 스크립트 클래스

매개변수와 실행 흐름:

7|22|1 줄은 동일한 순서를 지정합니다. 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()
    {
        UO.WaitGump("7|22|1");
        UO.TerminateAll();
        return null;
    }
}

명령 구현

C#은 대소문자를 구분합니다. 정확한 UO 이름을 사용하세요. 숫자 플래그는 0과 비교하고 반환 형식이 bool일 때만 bool을 사용하세요.

`UO.WaitGump(value)` — `UO.WaitGump(Any)`

매개변수: value (Any/Integer/String)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(arguments).

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

case "waitgump": CompactWaitGump(arguments); return InjectionValue.Unit;

`UO.WaitGump(value)` — `UO.WaitGump(Integer)`

매개변수: value (Any/Integer/String)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.WaitGump.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitGumpSelect: bridge.WaitGumpSelect(triggerId, 30_000).

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

public void WaitGump(int triggerId)

        {

            if (bridge is IApiGumpAutomation automation) automation.QueueGumpButtons(new[] { triggerId });

            else bridge.WaitGumpSelect(triggerId, 30_000);

        }

`UO.WaitGump(value)` — `UO.WaitGump(String)`

매개변수: value (Any/Integer/String)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.WaitGump.
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(chain).
InjectionScript.Runtime.InjectionApiUO.WaitGump: WaitGump(NumberConversions.ToInt(triggerId)).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(triggerId).

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

public void WaitGump(string triggerId)

        {

            string text = (triggerId ?? string.Empty).Trim();

            if (text.Contains('|') || text.Contains(','))

            {

                InjectionValue[] chain = text.Split(new[] { '|', ',' }, StringSplitOptions.RemoveEmptyEntries)

                    .Select(value => new InjectionValue(value.Trim())).ToArray();

                CompactWaitGump(chain);

                return;

            }

            WaitGump(NumberConversions.ToInt(triggerId));

        }

`UO.WaitGump(trigger1, trigger2)` — `UO.WaitGump(Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3)` — `UO.WaitGump(Any,Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any), trigger3 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4)` — `UO.WaitGump(Any,Any,Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5)` — `UO.WaitGump(Any,Any,Any,Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

매개변수: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13, trigger14)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13, trigger14, trigger15)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

`UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13, trigger14, trigger15, trigger16)` — `UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [WaitGump].
InjectionScript.Runtime.InjectionApiUO.CompactWaitGump: CompactWaitGump(values).

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGumpCheck

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

C# 시그니처

void UO.WaitGumpCheck(object? index, object? state);
void UO.WaitGumpCheck(object? index, object? state, object? index2, object? state2);
void UO.WaitGumpCheck(object? index, object? state, object? index2, object? state2, object? index3, object? state3);

현재 검프의 체크박스 필드를 최대 3개까지 변경합니다.

매개변수

index — int ID 요소 또는 SetGump와 같은 0 인덱스입니다. 인수는 선택자, 값 쌍으로 제공됩니다.
index2 — int ID 요소 또는 SetGump와 같은 0 인덱스입니다. 인수는 선택자, 값 쌍으로 제공됩니다.
index3 — int ID 요소 또는 SetGump와 같은 0 인덱스입니다. 인수는 선택자, 값 쌍으로 제공됩니다.
state — ToString까지의 필드 값입니다. 확인란에는 "선택됨"/"true"/0이 아닌 숫자가 포함됩니다. textentry는 텍스트를 허용합니다.
state2 — ToString까지의 필드 값입니다. 확인란에는 "선택됨"/"true"/0이 아닌 숫자가 포함됩니다. textentry는 텍스트를 허용합니다.
state3 — ToString까지의 필드 값입니다. 확인란에는 "선택됨"/"true"/0이 아닌 숫자가 포함됩니다. textentry는 텍스트를 허용합니다.

반환값

void - 값이 없습니다. 별도의 회선으로 전화하세요. 완료는 서버의 작업을 확인하지 않습니다.

동작

ExecuteLegacyManualAlias는 쌍으로 인수를 검토하고 각 인수에 대해 SetGumpValue(-1, "checkbox", selector, value)를 호출합니다. 등록된 모든 양식은 2, 4 또는 6 인수입니다.
UO.Wait라는 이름은 대기를 의미하지 않습니다. 차단도 없고 향후 검프를 위한 대기열도 없습니다. 필드가 누락되면 오류가 표시됩니다. 버튼 응답이 전송되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.WaitGumpCheck");
UO.WaitGumpCheck(0, 1);

1. 직접 통화 - 직접 스크립트

매개변수와 실행 흐름:

현재 검프의 체크박스 필드를 최대 3개까지 변경합니다.

if (Truth(UO.GetGumpsCount() > 0))
{
    UO.WaitGumpCheck(0, 1);
}

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

2. 명시적 옵션 - 스크립트 기능

매개변수와 실행 흐름:

ExecuteLegacyManualAlias는 쌍으로 인수를 검토하고 각 인수에 대해 SetGumpValue(-1, "checkbox", selector, value)를 호출합니다. 등록된 모든 양식은 2, 4 또는 6 인수입니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.WaitGumpCheck(0, 1, 1, 0);
    }

    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. 전체 도우미 기능 - 스크립트 클래스

매개변수와 실행 흐름:

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()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.WaitGumpCheck(0, 1, 1, 0, 2, 1);
        }

        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.WaitGumpCheck(index, state)` — `UO.WaitGumpCheck(Any,Any)`

매개변수: index (Any), state (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetGumpValue: bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(index).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(index + 1).

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

case "waitgumpcheck":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1));

                    break;

`UO.WaitGumpCheck(index, state, index2, state2)` — `UO.WaitGumpCheck(Any,Any,Any,Any)`

매개변수: index (Any), state (Any), index2 (Any), state2 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetGumpValue: bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(index).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(index + 1).

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

case "waitgumpcheck":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1));

                    break;

`UO.WaitGumpCheck(index, state, index2, state2, index3, state3)` — `UO.WaitGumpCheck(Any,Any,Any,Any,Any,Any)`

매개변수: index (Any), state (Any), index2 (Any), state2 (Any), index3 (Any), state3 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetGumpValue: bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(index).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(index + 1).

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

case "waitgumpcheck":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpEntry

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

C# 시그니처

void UO.WaitGumpEntry(object? index, object? text);
void UO.WaitGumpEntry(object? index, object? text, object? index2, object? text2);
void UO.WaitGumpEntry(object? index, object? text, object? index2, object? text2, object? index3, object? text3);

현재 검프의 텍스트 입력 필드를 최대 3개까지 변경합니다.

매개변수

index — int ID 요소 또는 SetGump와 같은 0 인덱스입니다. 인수는 선택자, 값 쌍으로 제공됩니다.
index2 — int ID 요소 또는 SetGump와 같은 0 인덱스입니다. 인수는 선택자, 값 쌍으로 제공됩니다.
index3 — int ID 요소 또는 SetGump와 같은 0 인덱스입니다. 인수는 선택자, 값 쌍으로 제공됩니다.
text — ToString까지의 필드 값입니다. 확인란에는 "선택됨"/"true"/0이 아닌 숫자가 포함됩니다. textentry는 텍스트를 허용합니다.
text2 — ToString까지의 필드 값입니다. 확인란에는 "선택됨"/"true"/0이 아닌 숫자가 포함됩니다. textentry는 텍스트를 허용합니다.
text3 — ToString까지의 필드 값입니다. 확인란에는 "선택됨"/"true"/0이 아닌 숫자가 포함됩니다. textentry는 텍스트를 허용합니다.

반환값

void - 값이 없습니다. 별도의 회선으로 전화하세요. 완료는 서버의 작업을 확인하지 않습니다.

동작

ExecuteLegacyManualAlias는 쌍으로 인수를 검토하고 각각에 대해 SetGumpValue(-1, "textentry", selector, value)를 호출합니다. 등록된 모든 양식은 2, 4 또는 6 인수입니다.
UO.Wait라는 이름은 대기를 의미하지 않습니다. 차단도 없고 향후 검프를 위한 대기열도 없습니다. 필드가 누락되면 오류가 표시됩니다. 버튼 응답이 전송되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

이 코드를 별도의 .csx 파일로 실행하세요. 인수는 호출에 직접 표시됩니다. 예제의 이름, serial, 주소를 자신의 값으로 바꾸세요.

명령은 독립된 문입니다. 앞의 메시지는 호출 시작을 나타내며 서버 동작의 완료를 확인하지 않습니다.

UO.Print("Calling UO.WaitGumpEntry");
UO.WaitGumpEntry(0, "Example");

1. 직접 통화 - 직접 스크립트

매개변수와 실행 흐름:

현재 검프의 텍스트 입력 필드를 최대 3개까지 변경합니다.

if (Truth(UO.GetGumpsCount() > 0))
{
    UO.WaitGumpEntry(0, "Example");
}

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

2. 명시적 옵션 - 스크립트 기능

매개변수와 실행 흐름:

ExecuteLegacyManualAlias는 쌍으로 인수를 검토하고 각각에 대해 SetGumpValue(-1, "textentry", selector, value)를 호출합니다. 등록된 모든 양식은 2, 4 또는 6 인수입니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.WaitGumpEntry(0, "First", 1, "Second");
    }

    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. 전체 도우미 기능 - 스크립트 클래스

매개변수와 실행 흐름:

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()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.WaitGumpEntry(0, "First", 1, "Second", 2, "Third");
        }

        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.WaitGumpEntry(index, text)` — `UO.WaitGumpEntry(Any,Any)`

매개변수: index (Any), text (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetGumpValue: bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(index).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(index + 1).

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

case "waitgumpentry":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1));

                    break;

`UO.WaitGumpEntry(index, text, index2, text2)` — `UO.WaitGumpEntry(Any,Any,Any,Any)`

매개변수: index (Any), text (Any), index2 (Any), text2 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetGumpValue: bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(index).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(index + 1).

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

case "waitgumpentry":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1));

                    break;

`UO.WaitGumpEntry(index, text, index2, text2, index3, text3)` — `UO.WaitGumpEntry(Any,Any,Any,Any,Any,Any)`

매개변수: index (Any), text (Any), index2 (Any), text2 (Any), index3 (Any), text3 (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetGumpValue: bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(index).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(index + 1).

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

case "waitgumpentry":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1));

                    break;

KO UO Topic gumps - LIHACHTETAN/ClassicUO-Bad-Newbie-CSharp-Scripts-IDE GitHub Wiki

Gump 창

섹션

모든 테마 명령

검프 정보

응답

Ignore / 닫기

주제에 대한 예

UO.GetGumpInfo

UO.WaitGump

전체 명령 참조

UO.AddGumpIgnoreByID

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. UO.GetGumpInfo 결과에서 ID 123로 검프를 제거합니다. - 직접 스크립트

2. 예외를 발생시키기 전에 ID를 변수에 저장하세요. - 스크립트 기능

3. ID를 추가하세요. 각 예외는 GetGumpInfo에 영향을 미칩니다. - 스크립트 클래스

명령 구현

UO.AddGumpIgnoreByID(id) — UO.AddGumpIgnoreByID(Any)

UO.AddGumpIgnoreBySerial

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. 결과 UO.GetGumpInfo에서 serial 1073741824로 검프를 제거합니다. - 직접 스크립트

2. 변수에서 serial를 전달합니다. - 스크립트 기능

3. GetGumpInfo 출력에서 ​​두 개의 serial 덩어리를 제거합니다. - 스크립트 클래스

명령 구현

UO.AddGumpIgnoreBySerial(serial) — UO.AddGumpIgnoreBySerial(Any)

UO.CancelGump

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. 마지막 검프 닫기 - 직접 스크립트

2. 알려진 ID로 검프를 닫습니다 - 스크립트 기능

3. 명시적 마지막 인덱스 - 스크립트 클래스

명령 구현

UO.CancelGump() — UO.CancelGump()

UO.CancelGump(gumpId) — UO.CancelGump(Any)

UO.ClearGumpsIgnore

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. 상태 지우기 - 직접 스크립트

2. 설정 후 지우기 - 스크립트 기능

3. 재제거 - 스크립트 클래스

명령 구현

UO.ClearGumpsIgnore() — UO.ClearGumpsIgnore()

UO.CloseClientGump

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. ID로 첫 번째 검프를 닫습니다 - 직접 스크립트

2. 변수의 ID - 스크립트 기능

3. Reclose - 스크립트 클래스

명령 구현

UO.CloseClientGump(id) — UO.CloseClientGump(Any)

UO.GetGump

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. 선택한 창의 ID 읽기 - 직접 스크립트

`UO.AddGumpIgnoreByID(id)` — `UO.AddGumpIgnoreByID(Any)`

3. GetGumpInfo 출력에서 두 개의 serial 덩어리를 제거합니다. - 스크립트 클래스

`UO.AddGumpIgnoreBySerial(serial)` — `UO.AddGumpIgnoreBySerial(Any)`

`UO.CancelGump()` — `UO.CancelGump()`

`UO.CancelGump(gumpId)` — `UO.CancelGump(Any)`

`UO.ClearGumpsIgnore()` — `UO.ClearGumpsIgnore()`

`UO.CloseClientGump(id)` — `UO.CloseClientGump(Any)`

`UO.GetGump(identifier)` — `UO.GetGump(String)`

`UO.GetGump(gumpId, identifier)` — `UO.GetGump(Integer,String)`

`UO.GetGump(gumpId, identifier)` — `UO.GetGump(String,Integer)`

`UO.GetGump(gumpId, identifier, key)` — `UO.GetGump(Integer,String,Integer)`

`UO.GetGumpButtonsDescription(gumpIndex)` — `UO.GetGumpButtonsDescription(Any)`

`UO.GetGumpCount()` — `UO.GetGumpCount()`

`UO.GetGumpFullLines(gumpIndex)` — `UO.GetGumpFullLines(Any)`

`UO.GetGumpID(gumpIndex)` — `UO.GetGumpID(Any)`

`UO.GetGumpInfo(gumpIndex)` — `UO.GetGumpInfo(Any)`