Skip to content

IT UO Topic trade

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

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

Commercio

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

Finestra per lo scambio sicuro tra giocatori: partecipante, contenitore, stato, conferma e annullamento.

Sezioni

Argomento Comandi e spiegazioni
IsTrade UO.IsTrade
Avversario commerciale UO.GetTradeOpponent · UO.GetTradeOpponentName
Contenitore commerciale UO.GetTradeContainer
ConfirmTrade UO.ConfirmTrade
CancelTrade UO.CancelTrade

Tutti i comandi del tema

Commercio sicuro

UO.IsTrade · UO.TradeCount · UO.TradeCheck · UO.TradeContainer · UO.GetTradeContainer · UO.TradeOpponent · UO.GetTradeOpponent · UO.TradeName · UO.GetTradeOpponentName · UO.ConfirmTrade · UO.CancelTrade

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

Parametri, risultato e tutti gli scenari

var value = UO.GetTradeContainer(1, 1);
UO.Print(Hex(value));

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

UO.ConfirmTrade

Parametri, risultato e tutti gli scenari

var result = UO.ConfirmTrade(1);
if (Truth(Truth(result) == true))
{
    UO.Print("Local request processed");
}

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

Riferimento completo dei comandi

UO.CancelTrade

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

Firme C#

dynamic UO.CancelTrade(object? tradeNum);

Annulla lo scambio selezionato e ne chiude la finestra.

Parametri

  • tradeNum — Intero: numero della finestra corrente da 1 a TradeCount(). 0 e valori negativi non sono ammessi. Questo non è serial.

Valore restituito

int: 1 (condizione soddisfatta) - la finestra viene trovata, chiusa e tramite chiusura viene inviata una richiesta di cancellazione; 0 (condizione non soddisfatta) - nessuna finestra. Non è in attesa di una risposta del server. Annullando nuovamente la finestra chiusa non viene inviato il secondo pacchetto.

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

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var result = UO.CancelTrade(1);
if (Truth(Truth(result) == true))
{
    UO.Print("Local request processed");
}

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

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.
return  RunScenario();
 object? RunScenario()
{
    var tradeNumber = 2;
    if (Truth(UO.TradeCount() >= tradeNumber))
    {
        var result = UO.CancelTrade(tradeNumber);
        UO.Print(Convert.ToString(result));
    }

    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. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 expectedPartner = UO.GetTradeOpponent(1);
        var result = ApplyToPartner(1, expectedPartner);
        UO.Print(Convert.ToString(result));
        return null;
    }

    dynamic ApplyToPartner(dynamic tradeNumber, dynamic expectedPartner)
    {
        if (Truth(expectedPartner == 0))
        {
            return false;
        }

        if (Truth(UO.GetTradeOpponent(tradeNumber) != expectedPartner))
        {
            return false;
        }

        return UO.CancelTrade(tradeNumber);
    }

    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.CancelTrade(tradeNum) — UO.CancelTrade(Any)

Parametri: tradeNum (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "canceltrade": return new InjectionValue(bridge.CancelTrade(Arg(0)));

UO.ConfirmTrade

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

Firme C#

dynamic UO.ConfirmTrade(object? tradeNum);

Imposta il flag di consenso personalizzato sull'exchange selezionato.

Parametri

  • tradeNum — Intero: numero della finestra corrente da 1 a TradeCount(). 0 e valori negativi non sono ammessi. Questo non è serial.

Valore restituito

int: 1 (condizione soddisfatta) - la finestra viene trovata e il suo accordo è attivato (o è già stato attivato); 0 (condizione non soddisfatta) - nessuna finestra. Non conferma il trasferimento degli elementi da parte del server. Richiamare non rimuove il consenso.

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

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var result = UO.ConfirmTrade(1);
if (Truth(Truth(result) == true))
{
    UO.Print("Local request processed");
}

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

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.
return  RunScenario();
 object? RunScenario()
{
    var tradeNumber = 2;
    if (Truth(UO.TradeCount() >= tradeNumber))
    {
        var result = UO.ConfirmTrade(tradeNumber);
        UO.Print(Convert.ToString(result));
    }

    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. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 expectedPartner = UO.GetTradeOpponent(1);
        var result = ApplyToPartner(1, expectedPartner);
        UO.Print(Convert.ToString(result));
        return null;
    }

    dynamic ApplyToPartner(dynamic tradeNumber, dynamic expectedPartner)
    {
        if (Truth(expectedPartner == 0))
        {
            return false;
        }

        if (Truth(UO.GetTradeOpponent(tradeNumber) != expectedPartner))
        {
            return false;
        }

        return UO.ConfirmTrade(tradeNumber);
    }

    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.ConfirmTrade(tradeNum) — UO.ConfirmTrade(Any)

Parametri: tradeNum (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "confirmtrade": return new InjectionValue(bridge.ConfirmTrade(Arg(0)));

UO.GetTradeContainer

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

Firme C#

dynamic UO.GetTradeContainer(object? tradeNum, object? num);

Restituisce il numerico serial di uno dei due contenitori di scambio.

Parametri

  • tradeNum — Intero: numero della finestra corrente da 1 a TradeCount(). 0 e valori negativi non sono ammessi. Questo non è serial.
  • num - 1 - contenitore proprio, 2 - contenitore del partner. I restanti valori restituiscono 0.

Valore restituito

int: 32 bit serial contenitore; 0 se non c'è nessuna finestra o Num errato. Questo non è type. Il bit più significativo viene preservato: controlla != 0, non > 0 o == true.

Comportamento

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var value = UO.GetTradeContainer(1, 1);
UO.Print(Hex(value));

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

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • totale: istantanea del numero di finestre; indice - indice/numero corrente. L'esempio di enumerazione non conferma nulla. In GetTradeContainer due chiamate leggono il proprio contenitore (1) e quello di qualcun altro (2) della prima finestra (1).
return  RunScenario();
 object? RunScenario()
{
    var ours = UO.GetTradeContainer(1, 1);
    var theirs = UO.GetTradeContainer(1, 2);
    UO.Print(Hex(ours) + " / " + Hex(theirs));
    return null;
}

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

3. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 value = ReadTradeValue(1);
        UO.Print(Hex(value));
        return null;
    }

    dynamic ReadTradeValue(dynamic index)
    {
        var total = UO.TradeCount();
        if (Truth(index < 1) || Truth(index >= total + 1))
        {
            return 0;
        }

        return UO.GetTradeContainer(index, 1);
    }

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

Implementazione del comando

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

UO.GetTradeContainer(tradeNum, num) — UO.GetTradeContainer(Any,Any)

Parametri: tradeNum (Any), num (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "gettradecontainer": return new InjectionValue(bridge.GetTradeContainer(Arg(0), Arg(1)));

UO.GetTradeOpponent

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

Firme C#

dynamic UO.GetTradeOpponent(object? tradeNum);

Restituisce il numero serial del carattere partner.

Parametri

  • tradeNum — Intero: numero della finestra corrente da 1 a TradeCount(). 0 e valori negativi non sono ammessi. Questo non è serial.

Valore restituito

int: carattere serial dalla finestra LocalSerial; 0 se non c'è finestra. Non un contenitore e non un bool; controlla != 0.

Comportamento

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var value = UO.GetTradeOpponent(1);
UO.Print(Hex(value));

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

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • totale: istantanea del numero di finestre; indice - indice/numero corrente. L'esempio di enumerazione non conferma nulla. In GetTradeContainer due chiamate leggono il proprio contenitore (1) e quello di qualcun altro (2) della prima finestra (1).
return  RunScenario();
 object? RunScenario()
{
    var total = UO.TradeCount();
    for (int index = (int)(1); index <= total - 0; index += (int)(1))
    {
        var value = UO.GetTradeOpponent(index);
        UO.Print(Convert.ToString(index) + ": " + Hex(value));
    }

    return null;
}

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

3. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 value = ReadTradeValue(1);
        UO.Print(Hex(value));
        return null;
    }

    dynamic ReadTradeValue(dynamic index)
    {
        var total = UO.TradeCount();
        if (Truth(index < 1) || Truth(index >= total + 1))
        {
            return 0;
        }

        return UO.GetTradeOpponent(index);
    }

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

Implementazione del comando

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

UO.GetTradeOpponent(tradeNum) — UO.GetTradeOpponent(Any)

Parametri: tradeNum (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "gettradeopponent": return new InjectionValue(bridge.GetTradeOpponent(Arg(0)));

UO.GetTradeOpponentName

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

Firme C#

dynamic UO.GetTradeOpponentName(object? tradeNum);

Restituisce il nome del partner ricevuto insieme alla finestra di scambio.

Parametri

  • tradeNum — Intero: numero della finestra corrente da 1 a TradeCount(). 0 e valori negativi non sono ammessi. Questo non è serial.

Valore restituito

string: nome dal pacchetto di apertura cambio; stringa vuota se non è presente alcuna finestra o nome. Non chiede più il nome.

Comportamento

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var value = UO.GetTradeOpponentName(1);
UO.Print(Convert.ToString(value));

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • totale: istantanea del numero di finestre; indice - indice/numero corrente. L'esempio di enumerazione non conferma nulla. In GetTradeContainer due chiamate leggono il proprio contenitore (1) e quello di qualcun altro (2) della prima finestra (1).
return  RunScenario();
 object? RunScenario()
{
    var total = UO.TradeCount();
    for (int index = (int)(1); index <= total - 0; index += (int)(1))
    {
        var value = UO.GetTradeOpponentName(index);
        UO.Print(Convert.ToString(index) + ": " + Convert.ToString(value));
    }

    return null;
}

3. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 value = ReadTradeValue(1);
        UO.Print(Convert.ToString(value));
        return null;
    }

    dynamic ReadTradeValue(dynamic index)
    {
        var total = UO.TradeCount();
        if (Truth(index < 1) || Truth(index >= total + 1))
        {
            return "";
        }

        return UO.GetTradeOpponentName(index);
    }

    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.GetTradeOpponentName(tradeNum) — UO.GetTradeOpponentName(Any)

Parametri: tradeNum (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "gettradeopponentname": return new InjectionValue(bridge.GetTradeOpponentName(Arg(0)));

UO.IsTrade

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

Firme C#

int UO.IsTrade();

Verifica la presenza di una finestra di scambio sicura aperta.

Parametri

Non ci sono parametri.

Valore restituito

int: 1 (condizione soddisfatta) - c'è uno scambio aperto; 0 (condizione non soddisfatta) - no.

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

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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.IsTrade();
UO.Print("IsTrade: " + Convert.ToString(result));

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var value = UO.IsTrade();
UO.Print(Convert.ToString(value));

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • prima/dopo: due istantanee separate con un intervallo di 500 millisecondi. La pausa non attende uno scambio specifico; Tra una lettura e l'altra lo stato può cambiare più volte.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.IsTrade();
    await Delay(500);
    var after = UO.IsTrade();
    UO.Print(Convert.ToString(before) + " -> " + Convert.ToString(after));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

3. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 value = ReadTradeState();
        UO.Print(Convert.ToString(value));
        return null;
    }

    dynamic ReadTradeState()
    {
        return UO.IsTrade();
    }
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "istrade": return new InjectionValue(bridge.IsTrade());

UO.TradeCheck

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

Firme C#

int UO.TradeCheck(object? windowIndex);
dynamic UO.TradeCheck(object? tradeNum, object? num);
int UO.TradeCheck(object? windowIndex, object? checkbox, object? stateValue);

Legge i flag di consenso; il modulo a tre parametri modifica anche la propria casella di controllo.

Parametri

  • windowIndex — Numero intero: indice della finestra corrente da 0 a TradeCount()-1. Un indice negativo o mancante produce un risultato vuoto. Questo non è serial.
  • tradeNum — Numero intero: indice della finestra corrente da 0 a TradeCount()-1. Un indice negativo o mancante produce un risultato vuoto. Questo non è serial.
  • num - Solo forma a due parametri: 1 - bandiera propria, 2 - bandiera del partner; altri significati danno 0. TradeNum qui inizia con 0.
  • checkbox — Solo forma a tre parametri: 0 — la tua bandiera, 1 — quella del tuo partner. La bandiera di qualcun altro viene solo letta; un altro significato è dato da 0.
  • stateValue — Solo con checkbox=0: 0/false rimuove il consenso, qualsiasi numero diverso da zero/true lo include. Se checkbox=1 il valore viene ignorato.

Valore restituito

int: 1 (condizione soddisfatta) - la casella di controllo selezionata è selezionata; 0 (condizione non soddisfatta) - rimossa, manca la finestra o il lato è errato. Il modulo di registrazione restituisce lo stato anziché l'indicazione di una transazione andata a buon fine: deselezionando la casella di controllo si restituisce 0.

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

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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.TradeCheck(0);
UO.Print("TradeCheck: " + Convert.ToString(result));

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • UO.TradeCheck(0) e UO.TradeCheck(0,1) leggono il loro accordo della prima finestra; UO.TradeCheck(0,2) - di qualcun altro. Non c'è registrazione e nessuna conferma automatica.
var own = UO.TradeCheck(0);
var sameOwn = UO.TradeCheck(0, 1);
var other = UO.TradeCheck(0, 2);
UO.Print(Convert.ToString(own) + "/" + Convert.ToString(sameOwn) + "/" + Convert.ToString(other));

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • UO.TradeCheck(0,0,false) revoca il proprio consenso. UO.TradeCheck(0,1,false) legge solo il consenso del partner: false non può cambiare la posizione di qualcun altro. Ci aspettiamo il risultato 0 dopo il ritiro.
return  RunScenario();
 object? RunScenario()
{
    var cleared = UO.TradeCheck(0, 0, false);
    var other = UO.TradeCheck(0, 1, false);
    UO.Print(Convert.ToString(cleared) + "/" + Convert.ToString(other));
    return null;
}

3. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 accepted = BothAccepted(0);
        if (Truth(Truth(accepted) == true))
        {
            UO.Print("Both boxes are checked; server completion is not known");
        }

        return null;
    }

    dynamic BothAccepted(dynamic index)
    {
        if (Truth(index < 0) || Truth(index >= UO.TradeCount()))
        {
            return false;
        }

        var own = UO.TradeCheck(index, 1);
        var other = UO.TradeCheck(index, 2);
        return Truth(Truth(own) == true) && Truth(Truth(other) == true);
    }

    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.TradeCheck(windowIndex) — UO.TradeCheck(Any)

Parametri: windowIndex (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int TradeCheck(InjectionValue windowIndex)

            => bridge.TradeCheck(NumberConversions.ToInt(windowIndex), 0, 0, false);

UO.TradeCheck(tradeNum, num) — UO.TradeCheck(Any,Any)

Parametri: tradeNum (Any), num (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "tradecheck":

                    // The compatibility reader uses participants 1/2; the legacy

                    // one/three-argument forms use checkbox indices 0/1.

                    int tradeSide = Arg(1);

                    return new InjectionValue(tradeSide is 1 or 2

                        ? bridge.TradeCheck(Arg(0), tradeSide - 1, 0, false) : 0);

UO.TradeCheck(windowIndex, checkbox, stateValue) — UO.TradeCheck(Any,Any,Any)

Parametri: windowIndex (Any), checkbox (Any), stateValue (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int TradeCheck(InjectionValue windowIndex, InjectionValue checkbox, InjectionValue stateValue)

            => bridge.TradeCheck(NumberConversions.ToInt(windowIndex), NumberConversions.ToInt(checkbox), NumberConversions.ToInt(stateValue), true);

UO.TradeContainer

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

Firme C#

string UO.TradeContainer(object? windowIndex);

Restituisce serial del suo contenitore di scambio come stringa esadecimale.

Parametri

  • windowIndex — Numero intero: indice della finestra corrente da 0 a TradeCount()-1. Un indice negativo o mancante produce un risultato vuoto. Questo non è serial.

Valore restituito

string: esadecimale della forma "0x40000011"; "0x00000000" se non è presente alcuna finestra. Questo è il ID del suo contenitore, non bool e non la stringa vuota.

Comportamento

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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.TradeContainer(0);
UO.Print("TradeContainer: " + Convert.ToString(result));

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var value = UO.TradeContainer(0);
UO.Print(Convert.ToString(value));

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • totale: istantanea del numero di finestre; indice - indice/numero corrente. L'esempio di enumerazione non conferma nulla. In GetTradeContainer due chiamate leggono il proprio contenitore (1) e quello di qualcun altro (2) della prima finestra (1).
return  RunScenario();
 object? RunScenario()
{
    var total = UO.TradeCount();
    for (int index = (int)(0); index <= total - 1; index += (int)(1))
    {
        var value = UO.TradeContainer(index);
        UO.Print(Convert.ToString(index) + ": " + Convert.ToString(value));
    }

    return null;
}

3. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 value = ReadTradeValue(0);
        UO.Print(Convert.ToString(value));
        return null;
    }

    dynamic ReadTradeValue(dynamic index)
    {
        var total = UO.TradeCount();
        if (Truth(index < 0) || Truth(index >= total + 0))
        {
            return "0x00000000";
        }

        return UO.TradeContainer(index);
    }

    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.TradeContainer(windowIndex) — UO.TradeContainer(Any)

Parametri: windowIndex (Any)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string TradeContainer(InjectionValue windowIndex) => NumberConversions.ToHex(bridge.TradeContainer(NumberConversions.ToInt(windowIndex)));

UO.TradeCount

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

Firme C#

int UO.TradeCount();

Restituisce il numero di finestre di scambio aperte.

Parametri

Non ci sono parametri.

Valore restituito

int: numero di finestre da 0. Questa è una quantità, non un bool; per verificare la disponibilità utilizzare > 0.

Comportamento

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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.TradeCount();
UO.Print("TradeCount: " + Convert.ToString(result));

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var value = UO.TradeCount();
UO.Print(Convert.ToString(value));

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • prima/dopo: due istantanee separate con un intervallo di 500 millisecondi. La pausa non attende uno scambio specifico; Tra una lettura e l'altra lo stato può cambiare più volte.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.TradeCount();
    await Delay(500);
    var after = UO.TradeCount();
    UO.Print(Convert.ToString(before) + " -> " + Convert.ToString(after));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

3. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 value = ReadTradeState();
        UO.Print(Convert.ToString(value));
        return null;
    }

    dynamic ReadTradeState()
    {
        return UO.TradeCount();
    }
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.TradeName

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

Firme C#

string UO.TradeName(object? windowIndex);

Restituisce il nome del partner dalla finestra di scambio in base all'indice da zero.

Parametri

  • windowIndex — Numero intero: indice della finestra corrente da 0 a TradeCount()-1. Un indice negativo o mancante produce un risultato vuoto. Questo non è serial.

Valore restituito

string: nome partner salvato; stringa vuota se non è presente alcuna finestra/nome. Il nome dell'elemento contenitore non viene utilizzato.

Comportamento

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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.TradeName(0);
UO.Print("TradeName: " + Convert.ToString(result));

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var value = UO.TradeName(0);
UO.Print(Convert.ToString(value));

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • totale: istantanea del numero di finestre; indice - indice/numero corrente. L'esempio di enumerazione non conferma nulla. In GetTradeContainer due chiamate leggono il proprio contenitore (1) e quello di qualcun altro (2) della prima finestra (1).
return  RunScenario();
 object? RunScenario()
{
    var total = UO.TradeCount();
    for (int index = (int)(0); index <= total - 1; index += (int)(1))
    {
        var value = UO.TradeName(index);
        UO.Print(Convert.ToString(index) + ": " + Convert.ToString(value));
    }

    return null;
}

3. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 value = ReadTradeValue(0);
        UO.Print(Convert.ToString(value));
        return null;
    }

    dynamic ReadTradeValue(dynamic index)
    {
        var total = UO.TradeCount();
        if (Truth(index < 0) || Truth(index >= total + 0))
        {
            return "";
        }

        return UO.TradeName(index);
    }

    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.TradeName(windowIndex) — UO.TradeName(Any)

Parametri: windowIndex (Any)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string TradeName(InjectionValue windowIndex) => bridge.TradeName(NumberConversions.ToInt(windowIndex));

UO.TradeOpponent

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

Firme C#

string UO.TradeOpponent(object? windowIndex);

Restituisce serial del contenitore partner come stringa esadecimale; questo non è un carattere ID.

Parametri

  • windowIndex — Numero intero: indice della finestra corrente da 0 a TradeCount()-1. Un indice negativo o mancante produce un risultato vuoto. Questo non è serial.

Valore restituito

string: esadecimale serial del contenitore ID2 di qualcun altro; "0x00000000" se non è presente alcuna finestra. Per un carattere ID, utilizza GetTradeOpponent(indice + 1).

Comportamento

  • GetTradeContainer/GetTradeOpponent/GetTradeOpponentName/ConfirmTrade/CancelTrade finestre numeriche con 1; TradeContainer/TradeOpponent/TradeName e tutte le forme di TradeCheck - da 0. Questa è un'ovvia compatibilità di questo client: i libri di riferimento esterni per motori diversi utilizzano punti di riferimento diversi.
  • La lettura viene eseguita sul thread di gioco utilizzando finestre live del mondo attuale. Le finestre chiuse non contano. Le chiamate di lettura non inviano pacchetti e non attendono una risposta. L'ordine di UI può cambiare quando si apre, si chiude e si sposta la finestra verso l'alto; il numero non è un identificatore permanente.
  • ConfirmTrade e il suo record TradeCheck inviano il pacchetto solo quando cambia il consenso. Il consenso di qualcun altro è determinato dal server. CancelTrade invia la cancellazione una volta. 1/true è lo stato/l'elaborazione locale e non una garanzia di completamento dello scambio. I nomi ed entrambi gli accordi non dimostrano che la composizione delle voci non sia cambiata.

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.TradeOpponent(0);
UO.Print("TradeOpponent: " + Convert.ToString(result));

1. Lettura o azione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • La chiamata viene effettuata una volta, il risultato viene memorizzato in valore/risultato. 0 è il primo indice, 1 è il primo numero (vedi la sintassi di questo comando). HEX mostra il numerico serial; Convert.ToString — numero o stringa.
var value = UO.TradeOpponent(0);
UO.Print(Convert.ToString(value));

2. Altri script e opzioni - Funzione script

Parametri e flusso di esecuzione:

  • totale: istantanea del numero di finestre; indice - indice/numero corrente. L'esempio di enumerazione non conferma nulla. In GetTradeContainer due chiamate leggono il proprio contenitore (1) e quello di qualcun altro (2) della prima finestra (1).
return  RunScenario();
 object? RunScenario()
{
    var total = UO.TradeCount();
    for (int index = (int)(0); index <= total - 1; index += (int)(1))
    {
        var value = UO.TradeOpponent(index);
        UO.Print(Convert.ToString(index) + ": " + Convert.ToString(value));
    }

    return null;
}

3. Assistente completo con tutte le funzionalità - Classe di script

Parametri e flusso di esecuzione:

  • L'aiutante viene fornito per intero e viene effettivamente chiamato da Main. I controlli Range/ID riducono il rischio di errore, ma più chiamate non sono atomiche: la finestra può cambiare tra di loro. Per l'azione expectedPartner: carattere serial salvato; questa non è una revisione del prezzo o del contenuto dello scambio.
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 value = ReadTradeValue(0);
        UO.Print(Convert.ToString(value));
        return null;
    }

    dynamic ReadTradeValue(dynamic index)
    {
        var total = UO.TradeCount();
        if (Truth(index < 0) || Truth(index >= total + 0))
        {
            return "0x00000000";
        }

        return UO.TradeOpponent(index);
    }

    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.TradeOpponent(windowIndex) — UO.TradeOpponent(Any)

Parametri: windowIndex (Any)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string TradeOpponent(InjectionValue windowIndex) => NumberConversions.ToHex(bridge.TradeOpponent(NumberConversions.ToInt(windowIndex)));

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally