Skip to content

IT UO Topic party

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

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

Gruppo

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

Inviti di gruppo, membri, uscite e messaggi. Queste transazioni differiscono dal discorso generale e dallo scambio commerciale.

Sezioni

Argomento Comandi e spiegazioni
InParty UO.InParty
Invite UO.InviteToParty
Accept UO.PartyAcceptInvite
Decline UO.PartyDeclineInvite
Leave UO.PartyLeave
Remove Member UO.RemoveFromParty
Members List UO.PartyMembersList
PartySay UO.PartySay
Messaggio della festa privata UO.PartyPrivateMessageTo

Tutti i comandi del tema

Festa

UO.InParty · UO.InviteToParty · UO.PartyAcceptInvite · UO.PartyDeclineInvite · UO.PartyLeave · UO.RemoveFromParty · UO.PartyMembersList · UO.PartyCanLootMe · UO.PartySay · UO.PartyPrivateMessageTo

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

Parametri, risultato e tutti gli scenari

var members = UO.PartyMembersList();
UO.Print(UO.GetArrayLength(members));

UO.PartySay

Parametri, risultato e tutti gli scenari

UO.PartySay("Ready");

Riferimento completo dei comandi

UO.InParty

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

Firme C#

int UO.InParty();

Verifica la presenza di un gruppo corrente in base allo stato Party del client.

Parametri

Non ci sono parametri.

Valore restituito

int 1 — nel Partito è noto un leader serial diverso da zero. int 0 - non c'è un leader. Questo non è il numero di partecipanti o l'indice del tuo personaggio nell'elenco.

Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.

Comportamento

  • Viene letto il modello client locale; Non ci sono richieste al server, nessuna attesa o spostamento.
  • Il risultato si riferisce al momento della lettura. Dopo UO.Wait o altra azione, l'oggetto e i suoi flag potrebbero cambiare.
  • Questo client controlla Party.Leader, non solo il numero di righe di elenco non vuote. Se l'invito viene accettato, lo stato cambierà dopo l'aggiornamento 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 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.InParty();
UO.Print("InParty: " + Convert.ToString(result));

1. Script fork basato sulla presenza del gruppo - script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti. Viene controllato il gruppo del personaggio corrente.
  • Il team non crea un gruppo e non accetta l'invito.
if (Truth(UO.InParty()))
{
    UO.Print("Party is active");
}
else
{
    UO.Print("No active party");
}

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

2. Salva stato una volta - Funzione script

Parametri e flusso di esecuzione:

  • inParty è numerico bool, non il numero di partecipanti.
  • Il riutilizzo di una variabile non rilegge il gruppo modificato.
return  RunScenario();
 object? RunScenario()
{
    var inParty = UO.InParty();
    UO.Print("Party 1/0: " + Convert.ToString(inParty));
    return null;
}

3. Attendi un aggiornamento non più di alcuni controlli: classe di script

Parametri e flusso di esecuzione:

  • Non più di 10 pause per 200 ms; Il ciclo è limitato a circa due secondi più l'esecuzione del comando.
  • L'attesa non invia inviti né garantisce l'appartenenza al gruppo.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var attempts = 0;
        while (Truth(UO.InParty() == 0) && Truth(attempts < 10))
        {
            await Delay(200);
            attempts = attempts + 1;
        }

        if (Truth(UO.InParty()))
        {
            UO.Print("Party state received");
        }
        else
        {
            UO.Print("Party still absent");
        }

        return null;
    }

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

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "inparty": return new InjectionValue(bridge.InParty());

UO.InviteToParty

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

Firme C#

void UO.InviteToParty(object? objID);

Richiede un invito per un personaggio a unirsi al gruppo.

Parametri

  • objID — Oggetto seriale/ID: int, stringa numerica/esadecimale o alias stabilito, ad esempio "lasttarget". Questo non è graphic/type. Controllare l'oggetto caricato prima di agire.

Valore restituito

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

Comportamento

  • PartyInvite invia serial a _manager.QueueTarget, quindi chiama RequestPartyInviteByTarget. Innanzitutto viene preparata la coda del target, quindi viene inviata la richiesta di invito.
  • 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.InviteToParty");
UO.InviteToParty(UO.GetSerial("lasttarget"));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede un invito per un personaggio a unirsi al gruppo.
var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.InviteToParty(id);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • PartyInvite invia serial a _manager.QueueTarget, quindi chiama RequestPartyInviteByTarget. Innanzitutto viene preparata la coda del target, quindi viene inviata la richiesta di invito.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("self");
    if (Truth(UO.Exists(id)))
    {
        UO.InviteToParty(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:

  • 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()
    {
        ApplyToLoaded(UO.GetSerial("lasttarget"));
        return null;
    }

    void ApplyToLoaded(dynamic id)
    {
        if (Truth(UO.Exists(id)))
        {
            UO.InviteToParty(id);
        }
    }

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

Parametri: objID (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "invitetoparty": bridge.PartyInvite(Arg(0)); return InjectionValue.Unit;

UO.PartyAcceptInvite

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

Firme C#

void UO.PartyAcceptInvite();

Accetta l'invito salvato al gruppo.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • PartyAcceptInvite se Party.Inviter è diverso da zero, invia RequestPartyAccept, assegna localmente Leader=Inviter e cancella Inviter. Senza invito non c'è azione.
  • 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.PartyAcceptInvite");
UO.PartyAcceptInvite();

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Accetta l'invito salvato al gruppo.
UO.PartyAcceptInvite();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • PartyAcceptInvite se Party.Inviter è diverso da zero, invia RequestPartyAccept, assegna localmente Leader=Inviter e cancella Inviter. Senza invito non c'è azione.
return  RunScenario();
 object? RunScenario()
{
    UO.PartyAcceptInvite();
    UO.Print(UO.InParty());
    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.PartyAcceptInvite();
        UO.Wait(500);
        UO.Print(UO.GetArrayLength(UO.PartyMembersList()));
        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.PartyAcceptInvite() — UO.PartyAcceptInvite()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "partyacceptinvite": bridge.PartyAcceptInvite(); return InjectionValue.Unit;

UO.PartyCanLootMe

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

Firme C#

void UO.PartyCanLootMe(object? value);

Cambia se i membri del gruppo possono rimuovere oggetti da un cadavere.

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

  • PartyCanLoot imposta localmente Party.CanLoot e chiama RequestPartyLootState(abilitato). Il valore diverso da zero si accende, 0 si spegne. Il server controlla ancora le regole.
  • 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.PartyCanLootMe");
UO.PartyCanLootMe(1);

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Cambia se i membri del gruppo possono rimuovere oggetti da un cadavere.
UO.PartyCanLootMe(1);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • PartyCanLoot imposta localmente Party.CanLoot e chiama RequestPartyLootState(abilitato). Il valore diverso da zero si accende, 0 si spegne. Il server controlla ancora le regole.
return  RunScenario();
 object? RunScenario()
{
    UO.PartyCanLootMe(0);
    return null;
}

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

    void ApplyMode(dynamic mode)
    {
        UO.PartyCanLootMe(mode);
    }
}

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.PartyCanLootMe(value) — UO.PartyCanLootMe(Any)

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "partycanlootme": bridge.PartyCanLoot(Arg(0) != 0); return InjectionValue.Unit;

UO.PartyDeclineInvite

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

Firme C#

void UO.PartyDeclineInvite();

Rifiuta un invito di gruppo salvato.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • PartyDeclineInvite se Party.Inviter è diverso da zero, invia Send_PartyDecline e cancella Inviter. Senza invito non c'è azione.
  • 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.PartyDeclineInvite");
UO.PartyDeclineInvite();

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Rifiuta un invito di gruppo salvato.
UO.PartyDeclineInvite();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • PartyDeclineInvite se Party.Inviter è diverso da zero, invia Send_PartyDecline e cancella Inviter. Senza invito non c'è azione.
return  RunScenario();
 object? RunScenario()
{
    UO.PartyDeclineInvite();
    UO.Print(UO.InParty());
    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.PartyDeclineInvite();
        UO.Wait(500);
        UO.Print(UO.GetArrayLength(UO.PartyMembersList()));
        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.PartyDeclineInvite() — UO.PartyDeclineInvite()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "partydeclineinvite": bridge.PartyDeclineInvite(); return InjectionValue.Unit;

UO.PartyLeave

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

Firme C#

void UO.PartyLeave();

Richiede al personaggio corrente di lasciare il gruppo.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • PartyLeave se c'è un Giocatore, chiama GameActions.RequestPartyQuit(_world.Player); senza Player non invia nulla.
  • 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.PartyLeave");
UO.PartyLeave();

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede al personaggio corrente di lasciare il gruppo.
UO.PartyLeave();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • PartyLeave se c'è un Giocatore, chiama GameActions.RequestPartyQuit(_world.Player); senza Player non invia nulla.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.InParty()))
    {
        UO.PartyLeave();
    }

    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.PartyLeave();
        UO.Wait(500);
        UO.Print(UO.InParty());
        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.PartyLeave() — UO.PartyLeave()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "partyleave": bridge.PartyLeave(); return InjectionValue.Unit;

UO.PartyMembersList

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

Firme C#

dynamic UO.PartyMembersList();

Bridge filtra le voci Party.Members non vuote e le memorizza serial nell'ordine dell'elenco.

Parametri

Non ci sono parametri.

Valore restituito

Membri dell'array int serial da Party.Members locale. Sono escluse le voci vuote/Seriale=0. L'array potrebbe essere vuoto.

Comportamento

  • Bridge filtra le voci Party.Members non vuote e le memorizza serial nell'ordine dell'elenco. La chiamata non aggiorna il gruppo dal server e non invita membri.
  • 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.PartyMembersList();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Bridge filtra le voci Party.Members non vuote e le memorizza serial nell'ordine dell'elenco.
var members = UO.PartyMembersList();
UO.Print(UO.GetArrayLength(members));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Bridge filtra le voci Party.Members non vuote e le memorizza serial nell'ordine dell'elenco. La chiamata non aggiorna il gruppo dal server e non invita membri.
return  RunScenario();
 object? RunScenario()
{
    var members = UO.PartyMembersList();
    if (Truth(UO.GetArrayLength(members) > 0))
    {
        UO.Print(Hex(members[0]));
    }

    return null;
}

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

3. 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.PartyMembersList();
        UO.Wait(500);
        var after = UO.PartyMembersList();
        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.PartyMembersList() — UO.PartyMembersList()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "partymemberslist":

                    return new InjectionValue(bridge.PartyMembersList().Select(serial => new InjectionValue(serial)).ToArray());

UO.PartyPrivateMessageTo

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

Firme C#

void UO.PartyPrivateMessageTo(object? objID, object? msg);

Invia un messaggio privato a un membro del gruppo.

Parametri

  • objID — Oggetto seriale/ID: int, stringa numerica/esadecimale o alias stabilito, ad esempio "lasttarget". Questo non è graphic/type. Controllare l'oggetto caricato prima di agire.
  • msg - 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

  • PartySay ottiene Testo(1) e Arg(0); GameActions.SayParty(testo, serial) indirizza il messaggio al serial trasmesso. L'ordine è prima ObjID, poi Msg.
  • 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.PartyPrivateMessageTo");
UO.PartyPrivateMessageTo("lasttarget", "Ready");

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Invia un messaggio privato a un membro del gruppo.
UO.PartyPrivateMessageTo("lasttarget", "Ready");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • PartySay ottiene Testo(1) e Arg(0); GameActions.SayParty(testo, serial) indirizza il messaggio al serial trasmesso. L'ordine è prima ObjID, poi Msg.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(id)))
    {
        UO.PartyPrivateMessageTo(id, "Ready");
    }

    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()
    {
        SendPartyMessage(UO.GetSerial("lasttarget"), "Ready");
        return null;
    }

    void SendPartyMessage(dynamic id, dynamic message)
    {
        if (Truth(id != "0x00000000") && Truth(Len(message) > 0))
        {
            UO.PartyPrivateMessageTo(id, 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.PartyPrivateMessageTo(objID, msg) — UO.PartyPrivateMessageTo(Any,Any)

Parametri: objID (Any), msg (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.PartySay

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

Firme C#

void UO.PartySay(object? msg);

Invia un messaggio all'intero gruppo.

Parametri

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

  • Chiama GameActions.SayParty(testo, 0). Null serial significa messaggio di gruppo; la composizione del gruppo e la consegna sono determinate dal server.
  • 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.PartySay");
UO.PartySay("Ready");

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Invia un messaggio all'intero gruppo.
UO.PartySay("Ready");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Chiama GameActions.SayParty(testo, 0). Null serial significa messaggio di gruppo; la composizione del gruppo e la consegna sono determinate dal server.
return  RunScenario();
 object? RunScenario()
{
    var message = "Ready";
    if (Truth(UO.IsOnline()))
    {
        UO.PartySay(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("Ready");
        return null;
    }

    void SendText(dynamic message)
    {
        if (Truth(Len(message) > 0))
        {
            UO.PartySay(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.PartySay(msg) — UO.PartySay(Any)

Parametri: msg (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "partysay": bridge.PartySay(Text(0), 0); return InjectionValue.Unit;

UO.RemoveFromParty

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

Firme C#

void UO.RemoveFromParty(object? objID);

Richiede la rimozione di un membro del gruppo entro serial.

Parametri

  • objID — Oggetto seriale/ID: int, stringa numerica/esadecimale o alias stabilito, ad esempio "lasttarget". Questo non è graphic/type. Controllare l'oggetto caricato prima di agire.

Valore restituito

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

Comportamento

  • PartyRemove chiama RequestPartyRemoveMember. La risoluzione dipende dal ruolo del personaggio e del server corrente; l'elenco dei partecipanti non viene modificato in modo sincrono da questo comando.
  • 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.RemoveFromParty");
UO.RemoveFromParty(UO.GetSerial("lasttarget"));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede la rimozione di un membro del gruppo entro serial.
var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.RemoveFromParty(id);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • PartyRemove chiama RequestPartyRemoveMember. La risoluzione dipende dal ruolo del personaggio e del server corrente; l'elenco dei partecipanti non viene modificato in modo sincrono da questo comando.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("self");
    if (Truth(UO.Exists(id)))
    {
        UO.RemoveFromParty(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:

  • 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()
    {
        ApplyToLoaded(UO.GetSerial("lasttarget"));
        return null;
    }

    void ApplyToLoaded(dynamic id)
    {
        if (Truth(UO.Exists(id)))
        {
            UO.RemoveFromParty(id);
        }
    }

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

Parametri: objID (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "removefromparty": bridge.PartyRemove(Arg(0)); return InjectionValue.Unit;

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally