Skip to content

IT UO Topic speech chat

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

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

Discorso e chat

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

Discorso dei personaggi, emozioni, canali di chat e filtri. La stampa locale dei messaggi nel client si trova in Client UI.

Sezioni

Argomento Comandi e spiegazioni
Say UO.Say
SayU UO.SayU
UOSay UO.UOSay
Emote UO.EmoteAction · UO.Bow · UO.Salute
Speech Filters UO.FilterSpeech
Global Chat UO.GlobalChatSendMsg · UO.GlobalChatActiveChannel
Channels UO.GlobalChatChannelsList · UO.GlobalChatJoinChannel · UO.GlobalChatLeaveChannel
Ignore Users UO.AddChatUserIgnore · UO.ClearChatUserIgnore

Tutti i comandi del tema

Discorso

UO.Say · UO.SayU · UO.UOSay · UO.UOSayColor · UO.Msg · UO.UOAMessage · UO.FixTalk

Emozione

UO.Bow · UO.Salute · UO.EmoteAction

Filtri/Canali

UO.FilterSpeech · UO.AddChatUserIgnore · UO.ClearChatUserIgnore · UO.GlobalChatActiveChannel · UO.GlobalChatChannelsList · UO.GlobalChatJoinChannel · UO.GlobalChatLeaveChannel · UO.GlobalChatSendMsg

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.Say

Parametri, risultato e tutti gli scenari

if (Truth(UO.Connected()))
{
    UO.Say("bank");
}

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

UO.GlobalChatSendMsg

Parametri, risultato e tutti gli scenari

UO.GlobalChatSendMsg("Hello");

Riferimento completo dei comandi

UO.AddChatUserIgnore

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

Firme C#

void UO.AddChatUserIgnore(object? userName);

Aggiunge il nome del mittente all'elenco di filtraggio dei messaggi di registro locale. Il filtro opera su questo client e non invia una richiesta al server.

Parametri

  • userName è il nome del mittente del registro. Un valore vuoto o contenente spazi viene ignorato; gli spazi sul bordo vengono rimossi.

Valore restituito

void. Il comando non restituisce un'aggiunta riuscita.

Comportamento

  • Il confronto dei nomi del mittente non fa distinzione tra maiuscole e minuscole. I messaggi provenienti da un nome corrispondente vengono nascosti da un filtro di registro locale; Questo non blocca un giocatore sul server. UO.ClearChatUserIgnore() cancella l'intero elenco locale dei nomi. La cancellazione del filtro non ripristina i record che sono già stati esclusi dalla 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.

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

UO.Print("Calling UO.AddChatUserIgnore");
UO.AddChatUserIgnore("ExampleVendor");

1. Nascondi le nuove voci di registro con questo nome nel tenant corrente. - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Nascondi le nuove voci di registro sotto questo nome nel tenant corrente.
UO.AddChatUserIgnore("ExampleVendor");

2. Passa il nome tramite una variabile stringa. - funzione di script

Parametri e flusso di esecuzione:

  • Passa il nome tramite una variabile stringa.
return  RunScenario();
 object? RunScenario()
{
    var sender = "ExampleVendor";
    UO.AddChatUserIgnore(sender);
    return null;
}

3. Aggiungi due nomi al filtro locale; la chiamata non li blocca sul server. - lezione di sceneggiatura

Parametri e flusso di esecuzione:

  • Aggiungi due nomi al filtro locale; la chiamata non li blocca sul 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.AddChatUserIgnore("ExampleVendor");
        UO.AddChatUserIgnore("ExamplePlayer");
        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.AddChatUserIgnore(userName) — UO.AddChatUserIgnore(Any)

Parametri: userName (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "addchatuserignore": bridge.AddChatUserIgnore(Text(0)); return InjectionValue.Unit;

UO.Bow

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

Firme C#

void UO.Bow();

Invia l'azione del personaggio dell'arco tramite GameActions.EmoteAction.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Questa è l'animazione/azione del personaggio. Il comando non restituisce una conferma del server e non attende il completamento dell'animazione.

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.Bow");
UO.Bow();

1. Arco - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Invia un inchino.
UO.Bow();

2. Inchinarsi durante la connessione - funzione script

Parametri e flusso di esecuzione:

  • Il controllo della connessione precede l'invio dell'azione.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Connected()))
    {
        UO.Bow();
    }

    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 Hello - Classe di script

