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

아이템

객체의 속성, 사용 및 전송. 시리얼은 특정 항목을 선택합니다. type/graphic 보기를 선택합니다. 스택 단위의 전송과 전송된 항목 수는 서로 다른 매개변수를 갖습니다.

섹션

주제	명령 및 설명
Item Properties	UO.GetSerial · UO.GetType · UO.GetGraphic · UO.GetColor · UO.GetQuantity · UO.GetName · UO.GetTooltip · UO.ContainerOf · UO.GetParent · UO.GetLayer · UO.IsMovable · UO.GetX · UO.GetY · UO.GetZ
아이템 찾기	UO.FindType · UO.FindTypeEx · UO.FindTypesArrayEx · UO.FindItem · UO.FindAnyType · UO.FindAtCoord · UO.FindList · UO.FindDistance · UO.FindVertical
아이템 사용	UO.UseObject · UO.UseType · UO.UseFromGround · UO.UseWorldObject · UO.UseItemOnMobile
Moving 아이템	UO.Grab · UO.Drag · UO.Drop · UO.MoveItem · UO.MoveItems · UO.MassMove · UO.EmptyContainer
Ground 아이템	UO.GetWorldItems · UO.FindType · UO.CountGround · UO.MoveItem
컨테이너 품목	UO.GetContent · UO.FindTypeEx · UO.OpenContainer
가짜/클라이언트 품목	UO.MakeFakeItem · UO.DeleteObject
Dye	UO.Dye

모든 테마 명령

주제에 대한 예

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

UO.MoveItem

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

var ok = UO.MoveItem("loot");
UO.Print("Move request: " + Convert.ToString(ok));

UO.MassMove

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

UO.MassMove(350, 0);
UO.Print("Drag one sample item to the destination container");

참조 구성

1 · 2

전체 명령 참조

UO.AddObject

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

C# 시그니처

void UO.AddObject(object? name);
void UO.AddObject(object? name, object? objectRawId);

나중에 스크립트에서 사용할 수 있도록 명명된 serial 개체를 저장합니다. 두 개의 인수 형식은 개체를 즉시 지정합니다. 단일 인수는 커서로 개체를 선택하도록 트리거합니다.

매개변수

name는 런타임에 객체를 사용할 수 있는 비어 있지 않은 이름입니다.
objectRawId - serial 또는 이미 저장된 개체 이름입니다. 단일 인수 오버로드는 이 매개 변수를 허용하지 않지만 대신 개체 선택을 요청합니다.

반환값

void. 이름별로 개체를 읽어서 저장된 바인딩을 확인하세요. 호출이 serial로 반환되지 않습니다.

동작

두 개의 인수가 주어지면 런타임은 objectRawId를 확인하고 serial를 name 아래에 저장합니다. 하나의 인수를 사용하여 클라이언트는 개체 선택을 요청합니다. 즉, 항목 또는 mobile이 선택되지만 카드 셀은 선택되지 않습니다. 선택하기 전에 동일한 이름의 이전 바인딩이 삭제됩니다. 커서를 취소하거나 잃어도 커서가 복원되지 않습니다.

독립 실행 C# 스크립트

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

간단한 예제

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

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

UO.Print("Calling UO.AddObject");
UO.AddObject("target");

1. 알려진 항목의 serial를 편리한 이름으로 저장하세요. - 직접 스크립트

매개변수와 실행 흐름:

알려진 항목의 serial를 편리한 이름으로 저장하세요.

UO.AddObject("supplyBox", "0x40012345");

2. 항목 선택을 요청하거나 커서로 mobile를 누르고 대상 이름을 지정합니다. - 스크립트 기능

매개변수와 실행 흐름:

항목 선택을 요청하거나 커서로 mobile를 누르고 대상 이름을 지정합니다.

return  RunScenario();
 object? RunScenario()
{
    UO.AddObject("target");
    return null;
}

3. 이름을 다시 저장하면 바인딩이 새 serial로 대체됩니다. - 스크립트 클래스

매개변수와 실행 흐름:

이름을 다시 저장하면 바인딩이 새 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()
    {
        var selectedSerial = "0x40012345";
        UO.AddObject("supplyBox", selectedSerial);
        return null;
    }
}

명령 구현

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

`UO.AddObject(name)` — `UO.AddObject(String)`

매개변수: name (String)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.AddObject.
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"What is {name}").
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.AddObject: bridge.AddObject(name).

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

public void AddObject(string name)

        {

            SystemMessage($"What is {name}");

            bridge.AddObject(name);

        }

`UO.AddObject(name, objectRawId)` — `UO.AddObject(Any,Any)`

매개변수: name (Any), objectRawId (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.AddObject.
InjectionScript.Runtime.InjectionApiUO.ObjectChecked: ObjectChecked(objectRawId, id => AddObject((string)name, id)).
InjectionScript.Runtime.InjectionApiUO.AddObject: AddObject((string)name, id).

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

public void AddObject(InjectionValue name, InjectionValue objectRawId) 

            => ObjectChecked(objectRawId, id => AddObject((string)name, id));

UO.AddType

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

C# 시그니처

void UO.AddType(object? name);
void UO.AddType(object? name, object? @type);

항목 또는 본문 그래픽 유형 mobile에 대한 친숙한 이름을 저장합니다. 예를 들어, UO.AddType("bandage", 0x0E21) 뒤에는 각 줄에 숫자 type를 반복하지 않고도 "bandage"라는 이름을 통해 bandages를 검색하거나 사용할 수 있습니다. 이는 이름 설정 → 그래픽 매핑이며, 항목을 생성하거나 특정 항목을 기억하는 것이 아닙니다(ID).

매개변수

name - 따옴표로 묶인 필수 문자열 - 유형 이름. 가장자리 공간은 제거되며 대소문자는 중요하지 않습니다. "Bandage"와 "bandage"는 하나의 항목입니다. 빈 문자열, 숫자 이름, 임의의 단어, 문자 | 및 제어 문자는 금지됩니다. 이는 새 변수나 UO 명령이 아닌 매개변수 값입니다. 후속 호출에도 따옴표가 필요합니다.
type - 선택 사항 int 0..65535: 그래픽/type(예: 0x0E21 또는 3617). 10진수/16진수 숫자 또는 이미 저장된 유형의 이름이 포함된 문자열이 허용됩니다. 후자는 현재 번호를 복사하고 이름 간의 연결을 생성하지 않습니다. 0x40001001 형식의 ID, 음수, 분수 및 알 수 없는 이름은 허용되지 않습니다. 인수가 없으면 선택 커서가 나타납니다. 컨테이너 내부를 포함하여 로드된 항목을 클릭하거나 mobile를 클릭합니다. 선택한 개체의 그래픽이 저장됩니다. 지표면과 정적 타일은 적합하지 않습니다.

반환값

void - 반환 값이 없습니다. var 결과 = 및 true/1와의 비교 없이 별도의 줄에 작성합니다. 이 명령은 선택한 type, serial 또는 성공 플래그를 반환하지 않습니다. 마우스로 취소하면 이전 항목이 유지됩니다. 이전에 이름이 없으면 정의되지 않은 상태로 유지됩니다. 일반적인 취소 후에 스크립트의 다음 줄이 실행되므로 사용자가 확실히 새 항목을 선택했다고 가정하고 작업을 자동으로 트리거하지 마세요.

동작

AddType(name, type) 형식은 커서나 네트워크 작업 없이 즉시 번호를 저장합니다. 동일한 이름의 반복이 해당 유형을 대체합니다. 잘못된 값은 이전 항목을 파괴하지 않습니다. AddType(이름) 양식이 선택을 기다리고 있습니다. Esc, 커서를 다른 작업으로 바꾸거나 부적절한 대상으로 인해 항목이 변경되지 않고 그대로 유지됩니다. 스크립트를 강제로 중지하면 대기가 중단되고 해당 대기에 속한 커서만 해제됩니다.
유형 이름은 AddObject와 별도로 유지됩니다. 동일한 단어가 FindType에서는 type을, UseObject에서는 serial를 나타낼 수 있습니다. AddType("공급", 0x0E21) 자체만으로는 UseObject("공급")이 유효하지 않습니다. 특정 항목의 경우 AddObject/GetSerial를 사용하세요. 항목군 - AddType 및 매개변수 type.
이름은 매개변수 type FindType(모든 형식), FindTypeEx, FindTypesArrayEx, FindList, FindNotoriety, GetWorldItems, UseType, UseFromGround, Count, CountGround, CountEx, EquipT, WaitTargetType, WaitTargetGround 및 WaitTargetObjectType. GetMobiles/FindAnyType/WaitTarget 유형의 마스크에서는 |를 통해 이름을 결합할 수 있습니다. 또는 배열; 악명에 대한 규칙은 별도로 유지됩니다. 인간/가까운 단어 및 기타 FindMobile 필터는 재정의되지 않습니다.
그래픽만 저장되며 색상, 수량, 컨테이너, 항목 이름, 레이어 또는 속성은 저장되지 않습니다. 색상이 다른 동일한 유형의 두 항목은 검색 시 별도의 색상이 필요합니다. 항목은 항목이 현재 존재하는지, 사용 가능한지 또는 서버가 해당 작업을 허용하는지 확인하지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

UO.Print("Calling UO.AddType");
UO.AddType("my_tool");

1. 발견된 금 더미 하나 올리기 - 직접 스크립트

매개변수와 실행 흐름:

gold_stack - 이름; 0x0EED – 그래픽 골드. FindType: -1 - 모든 색상, ground - 지구, 2 - 검색 반경. 문자열 serial 또는 빈 문자열이 반환됩니다.
MoveItem는 발견된 serial, 전체 스택에 대한 0, 그리고 대상으로 backpack를 받습니다. 이것은 반경 내 모든 스택이 아닌 하나의 스택입니다. 전송 가능 여부와 실제 결과는 서버에 따라 다릅니다. 유형 정의 자체에는 아무것도 포함되지 않습니다.

UO.AddType("gold_stack", 0x0EED);
var item = UO.FindType("gold_stack", -1, "ground", 2);
if (Truth(item == ""))
{
    UO.Print("No loaded gold stack within 2 tiles");
    return null;
}
var moved = UO.MoveItem(item, 0, "backpack");
if (Truth(moved == 0))
{
    UO.Print("Move request failed");
}

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

2. 체력이 낮을 때만 붕대를 사용하세요 - 스크립트 기능

매개변수와 실행 흐름:

문자열 번호 0x0E21는 int Graphic로 저장됩니다. Life/MaxHP HP 문자를 비교합니다. FindType 배낭에서 반복적으로 색상을 검색합니다. -1 거리에서는 표준 검색 동작을 사용합니다.
self은 적용 목적이고, FindType 이후의 붕대는 serial로 변수입니다. 아이템을 사용하기 전에 대상의 대기열이 준비됩니다. 스크립트는 사용법을 보내고 처리가 이미 완료되었다고 주장하지 않습니다. 타이머/처리 규칙은 서버에 따라 다릅니다.

return  RunScenario();
 object? RunScenario()
{
    UO.AddType("bandage", "0x0E21");
    if (Truth(UO.Life() >= UO.MaxHP()))
    {
        return null;
    }

    var bandage = UO.FindType("bandage", -1, "backpack", -1, true);
    if (Truth(bandage == ""))
    {
        UO.Print("No loaded bandages in backpack");
        return null;
    }

    UO.WaitTargetObject("self");
    UO.UseObject(bandage);
    return null;
}

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

3. 도구를 마우스에 할당하고 별도의 절차로 적용 - 스크립트 클래스

매개변수와 실행 흐름:

Main에는 이름만 포함되어 있으므로 커서가 열립니다. 도구 유형은 ID 및 색상이 아닌 저장됩니다. UseSavedTool은 기본 제공 명령이 아닌 일반적인 독립 실행형 절차 C#입니다.
UseType 배낭에 저장된 모든 색상의 인스턴스를 검색하여 사용합니다. 누락된 경우 int serial 또는 0를 반환합니다. 이름이 정의되지 않은 경우 0의 결과가 아닌 인수 오류입니다. 할당 해제 후 Main은 UseSavedTool를 호출하지 않습니다.

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.AddType("my_tool");
        return null;
    }

    void UseSavedTool()
    {
        var used = UO.UseType("my_tool", -1, "backpack");
        if (Truth(used == 0))
        {
            UO.Print("No matching loaded tool in backpack");
        }
    }

    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.AddType(name)` — `UO.AddType(Any)`

매개변수: name (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.AddType: AddType(arguments).

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

case "addtype":

                    AddType(arguments);

                    break;

`UO.AddType(name, type)` — `UO.AddType(Any,Any)`

매개변수: name (Any), type (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.AddType: AddType(arguments).

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

case "addtype":

                    AddType(arguments);

                    break;

UO.ClickOnObject

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

C# 시그니처

void UO.ClickOnObject(object? objID);

GameActions.SingleClick를 통해 개체에 대한 단일 클릭을 보냅니다.

매개변수

objID — self/backpack/lasttarget/저장된 객체의 객체 일련번호 또는 지원되는 이름입니다. 숫자 문자열과 0x 문자열은 런타임에 의해 해결됩니다.

반환값

void - 반환 값이 없습니다.

동작

Click는 ObjectChecked를 통해 링크를 해결합니다. ClickOnObject는 먼저 serial에 Arg를 사용하고 Click(int)를 호출합니다. 이는 DoubleClick 또는 아이템 사용이 아닌 아이템의 서명/정보에 대한 요청입니다. 서버 응답은 비동기적으로 제공됩니다.

독립 실행 C# 스크립트

간단한 예제

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

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

UO.Print("Calling UO.ClickOnObject");
UO.ClickOnObject("self");

1. 캐릭터 클릭 - 직접 스크립트

매개변수와 실행 흐름:

한 번의 클릭은 self로 전송됩니다.

UO.ClickOnObject("self");

2. 마지막 대상 클릭 - 스크립트 기능

매개변수와 실행 흐름:

전송하기 전에 대상의 로컬 존재 여부를 확인합니다.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.LastTarget();
    if (Truth(UO.Exists(target)))
    {
        UO.ClickOnObject(target);
    }

    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. 그들은 배낭을 클릭할 것입니다 - 스크립트 클래스

매개변수와 실행 흐름:

배낭을 한 번 클릭하면 두 번 클릭하는 것처럼 열리지 않습니다.

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

     public object? RunScenario()
    {
        var bag = UO.Backpack();
        if (Truth(bag != 0))
        {
            UO.ClickOnObject(bag);
        }

        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.ClickOnObject(objID)` — `UO.ClickOnObject(Any)`

매개변수: objID (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.Click: Click(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "clickonobject": Click(Arg(0)); return InjectionValue.Unit;

UO.DeleteObject

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

C# 시그니처

void UO.DeleteObject(object? name);

런타임 테이블에서 저장된 개체 이름을 제거합니다.

매개변수

name - string 개체 테이블의 이름입니다. 이 항목만 삭제됩니다.

반환값

void - 반환 값이 없습니다.

동작

이름이 발견되면 항목을 삭제하고 확인 메시지를 인쇄합니다. 이름이 없으면 찾을 수 없다는 메시지를 인쇄합니다. 서버 개체와 해당 내용은 삭제되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

UO.Print("Calling UO.DeleteObject");
UO.DeleteObject("temporary");

1. 생성된 이름 삭제 - 직접 스크립트

매개변수와 실행 흐름:

해당 캐릭터의 serial와의 임시 연결만 해제됩니다.

UO.AddObject("temporary",UO.Self());
UO.DeleteObject("temporary");

2. 이름 누락 - 스크립트 기능

매개변수와 실행 흐름:

이름이 누락되면 진단 메시지가 나타납니다.

return  RunScenario();
 object? RunScenario()
{
    UO.DeleteObject("missing-example-name");
    return null;
}

3. 변수에 이름 저장 - 스크립트 클래스

매개변수와 실행 흐름:

string 변수는 삭제할 정확한 항목을 지정합니다.

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 name = "temporary";
        UO.AddObject(name, UO.Self());
        UO.DeleteObject(name);
        return null;
    }
}

명령 구현

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

`UO.DeleteObject(name)` — `UO.DeleteObject(String)`

매개변수: name (String)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.DeleteObject.
InjectionScript.Runtime.State.RuntimeDictionary.TryGet: objects.TryGet(name, out int value).
InjectionScript.Runtime.State.RuntimeDictionary.Remove: objects.Remove(name).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"Object {name} has been deleted").

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

public void DeleteObject(string name)

        {

            if (objects.TryGet(name, out int value))

            {

                objects.Remove(name);

                SystemMessage($"Object {name} has been deleted");

            }

            else

                SystemMessage($"Object {name} not found");

        }

UO.Drag

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

C# 시그니처

int UO.Drag(object? id);
int UO.Drag(object? id, object? amount);
int UO.Drag(object? id, object? amount, object? timeout);
void UO.Drag(object? fromX, object? fromY, object? toX, object? toY);

특정 항목을 커서로 올립니다. 별도의 4개 인수 형식은 Windows 창에서 마우스를 드래그합니다.

매개변수

id — 특정 항목/문자의 일련번호: 숫자, 16진수/10진수 문자열, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus 또는 저장된 이름 AddObject. 이것은 type이 아닙니다. 개체를 로드해야 합니다. 작업 전에 Exists를 확인하세요.
amount — 한 스택 안에 있는 단위 수입니다. 0 또는 음수 값은 전체 스택을 의미합니다. 긍정적인 것은 사용 가능한 수량에 의해 제한됩니다. MassMove를 제한하는 것은 스택 수가 아닙니다. 없으면 0와 같습니다.
timeout - 선택적인 세 번째 인수: 지정된 밀리초 수까지 관찰 가능 Picking을 기다립니다. 기본값은 0입니다. 음수 값은 0와 같습니다.
fromX - 4개의 int 형식만 해당: 클라이언트 창 픽셀에서 마우스의 초기 X.
fromY — 클라이언트 창 픽셀에 있는 마우스의 초기 Y입니다.
toX — 마우스의 끝 X(픽셀 단위)입니다.
toY — 마우스의 끝 Y(픽셀 단위)입니다.

반환값

1..3 인수 int: 1 — 클라이언트가 리프트 요청을 수락했습니다(시간 초과>0 사용 중인 커서도 관찰됨). 0 - 리프트가 거부되었거나 시간 초과가 만료되었습니다. 4개의 인수 사용 null: 반환 값이 없습니다. ID 아이템이 아닙니다.

동작

게임 전송의 경우 선호되는 형식은 id[,amount[,timeout]] 뒤에 DropItem 또는 단일 MoveItem이 오는 형식입니다.
fromX/fromY/toX/toY 형식은 Windows 마우스 이벤트(이동, 누르기, 이동, 놓기)를 사용합니다. 서버 확인이 없으며 창의 실제 내용/초점에 따라 달라집니다.
사용 중인 커서는 대상으로의 성공적인 전송과 같지 않습니다. 캡처와 릴리스는 별도의 작업입니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 전체 스택을 집어 배낭에 넣습니다 - 직접 스크립트

매개변수와 실행 흐름:

전리품 - serial부터 AddObject까지. amount=0는 전체 스택을 의미합니다. -1/-1 검프의 자동 위치를 설정합니다.
DropItem는 동일한 런타임 캡처를 완료합니다. 하나는 서버의 확인이 아니라 요청이 전송되었음을 의미합니다.

if (Truth(UO.Drag("loot", 0)))
{
    var dropped = UO.DropItem("backpack", -1, -1, 0);
    UO.Print("Drop request: " + Convert.ToString(dropped));
}

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

2. 제한된 대기로 스택에 참여 - 스크립트 기능

매개변수와 실행 흐름:

amount=10 — 한 스택의 최대 10개 단위; 시간 초과=500ms.
44/55 - 지도가 아닌 배낭 내부의 좌표입니다. 항목을 가져올 수 없으면 DropItem가 호출되지 않습니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Drag("loot", 10, 500)))
    {
        var dropped = UO.DropItem("backpack", 44, 55, 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. 그립 전 바쁜 손 확인 - 스크립트 수업

매개변수와 실행 흐름:

하나의 인수 Drag는 전체 스택을 의미하며 시간 초과=0입니다.
Picking 클라이언트의 공유 커서를 확인합니다. 동시에 두 개의 독립적인 마이그레이션을 실행하지 마십시오.

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.Picking() == 0))
        {
            if (Truth(UO.Drag("loot")))
            {
                var dropped = UO.DropItem("backpack", -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;
}

4. 4개의 마우스 좌표 - 직접 스크립트

매개변수와 실행 흐름:

창 픽셀은 시작(100,120), 끝(260,180)입니다. serial, 금액 또는 시간 초과가 없습니다.
원하는 요소가 이 위치에 있을 때만 사용하십시오. 객체의 경우 serial로 주소를 지정하는 것이 더 안정적입니다.

UO.Drag(100, 120, 260, 180);

명령 구현

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

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

매개변수: id (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Drag.
InjectionScript.Runtime.InjectionApiUO.Drag: Drag(id, InjectionValue.Zero, InjectionValue.Zero).

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

public int Drag(InjectionValue id) => Drag(id, InjectionValue.Zero, InjectionValue.Zero);

`UO.Drag(id, amount)` — `UO.Drag(Any,Any)`

매개변수: id (Any), amount (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Drag.
InjectionScript.Runtime.InjectionApiUO.Drag: Drag(id, amount, InjectionValue.Zero).

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

public int Drag(InjectionValue id, InjectionValue amount) => Drag(id, amount, InjectionValue.Zero);

`UO.Drag(id, amount, timeout)` — `UO.Drag(Any,Any,Any)`

매개변수: id (Any), amount (Any), timeout (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Drag.
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(amount).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.DragItem: bridge.DragItem(serial, requestedAmount).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Picking: bridge.Picking().
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Wait: bridge.Wait(10).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"UO.Drag: item pickup was not observable within {timeoutMs} ms.").

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

public int Drag(InjectionValue id, InjectionValue amount, InjectionValue timeout)

        {

            int serial = GetObject(id);

            if (serial == 0)

                return 0;

            int requestedAmount = NumberConversions.ToInt(amount);

            int timeoutMs = Math.Max(0, NumberConversions.ToInt(timeout));

            int result = bridge.DragItem(serial, requestedAmount);

            if (result == 0 || timeoutMs <= 0)

                return result;



            DateTime deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);

            do

            {

                if (bridge.Picking() != 0)

                    return 1;

                if (DateTime.UtcNow >= deadline)

                    break;

                bridge.Wait(10);

            }

            while (true);



            SystemMessage($"UO.Drag: item pickup was not observable within {timeoutMs} ms.");

            return 0;

        }

`UO.Drag(fromX, fromY, toX, toY)` — `UO.Drag(Integer,Integer,Integer,Integer)`

매개변수: fromX (Integer), fromY (Integer), toX (Integer), toY (Integer)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Drag.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Drag: bridge.Drag(fromX, fromY, toX, toY).

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

public void Drag(int fromX, int fromY, int toX, int toY) => bridge.Drag(fromX, fromY, toX, toY);

UO.DragItem

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

C# 시그니처

dynamic UO.DragItem(object? objID, object? count);

특정 항목을 선택하고 이번 런타임 동안 DropItem 동안 기억합니다.

매개변수

objID — 특정 항목/문자의 일련번호: 숫자, 16진수/10진수 문자열, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus 또는 저장된 이름 AddObject. 이것은 type이 아닙니다. 개체를 로드해야 합니다. 작업 전에 Exists를 확인하세요.
count — 한 스택 안에 있는 단위 수입니다. 0 또는 음수 값은 전체 스택을 의미합니다. 긍정적인 것은 사용 가능한 수량에 의해 제한됩니다. MassMove를 제한하는 것은 스택 수가 아닙니다.

반환값

int 1 — 클라이언트가 상승을 수락했습니다. 0 - 항목을 찾을 수 없거나 PickUp 거부되었습니다. 호환성 메타데이터 object? 임의의 결과 유형을 의미하지는 않습니다. 이것은 serial가 아닙니다.

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

동작

두 인수가 모두 필요합니다. 확인을 기다리는 내장 기능은 없습니다. Drag(id,amount,timeout) 형식은 로컬 Picking에 대한 대기 시간을 추가합니다.
성공적인 캡처 후 작업 DropItem을 완료하세요. 마우스로 수동으로 선택한 항목은 이 런타임의 DragItem 메모리를 설정하지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 전체 스택 올리기 - 직접 스크립트

매개변수와 실행 흐름:

ObjID=loot via AddObject, Count=0는 전체 스택입니다.
두 번째 팀은 동일한 주운 아이템을 떨어뜨립니다.

if (Truth(UO.DragItem("loot", 0)))
{
    var ok = UO.DropItem("backpack", -1, -1, 0);
}

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

2. 다섯 유닛 키우기 - 스크립트 기능

매개변수와 실행 흐름:

ObjID를 serial로 바꾸세요. Count=5는 동일한 스택의 단위를 나타냅니다.
위치 44/55는 백팩 검프 내부입니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.DragItem(0x40001234, 5)))
    {
        var ok = UO.DropItem("backpack", 44, 55, 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. 실패한 캡처 표시 - 스크립트 클래스

매개변수와 실행 흐름:

picked — int 1/0.
캡처가 실패한 후에는 DropItem를 호출하지 마세요. 커서가 다른 활동에 속할 수 있습니다.

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 picked = UO.DragItem("loot", 0);
        if (Truth(picked == 0))
        {
            UO.Print("Item was not picked up");
        }
        else
        {
            var ok = UO.DropItem("backpack", -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;
}

명령 구현

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

`UO.DragItem(objID, count)` — `UO.DragItem(Any,Any)`

매개변수: objID (Any), count (Any)

결과: dynamic / Any.

호출 시:

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

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

case "dragitem": return new InjectionValue(bridge.DragItem(Arg(0), Arg(1)));

UO.Drop

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

C# 시그니처

int UO.Drop(object? @object);
int UO.Drop(object? @object, object? count);
int UO.Drop(object? @object, object? count, object? destination);
dynamic UO.Drop(object? objID, object? count, object? x, object? y, object? z);

기본적으로 지정된 아이템을 캐릭터 아래의 지면으로 완전히 전송합니다.

매개변수

object — 특정 항목/문자의 일련번호: 숫자, 16진수/10진수 문자열, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus 또는 저장된 이름 AddObject. 이것은 type이 아닙니다. 개체를 로드해야 합니다. 작업 전에 Exists를 확인하세요.
objID — 특정 항목/문자의 일련번호: 숫자, 16진수/10진수 문자열, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus 또는 저장된 이름 AddObject. 이것은 type이 아닙니다. 개체를 로드해야 합니다. 작업 전에 Exists를 확인하세요.
count — 한 스택 안에 있는 단위 수입니다. 0 또는 음수 값은 전체 스택을 의미합니다. 긍정적인 것은 사용 가능한 수량에 의해 제한됩니다. MassMove를 제한하는 것은 스택 수가 아닙니다. 셀 수 없는 짧은 형식은 0입니다.
destination - 세 개의 인수가 있는 형식으로만 사용: 컨테이너의 일련번호 또는 세트 이름 AddObject; backpack/self/my 배낭을 선택하고, receiving/catchbag - SetCatchBag를 선택하고, 배낭이 없으면 배낭을 선택합니다. lastcontainer/lastobject/lasttarget/lastcorpse/finditem/laststatus는 올바른 컨테이너로 확인되면 유효합니다. ground 또는 0는 토지를 명시적으로 선택합니다. -1—동일한 배낭 선택기. 알 수 없거나 지정되지 않은 이름으로 인해 항목이 캡처되기 전에 오류가 발생합니다. 목적지 인수가 없으면 배낭이 사용됩니다.
x - 5개의 인수 형식으로만 사용됩니다: 세계 X 지구상의 목적지.
y — 5개 인수 형식의 경우 World Y입니다.
z — 5개 인수 형식의 표준 높이입니다.

반환값

int 1—클라이언트가 전체 전송 요청을 수락했습니다. 0 - 실패했습니다. 5개 인수 호환 형식에는 object?라는 메타데이터가 있지만 실제로는 int 1/0도 반환합니다. 이는 이전에 수행한 DragItem의 재설정이 아닙니다. DropItem를 사용하세요.

동작

1, 2, 3 및 5 인수가 포함된 양식이 등록됩니다. 인수가 4개 있는 형식은 없습니다.
Drop(item)은 전체 스택을 그 아래의 땅으로 옮깁니다. Drop(item,count)는 단위를 지정합니다. Drop(item,count,destination) 은 컨테이너를 허용합니다.
Drop(item,count,X,Y,Z)는 항상 토지를 의미합니다. 검프 좌표가 있는 컨테이너의 경우 MoveItem를 사용하세요.
리프팅, DropCheckCoord 및 서버 점검 제한이 적용됩니다. 팀에서는 별도의 배송 확인을 기다리지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 전체 스택이 당신의 발 아래에 있습니다 - 직접 스크립트

매개변수와 실행 흐름:

object=AddObject를 통한 전리품, 기본적으로 개수=0.
목적지 - 캐릭터가 현재 지상에 있는 지점입니다.

var ok = UO.Drop("loot");

2. 배낭에 5개 유닛 - 스크립트 기능

매개변수와 실행 흐름:

count=5 한 스택의 단위; 목적지=backpack.
여기서 세 번째 인수는 X가 아닌 컨테이너입니다.

return  RunScenario();
 object? RunScenario()
{
    var ok = UO.Drop("loot", 5, "backpack");
    return null;
}

3. 지상의 명시적 지점 - 시나리오 클래스

매개변수와 실행 흐름:

ObjID를 serial로 바꾸세요. Count=0 전체 스택; X/Y/Z=1445/1690/0.
이 형식의 경우 세 번째 값은 X입니다. 예비 Drag는 필요하지 않습니다.

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 ok = UO.Drop(0x40001234, 0, 1445, 1690, 0);
        return null;
    }
}

명령 구현

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

`UO.Drop(object)` — `UO.Drop(Any)`

매개변수: object (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.MoveItem: MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")).

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

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

`UO.Drop(object, count)` — `UO.Drop(Any,Any)`

매개변수: object (Any), count (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.MoveItem: MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")).

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

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

`UO.Drop(object, count, destination)` — `UO.Drop(Any,Any,Any)`

매개변수: object (Any), count (Any), destination (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.MoveItem: MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")).

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

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

`UO.Drop(objID, count, x, y, z)` — `UO.Drop(Any,Any,Any,Any,Any)`

매개변수: objID (Any), count (Any), x (Any), y (Any), z (Any)

결과: dynamic / Any.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.MoveItemChecked: MoveItemChecked(Arg(0), Arg(1), 0, Arg(2), Arg(3), Arg(4)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "drop": return new InjectionValue(MoveItemChecked(Arg(0), Arg(1), 0, Arg(2), Arg(3), Arg(4)) ? 1 : 0);

UO.DropCheckCoord

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

C# 시그니처

dynamic UO.DropCheckCoord();
dynamic UO.DropCheckCoord(object? value);

아이템을 땅에 떨어뜨릴 때 좌표 범위 확인을 읽거나 변경합니다.

매개변수

value — 선택 값: 0 비활성화, 0이 아닌 int 활성화. 인수가 없으면 상태는 읽기만 됩니다.

반환값

int 0/1 — 가능한 녹화 후 현재 상태; 두 형식 모두 숫자를 반환합니다.

동작

MoveItemChecked 지면에 할당되고 플래그가 켜지면 캐릭터로부터 2 셀보다 큰 체비쇼프 X/Y 거리를 거부합니다. 확인은 좌표를 변경하지 않으며 서버 전송 권한을 확인하지 않습니다. 컨테이너 할당은 이 플래그로 제한되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 플래그 읽기 - 직접 스크립트

매개변수와 실행 흐름:

읽기는 현재 표준화된 설정을 반환합니다.

var enabled = UO.DropCheckCoord();
UO.Print(Convert.ToString(enabled));

2. 범위 보호 활성화 - 스크립트 기능

매개변수와 실행 흐름:

MoveItemChecked를 통한 지상 이동은 이제 두 개의 사각형으로 제한됩니다.

return  RunScenario();
 object? RunScenario()
{
    var enabled = UO.DropCheckCoord(1);
    UO.Print(Convert.ToString(enabled));
    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()
    {
        var old = UO.DropCheckCoord();
        var temporary = UO.DropCheckCoord(0);
        var restored = UO.DropCheckCoord(old);
        return null;
    }
}

명령 구현

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

`UO.DropCheckCoord()` — `UO.DropCheckCoord()`

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

결과: dynamic / Any.

호출 시:

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

case "dropcheckcoord":

                    if (arguments.Length > 0) state.DropCheckCoord = Arg(0) != 0 ? 1 : 0;

                    return new InjectionValue(state.DropCheckCoord);

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

매개변수: value (Any)

결과: dynamic / Any.

호출 시:

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

case "dropcheckcoord":

                    if (arguments.Length > 0) state.DropCheckCoord = Arg(0) != 0 ? 1 : 0;

                    return new InjectionValue(state.DropCheckCoord);

UO.DropDelay

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

C# 시그니처

dynamic UO.DropDelay();
dynamic UO.DropDelay(object? value);

아이템 전송에 사용되는 GrabDelay 런타임 지연을 읽거나 변경합니다.

매개변수

value — 밀리초 단위의 선택적 지연; 한계를 50..10000로 제한합니다.

반환값

인수 int가 없고 현재 GrabDelay가 있습니다. 두 양식 모두의 메타데이터에 object?가 포함되어 있지만 항목 양식은 null를 반환합니다.

동작

SetDropDelay 및 GetDropDelay는 상태를 사용합니다. GrabDelay. 이 설정은 서버에서 전송 완료를 확인하는 대신 클라이언트 전송 지연을 지정합니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 읽기 지연 - 직접 스크립트

매개변수와 실행 흐름:

읽기는 밀리초를 반환합니다.

var ms = UO.DropDelay();
UO.Print(Convert.ToString(ms));

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

매개변수와 실행 흐름:

항목은 250 ms를 설정합니다.

return  RunScenario();
 object? RunScenario()
{
    UO.DropDelay(250);
    return null;
}

3. 테두리 하단 - 스크립트 클래스

매개변수와 실행 흐름:

0은 50 ms로 제한되며, 이후에는 이전 값으로 복원됩니다.

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

     public object? RunScenario()
    {
        var previous = UO.DropDelay();
        UO.DropDelay(0);
        UO.Print(Convert.ToString(UO.DropDelay()));
        UO.DropDelay(previous);
        return null;
    }
}

명령 구현

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

`UO.DropDelay()` — `UO.DropDelay()`

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

결과: dynamic / Any.

호출 시:

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

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

case "dropdelay":

                    if (arguments.Length > 0) { bridge.SetDropDelay(Arg(0)); return InjectionValue.Unit; }

                    return new InjectionValue(bridge.GetDropDelay());

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

매개변수: value (Any)

결과: dynamic / Any.

호출 시:

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

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

case "dropdelay":

                    if (arguments.Length > 0) { bridge.SetDropDelay(Arg(0)); return InjectionValue.Unit; }

                    return new InjectionValue(bridge.GetDropDelay());

UO.DropHere

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

C# 시그니처

int UO.DropHere(object? @object);

지정된 아이템/스택 전체를 캐릭터의 현재 지점에 있는 지면으로 옮깁니다.

매개변수

object — 특정 항목/문자의 일련번호: 숫자, 16진수/10진수 문자열, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus 또는 저장된 이름 AddObject. 이것은 type이 아닙니다. 개체를 로드해야 합니다. 작업 전에 Exists를 확인하세요.

반환값

int 1 — 클라이언트가 전송 요청을 수락했습니다. 0 - 완료되지 않았습니다. 이는 serial이나 서버 확인이 아닙니다.

동작

정확히 하나의 인수로 양식이 등록되었습니다. 스택의 일부에는 Drop(item,count) 또는 MoveItem를 사용하세요.
X/Y/Z는 챌린지 중에 캐릭터에서 가져옵니다. 사전 DragItem가 필요하지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 알려진 항목 던지기 - 직접 스크립트

매개변수와 실행 흐름:

object - serial, 실제로 대체합니다.
전체 스택이 캐릭터로 전송됩니다.

var ok = UO.DropHere(0x40001234);

2. 저장된 이름 사용 - 스크립트 기능

매개변수와 실행 흐름:

전리품은 AddObject를 통해 지정됩니다.
Exists는 서버 권한보다는 가용성을 확인하여 이전합니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("loot")))
    {
        var ok = UO.DropHere("loot");
    }

    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. 클라이언트 오류 처리 - 스크립트 클래스

매개변수와 실행 흐름:

ok — int 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 ok = UO.DropHere("loot");
        if (Truth(ok == 0))
        {
            UO.Print("Drop request was not accepted");
        }

        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.DropHere(object)` — `UO.DropHere(Any)`

매개변수: object (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.MoveItem: MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, new InjectionValue("ground"), new InjectionValue(GetX()), new InjectionValue(GetY()), new InjectionValue(GetZ())).
InjectionScript.Runtime.InjectionApiUO.GetX: GetX().
InjectionScript.Runtime.InjectionApiUO.GetY: GetY().
InjectionScript.Runtime.InjectionApiUO.GetZ: GetZ().

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

case "drophere":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, new InjectionValue("ground"), new InjectionValue(GetX()), new InjectionValue(GetY()), new InjectionValue(GetZ())));

                    return InjectionValue.False;

UO.DropItem

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

C# 시그니처

dynamic UO.DropItem(object? moveIntoID, object? x, object? y, object? z);

동일한 런타임에서 이전에 Drag/DragItem로 선택한 항목을 재설정합니다.

매개변수

moveIntoID — 직렬 대상, backpack 또는 세트 이름 AddObject. 숫자 0는 지구를 의미합니다. self 대신 backpack 사용: 이 하위 수준 인수는 self를 캐릭터의 serial로 해석합니다.
x — 용기의 경우 — 검프 안에 넣습니다(-1/65535 자동). 지구를 위해 - 세계 X.
y — 용기의 경우 — 검프 안에 넣습니다(-1/65535 자동). 지구를 위해 - 세계 Y.
z — 높이 재설정; 컨테이너에서는 일반적으로 0, 지상에서는 실제 Z 지점입니다.

반환값

int 1 - 재설정이 전송되었으며 커서가 삭제됨으로 표시됩니다. 0 - 성공하지 못했습니다. DragItem, 커서가 변경되었거나 액세스할 수 없거나 할당이 유효하지 않습니다. 메타데이터 object? 호환성은 이 결과를 변경하지 않습니다. 수량도 아니고 serial도 아닙니다.

동작

네 가지 인수가 모두 필요합니다. 이 옵션은 항목을 다시 가져오지 않습니다. Drop 및 MoveItem는 serial를 완전히 이월합니다.
보유하고 있는 것이 이번 런타임에 기억된 항목인지 확인합니다. 다른 사람이 가져가거나 손으로 가져간 물건을 실수로 떨어뜨리면 안 됩니다.
전송 후에는 캡처 메모리가 지워집니다. GrabDelay를 설정하면 스크립트 흐름에 일시 중지가 추가됩니다. 반납 후 서버 장애가 발생할 수 있습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

object? result = UO.DropItem("backpack", -1, -1, 0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. 자동 배낭 공간 - 직접 스크립트

매개변수와 실행 흐름:

MoveIntoID=backpack, X/Y=-1, Z=0.
성공적인 캡처는 릴리스 전에 확인됩니다.

if (Truth(UO.DragItem("loot", 0)))
{
    var ok = UO.DropItem("backpack", -1, -1, 0);
}

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

2. 가슴 안쪽 공간 - 스크립트 기능

매개변수와 실행 흐름:

가슴은 AddObject를 통해 지정됩니다. X=60/Y=70 — 검프의 좌표입니다.
amount=10는 Drag을 의미하며, DropItem는 자체 수량이 없습니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Drag("loot", 10)))
    {
        var ok = UO.DropItem("chest", 60, 70, 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. 캐릭터 아래 바닥에 놓기 - 시나리오 클래스

매개변수와 실행 흐름:

MoveIntoID=0 토지를 명확하게 선택합니다.
X/Y/Z는 컨테이너의 좌표가 아닌 월드 포인트입니다.

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 x = UO.GetX();
        var y = UO.GetY();
        var z = UO.GetZ();
        if (Truth(UO.DragItem("loot", 0)))
        {
            var ok = UO.DropItem(0, x, y, z);
        }

        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.DropItem(moveIntoID, x, y, z)` — `UO.DropItem(Any,Any,Any,Any)`

매개변수: moveIntoID (Any), x (Any), y (Any), z (Any)

결과: dynamic / Any.

호출 시:

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

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

case "dropitem": return new InjectionValue(bridge.DropDraggedItem(Arg(0), Arg(1), Arg(2), Arg(3)));

UO.Dye

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

C# 시그니처

void UO.Dye(object? dyeObject);
void UO.Dye(object? dyeObject, object? target);

전송된 컬러링 아이템을 사용합니다. 두 번째 인수는 UO.Wait-target 객체를 미리 설정합니다.

매개변수

dyeObject — self/backpack/lasttarget/저장된 객체의 객체 일련번호 또는 지원되는 이름입니다. 숫자 문자열과 0x 문자열은 런타임에 의해 해결됩니다.
target - 선택적 개체/serial 다음 대상. 두 번째 인수가 없으면 새 목표가 설정되지 않습니다.

반환값

void - 반환 값이 없습니다.

동작

두 개의 인수 형식은 먼저 WaitTargetObject(target)을 호출한 다음 UseObject(dyeObject)를 호출합니다. 단일 인수 형식은 주어만 사용합니다. 이는 조치를 보내는 것입니다. 색상, 색상권, 합계는 서버에 의해 결정됩니다.

독립 실행 C# 스크립트

간단한 예제

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

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

UO.Print("Calling UO.Dye");
UO.Dye(UO.LastObject());

1. 염색 아이템 사용 - 다이렉트 스크립트

매개변수와 실행 흐름:

단일 인수 호출은 대상을 지정하지 않습니다.

var dye = UO.LastObject();
if (Truth(UO.Exists(dye)))
{
    UO.Dye(dye);
}

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

2. 색상이 선택된 대상 - 스크립트 기능

매개변수와 실행 흐름:

Target는 염료를 더블클릭하기 전에 배치됩니다.

return  RunScenario();
 object? RunScenario()
{
    var dye = UO.LastObject();
    var target = UO.LastTarget();
    if (Truth(UO.Exists(dye)) && Truth(UO.Exists(target)))
    {
        UO.Dye(dye, target);
    }

    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. 저장된 이름 - 스크립트 클래스

매개변수와 실행 흐름:

이 예에서는 이전에 저장된 이름인 염료와 천을 사용합니다.

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.Exists("dye")) && Truth(UO.Exists("cloth")))
        {
            UO.Dye("dye", "cloth");
        }

        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.Dye(dyeObject)` — `UO.Dye(Any)`

매개변수: dyeObject (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitTargetObject: bridge.WaitTargetObject(Arg(1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(1).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.UseObject: bridge.UseObject(Arg(0, bridge.GetLastObject())).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLastObject: bridge.GetLastObject().

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

case "dye":

                    if (arguments.Length > 1) bridge.WaitTargetObject(Arg(1));

                    bridge.UseObject(Arg(0, bridge.GetLastObject()));

                    break;

`UO.Dye(dyeObject, target)` — `UO.Dye(Any,Any)`

매개변수: dyeObject (Any), target (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitTargetObject: bridge.WaitTargetObject(Arg(1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(1).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.UseObject: bridge.UseObject(Arg(0, bridge.GetLastObject())).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLastObject: bridge.GetLastObject().

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

case "dye":

                    if (arguments.Length > 1) bridge.WaitTargetObject(Arg(1));

                    bridge.UseObject(Arg(0, bridge.GetLastObject()));

                    break;

UO.EasyObject

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

C# 시그니처

void UO.EasyObject(object? name);
void UO.EasyObject(object? name, object? @object);

대화형 대상 쿼리 없이 개체 이름을 저장합니다.

매개변수

name — string로 확인되는 런타임 개체 항목의 이름입니다.
object - 선택사항 serial/링크. 그렇지 않으면 GetLastObject가 보존됩니다.

반환값

void - 반환 값이 없습니다.

동작

State.Objects.Set는 이름 항목을 대체합니다. 단일 인수 형식은 LastTarget 대신 마지막으로 사용된 개체를 사용합니다. 이 분기에서는 세계에 객체가 있는지 별도로 확인하지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

UO.Print("Calling UO.EasyObject");
UO.EasyObject("last-used");

1. 마지막 개체 저장 - 직접 스크립트

매개변수와 실행 흐름:

이름은 현재 LastObject에 부여됩니다.

UO.EasyObject("last-used");

2. 자신을 구하세요 - 스크립트 기능

매개변수와 실행 흐름:

두 개의 인수 형식은 전달된 serial를 유지합니다.

return  RunScenario();
 object? RunScenario()
{
    UO.EasyObject("me", UO.Self());
    return null;
}

3. 임시 항목 삭제 - 스크립트 클래스

매개변수와 실행 흐름:

Forget는 저장된 이름 연관만 삭제합니다.

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.EasyObject("temporary", UO.Self());
        UO.Forget("temporary");
        return null;
    }
}

명령 구현

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

`UO.EasyObject(name)` — `UO.EasyObject(Any)`

매개변수: name (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.State.RuntimeDictionary.Set: state.Objects.Set(Text(0), Arg(1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(1).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLastObject: bridge.GetLastObject().

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

case "easyobject":

                    if (arguments.Length > 1) state.Objects.Set(Text(0), Arg(1));

                    else if (arguments.Length > 0) state.Objects.Set(Text(0), bridge.GetLastObject());

                    break;

`UO.EasyObject(name, object)` — `UO.EasyObject(Any,Any)`

매개변수: name (Any), object (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.State.RuntimeDictionary.Set: state.Objects.Set(Text(0), Arg(1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(1).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLastObject: bridge.GetLastObject().

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

case "easyobject":

                    if (arguments.Length > 1) state.Objects.Set(Text(0), Arg(1));

                    else if (arguments.Length > 0) state.Objects.Set(Text(0), bridge.GetLastObject());

                    break;

UO.EmptyContainer

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

C# 시그니처

int UO.EmptyContainer(object? delay);
int UO.EmptyContainer(object? delay, object? source);
int UO.EmptyContainer(object? delay, object? source, object? destination);

상자, 가방, 시체 등의 직접적인 내용물을 모두 지정된 용기로 옮깁니다. 첫 번째 매개변수는 항상 밀리초 단위의 지연입니다. 소스가 지정되지 않으면 로컬 범위가 나타납니다. 소스 컨테이너를 선택합니다. 기본 목적지는 현재 캐릭터의 배낭입니다.

매개변수

delay — 첫 번째 필수 매개변수: 전송 간 지연(밀리초). 예를 들어 350 - 0,35 초입니다. 정수 값이 사용됩니다. 부정적인 것은 0로 줄어듭니다. GrabDelay는 이 지연에 별도로 추가되지 않습니다. 다음 줄이 마지막 요청을 따라잡지 않도록 마지막 일시 중지가 저장됩니다.
source — 두 번째 선택적 매개변수: 소스 컨테이너의 serial, 숫자/16진수 문자열 또는 저장된 개체 이름. lastobject, lastcontainer, lasttarget, lastcorpse, backpack/my가 지원됩니다. 매개변수가 없거나 0와 같으면 십자선이 나타납니다. 컨테이너 아이템이나 시체를 선택하세요. Esc는 작업을 취소합니다.
destination - 세 번째 선택적 매개변수는 serial 또는 대상 컨테이너의 저장된 이름입니다. backpack/self/my 캐릭터의 배낭을 선택하세요. receiving/catchbag 설치된 SetCatchBag 컨테이너(또는 설치되지 않은 경우 배낭)를 선택합니다. lastcontainer/lastobject/lasttarget/lastcorpse/finditem/laststatus는 액세스 가능한 컨테이너로 확인되는 경우 유효합니다. 알 수 없거나 설정되지 않은 별칭으로 인해 오류가 발생합니다. 매개변수가 지정되지 않으면 배낭이 사용됩니다. receiving 컨테이너 설정은 이 선택을 변경하지 않습니다. 대상은 존재해야 하며 소스와 달라야 합니다. Ground/0는 여기서 유효한 대상 컨테이너가 아닙니다.

반환값

int: 1 소스가 비어 있지 않았고 선택한 각 직접 항목에 대해 전송 요청을 보낼 수 있는 경우; 0 소스가 비어 있거나, 범위가 취소되었거나, 대상이 올바르지 않거나, 다운로드 시간이 초과되었거나, 부분/전체 전송 실패가 발생한 경우입니다. 이는 클라이언트 요청의 결과이지 서버에서 비움을 확인했다는 보장은 없습니다.

동작

정확한 형식: EmptyContainer(지연), EmptyContainer(지연, 소스), EmptyContainer(지연, 소스, 대상). 표준 접두사를 사용하는 게임 채팅: ,emptycontainer 350; 스크립트에서: UO.EmptyContainer(350).
조준 시 명령은 선택, 취소 또는 비상 정지를 기다립니다. 클라이언트는 계속해서 이미지와 네트워크를 업데이트합니다. Esc는 캐리를 보내지 않고 이전 개체를 사용하지 않으며 0를 반환합니다. 다른 조준경이 이 선택 사항을 대체하는 경우 작업도 취소됩니다.
콘텐츠가 아직 다운로드되지 않은 경우 클라이언트는 소스를 열고 서버가 응답할 때까지 3000 ms까지 기다립니다. 클라이언트에서 숨겨진 콘텐츠는 서버 데이터를 얻지 않으면 전송할 수 없습니다. 접근할 수 없거나 상자가 너무 멀거나 서버가 금지되면 다른 상자를 선택하는 대신 실패하게 됩니다.
데이터를 받은 후 직접 항목 목록이 생성됩니다. 각 스택은 한 번에 하나의 캡처 및 재설정 요청을 통해 전체적으로 마이그레이션됩니다. 동봉된 가방은 완전히 휴대됩니다. 그 내용은 별도로 검색되지 않습니다. 나중에 추가된 새 항목은 현재 목록에 포함되지 않습니다.
각 요청 전에 해당 항목이 원래 컨테이너에 아직 있는지 다시 확인합니다. 컨테이너 자체 또는 자체 하위 컨테이너를 중첩할 수 없습니다. 커서가 다른 항목에 의해 점유되어 있는 경우 명령은 사용자를 대신하여 커서를 재설정하지 않습니다.
누락된 목적지 컨테이너는 배낭으로 대체되지 않습니다. 1 결과는 서버가 모든 작업을 수락했다는 의미는 아닙니다. 필요한 경우 서버를 업데이트한 후 내용을 확인하세요. 비상 정지는 대기를 중단합니다. 이미 전송된 작업은 롤백되지 않습니다.
알 수 없는 저장된 이름이나 잘못된 인수 형식으로 인해 0 반환이 아닌 API 오류가 발생합니다. 이를 유효한 serial 누락 개체와 구별하세요. 이에 대해 작업은 0를 반환합니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 조준경이 있는 상자나 시체를 선택하고 배낭으로 옮깁니다. - 직접 스크립트

매개변수와 실행 흐름:

유일한 매개변수인 Delay=350는 간격 350 ms를 지정합니다. 소스가 누락되어 십자선이 나타납니다.
목적지도 누락되었습니다. 내용물이 캐릭터의 배낭으로 이동합니다. 그 안에 있는 하나의 항목이 아니라 용기/시체 자체를 선택하십시오.
전송된 내용은 1 또는 0을 수신합니다. 0의 의미는 취소, 공허함, 실패를 결합합니다. 자세한 내용은 잡지를 참조하세요.

UO.Print("Select a chest or corpse");
var sent = UO.EmptyContainer(350);
if (Truth(sent == 0))
{
    UO.Print("Cancelled, empty, unavailable, or a transfer failed");
}

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

2. 유명한 가슴부터 스코프 없는 백팩까지 - 스크립트 기능

매개변수와 실행 흐름:

지연=350; 소스는 가슴의 실제 serial입니다. 대략적인 ID를 귀하의 것으로 바꾸세요. 광경은 나타나지 않습니다.
세 번째 매개변수는 지정되지 않았으므로 대상=backpack입니다. 모든 종류의 직접 아이템과 풀 스택이 이월에 포함됩니다.
Print에는 항목 수나 서버의 확인이 아닌 클라이언트의 제출 결과가 표시됩니다.

return  RunScenario();
 object? RunScenario()
{
    var source = "0x40001234";
    var sent = UO.EmptyContainer(350, source);
    UO.Print("Client request result: " + Convert.ToString(sent));
    return null;
}

3. 선택한 두 컨테이너 사이 - 스크립트 클래스

매개변수와 실행 흐름:

AddObject 매개변수가 하나 있으면 개체를 선택하라는 메시지가 표시되고 해당 이름이 저장됩니다. 두 가지 선택이 순차적으로 이루어집니다.
유 EmptyContainer delay=350; 소스=source_bag; 목적지=destination_bag. 세 번째 매개변수는 배낭 대신 특정 가방을 지정합니다.
이름은 다른 컨테이너를 참조해야 합니다. 취소된 AddObject는 이름의 이전 의미를 제거하므로 이전 가방이 실수로 사용되는 일이 없습니다.

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

     public object? RunScenario()
    {
        UO.Print("Select source");
        UO.AddObject("source_bag");
        UO.Print("Select destination");
        UO.AddObject("destination_bag");
        var sent = UO.EmptyContainer(350, "source_bag", "destination_bag");
        UO.Print("Client request result: " + Convert.ToString(sent));
        return null;
    }
}

4. 마지막으로 열린 컨테이너부터 특정 상자까지 - 직접 스크립트

매개변수와 실행 흐름:

Delay=500 — 0.5초 간격. source=lastcontainer - 이 클라이언트에서 서버가 연 마지막 컨테이너입니다.
목적지 - 가슴의 명시적인 ID; 예를 교체하십시오. lastcontainer 및 lastobject는 마지막으로 열린 컨테이너와 마지막으로 사용된 개체라는 의미가 다릅니다.
시작하기 전에 마지막으로 열어본 소스가 필요한 소스인지 확인하세요. 캐리는 중첩된 백을 재귀적으로 열지 않습니다.

var destination = "0x40005678";
UO.EmptyContainer(500, "lastcontainer", destination);

5. 소스를 눈으로 선택하고 목적지를 미리 지정 - 스크립트 기능

매개변수와 실행 흐름:

지연=350; source=0는 세 번째 매개변수를 전달하는 기능을 유지하면서 구체적으로 범위를 호출합니다.
목적지=저장소는 이전에 저장된 상자를 가리킵니다. 소스를 선택하면 콘텐츠가 해당 소스로 전송됩니다.
Esc는 래핑 없이 sent=0를 반환합니다. 스토리지를 알 수 없거나 존재하지 않는 경우 다른 컨테이너가 자동으로 선택되지 않습니다.

return  RunScenario();
 object? RunScenario()
{
    UO.AddObject("storage", "0x40005678");
    var sent = UO.EmptyContainer(350, 0, "storage");
    return null;
}

명령 구현

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

`UO.EmptyContainer(delay)` — `UO.EmptyContainer(Any)`

매개변수: delay (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteEmptyContainer: ExecuteEmptyContainer(arguments).

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

case "emptycontainer": return ExecuteEmptyContainer(arguments);

`UO.EmptyContainer(delay, source)` — `UO.EmptyContainer(Any,Any)`

매개변수: delay (Any), source (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteEmptyContainer: ExecuteEmptyContainer(arguments).

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

case "emptycontainer": return ExecuteEmptyContainer(arguments);

`UO.EmptyContainer(delay, source, destination)` — `UO.EmptyContainer(Any,Any,Any)`

매개변수: delay (Any), source (Any), destination (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteEmptyContainer: ExecuteEmptyContainer(arguments).

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

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.Exists

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

C# 시그니처

int UO.Exists(object? id);

클라이언트의 로컬 세계에 삭제되지 않은 개체가 있는지 확인합니다.

매개변수

id — 특정 개체의 필수 serial/ID: int, 16진수 문자열 또는 별칭 self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse 또는 이름 AddObject. 이것은 graphic/type이 아닙니다. 지정되지 않은 이름은 0로 해석됩니다. 이 명령은 새 대상을 열지 않습니다.

반환값

int 1 - serial는 이제 로드된 항목 또는 mobile로 확인됩니다. int 0 - 개체가 클라이언트에 알려지지 않았거나 삭제되었거나 별칭이 설정되지 않았습니다. 이는 객체의 존재에 대한 서버 응답이 아닙니다. 가시 영역 외부의 항목이 서버에 존재할 수 있으며 여기에 0가 표시됩니다.

동작

로컬 클라이언트 모델을 읽습니다. 서버에 대한 요청도 없고 기다리거나 이동할 필요도 없습니다.
결과는 읽는 순간을 가리킨다. UO.Wait 또는 다른 작업 후에 개체와 해당 플래그가 변경될 수 있습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 배낭이 사용 가능한지 확인 - 직접 스크립트

매개변수와 실행 흐름:

인수 backpack는 자신의 캐릭터 배낭의 별칭 serial입니다.
1는 백팩의 내용물이 이미 완전히 수령되었거나 개봉되었다는 의미가 아닙니다.

var present = UO.Exists("backpack");
if (Truth(present))
{
    UO.Print("Backpack is loaded");
}
else
{
    UO.Print("Backpack is unavailable");
}

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

2. 저장된 serial 다시 확인 - 스크립트 기능

매개변수와 실행 흐름:

target은 특정 serial를 저장합니다. 새로운 값 lasttarget은 이를 대체하지 않습니다.
일시정지 500ms 이후에는 객체가 표시되지 않을 수 있으므로 검사가 다시 수행됩니다.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var target = UO.GetSerial("lasttarget");
    await Delay(500);
    if (Truth(UO.Exists(target)))
    {
        UO.Print(UO.GetName(target));
    }
    else
    {
        UO.Print("Saved target is no longer loaded");
    }

    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. ID 형식과 객체 존재 구별 - 스크립트 클래스

매개변수와 실행 흐름:

GetSerial는 개체가 없더라도 숫자 1073746484를 0x40001234로 형식화합니다.
다음 확인에서만 현재 로컬 세계에 이 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()
    {
        var serial = UO.GetSerial("1073746484");
        UO.Print("Serial: " + serial);
        var present = UO.Exists(serial);
        UO.Print("Present 1/0: " + Convert.ToString(present));
        return null;
    }
}

명령 구현

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

`UO.Exists(id)` — `UO.Exists(Integer)`

매개변수: id (Integer/String)

결과: int / Integer.

호출 시:

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

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

public int Exists(int id) => bridge.Exists(id);

`UO.Exists(id)` — `UO.Exists(String)`

매개변수: id (Integer/String)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Exists.
InjectionScript.Runtime.InjectionApiUO.Exists: Exists(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public int Exists(string id) => Exists(GetObject(id));

UO.Forget

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

C# 시그니처

void UO.Forget(object? name);

메시지 없이 런타임 개체에서 저장된 이름을 제거합니다.

매개변수

name — string로 변환되는 항목 이름입니다.

반환값

void - 반환 값이 없습니다.

동작

분기는 state.Objects.Remove를 호출합니다. DeleteObject와 달리 이 양식은 확인을 인쇄하거나 누락된 이름을 보고하지 않습니다. 게임 월드 개체는 삭제되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

UO.Print("Calling UO.Forget");
UO.Forget("temporary");

1. 임시 이름 삭제 - 직접 스크립트

매개변수와 실행 흐름:

serial와의 이름 연결만 제거됩니다.

UO.EasyObject("temporary",UO.Self());
UO.Forget("temporary");

2. 이름 누락 - 스크립트 기능

매개변수와 실행 흐름:

메시지 없이 누락된 이름이 허용됩니다.

return  RunScenario();
 object? RunScenario()
{
    UO.Forget("missing-example-name");
    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()
    {
        var name = "temporary";
        UO.EasyObject(name, UO.Self());
        UO.Forget(name);
        return null;
    }
}

명령 구현

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

`UO.Forget(name)` — `UO.Forget(Any)`

매개변수: name (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.State.RuntimeDictionary.Remove: state.Objects.Remove(Text(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(0).

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

case "forget": if (arguments.Length > 0) state.Objects.Remove(Text(0)); break;

UO.GetAltName

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

C# 시그니처

dynamic UO.GetAltName(object? objID);

클라이언트에게 알려진 캐릭터의 직함(예: 이름 뒤의 직업 또는 서명)을 읽습니다.

매개변수

objID — 필수 serial/ID 객체. type도 아니고 cliloc도 아닙니다. int, 10진수/16진수 문자열, self, backpack, lasttarget, finditem 또는 이름 AddObject를 허용합니다. 0는 개체가 없음을 의미합니다.

반환값

string — 모바일용 제목 필드의 텍스트입니다. 제목을 알 수 없거나 개체가 문자가 아니거나 ID가 누락된 경우 빈 문자열입니다. serial, 전체 이름 또는 속성 배열이 아닙니다. GetAltName은 GetTitle와 동일한 필드를 사용합니다.

동작

호출 자체는 로컬 데이터를 읽고 서버를 기다리지 않으며 단일 클릭을 보내지 않습니다. 이름/직함을 요청하려면 ClickOnObject만 사용하세요. 응답은 비동기적으로 옵니다.
기존 문자에는 빈 문자열도 허용됩니다. Exists 검사는 객체가 로드되었는지 여부라는 또 다른 질문에 답합니다.
이 구현에서는 대체 이름이 캐릭터의 제목 필드에 매핑됩니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 캐릭터 이름 - 직접 스크립트

매개변수와 실행 흐름:

ObjID=self — 현재 클라이언트의 문자입니다.
제목에는 제목만 포함됩니다. 빈 필드는 스크립트 오류를 의미하지 않습니다.

var title = UO.GetAltName("self");
UO.Print(title);

2. 선택한 캐릭터 확인 - 스크립트 기능

매개변수와 실행 흐름:

ObjID=id — 마지막 대상의 serial GetName와 제목은 따로 읽습니다.
항목 대상에는 제목 필드가 없으며 빈 문자열을 제공합니다.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(id)))
    {
        var title = UO.GetAltName(id);
        if (Truth(title != ""))
        {
            UO.Print(UO.GetName(id) + " " + title);
        }
    }

    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. 읽기 전에 이름을 묻는 메시지 표시 - 스크립트 클래스

매개변수와 실행 흐름:

350 — 한 번 클릭한 후 밀리초 단위로 일시 중지되는 예; 이는 getter 매개변수가 아닙니다.
서버가 나중에 응답할 수도 있고 소유권을 전송하지 않을 수도 있습니다. 빈 문자열 처리를 유지합니다.

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.GetSerial("lasttarget");
        if (Truth(UO.Exists(id)))
        {
            UO.ClickOnObject(id);
            UO.Wait(350);
            UO.Print(UO.GetAltName(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.GetAltName(objID)` — `UO.GetAltName(Any)`

매개변수: objID (Any)

결과: dynamic / Any.

호출 시:

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

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

case "getaltname": return new InjectionValue(bridge.GetAltName(Arg(0)));

UO.GetColor

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

C# 시그니처

string UO.GetColor();
string UO.GetColor(object? id);

hue 개체를 읽고 16진수 문자열로 형식을 지정합니다.

매개변수

id는 graphic/type가 아니라 객체의 Serial/ID입니다. 숫자, 16진수 문자열, 표준 이름 self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse 또는 이름 AddObject. 별칭을 설정해야 합니다. 존재 여부는 Exists로 확인합니다. 인수가 없는 등록 양식은 self을 사용합니다.

반환값

string 형식 "0x0481" - 코드 hue/color, 0x 뒤의 4자리 16진수. 누락된 객체의 경우 "0x0000"가 반환됩니다. 도색되지 않은 항목에도 동일한 코드가 발생합니다. 색상이 graphic/type 또는 고유한 serial가 아닙니다.

동작

클라이언트에 이미 알려진 최신 데이터를 읽습니다. 업데이트 요청이 서버로 전송되지 않습니다.
알 수 없는 개체와 아직 검색되지 않은 속성은 null/빈 값을 가질 수 있습니다. Exists와 특정 동작의 조건을 확인하세요.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 마지막 항목의 색상 알아보기 - 직접 스크립트

매개변수와 실행 흐름:

id=lastobject - 마지막으로 사용된 개체입니다.
결과는 이미 16진수 문자열이므로 Int2Hex가 필요하지 않습니다.

var hue = UO.GetColor("lastobject");
UO.Print(hue);

2. 같은 색의 물체 찾기 - 스크립트 기능

매개변수와 실행 흐름:

type과 hue는 샘플의 서로 다른 특성입니다. FindType는 두 가지 16진수 표현을 모두 허용합니다.
일치 - serial 또는 빈 문자열을 찾았습니다. 색상은 type을 대체하지 않습니다.

return  RunScenario();
 object? RunScenario()
{
    var sample = UO.GetSerial("lastobject");
    if (Truth(UO.Exists(sample)))
    {
        var type = UO.GetGraphic(sample);
        var hue = UO.GetColor(sample);
        var match = UO.FindType(type, hue, "backpack");
        UO.Print(match);
    }

    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. 비교를 위해 hue를 정수로 변환 - 스크립트 클래스

매개변수와 실행 흐름:

GetColor는 self을 읽습니다. Hex2Int는 16진수 텍스트를 int로 변환합니다.
null hue 자체만으로는 캐릭터가 세계에 존재하는지 여부를 알 수 없습니다.

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 hue = UO.Hex2Int(UO.GetColor("self"));
        if (Truth(hue == 0))
        {
            UO.Print("Hue is 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;
}

명령 구현

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

`UO.GetColor()` — `UO.GetColor()`

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

결과: string / String.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetColor.
InjectionScript.Runtime.InjectionApiUO.GetColor: GetColor(new InjectionValue(bridge.Self)).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

public string GetColor() => GetColor(new InjectionValue(bridge.Self));

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

매개변수: id (Any)

결과: string / String.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetColor.
InjectionScript.Runtime.NumberConversions.ToHex: NumberConversions.ToHex((short)bridge.GetColor(GetObject(id))).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetColor: bridge.GetColor(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public string GetColor(InjectionValue id) => NumberConversions.ToHex((short)bridge.GetColor(GetObject(id)));

UO.GetFlags

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

C# 시그니처

int UO.GetFlags(object? id);

알려진 로컬 개체에서 Entity.Flags 비트마스크를 읽습니다.

매개변수

id — self/backpack/lasttarget/저장된 객체의 객체 일련번호 또는 지원되는 이름입니다. 숫자 문자열과 0x 문자열은 런타임에 의해 해결됩니다.

반환값

int - 원본 Entity.Flags. 알 수 없거나 누락된 엔터티가 0를 반환합니다. 그것은 논리적 결과가 아니라 마스크입니다.

동작

GetObject가 링크를 확인한 다음 bridge.World.Get이 게임 스트림에서 Entity.Flags를 읽습니다. null 값은 플래그나 모델이 없는 객체를 의미할 수 있습니다. Exists는 이러한 경우를 구분합니다. 이 명령은 상태 업데이트를 요청하지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 스스로 플래그 지정 - 직접 스크립트

매개변수와 실행 흐름:

현재 캐릭터의 마스크가 표시됩니다.

var flags = UO.GetFlags("self");
UO.Print(Convert.ToString(flags));

2. 알려진 대상 플래그 - 스크립트 기능

매개변수와 실행 흐름:

Exists 테스트는 누락된 모델을 구별합니다.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastTarget();
    if (Truth(UO.Exists(id)))
    {
        var flags = UO.GetFlags(id);
        UO.Print(Convert.ToString(flags));
    }

    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. serial 누락 - 스크립트 클래스

매개변수와 실행 흐름:

null serial는 일반적으로 엔터티와 일치하지 않으며 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 flags = UO.GetFlags(0);
        UO.Print(Convert.ToString(flags));
        return null;
    }
}

명령 구현

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

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

매개변수: id (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetFlags.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetFlags: bridge.GetFlags(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public int GetFlags(InjectionValue id) => bridge.GetFlags(GetObject(id));

UO.GetGraphic

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

C# 시그니처

string UO.GetGraphic();
string UO.GetGraphic(object? id);

항목의 graphic 또는 문자의 body을 읽고 16진수 텍스트로 반환합니다.

매개변수

id — 특정 개체의 일련 번호 또는 확인 가능한 별칭(예: "self", "backpack", "lasttarget" 또는 AddObject에서 저장한 이름)입니다. 그래픽/type는 여기로 전송되지 않습니다. 인수 없는 형식에서는 self를 사용합니다.

반환값

string "0x0EED" 형식 - 그래픽 type/body 개체. 이는 고유한 ID/serial가 아닙니다. 알 수 없는 객체의 경우 브리지는 "0x0000" 형식의 graphic 0를 반환합니다. 이 명령은 true/false를 반환하지 않습니다.

동작

이 명령은 클라이언트의 로컬 데이터를 읽습니다. 대상을 보내지 않으며 서버의 개체를 변경하지 않습니다.
숫자 0는 유효한 데이터 값일 수 있습니다. 해당 속성 값뿐만 아니라 Exists(serial)를 통해 객체가 없는지 확인합니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 찾은 항목의 type 확인 - 직접 스크립트

매개변수와 실행 흐름:

FindType는 type 골드를 받고 serial를 반환합니다.
GetGraphic(serial)는 "0x0EED" 텍스트를 반환합니다. 변수 항목과 graphic는 다른 의미를 갖습니다.

var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    var graphic = UO.GetGraphic(item);
    UO.Print("Graphic: " + graphic);
}

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

2. 캐릭터의 body 읽기 - 스크립트 기능

매개변수와 실행 흐름:

인수 없는 형식에서는 self를 사용합니다.
body는 serial이 아닌 캐릭터의 외모에 대한 코드입니다.

return  RunScenario();
 object? RunScenario()
{
    var body = UO.GetGraphic();
    UO.Print("Body graphic: " + body);
    return null;
}

3. 읽기 graphic를 새 검색에 전달 - 스크립트 클래스

매개변수와 실행 흐름:

lastobject—샘플; graphic는 FindType가 type로 허용하는 16진수 문자열입니다.
-1는 모든 색상을 허용하고, backpack는 검색 영역을 지정합니다. sameType는 다시 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()
    {
        var graphic = UO.GetGraphic("lastobject");
        var sameType = UO.FindType(graphic, -1, "backpack");
        if (Truth(sameType != ""))
        {
            UO.Print("Matching serial: " + sameType);
        }

        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.GetGraphic()` — `UO.GetGraphic()`

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

결과: string / String.

호출 시:

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

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

public string GetGraphics() => GetGraphics(bridge.Self);

`UO.GetGraphic(id)` — `UO.GetGraphic(Integer)`

매개변수: id (Integer/String)

결과: string / String.

호출 시:

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

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

public string GetGraphics(int id) => $"0x{bridge.GetGraphics(id):X4}";

`UO.GetGraphic(id)` — `UO.GetGraphic(String)`

매개변수: id (Integer/String)

결과: string / String.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetGraphics.
InjectionScript.Runtime.InjectionApiUO.GetGraphics: GetGraphics(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public string GetGraphics(string id) => GetGraphics(GetObject(id));

UO.GetLayer

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

C# 시그니처

string UO.GetLayer();
string UO.GetLayer(object? id);

매개변수

id — 특정 개체의 일련 번호 또는 확인 가능한 별칭(예: "self", "backpack", "lasttarget" 또는 AddObject에서 저장한 이름)입니다. 그래픽/type는 여기로 전송되지 않습니다. 인수 없는 형식에서는 self를 사용합니다.

반환값

string는 "Rhand", "Lhand", "Hat", "Bpack" 또는 "Mount"과 같은 레이어 이름입니다. 레이어 번호의 첫 번째 정식 이름이 반환되므로 헬멧은 "Hat"으로, Backpack는 "Bpack"으로 출력됩니다. 레이어 0, 알 수 없는 항목 또는 self는 "잘못됨"을 제공합니다. 0이 아닌 알 수 없는 숫자는 "0xNN" 형식으로 지정됩니다. serial도 아니고 graphic도 아니고 높이 Z도 아닙니다.

동작

이 명령은 클라이언트의 로컬 데이터를 읽습니다. 대상을 보내지 않으며 서버의 개체를 변경하지 않습니다.
숫자 0는 유효한 데이터 값일 수 있습니다. 해당 속성 값뿐만 아니라 Exists(serial)를 통해 객체가 없는지 확인합니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 오른손에 있는 객체의 레이어 결정 - 직접 스크립트

매개변수와 실행 흐름:

ObjAtLayer("Rhand")는 오른쪽에 있는 항목을 선택합니다. 0은 빈 슬롯을 의미합니다.
GetLayer는 발견된 항목의 serial을 수신하고 "Rhand" 문자열을 반환합니다.

object? item = UO.ObjAtLayer("Rhand");
if (item is string serial)
{
    var layer = UO.GetLayer(serial);
    UO.Print(layer);
}

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

2. Backpack 레이어 이름 확인 - 스크립트 기능

매개변수와 실행 흐름:

id="backpack" — 현재 캐릭터 배낭의 serial
별칭 Backpack이 아닌 표준 이름 Bpack이 확인됩니다.

return  RunScenario();
 object? RunScenario()
{
    var layer = UO.GetLayer("backpack");
    if (Truth(layer == "Bpack"))
    {
        UO.Print("Player backpack layer");
    }
    else
    {
        UO.Print("Layer: " + layer);
    }

    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. 장비 부족 처리 - 스크립트 클래스

매개변수와 실행 흐름:

lastobject는 유효한 항목 별칭이어야 합니다.
유효하지 않음은 레이어 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 layer = UO.GetLayer("lastobject");
        if (Truth(layer == "Invalid"))
        {
            UO.Print("No equipment layer");
        }
        else
        {
            UO.Print("Equipment layer: " + layer);
        }

        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.GetLayer()` — `UO.GetLayer()`

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

결과: string / String.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetLayer.
InjectionScript.Runtime.InjectionApiUO.GetLayer: GetLayer(new InjectionValue(bridge.Self)).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

public string GetLayer() => GetLayer(new InjectionValue(bridge.Self));

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

매개변수: id (Any)

결과: string / String.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetLayer.
InjectionScript.Runtime.InjectionApiUO.ConvertLayer: ConvertLayer(bridge.GetLayer(GetObject(id))).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLayer: bridge.GetLayer(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public string GetLayer(InjectionValue id) => ConvertLayer(bridge.GetLayer(GetObject(id)));

UO.GetLocked

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

C# 시그니처

int UO.GetLocked(object? id);

mobile 마비를 확인합니다.

매개변수

id — 특정 개체의 필수 serial/ID: int, 16진수 문자열 또는 별칭 self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse 또는 이름 AddObject. 이것은 graphic/type이 아닙니다. 지정되지 않은 이름은 0로 해석됩니다. 이 명령은 새 대상을 열지 않습니다. 인수는 필수입니다. 직접 self를 통과하세요.

반환값

int 1 - 로드됨 mobile에는 IsParalyzed 속성이 있습니다. int 0 - 속성이 누락되었거나 객체가 mobile가 아니거나 알 수 없거나 삭제되었습니다. Locked라는 이름에도 불구하고 이것은 가슴 자물쇠나 물건이 고정되어 있거나 움직일 수 없는 어떤 이유도 아닙니다. 동일한 플래그는 Paralyzed로 읽혀집니다.

동작

로컬 클라이언트 모델을 읽습니다. 서버에 대한 요청도 없고 기다리거나 이동할 필요도 없습니다.
결과는 읽는 순간을 가리킨다. UO.Wait 또는 다른 작업 후에 개체와 해당 플래그가 변경될 수 있습니다.
Locked라는 이름에도 불구하고 이것은 가슴 자물쇠나 물건이 고정되어 있거나 움직일 수 없는 어떤 이유도 아닙니다. Paralyzed와 동일한 플래그를 읽습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 자신의 상태를 확인하세요 - 직접 스크립트

매개변수와 실행 흐름:

self 인수는 해당 문자를 명시적으로 선택합니다. 상태 - 1/0에만 해당됩니다.
Locked라는 이름에도 불구하고 이것은 가슴 자물쇠나 물건이 고정되어 있거나 움직일 수 없는 어떤 이유도 아닙니다. Paralyzed와 동일한 플래그를 읽습니다.

var state = UO.GetLocked("self");
var paralyzed = UO.Paralyzed();
UO.Print("GetLocked: " + Convert.ToString(state));
UO.Print("Paralyzed: " + Convert.ToString(paralyzed));

2. 선택됨 확인 mobile - 스크립트 기능

매개변수와 실행 흐름:

IsNpc 제목 및 알 수 없는 개체는 제외됩니다. target은 변경되는 lasttarget에 대한 실시간 참조가 아닌 단일 serial을 저장합니다.
결과는 IsParalyzed 필드를 참조합니다. 클라이언트가 적절한 상태를 수신한 후에만 데이터가 업데이트됩니다.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.GetSerial("lasttarget");
    if (Truth(UO.IsNPC(target)))
    {
        var state = UO.GetLocked(target);
        UO.Print("Selected mobile state 1/0: " + Convert.ToString(state));
    }
    else
    {
        UO.Print("No loaded mobile selected");
    }

    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(500) — 밀리초 단위로 일시 중지됩니다. 이후에는 mobile이 여전히 존재하는지 별도로 확인합니다.
두 이미지가 비교됩니다. 중간 변경 사항이 누락될 수 있으며 이는 서버 이벤트에 대한 지속적인 구독이 아닙니다.

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 target = UO.GetSerial("lasttarget");
        if (Truth(UO.IsNPC(target)))
        {
            var before = UO.GetLocked(target);
            await Delay(500);
            if (Truth(UO.IsNPC(target)))
            {
                var after = UO.GetLocked(target);
                if (Truth(before != after))
                {
                    UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
                }
            }
            else
            {
                UO.Print("Mobile left the local world");
            }
        }

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

명령 구현

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

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

매개변수: id (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetLocked.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLocked: bridge.GetLocked(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public int GetLocked(InjectionValue id) => bridge.GetLocked(GetObject(id));

UO.GetName

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

C# 시그니처

string UO.GetName();
string UO.GetName(object? id);

클라이언트가 알고 있는 아이템이나 캐릭터의 이름을 읽습니다.

매개변수

id는 graphic/type가 아니라 객체의 Serial/ID입니다. 숫자, 16진수 문자열, 표준 이름 self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse 또는 이름 AddObject. 별칭을 설정해야 합니다. 존재 여부는 Exists로 확인합니다. 인수가 없는 등록 양식은 self을 사용합니다.

반환값

string — 객체 이름. 알 수 없는 개체 또는 아직 획득되지 않은 이름의 경우 빈 문자열 ""이 표시됩니다. 이것은 serial도 아니고 type도 아니며, 툴팁에 있는 전체 속성 목록도 아닙니다.

동작

클라이언트에 이미 알려진 최신 데이터를 읽습니다. 업데이트 요청이 서버로 전송되지 않습니다.
알 수 없는 개체와 아직 검색되지 않은 속성은 null/빈 값을 가질 수 있습니다. Exists와 특정 동작의 조건을 확인하세요.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 캐릭터 이름 인쇄 - 직접 스크립트

매개변수와 실행 흐름:

인수가 없으면 self가 사용됩니다.
결과는 이름 텍스트이며 직접 표시될 수 있습니다.

var name = UO.GetName();
UO.Print(name);

2. 프로세스 알 수 없는 대상 이름 - 스크립트 기능

매개변수와 실행 흐름:

lasttarget — 객체 별칭. GetName는 새 대상을 열지 않습니다.
빈 이름은 객체가 없다는 것을 증명하지 않습니다. 이름이 없는 serial에 대한 정보가 먼저 나타날 수 있습니다.

return  RunScenario();
 object? RunScenario()
{
    var name = UO.GetName("lasttarget");
    if (Truth(name == ""))
    {
        UO.Print("Name is not available");
    }
    else
    {
        UO.Print("Target: " + name);
    }

    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. 이름 대소문자 구분 비교 - 스크립트 클래스

매개변수와 실행 흐름:

ToLowerInvariant는 비교를 위해 문자열을 소문자로 변환합니다.
이름은 서버에 의해 설정되며 현지화될 수 있습니다. 그래픽 유형별로 필터링하려면 FindType/GetGraphic를 사용하세요.

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 name = UO.GetName("lastobject");
        if (Truth(Convert.ToString(name) == "gold"))
        {
            UO.Print("Known name matches");
        }

        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.GetName()` — `UO.GetName()`

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

결과: string / String.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetName.
InjectionScript.Runtime.InjectionApiUO.GetName: GetName("self").

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

public string GetName() => GetName("self");

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

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

결과: string / Any.

호출 시:

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

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

case "getname":

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

`UO.GetName(id)` — `UO.GetName(Integer)`

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

결과: string / String.

호출 시:

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

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

public string GetName(int id) => bridge.GetName(id);

`UO.GetName(id)` — `UO.GetName(String)`

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

결과: string / String.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetName.
InjectionScript.Runtime.InjectionApiUO.GetName: GetName(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public string GetName(string id) => GetName(GetObject(id));

UO.GetQuantity

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

C# 시그니처

int UO.GetQuantity(object? id);

하나의 항목 스택에 있는 단위 수를 읽습니다.

매개변수

id는 graphic/type가 아니라 객체의 Serial/ID입니다. 숫자, 16진수 문자열, 표준 이름 self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse 또는 이름 AddObject. 별칭을 설정해야 합니다. 존재 여부는 Exists로 확인합니다. 인수가 없는 등록 양식은 self을 사용합니다. 이 명령에는 ID가 필요합니다.

반환값

int — 특정 항목의 금액 필드입니다. 1000 단위 스택은 일반적으로 1000를 반환합니다. 단품 - 1. 알 수 없는 serial 및 문자의 경우 0가 반환됩니다. 이는 상자의 하위 아이템 개수도 아니고 MassMove 명령의 아이템 제한도 아닙니다.

동작

클라이언트에 이미 알려진 최신 데이터를 읽습니다. 업데이트 요청이 서버로 전송되지 않습니다.
알 수 없는 개체와 아직 검색되지 않은 속성은 null/빈 값을 가질 수 있습니다. Exists와 특정 동작의 조건을 확인하세요.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 발견된 스택의 크기 보기 - 직접 스크립트

매개변수와 실행 흐름:

FindType는 배낭에서 어떤 색깔의 금색 type을 찾고 있습니다.
금에는 하나의 serial이 포함되어 있으므로 금액은 발견된 하나의 스택에만 적용됩니다.

var gold = UO.FindType(0x0EED, -1, "backpack");
if (Truth(gold != ""))
{
    var amount = UO.GetQuantity(gold);
    UO.Print("Units in this stack: " + Convert.ToString(amount));
}

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

2. 최소 수량 확인 - 스크립트 기능

매개변수와 실행 흐름:

id=sample - 마지막으로 사용한 항목입니다.
50는 주어진 스택에 있는 것을 의미합니다. 50 개별 품목은 여기에 포함되지 않습니다.

return  RunScenario();
 object? RunScenario()
{
    var sample = UO.GetSerial("lastobject");
    if (Truth(UO.Exists(sample)))
    {
        if (Truth(UO.GetQuantity(sample) >= 50))
        {
            UO.Print("At least 50 units in this item");
        }
    }

    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. 스택 수와 스택 수 구별 - 시나리오 클래스

매개변수와 실행 흐름:

FindCount는 마지막 검색 결과를 나타냅니다. GetQuantity - 하나의 serial로.
숫자는 크게 다를 수 있습니다. MassMove 수량은 스택을 포함한 전체 항목을 제한합니다.

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 item = UO.FindType(0x0EED, -1, "backpack");
        var stacks = UO.FindCount();
        if (Truth(item != ""))
        {
            var units = UO.GetQuantity(item);
            UO.Print("Matching items: " + Convert.ToString(stacks));
            UO.Print("Units in selected item: " + Convert.ToString(units));
        }

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

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

결과: int / Any.

호출 시:

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

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

case "getquantity": return new InjectionValue(bridge.GetQuantity(Arg(0)));

`UO.GetQuantity(id)` — `UO.GetQuantity(Integer)`

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

결과: int / Integer.

호출 시:

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

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

public int GetQuantity(int id) => bridge.GetQuantity(id);

`UO.GetQuantity(id)` — `UO.GetQuantity(String)`

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

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetQuantity.
InjectionScript.Runtime.InjectionApiUO.GetQuantity: GetQuantity(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public int GetQuantity(string id) => GetQuantity(GetObject(id));

UO.GetSerial

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

C# 시그니처

string UO.GetSerial();
string UO.GetSerial(object? id);

개체 이름을 serial로 확인하고 serial 형식을 16진수 문자열로 지정합니다.

매개변수

id - 선택적 문자열: 표준 별칭, 이름 AddObject 또는 숫자 텍스트(10진수/16진수). 인수가 없으면 현재 문자의 serial가 사용됩니다.

반환값

"0x40001234" 형식의 string는 고유한 serial/ID 개체로, 0x 뒤에 8자리 16진수가 붙습니다. 해결되지 않은 이름은 "0x00000000"입니다. 이것은 type가 아닙니다. 해당 객체가 로드되지 않은 경우에도 숫자 텍스트의 형식이 지정됩니다. GetSerial 자체는 Exists를 확인하지 않습니다.

동작

별칭 이름은 현재 스크립트/클라이언트 상태에서 읽습니다. 별칭이 이후에 다른 객체를 가리키는 경우 저장된 문자열 serial은 자동으로 변경되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 캐릭터의 ID 얻기 - 직접 스크립트

매개변수와 실행 흐름:

매개변수가 없으며 self가 선택되었습니다.
serial — 16진수 문자열. 0x00000000 값은 serial 문자가 없음을 의미합니다.

var serial = UO.GetSerial();
UO.Print(serial);

2. 선택한 성을 안전하게 사용 - 스크립트 기능

매개변수와 실행 흐름:

id="lasttarget"는 serial 마지막 대상으로 확인됩니다.
Exists는 객체의 존재를 확인하고, GetName는 클라이언트에 알려진 이름을 읽습니다.

return  RunScenario();
 object? RunScenario()
{
    var serial = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(serial)))
    {
        UO.Print(UO.GetName(serial));
    }
    else
    {
        UO.Print("Target is not loaded");
    }

    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. 숫자 표현 비교 - 스크립트 클래스

매개변수와 실행 흐름:

id는 10진수 serial 1073746484을 포함하는 문자열입니다.
결과 0x40001234에는 서식이 표시됩니다. 이것은 숫자의 예이며 객체를 생성하지 않으며 객체의 존재를 보장하지 않습니다.

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 serial = UO.GetSerial("1073746484");
        UO.Print(serial);
        return null;
    }
}

명령 구현

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

`UO.GetSerial()` — `UO.GetSerial()`

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

결과: string / String.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetSerial.
InjectionScript.Runtime.NumberConversions.ToHex: NumberConversions.ToHex(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

public string GetSerial() => NumberConversions.ToHex(bridge.Self);

`UO.GetSerial(id)` — `UO.GetSerial(String)`

매개변수: id (String)

결과: string / String.

호출 시:

InjectionScript.Runtime.InjectionApiUO.GetSerial.
InjectionScript.Runtime.NumberConversions.ToHex: NumberConversions.ToHex(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public string GetSerial(string id) => NumberConversions.ToHex(GetObject(id));

UO.GetTooltip

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

C# 시그니처

dynamic UO.GetTooltip(object? objID);

OPL에서 완성된 개체 속성 텍스트를 읽습니다. GetTooltip 및 GetCliloc는 동의어입니다.

매개변수

objID — 필수 serial/ID 객체. type도 아니고 cliloc도 아닙니다. int, 10진수/16진수 문자열, self, backpack, lasttarget, finditem 또는 이름 AddObject를 허용합니다. 0는 개체가 없음을 의미합니다.

반환값

string — 속성의 이름과 텍스트를 줄 바꿈으로 구분하거나 비어 있지 않은 부분만 구분합니다. ObjID=0이거나 속성이 수신되지 않은 경우 빈 문자열입니다. 이것은 이미 만들어진 텍스트입니다. 숫자 ID cliloc 및 매개변수는 GetTooltipRec에 의해 반환됩니다.

동작

항목이 OPL에 이미 존재하는 경우 해당 텍스트가 즉시 반환됩니다. 항목이 없으면 속성 요청이 전송되고 10ms마다 확인하여 최대 200ms까지 응답이 예상됩니다. 일시 중지가 응답을 보장하지는 않습니다.
접근 가능한 객체와 서버의 속성 지원이 필요합니다. 빈 결과는 객체가 없다는 증거가 아닙니다. Exists만 사용하세요.
텍스트에는 서버 마크업이 포함될 수 있습니다. 숫자 속성을 줄 위치로 구문 분석하지 마세요. 이를 위해 GetTooltipRec를 사용하세요.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 배낭에 있는 아이템의 속성 - 직접 스크립트

매개변수와 실행 흐름:

FindType: 골드 0x0EED, 모든 hue=-1, 직접 콘텐츠 backpack. ObjID=항목 - serial을 찾았습니다.
getter 결과는 금의 양이 아니라 텍스트입니다. 수량은 FindCount(항목)을 사용하세요.

var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    UO.Print(UO.GetTooltip(item));
}

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

2. 응답 없음 처리 - 스크립트 기능

매개변수와 실행 흐름:

ObjID=lasttarget는 원하는 개체를 가리켜야 합니다.
빈 문자열은 별도로 처리됩니다. 무한 루프에서 요청을 자동으로 반복할 필요가 없습니다.

return  RunScenario();
 object? RunScenario()
{
    var text = UO.GetTooltip("lasttarget");
    if (Truth(text == ""))
    {
        UO.Print("No properties received");
    }
    else
    {
        UO.Print(text);
    }

    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. 다음 작업까지 텍스트 저장 - 스크립트 클래스

매개변수와 실행 흐름:

id와 save는 별도의 변수입니다. 즉, 개체의 고유한 ID와 해당 텍스트의 스냅샷입니다.
나중에 서버의 속성이 변경되더라도 저장된 내용은 자동으로 변경되지 않습니다.

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

     public object? RunScenario()
    {
        var id = UO.GetSerial("lasttarget");
        var saved = UO.GetTooltip(id);
        UO.Print("Object: 0x" + Hex(id));
        UO.Print(saved);
        return null;
    }

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

명령 구현

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

`UO.GetTooltip(objID)` — `UO.GetTooltip(Any)`

매개변수: objID (Any)

결과: dynamic / Any.

호출 시:

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

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

case "getcliloc":

                case "gettooltip":

                    return new InjectionValue(bridge.GetTooltip(Arg(0)));

UO.GetTooltipRec

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

C# 시그니처

dynamic UO.GetTooltipRec(object? objID);

구조화된 속성을 읽습니다: cliloc ID 및 각 항목의 매개변수 OPL.

매개변수

objID — 필수 serial/ID 객체. type도 아니고 cliloc도 아닙니다. int, 10진수/16진수 문자열, self, backpack, lasttarget, finditem 또는 이름 AddObject를 허용합니다. 0는 개체가 없음을 의미합니다.

반환값

Array는 속성 행의 단일 스냅샷입니다. 각 줄은 [clilocID:int, 매개변수:Array]과 같습니다. rows[i][0]는 현지화된 메시지의 수이고,rows[i][1]는 매개변수의 배열입니다. ArrayLength(행) — 속성 수; ArrayLength(parameters) — 하나의 속성에 대한 매개변수 수입니다. ObjID=0이거나 수신된 레코드가 없는 경우 빈 배열입니다. 이것은 ID 항목 목록이나 완성된 텍스트가 아닙니다.

동작

캐시 항목이 즉시 반환됩니다. OPL가 누락된 경우 최대 120ms 동안 대기하면서 속성이 쿼리됩니다. 프로시저를 취소하면 대기가 중단됩니다. 알려진 빈 OPL는 기대를 유발하지 않습니다.
ClilocLoader와 같이 초기 서비스 탭을 건너뜁니다. 빈 내부 매개변수는 위치를 저장합니다. #번호는 이후 현지화를 위해 문자열로 저장됩니다. 알 수 없는 매개변수는 빈 배열을 생성합니다.
반환된 배열을 변경해도 클라이언트의 캐시는 변경되지 않습니다. 텍스트 사용의 경우 GetTooltip/GetCliloc; 한 줄을 번역하려면 - GetClilocByID(clilocID, 매개변수).

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 모든 부동산 번호 보기 - 직접 스크립트

매개변수와 실행 흐름:

ObjID=lasttarget — 개체. 행에는 속성이 포함되어 있으며 i는 0의 인덱스입니다. row[0]는 serial이 아니라 cliloc입니다.
빈 배열에서 루프가 실패합니다. 각 레코드는 한 번 처리됩니다.

var rows = UO.GetTooltipRec("lasttarget");
var i = 0;
while (Truth(i < ArrayLength(rows)))
{
    var row = rows[i];
    UO.Print("Cliloc: " + Convert.ToString(row[0]));
    i = i + 1;
}

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. 매개변수를 사용하여 각 레코드 번역 - 스크립트 기능

매개변수와 실행 흐름:

GetClilocByID는 clilocID=행[0] 및 대체 배열=행[1]을 받습니다.
매개변수는 순서대로 유지됩니다. 매개변수 배열 대신 전체 행을 전달하지 마세요.

return  RunScenario();
 object? RunScenario()
{
    var rows = UO.GetTooltipRec("lasttarget");
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        var text = UO.GetClilocByID(row[0], row[1]);
        UO.Print(text);
        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. 알려진 속성의 숫자 매개변수 가져오기 - 스크립트 클래스

매개변수와 실행 흐름:

원함 - ID 속성의 예; 원하는 cliloc으로 교체하세요. args[0]는 첫 번째 매개변수이며 처음에는 string입니다.
Val 이전에 매개변수 개수와 숫자 형식을 확인합니다. 매개변수는 텍스트 또는 #cliloc 링크일 수 있습니다.

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 rows = UO.GetTooltipRec("lasttarget");
        var wanted = 1060401;
        var i = 0;
        while (Truth(i < ArrayLength(rows)))
        {
            var row = rows[i];
            var args = row[1];
            if (Truth(row[0] == wanted) && Truth(ArrayLength(args) > 0))
            {
                if (Truth(IsNumeric(args[0])))
                {
                    UO.Print("Value: " + Convert.ToString(Val(args[0])));
                }
            }

            i = i + 1;
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    bool IsNumeric(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _);
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    double Val(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var number) ? number : 0;
}

명령 구현

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

`UO.GetTooltipRec(objID)` — `UO.GetTooltipRec(Any)`

매개변수: objID (Any)

결과: dynamic / Array.

호출 시:

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

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

case "gettooltiprec":

                    return new InjectionValue(bridge.GetTooltipRecords(Arg(0)).Select(entry =>

                        new InjectionValue(new[]

                        {

                            new InjectionValue(entry.ClilocID),

                            new InjectionValue(entry.Parameters.Select(value => new InjectionValue(value)).ToArray())

                        })).ToArray());

UO.GetType

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

C# 시그니처

dynamic UO.GetType(object? objID);

항목의 숫자 graphic 또는 문자의 body를 읽습니다.

매개변수

반환값

int - 아이템의 graphic/type 또는 캐릭터의 body(예: 골드의 경우 0x0EED (3821)). 객체를 찾을 수 없으면 0 값이 반환됩니다. GetType는 serial 또는 "0x..." 텍스트를 반환하지 않습니다. 문자열 형식은 GetGraphic로 제공됩니다.

동작

이 명령은 클라이언트의 로컬 데이터를 읽습니다. 대상을 보내지 않으며 서버의 개체를 변경하지 않습니다.
숫자 0는 유효한 데이터 값일 수 있습니다. 해당 속성 값뿐만 아니라 Exists(serial)를 통해 객체가 없는지 확인합니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 숫자 type를 상수와 비교 - 직접 스크립트

매개변수와 실행 흐름:

ObjID="lastobject" - 특정 개체의 별칭입니다.
0x0EED는 graphic의 수입니다. 비교에서는 serial과 같은 개체를 찾지 않습니다.

var graphic = UO.GetType("lastobject");
if (Truth(graphic == 0x0EED))
{
    UO.Print("Gold graphic");
}

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

2. type 나만의 백팩 받기 - 스크립트 기능

매개변수와 실행 흐름:

ObjID="backpack" - 현재 배낭.
Convert.ToString는 출력을 위해 반환된 숫자의 형식을 지정합니다.

return  RunScenario();
 object? RunScenario()
{
    var graphic = UO.GetType("backpack");
    UO.Print("Backpack type: " + Convert.ToString(graphic));
    return null;
}

3. 읽기 전에 객체 존재를 확인하세요 type - 스크립트 클래스

매개변수와 실행 흐름:

빈 문자열 FindType은 Exists 이전에 확인됩니다.
Exists는 부울 1/0를 반환합니다. GetType는 숫자 graphic를 반환합니다.

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 item = UO.FindType(0x0EED, -1, "backpack");
        if (Truth(item != ""))
        {
            if (Truth(UO.Exists(item)))
            {
                UO.Print("Type: " + Convert.ToString(UO.GetType(item)));
            }
        }

        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.GetType(objID)` — `UO.GetType(Any)`

매개변수: objID (Any)

결과: dynamic / Any.

호출 시:

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

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

case "gettype": return new InjectionValue(bridge.GetGraphics(Arg(0)));

UO.Grab

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

C# 시그니처

int UO.Grab();
int UO.Grab(object? id);
int UO.Grab(object? amount, object? id);
int UO.Grab(object? amount, object? item, object? container);
int UO.Grab(object? amount, object? item, object? container, object? timeout);

지정된/수신 컨테이너로 항목을 전송하거나 항목 선택을 엽니다.

매개변수

id — 항목의 일련번호/별칭입니다. 인수가 없으면 대화형 선택이 시작됩니다. 정확히 하나의 인수로 1 이 항목의 단위가 사용됩니다.
item — 항목의 일련번호/별칭입니다. 인수가 없으면 대화형 선택이 시작됩니다. 정확히 하나의 인수로 1 이 항목의 단위가 사용됩니다.
id / item — 항목의 일련번호/별칭입니다. 인수가 없으면 대화형 선택이 시작됩니다. 정확히 하나의 인수로 1 이 항목의 단위가 사용됩니다.
amount - 양식 2..4 - 첫 번째 인수로 수량, 그다음 항목. 0는 MoveItem 규칙에 따른 전체 스택을 의미합니다. Grab(item) 형식으로 순서를 변경하지 마세요.
container - 양식 3/4에만 해당: 명시적 할당. 그것이 없으면 상태.ReceivingContainer, >0이면, 그렇지 않으면 backpack입니다. 목적지의 self/my/backpack 선은 배낭을 의미합니다. ground - 지상.
timeout - 4 형식만, 밀리초입니다. 확인을 기다리는 동안 CompactMoveItem로 전송되었습니다. 좌표 ground는 self, 컨테이너 - 0xFFFF/0xFFFF/0에서 가져옵니다.

반환값

숫자 플래그 int: 1 — 대화형 선택이 허용되거나 선택한 양식에 따라 전송이 허용/확인됩니다. 0 - 실패/적합한 항목 없음. 인수가 없다는 결과가 항목이 이미 전송되었음을 의미하지는 않습니다.

동작

CompactGrab는 Grab(항목)=1 단위의 역사적 형태를 유지합니다. 시간 초과가 없는 양식은 확인 대기를 강제하지 않고 CompactMoveItem를 사용합니다. 시간 초과가 있는 양식은 UO.Wait=true를 지정합니다.
직렬 0은 즉시 0를 제공합니다. 해결되지 않은/부적절한 개체는 MoveItem를 통해 추가로 확인됩니다. 서버 규칙, 스택 양 및 현재 컨테이너가 결과에 영향을 미칩니다. 3/4개의 인수는 놓기 좌표가 아닙니다.
amount<=0는 전체 스택을 요청합니다. 시간 초과가 있는 형식에서는 부정적인 일시 중지가 0가 되지만 최소한 하나의 로컬 확인이 수행됩니다. 수표 사이 UO.Wait(10). 부분 이전은 초기 수량 감소로 확정되며, 완전 이전은 과제 및 ground X/Y/Z에 대해 확정됩니다. 이는 ID 요청의 새로운 프로토콜 응답이 아니라 세계 상태를 관찰한 것입니다. 이미 적합한 상태는 즉시 1를 제공할 수 있습니다. 요청이 이미 전송되었더라도 시간 초과로 인해 0가 발생합니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

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

매개변수와 실행 흐름:

지정된/수신 컨테이너로 항목을 전송하거나 항목 선택을 엽니다.

var accepted = UO.Grab();
UO.Print(accepted);

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

매개변수와 실행 흐름:

CompactGrab는 Grab(항목)=1 단위의 역사적 형태를 유지합니다. 시간 초과가 없는 양식은 확인 대기를 강제하지 않고 CompactMoveItem를 사용합니다. 시간 초과가 있는 양식은 UO.Wait=true를 지정합니다.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lastobject")))
    {
        UO.Print(UO.Grab("lastobject"));
    }

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

매개변수와 실행 흐름:

직렬 0은 즉시 0를 제공합니다. 해결되지 않은/부적절한 개체는 MoveItem를 통해 추가로 확인됩니다. 서버 규칙, 스택 양 및 현재 컨테이너가 결과에 영향을 미칩니다. 3/4개의 인수는 놓기 좌표가 아닙니다.

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.Exists("lastobject")))
        {
            UO.Print(UO.Grab(0, "lastobject", "backpack", 2000));
        }

        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.Grab()` — `UO.Grab()`

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

결과: int / Integer.

호출 시:

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

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

public int Grab() => bridge.RequestInteractiveGrabTarget();

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

매개변수: id (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Grab.
InjectionScript.Runtime.InjectionApiUO.CompactGrab: CompactGrab(new[] { id }).

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

public int Grab(InjectionValue id) => CompactGrab(new[] { id });

`UO.Grab(amount, id)` — `UO.Grab(Any,Any)`

매개변수: amount (Any/Integer/String), id (Any/Integer/String)

결과: int / Any.

호출 시:

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

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

case "grab": return new InjectionValue(CompactGrab(arguments));

`UO.Grab(amount, id)` — `UO.Grab(Integer,Integer)`

매개변수: amount (Any/Integer/String), id (Any/Integer/String)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Grab.
InjectionScript.Runtime.InjectionApiUO.CompactGrab: CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) }).

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

public int Grab(int amount, int id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

`UO.Grab(amount, id)` — `UO.Grab(Integer,String)`

매개변수: amount (Any/Integer/String), id (Any/Integer/String)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Grab.
InjectionScript.Runtime.InjectionApiUO.CompactGrab: CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) }).

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

public int Grab(int amount, string id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

`UO.Grab(amount, id)` — `UO.Grab(String,String)`

매개변수: amount (Any/Integer/String), id (Any/Integer/String)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Grab.
InjectionScript.Runtime.InjectionApiUO.CompactGrab: CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) }).

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

public int Grab(string amount, string id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

`UO.Grab(amount, item, container)` — `UO.Grab(Any,Any,Any)`

매개변수: amount (Any), item (Any), container (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [Grab].
InjectionScript.Runtime.InjectionApiUO.CompactGrab: CompactGrab(values).

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

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

values => new InjectionValue(CompactGrab(values))

`UO.Grab(amount, item, container, timeout)` — `UO.Grab(Any,Any,Any,Any)`

매개변수: amount (Any), item (Any), container (Any), timeout (Any)

결과: int / Integer.

호출 시:

InjectionScript.Runtime.InjectionApiUO.Register [Grab].
InjectionScript.Runtime.InjectionApiUO.CompactGrab: CompactGrab(values).

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

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

values => new InjectionValue(CompactGrab(values))

UO.IsMovable

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

C# 시그니처

int UO.IsMovable(object? objID);

클래식 UO 선택 규칙을 사용하여 알려진 항목의 이식성의 로컬 징후를 확인합니다.

매개변수

objID — 특정 개체의 필수 serial/ID: int, 16진수 문자열 또는 별칭 self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse 또는 이름 AddObject. 이것은 graphic/type이 아닙니다. 지정되지 않은 이름은 0로 해석됩니다. 이 명령은 새 대상을 열지 않습니다.

반환값

int 1 - 아이템이 제거되지 않고, 멀티가 되지 않으며, 지상에 있는 아이템에 대한 로컬 무게/이동 규칙에 의해 차단되지 않습니다. int 0 - mobile, 지상에 있는 다중, 알 수 없는/제거된 물체 또는 막힌 물체. 1는 성공적인 Drag/MoveItem을 보장하지 않습니다. 범위, 액세스, 커서 상태 및 최종 서버 결정은 별도로 확인됩니다.

동작

로컬 클라이언트 모델을 읽습니다. 서버에 대한 요청도 없고 기다리거나 이동할 필요도 없습니다.
결과는 읽는 순간을 가리킨다. UO.Wait 또는 다른 작업 후에 개체와 해당 플래그가 변경될 수 있습니다.
지상에서는 타일 데이터 항목의 가중치가 90보다 크고 이동 가능한 서버 플래그가 누락된 경우 항목이 잠긴 것으로 간주됩니다. 가중치 90 이하에는 이 플래그가 필요하지 않습니다.
컨테이너 내부에서는 바닥에 있는 물건을 막는 규칙이 적용되지 않습니다. 여기서 타일데이터의 가중치는 서비스 속성으로, GetQuantity도 아니고 현재 캐릭터의 가중치도 아닙니다.
다른 고객 문서에는 무게 설명이 다를 수 있습니다. 이는 이 클라이언트의 실제 규칙 GameActions.PickUp을 설명합니다.

독립 실행 C# 스크립트

간단한 예제

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

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

var result = UO.IsMovable(UO.GetSerial("lastobject"));
UO.Print("IsMovable: " + Convert.ToString(result));

1. 이동하지 않고 마지막 항목 확인 - 직접 스크립트

매개변수와 실행 흐름:

item — 마지막으로 사용한 아이템의 serial. 움직일 수 있는 수는 그 수량이 아닙니다.
이 예제에서는 아무것도 선택하지 않으며 서버에 아무것도 보내지 않습니다.

var item = UO.GetSerial("lastobject");
var movable = UO.IsMovable(item);
UO.Print("Locally movable 1/0: " + Convert.ToString(movable));

2. 부호와 거리를 별도로 추정 - 스크립트 기능

매개변수와 실행 흐름:

지상에 있는 아이템의 경우 GetDistance는 클라이언트의 알려진 범위를 표시합니다.
moveable=1을 사용해도 항목이 너무 멀리 떨어져 있을 수 있습니다. 긍정적인 결과는 서버의 전송 권한을 의미하지 않습니다.

return  RunScenario();
 object? RunScenario()
{
    var item = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(item)))
    {
        var movable = UO.IsMovable(item);
        var distance = UO.GetDistance(item);
        UO.Print("Movable: " + Convert.ToString(movable));
        UO.Print("Distance: " + Convert.ToString(distance));
    }

    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. 발견된 전체 스택 확인 - 스크립트 클래스

매개변수와 실행 흐름:

FindType는 배낭에서 원하는 색상의 금색 serial 하나를 선택합니다.
IsMovable 전체 항목을 확인합니다. GetQuantity는 단위 수를 별도로 읽습니다. 결과 IsMovable는 이 카운터를 대체하지 않습니다.

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 item = UO.FindType(0x0EED, -1, "backpack");
        if (Truth(item != ""))
        {
            if (Truth(UO.IsMovable(item)))
            {
                var units = UO.GetQuantity(item);
                UO.Print("Selected stack units: " + Convert.ToString(units));
            }
        }

        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.IsMovable(objID)` — `UO.IsMovable(Any)`

매개변수: objID (Any)

결과: int / Integer.

호출 시:

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

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

case "ismovable": return new InjectionValue(bridge.IsMovable(Arg(0)));

UO.IsObjectExists

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

C# 시그니처

int UO.IsObjectExists(object? objID);

클라이언트의 로컬 세계에 삭제되지 않은 개체가 있는지 확인합니다.

매개변수

objID — 특정 개체의 필수 serial/ID: int, 16진수 문자열 또는 별칭 self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse 또는 이름 AddObject. 이것은 graphic/type이 아닙니다. 지정되지 않은 이름은 0로 해석됩니다. 이 명령은 새 대상을 열지 않습니다.

반환값

동작

로컬 클라이언트 모델을 읽습니다. 서버에 대한 요청도 없고 기다리거나 이동할 필요도 없습니다.
결과는 읽는 순간을 가리킨다. UO.Wait 또는 다른 작업 후에 개체와 해당 플래그가 변경될 수 있습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

1. 배낭이 사용 가능한지 확인 - 직접 스크립트

매개변수와 실행 흐름:

인수 backpack는 자신의 캐릭터 배낭의 별칭 serial입니다.
1는 백팩의 내용물이 이미 완전히 수령되었거나 개봉되었다는 의미가 아닙니다.

var present = UO.IsObjectExists("backpack");
if (Truth(present))
{
    UO.Print("Backpack is loaded");
}
else
{
    UO.Print("Backpack is unavailable");
}

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

2. 저장된 serial 다시 확인 - 스크립트 기능

매개변수와 실행 흐름:

target은 특정 serial를 저장합니다. 새로운 값 lasttarget은 이를 대체하지 않습니다.
일시정지 500ms 이후에는 객체가 표시되지 않을 수 있으므로 검사가 다시 수행됩니다.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var target = UO.GetSerial("lasttarget");
    await Delay(500);
    if (Truth(UO.IsObjectExists(target)))
    {
        UO.Print(UO.GetName(target));
    }
    else
    {
        UO.Print("Saved target is no longer loaded");
    }

    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. ID 형식과 객체 존재 구별 - 스크립트 클래스

매개변수와 실행 흐름:

GetSerial는 개체가 없더라도 숫자 1073746484를 0x40001234로 형식화합니다.
다음 확인에서만 현재 로컬 세계에 이 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()
    {
        var serial = UO.GetSerial("1073746484");
        UO.Print("Serial: " + serial);
        var present = UO.IsObjectExists(serial);
        UO.Print("Present 1/0: " + Convert.ToString(present));
        return null;
    }
}

명령 구현

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

`UO.IsObjectExists(objID)` — `UO.IsObjectExists(Any)`

매개변수: objID (Any)

결과: int / Integer.

호출 시:

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

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

case "isobjectexists": return new InjectionValue(bridge.Exists(Arg(0)));

UO.LastObject

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

C# 시그니처

dynamic UO.LastObject();

마지막으로 사용한 객체의 serial를 읽습니다.

매개변수

매개변수가 없습니다.

반환값

int — 저장됨 serial; 0은 serial이 설치되지 않았음을 의미합니다. bool도 아니고 graphic/type도 아닙니다. 0이 아닌 ID는 세상에 더 이상 존재하지 않을 수 있습니다.

동작

필드 소스: _world.LastObject. 이 명령은 개체를 선택하거나 사용하거나 공격하지 않습니다.
현재 로컬 상태를 읽습니다. 패키지, 대상 또는 자동 업데이트가 없습니다. 개별 읽기에서는 다른 상태가 나타날 수 있습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

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

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

매개변수와 실행 흐름:

마지막으로 사용한 객체의 serial를 읽습니다.

var id = UO.LastObject();
UO.Print(Hex(id));

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

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

매개변수와 실행 흐름:

필드 소스: _world.LastObject. 이 명령은 개체를 선택하거나 사용하거나 공격하지 않습니다.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastObject();
    if (Truth(id != 0) && Truth(UO.Exists(id)))
    {
        UO.Print(UO.GetName(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. 전체 도우미 기능 - 스크립트 클래스

매개변수와 실행 흐름:

현재 로컬 상태를 읽습니다. 패키지, 대상 또는 자동 업데이트가 없습니다. 개별 읽기에서는 다른 상태가 나타날 수 있습니다.

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 before = UO.LastObject();
        UO.Wait(500);
        var after = UO.LastObject();
        UO.Print(before = after);
        return null;
    }
}

명령 구현

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

`UO.LastObject()` — `UO.LastObject()`

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

결과: dynamic / Any.

호출 시:

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

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

case "lastobject": return new InjectionValue(bridge.GetLastObject());

UO.MakeFakeItem

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

C# 시그니처

void UO.MakeFakeItem(object? @type);
void UO.MakeFakeItem(object? @type, object? serial);
void UO.MakeFakeItem(object? @type, object? serial, object? count);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color, object? x);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color, object? x, object? y);

로컬 클라이언트 항목만 생성하거나 수정합니다.

매개변수

type - 필수 graphic 1..65535; 이름이 지정되지 않은 type부터 ResolveType까지: 이 레거시 브랜치는 Arg/int를 사용합니다.
serial - 선택사항 serial 항목입니다. 0(기본값)은 0x7FFEFFFF 주변의 로컬 범위에서 무료 ID를 할당합니다. 명시적 항목 serial는 이미 로드된 항목과 일치하고 로컬 모델을 변경할 수 있습니다.
count - 선택 수량, 기본값 1. 양성이 아닌 것은 1가 됩니다. 최대 65535.
color - 선택 사항 hue, 기본값 0; 0..65535로 제한됩니다.
x — 선택적 세계 좌표, 기본값 self; 부정적인 것들은 self를 사용한 다음 0..65535로 제한합니다. Z는 항상 현재 플레이어입니다.Z.
y — 선택적 세계 좌표, 기본값 self; 부정적인 것들은 self를 사용한 다음 0..65535로 제한합니다. Z는 항상 현재 플레이어입니다.Z.

반환값

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

동작

CreateFakeItem에는 플레이어가 필요하며 유효한 graphic/item serial이 필요합니다. GetOrCreateItem은 로컬 모델을 반환합니다. 컨테이너에 있으면 연결을 삭제합니다. ground 컨테이너 0xFFFFFFFF, graphic/amount/hue/X/Y/Z, Layer.Invalid, AllowedToDraw=true 할당, IsDamageable=false 및 IsMulti=false.
Legacy 명령은 반환된 serial를 삭제합니다. 0가 오류 메시지를 표시하는 경우. 서버는 아이템을 생성하지 않습니다. 액션은 실제 아이템, 전리품 또는 양도 권한을 제공하지 않습니다. 예를 들어 serial=0를 그대로 둡니다.

독립 실행 C# 스크립트

간단한 예제

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

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

UO.Print("Calling UO.MakeFakeItem");
UO.MakeFakeItem(0x0E21);

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

매개변수와 실행 흐름:

로컬 클라이언트 항목만 생성하거나 수정합니다.

UO.MakeFakeItem(0x0E21);

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

매개변수와 실행 흐름:

CreateFakeItem에는 플레이어가 필요하며 유효한 graphic/item serial이 필요합니다. GetOrCreateItem은 로컬 모델을 반환합니다. 컨테이너에 있으면 연결을 삭제합니다. ground 컨테이너 0xFFFFFFFF, graphic/amount/hue/X/Y/Z, Layer.Invalid, AllowedToDraw=true 할당, IsDamageable=false 및 IsMulti=false.

return  RunScenario();
 object? RunScenario()
{
    UO.MakeFakeItem(0x0E21, 0, 5, 0);
    return null;
}

3. 전체 도우미 기능 - 스크립트 클래스

매개변수와 실행 흐름:

Legacy 명령은 반환된 serial를 삭제합니다. 0가 오류 메시지를 표시하는 경우. 서버는 아이템을 생성하지 않습니다. 액션은 실제 아이템, 전리품 또는 양도 권한을 제공하지 않습니다. 예를 들어 serial=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()
    {
        UO.MakeFakeItem(0x0E21, 0, 1, 0, UO.GetX(), UO.GetY());
        return null;
    }
}

명령 구현

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

`UO.MakeFakeItem(type)` — `UO.MakeFakeItem(Any)`

매개변수: type (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CreateFakeItem: bridge.CreateFakeItem(graphic, serial, amount, hue, x, y).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.").
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

`UO.MakeFakeItem(type, serial)` — `UO.MakeFakeItem(Any,Any)`

매개변수: type (Any), serial (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CreateFakeItem: bridge.CreateFakeItem(graphic, serial, amount, hue, x, y).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.").
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

`UO.MakeFakeItem(type, serial, count)` — `UO.MakeFakeItem(Any,Any,Any)`

매개변수: type (Any), serial (Any), count (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CreateFakeItem: bridge.CreateFakeItem(graphic, serial, amount, hue, x, y).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.").
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

`UO.MakeFakeItem(type, serial, count, color)` — `UO.MakeFakeItem(Any,Any,Any,Any)`

매개변수: type (Any), serial (Any), count (Any), color (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CreateFakeItem: bridge.CreateFakeItem(graphic, serial, amount, hue, x, y).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.").
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

`UO.MakeFakeItem(type, serial, count, color, x)` — `UO.MakeFakeItem(Any,Any,Any,Any,Any)`

매개변수: type (Any), serial (Any), count (Any), color (Any), x (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CreateFakeItem: bridge.CreateFakeItem(graphic, serial, amount, hue, x, y).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.").
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

`UO.MakeFakeItem(type, serial, count, color, x, y)` — `UO.MakeFakeItem(Any,Any,Any,Any,Any,Any)`

매개변수: type (Any), serial (Any), count (Any), color (Any), x (Any), y (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CreateFakeItem: bridge.CreateFakeItem(graphic, serial, amount, hue, x, y).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.").
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MassMove

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

C# 시그니처

void UO.MassMove();
void UO.MassMove(object? delay);
void UO.MassMove(object? delay, object? quantity);
void UO.MassMove(object? delay, object? quantity, object? @type);
void UO.MassMove(object? delay, object? quantity, object? @type, object? destination);
void UO.MassMove(object? delay, object? quantity, object? @type, object? destination, object? x, object? y, object? z);

선택한 유형의 항목을 일회성으로 대량 전송할 수 있습니다. MassMove를 활성화한 후 마우스로 적절한 항목 하나를 드래그하면 소스 컨테이너가 결정됩니다. 동일한 소스에서 이 유형의 다른 항목이 자동으로 이어집니다. 세 번째 매개변수는 항목의 ID가 아닌 TYPE/Graphic입니다. 모든 양식에는 첫 번째 수동 전송을 기다리는 것이 포함됩니다. 명시적인 목적지는 어디로 갈지 지정합니다.

매개변수

delay — 첫 번째 매개변수는 전송 요청 간 지연 시간(밀리초)으로, 0부터 2147483647까지의 정수입니다. 350는 0,35초를 의미합니다. 0를 사용하면 게임 프레임당 다음 캐리가 하나만 전송됩니다. GrabDelay에는 지연이 추가되지 않습니다. 음수 값은 모드를 비활성화하고 대기열을 지웁니다. 끄려면 명확한 UO.MassMove() 표기가 선호됩니다.
quantity - 두 번째 매개변수는 첫 번째 수동 전송을 포함한 개별 항목(항목)의 총 한도입니다. 하나의 스택/스택은 내부 수량에 관계없이 하나의 품목으로 간주됩니다. 50는 최대 50 전체 스택 또는 50 단일 항목을 의미합니다. 스택은 이 제한으로 분할되지 않습니다. 0 또는 매개변수 없음 - 모든 적합한 항목. 음수 값은 허용되지 않습니다.
type - 세 번째 매개변수는 아이템 유형 코드(그래픽/유형), 정수 0..65535(예: 0x0EED 또는 금의 경우 "0x0EED" 문자열)입니다. 이것은 serial/ID도 아니고 이름 AddObject도 아닙니다. 0 유무에 따라 첫 번째 수동 전송으로 유형이 결정됩니다. 명시적 유형을 사용하면 다른 유형을 드래그해도 대기열이 활성화되지 않습니다. 모드는 적합한 항목을 계속해서 기다립니다.
destination — 네 번째 매개변수가 목적입니다. 가슴 일련번호(숫자/16진수 문자열) 또는 저장된 이름 AddObject은 컨테이너를 선택합니다. X/Y는 창 안쪽에 있는 공간입니다. backpack, self 및 my 현재 캐릭터의 배낭을 선택하고 배낭 내부의 좌표도 선택합니다. ground 또는 0 토지 선택: X/Y/Z - 지도의 절대 위치, 세 가지 매개변수가 모두 필요합니다. lastcontainer — 마지막으로 열린 컨테이너; lastobject, lasttarget, lastcorpse, finditem, laststatus는 사용 가능한 컨테이너를 가리키는 경우 유효합니다. receiving 및 catchbag는 설치된 SetCatchBag 컨테이너를 선택하고, 설치되지 않은 경우 백팩을 선택합니다. self/my 여기서는 배낭을 의미하지만 GetX(self)는 캐릭터의 위치를 읽습니다. 이름은 대소문자를 구분하지 않고 비교됩니다. 알 수 없거나 아직 설정되지 않은 이름은 항목을 땅에 떨어뜨리는 대신 오류를 발생시킵니다. 대상이 없으면 첫 번째 수동 재설정부터 위치가 기억됩니다. 샘플을 컨테이너 내부에 놓거나 바닥에 놓을 수 있습니다. 지구에게는 첫 번째 초기화의 세계 X/Y/Z가 기억됩니다.
x — 다섯 번째 매개변수. 컨테이너의 경우 컨테이너 내부의 좌표입니다. -1 또는 65535는 자동 배치를 의미합니다. 토지의 경우 0부터 65535까지의 절대 지도 좌표입니다. X/Y/Z가 없는 양식의 경우 -1가 명시적 컨테이너에 사용됩니다.
y — 여섯 번째 매개변수. 컨테이너의 경우 - 컨테이너 내부 좌표, 자동 배치의 경우 -1/65535; 지상의 경우 - 절대 지도 좌표 0..65535. 명시적 컨테이너에 좌표가 없는 양식의 경우 -1를 사용하세요.
z — 일곱 번째 매개변수는 대상 높이, 정수 -128..127입니다. 컨테이너에는 일반적으로 0가 포함됩니다. 지상에 실제 높이를 나타냅니다. 짧은 형식에서는 높이와 X/Y가 수동 전송에서 가져옵니다.

반환값

void: 값이 없습니다. MassMove 활성화는 수동 환승 대기를 활성화한다는 의미입니다. 총계 행은 첫 번째 항목을 포함하여 요청이 전송된 개별 항목의 수를 보고합니다. 스택은 하나의 항목으로 간주됩니다. 결과는 서버의 각 요청 수락을 확인하지 않습니다.

동작

0, 1, 2, 3, 4 및 7 인수가 포함된 양식이 등록됩니다. X/Y/Z는 함께만 지정됩니다. 5, 6 또는 8 인수가 포함된 양식은 지원되지 않습니다. 주문: 지연, 수량, type, 목적지, x, y, z.
BEFORE 마우스 캡처 모드를 활성화하십시오. 첫 번째 수동 전송은 하나의 항목으로 간주됩니다. 1000의 스택이 완전히 전송되고 한도 50에서 한 공간만 소비합니다. 활성화된 모드는 분할 대화 상자 없이 전체 스택을 사용합니다. 포함하기 전에 스택의 일부를 가져온 경우 전송이 거부됩니다. 해당 부분을 다시 넣고 다시 시작하십시오.
활성화 1회는 수동 전송 1회를 의미합니다. 샘플을 선택한 후 선택 모드가 꺼집니다. 나머지 대기열은 자동으로 처리됩니다. 다른 스크립트에서 MoveItem에 대한 일반적인 호출은 수동 샘플 선택으로 간주되지 않습니다.
그래픽 유형이 비교됩니다. 이 명령에서는 색상이 필터링되지 않습니다. 소스 컨테이너의 직접 콘텐츠만 처리됩니다. 동봉된 가방은 열리지 않습니다. 대기열이 생성된 후에 나타나는 새 항목은 대기열에 추가되지 않습니다. 샘플이 바닥에 놓여 있는 경우 캡처 반경 내에서 동일한 유형의 로드된 물체가 고려됩니다.
수량은 요청의 상한선입니다. 이 명령은 서버에서 거부한 전송을 자동으로 재시도하지 않습니다. 서버 장애, 목적지 이용 불가, 캐릭터 사망, 다음 아이템 획득 불가 등의 경우 작업이 종료됩니다. 커서가 사용 중이면 대기열은 사용 가능해질 때까지 최대 5초까지 기다립니다.
UO.MassMove() 모드를 끄고 남은 대기열을 취소합니다. UO.TerminateAll() 및 캐릭터 탈퇴도 취소됩니다. 이미 전송된 요청은 취소로 인해 롤백되지 않습니다. 큐는 명령이 반환된 후 클라이언트에 의해 실행됩니다. 스크립트의 다음 줄은 서버가 이미 전송을 완료했음을 의미하지 않습니다.
다양한 유형의 콘텐츠를 완전히 이전하려면 EmptyContainer를 사용하세요. 특정 품목 하나를 운반하려면 - MoveItem. 8개의 인수 source, type, color, Destination, x, y, z, Delay는 MassMove가 아니라 MoveItems를 참조합니다.
모드가 첫 번째 마우스 드래그를 기다리는 동안 동일한 명령을 올바르게 반복적으로 호출하면 대기가 꺼집니다. 비활성화 MassMove/MassPriceMove가 게임 창에 직접 나타납니다. 다음 호출은 모드를 다시 켭니다. 첫 번째 전송 후 인수 없는 형식을 사용하여 나머지 대기열을 중지합니다. 이미 전송된 요청은 롤백되지 않습니다.

독립 실행 C# 스크립트

간단한 예제

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

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

UO.Print("Calling UO.MassMove");
UO.MassMove(350, 0);

1. 수 제한 없이 마우스 전송 활성화 - 직접 스크립트

매개변수와 실행 흐름:

지연=350: 다음 요청은 최소 350 ms만큼 분리됩니다. 수량=0: 상한 사용자 제한이 없습니다.
type, 목적지 및 X/Y/Z는 전송되지 않습니다. MassMove를 활성화한 후 샘플을 가방에서 상자로 드래그하세요. 유형과 소스는 샘플에서 가져오고 대상은 드롭 위치에서 가져옵니다.
샘플이 금인 경우 동일한 원래 용기에 로드된 금 더미가 이동됩니다. 다른 유형의 항목은 그대로 유지됩니다. Print는 후속 직접 조치만 설명합니다.

UO.MassMove(350, 0);
UO.Print("Drag one sample item to the destination container");

2. 100에서 50 전체 스택 전송 - 스크립트 기능

매개변수와 실행 흐름:

지연은 350 ms로 설정됩니다. 총계는 두 번째 수량 매개변수로 전달되고 전체 연산 50을 개별 항목으로 제한합니다.
소스에 동일한 유형의 100 스택이 포함된 경우 50 전체 스택이 전송됩니다(첫 번째 수동 스택과 다른 스택 49). 각 스택에는 서로 다른 양이 포함될 수 있습니다. 카운터에는 영향을 미치지 않습니다. 단품인 경우 50 단품으로 이전됩니다.
다른 옵션은 없습니다. 첫 번째 캡처 및 할당은 호출 후 마우스로 선택됩니다.

return  RunScenario();
 object? RunScenario()
{
    var delay = 350;
    var total = 50;
    UO.MassMove(delay, total);
    return null;
}

3. 금 종류 선택 및 상자 미리 세팅 - 시나리오 수업

매개변수와 실행 흐름:

goldType - TYPE 골드, ID 별도의 스택이 아닙니다. AddObject는 가슴의 serial를 가슴에 저장합니다. 0x40005678를 ID로 바꾸세요.
지연=350 ms, 수량=50 개별 품목, type=0x0EED, 목적지=가슴. 한도에는 첫 번째 더미가 포함되며 49 이하입니다. 모든 것.
x=-1 및 y=-1는 가슴에 자동 배치를 설정합니다(z=0). 이는 모두 7개의 매개변수입니다.
금을 수동으로 드래그하면 대기열이 시작됩니다. 그의 원래 가방이 소스가 될 것입니다. 명시적인 상자가 마우스 재설정 위치를 대체합니다. 다른 유형의 항목은 대기열을 시작하지 않습니다.

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 goldType = "0x0EED";
        UO.AddObject("chest", "0x40005678");
        UO.MassMove(350, 50, goldType, "chest", -1, -1, 0);
        UO.Print("Now drag one gold stack from the source bag");
        return null;
    }
}

4. 마우스로 샘플을 선택하되 사전에 기반을 설정 - 직접 스크립트

매개변수와 실행 흐름:

지연=350 ms, 수량=0 — 모든 적합한 항목. type=0는 향후 수동 전송에서 유형을 가져옵니다.
목적지=0는 토지를 의미하므로 전체 삼중 x,y,z가 제공됩니다. GetX/GetY/GetZ 여기서는 캐릭터의 현재 위치를 반환합니다.
호출 후 마우스로 샘플을 집어서 떨어뜨립니다. 이 명령은 마우스가 컨테이너 위에 있더라도 해당 항목과 일치하는 다른 항목을 지정된 좌표로 보냅니다. 서버는 토지의 가용성을 확인합니다.

var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
UO.MassMove(350, 0, 0, 0, x, y, z);

5. 알려진 유형의 항목을 최대 10개까지 배낭으로 이동 - 스크립트 기능

매개변수와 실행 흐름:

Delay=500 — 0.5초; 수량=10 - 전체 작업에 대한 10개의 개별 항목/스택.
type=0x0F7A — 항목의 그래픽 유형. 귀하의 유형을 표시해 주십시오. 0x40001234 형식의 일련번호는 여기에 허용되지 않습니다.
목적지=backpack — 캐릭터의 배낭. 좌표는 전송되지 않으므로 그 내부에는 x=-1, y=-1, z=0가 사용됩니다.
소스는 먼저 적절한 항목을 수동으로 전송하여 선택됩니다. 소스가 이미 배낭인 경우 유용하게 휴대할 수 있는 다른 소스 가방을 선택하세요.

return  RunScenario();
 object? RunScenario()
{
    UO.MassMove(500, 10, "0x0F7A", "backpack");
    UO.Print("Drag one matching item from the source chest");
    return null;
}

6. 이미 놓여 있는 아이템을 기준으로 상자 안의 장소를 선택하세요 - 시나리오 클래스

매개변수와 실행 흐름:

먼저, 가슴의 원하는 위치에 항목을 수동으로 배치합니다. 첫 번째 AddObject는 가슴 자체를 선택하고 이를 가슴에 ID 저장합니다. 두 번째는 그 안에 있는 항목을 선택하고 position_sample에 ID를 저장합니다.
컨테이너 내부 항목의 GetX/GetY는 해당 컨테이너 내부의 좌표를 반환합니다. 가슴 창이 화면에서 어디에 위치하는지에 따라 달라지지 않습니다.
지연=350 ms, 수량=50 정수 항목, type=0 소스에서 향후 수동 전송에 의해 결정됨, 대상=chest.
x와 y는 가슴 내부의 선택된 위치를 정의하며, 마지막 z=0입니다. position_sample 객체는 좌표를 읽는 역할만 합니다. 마이그레이션되는 소스와 유형은 후속 수동 마이그레이션에 의해 결정됩니다.
배낭의 경우 가슴을 backpack 또는 self로 바꾸세요. 육지의 경우 캐릭터의 현재 위치에 대한 인수 없이 ground 및 UO.GetX(), UO.GetY(), UO.GetZ()와 같은 지도 좌표를 사용합니다.

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

     public object? RunScenario()
    {
        UO.Print("Select the destination chest");
        UO.AddObject("chest");
        UO.Print("Select an item already at the desired position inside that chest");
        UO.AddObject("position_sample");
        var x = UO.GetX("position_sample");
        var y = UO.GetY("position_sample");
        UO.MassMove(350, 50, 0, "chest", x, y, 0);
        UO.Print("Drag one source item to start the transfer");
        return null;
    }
}

7. 가슴에서 땅바닥까지: 마우스로 장소 선택 - 직접 스크립트

매개변수와 실행 흐름:

지연=350 — 후속 요청 사이에 최소 350ms가 걸립니다. 수량=50 - 샘플을 포함하여 최대 50 개별 항목/전체 스택; 이는 동일한 스택의 50 장치가 아닙니다.
MassMove를 활성화한 후 열린 상자에서 아이템을 집어 마우스로 바닥에 놓습니다. 그 유형과 원래 가슴은 패턴에 따라 결정됩니다. 세계 X/Y/Z 목적지는 이 재설정 위치에 기억됩니다.
이 상자에서 로드된 동일한 유형의 나머지 아이템은 지상의 동일한 지점으로 보내집니다. 중첩된 가방 및 기타 유형의 내용물은 영향을 받지 않습니다. 일치하는 모든 항목에 대해 50를 0로 바꿉니다.
MassMove에는 반환 값이 없습니다. 모드가 활성화된 후 절차가 종료되고 대기열은 클라이언트에서 계속 작동합니다. 최종 메시지에는 서버 확인이 아닌 전송된 요청이 포함됩니다. 남은 대기열을 취소하려면 UO.MassMove()를 호출하세요.

UO.MassMove(350, 50);
UO.Print("Drag one item from the chest onto the ground");

명령 구현

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

`UO.MassMove()` — `UO.MassMove()`

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

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MassMove: bridge.MassMove(-1, 0, 0, -1, -1, -1, 0).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(arguments[0]).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(arguments[2]).
InjectionScript.Runtime.InjectionApiUO.ResolveTransferDestination: ResolveTransferDestination(arguments[3], true).

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

`UO.MassMove(delay)` — `UO.MassMove(Any)`

매개변수: delay (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MassMove: bridge.MassMove(-1, 0, 0, -1, -1, -1, 0).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(arguments[0]).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(arguments[2]).
InjectionScript.Runtime.InjectionApiUO.ResolveTransferDestination: ResolveTransferDestination(arguments[3], true).

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

`UO.MassMove(delay, quantity)` — `UO.MassMove(Any,Any)`

매개변수: delay (Any), quantity (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MassMove: bridge.MassMove(-1, 0, 0, -1, -1, -1, 0).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(arguments[0]).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(arguments[2]).
InjectionScript.Runtime.InjectionApiUO.ResolveTransferDestination: ResolveTransferDestination(arguments[3], true).

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

`UO.MassMove(delay, quantity, type)` — `UO.MassMove(Any,Any,Any)`

매개변수: delay (Any), quantity (Any), type (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MassMove: bridge.MassMove(-1, 0, 0, -1, -1, -1, 0).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(arguments[0]).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(arguments[2]).
InjectionScript.Runtime.InjectionApiUO.ResolveTransferDestination: ResolveTransferDestination(arguments[3], true).

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

`UO.MassMove(delay, quantity, type, destination)` — `UO.MassMove(Any,Any,Any,Any)`

매개변수: delay (Any), quantity (Any), type (Any), destination (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MassMove: bridge.MassMove(-1, 0, 0, -1, -1, -1, 0).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(arguments[0]).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(arguments[2]).
InjectionScript.Runtime.InjectionApiUO.ResolveTransferDestination: ResolveTransferDestination(arguments[3], true).

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

`UO.MassMove(delay, quantity, type, destination, x, y, z)` — `UO.MassMove(Any,Any,Any,Any,Any,Any,Any)`

매개변수: delay (Any), quantity (Any), type (Any), destination (Any), x (Any), y (Any), z (Any)

결과: void / Unit.

호출 시:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MassMove: bridge.MassMove(-1, 0, 0, -1, -1, -1, 0).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(arguments[0]).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(arguments[2]).
InjectionScript.Runtime.InjectionApiUO.ResolveTransferDestination: ResolveTransferDestination(arguments[3], true).

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

KO UO Topic items - LIHACHTETAN/ClassicUO-Bad-Newbie-CSharp-Scripts-IDE GitHub Wiki

아이템

섹션

모든 테마 명령

아이템 속성

아이템 사용

Moving 아이템

가짜 / 고객 품목

Dye

저장된 객체

주제에 대한 예

UO.MoveItem

UO.MassMove

참조 구성

전체 명령 참조

UO.AddObject

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. 알려진 항목의 serial를 편리한 이름으로 저장하세요. - 직접 스크립트

2. 항목 선택을 요청하거나 커서로 mobile를 누르고 대상 이름을 지정합니다. - 스크립트 기능

3. 이름을 다시 저장하면 바인딩이 새 serial로 대체됩니다. - 스크립트 클래스

명령 구현

UO.AddObject(name) — UO.AddObject(String)

UO.AddObject(name, objectRawId) — UO.AddObject(Any,Any)

UO.AddType

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. 발견된 금 더미 하나 올리기 - 직접 스크립트

2. 체력이 낮을 때만 붕대를 사용하세요 - 스크립트 기능

3. 도구를 마우스에 할당하고 별도의 절차로 적용 - 스크립트 클래스

명령 구현

UO.AddType(name) — UO.AddType(Any)

UO.AddType(name, type) — UO.AddType(Any,Any)

UO.ClickOnObject

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. 캐릭터 클릭 - 직접 스크립트

2. 마지막 대상 클릭 - 스크립트 기능

3. 그들은 배낭을 클릭할 것입니다 - 스크립트 클래스

명령 구현

UO.ClickOnObject(objID) — UO.ClickOnObject(Any)

UO.DeleteObject

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. 생성된 이름 삭제 - 직접 스크립트

2. 이름 누락 - 스크립트 기능

3. 변수에 이름 저장 - 스크립트 클래스

명령 구현

UO.DeleteObject(name) — UO.DeleteObject(String)

UO.Drag

C# 시그니처

매개변수

반환값

동작

독립 실행 C# 스크립트

간단한 예제

1. 전체 스택을 집어 배낭에 넣습니다 - 직접 스크립트

2. 제한된 대기로 스택에 참여 - 스크립트 기능

3. 그립 전 바쁜 손 확인 - 스크립트 수업

4. 4개의 마우스 좌표 - 직접 스크립트

명령 구현

UO.Drag(id) — UO.Drag(Any)

UO.Drag(id, amount) — UO.Drag(Any,Any)

UO.Drag(id, amount, timeout) — UO.Drag(Any,Any,Any)

`UO.AddObject(name)` — `UO.AddObject(String)`

`UO.AddObject(name, objectRawId)` — `UO.AddObject(Any,Any)`

`UO.AddType(name)` — `UO.AddType(Any)`

`UO.AddType(name, type)` — `UO.AddType(Any,Any)`

`UO.ClickOnObject(objID)` — `UO.ClickOnObject(Any)`

`UO.DeleteObject(name)` — `UO.DeleteObject(String)`

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

`UO.Drag(id, amount)` — `UO.Drag(Any,Any)`

`UO.Drag(id, amount, timeout)` — `UO.Drag(Any,Any,Any)`

`UO.Drag(fromX, fromY, toX, toY)` — `UO.Drag(Integer,Integer,Integer,Integer)`

`UO.DragItem(objID, count)` — `UO.DragItem(Any,Any)`

`UO.Drop(object)` — `UO.Drop(Any)`

`UO.Drop(object, count)` — `UO.Drop(Any,Any)`

`UO.Drop(object, count, destination)` — `UO.Drop(Any,Any,Any)`

`UO.Drop(objID, count, x, y, z)` — `UO.Drop(Any,Any,Any,Any,Any)`

`UO.DropCheckCoord()` — `UO.DropCheckCoord()`

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

`UO.DropDelay()` — `UO.DropDelay()`

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

`UO.DropHere(object)` — `UO.DropHere(Any)`