IT UO Topic client ui

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

Cliente UI

Home · C# · IDE · UO API · A–Z · Esempi · Lingue

Visualizza messaggi, finestre di servizio, visualizza oggetti e apre IDE. Questi passaggi non sostituiscono l'invio della voce al server.

Sezioni

Argomento	Comandi e spiegazioni
Print	UO.Print
ClientPrint	UO.ClientPrint
Info Window	UO.FillInfoWindow · UO.ClearInfoWindow · UO.FillNewWindow
Text Window	UO.TextOpen · UO.TextPrint · UO.TextClear · UO.TextClose
Gump semplici	UO.CloseSimpleGump
Close UI Window	UO.CloseClientUIWindow
Circle Transparency	UO.CircleTrans
Show Z	UO.SetShowZ
Open IDE	UO.OpenIDE

Tutti i comandi del tema

Esempi sull'argomento

Ogni carta comando ha diversi scenari indipendenti: codice diretto, funzioni e classi. Di seguito sono selezionati brevi scenari; restrizioni e un'analisi completa sono nelle carte.

UO.Print

Parametri, risultato e tutti gli scenari

var processed = 12;
UO.Print("Processed item entries: " + Convert.ToString(processed), 0x0044);

UO.FillInfoWindow

Parametri, risultato e tutti gli scenari

UO.FillInfoWindow("Status ready");

Riferimento completo dei comandi

UO.ActivateHandle

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

Firme C#

void UO.ActivateHandle();

Richiede a Windows/SDL di portare in primo piano la finestra del client corrente. Non ci sono argomenti né risultati. Questo è un comando della finestra, non un oggetto, un'abilità o un'applicazione di destinazione; la messa a fuoco effettiva dipende dal sistema di finestre.

Parametri

Non ci sono parametri.

Valore restituito

void. La chiamata richiede solo l'attivazione della finestra; non riconosce che il sistema a finestre lo ha portato in primo piano.

Comportamento

Il client apre la finestra di visualizzazione del gioco tramite SDL. Il comando non invia un pacchetto di gioco né esegue un'azione nel mondo. Una finestra ridotta a icona o limitazioni del sistema di finestre potrebbero impedire l'effettiva messa a fuoco.
RequireGameView richiede Client.Game. Se la finestra grafica ClassicUO non è aperta, il ponte lancia InvalidOperationException. SDL_RaiseWindow richiede l'apertura di una finestra esistente; La decisione sulla messa a fuoco è lasciata al sistema a finestre.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Richiedere che la finestra del client venga portata in primo piano. - sceneggiatura diretta

Parametri e flusso di esecuzione:

Richiedere che la finestra del client venga portata in primo piano.

UO.ActivateHandle();

2. Non richiedere il focus della finestra prima di connetterti al gioco. - funzione di script

Parametri e flusso di esecuzione:

Non richiedere il focus della finestra prima di connetterti al gioco.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Connected()))
    {
        UO.ActivateHandle();
    }

    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. Avvolgi l'azione della finestra in una procedura riutilizzabile. - lezione di sceneggiatura

Parametri e flusso di esecuzione:

Avvolgi l'azione della finestra in una procedura riutilizzabile.
Eseguire la richiesta tramite una procedura ausiliaria.

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()
    {
        RunAction();
        return null;
    }

    void RunAction()
    {
        UO.ActivateHandle();
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ActivateHandle()` — `UO.ActivateHandle()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public void ActivateHandle() => bridge.ActivateHandle();

UO.AddFigure

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

Firme C#

dynamic UO.AddFigure(object? figure);

Aggiunge una figura locale alla mappa del mondo ClassicUO e restituisce il suo ID. La figura viene memorizzata sul lato client, il server di gioco non viene informato.

Parametri

Valore restituito

int è il positivo ID della cifra aggiunta. Se i dati della cifra non sono corretti o la carta si rifiuta di aggiungerla, viene restituito 0. Trasferisci il ID ricevuto su UO.UpdateFigure o UO.RemoveFigure.

Comportamento

Crea una figura locale per WorldMapGump. Sono supportati linea, ellisse, rettangolo, freccia direzionale e testo. Le coordinate fcWorld seguono la trasformazione e la scala della mappa; fcScreen sono misurati rispetto alla finestra della mappa. Vengono visualizzate le forme per la sfaccettatura selezionata.

Formato array: [kind, coord, x1, y1, x2, y2, brushColor, brushStyle, color, worldNum, text]. kind: 0 linea, 1 ellisse, 2 rettangolo, 3 freccia direzionale, 4 testo. coord: schermata 0 world, 1. color utilizza l'ordine dei byte Delphi TColor (0x00BBGGRR). Per una freccia con coordinate mondiali e x2=0,y2=0, il punto iniziale è il carattere corrente. Gli storici brushColor e brushStyle sono adottati per compatibilità; l'ombreggiatura visiva non garantisce una corrispondenza completa con Delphi.

La figura rimane nella raccolta del cliente finché non viene eliminata/eliminata o il processo termina. Cambiando faccetta si nascondono solo le figure appartenenti ad un'altra faccetta.

È accettato un minimo di campi 9. Se manca worldNum viene utilizzata la carta corrente; senza testo, viene presa una stringa vuota. il tipo è limitato a 0..4, coordinata - 0..1; altri significati danno 0. Negativo worldNum consente la visualizzazione su qualsiasi aspetto. Il contatore ID viene incrementato prima che venga controllato SetYokoMapFigure, quindi un pezzo rifiutato può lasciare uno spazio vuoto in ID. Raccolta WorldMapGump statico in corso; gli script regolari di un gestore utilizzano uno stato di runtime persistente comune.
brushColor e brushStyle vengono salvati nella voce, ma il renderer corrente non li utilizza. La linea e il rettangolo vengono disegnati come un contorno; l'ellisse è composta da segmenti 32. La firma del testo viene disegnata solo per kind=4; altri tipi non lo emettono. color specifica il contorno nel formato COLORREF 0x00BBGGRR.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

object? result = UO.AddFigure(new object?[] { 0, 0, UO.X(), UO.Y(), UO.X() + 3, UO.Y(), 0, 0, 255 });
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Contorno rosso di un rettangolo sulla mappa di gioco - script diretto

Parametri e flusso di esecuzione:

kind=2 disegna un contorno rosso. Il campo testo con il valore Area viene salvato, ma per questa tipologia l'etichetta non viene disegnata; il testo restituisce kind=4.

dynamic[] fig = new dynamic[checked((int)(11) + 1)];
fig[0] = 2;
fig[1] = 0;
fig[2] = UO.GetX("self")-3;
fig[3] = UO.GetY("self")-3;
fig[4] = UO.GetX("self")+3;
fig[5] = UO.GetY("self")+3;
fig[6] = 0;
fig[7] = 1;
fig[8] = 255;
fig[9] = UO.WorldNum();
fig[10] = "Area";
var figureId = UO.AddFigure(fig);

2. Una freccia che va da un personaggio a un punto sulla mappa di gioco: una funzione dello script

Parametri e flusso di esecuzione:

Con le coordinate world e x2=0,y2=0 l'origine della freccia viene presa dalla posizione del carattere quando viene disegnata. il testo con il valore East per kind=3 non viene restituito.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] dirFig = new dynamic[checked((int)(11) + 1)];
    dirFig[0] = 3;
    dirFig[1] = 0;
    dirFig[2] = UO.GetX("self") + 10;
    dirFig[3] = UO.GetY("self");
    dirFig[4] = 0;
    dirFig[5] = 0;
    dirFig[6] = 0;
    dirFig[7] = 1;
    dirFig[8] = 65280;
    dirFig[9] = UO.WorldNum();
    dirFig[10] = "East";
    var arrowId = UO.AddFigure(dirFig);
    return null;
}

3. Crea una linea blu tra due punti della sfaccettatura corrente. - lezione di sceneggiatura

Parametri e flusso di esecuzione:

Crea una linea blu tra due punti della sfaccettatura corrente.

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()
    {
        dynamic[] lineFig = new dynamic[checked((int)(11) + 1)];
        lineFig[0] = 0;
        lineFig[1] = 0;
        lineFig[2] = UO.GetX("self");
        lineFig[3] = UO.GetY("self");
        lineFig[4] = UO.GetX("self") + 8;
        lineFig[5] = UO.GetY("self");
        lineFig[6] = 0;
        lineFig[7] = 1;
        lineFig[8] = 16711680;
        lineFig[9] = UO.WorldNum();
        lineFig[10] = "";
        var lineId = UO.AddFigure(lineFig);
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.AddFigure(figure)` — `UO.AddFigure(Any)`

Parametri: figure (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::TryMapFigureArg: TryMapFigureArg(0, out int[] figure, out string figureText).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetMapFigure: bridge.SetMapFigure(id, figure[0], figure[1], figure[2], figure[3], figure[4], figure[5], figure[6], figure[7], figure[8], figure[9], figureText).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::SerializeMapFigure: SerializeMapFigure(figure, figureText).

Codice interno di implementazione; non è uno script autonomo.

case "addfigure":

                {

                    if (!TryMapFigureArg(0, out int[] figure, out string figureText))

                        return InjectionValue.Zero;

                    int id = state.NextMapFigureId++;

                    if (bridge.SetMapFigure(id, figure[0], figure[1], figure[2], figure[3], figure[4], figure[5], figure[6], figure[7], figure[8], figure[9], figureText) == 0)

                        return InjectionValue.Zero;

                    state.MapFigures[id] = SerializeMapFigure(figure, figureText);

                    return new InjectionValue(id);

                }

UO.CharPrint

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

Firme C#

void UO.CharPrint(object? color, object? msg);
void UO.CharPrint(object? id, object? color, object? msg);

Crea un'iscrizione visibile solo a te sopra l'oggetto caricato: ad esempio, un segno del bersaglio selezionato o un avvertimento sopra il tuo personaggio. Questo non è il discorso del personaggio o il messaggio nella parte inferiore della finestra di gioco.

Parametri

id è il seriale dell'oggetto, non graphic/type o una coordinata. UO.CharPrint nella forma a tre argomenti comprende anche self, lasttarget e i nomi degli oggetti memorizzati. Per SenderID in UO.ClientPrintEx utilizzare un numero, ad esempio UO.Hex2Int(UO.GetSerial("self")); gli alias di stringa non vengono risolti come oggetti lì.
color è UO hue, non RGB. Vengono presi i bit 16 meno significativi del numero; 0x0044 è un esempio. -1 diventa 0xFFFF invece di significare "qualsiasi colore". Il colore ConColor non è utilizzato qui.

Valore restituito

Una chiamata a un metodo con un tipo restituito void viene scritta come un'istruzione autonoma C#; il risultato non può essere assegnato o controllato. Il completamento della dichiarazione non costituisce conferma da parte del server di gioco.

Comportamento

L'oggetto deve esistere nel mondo caricato e non essere eliminato; il testo vuoto o il target mancante non vengono disegnati. Il comando non scarica l'oggetto dal server. Il server e gli altri giocatori non ricevono questo messaggio. Senza la finestra di gioco, l'iscrizione non è visibile al mondo; non sostituisce il syslog del manager.
UO.CharPrint(color, msg) seleziona il suo personaggio. UO.CharPrint(id, color, msg) seleziona l'oggetto specificato. Entrambe le forme utilizzano il carattere 3. UO.ClientPrintEx richiede tutti e quattro gli argomenti nell'ordine SenderID, Colore, Carattere, Testo.
Il numero del carattere è UO, non la dimensione in punti o il nome del carattere di Windows. Il numero è limitato all'intervallo 0..255; La disponibilità di un carattere specifico dipende dai file di gioco. Nell'esempio, 3 è il numero del carattere normale.
GetSerial restituisce una stringa esadecimale. Hex2Int lo trasforma in un int prima di confrontarlo con il numero 0; la stringa "0x00000000" non può essere selezionata come numero 0.
UO.Print · UO.CharPrint · UO.ClientPrintEx · UO.AddToSystemJournalEx

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.CharPrint");
UO.CharPrint(0x0044, "Ready");

1. UO.CharPrint - 1 - sceneggiatura diretta

Parametri e flusso di esecuzione:

La prima forma CharPrint posiziona Ready sopra il suo carattere. ClientPrintEx lo riceve serial tramite UO.Hex2Int(UO.GetSerial("self")) e passa esplicitamente il carattere a 3. L'iscrizione non include alcuna modalità di gioco.
GetSerial restituisce una stringa esadecimale. Hex2Int lo trasforma in un int prima di confrontarlo con il numero 0; la stringa "0x00000000" non può essere selezionata come numero 0.

UO.CharPrint(0x0044, "Ready");

2. UO.CharPrint — 2 — funzione di script

Parametri e flusso di esecuzione:

target — serial dell'ultimo target. Zero significa che non c'è nessuno da taggare in questo esempio. Target selezionato - solo firma locale: il target non viene attaccato e il target del server attivo non viene riempito.
GetSerial restituisce una stringa esadecimale. Hex2Int lo trasforma in un int prima di confrontarlo con il numero 0; la stringa "0x00000000" non può essere selezionata come numero 0.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.Hex2Int(UO.GetSerial("lasttarget"));
    if (Truth(target != 0))
    {
        UO.CharPrint(target, 0x0044, "Selected 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. UO.CharPrint - 3 - classe dello scenario

Parametri e flusso di esecuzione:

ShowWeightWarning è dichiarato integralmente di seguito. Confronta il peso con un limite positivo noto e riscrive il suo personaggio solo quando è sovraccarico; non butta via niente. Convert.ToString trasforma il peso in testo.
GetSerial restituisce una stringa esadecimale. Hex2Int lo trasforma in un int prima di confrontarlo con il numero 0; la stringa "0x00000000" non può essere selezionata come numero 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()
    {
        ShowWeightWarning(UO.Weight(), UO.MaxWeight());
        return null;
    }

    void ShowWeightWarning(dynamic weight, dynamic maximum)
    {
        if (Truth(maximum > 0) && Truth(weight >= maximum))
        {
            UO.CharPrint(UO.Hex2Int(UO.GetSerial("self")), 0x0044, "Too heavy: " + Convert.ToString(weight));
        }
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.CharPrint(color, msg)` — `UO.CharPrint(Integer,String)`

Parametri: color (Integer/String), msg (String)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.CharPrint.
InjectionScript.Runtime.InjectionApiUO.CharPrint: CharPrint(bridge.Self, color, msg).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Codice interno di implementazione; non è uno script autonomo.

public void CharPrint(int color, string msg) => CharPrint(bridge.Self, color, msg);

`UO.CharPrint(color, msg)` — `UO.CharPrint(String,String)`

Parametri: color (Integer/String), msg (String)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.CharPrint.
InjectionScript.Runtime.InjectionApiUO.CharPrint: CharPrint(bridge.Self, NumberConversions.ToInt(color), msg).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Codice interno di implementazione; non è uno script autonomo.

public void CharPrint(string color, string msg) => CharPrint(bridge.Self, NumberConversions.ToInt(color), msg);

`UO.CharPrint(id, color, msg)` — `UO.CharPrint(Any,Any,Any)`

Parametri: id (Any/Integer), color (Any/Integer), msg (Any/String)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.CharPrint.
InjectionScript.Runtime.InjectionApiUO.CharPrint: CharPrint(GetObject(id), NumberConversions.ToInt(color), (string)msg).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).

Codice interno di implementazione; non è uno script autonomo.

public void CharPrint(InjectionValue id, InjectionValue color, InjectionValue msg) 

            => CharPrint(GetObject(id), NumberConversions.ToInt(color), (string)msg);

`UO.CharPrint(id, color, msg)` — `UO.CharPrint(Integer,Integer,String)`

Parametri: id (Any/Integer), color (Any/Integer), msg (Any/String)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.CharPrint.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CharPrint: bridge.CharPrint(id, color, msg).

Codice interno di implementazione; non è uno script autonomo.

public void CharPrint(int id, int color, string msg) => bridge.CharPrint(id, color, msg);

UO.CircleTrans

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

Firme C#

int UO.CircleTrans();
void UO.CircleTrans(object? enabled);

Legge o modifica l'impostazione del cerchio di trasparenza del profilo attivo.

Parametri

enabled - int: 0 disabilita, qualsiasi valore diverso da zero abilita. Senza argomenti, l'impostazione è di sola lettura.

Valore restituito

Senza argomento int 1/0; la forma con un argomento restituisce null.

Comportamento

La lettura in assenza di profilo dà 0. Una voce senza profilo stampa un errore; se c'è un profilo, cambia UseCircleOfTransparency e salva il profilo. Questa è una personalizzazione visiva del client.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

La lettura non cambia il profilo.

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

2. Abilita trasparenza - Funzione script

Parametri e flusso di esecuzione:

La registrazione mantiene attivo il cerchio di trasparenza.

return  RunScenario();
 object? RunScenario()
{
    UO.CircleTrans(1);
    return null;
}

3. Ripristina valore precedente - Classe script

Parametri e flusso di esecuzione:

Il flag salvato viene ripristinato dopo una modifica temporanea dell'impostazione.

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.CircleTrans();
        UO.CircleTrans(0);
        UO.CircleTrans(previous);
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.CircleTrans()` — `UO.CircleTrans()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

`UO.CircleTrans(enabled)` — `UO.CircleTrans(Integer)`

Parametri: enabled (Integer)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

UO.ClearFigures

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

Firme C#

void UO.ClearFigures();

Elimina tutte le forme di mappa personalizzate e le relative voci di runtime.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

Cancella WorldMapGump.ClearYokoMapFigures e state.MapFigures. La mappa base e UserStatics non sono cambiate.
ClearYokoMapFigures cancella la raccolta statica di WorldMapGump in corso, quindi il comando cancella MapFigures dal suo stato di runtime. L'ambito della pulizia è determinato dalla raccolta client complessiva, non solo dal nome dello script chiamante.
Vengono mantenute le normali etichette della mappa personalizzata (userMarkers.usr).

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Stato chiaro: sceneggiatura diretta

Parametri e flusso di esecuzione:

Elimina tutte le forme di mappa personalizzate e le relative voci di runtime.

UO.ClearFigures();

2. Cancella dopo l'installazione - funzione script

Parametri e flusso di esecuzione:

Crea una forma locale per la mappa corrente, quindi elimina tutte le forme personalizzate.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] figure = new dynamic[checked((int)(9) + 1)];
    figure[0] = 0;
    figure[1] = 0;
    figure[2] = UO.GetX();
    figure[3] = UO.GetY();
    figure[4] = figure[2] + 1;
    figure[5] = figure[3] + 1;
    figure[6] = 0;
    figure[7] = 0;
    figure[8] = 0;
    figure[9] = UO.WorldNum();
    var figureId = UO.AddFigure(figure);
    UO.ClearFigures();
    return null;
}

3. Rieliminazione: classe di script

Parametri e flusso di esecuzione:

La cancellazione di un set vuoto è accettabile e non crea una nuova impostazione.

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ClearFigures()` — `UO.ClearFigures()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "clearfigures":

                    bridge.ClearMapFigures();

                    state.MapFigures.Clear();

                    return InjectionValue.Unit;

UO.ClearInfoWindow

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

Firme C#

void UO.ClearInfoWindow();

Cancella le righe della finestra di testo del client.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

TextClear cancella il buffer; se la finestra era aperta, la aggiorna con contenuto vuoto. La finestra non si chiude necessariamente.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Stato chiaro: sceneggiatura diretta

Parametri e flusso di esecuzione:

Cancella le righe della finestra di testo del client.

UO.ClearInfoWindow();

2. Cancella dopo l'installazione - funzione script

Parametri e flusso di esecuzione:

Cancella una riga della finestra di testo aggiunta in precedenza.

return  RunScenario();
 object? RunScenario()
{
    UO.FillInfoWindow("status");
    UO.ClearInfoWindow();
    return null;
}

3. Rieliminazione: classe di script

Parametri e flusso di esecuzione:

La cancellazione di un set vuoto è accettabile e non crea una nuova impostazione.

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ClearInfoWindow()` — `UO.ClearInfoWindow()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "clearinfowindow": bridge.TextClear(); return InjectionValue.Unit;

UO.ClientHide

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

Firme C#

dynamic UO.ClientHide(object? objID);

Nasconde serial un oggetto caricato o un altro personaggio solo nella visualizzazione ClassicUO, inclusi contenitori, bambole di carta e oggetti equipaggiati.

Parametri

objID — Seriale dell'oggetto specifico caricato: int o stringa esadecimale/decimale. Questo non è graphic/type. Per un nome salvato, utilizzare GetSerial(nome). Il parametro è obbligatorio; la vista non appare.

Valore restituito

int 1 dopo aver trasmesso il comando della plancia. Il risultato storico non conferma la presenza dell'oggetto: anche per un bridge serial o self sconosciuto restituisce un errore e il runtime restituisce 1. Non utilizzare questo valore come test per nascondersi con successo. I metadati di compatibilità mostrano object?.

Comportamento

È richiesto esattamente un argomento. Per selezionare con il mouse, utilizzare UO.Hide().
Hide(serial) agisce immediatamente su un oggetto caricato noto. Passa serial di uno stack/oggetto specifico anziché graphic/type. Lo stack selezionato viene completamente nascosto, indipendentemente dall'importo.
L'articolo rimane nel contenitore: quantità, proprietario, contenuto e stato del server non cambiano. FindType/GetContent riesce ancora a trovarlo. Nascondere non è un filtro di ricerca, un riporto, un'eliminazione, una capacità di nascondere o un'invisibilità lato server.
Il contenitore normale, la finestra di scambio e la griglia del bottino non disegnano l'oggetto nascosto e non accettano clic/trascinamenti su di esso. Il flag persiste quando la finestra viene ricostruita e riaperta mentre è in uso lo stesso oggetto caricato.
L'oggetto equipaggiato scompare dalla bambola di carta, dalla piccola fessura e dall'immagine del personaggio. Resta equipaggiato: il layer, l'armatura e lo stato sul server non cambiano. La veste nascosta non si sovrappone più alla biancheria intima. L'immagine del personaggio nel gestore viene aggiornata utilizzando lo stesso flag; l'elenco delle attrezzature effettive rimane disponibile.
Hide non nasconde il proprio carattere, il proprio territorio e la propria statica. L'inesistente serial dà un messaggio. Nascondere la borsa stessa non chiude la finestra del contenuto già aperta, né nasconde automaticamente ogni articolo incluso.
Non esiste un comando Scopri separato nell'attuale API. Nascondere appartiene all'istanza dell'oggetto caricato: rimuoverlo dal mondo client e caricarlo nuovamente (ad esempio, quando ci si ricollega) reimposta il flag. La semplice chiusura/apertura di un baule non è un modo garantito per restituire un articolo.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

1. Nascondi elemento con il noto ID - script diretto

Parametri e flusso di esecuzione:

ObjID è un elemento specifico, non il suo type. Scompare dal display, rimanendo nel suo contenitore.

var item = 0x40001234;
if (Truth(UO.Exists(item)))
{
    UO.ClientHide(item);
}

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

2. Nascondi stack trovato - Funzione script

Parametri e flusso di esecuzione:

FindType cerca graphic 0x0EED di qualsiasi colore in backpack. Il serial restituito viene trasmesso a ClientHide; l'intero stack è completamente nascosto.

return  RunScenario();
 object? RunScenario()
{
    var item = UO.FindType(0x0EED, -1, "backpack");
    if (Truth(item != ""))
    {
        UO.ClientHide(item);
        UO.Print("Amount is still: " + Convert.ToString(UO.GetQuantity(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. Utilizza Oggetto con nome - Classe script

Parametri e flusso di esecuzione:

GetSerial risolve il nome della decorazione precedentemente salvata. L'oggetto deve prima essere caricato, ad esempio aprendo il suo contenitore.

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.GetSerial("decoration");
        if (Truth(UO.Exists(item)) && Truth(item != UO.GetSerial("self")))
        {
            UO.ClientHide(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;
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: objID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "clienthide": bridge.ClientHide(Arg(0)); return InjectionValue.True;

UO.ClientMarkChar

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

Firme C#

void UO.ClientMarkChar(object? actionIndex, object? id);

Aggiorna le etichette del client LastTarget e/o LastAttack.

Parametri

actionIndex - int: 1 - LastTarget; 2 - LastAttack; 3 - entrambi. Altri valori stampano un errore.
id — Numero seriale dell'oggetto o nome supportato di self/backpack/lasttarget/oggetto salvato; le stringhe numeriche e le stringhe 0x vengono risolte dal runtime.

Valore restituito

void: nessun valore restituito.

Comportamento

ClientMarkChar modifica gli obiettivi salvati senza inviare un attacco o rispondere al server di destinazione. I comandi successivi possono utilizzare la nuova etichetta.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.ClientMarkChar");
UO.ClientMarkChar(1, "self");

1. Aggiornamento LastTarget - script diretto

Parametri e flusso di esecuzione:

Il bersaglio salvato diventa il tuo personaggio.

UO.ClientMarkChar(1,"self");

2. Aggiorna entrambe le etichette: funzione script

Parametri e flusso di esecuzione:

Quest'ultimo target viene utilizzato per entrambi i tag client.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.LastTarget();
    if (Truth(UO.Exists(target)))
    {
        UO.ClientMarkChar(3, 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. Azione errata - Classe script

Parametri e flusso di esecuzione:

Zero non fa parte del set di azioni e genera un messaggio di errore.

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.ClientMarkChar(0, "self");
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ClientMarkChar(actionIndex, id)` — `UO.ClientMarkChar(Any,Any)`

Parametri: actionIndex (Any), id (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ClientMarkChar.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClientMarkChar: bridge.ClientMarkChar(NumberConversions.ToInt(actionIndex), GetObject(id)).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(actionIndex).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

Codice interno di implementazione; non è uno script autonomo.

public void ClientMarkChar(InjectionValue actionIndex, InjectionValue id)

            => bridge.ClientMarkChar(NumberConversions.ToInt(actionIndex), GetObject(id));

UO.ClientPrint

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

Firme C#

void UO.ClientPrint(object? text);

Mostra un messaggio locale sull'avanzamento dello script o sulla condizione di arresto. Lo vedi tu, non gli altri giocatori.

Parametri

Valore restituito

Una chiamata a un metodo con un tipo restituito void viene scritta come un'istruzione autonoma C#; il risultato non può essere assegnato o controllato. Il completamento della dichiarazione non costituisce conferma da parte del server di gioco.

Comportamento

Il messaggio va nell'area in basso a sinistra della finestra di gioco e nel registro locale. Una copia è disponibile nell'output IDE. Nel registro generale del manager, attiva il filtro dei messaggi script: la voce è disponibile senza la finestra di gioco. Il filtro dei messaggi del sistema server non seleziona tali record. Il pacchetto vocale di rete non viene inviato. Per la scritta sopra la testa c'è UO.CharPrint.
UO.Print aggiunge una nuova voce al registro dei messaggi del gioco: prima leggi o salva la stringa/risultato di ricerca desiderato, quindi registra il messaggio diagnostico. In un ciclo veloce, registra i messaggi quando si verificano le modifiche anziché a ogni iterazione.
Viene utilizzato il colore dei messaggi di sistema di questo script runtime: inizialmente 0x0440, modificato UO.ConColor. Questa è una voce locale; il nome del comando non significa invio al server.
UO.Print · UO.CharPrint · UO.Say · UO.ConColor

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata senza valore restituito (void). Il testo del messaggio è indicato direttamente nella chiamata.

UO.ClientPrint("Hello from C#");

1. Breve relazione - sceneggiatura diretta

Parametri e flusso di esecuzione:

elaborato=12 — numero demo di elementi già elaborati. Convert.ToString lo trasforma in una stringa. Questo esempio riporta solo un numero; non trasferisce gli oggetti stessi.

var processed = 12;
UO.ClientPrint("Processed item entries: " + Convert.ToString(processed));

2. Avviso di sovraccarico - Funzione script

Parametri e flusso di esecuzione:

Vengono letti il peso e il massimo del personaggio. Un massimo pari a zero/sconosciuto non è considerato un sovraccarico. Se peso >= massimo, viene stampata una riga e Principale termina; gli oggetti non vengono buttati via.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.ClientPrint("Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum));
        return null;
    }

    return null;
}

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

3. Segnala solo modifiche del peso: classe di script

Parametri e flusso di esecuzione:

Main ricorda il peso, attende 1000 millisecondi e chiama il ReportWeight completamente dichiarato. L'assistente stampa solo se il peso è cambiato e restituisce il nuovo peso per il controllo successivo. Di per sé non crea un ciclo infinito.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.ClientPrint("Weight changed: " + Convert.ToString(current));
        }

        return current;
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ClientPrint(text)` — `UO.ClientPrint(Any)`

Parametri: text (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage(Text(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "addtojournal":

                case "addtosystemjournal":

                case "clientprint":

                    SystemMessage(Text(0)); return InjectionValue.Unit;

UO.ClientPrintEx

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

Firme C#

void UO.ClientPrintEx(object? senderID, object? color, object? font, object? text);

Crea un'iscrizione visibile solo a te sopra l'oggetto caricato: ad esempio, un segno del bersaglio selezionato o un avvertimento sopra il tuo personaggio. Questo non è il discorso del personaggio o il messaggio nella parte inferiore della finestra di gioco.

Parametri

senderID è il seriale dell'oggetto, non graphic/type o una coordinata. UO.CharPrint nella forma a tre argomenti comprende anche self, lasttarget e i nomi degli oggetti memorizzati. Per SenderID in UO.ClientPrintEx utilizzare un numero, ad esempio UO.Hex2Int(UO.GetSerial("self")); gli alias di stringa non vengono risolti come oggetti lì.
color è UO hue, non RGB. Vengono presi i bit 16 meno significativi del numero; 0x0044 è un esempio. -1 diventa 0xFFFF invece di significare "qualsiasi colore". Il colore ConColor non è utilizzato qui.
font: numero del carattere UO, non la dimensione in punti o il nome del carattere di Windows. Il numero è limitato all'intervallo 0..255; La disponibilità di un carattere specifico dipende dai file di gioco. Nell'esempio, 3 è il numero del carattere normale.

Valore restituito

Una chiamata a un metodo con un tipo restituito void viene scritta come un'istruzione autonoma C#; il risultato non può essere assegnato o controllato. Il completamento della dichiarazione non costituisce conferma da parte del server di gioco.

Comportamento

L'oggetto deve esistere nel mondo caricato e non essere eliminato; il testo vuoto o il target mancante non vengono disegnati. Il comando non scarica l'oggetto dal server. Il server e gli altri giocatori non ricevono questo messaggio. Senza la finestra di gioco, l'iscrizione non è visibile al mondo; non sostituisce il syslog del manager.
UO.CharPrint(color, msg) seleziona il suo personaggio. UO.CharPrint(id, color, msg) seleziona l'oggetto specificato. Entrambe le forme utilizzano il carattere 3. UO.ClientPrintEx richiede tutti e quattro gli argomenti nell'ordine SenderID, Colore, Carattere, Testo.
Il numero del carattere è UO, non la dimensione in punti o il nome del carattere di Windows. Il numero è limitato all'intervallo 0..255; La disponibilità di un carattere specifico dipende dai file di gioco. Nell'esempio, 3 è il numero del carattere normale.
GetSerial restituisce una stringa esadecimale. Hex2Int lo trasforma in un int prima di confrontarlo con il numero 0; la stringa "0x00000000" non può essere selezionata come numero 0.
UO.Print · UO.CharPrint · UO.ClientPrintEx · UO.AddToSystemJournalEx

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.ClientPrintEx");
UO.ClientPrintEx(UO.Hex2Int(UO.GetSerial("self")), 0x0044, 3, "Ready");

1. UO.ClientPrintEx - 1 - sceneggiatura diretta

Parametri e flusso di esecuzione:

La prima forma CharPrint posiziona Ready sopra il suo carattere. ClientPrintEx lo riceve serial tramite UO.Hex2Int(UO.GetSerial("self")) e passa esplicitamente il carattere a 3. L'iscrizione non include alcuna modalità di gioco.
GetSerial restituisce una stringa esadecimale. Hex2Int lo trasforma in un int prima di confrontarlo con il numero 0; la stringa "0x00000000" non può essere selezionata come numero 0.

UO.ClientPrintEx(UO.Hex2Int(UO.GetSerial("self")), 0x0044, 3, "Ready");

2. UO.ClientPrintEx — 2 — funzione di script

Parametri e flusso di esecuzione:

target — serial dell'ultimo target. Zero significa che non c'è nessuno da taggare in questo esempio. Target selezionato - solo firma locale: il target non viene attaccato e il target del server attivo non viene riempito.
GetSerial restituisce una stringa esadecimale. Hex2Int lo trasforma in un int prima di confrontarlo con il numero 0; la stringa "0x00000000" non può essere selezionata come numero 0.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.Hex2Int(UO.GetSerial("lasttarget"));
    if (Truth(target != 0))
    {
        UO.ClientPrintEx(target, 0x0044, 3, "Selected 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. UO.ClientPrintEx - 3 - classe dello scenario

Parametri e flusso di esecuzione:

ShowWeightWarning è dichiarato integralmente di seguito. Confronta il peso con un limite positivo noto e riscrive il suo personaggio solo quando è sovraccarico; non butta via niente. Convert.ToString trasforma il peso in testo.
GetSerial restituisce una stringa esadecimale. Hex2Int lo trasforma in un int prima di confrontarlo con il numero 0; la stringa "0x00000000" non può essere selezionata come numero 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()
    {
        ShowWeightWarning(UO.Weight(), UO.MaxWeight());
        return null;
    }

    void ShowWeightWarning(dynamic weight, dynamic maximum)
    {
        if (Truth(maximum > 0) && Truth(weight >= maximum))
        {
            UO.ClientPrintEx(UO.Hex2Int(UO.GetSerial("self")), 0x0044, 3, "Too heavy: " + Convert.ToString(weight));
        }
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ClientPrintEx(senderID, color, font, text)` — `UO.ClientPrintEx(Any,Any,Any,Any)`

Parametri: senderID (Any), color (Any), font (Any), text (Any)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "clientprintex":

                    bridge.CharPrintEx(Arg(0), Arg(1), Arg(2), Text(3)); return InjectionValue.Unit;

UO.CloseClientUIWindow

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

Firme C#

void UO.CloseClientUIWindow(object? uiWindowType, object? id);

Chiude la finestra del client locale del tipo specificato per un oggetto specifico. Ad esempio, puoi rimuovere la bambola di carta del personaggio, il suo stato o la finestra dello zaino. Il comando non chiude il client di gioco e non risponde ai pulsanti gump del server.

Parametri

uiWindowType — Codice finestra numerico obbligatorio: 0 — paperdoll (attrezzatura), 1 — stato del personaggio, 2 — profilo, 3 — contenitore. Questo è un elenco separato di quattro codici, non graphic/type body e non ID server gump. Altri numeri non trovano la finestra.
id — Seriale dell'oggetto a cui appartiene la finestra: carattere self/serial per i tipi 0..2, contenitore backpack/serial per il tipo 3. Accetta un numero, una stringa esadecimale o un alias di oggetto risolvibile. Questo non è il numero della finestra nell'elenco InfoGumps. Un alias di oggetto sconosciuto viene convertito in 0.

Valore restituito

void - nessun valore. La chiamata viene scritta su una riga separata, senza var risultato = e senza if UO.CloseClientUIWindow(...). Se non c'è una finestra aperta adatta, non succede nulla; il comando non restituisce true/false.

Comportamento

Entrambi i parametri sono obbligatori. Vengono confrontate sia la classe della finestra che LocalSerial. Chiamare con (3, self) non significa zaino: lo zaino richiede backpack.
Il bypass influisce sulle finestre aperte e non ancora distrutte di questo tipo/serial; tutte le finestre corrispondenti vengono chiuse nel thread del gioco. Le restanti finestre rimangono aperte.
L'interfaccia si chiude, gli oggetti non vengono rimossi dal contenitore e il personaggio non scompare dal mondo. È lecito ripetere: se la finestra è già chiusa, non c'è corrispondenza.
Per le finestre di dialogo lato server, studia UO.CloseSimpleGump e UO.NumGumpButton; i codici 0..3 di questo comando non si applicano lì.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.CloseClientUIWindow");
UO.CloseClientUIWindow(0, "self");

1. Rimuovi la tua bambola di carta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Si chiude solo la finestra dell'equipaggiamento del tuo personaggio; il suo stato, profilo e zaino rimangono finestre separate.

UO.CloseClientUIWindow(0, "self");

2. Chiudi la finestra dello zaino dopo aver lavorato con le cose - funzione script

Parametri e flusso di esecuzione:

Se lo zaino non è stato aperto l'azione non cambierà nulla. Questo comando non sposta gli elementi e non restituisce un risultato.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Connected()) && Truth(UO.Exists("backpack")))
    {
        UO.CloseClientUIWindow(3, "backpack");
    }

    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. Rimuovi lo stato e il profilo del personaggio selezionato - classe dello scenario

Parametri e flusso di esecuzione:

1 - stato, 2 - profilo. l'id è serial del mobile selezionato. ASC(testo,0) qui analizza la stringa serial in un numero con un 0 di riserva. La procedura utente non promette nulla circa la presenza di una finestra; entrambe le chiamate hanno Unit.

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 selected = Asc(UO.GetSerial("lasttarget"), 0);
        CloseMobilePanels(selected);
        return null;
    }

    void CloseMobilePanels(dynamic id)
    {
        if (Truth(id == 0) || !(Truth(UO.Exists(id))))
        {
            return;
        }

        UO.CloseClientUIWindow(1, id);
        UO.CloseClientUIWindow(2, id);
    }

    int Asc(object? value, int fallback = 0)
    {
        string text = Convert.ToString(value) ?? "";
        if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
            return int.TryParse(text[2..], System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out int hex) ? hex : fallback;
        return int.TryParse(text, out int number) ? number : fallback;
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.CloseClientUIWindow(uiWindowType, id)` — `UO.CloseClientUIWindow(Any,Any)`

Parametri: uiWindowType (Any), id (Any)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "closeclientuiwindow": bridge.CloseClientWindow(Arg(0), Arg(1)); return InjectionValue.Unit;

UO.CloseHandle

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

Firme C#

void UO.CloseHandle();

Richiede all'applicazione client corrente di uscire tramite Client.Game.Exit.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

CloseUO viene inviato allo stesso bridge.CloseHandle. L'uscita viene eseguita nel thread del gioco; se manca Client.Game, non viene eseguita alcuna azione. Il comando non è l'arresto di un gump separato.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Termina client - Script diretto

Parametri e flusso di esecuzione:

La chiamata richiede la chiusura dell'applicazione client.

UO.CloseHandle();

2. Condizione di terminazione esplicita - funzione dello script

Parametri e flusso di esecuzione:

L'esempio mostra una condizione controllata; il valore 0 mantiene il client aperto.

return  RunScenario();
 object? RunScenario()
{
    var finishClient = 0;
    if (Truth(finishClient))
    {
        UO.CloseHandle();
    }

    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. Procedura di completamento - Classe di script

Parametri e flusso di esecuzione:

Un helper completamente dichiarato consente l'abilitazione esplicita dell'uscita.

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()
    {
        FinishClient(0);
        return null;
    }

    void FinishClient(dynamic enabled)
    {
        if (Truth(enabled))
        {
            UO.CloseHandle();
        }
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.CloseHandle()` — `UO.CloseHandle()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public void CloseHandle() => bridge.CloseHandle();

UO.CloseSimpleGump

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

Firme C#

void UO.CloseSimpleGump(object? gumpIndex);

Chiude localmente un server gump che può essere chiuso da un indice rigoroso.

Parametri

gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.

Valore restituito

void: non restituisce nulla. Il risultato non può essere interpretato come conferma del server o bool.

Comportamento

Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
Indice non valido e NoClose non cambiano nulla. Il comando non invia la risposta del pulsante al server. Per questa risposta, usa SendGumpSelect.
La chiusura modifica l'elenco e gli indici. Per chiudere in massa, attraversa l'elenco dall'ultimo indice al primo.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiudi la prima finestra - script diretto

Parametri e flusso di esecuzione:

0 è un indice, non ID. Se la finestra impedisce la chiusura, rimane aperta.

UO.CloseSimpleGump(0);

2. Chiudi tutte le finestre abilitate - funzione script

Parametri e flusso di esecuzione:

L'attraversamento inverso riduce l'impatto degli spostamenti dell'indice post-chiusura. Quando si aprono nuove finestre in parallelo, controllare nuovamente l'elenco.

return  RunScenario();
 object? RunScenario()
{
    var i = UO.GetGumpsCount() - 1;
    while (Truth(i >= 0))
    {
        UO.CloseSimpleGump(i);
        i = i - 1;
    }

    return null;
}

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

3. Salva le informazioni prima di chiudere - lezione di script

Parametri e flusso di esecuzione:

info[1] - GumpID salvato. L'azione non restituisce nulla, quindi il risultato non viene assegnato alla variabile.

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

     public object? RunScenario()
    {
        var info = UO.GetGumpInfo(0);
        if (Truth(ArrayLength(info) == 5))
        {
            UO.CloseSimpleGump(0);
            UO.Print(Hex(info[1]));
        }

        return null;
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: gumpIndex (Any)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "closesimplegump":

                    if (bridge is IApiGumpAccess gumpAccess) gumpAccess.CloseGumpAtIndex(Arg(0));

                    else bridge.CloseSimpleGump(Arg(0));

                    return InjectionValue.Unit;

UO.ColorPrint

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

Firme C#

void UO.ColorPrint(object? color, object? msg);

Mostra un messaggio locale sull'avanzamento dello script o sulla condizione di arresto. Lo vedi tu, non gli altri giocatori.

Parametri

color - UO hue, non RGB. Numero o stringa esadecimale; il bridge utilizza i bit bassi 16. Da non confondere con graphic/type. 0x0044 nell'esempio è il hue selezionato. Senza colore, viene utilizzato hue 0x03B2. UO.Print(text, color) accetta prima il testo; UO.ColorPrint(color, text) – colora prima.

Valore restituito

Una chiamata a un metodo con un tipo restituito void viene scritta come un'istruzione autonoma C#; il risultato non può essere assegnato o controllato. Il completamento della dichiarazione non costituisce conferma da parte del server di gioco.

Comportamento

Il messaggio va nell'area in basso a sinistra della finestra di gioco e nel registro locale. Una copia è disponibile nell'output IDE. Nel registro generale del manager, attiva il filtro dei messaggi script: la voce è disponibile senza la finestra di gioco. Il filtro dei messaggi del sistema server non seleziona tali record. Il pacchetto vocale di rete non viene inviato. Per la scritta sopra la testa c'è UO.CharPrint.
UO.Print aggiunge una nuova voce al registro dei messaggi del gioco: prima leggi o salva la stringa/risultato di ricerca desiderato, quindi registra il messaggio diagnostico. In un ciclo veloce, registra i messaggi quando si verificano le modifiche anziché a ogni iterazione.
Senza colore, viene utilizzato hue 0x03B2. UO.Print(text, color) accetta prima il testo; UO.ColorPrint(color, text) – colora prima.
UO.Print · UO.CharPrint · UO.Say · UO.ConColor

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata senza valore restituito (void). Il testo del messaggio è indicato direttamente nella chiamata.

UO.ColorPrint(0x0044, "Hello from C#");

1. Breve relazione - sceneggiatura diretta

Parametri e flusso di esecuzione:

elaborato=12 — numero demo di elementi già elaborati. Convert.ToString lo trasforma in una stringa. Questo esempio riporta solo un numero; non trasferisce gli oggetti stessi.

var processed = 12;
UO.ColorPrint(0x0044, "Processed item entries: " + Convert.ToString(processed));

2. Avviso di sovraccarico - Funzione script

Parametri e flusso di esecuzione:

Vengono letti il peso e il massimo del personaggio. Un massimo pari a zero/sconosciuto non è considerato un sovraccarico. Se peso >= massimo, viene stampata una riga e Principale termina; gli oggetti non vengono buttati via.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.ColorPrint(0x0044, "Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum));
        return null;
    }

    return null;
}

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

3. Segnala solo modifiche del peso: classe di script

Parametri e flusso di esecuzione:

Main ricorda il peso, attende 1000 millisecondi e chiama il ReportWeight completamente dichiarato. L'assistente stampa solo se il peso è cambiato e restituisce il nuovo peso per il controllo successivo. Di per sé non crea un ciclo infinito.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.ColorPrint(0x0044, "Weight changed: " + Convert.ToString(current));
        }

        return current;
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ColorPrint(color, msg)` — `UO.ColorPrint(Any,Any)`

Parametri: color (Any), msg (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ColorPrint.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Print: bridge.Print(NumberConversions.ToInt(color), msg.ToString()).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).
InjectionScript.Runtime.InjectionValue.ToString: msg.ToString().

Codice interno di implementazione; non è uno script autonomo.

public void ColorPrint(InjectionValue color, InjectionValue msg) => bridge.Print(NumberConversions.ToInt(color), msg.ToString());

UO.ConColor

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

Firme C#

void UO.ConColor(object? color);

Imposta UO hue per i successivi messaggi di sistema di questo runtime di script.

Parametri

color - UO hue, non RGB. Numero o stringa esadecimale; il bridge utilizza i bit bassi 16. Da non confondere con graphic/type. 0x0044 nell'esempio è il hue selezionato.

Valore restituito

Una chiamata a un metodo con un tipo restituito void viene scritta come un'istruzione autonoma C#; il risultato non può essere assegnato o controllato. Il completamento della dichiarazione non costituisce conferma da parte del server di gioco.

Comportamento

Influisce sui successivi UO.ClientPrint, UO.AddToJournal e UO.AddToSystemJournal. Non ricolora le righe precedenti, non cambia il profilo SpeechHue e non cambia il colore di UO.Print senza un argomento colore. Il vecchio getter di colore non è qui: memorizza il normale hue selezionato nella sua variabile.
UO.Print · UO.CharPrint · UO.Say · UO.ConColor

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.ConColor");
UO.ConColor(0x0044);

1. UO.ConColor - 1 - sceneggiatura diretta

Parametri e flusso di esecuzione:

0x0044 diventa il colore della successiva linea di sistema. ConColor stesso non stampa nulla.

UO.ConColor(0x0044);
UO.AddToSystemJournal("Notice");

2. UO.ConColor — 2 — funzione di script

Parametri e flusso di esecuzione:

Il normale Print mantiene il suo colore 0x03B2 e AddToJournal utilizza il 0x0044 specificato. Entrambi i messaggi sono locali.

return  RunScenario();
 object? RunScenario()
{
    UO.ConColor(0x0044);
    UO.Print("Normal Print color");
    UO.AddToJournal("System color");
    return null;
}

3. UO.ConColor - 3 - classe dello scenario

Parametri e flusso di esecuzione:

usualHue=0x0440 è chiaramente il colore normale selezionato, non il vecchio valore letto. La prova utilizza il temporaneo 0x0035; finally restituisce usualHue, quindi la riga successiva viene stampata nuovamente a colori normali.

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 usualHue = 0x0440;
        UO.ConColor(usualHue);
        try
        {
            UO.ConColor(0x0035);
            UO.AddToSystemJournal("Temporary warning");
        }
        finally
        {
            UO.ConColor(usualHue);
        }

        UO.AddToSystemJournal("Normal messages again");
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ConColor(color)` — `UO.ConColor(Any)`

Parametri: color (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ConColor.
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).

Codice interno di implementazione; non è uno script autonomo.

public void ConColor(InjectionValue color)

        {

            systemMessageColor = NumberConversions.ToInt(color);

        }

UO.ConsolePrint

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

Firme C#

void UO.ConsolePrint(object? msg);

Mostra un messaggio locale sull'avanzamento dello script o sulla condizione di arresto. Lo vedi tu, non gli altri giocatori.

Parametri

Valore restituito

Una chiamata a un metodo con un tipo restituito void viene scritta come un'istruzione autonoma C#; il risultato non può essere assegnato o controllato. Il completamento della dichiarazione non costituisce conferma da parte del server di gioco.

Comportamento

Il messaggio va nell'area in basso a sinistra della finestra di gioco e nel registro locale. Una copia è disponibile nell'output IDE. Nel registro generale del manager, attiva il filtro dei messaggi script: la voce è disponibile senza la finestra di gioco. Il filtro dei messaggi del sistema server non seleziona tali record. Il pacchetto vocale di rete non viene inviato. Per la scritta sopra la testa c'è UO.CharPrint.
UO.Print aggiunge una nuova voce al registro dei messaggi del gioco: prima leggi o salva la stringa/risultato di ricerca desiderato, quindi registra il messaggio diagnostico. In un ciclo veloce, registra i messaggi quando si verificano le modifiche anziché a ogni iterazione.
Senza colore, viene utilizzato hue 0x03B2. UO.Print(text, color) accetta prima il testo; UO.ColorPrint(color, text) – colora prima.
Nonostante la Console nel nome, si tratta dello stesso output del gioco locale, non di un terminale Windows separato.
UO.Print · UO.CharPrint · UO.Say · UO.ConColor

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata senza valore restituito (void). Il testo del messaggio è indicato direttamente nella chiamata.

UO.ConsolePrint("Hello from C#");

1. Breve relazione - sceneggiatura diretta

Parametri e flusso di esecuzione:

elaborato=12 — numero demo di elementi già elaborati. Convert.ToString lo trasforma in una stringa. Questo esempio riporta solo un numero; non trasferisce gli oggetti stessi.

var processed = 12;
UO.ConsolePrint("Processed item entries: " + Convert.ToString(processed));

2. Avviso di sovraccarico - Funzione script

Parametri e flusso di esecuzione:

Vengono letti il peso e il massimo del personaggio. Un massimo pari a zero/sconosciuto non è considerato un sovraccarico. Se peso >= massimo, viene stampata una riga e Principale termina; gli oggetti non vengono buttati via.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.ConsolePrint("Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum));
        return null;
    }

    return null;
}

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

3. Segnala solo modifiche del peso: classe di script

Parametri e flusso di esecuzione:

Main ricorda il peso, attende 1000 millisecondi e chiama il ReportWeight completamente dichiarato. L'assistente stampa solo se il peso è cambiato e restituisce il nuovo peso per il controllo successivo. Di per sé non crea un ciclo infinito.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.ConsolePrint("Weight changed: " + Convert.ToString(current));
        }

        return current;
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ConsolePrint(msg)` — `UO.ConsolePrint(Any)`

Parametri: msg (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ConsolePrint.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Print: bridge.Print(msg.ToString()).
InjectionScript.Runtime.InjectionValue.ToString: msg.ToString().

Codice interno di implementazione; non è uno script autonomo.

public void ConsolePrint(InjectionValue msg) => bridge.Print(msg.ToString());

UO.FillInfoWindow

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

Firme C#

void UO.FillInfoWindow(object? s);

Aggiunge una riga a una finestra di testo e la visualizza.

Parametri

s — Testo della riga; il valore viene convertito in string.

Valore restituito

void: nessun valore restituito.

Comportamento

Le righe precedentemente accumulate vengono conservate fino al limite MaxTextWindowLines.
TextPrint aggiunge una linea e mostra YokoTextWindowGump stesso; TextOpen protegge lo stato aperto. Quando il buffer trabocca, le righe più vecchie vengono cancellate. Questa è una finestra di testo separata, non un server gump e non UO.GetInfo.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.FillInfoWindow");
UO.FillInfoWindow("Status ready");

1. Mostra riga - script diretto

Parametri e flusso di esecuzione:

Il testo viene inviato alla finestra di testo del client.

UO.FillInfoWindow("Status ready");

2. Testo da variabile - funzione script

Parametri e flusso di esecuzione:

La stringa è formata dalla corrente locale HP.

return  RunScenario();
 object? RunScenario()
{
    var status = "HP: " + Convert.ToString(UO.GetHP());
    UO.FillInfoWindow(status);
    return null;
}

3. Due righe consecutive: classe di script

Parametri e flusso di esecuzione:

Il secondo comando aggiunge secondo dopo primo.

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.FillInfoWindow("first");
        UO.FillInfoWindow("second");
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.FillInfoWindow(s)` — `UO.FillInfoWindow(Any)`

Parametri: s (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextPrint: bridge.TextPrint(Text(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextOpen: bridge.TextOpen().

Codice interno di implementazione; non è uno script autonomo.

case "fillinfowindow":

                    bridge.TextPrint(Text(0));

                    bridge.TextOpen();

                    return InjectionValue.Unit;

UO.FillNewWindow

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

Firme C#

void UO.FillNewWindow(object? s);

Cancella la finestra di testo, aggiunge una riga e la mostra.

Parametri

s — Testo della riga; il valore viene convertito in string.

Valore restituito

void: nessun valore restituito.

Comportamento

Prima che TextPrint venga eseguito TextClear; le righe precedentemente accumulate vengono eliminate.
TextPrint aggiunge una linea e mostra YokoTextWindowGump stesso; TextOpen protegge lo stato aperto. Quando il buffer trabocca, le righe più vecchie vengono cancellate. Questa è una finestra di testo separata, non un server gump e non UO.GetInfo.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.FillNewWindow");
UO.FillNewWindow("Status ready");

1. Mostra riga - script diretto

Parametri e flusso di esecuzione:

Il testo viene inviato alla finestra di testo del client.

UO.FillNewWindow("Status ready");

2. Testo da variabile - funzione script

Parametri e flusso di esecuzione:

La stringa è formata dalla corrente locale HP.

return  RunScenario();
 object? RunScenario()
{
    var status = "HP: " + Convert.ToString(UO.GetHP());
    UO.FillNewWindow(status);
    return null;
}

3. Due righe consecutive: classe di script

Parametri e flusso di esecuzione:

Il secondo comando sostituisce il contenuto: ciò che resta è il secondo.

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.FillNewWindow("first");
        UO.FillNewWindow("second");
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.FillNewWindow(s)` — `UO.FillNewWindow(Any)`

Parametri: s (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextClear: bridge.TextClear().
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextPrint: bridge.TextPrint(Text(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextOpen: bridge.TextOpen().

Codice interno di implementazione; non è uno script autonomo.

case "fillnewwindow": bridge.TextClear(); bridge.TextPrint(Text(0)); bridge.TextOpen(); return InjectionValue.Unit;

UO.FontColor

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

Firme C#

void UO.FontColor(object? color);

Imposta hue sul successivo UO.UOAMessage locale di questo script. Non cambia il colore del discorso del personaggio, il normale tema UO.Print, InfoFindList o IDE.

Parametri

color — Indice numerico obbligatorio hue 0..65535, ad esempio 0x0044. Questo non è RGB. int è memorizzato all'interno e quando l'output viene ridotto a ushort; -1 NON significa reset e diventa 65535. Il valore iniziale del nuovo runtime è 0x03B2. Non esiste forma senza argomento.

Valore restituito

void: nessun risultato, vecchio colore o segno di successo. Per ripristinare l'impostazione in un secondo momento, memorizza il hue selezionato in una variabile di script.

Comportamento

Cambia solo stato.FontColor, non stampa un messaggio né invia un pacchetto di rete.
Valido fino al successivo FontColor nello stesso runtime. Un'altra scrittura indipendente ha il proprio stato. UO.Print(text,color) imposta direttamente il colore e non legge FontColor.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.FontColor");
UO.FontColor(0x0021);

1. Evidenzia Avviso inventario - Script diretto

Parametri e flusso di esecuzione:

0x0021 — indice hue; La tonalità finale dipende dai file tonalità del cliente. Il messaggio è visibile localmente; non è parlato dal personaggio.

UO.FontColor(0x0021);
var first = UO.FindList("0x0EED", "backpack");
if (Truth(first == ""))
{
    UO.UOAMessage("No gold in the loaded backpack");
}
else
{
    UO.UOAMessage("Gold units: " + Convert.ToString(UO.FindFullQuantity()));
}

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

2. Procedura generale di notifica del colore - Funzione script

Parametri e flusso di esecuzione:

L'avviso completo accetta testo e hue. L'ultimo hue installato rimane per il successivo UOAMessage di questo runtime. Non esiste FontColor() integrato per la lettura qui.

return  RunScenario();
 object? RunScenario()
{
    Notice("Supplies checked", 0x0044);
    Notice("Restock needed", 0x0021);
    return null;
}

void Notice(dynamic text, dynamic hue)
{
    UO.FontColor(hue);
    UO.UOAMessage(text);
}

3. Ripristina colore base noto - Classe script

Parametri e flusso di esecuzione:

0x03B2 — valore iniziale FontColor del nuovo runtime. Infine restituisce esattamente la base selezionata in caso di normale completamento/gestione degli errori; non ripristina il valore precedente sconosciuto.

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 baseHue = 0x03B2;
        try
        {
            UO.FontColor(0x0021);
            UO.UOAMessage("Check the route before moving");
        }
        finally
        {
            UO.FontColor(baseHue);
        }

        UO.UOAMessage("Ready");
        UO.Print("Regular Print keeps its own color");
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.FontColor(color)` — `UO.FontColor(Any)`

Parametri: color (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0, state.FontColor).

Codice interno di implementazione; non è uno script autonomo.

case "fontcolor": state.FontColor = Arg(0, state.FontColor); break;

UO.HelpRequest

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

Firme C#

void UO.HelpRequest();

Richiede il menu di aiuto del server.

Parametri

Non ci sono parametri.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

ExecuteClientApiCompatibility chiama HelpRequest, che invia GameActions.RequestHelp tramite Invoke. Il contenuto del menu è determinato dal server.
Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Richiede il menu di aiuto del server.

UO.HelpRequest();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

ExecuteClientApiCompatibility chiama HelpRequest, che invia GameActions.RequestHelp tramite Invoke. Il contenuto del menu è determinato dal server.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.IsOnline()))
    {
        UO.HelpRequest();
    }

    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. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.

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.IsOnline()))
        {
            UO.HelpRequest();
            UO.Print("Help requested");
        }

        return null;
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.HelpRequest()` — `UO.HelpRequest()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "helprequest": bridge.HelpRequest(); return InjectionValue.Unit;

UO.Hide

Firme C#

void UO.Hide();
void UO.Hide(object? serial);
string UO.Hide(object? type, object? x, object? y);
string UO.Hide(object? type, object? x, object? y, object? z);

Comportamento e risultato

Hide nasconde localmente un oggetto caricato senza usare Hiding. Resend/Resync annulla questa modifica e ripristina la precedente visualizzazione, anche dopo più Hide. I dati e il flag Hidden del server non cambiano.

Parametri

serial — Seriale oggetto o alias salvato.
type — ID grafico; -1 accetta qualsiasi tipo nella posizione.
x — Coordinata X del mondo.
y — Coordinata Y del mondo.
z — Altezza Z; la forma breve usa 0.

Configurare il prefisso in C# Scripts IDE; # è un esempio. Separare i parametri con spazi e racchiudere il testo fra virgolette. id significa serial, type significa graphic. xy x y [z] seleziona il primo oggetto caricato nel punto; type da solo il primo risultato. Il terzo argomento di InfoTile(x,y,map) è la mappa, non Z.

Comandi chat

#hide
#hide id 0x40001234
#hide type 0x0EED
#hide xy 1450 1690
#hide type 0x0EED xy 1450 1690 0

Esempi C# completi

Ogni blocco è un .csx completo. Sostituire serial, tipi e coordinate di esempio. Ordine e argomenti C# nominati seguono la firma.

1

UO.Hide(0x40001234);

2

UO.Print(UO.Hide(0x0EED, 1450, 1690, 0));

3

foreach (int serial in new[] { 0x40001234, 0x40005678 })
    UO.Hide(serial);

4

new CommandSample().Execute(UO);

sealed class CommandSample
{
    public void Execute(global::ClassicUO.CSharp.CSharpGameApi api)
    {
        api.Hide(0x40001234);
    }
}

Chiamate interne

CSharpGameApi.Hide
  -> CSharpScriptGlobals
  -> InjectionScript.Runtime.InjectionApiUO.Hide

ClassicUOInjectionApiBridge -> target / serial / type-position selection
  -> local hidden-object state -> renderer visibility

UO.Morph

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

Firme C#

void UO.Morph(object? @type);

Cambia localmente il graphic del personaggio corrente.

Parametri

type - int body graphic o la stringa type risolta da ResolveType. 0 ripristina graphic salvato con il primo Morph; un numero diverso da zero viene ridotto a ushort.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Bridge.Morph senza Player non cambia nulla. La prima volta che viene chiamato, salva _originalGraphic, quindi lo assegna a Player.Graphic. Aggiornamenti runtime ticksAnim=Timer anche se manca il Player.
Si tratta di un'apparizione locale, non di una trasformazione del server o di un cambiamento nella razza/nelle abilità disponibili. I valori esterni a ushort non vengono controllati da questa funzione bridge e vengono ridotti a 16 bit.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.Morph");
UO.Morph("0x0190");

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Cambia localmente il graphic del personaggio corrente.

UO.Morph("0x0190");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Bridge.Morph senza Player non cambia nulla. La prima volta che viene chiamato, salva _originalGraphic, quindi lo assegna a Player.Graphic. Aggiornamenti runtime ticksAnim=Timer anche se manca il Player.

return  RunScenario();
 object? RunScenario()
{
    UO.Morph(0);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Si tratta di un'apparizione locale, non di una trasformazione del server o di un cambiamento nella razza/nelle abilità disponibili. I valori esterni a ushort non vengono controllati da questa funzione bridge e vengono ridotti a 16 bit.

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.Morph("0x0190");
        UO.Wait(500);
        UO.Morph(0);
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.Morph(type)` — `UO.Morph(Integer)`

Parametri: type (Integer/String)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Morph.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Morph: bridge.Morph(type).
InjectionScript.Runtime.InjectionApiUO.Timer: Timer().

Codice interno di implementazione; non è uno script autonomo.

public void Morph(int type)

        {

            bridge.Morph(type);

            ticksAnim = Timer();

        }

`UO.Morph(type)` — `UO.Morph(String)`

Parametri: type (Integer/String)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Morph.
InjectionScript.Runtime.InjectionApiUO.Morph: Morph(ResolveType(type)).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(type).

Codice interno di implementazione; non è uno script autonomo.

public void Morph(string type) => Morph(ResolveType(type));

UO.OpenIDE

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

Firme C#

void UO.OpenIDE();
void UO.OpenIDE(object? filePath);

Parametri

filePath — Percorso facoltativo. Spazio vuoto/bianco: apre l'editor senza selezionare un file; il relativo viene risolto da _manager.AutoloadPath, l'assoluto viene preservato.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Bridge.OpenIDE prepara il percorso richiesto, quindi Invoke chiama YokoScriptEditorGump.Open(_world,requested). Lo script dal file non viene eseguito dal comando OpenIDE.
L'editor è una finestra grafica, non un'applicazione esterna Launch. La lettura/visualizzazione del file dipende dall'esistenza del percorso e dalla logica dell'editor.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Apre l'editor grafico C# IDE.

UO.OpenIDE();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Bridge.OpenIDE prepara il percorso richiesto, quindi Invoke chiama YokoScriptEditorGump.Open(_world,requested). Lo script dal file non viene eseguito dal comando OpenIDE.

return  RunScenario();
 object? RunScenario()
{
    UO.OpenIDE("Example.csx");
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

L'editor è una finestra grafica, non un'applicazione esterna Launch. La lettura/visualizzazione del file dipende dall'esistenza del percorso e dalla logica dell'editor.

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 path = "C:\\UO Scripts\\Example.csx";
        UO.OpenIDE(path);
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.OpenIDE()` — `UO.OpenIDE()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

`UO.OpenIDE(filePath)` — `UO.OpenIDE(Any)`

Parametri: filePath (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.OpenIDE.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.OpenIDE: bridge.OpenIDE(filePath.ToString()).
InjectionScript.Runtime.InjectionValue.ToString: filePath.ToString().

Codice interno di implementazione; non è uno script autonomo.

public void OpenIDE(InjectionValue filePath) => bridge.OpenIDE(filePath.ToString());

UO.Print

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

Firme C#

void UO.Print(object? msg);
void UO.Print(object? msg, object? color);

Mostra un messaggio locale sull'avanzamento dello script o sulla condizione di arresto. Lo vedi tu, non gli altri giocatori.

Parametri

color - UO hue, non RGB. Numero o stringa esadecimale; il bridge utilizza i bit bassi 16. Da non confondere con graphic/type. 0x0044 nell'esempio è il hue selezionato. Senza colore, viene utilizzato hue 0x03B2. UO.Print(text, color) accetta prima il testo; UO.ColorPrint(color, text) – colora prima.

Valore restituito

Una chiamata a un metodo con un tipo restituito void viene scritta come un'istruzione autonoma C#; il risultato non può essere assegnato o controllato. Il completamento della dichiarazione non costituisce conferma da parte del server di gioco.

Comportamento

Il messaggio va nell'area in basso a sinistra della finestra di gioco e nel registro locale. Una copia è disponibile nell'output IDE. Nel registro generale del manager, attiva il filtro dei messaggi script: la voce è disponibile senza la finestra di gioco. Il filtro dei messaggi del sistema server non seleziona tali record. Il pacchetto vocale di rete non viene inviato. Per la scritta sopra la testa c'è UO.CharPrint.
UO.Print aggiunge una nuova voce al registro dei messaggi del gioco: prima leggi o salva la stringa/risultato di ricerca desiderato, quindi registra il messaggio diagnostico. In un ciclo veloce, registra i messaggi quando si verificano le modifiche anziché a ogni iterazione.
Senza colore, viene utilizzato hue 0x03B2. UO.Print(text, color) accetta prima il testo; UO.ColorPrint(color, text) – colora prima.
UO.Print · UO.CharPrint · UO.Say · UO.ConColor

Esempio .csx

UO.Print("C# script started");
UO.Print($"Position: {UO.GetX()}, {UO.GetY()}");

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata senza valore restituito (void). Il testo del messaggio è indicato direttamente nella chiamata.

UO.Print("Hello from C#");

1. Breve relazione - sceneggiatura diretta

Parametri e flusso di esecuzione:

elaborato=12 — numero demo di elementi già elaborati. Convert.ToString lo trasforma in una stringa. Questo esempio riporta solo un numero; non trasferisce gli oggetti stessi.

var processed = 12;
UO.Print("Processed item entries: " + Convert.ToString(processed), 0x0044);

2. Avviso di sovraccarico - Funzione script

Parametri e flusso di esecuzione:

Vengono letti il peso e il massimo del personaggio. Un massimo pari a zero/sconosciuto non è considerato un sovraccarico. Se peso >= massimo, viene stampata una riga e Principale termina; gli oggetti non vengono buttati via.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.Print("Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum), 0x0044);
        return null;
    }

    return null;
}

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

3. Segnala solo modifiche del peso: classe di script

Parametri e flusso di esecuzione:

Main ricorda il peso, attende 1000 millisecondi e chiama il ReportWeight completamente dichiarato. L'assistente stampa solo se il peso è cambiato e restituisce il nuovo peso per il controllo successivo. Di per sé non crea un ciclo infinito.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.Print("Weight changed: " + Convert.ToString(current), 0x0044);
        }

        return current;
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.Print(msg)` — `UO.Print(Any)`

Parametri: msg (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Print.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Print: bridge.Print(msg.ToString()).
InjectionScript.Runtime.InjectionValue.ToString: msg.ToString().

Codice interno di implementazione; non è uno script autonomo.

public void Print(InjectionValue msg)

        {

            bridge.Print(msg.ToString());

        }

`UO.Print(msg, color)` — `UO.Print(Any,Any)`

Parametri: msg (Any), color (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Print.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Print: bridge.Print(NumberConversions.ToInt(color), msg.ToString()).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).
InjectionScript.Runtime.InjectionValue.ToString: msg.ToString().

Codice interno di implementazione; non è uno script autonomo.

public void Print(InjectionValue msg, InjectionValue color)

        {

            bridge.Print(NumberConversions.ToInt(color), msg.ToString());

        }

UO.RemoveFigure

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

Firme C#

dynamic UO.RemoveFigure(object? figureID);

Elimina una figura sulla mappa locale tramite il suo ID.

Parametri

figureID - int ID, restituito AddFigure. Questo non è un oggetto serial e nemmeno un gump ID.

Valore restituito

int — il risultato di bridge.RemoveMapFigure: 1/0 dalla presenza di una figura rimossa. La voce runtime viene cancellata indipendentemente dal risultato del bridge.

Comportamento

Prima chiama bridge.RemoveMapFigure, quindi state.MapFigures.Remove(id), quindi restituisce il risultato del bridge. Sconosciuto ID non crea una forma né attiva un'azione del server.
La figura locale della mappa non è un oggetto del mondo. Altre forme e geometrie del server non cambiano.
WorldMapGump memorizza le immagini nel dizionario statico del processo. Gli script/chat/macro regolari di un mondo/profilo utilizzano un comune GetPersistentState e un contatore ID; I processi dei singoli manager non condividono i disegni. World.Clear/YokoScripts.Clear e lo stato di caricamento del profilo non cancellano o ripristinano questo dizionario (il caricatore ripristina solo UserStatics). Pertanto, i disegni possono sopravvivere a un cambiamento del mondo/profilo nello stesso processo, tenendo conto di worldNum; il nuovo stato può enfatizzare nuovamente un disegno ID già esistente. ClearFigures cancella esplicitamente i disegni e i record dello stato attuale. Successo: scrittura/eliminazione dei dati, non prova della visualizzazione.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

var id = UO.AddFigure(new object?[] { 0, 0, UO.X(), UO.Y(), UO.X() + 3, UO.Y(), 0, 0, 255 });
UO.Print("Removed flag: " + Convert.ToString(UO.RemoveFigure(id)));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Elimina una figura sulla mappa locale tramite il suo ID.

UO.Print(UO.RemoveFigure(1));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Prima chiama bridge.RemoveMapFigure, quindi state.MapFigures.Remove(id), quindi restituisce il risultato del bridge. Sconosciuto ID non crea una forma né attiva un'azione del server.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] figure = new dynamic[checked((int)(10) + 1)];
    figure[0] = 0;
    figure[1] = 0;
    figure[2] = UO.GetX();
    figure[3] = UO.GetY();
    figure[4] = UO.GetX() + 1;
    figure[5] = UO.GetY() + 1;
    figure[6] = 0;
    figure[7] = 0;
    figure[8] = 0;
    figure[9] = UO.WorldNum();
    figure[10] = "Example";
    var id = UO.AddFigure(figure);
    if (Truth(id > 0))
    {
        UO.Print(UO.RemoveFigure(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. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

La figura locale della mappa non è un oggetto del mondo. Altre forme e geometrie del server non cambiano.

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 = 1;
        var first = UO.RemoveFigure(id);
        var second = UO.RemoveFigure(id);
        UO.Print(Convert.ToString(first) + " " + Convert.ToString(second));
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.RemoveFigure(figureID)` — `UO.RemoveFigure(Any)`

Parametri: figureID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "removefigure":

                {

                    int id = Arg(0);

                    int removed = bridge.RemoveMapFigure(id);

                    state.MapFigures.Remove(id);

                    return new InjectionValue(removed);

                }

UO.ServerPrint

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

Firme C#

void UO.ServerPrint(object? message);

Mostra un messaggio locale sull'avanzamento dello script o sulla condizione di arresto. Lo vedi tu, non gli altri giocatori.

Parametri

Valore restituito

Una chiamata a un metodo con un tipo restituito void viene scritta come un'istruzione autonoma C#; il risultato non può essere assegnato o controllato. Il completamento della dichiarazione non costituisce conferma da parte del server di gioco.

Comportamento

Il messaggio va nell'area in basso a sinistra della finestra di gioco e nel registro locale. Una copia è disponibile nell'output IDE. Nel registro generale del manager, attiva il filtro dei messaggi script: la voce è disponibile senza la finestra di gioco. Il filtro dei messaggi del sistema server non seleziona tali record. Il pacchetto vocale di rete non viene inviato. Per la scritta sopra la testa c'è UO.CharPrint.
UO.Print aggiunge una nuova voce al registro dei messaggi del gioco: prima leggi o salva la stringa/risultato di ricerca desiderato, quindi registra il messaggio diagnostico. In un ciclo veloce, registra i messaggi quando si verificano le modifiche anziché a ogni iterazione.
Senza colore, viene utilizzato hue 0x03B2. UO.Print(text, color) accetta prima il testo; UO.ColorPrint(color, text) – colora prima.
Nonostante la parola Server nel nome o la somiglianza con un messaggio di rete, il comando stampa solo testo locale. Per parlare al mondo, usa UO.Say.
UO.Print · UO.CharPrint · UO.Say · UO.ConColor

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata senza valore restituito (void). Il testo del messaggio è indicato direttamente nella chiamata.

UO.ServerPrint("Hello from C#");

1. Breve relazione - sceneggiatura diretta

Parametri e flusso di esecuzione:

elaborato=12 — numero demo di elementi già elaborati. Convert.ToString lo trasforma in una stringa. Questo esempio riporta solo un numero; non trasferisce gli oggetti stessi.

var processed = 12;
UO.ServerPrint("Processed item entries: " + Convert.ToString(processed));

2. Avviso di sovraccarico - Funzione script

Parametri e flusso di esecuzione:

Vengono letti il peso e il massimo del personaggio. Un massimo pari a zero/sconosciuto non è considerato un sovraccarico. Se peso >= massimo, viene stampata una riga e Principale termina; gli oggetti non vengono buttati via.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.ServerPrint("Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum));
        return null;
    }

    return null;
}

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

3. Segnala solo modifiche del peso: classe di script

Parametri e flusso di esecuzione:

Main ricorda il peso, attende 1000 millisecondi e chiama il ReportWeight completamente dichiarato. L'assistente stampa solo se il peso è cambiato e restituisce il nuovo peso per il controllo successivo. Di per sé non crea un ciclo infinito.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.ServerPrint("Weight changed: " + Convert.ToString(current));
        }

        return current;
    }

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

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ServerPrint(message)` — `UO.ServerPrint(String)`

Parametri: message (String)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public void ServerPrint(string message) => bridge.ServerPrint(message);

UO.SetShowZ

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

Firme C#

void UO.SetShowZ(object? stateValue);

Cambia il flag locale showZ runtime.

Parametri

stateValue - 0 si spegne; qualsiasi numero intero diverso da zero include.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Assegna a showZ il valore di 0 o 1 dopo NumberConversions.ToInt. Questa funzione stessa non modifica le coordinate e non invia il pacchetto.
Questo è l'archivio di compatibilità del runtime corrente. Non sono presenti consumatori nel progetto privato mulPath/showZ; la modifica non ricarica le risorse né modifica la visualizzazione dell'altezza.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Cambia il flag locale showZ runtime.

UO.SetShowZ(1);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Assegna a showZ il valore di 0 o 1 dopo NumberConversions.ToInt. Questa funzione stessa non modifica le coordinate e non invia il pacchetto.

return  RunScenario();
 object? RunScenario()
{
    UO.SetShowZ(0);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Questo è l'archivio di compatibilità del runtime corrente. Non sono presenti consumatori nel progetto privato mulPath/showZ; la modifica non ricarica le risorse né modifica la visualizzazione dell'altezza.

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

    void ApplyValue(dynamic value)
    {
        UO.SetShowZ(value);
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.SetShowZ(stateValue)` — `UO.SetShowZ(Any)`

Parametri: stateValue (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.SetShowZ.
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(stateValue).

Codice interno di implementazione; non è uno script autonomo.

public void SetShowZ(InjectionValue stateValue) => showZ = NumberConversions.ToInt(stateValue) != 0 ? 1 : 0;

UO.SetSilentMode

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

Firme C#

void UO.SetSilentMode(object? value);

Cambia il flag locale SilentMode runtime.

Parametri

value - 0 si spegne; qualsiasi numero intero diverso da zero include.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Memorizza SilentMode come 0/1. GumpLinesResult legge il flag: con 0 i risultati non vuoti GetGumpShortLines/GetGumpFullLines/GetGumpButtonsDescription vengono inoltre stampati in una finestra di testo e aperta; con 1 questa visualizzazione aggiuntiva viene soppressa. L'array restituito non cambia. Altri suoni Print e messaggi del server non vengono soppressi.
In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Memorizza SilentMode come 0/1. GumpLinesResult legge il flag: con 0 i risultati non vuoti GetGumpShortLines/GetGumpFullLines/GetGumpButtonsDescription vengono inoltre stampati in una finestra di testo e aperta; con 1 questa visualizzazione aggiuntiva viene soppressa. L'array restituito non cambia. Altri suoni Print e messaggi del server non vengono soppressi.

UO.SetSilentMode(1);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Memorizza SilentMode come 0/1. GumpLinesResult legge il flag: con 0 i risultati non vuoti GetGumpShortLines/GetGumpFullLines/GetGumpButtonsDescription vengono inoltre stampati in una finestra di testo e aperta; con 1 questa visualizzazione aggiuntiva viene soppressa. L'array restituito non cambia. Altri suoni Print e messaggi del server non vengono soppressi.

return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(0);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Memorizza SilentMode come 0/1. GumpLinesResult legge il flag: con 0 i risultati non vuoti GetGumpShortLines/GetGumpFullLines/GetGumpButtonsDescription vengono inoltre stampati in una finestra di testo e aperta; con 1 questa visualizzazione aggiuntiva viene soppressa. L'array restituito non cambia. Altri suoni Print e messaggi del server non vengono soppressi.

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

    void ApplyValue(dynamic value)
    {
        UO.SetSilentMode(value);
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "setsilentmode": state.SilentMode = Arg(0) != 0 ? 1 : 0; return InjectionValue.Unit;

UO.ShowJournal

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

Firme C#

void UO.ShowJournal();

Apre una finestra di registro del client locale.

Parametri

Non ci sono parametri.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

ShowJournal chiama GameActions.OpenJournal(_world). I record non vengono cancellati e il testo non viene inviato al server.
Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma del server.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Apre una finestra di registro del client locale.

UO.ShowJournal();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

ShowJournal chiama GameActions.OpenJournal(_world). I record non vengono cancellati e il testo non viene inviato al server.

return  RunScenario();
 object? RunScenario()
{
    UO.Print("Journal example");
    UO.ShowJournal();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma del server.

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.ShowJournal();
        UO.Print(UO.LineCount());
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.ShowJournal()` — `UO.ShowJournal()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "showjournal": bridge.ShowJournal(); break;

UO.Snap

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

Firme C#

int UO.Snap();
int UO.Snap(object? name);
int UO.Snap(object? name, object? quality);
int UO.Snap(object? file, object? quality, object? includeUI);

Salva un'istantanea della finestra grafica del client.

Parametri

name - Nome file opzionale. .jpg/.jpeg seleziona JPEG, altro/nessuno seleziona PNG. Le directory dal nome vengono rimosse; Viene utilizzato solo il nome di base.
file - Nome file opzionale. .jpg/.jpeg seleziona JPEG, altro/nessuno seleziona PNG. Le directory dal nome vengono rimosse; Viene utilizzato solo il nome di base.
quality - Opzionale int, predefinito 100, limitato a 1..100. Colpisce JPEG; PNG non utilizza la qualità con perdita.
includeUI - Opzionale bool, predefinito true. false disegna il mondo/l'illuminazione senza UI.

Valore restituito

Flag numerico int: 1 - file immagine salvato, 0 - errore di acquisizione/scrittura. Senza una finestra grafica, RequireGameView genera un errore prima di TakeScreenshot.

Comportamento

TakeScreenshot scrive in ExecutablePath/Data/Client/Screenshots, cancella i caratteri del nome non validi, seleziona automaticamente il nome in base alla data se vuoto, aggiunge _2/_3 se esiste un file esistente. Non viene utilizzato un percorso assoluto arbitrario.
Con UI legge il backbuffer; senza UI crea RenderTarget2D e rende il mondo. JPEG imposta temporaneamente FNA_GRAPHICS_JPEG_SAVE_QUALITY con ripristino; PNG SaveAsPng. Gli errori all'interno di TakeScreenshot vengono registrati e indicati come 0.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Salva un'istantanea della finestra grafica del client.

UO.Print(UO.Snap());

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

TakeScreenshot scrive in ExecutablePath/Data/Client/Screenshots, cancella i caratteri del nome non validi, seleziona automaticamente il nome in base alla data se vuoto, aggiunge _2/_3 se esiste un file esistente. Non viene utilizzato un percorso assoluto arbitrario.

return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.Snap("manual-example.jpg", 85));
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Con UI legge il backbuffer; senza UI crea RenderTarget2D e rende il mondo. JPEG imposta temporaneamente FNA_GRAPHICS_JPEG_SAVE_QUALITY con ripristino; PNG SaveAsPng. Gli errori all'interno di TakeScreenshot vengono registrati e indicati come 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.Print(UO.Snap("manual-world.png", 100, false));
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.Snap()` — `UO.Snap()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Snap.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Snap: bridge.Snap(null, 100, true).

Codice interno di implementazione; non è uno script autonomo.

public int Snap() => bridge.Snap(null, 100, true);

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

Parametri: name (String)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Snap.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Snap: bridge.Snap(name, 100, true).

Codice interno di implementazione; non è uno script autonomo.

public int Snap(string name) => bridge.Snap(name, 100, true);

`UO.Snap(name, quality)` — `UO.Snap(String,Integer)`

Parametri: name (String), quality (Integer)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Snap.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Snap: bridge.Snap(name, Math.Max(1, Math.Min(100, quality)), true).

Codice interno di implementazione; non è uno script autonomo.

public int Snap(string name, int quality) => bridge.Snap(name, Math.Max(1, Math.Min(100, quality)), true);

`UO.Snap(file, quality, includeUI)` — `UO.Snap(Any,Any,Any)`

Parametri: file (Any), quality (Any), includeUI (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [Snap].
InjectionScript.Runtime.InjectionApiUO.Snap: Snap(values[0].ToString(), NumberConversions.ToInt(values[1]), ToBoolean(values[2])).
InjectionScript.Runtime.InjectionValue.ToString: values[0].ToString().
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[1]).
InjectionScript.Runtime.InjectionApiUO.ToBoolean: ToBoolean(values[2]).

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(Snap(values[0].ToString(), NumberConversions.ToInt(values[1]), ToBoolean(values[2])))

UO.TextClear

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

Firme C#

void UO.TextClear();

Cancella il buffer della finestra di testo locale.

Parametri

Non ci sono parametri.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Cancella _textWindow; se la finestra era aperta, la ripropone con un elenco vuoto. Una finestra chiusa rimane chiusa. Il registro del client non viene cancellato.
L'azione è un'interfaccia/buffer locale; Non c'è alcun messaggio di rete o conferma del server.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Cancella il buffer della finestra di testo locale.

UO.TextClear();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Cancella _textWindow; se la finestra era aperta, la ripropone con un elenco vuoto. Una finestra chiusa rimane chiusa. Il registro del client non viene cancellato.

return  RunScenario();
 object? RunScenario()
{
    UO.TextPrint("Old line");
    UO.TextClear();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

L'azione è un'interfaccia/buffer locale; Non c'è alcun messaggio di rete o conferma del server.

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.TextClose();
        UO.TextClear();
        UO.TextOpen();
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.TextClear()` — `UO.TextClear()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public void TextClear() => bridge.TextClear();

UO.TextClose

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

Firme C#

void UO.TextClose();

Chiude la finestra di testo locale, salvando il buffer.

Parametri

Non ci sono parametri.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Imposta _textWindowOpen=false e Elimina l'esistente YokoTextWindowGump. L'elenco _textWindow non viene cancellato; TextOpen mostrerà nuovamente le sue linee.
L'azione è un'interfaccia/buffer locale; Non c'è alcun messaggio di rete o conferma del server.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Chiude la finestra di testo locale, salvando il buffer.

UO.TextClose();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Imposta _textWindowOpen=false e Elimina l'esistente YokoTextWindowGump. L'elenco _textWindow non viene cancellato; TextOpen mostrerà nuovamente le sue linee.

return  RunScenario();
 object? RunScenario()
{
    UO.TextPrint("Retained line");
    UO.TextClose();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

L'azione è un'interfaccia/buffer locale; Non c'è alcun messaggio di rete o conferma del server.

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.TextPrint("Retained line");
        UO.TextClose();
        UO.Wait(250);
        UO.TextOpen();
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.TextClose()` — `UO.TextClose()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public void TextClose() => bridge.TextClose();

UO.TextOpen

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

Firme C#

void UO.TextOpen();

Apre una finestra di testo locale.

Parametri

Non ci sono parametri.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Memorizza _textWindowOpen=true e chiama YokoTextWindowGump.Show con la _textWindow corrente. Il buffer non viene cancellato; alla riapertura vengono visualizzate le righe accumulate.
L'azione è un'interfaccia/buffer locale; Non c'è alcun messaggio di rete o conferma del server.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Apre una finestra di testo locale.

UO.TextOpen();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Memorizza _textWindowOpen=true e chiama YokoTextWindowGump.Show con la _textWindow corrente. Il buffer non viene cancellato; alla riapertura vengono visualizzate le righe accumulate.

return  RunScenario();
 object? RunScenario()
{
    UO.TextPrint("Example");
    UO.TextOpen();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

L'azione è un'interfaccia/buffer locale; Non c'è alcun messaggio di rete o conferma del server.

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.TextOpen();
        UO.Wait(500);
        UO.TextClose();
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.TextOpen()` — `UO.TextOpen()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public void TextOpen() => bridge.TextOpen();

UO.TextPrint

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

Firme C#

void UO.TextPrint(object? text);

Aggiunge una riga a una finestra di testo locale e la apre.

Parametri

text - Testo fino a ToString; salvato come trasmesso.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Al limite, MaxTextWindowLines=2000 rimuove le vecchie righe, quindi aggiunge testo o una riga vuota, imposta _textWindowOpen=true e mostra la finestra. Questo non è UO.Print nel registro e non è un discorso al server.
L'azione è un'interfaccia/buffer locale; Non c'è alcun messaggio di rete o conferma del server.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.TextPrint");
UO.TextPrint("Example");

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Aggiunge una riga a una finestra di testo locale e la apre.

UO.TextPrint("Example");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Al limite, MaxTextWindowLines=2000 rimuove le vecchie righe, quindi aggiunge testo o una riga vuota, imposta _textWindowOpen=true e mostra la finestra. Questo non è UO.Print nel registro e non è un discorso al server.

return  RunScenario();
 object? RunScenario()
{
    var message = "Line 1";
    UO.TextPrint(message);
    UO.TextPrint("Line 2");
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

L'azione è un'interfaccia/buffer locale; Non c'è alcun messaggio di rete o conferma del server.

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.TextClear();
        UO.TextPrint("Fresh report");
        UO.TextClose();
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.TextPrint(text)` — `UO.TextPrint(String)`

Parametri: text (String)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public void TextPrint(string text) => bridge.TextPrint(text);

UO.UpdateFigure

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

Firme C#

dynamic UO.UpdateFigure(object? figureID, object? figure);

Sostituisce la descrizione di una figura esistente sulla mappa locale.

Parametri

figureID - int ID nello stato. MapFigures ricevuto da AddFigure. Sconosciuto ID dà 0.
figure — Matrice o stringa con |: [tipo,coord,x1,y1,x2,y2,brushColor,brushStyle,colore,worldNum,testo]. Minimo primi 9 campi numerici; worldNum è la mappa corrente per impostazione predefinita, il testo è vuoto per impostazione predefinita.
figure[0] (kind) - il tipo dovrebbe essere 0..4, coord - 0..1, FigureID - positivo. WorldMapGump.SetYokoMapFigure restituisce 0 quando questi limiti vengono violati.
figure[1] (coord) - il tipo dovrebbe essere 0..4, coord - 0..1, FigureID - positivo. WorldMapGump.SetYokoMapFigure restituisce 0 quando questi limiti vengono violati.

Valore restituito

Flag numerico int: 1 - l'analisi ha avuto successo e bridge. SetMapFigure ha restituito un risultato diverso da zero, dopodiché il record è stato aggiornato; 0 - no ID, errore nel campo di testo struttura/numerico o bridge non riuscito.

Comportamento

TryMapFigureArg accetta Array o |string. I primi campi 9 vengono convertiti; il testo numerico è controllato da TryStr2Int. Vista/notazione breve non supportata - 0, altri errori di conversione della vista potrebbero interrompere lo script.
Se il bridge fallisce, la voce di runtime esistente non viene sostituita. In caso di successo, salva SerializeMapFigure con 10 campi numerici e testo. La figura è solo locale, non un elemento del server.
tipo: 0 linea, 1 ellisse (32 segmento di contorno), 2 contorno rettangolare, 3 freccia, 4 testo. coord=0 — coordinate del mondo con conversione nella mappa, coord=1 — pixel relativi all'area di disegno della mappa. x1/y1 e x2/y2 - estremità/confini; per la freccia del mondo x2=y2=0 imposta l'inizio del Giocatore e l'obiettivo di x1/y1. colore: 0x00BBGGRR (byte basso rosso), colore del contorno. brushColor/brushStyle vengono salvati, ma il render non li legge: non c'è riempimento. worldNum<0 viene visualizzato su qualsiasi mappa, altrimenti solo quella specificata. Il testo viene disegnato nel primo punto (+3 pixel per forme non di testo) nel carattere della mappa, non nel colore del contorno.
WorldMapGump memorizza le immagini nel dizionario statico del processo. Gli script/chat/macro regolari di un mondo/profilo utilizzano un comune GetPersistentState e un contatore ID; I processi dei singoli manager non condividono i disegni. World.Clear/YokoScripts.Clear e lo stato di caricamento del profilo non cancellano o ripristinano questo dizionario (il caricatore ripristina solo UserStatics). Pertanto, i disegni possono sopravvivere a un cambiamento del mondo/profilo nello stesso processo, tenendo conto di worldNum; il nuovo stato può enfatizzare nuovamente un disegno ID già esistente. ClearFigures cancella esplicitamente i disegni e i record dello stato attuale. Successo: scrittura/eliminazione dei dati, non prova della visualizzazione.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

object?[] figure = { 0, 0, UO.X(), UO.Y(), UO.X() + 3, UO.Y(), 0, 0, 255 };
var id = UO.AddFigure(figure);
figure[8] = 65280;
UO.Print("Updated flag: " + Convert.ToString(UO.UpdateFigure(id, figure)));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Sostituisce la descrizione di una figura esistente sulla mappa locale.

dynamic[] figure = new dynamic[checked((int)(8) + 1)];
figure[0] = 0;
figure[1] = 0;
figure[2] = 100;
figure[3] = 100;
figure[4] = 101;
figure[5] = 101;
figure[6] = 0;
figure[7] = 0;
figure[8] = 0;
UO.Print(UO.UpdateFigure(1, figure));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

TryMapFigureArg accetta Array o |string. I primi campi 9 vengono convertiti; il testo numerico è controllato da TryStr2Int. Vista/notazione breve non supportata - 0, altri errori di conversione della vista potrebbero interrompere lo script.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] figure = new dynamic[checked((int)(10) + 1)];
    figure[0] = 0;
    figure[1] = 0;
    figure[2] = UO.GetX();
    figure[3] = UO.GetY();
    figure[4] = UO.GetX() + 1;
    figure[5] = UO.GetY() + 1;
    figure[6] = 0;
    figure[7] = 0;
    figure[8] = 0;
    figure[9] = UO.WorldNum();
    figure[10] = "Example";
    var id = UO.AddFigure(figure);
    if (Truth(id > 0))
    {
        UO.Print(UO.UpdateFigure(id, figure));
        UO.RemoveFigure(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. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Se il bridge fallisce, la voce di runtime esistente non viene sostituita. In caso di successo, salva SerializeMapFigure con 10 campi numerici e testo. La figura è solo locale, non un elemento del server.

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 figure = "0|0|100|100|101|101|0|0|0";
        UO.Print(UO.UpdateFigure(1, figure));
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

`UO.UpdateFigure(figureID, figure)` — `UO.UpdateFigure(Any,Any)`

Parametri: figureID (Any), figure (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::TryMapFigureArg: TryMapFigureArg(1, out int[] figure, out string figureText).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetMapFigure: bridge.SetMapFigure(id, figure[0], figure[1], figure[2], figure[3], figure[4], figure[5], figure[6], figure[7], figure[8], figure[9], figureText).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::SerializeMapFigure: SerializeMapFigure(figure, figureText).

Codice interno di implementazione; non è uno script autonomo.

case "updatefigure":

                {

                    int id = Arg(0);

                    if (!state.MapFigures.ContainsKey(id) || !TryMapFigureArg(1, out int[] figure, out string figureText))

                        return InjectionValue.False;

                    if (bridge.SetMapFigure(id, figure[0], figure[1], figure[2], figure[3], figure[4], figure[5], figure[6], figure[7], figure[8], figure[9], figureText) == 0)

                        return InjectionValue.False;

                    state.MapFigures[id] = SerializeMapFigure(figure, figureText);

                    return InjectionValue.True;

                }

ClassicUO — Bad Newbie & C# Scripts IDE

IT UO Topic client ui

Cliente UI

Sezioni

Tutti i comandi del tema

Messaggi

Finestre

Visualizzazione degli oggetti

Figure

Esempi sull'argomento

UO.Print

UO.FillInfoWindow

Riferimento completo dei comandi

UO.ActivateHandle

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Richiedere che la finestra del client venga portata in primo piano. - sceneggiatura diretta

2. Non richiedere il focus della finestra prima di connetterti al gioco. - funzione di script

3. Avvolgi l'azione della finestra in una procedura riutilizzabile. - lezione di sceneggiatura

Implementazione del comando

UO.ActivateHandle() — UO.ActivateHandle()

UO.AddFigure

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Contorno rosso di un rettangolo sulla mappa di gioco - script diretto

2. Una freccia che va da un personaggio a un punto sulla mappa di gioco: una funzione dello script

3. Crea una linea blu tra due punti della sfaccettatura corrente. - lezione di sceneggiatura

Implementazione del comando

UO.AddFigure(figure) — UO.AddFigure(Any)

UO.CharPrint

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. UO.CharPrint - 1 - sceneggiatura diretta

2. UO.CharPrint — 2 — funzione di script

3. UO.CharPrint - 3 - classe dello scenario

Implementazione del comando

UO.CharPrint(color, msg) — UO.CharPrint(Integer,String)

UO.CharPrint(color, msg) — UO.CharPrint(String,String)

UO.CharPrint(id, color, msg) — UO.CharPrint(Any,Any,Any)

UO.CharPrint(id, color, msg) — UO.CharPrint(Integer,Integer,String)

UO.CircleTrans

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Impostazioni di lettura: script diretto

2. Abilita trasparenza - Funzione script

3. Ripristina valore precedente - Classe script

Implementazione del comando

UO.CircleTrans() — UO.CircleTrans()

UO.CircleTrans(enabled) — UO.CircleTrans(Integer)

UO.ClearFigures

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Stato chiaro: sceneggiatura diretta

2. Cancella dopo l'installazione - funzione script

3. Rieliminazione: classe di script

Implementazione del comando

UO.ClearFigures() — UO.ClearFigures()

UO.ClearInfoWindow

Firme C#

Parametri

Valore restituito

`UO.ActivateHandle()` — `UO.ActivateHandle()`

`UO.AddFigure(figure)` — `UO.AddFigure(Any)`

`UO.CharPrint(color, msg)` — `UO.CharPrint(Integer,String)`

`UO.CharPrint(color, msg)` — `UO.CharPrint(String,String)`

`UO.CharPrint(id, color, msg)` — `UO.CharPrint(Any,Any,Any)`

`UO.CharPrint(id, color, msg)` — `UO.CharPrint(Integer,Integer,String)`

`UO.CircleTrans()` — `UO.CircleTrans()`

`UO.CircleTrans(enabled)` — `UO.CircleTrans(Integer)`

`UO.ClearFigures()` — `UO.ClearFigures()`

`UO.ClearInfoWindow()` — `UO.ClearInfoWindow()`

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

`UO.ClientMarkChar(actionIndex, id)` — `UO.ClientMarkChar(Any,Any)`

`UO.ClientPrint(text)` — `UO.ClientPrint(Any)`

`UO.ClientPrintEx(senderID, color, font, text)` — `UO.ClientPrintEx(Any,Any,Any,Any)`

`UO.CloseClientUIWindow(uiWindowType, id)` — `UO.CloseClientUIWindow(Any,Any)`