Parametri e flusso di esecuzione:

  • La procedura completamente dichiarata invia la stessa azione.
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()
    {
        Greet();
        return null;
    }

    void Greet()
    {
        UO.Bow();
    }
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "bow": bridge.Bow(); return InjectionValue.Unit;

UO.ClearChatUserIgnore

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

Firme C#

void UO.ClearChatUserIgnore();

Rimuove tutti i filtri del nome mittente senza distinzione tra maiuscole e minuscole JournalManager.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

  • La rimozione dei filtri non elimina le voci della cronologia né annulla i filtri di testo AddJournalIgnore.

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.ClearChatUserIgnore");
UO.ClearChatUserIgnore();

1. Stato chiaro: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Rimuove tutti i filtri del nome mittente senza distinzione tra maiuscole e minuscole JournalManager.
UO.ClearChatUserIgnore();

2. Cancella dopo l'installazione - funzione script

Parametri e flusso di esecuzione:

  • Riabilitare la visualizzazione dei messaggi per conto del Fornitore.
return  RunScenario();
 object? RunScenario()
{
    UO.AddChatUserIgnore("Vendor");
    UO.ClearChatUserIgnore();
    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.ClearChatUserIgnore();
        UO.ClearChatUserIgnore();
        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.ClearChatUserIgnore() — UO.ClearChatUserIgnore()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "clearchatuserignore": bridge.ClearChatUserIgnore(); return InjectionValue.Unit;

UO.EmoteAction

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

Firme C#

void UO.EmoteAction(object? action);

Invia il nome della stringa di azione/animazione del carattere a GameActions.EmoteAction.

Parametri

  • action - Nome dell'azione, come inchino o saluto; convertito in string. Il riconoscimento dell'azione viene eseguito da GameActions.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Questa è un'azione di carattere, non stampare una frase su una rivista. Il comando non restituisce una conferma del server e non attende l'animazione.

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.EmoteAction");
UO.EmoteAction("bow");

1. Arco - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Il nome dell'azione è arco.
UO.EmoteAction("bow");

2. Benvenuto: funzione dello script

Parametri e flusso di esecuzione:

  • Il nome dell'azione salute viene passato.
return  RunScenario();
 object? RunScenario()
{
    UO.EmoteAction("salute");
    return null;
}

3. Nome dalla variabile - classe di script

Parametri e flusso di esecuzione:

  • La stringa dell'azione viene passata senza assegnare una destinazione dell'oggetto.
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 action = "bow";
        UO.EmoteAction(action);
        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.EmoteAction(action) — UO.EmoteAction(Any)

Parametri: action (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "emoteaction": bridge.EmoteAction(Text(0)); break;

UO.FilterSpeech

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

Firme C#

void UO.FilterSpeech();
void UO.FilterSpeech(object? enabled);

Abilita o disabilita il filtro vocale del client.

Parametri

  • enabled — Valore opzionale: senza argomento, il filtro è attivato; 0 si spegne, l'int diverso da zero si accende.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Scrive il flag normalizzato nello stato di runtime e lo passa al gestore. Il filtro influisce sull'elaborazione del client; gli eventi del server e altre impostazioni del registro rimangono separati.

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.FilterSpeech");
UO.FilterSpeech();

1. Abilita senza argomento - script diretto

Parametri e flusso di esecuzione:

  • Un numero zero di argomenti significa includere, non leggere.
UO.FilterSpeech();

2. Disattiva - funzione script

Parametri e flusso di esecuzione:

  • Un 0 esplicito disattiva il filtro client.
return  RunScenario();
 object? RunScenario()
{
    UO.FilterSpeech(0);
    return null;
}

3. Attiva e disattiva - Classe di script

Parametri e flusso di esecuzione:

  • Il filtro si accende e ritorna chiaramente allo stato spento.
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.FilterSpeech(1);
        UO.FilterSpeech(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.FilterSpeech() — UO.FilterSpeech()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "filterspeech": state.SpeechFilter = arguments.Length == 0 || Arg(0) != 0 ? 1 : 0; bridge.SetSpeechFilter(state.SpeechFilter); break;

UO.FilterSpeech(enabled) — UO.FilterSpeech(Any)

Parametri: enabled (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "filterspeech": state.SpeechFilter = arguments.Length == 0 || Arg(0) != 0 ? 1 : 0; bridge.SetSpeechFilter(state.SpeechFilter); break;

UO.FixTalk

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

Firme C#

void UO.FixTalk();

Stampa un avviso che la patch del client nativo legacy FixTalk non è richiesta da ClassicUO.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Il ramo ExecuteLegacyManualAlias chiama solo SystemMessage. Non corregge il movimento, la voce, i contenitori o il protocollo di rete.

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.FixTalk");
UO.FixTalk();

1. Avviso di compatibilità - Script diretto

Parametri e flusso di esecuzione:

  • Il messaggio descrive la mancata necessità della vecchia patch.
UO.FixTalk();

2. Procedura di chiamata - funzione script

Parametri e flusso di esecuzione:

  • La procedura di compatibilità non modifica il mondo di gioco.
return  RunScenario();
 object? RunScenario()
{
    CompatibilityNotice();
    return null;
}

void CompatibilityNotice()
{
    UO.FixTalk();
}

3. Continuazione dello script - Classe di script

Parametri e flusso di esecuzione:

  • Dopo il messaggio diagnostico, l'esecuzione continua.
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.FixTalk();
        UO.Print("continued");
        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.FixTalk() — UO.FixTalk()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "boxhack":

                case "fixtalk":

                case "fixwalk":

                    SystemMessage($"{name}: obsolete native-client patch; ClassicUO does not require it.");

                    break;

UO.GlobalChatActiveChannel

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

Firme C#

dynamic UO.GlobalChatActiveChannel();

Legge ChatManager.CurrentChannelName.

Parametri

Non ci sono parametri.

Valore restituito

string - CurrentChannelName o una riga vuota se il canale non è selezionato.

Comportamento

  • Legge ChatManager.CurrentChannelName. Riga vuota: nessun nome, nessun codice di errore; il canale stesso non viene inserito.
  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.

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.GlobalChatActiveChannel();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Legge ChatManager.CurrentChannelName.
UO.Print(UO.GlobalChatActiveChannel());

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Legge ChatManager.CurrentChannelName. Riga vuota: nessun nome, nessun codice di errore; il canale stesso non viene inserito.
return  RunScenario();
 object? RunScenario()
{
    var channel = UO.GlobalChatActiveChannel();
    if (Truth(Len(channel) > 0))
    {
        UO.Print(channel);
    }

    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var before = UO.GlobalChatActiveChannel();
        UO.Wait(500);
        var after = UO.GlobalChatActiveChannel();
        UO.Print(before);
        UO.Print(after);
        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.GlobalChatActiveChannel() — UO.GlobalChatActiveChannel()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "globalchatactivechannel": return new InjectionValue(bridge.GlobalChatActiveChannel());

UO.GlobalChatChannelsList

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

Firme C#

dynamic UO.GlobalChatChannelsList();

Il bridge restituisce ChatManager.Channels.Keys.OrderBy(nome => nome).

Parametri

Non ci sono parametri.

Valore restituito

Matrice di stringhe di nomi di canale, ordinate per nome. Una tabella locale vuota produce un array vuoto.

Comportamento

  • Il bridge restituisce ChatManager.Channels.Keys.OrderBy(nome => nome). L'elenco è noto al client e potrebbe non essere completo fino all'aggiornamento del server.
  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.

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.GlobalChatChannelsList();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Il bridge restituisce ChatManager.Channels.Keys.OrderBy(nome => nome).
var channels = UO.GlobalChatChannelsList();
UO.Print(UO.GetArrayLength(channels));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Il bridge restituisce ChatManager.Channels.Keys.OrderBy(nome => nome). L'elenco è noto al client e potrebbe non essere completo fino all'aggiornamento del server.
return  RunScenario();
 object? RunScenario()
{
    var channels = UO.GlobalChatChannelsList();
    if (Truth(UO.GetArrayLength(channels) > 0))
    {
        UO.Print(channels[0]);
    }

    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var before = UO.GlobalChatChannelsList();
        UO.Wait(500);
        var after = UO.GlobalChatChannelsList();
        UO.Print(before);
        UO.Print(after);
        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.GlobalChatChannelsList() — UO.GlobalChatChannelsList()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "globalchatchannelslist": return StringArray(bridge.GlobalChatChannels());

UO.GlobalChatJoinChannel

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

Firme C#

void UO.GlobalChatJoinChannel(object? chName);

Richiede l'ingresso nel canale di chat globale.

Parametri

  • chName - 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

  • Invia un Send_ChatJoinCommand con il nome del canale specificato. La presenza di un canale e il permesso di accesso sono determinati dal server. Il nome del canale attivo locale viene letto separatamente.
  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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.GlobalChatJoinChannel");
UO.GlobalChatJoinChannel("General");

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede l'ingresso nel canale di chat globale.
UO.GlobalChatJoinChannel("General");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Invia un Send_ChatJoinCommand con il nome del canale specificato. La presenza di un canale e il permesso di accesso sono determinati dal server. Il nome del canale attivo locale viene letto separatamente.
return  RunScenario();
 object? RunScenario()
{
    var message = "General";
    if (Truth(UO.IsOnline()))
    {
        UO.GlobalChatJoinChannel(message);
    }

    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:

  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.
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()
    {
        SendText("General");
        return null;
    }

    void SendText(dynamic message)
    {
        if (Truth(Len(message) > 0))
        {
            UO.GlobalChatJoinChannel(message);
        }
    }

    int Len(object? value) => Convert.ToString(value)?.Length ?? 0;
    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.GlobalChatJoinChannel(chName) — UO.GlobalChatJoinChannel(Any)

Parametri: chName (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "globalchatjoinchannel": bridge.GlobalChatJoin(Text(0)); return InjectionValue.Unit;

UO.GlobalChatLeaveChannel

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

Firme C#

void UO.GlobalChatLeaveChannel();

Richieste di lasciare il canale di chat globale.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • GlobalChatLeave invia Send_ChatLeaveChannelCommand. Il nome del canale locale cambierà dopo l'elaborazione dei dati della chat.
  • 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.GlobalChatLeaveChannel");
UO.GlobalChatLeaveChannel();

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richieste di lasciare il canale di chat globale.
UO.GlobalChatLeaveChannel();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • GlobalChatLeave invia Send_ChatLeaveChannelCommand. Il nome del canale locale cambierà dopo l'elaborazione dei dati della chat.
return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.GlobalChatActiveChannel());
    UO.GlobalChatLeaveChannel();
    return null;
}

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()
    {
        UO.GlobalChatLeaveChannel();
        UO.Wait(500);
        UO.Print(UO.GlobalChatActiveChannel());
        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.GlobalChatLeaveChannel() — UO.GlobalChatLeaveChannel()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "globalchatleavechannel": bridge.GlobalChatLeave(); return InjectionValue.Unit;

UO.GlobalChatSendMsg

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

Firme C#

void UO.GlobalChatSendMsg(object? msgText);

Invia un messaggio alla chat globale.

Parametri

  • msgText - 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

  • Invia un Send_ChatMessageCommand con il testo trasmesso. Il canale utilizza lo stato chat client/server; la squadra non sceglie il canale stesso.
  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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.GlobalChatSendMsg");
UO.GlobalChatSendMsg("Hello");

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Invia un messaggio alla chat globale.
UO.GlobalChatSendMsg("Hello");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Invia un Send_ChatMessageCommand con il testo trasmesso. Il canale utilizza lo stato chat client/server; la squadra non sceglie il canale stesso.
return  RunScenario();
 object? RunScenario()
{
    var message = "Hello";
    if (Truth(UO.IsOnline()))
    {
        UO.GlobalChatSendMsg(message);
    }

    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:

  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.
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()
    {
        SendText("Hello");
        return null;
    }

    void SendText(dynamic message)
    {
        if (Truth(Len(message) > 0))
        {
            UO.GlobalChatSendMsg(message);
        }
    }

    int Len(object? value) => Convert.ToString(value)?.Length ?? 0;
    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.GlobalChatSendMsg(msgText) — UO.GlobalChatSendMsg(Any)

Parametri: msgText (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "globalchatsendmsg": bridge.GlobalChatSend(Text(0)); return InjectionValue.Unit;

UO.Msg

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

Firme C#

void UO.Msg(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.Msg("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.Msg("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.Msg("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.Msg("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.Msg(message) — UO.Msg(String)

Parametri: message (String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.Salute

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

Firme C#

void UO.Salute();

Richiede un'animazione di saluto.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • Salute chiama GameActions.EmoteAction("saluto") tramite Invoke. Questa è un'azione del personaggio, non il testo UO.Say.
  • 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.Salute");
UO.Salute();

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede un'animazione di saluto.
UO.Salute();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Salute chiama GameActions.EmoteAction("saluto") tramite Invoke. Questa è un'azione del personaggio, non il testo UO.Say.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.IsOnline()))
    {
        UO.Salute();
    }

    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()
    {
        UO.Salute();
        UO.Wait(1000);
        UO.Print("Salute requested");
        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.Salute() — UO.Salute()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "salute": bridge.Salute(); return InjectionValue.Unit;

UO.Say

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

Firme C#

void UO.Say(object? message);

Invia il normale discorso del personaggio al server: ad esempio, un indirizzo a un banchiere o un comando a un animale domestico.

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

  • Per la versione del protocollo 2.0.0 e successive, il client invia la sintesi vocale Unicode; per il più grande - discorso ASCII. Il nome SayU non forza il vecchio protocollo su Unicode. Senza un colore esplicito, viene preso SpeechHue del profilo; Anche 0xFFFF in UO.UOSayColor seleziona questo colore. Il testo viene inviato al server, ma lo script non lo esegue come codice.
  • 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.Say");
UO.Say("bank");

1. Contatta un banchiere - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Connected viene controllato prima della spedizione. bank è una frase, non il nome API. Per aprire una banca solitamente è necessario un NPC adatto nelle vicinanze; se il server utilizza una frase diversa, sostituiscila.
if (Truth(UO.Connected()))
{
    UO.Say("bank");
}

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

2. Comando ad un animale domestico selezionato per nome - funzione script

Parametri e flusso di esecuzione:

  • petName è il nome del tuo animale domestico, qui Shadow. Costituisce una riga: Shadow follow me. Questo è un ordine per il tuo animale domestico di seguirti, invece di UO.Follow, che muove il tuo personaggio.
return  RunScenario();
 object? RunScenario()
{
    var petName = "Shadow";
    if (Truth(UO.Connected()))
    {
        UO.Say(petName + " follow me");
    }

    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. Chiedi alla banca solo quando sovraccarico - classe script

Parametri e flusso di esecuzione:

  • RequestBankIfHeavy controlla la connessione e il peso massimo positivo affidabile. Solo quando sovraccarico invia bank e restituisce 1 come segno di richiesta inviata. 0: richiesta non inviata. Questo risultato appartiene all'assistente, non al comando vocale.
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()
    {
        return RequestBankIfHeavy();
        return null;
    }

    dynamic RequestBankIfHeavy()
    {
        if (!(Truth(UO.Connected())))
        {
            return 0;
        }

        var maximum = UO.MaxWeight();
        if (Truth(maximum <= 0) || Truth(UO.Weight() < maximum))
        {
            return 0;
        }

        UO.Say("bank");
        return 1;
    }

    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.Say(message) — UO.Say(String)

Parametri: message (String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.SayU

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

Firme C#

void UO.SayU(object? text);

Invia il normale discorso del personaggio al server: ad esempio, un indirizzo a un banchiere o un comando a un animale domestico.

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

  • Per la versione del protocollo 2.0.0 e successive, il client invia la sintesi vocale Unicode; per il più grande - discorso ASCII. Il nome SayU non forza il vecchio protocollo su Unicode. Senza un colore esplicito, viene preso SpeechHue del profilo; Anche 0xFFFF in UO.UOSayColor seleziona questo colore. Il testo viene inviato al server, ma lo script non lo esegue come codice.
  • 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.SayU");
UO.SayU("bank");

1. Contatta un banchiere - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Connected viene controllato prima della spedizione. bank è una frase, non il nome API. Per aprire una banca solitamente è necessario un NPC adatto nelle vicinanze; se il server utilizza una frase diversa, sostituiscila.
if (Truth(UO.Connected()))
{
    UO.SayU("bank");
}

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

2. Comando ad un animale domestico selezionato per nome - funzione script

Parametri e flusso di esecuzione:

  • petName è il nome del tuo animale domestico, qui Shadow. Costituisce una riga: Shadow follow me. Questo è un ordine per il tuo animale domestico di seguirti, invece di UO.Follow, che muove il tuo personaggio.
return  RunScenario();
 object? RunScenario()
{
    var petName = "Shadow";
    if (Truth(UO.Connected()))
    {
        UO.SayU(petName + " follow me");
    }

    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. Chiedi alla banca solo quando sovraccarico - classe script

Parametri e flusso di esecuzione:

  • RequestBankIfHeavy controlla la connessione e il peso massimo positivo affidabile. Solo quando sovraccarico invia bank e restituisce 1 come segno di richiesta inviata. 0: richiesta non inviata. Questo risultato appartiene all'assistente, non al comando vocale.
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()
    {
        return RequestBankIfHeavy();
        return null;
    }

    dynamic RequestBankIfHeavy()
    {
        if (!(Truth(UO.Connected())))
        {
            return 0;
        }

        var maximum = UO.MaxWeight();
        if (Truth(maximum <= 0) || Truth(UO.Weight() < maximum))
        {
            return 0;
        }

        UO.SayU("bank");
        return 1;
    }

    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.SayU(text) — UO.SayU(Any)

Parametri: text (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "sayu": Say(arguments.Length > 0 ? arguments[0].ToString() : string.Empty); break;

UO.UOAMessage

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

Firme C#

void UO.UOAMessage(object? text);

Stampa un messaggio locale su ClassicUO con hue impostato su UO.FontColor. Adatto per notifiche di script sull'inventario, sullo stato del percorso o sul completamento della fase.

Parametri

Valore restituito

void: non restituisce testo, indice di registro o true/false. La chiamata esegue l'output locale; Non viene restituita alcuna conferma sul display.

Comportamento

  • Utilizza lo stato.FontColor del runtime corrente, originariamente 0x03B2. La registrazione passa attraverso l'area messaggi inferiore e il registro del client, nonché l'uscita IDE.
  • Non invia la parola al server, non provoca una finestra pop-up, non invia un messaggio ad un altro giocatore. Il normale UO.Print ha il suo colore.
  • Per il colore di un messaggio senza cambiare stato.FontColor puoi usare UO.Print(text,color).

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.UOAMessage("Hello from C#");

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.UOAMessage(text) — UO.UOAMessage(Any)

Parametri: text (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "uoamessage": bridge.Print(state.FontColor, Text(0)); break;

UO.UOSay

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

Firme C#

void UO.UOSay(object? text);

Invia il normale discorso del personaggio al server: ad esempio, un indirizzo a un banchiere o un comando a un animale domestico.

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

  • Per la versione del protocollo 2.0.0 e successive, il client invia la sintesi vocale Unicode; per il più grande - discorso ASCII. Il nome SayU non forza il vecchio protocollo su Unicode. Senza un colore esplicito, viene preso SpeechHue del profilo; Anche 0xFFFF in UO.UOSayColor seleziona questo colore. Il testo viene inviato al server, ma lo script non lo esegue come codice.
  • 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.UOSay");
UO.UOSay("bank");

1. Contatta un banchiere - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Connected viene controllato prima della spedizione. bank è una frase, non il nome API. Per aprire una banca solitamente è necessario un NPC adatto nelle vicinanze; se il server utilizza una frase diversa, sostituiscila.
if (Truth(UO.Connected()))
{
    UO.UOSay("bank");
}

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

2. Comando ad un animale domestico selezionato per nome - funzione script

Parametri e flusso di esecuzione:

  • petName è il nome del tuo animale domestico, qui Shadow. Costituisce una riga: Shadow follow me. Questo è un ordine per il tuo animale domestico di seguirti, invece di UO.Follow, che muove il tuo personaggio.
return  RunScenario();
 object? RunScenario()
{
    var petName = "Shadow";
    if (Truth(UO.Connected()))
    {
        UO.UOSay(petName + " follow me");
    }

    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. Chiedi alla banca solo quando sovraccarico - classe script

Parametri e flusso di esecuzione:

  • RequestBankIfHeavy controlla la connessione e il peso massimo positivo affidabile. Solo quando sovraccarico invia bank e restituisce 1 come segno di richiesta inviata. 0: richiesta non inviata. Questo risultato appartiene all'assistente, non al comando vocale.
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()
    {
        return RequestBankIfHeavy();
        return null;
    }

    dynamic RequestBankIfHeavy()
    {
        if (!(Truth(UO.Connected())))
        {
            return 0;
        }

        var maximum = UO.MaxWeight();
        if (Truth(maximum <= 0) || Truth(UO.Weight() < maximum))
        {
            return 0;
        }

        UO.UOSay("bank");
        return 1;
    }

    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.UOSay(text) — UO.UOSay(Any)

Parametri: text (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "uosay": Say(Text(0)); return InjectionValue.Unit;

UO.UOSayColor

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

Firme C#

void UO.UOSayColor(object? text, object? color);

Invia il normale discorso del personaggio al server: ad esempio, un indirizzo a un banchiere o un comando a un animale domestico.

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. Per la versione del protocollo 2.0.0 e successive, il client invia la sintesi vocale Unicode; per il più grande - discorso ASCII. Il nome SayU non forza il vecchio protocollo su Unicode. Senza un colore evidente, viene preso SpeechHue del profilo; Anche 0xFFFF in UO.UOSayColor seleziona questo colore. Il testo viene inviato al server, ma lo script non lo esegue come codice.

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

  • Per la versione del protocollo 2.0.0 e successive, il client invia la sintesi vocale Unicode; per il più grande - discorso ASCII. Il nome SayU non forza il vecchio protocollo su Unicode. Senza un colore esplicito, viene preso SpeechHue del profilo; Anche 0xFFFF in UO.UOSayColor seleziona questo colore. Il testo viene inviato al server, ma lo script non lo esegue come codice.
  • 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.UOSayColor");
UO.UOSayColor("bank", 0x0044);

1. Contatta un banchiere - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Connected viene controllato prima della spedizione. bank è una frase, non il nome API. Per aprire una banca solitamente è necessario un NPC adatto nelle vicinanze; se il server utilizza una frase diversa, sostituiscila.
if (Truth(UO.Connected()))
{
    UO.UOSayColor("bank", 0x0044);
}

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

2. Comando ad un animale domestico selezionato per nome - funzione script

Parametri e flusso di esecuzione:

  • petName è il nome del tuo animale domestico, qui Shadow. Costituisce una riga: Shadow follow me. Questo è un ordine per il tuo animale domestico di seguirti, invece di UO.Follow, che muove il tuo personaggio.
return  RunScenario();
 object? RunScenario()
{
    var petName = "Shadow";
    if (Truth(UO.Connected()))
    {
        UO.UOSayColor(petName + " follow me", 0x0044);
    }

    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. Chiedi alla banca solo quando sovraccarico - classe script

Parametri e flusso di esecuzione:

  • RequestBankIfHeavy controlla la connessione e il peso massimo positivo affidabile. Solo quando sovraccarico invia bank e restituisce 1 come segno di richiesta inviata. 0: richiesta non inviata. Questo risultato appartiene all'assistente, non al comando vocale.
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()
    {
        return RequestBankIfHeavy();
        return null;
    }

    dynamic RequestBankIfHeavy()
    {
        if (!(Truth(UO.Connected())))
        {
            return 0;
        }

        var maximum = UO.MaxWeight();
        if (Truth(maximum <= 0) || Truth(UO.Weight() < maximum))
        {
            return 0;
        }

        UO.UOSayColor("bank", 0x0044);
        return 1;
    }

    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.UOSayColor(text, color) — UO.UOSayColor(Any,Any)

Parametri: text (Any), color (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally