Skip to content

IT UO Topic movement Part 2

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

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

Movimento — 2

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

Parti del riferimento

1 · 2

Riferimento completo dei comandi

UO.NewMoveXY

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

Firme C#

int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance, object? accuracyZ);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance, object? accuracyZ, object? avoidMobiles);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance, object? accuracyZ, object? avoidMobiles, object? openDoors);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance, object? accuracyZ, object? avoidMobiles, object? openDoors, object? stopOnStuck);

Muove il personaggio su X/Y, attende la fine e controlla il raggiungimento dell'obiettivo; supporta ulteriori restrizioni e richiamate.

Parametri

  • xdst — Coordinata mondiale X della destinazione, 0..65535. Questo non è serial o una posizione all'interno di un gump.
  • ydst - Coordinata Y mondiale della destinazione, 0..65535.
  • optimized - true - modalità normale di ricerca e controllo del percorso da seguire; false - euristica ridotta e controllo del passo più vicino. false non disabilita l'evitamento degli ostacoli.
  • accuracy — Tolleranza per X e Y nelle celle: entrambe le deviazioni devono rientrare in essa. Il valore è limitato all'intervallo 0..20; 0 richiede X/Y precisi.
  • running - true/1 - richiesta di esecuzione, false/0 - passo. I ritardi di movimento del server persistono; Non è un moltiplicatore di velocità.
  • timeout - Limite di attesa opzionale in millisecondi; un argomento mancante, 0 e un valore negativo indicano l'assenza di questo limite aggiuntivo.
  • maxSteps — Limite opzionale dei cambiamenti di posizione osservati, non dei pacchetti di rete. 0/negativo/assente - senza questo limite. Potrebbero essere necessari diversi passaggi tra i sondaggi, quindi questo non è un contatore di cellule accurato.
  • maxDistance — Limite opzionale sulla distanza iniziale max(abs(dx),abs(dy)) dal bersaglio. 0/absence lo disabilita. Questa non è la deviazione consentita durante l'attraversamento e non la lunghezza del percorso trovato.
  • accuracyZ — Tolleranza altezza: abs (Z effettiva - Z richiesta), limitata da 0..255. Lo zero richiede un'altitudine precisa; 255 essenzialmente disabilita il limite Z. Per NewMoveXY la Z del bersaglio è uguale alla Z del personaggio quando viene evocato; la tolleranza predefinita è 255.
  • avoidMobiles — Flag opzionale: true impedisce di passare attraverso i caratteri presi in considerazione; false consente il tentativo. Senza argomento, viene utilizzato moveThroughNPC. Il server potrebbe ancora negare l'accesso.
  • openDoors — Flag opzionale per l'apertura delle porte lungo il percorso. Senza argomento, viene utilizzato moveOpenDoor; true non fornisce l'accesso alle porte chiuse.
  • stopOnStuck - true completa il movimento con 0, se dopo aver pianificato circa 1000 ms X/Y/Z non sono cambiati. Le porzioni attive di ricerca e ricalcolo reimpostano questo timer; il timeout separato continua a funzionare. L'impostazione predefinita è false.

Valore restituito

int 1 - al termine del controllo il personaggio si trova nella tolleranza data X/Y/Z, anche quando era già lì prima della sfida. int 0 - coordinate non valide, lancio fallito, punto non raggiunto o condizione di arresto attivata. Non è il numero di passi o serial; In caso di cancellazione d'emergenza, la procedura viene interrotta invece di tornare normalmente 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

  • Il percorso A* completo viene creato prima del primo passaggio, in brevi porzioni tra gli aggiornamenti del client. Quando Ottimizzato=true vengono selezionate le celle 4 successive del percorso; quando false è il passo più vicino. Questo è un controllo del percorso già calcolato e non della distanza dell'intero percorso e non dei cursori della deviazione quando si sposta il mouse.
  • Il guasto del server DenyWalk o un nuovo ostacolo richiede un ricalcolo dalla posizione corrente dopo aver completato la coda di passaggi. Il numero di ripetizioni e la frequenza di ricalcolo sono limitati; nessun percorso può terminare il movimento con 0.
  • Il percorso appartiene alla procedura che lo ha avviato: il suo arresto di emergenza annulla il rimanente percorso automatico. Se un'altra corsa o un altro utente ha già sostituito il percorso, l'annullamento del proprietario precedente non influisce sul nuovo percorso. I passaggi già inviati non vengono richiamati.
  • SetBadLocation e SetBadObject vengono utilizzati come istantanea dei divieti del runtime corrente quando viene avviato il percorso. Vengono salvati durante il ricalcolo interno. La modifica o la cancellazione degli elenchi influisce sul percorso successivo, anziché sovrascriverne uno già in corso.
  • Dopo aver accettato la richiesta, la chiamata attende nel thread dello script. La ricerca iniziale e il ricalcolo vengono eseguiti sul flusso di gioco in blocchi: un massimo di 32 espansione del nodo e un budget morbido di circa 1 ms per blocco. Un controllo cellulare complesso o una lettura della carta possono superare questo budget. Tra una porzione e l'altra il client continua ad aggiornarsi; il limite totale di ricerca rimane 10000 nodi.
  • il timeout viene conteggiato dopo l'accettazione della richiesta e comprende le successive porzioni di ricerca e ricalcolo. stopOnStuck non considera una ricerca in corso come un carattere bloccato; Una volta completata la pianificazione, non verrà più presa in considerazione alcuna modifica della posizione. Il 1/0 finale controlla le coordinate effettive, non solo la disponibilità del percorso.
  • Il risultato tiene conto della posizione locale del cliente; è ancora possibile la successiva correzione del server. L'esecuzione di comandi di movimento concorrenti da routine diverse modifica il percorso generale del personaggio.
  • Le impostazioni moveCheckStamina, moveExitOnDisconnect, moveOpenDoor, moveThroughCorner, moveThroughNPC, moveHeuristicMult, moveTurnCost e moveBetweenTwoCorners influiscono sulle prestazioni. Gli espliciti avoidMobiles/openDoors sovrascrivono i valori corrispondenti per questa chiamata.
  • Il risultato 0 non indica la causa esatta. Controlla le coordinate, la connessione, la resistenza e il registro; non ripetere il movimento all'infinito senza UO.Wait e un limite di tentativi.
  • Il bridge principale registra il numero di richiesta, le istanze del giocatore/Pathfinder/della mappa e l'indice della mappa. Una nuova richiesta, cambio di contesto o rifiuto definitivo dà 0; il controllo viene ripetuto dopo la lettura delle coordinate e dell'ultima richiamata. Timeout, maxSteps e callback=0 interrompono solo la richiesta salvata, non una nuova rotta straniera. Temporaneamente Bloccato, mentre il recupero è ancora attivo, non perde il possesso: l'attesa continua. Per il bridge legacy esterno senza IApiMovementOwnershipBridge, viene mantenuto il meccanismo compatibile precedente.
  • Il Pathfinder generale memorizza fino a 8 divieti direzionali temporanei X/Y/Z per 2000 ms, solo in caso di movimento rifiutato della corrispondente richiesta attiva. Rotazione, sequenza sconosciuta, risincronizzazione e richiesta vecchia/estranea non creano tale divieto. Una nuova richiesta esterna e la perdita del contesto mappa/giocatore li cancella. La ricerca della geometria caricata tenta di aggirare la transizione; non conosce tutti gli ostacoli del server. Senza modificare X/Y/Z del giocatore, sono consentiti fino a 8 ricalcoli interni con una pausa di almeno 40 ms. Non esiste un percorso completo oppure il budget è esaurito: il percorso termina. L'attività coordinata viene quindi completata dopo l'elaborazione dei passaggi inviati; mobile-Follow potrebbe riprovare a causa del ritardo.

Il callback del passo in C# è registrato esplicitamente tramite RegisterStepCallback(name, Func<int,int,int,bool>) o Func<int,int,int,int>. Le coordinate x/y/z vengono trasmesse come int; false/0 interrompe il percorso, true/numero diverso da zero continua. La registrazione è valida nell'esecuzione corrente e viene rilasciata con essa.

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.NewMoveXY((UO.GetX() + 3), UO.GetY(), true, 0, false);
UO.Print("NewMoveXY: " + Convert.ToString(result));

1. Raggiungi il punto successivo e controlla il risultato: script diretto

Parametri e flusso di esecuzione:

  • x/y: obiettivo mondiale; Ottimizzato=true, Precisione=0 richiede X/Y precisi, Corsa=false specifica la camminata.
  • ok - int 1 o 0, non il numero di celle passate. Il bersaglio deve essere disponibile sulla mappa corrente.
var x = UO.GetX() + 3;
var y = UO.GetY();
var ok = UO.NewMoveXY(x, y, true, 0, false);
if (Truth(ok))
{
    UO.Print("Destination reached");
}
else
{
    UO.Print("Destination not reached");
}

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

2. Correre con limite di tempo e distanza - Funzione script

Parametri e flusso di esecuzione:

  • 1445/1690 - esempio di goal; Precisione=1 consente il parcheggio nelle vicinanze. Corsa=true. StepCallback=0 disabilita la richiamata.
  • timeout=5000 ms; maxSteps=100 movimenti osservati; maxDistance=30 viene controllato dall'origine.
  • PrecisioneZ=255 non richiede un pavimento; avoidMobiles=true, openDoors=true, stopOnStuck=true includono queste condizioni.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NewMoveXY(1445, 1690, true, 1, true, 0, 5000, 100, 30, 255, true, true, true);
    UO.Print("Move result: " + Convert.ToString(ok));
    return null;
}

3. Testare la resistenza nella callback - lezione di script

Parametri e flusso di esecuzione:

  • StepCallback="AfterStep" riceve tre coordinate. La registrazione RegisterStepCallback associa il nome al delegato bool. Quando Stamina <= 10 ritorna false e smette di muoversi; true continua il percorso.
  • timeout=5000 ms limita l'attesa. La richiamata viene chiamata dopo che viene rilevata una modifica e non è garantita per ogni passaggio della rete; Non fare una lunga attesa o un nuovo percorso al suo interno.
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 stepRegistration = RegisterStepCallback("AfterStep", AfterStep);
        var ok = UO.NewMoveXY(UO.GetX() + 5, UO.GetY(), true, 0, false, "AfterStep", 5000);
        UO.Print("Move result: " + Convert.ToString(ok));
        return null;
    }

    bool AfterStep(int x, int y, int z)
    {
        UO.Print("Position: " + Convert.ToString(x) + "," + Convert.ToString(y) + "," + Convert.ToString(z));
        return UO.Stamina() > 10;
    }

    private IDisposable RegisterStepCallback(string name, Func<int, int, int, bool> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterStepCallback(name, handler);
    private IDisposable RegisterStepCallback(string name, Func<int, int, int, int> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterStepCallback(name, handler);
}

4. GoToPoint: codice funzione helper completo e script diretto principale

Parametri e flusso di esecuzione:

  • GoToPoint è una funzione di supporto solo per questo esempio. I suoi quattro parametri x/y/accuracy/running sono descritti sopra la dichiarazione della funzione; il corpo completo della funzione si trova nello stesso blocco copiato.
  • Main valuta il target e chiama GoToPoint. Aggiunge ottimizzato=true, callback=0, timeout=8000 e maxSteps=100, chiama NewMoveXY una volta e passa il int restituito a Main.
  • NewMoveXY è un comando client integrato. La ricerca A*, il controllo di pervietà e l'elaborazione dei passaggi del server sono implementati nel client e non in procedure nascoste aggiuntive di questo script.
  • In questo esempio, la richiamata è disabilitata. Se un altro esempio specifica un nome di callback o richiama una funzione di script aggiuntiva, anche la sua definizione deve essere fornita nella sua interezza.
  • In C# check if (reached != 0); un risultato numerico di 0 indica fallimento. Un confronto diretto di int con bool non è accettabile. Una cancellazione di emergenza interrompe l'esecuzione e non è necessario restituire false.
var x = UO.GetX() + 3;
var y = UO.GetY();
var reached = GoToPoint(x, y, 0, true);
if (Truth(Truth(reached) == true))
{
    UO.Print("Destination reached");
}
else
{
    UO.Print("Destination not reached");
}

dynamic GoToPoint(dynamic x, dynamic y, dynamic accuracy, dynamic running)
{
    dynamic optimized = true;
    var callback = 0;
    var timeout = 8000;
    var maxSteps = 100;
    var reached = UO.NewMoveXY(x, y, optimized, accuracy, running, callback, timeout, maxSteps);
    return reached;
}

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.NewMoveXY(xdst, ydst, optimized, accuracy, running) — UO.NewMoveXY(Any,Any,Any,Any,Any)

Parametri: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any)

Parametri: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any)

Parametri: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance, accuracyZ) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any), accuracyZ (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance, accuracyZ, avoidMobiles) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any), accuracyZ (Any), avoidMobiles (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance, accuracyZ, avoidMobiles, openDoors) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any), accuracyZ (Any), avoidMobiles (Any), openDoors (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance, accuracyZ, avoidMobiles, openDoors, stopOnStuck) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any), accuracyZ (Any), avoidMobiles (Any), openDoors (Any), stopOnStuck (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactNewMoveXY(values))

UO.OpenDoor

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

Firme C#

void UO.OpenDoor();

Richiede che la porta venga aperta per il personaggio.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • OpenDoor chiama GameActions.OpenDoor tramite Invoke. La porta seriale non è accettata; le regole di ricerca e rilevamento appartengono a GameActions/server.
  • Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede che la porta venga aperta per il personaggio.
UO.OpenDoor();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • OpenDoor chiama GameActions.OpenDoor tramite Invoke. La porta seriale non è accettata; le regole di ricerca e rilevamento appartengono a GameActions/server.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.IsOnline()))
    {
        UO.OpenDoor();
    }

    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.OpenDoor();
        UO.Wait(250);
        UO.Print("Door request sent");
        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.OpenDoor() — UO.OpenDoor()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "opendoor": bridge.OpenDoor(); break;

UO.PMove

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

Firme C#

void UO.PMove(object? targetX, object? targetY);
void UO.PMove(object? x, object? y, object? z);

Comando di spostamento compatibile su X/Y tramite passaggi chiave separati con un limite di 30 secondi.

Parametri

  • targetX — Obiettivo del mondo X.
  • x — Obiettivo del mondo X.
  • targetY — Obiettivo del mondo Y.
  • y — Obiettivo del mondo Y.
  • z — Il terzo argomento compatibile viene accettato ma ignorato. Per controllare l'altezza, utilizzare MoveXYZ.

Valore restituito

void - nessun valore restituito. Chiama su una linea separata; non è true/false o il numero di passi.

Comportamento

  • Questo è un semplice movimento verso il bersaglio con una pausa 75 ms tra i tentativi, senza una ricerca completa di una deviazione. Per nuovi scenari con ostacoli, utilizzare NewMoveXY.
  • Se il X/Y esatto non viene raggiunto entro 30 secondi, viene visualizzato un messaggio. Non è possibile ottenere successo dal risultato void; confrontare le coordinate
  • MoveOff disabilita i passaggi chiave di questo comando, MoveOn lo abilita di nuovo. PMove con il movimento disattivato può ancora attendere fino al limite.

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.PMove");
UO.PMove((UO.GetX() + 1), UO.GetY());

1. Passa la cella successiva: script diretto

Parametri e flusso di esecuzione:

  • x/y specifica la destinazione. MoveOn abilita i passaggi chiave.
  • PMove non restituisce un numero: la posizione viene letta separatamente.
var x = UO.GetX() + 1;
var y = UO.GetY();
UO.MoveOn();
UO.PMove(x, y);
UO.Print("X=" + Convert.ToString(UO.GetX()));

2. Controlla il risultato in base alle coordinate - funzione dello script

Parametri e flusso di esecuzione:

  • Sostituisci 1445/1690 con il tuo punto accessibile.
  • Il controllo confronta entrambe le coordinate; L'unità non è adatta per se UO.PMove(...).
return  RunScenario();
 object? RunScenario()
{
    var x = 1445;
    var y = 1690;
    UO.PMove(x, y);
    if (Truth(UO.GetX() == x) && Truth(UO.GetY() == y))
    {
        UO.Print("Exact XY reached");
    }

    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. La forma compatibile con il terzo argomento è la classe script

Parametri e flusso di esecuzione:

  • X/Y corrisponde a quelli attuali, quindi non è necessario andare.
  • z=20 viene ignorato e non sale al piano più alto. Per questo è necessario MoveXYZ con un vero punto scala.

Velocità di guida standard

Intervallo minimo di passo: camminare - camminare 400 ms, correre 200 ms; cavalcare - camminare 200 ms, correre 100 ms.

Questi sono limiti client standard, non impostazioni definite automaticamente per il tuo shard. La velocità del server e le modalità di volo vengono conteggiate separatamente. I timer degli script possono rallentare il movimento, ma non riducono questi limiti.

Passi, percorsi, Follow, controlli mouse/tasti e mappa utilizzano la coda condivisa del personaggio. La sostituzione del percorso, la svolta o la regolazione della posizione da parte del server non annulla la pausa rimanente dopo la richiesta del passo. Dopo il ritardo, non vi è alcuna raffica veloce per compensare i fotogrammi persi. L'attesa di conferme, gli ostacoli e la scarsa comunicazione possono rallentare il movimento.

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.PMove(UO.GetX(), UO.GetY(), 20);
        UO.Print("Actual Z=" + Convert.ToString(UO.GetZ()));
        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.PMove(targetX, targetY) — UO.PMove(Integer,Integer)

Parametri: targetX (Integer), targetY (Integer)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void PMove(int targetX, int targetY)

        {

            var currentX = GetX();

            var currentY = GetY();

            var timeout = timeSource.Now.AddSeconds(30);



            while ((targetX != currentX || targetY != currentY) && timeSource.Now < timeout)

            {

                var direction = GetDirection(currentX, currentY, targetX, targetY);

                var key = GetKey(direction);



                bridge.MakeStepByKey(key);

                bridge.Wait(75);



                currentX = GetX();

                currentY = GetY();

            }



            if (targetX != currentX || targetY != currentY)

                SystemMessage("PMove stopped: destination was not reached in 30 seconds.");

        }

UO.PMove(x, y, z) — UO.PMove(Integer,Integer,Integer)

Parametri: x (Integer), y (Integer), z (Integer)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void PMove(int x, int y, int z) => PMove(x, y);

UO.PredictedDirection

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

Firme C#

int UO.PredictedDirection();

Legge il lato della direzione prevista dopo i passi già in coda del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

int direzione 0..7, senza bit run. 0 - nord o assenza di carattere.

Comportamento

  • Solo la funzione mostrata nella sintassi è UO senza argomenti. Non ci sono parametri target, serial, type, target, distanza o timeout. Il numero diverso da bool, ID o la notazione della tessera: 1 non significa raggiungere l'obiettivo.
  • GetEndPosition legge la direzione X/Y/Z/dell'ultimo Mobile.Step già aggiunto. Quando la coda è vuota, legge la posizione/direzione attuale del personaggio. Questa è una lettura O(1): il passo non viene recuperato, il movimento e il pacchetto non vengono inviati, il percorso non viene calcolato, il comando non attende un risultato.
  • Direzioni dal mondo: 0 nord, 1 nord-est, 2 est, 3 sud-est, 4 sud, 5 sud-ovest, 6 ovest, 7 nord-ovest. Lo schermo è isometrico. Direction.Mask rimuove il flag di esecuzione; la velocità non ritorna.
  • Questa è una previsione locale, non un arrivo confermato. Passaggi nuovi/completati, guasto del server, cancellazione della coda o teletrasporto possono cambiarlo. Le chiamate dei singoli componenti non sono atomiche; una corrispondenza X non dimostra una corrispondenza Y/Z o una conferma del server.
  • Invoke esegue una lettura sul thread del gioco; Il thread di lavoro è in attesa che il manager elabori la richiesta. L'annullamento dello script interrompe l'attesa. Non vengono aggiunte pause e richieste di rete aggiuntive.
  • Le implementazioni esterne di IApiBridge senza IPredictedMovementBridge mantengono una lettura di fallback delle coordinate/direzione correnti. Il classico UO implementa un'interfaccia in grado di riconoscere la coda.

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

1. Leggi un componente: script diretto

Parametri e flusso di esecuzione:

  • previsto salva una chiamata senza argomenti; Convert.ToString formatta il numero per il registro.
var predicted = UO.PredictedDirection();
UO.Print("Predicted: " + Convert.ToString(predicted));

2. Osservare il cambiamento delle previsioni - funzione script

Parametri e flusso di esecuzione:

  • UO.Wait(100) mette in pausa l'esempio per 100 ms. il prima e il dopo possono coincidere anche con un movimento intermedio; queste letture non avviano un movimento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.PredictedDirection();
    await Delay(100);
    var after = UO.PredictedDirection();
    if (Truth(before != after))
    {
        UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
    }

    return null;
}

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

3. Funzione di confronto completa - Classe di script

Parametri e flusso di esecuzione:

  • previsto: un esempio di coordinate/altezza/direzione, non un argomento per il comando nativo. PredictionEquals controlla UO.Self(), legge il valore una volta e restituisce 1 (condizione soddisfatta) se uguale, altrimenti 0 (condizione non soddisfatta). L'intero codice della funzione è mostrato sotto Main. La coincidenza di una componente non significa arrivo.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(Truth(PredictionEquals(4)) == true))
        {
            UO.Print("Queued endpoint matches this component");
        }
        else
        {
            UO.Print("Different component or no player");
        }

        return null;
    }

    dynamic PredictionEquals(dynamic expected)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var predicted = UO.PredictedDirection();
        return Truth(predicted == expected);
    }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "predicteddirection": return new InjectionValue(ReadPredictedCoordinate(3));

UO.PredictedX

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

Firme C#

int UO.PredictedX();

Legge la coordinata X prevista dopo i passi già in coda del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

int X nelle celle della mappa. 0 - coordinata valida o assenza di carattere.

Comportamento

  • Solo la funzione mostrata nella sintassi è UO senza argomenti. Non ci sono parametri target, serial, type, target, distanza o timeout. Il numero diverso da bool, ID o la notazione della tessera: 1 non significa raggiungere l'obiettivo.
  • GetEndPosition legge la direzione X/Y/Z/dell'ultimo Mobile.Step già aggiunto. Quando la coda è vuota, legge la posizione/direzione attuale del personaggio. Questa è una lettura O(1): il passo non viene recuperato, il movimento e il pacchetto non vengono inviati, il percorso non viene calcolato, il comando non attende un risultato.
  • X e Y sono coordinate del mondo/mappa, non pixel Gump del contenitore. Z è l'altezza, non il numero del piano. Viene restituito un singolo componente, non un array o la destinazione finale dell'intero percorso.
  • Questa è una previsione locale, non un arrivo confermato. Passaggi nuovi/completati, guasto del server, cancellazione della coda o teletrasporto possono cambiarlo. Le chiamate dei singoli componenti non sono atomiche; una corrispondenza X non dimostra una corrispondenza Y/Z o una conferma del server.
  • Invoke esegue una lettura sul thread del gioco; Il thread di lavoro è in attesa che il manager elabori la richiesta. L'annullamento dello script interrompe l'attesa. Non vengono aggiunte pause e richieste di rete aggiuntive.
  • Le implementazioni esterne di IApiBridge senza IPredictedMovementBridge mantengono una lettura di fallback delle coordinate/direzione correnti. Il classico UO implementa un'interfaccia in grado di riconoscere la coda.

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

1. Leggi un componente: script diretto

Parametri e flusso di esecuzione:

  • previsto salva una chiamata senza argomenti; Convert.ToString formatta il numero per il registro.
var predicted = UO.PredictedX();
UO.Print("Predicted: " + Convert.ToString(predicted));

2. Osservare il cambiamento delle previsioni - funzione script

Parametri e flusso di esecuzione:

  • UO.Wait(100) mette in pausa l'esempio per 100 ms. il prima e il dopo possono coincidere anche con un movimento intermedio; queste letture non avviano un movimento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.PredictedX();
    await Delay(100);
    var after = UO.PredictedX();
    if (Truth(before != after))
    {
        UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
    }

    return null;
}

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

3. Funzione di confronto completa - Classe di script

Parametri e flusso di esecuzione:

  • previsto: un esempio di coordinate/altezza/direzione, non un argomento per il comando nativo. PredictionEquals controlla UO.Self(), legge il valore una volta e restituisce 1 (condizione soddisfatta) se uguale, altrimenti 0 (condizione non soddisfatta). L'intero codice della funzione è mostrato sotto Main. La coincidenza di una componente non significa arrivo.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(Truth(PredictionEquals(1445)) == true))
        {
            UO.Print("Queued endpoint matches this component");
        }
        else
        {
            UO.Print("Different component or no player");
        }

        return null;
    }

    dynamic PredictionEquals(dynamic expected)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var predicted = UO.PredictedX();
        return Truth(predicted == expected);
    }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "predictedx": return new InjectionValue(ReadPredictedCoordinate(0));

UO.PredictedY

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

Firme C#

int UO.PredictedY();

Legge la coordinata Y prevista dopo i passi già in coda del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

int Y nelle celle della mappa. 0 - coordinata valida o assenza di carattere.

Comportamento

  • Solo la funzione mostrata nella sintassi è UO senza argomenti. Non ci sono parametri target, serial, type, target, distanza o timeout. Il numero diverso da bool, ID o la notazione della tessera: 1 non significa raggiungere l'obiettivo.
  • GetEndPosition legge la direzione X/Y/Z/dell'ultimo Mobile.Step già aggiunto. Quando la coda è vuota, legge la posizione/direzione attuale del personaggio. Questa è una lettura O(1): il passo non viene recuperato, il movimento e il pacchetto non vengono inviati, il percorso non viene calcolato, il comando non attende un risultato.
  • X e Y sono coordinate del mondo/mappa, non pixel Gump del contenitore. Z è l'altezza, non il numero del piano. Viene restituito un singolo componente, non un array o la destinazione finale dell'intero percorso.
  • Questa è una previsione locale, non un arrivo confermato. Passaggi nuovi/completati, guasto del server, cancellazione della coda o teletrasporto possono cambiarlo. Le chiamate dei singoli componenti non sono atomiche; una corrispondenza X non dimostra una corrispondenza Y/Z o una conferma del server.
  • Invoke esegue una lettura sul thread del gioco; Il thread di lavoro è in attesa che il manager elabori la richiesta. L'annullamento dello script interrompe l'attesa. Non vengono aggiunte pause e richieste di rete aggiuntive.
  • Le implementazioni esterne di IApiBridge senza IPredictedMovementBridge mantengono una lettura di fallback delle coordinate/direzione correnti. Il classico UO implementa un'interfaccia in grado di riconoscere la coda.

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

1. Leggi un componente: script diretto

Parametri e flusso di esecuzione:

  • previsto salva una chiamata senza argomenti; Convert.ToString formatta il numero per il registro.
var predicted = UO.PredictedY();
UO.Print("Predicted: " + Convert.ToString(predicted));

2. Osservare il cambiamento delle previsioni - funzione script

Parametri e flusso di esecuzione:

  • UO.Wait(100) mette in pausa l'esempio per 100 ms. il prima e il dopo possono coincidere anche con un movimento intermedio; queste letture non avviano un movimento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.PredictedY();
    await Delay(100);
    var after = UO.PredictedY();
    if (Truth(before != after))
    {
        UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
    }

    return null;
}

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

3. Funzione di confronto completa - Classe di script

Parametri e flusso di esecuzione:

  • previsto: un esempio di coordinate/altezza/direzione, non un argomento per il comando nativo. PredictionEquals controlla UO.Self(), legge il valore una volta e restituisce 1 (condizione soddisfatta) se uguale, altrimenti 0 (condizione non soddisfatta). L'intero codice della funzione è mostrato sotto Main. La coincidenza di una componente non significa arrivo.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(Truth(PredictionEquals(1690)) == true))
        {
            UO.Print("Queued endpoint matches this component");
        }
        else
        {
            UO.Print("Different component or no player");
        }

        return null;
    }

    dynamic PredictionEquals(dynamic expected)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var predicted = UO.PredictedY();
        return Truth(predicted == expected);
    }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "predictedy": return new InjectionValue(ReadPredictedCoordinate(1));

UO.PredictedZ

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

Firme C#

int UO.PredictedZ();

Legge l'altezza Z prevista dopo i passi già in coda del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

int Z, altezza con segno -128..127; viene mantenuto un valore negativo. 0 - altezza accettabile o assenza del personaggio.

Comportamento

  • Solo la funzione mostrata nella sintassi è UO senza argomenti. Non ci sono parametri target, serial, type, target, distanza o timeout. Il numero diverso da bool, ID o la notazione della tessera: 1 non significa raggiungere l'obiettivo.
  • GetEndPosition legge la direzione X/Y/Z/dell'ultimo Mobile.Step già aggiunto. Quando la coda è vuota, legge la posizione/direzione attuale del personaggio. Questa è una lettura O(1): il passo non viene recuperato, il movimento e il pacchetto non vengono inviati, il percorso non viene calcolato, il comando non attende un risultato.
  • X e Y sono coordinate del mondo/mappa, non pixel Gump del contenitore. Z è l'altezza, non il numero del piano. Viene restituito un singolo componente, non un array o la destinazione finale dell'intero percorso.
  • Questa è una previsione locale, non un arrivo confermato. Passaggi nuovi/completati, guasto del server, cancellazione della coda o teletrasporto possono cambiarlo. Le chiamate dei singoli componenti non sono atomiche; una corrispondenza X non dimostra una corrispondenza Y/Z o una conferma del server.
  • Invoke esegue una lettura sul thread del gioco; Il thread di lavoro è in attesa che il manager elabori la richiesta. L'annullamento dello script interrompe l'attesa. Non vengono aggiunte pause e richieste di rete aggiuntive.
  • Le implementazioni esterne di IApiBridge senza IPredictedMovementBridge mantengono una lettura di fallback delle coordinate/direzione correnti. Il classico UO implementa un'interfaccia in grado di riconoscere la coda.

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

1. Leggi un componente: script diretto

Parametri e flusso di esecuzione:

  • previsto salva una chiamata senza argomenti; Convert.ToString formatta il numero per il registro.
var predicted = UO.PredictedZ();
UO.Print("Predicted: " + Convert.ToString(predicted));

2. Osservare il cambiamento delle previsioni - funzione script

Parametri e flusso di esecuzione:

  • UO.Wait(100) mette in pausa l'esempio per 100 ms. il prima e il dopo possono coincidere anche con un movimento intermedio; queste letture non avviano un movimento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.PredictedZ();
    await Delay(100);
    var after = UO.PredictedZ();
    if (Truth(before != after))
    {
        UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
    }

    return null;
}

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

3. Funzione di confronto completa - Classe di script

Parametri e flusso di esecuzione:

  • previsto: un esempio di coordinate/altezza/direzione, non un argomento per il comando nativo. PredictionEquals controlla UO.Self(), legge il valore una volta e restituisce 1 (condizione soddisfatta) se uguale, altrimenti 0 (condizione non soddisfatta). L'intero codice della funzione è mostrato sotto Main. La coincidenza di una componente non significa arrivo.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(Truth(PredictionEquals(-4)) == true))
        {
            UO.Print("Queued endpoint matches this component");
        }
        else
        {
            UO.Print("Different component or no player");
        }

        return null;
    }

    dynamic PredictionEquals(dynamic expected)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var predicted = UO.PredictedZ();
        return Truth(predicted == expected);
    }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "predictedz": return new InjectionValue(ReadPredictedCoordinate(2));

UO.SetRunMountTimer

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

Firme C#

void UO.SetRunMountTimer(object? value);

Imposta l'intervallo di passi per correre a cavallo. Utilizzare per rallentare intenzionalmente o tornare alla velocità standard. Con questo comando non puoi accelerare il movimento oltre il tempo standard.

Parametri

  • value — Numero intero richiesto di millisecondi. Intervallo 100..2000; valori più piccoli, inclusi 0 e quelli negativi, salgono a 100, valori più grandi scendono a 2000.

Valore restituito

void - nessun valore. Chiama su una linea separata. Per leggere la spaziatura applicata, utilizzare UO.GetRunMountTimer(). Questa non è una conferma del passaggio da parte del server.

Comportamento

  • L'impostazione si applica alla modalità di guida. Il valore standard e minimo consentito è 100 ms; il limite superiore è 2000 ms. Le altre tre modalità hanno impostazioni separate.
  • Questo è l'intervallo di movimento locale del personaggio, non il ping, FPS, il timeout di ricerca del percorso o la durata misurata del passaggio del server. Aumentando il numero si rallenta il movimento; la diminuzione al di sotto dell'intervallo standard non accelera l'invio dei pacchetti.
  • La squadra stessa non inizia a muoversi, non monta sulla cavalcatura e non cambia la modalità camminata/corsa. La modalità viene selezionata durante la guida; anche la modalità di velocità e il volo specificati dal server vengono presi in considerazione dal client.
  • L'impostazione è generale per il movimento di questo client: può essere utilizzata dal controllo manuale, dal percorso della mappa e da altri script. Modificandolo temporaneamente, mantiene il valore precedente e lo ripristina dopo l'operazione; non modificare una modalità contemporaneamente da diverse procedure.
  • I passi di svolta e deviazione sono diversi dai movimenti normali. La conferma del server, i ritardi di comunicazione e gli ostacoli possono aumentare il tempo effettivo. Il client non invia una serie di passaggi accelerati per recuperare i frame mancanti.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

UO.Print("Calling UO.SetRunMountTimer");
UO.SetRunMountTimer(100);

1. Ripristina il tempo standard - script diretto

Parametri e flusso di esecuzione:

  • Valore=100 — millisecondi. La chiamata imposta il movimento successivo, ma non avvia un percorso.
UO.SetRunMountTimer(100);

2. Rallenta temporaneamente una richiesta di movimento - funzione script

Parametri e flusso di esecuzione:

  • Valore=200 aggiunge 100 ms all'intervallo standard. La modifica si applica solo alle corse a cavallo. Ad esempio, seleziona una direzione libera.
  • UO.Step ottiene Direction=2 e Running=true. Il codice 7 può significare solo svoltare; altri codici non sono true/false. finally ripristina l'impostazione precedente sullo spegnimento normale o sulla gestione degli errori.
return  RunScenario();
 object? RunScenario()
{
    var previous = UO.GetRunMountTimer();
    try
    {
        UO.SetRunMountTimer(200);
        var stepResult = UO.Step(2, true);
        if (Truth(stepResult != 7))
        {
            UO.Print("Step was not confirmed: " + Convert.ToString(stepResult));
        }
    }
    finally
    {
        UO.SetRunMountTimer(previous);
    }

    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. Controlla la protezione da un valore troppo basso - Classe script

Parametri e flusso di esecuzione:

  • Dopo che Valore=1 applicato è uguale a 100. L'esempio non sposta il carattere e ripristina la spaziatura originale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.GetRunMountTimer();
        try
        {
            UO.SetRunMountTimer(1);
            var applied = UO.GetRunMountTimer();
            UO.Print("Applied delay, ms: " + Convert.ToString(applied));
        }
        finally
        {
            UO.SetRunMountTimer(previous);
        }

        return null;
    }
}

Implementazione del comando

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

UO.SetRunMountTimer(value) — UO.SetRunMountTimer(Any)

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "setrunmounttimer":

                    state.RunMountTimer = ClampMoveTimer(Arg(0), 100);

                    bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer);

                    return InjectionValue.Unit;

UO.SetRunUnmountTimer

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

Firme C#

void UO.SetRunUnmountTimer(object? value);

Imposta l'intervallo del passo di camminata. Utilizzare per rallentare intenzionalmente o tornare alla velocità standard. Con questo comando non puoi accelerare il movimento oltre il tempo standard.

Parametri

  • value — Numero intero richiesto di millisecondi. Intervallo 200..2000; valori più piccoli, inclusi 0 e quelli negativi, salgono a 200, valori più grandi scendono a 2000.

Valore restituito

void - nessun valore. Chiama su una linea separata. Per leggere la spaziatura applicata, utilizzare UO.GetRunUnmountTimer(). Questa non è una conferma del passaggio da parte del server.

Comportamento

  • L'impostazione si applica alla modalità camminata. Il valore standard e minimo consentito è 200 ms; il limite superiore è 2000 ms. Le altre tre modalità hanno impostazioni separate.
  • Questo è l'intervallo di movimento locale del personaggio, non il ping, FPS, il timeout di ricerca del percorso o la durata misurata del passaggio del server. Aumentando il numero si rallenta il movimento; la diminuzione al di sotto dell'intervallo standard non accelera l'invio dei pacchetti.
  • La squadra stessa non inizia a muoversi, non monta sulla cavalcatura e non cambia la modalità camminata/corsa. La modalità viene selezionata durante la guida; anche la modalità di velocità e il volo specificati dal server vengono presi in considerazione dal client.
  • L'impostazione è generale per il movimento di questo client: può essere utilizzata dal controllo manuale, dal percorso della mappa e da altri script. Modificandolo temporaneamente, mantiene il valore precedente e lo ripristina dopo l'operazione; non modificare una modalità contemporaneamente da diverse procedure.
  • I passi di svolta e deviazione sono diversi dai movimenti normali. La conferma del server, i ritardi di comunicazione e gli ostacoli possono aumentare il tempo effettivo. Il client non invia una serie di passaggi accelerati per recuperare i frame mancanti.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

UO.Print("Calling UO.SetRunUnmountTimer");
UO.SetRunUnmountTimer(200);

1. Ripristina il tempo standard - script diretto

Parametri e flusso di esecuzione:

  • Valore=200 — millisecondi. La chiamata imposta il movimento successivo, ma non avvia un percorso.
UO.SetRunUnmountTimer(200);

2. Rallenta temporaneamente una richiesta di movimento - funzione script

Parametri e flusso di esecuzione:

  • Valore=300 aggiunge 100 ms all'intervallo standard. La modifica riguarda solo la corsa a piedi. Ad esempio, seleziona una direzione libera.
  • UO.Step ottiene Direction=2 e Running=true. Il codice 7 può significare solo svoltare; altri codici non sono true/false. finally ripristina l'impostazione precedente sullo spegnimento normale o sulla gestione degli errori.
return  RunScenario();
 object? RunScenario()
{
    var previous = UO.GetRunUnMountTimer();
    try
    {
        UO.SetRunUnmountTimer(300);
        var stepResult = UO.Step(2, true);
        if (Truth(stepResult != 7))
        {
            UO.Print("Step was not confirmed: " + Convert.ToString(stepResult));
        }
    }
    finally
    {
        UO.SetRunUnmountTimer(previous);
    }

    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. Controlla la protezione da un valore troppo basso - Classe script

Parametri e flusso di esecuzione:

  • Dopo che Valore=1 applicato è uguale a 200. L'esempio non sposta il carattere e ripristina la spaziatura originale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.GetRunUnMountTimer();
        try
        {
            UO.SetRunUnmountTimer(1);
            var applied = UO.GetRunUnMountTimer();
            UO.Print("Applied delay, ms: " + Convert.ToString(applied));
        }
        finally
        {
            UO.SetRunUnmountTimer(previous);
        }

        return null;
    }
}

Implementazione del comando

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

UO.SetRunUnmountTimer(value) — UO.SetRunUnmountTimer(Any)

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "setrununmounttimer":

                    state.RunUnmountTimer = ClampMoveTimer(Arg(0), 200);

                    bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer);

                    return InjectionValue.Unit;

UO.SetWalkMountTimer

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

Firme C#

void UO.SetWalkMountTimer(object? value);

Imposta l'intervallo dei passi per camminare a cavallo. Utilizzare per rallentare intenzionalmente o tornare alla velocità standard. Con questo comando non puoi accelerare il movimento oltre il tempo standard.

Parametri

  • value — Numero intero richiesto di millisecondi. Intervallo 200..2000; valori più piccoli, inclusi 0 e quelli negativi, salgono a 200, valori più grandi scendono a 2000.

Valore restituito

void - nessun valore. Chiama su una linea separata. Per leggere la spaziatura applicata, utilizzare UO.GetWalkMountTimer(). Questa non è una conferma del passaggio da parte del server.

Comportamento

  • L'impostazione si applica alla modalità di guida. Il valore standard e minimo consentito è 200 ms; il limite superiore è 2000 ms. Le altre tre modalità hanno impostazioni separate.
  • Questo è l'intervallo di movimento locale del personaggio, non il ping, FPS, il timeout di ricerca del percorso o la durata misurata del passaggio del server. Aumentando il numero si rallenta il movimento; la diminuzione al di sotto dell'intervallo standard non accelera l'invio dei pacchetti.
  • La squadra stessa non inizia a muoversi, non monta sulla cavalcatura e non cambia la modalità camminata/corsa. La modalità viene selezionata durante la guida; anche la modalità di velocità e il volo specificati dal server vengono presi in considerazione dal client.
  • L'impostazione è generale per il movimento di questo client: può essere utilizzata dal controllo manuale, dal percorso della mappa e da altri script. Modificandolo temporaneamente, mantiene il valore precedente e lo ripristina dopo l'operazione; non modificare una modalità contemporaneamente da diverse procedure.
  • I passi di svolta e deviazione sono diversi dai movimenti normali. La conferma del server, i ritardi di comunicazione e gli ostacoli possono aumentare il tempo effettivo. Il client non invia una serie di passaggi accelerati per recuperare i frame mancanti.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

UO.Print("Calling UO.SetWalkMountTimer");
UO.SetWalkMountTimer(200);

1. Ripristina il tempo standard - script diretto

Parametri e flusso di esecuzione:

  • Valore=200 — millisecondi. La chiamata imposta il movimento successivo, ma non avvia un percorso.
UO.SetWalkMountTimer(200);

2. Rallenta temporaneamente una richiesta di movimento - funzione script

Parametri e flusso di esecuzione:

  • Valore=300 aggiunge 100 ms all'intervallo standard. La modifica riguarda solo le passeggiate a cavallo. Ad esempio, seleziona una direzione libera.
  • UO.Step ottiene Direction=2 e Running=false. Il codice 7 può significare solo svoltare; altri codici non sono true/false. finally ripristina l'impostazione precedente sullo spegnimento normale o sulla gestione degli errori.
return  RunScenario();
 object? RunScenario()
{
    var previous = UO.GetWalkMountTimer();
    try
    {
        UO.SetWalkMountTimer(300);
        var stepResult = UO.Step(2, false);
        if (Truth(stepResult != 7))
        {
            UO.Print("Step was not confirmed: " + Convert.ToString(stepResult));
        }
    }
    finally
    {
        UO.SetWalkMountTimer(previous);
    }

    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. Controlla la protezione da un valore troppo basso - Classe script

Parametri e flusso di esecuzione:

  • Dopo che Valore=1 applicato è uguale a 200. L'esempio non sposta il carattere e ripristina la spaziatura originale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.GetWalkMountTimer();
        try
        {
            UO.SetWalkMountTimer(1);
            var applied = UO.GetWalkMountTimer();
            UO.Print("Applied delay, ms: " + Convert.ToString(applied));
        }
        finally
        {
            UO.SetWalkMountTimer(previous);
        }

        return null;
    }
}

Implementazione del comando

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

UO.SetWalkMountTimer(value) — UO.SetWalkMountTimer(Any)

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "setwalkmounttimer":

                    state.WalkMountTimer = ClampMoveTimer(Arg(0), 200);

                    bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer);

                    return InjectionValue.Unit;

UO.SetWalkUnmountTimer

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

Firme C#

void UO.SetWalkUnmountTimer(object? value);

Imposta l'intervallo del passo di camminata. Utilizzare per rallentare intenzionalmente o tornare alla velocità standard. Con questo comando non puoi accelerare il movimento oltre il tempo standard.

Parametri

  • value — Numero intero richiesto di millisecondi. Intervallo 400..2000; valori più piccoli, inclusi 0 e quelli negativi, salgono a 400, valori più grandi scendono a 2000.

Valore restituito

void - nessun valore. Chiama su una linea separata. Per leggere la spaziatura applicata, utilizzare UO.GetWalkUnmountTimer(). Questa non è una conferma del passaggio da parte del server.

Comportamento

  • L'impostazione si applica alla modalità camminata. Il valore standard e minimo consentito è 400 ms; il limite superiore è 2000 ms. Le altre tre modalità hanno impostazioni separate.
  • Questo è l'intervallo di movimento locale del personaggio, non il ping, FPS, il timeout di ricerca del percorso o la durata misurata del passaggio del server. Aumentando il numero si rallenta il movimento; la diminuzione al di sotto dell'intervallo standard non accelera l'invio dei pacchetti.
  • La squadra stessa non inizia a muoversi, non monta sulla cavalcatura e non cambia la modalità camminata/corsa. La modalità viene selezionata durante la guida; anche la modalità di velocità e il volo specificati dal server vengono presi in considerazione dal client.
  • L'impostazione è generale per il movimento di questo client: può essere utilizzata dal controllo manuale, dal percorso della mappa e da altri script. Modificandolo temporaneamente, mantiene il valore precedente e lo ripristina dopo l'operazione; non modificare una modalità contemporaneamente da diverse procedure.
  • I passi di svolta e deviazione sono diversi dai movimenti normali. La conferma del server, i ritardi di comunicazione e gli ostacoli possono aumentare il tempo effettivo. Il client non invia una serie di passaggi accelerati per recuperare i frame mancanti.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

UO.Print("Calling UO.SetWalkUnmountTimer");
UO.SetWalkUnmountTimer(400);

1. Ripristina il tempo standard - script diretto

Parametri e flusso di esecuzione:

  • Valore=400 — millisecondi. La chiamata imposta il movimento successivo, ma non avvia un percorso.
UO.SetWalkUnmountTimer(400);

2. Rallenta temporaneamente una richiesta di movimento - funzione script

Parametri e flusso di esecuzione:

  • Valore=500 aggiunge 100 ms all'intervallo standard. La modifica riguarda solo la camminata. Ad esempio, seleziona una direzione libera.
  • UO.Step ottiene Direction=2 e Running=false. Il codice 7 può significare solo svoltare; altri codici non sono true/false. finally ripristina l'impostazione precedente sullo spegnimento normale o sulla gestione degli errori.
return  RunScenario();
 object? RunScenario()
{
    var previous = UO.GetWalkUnmountTimer();
    try
    {
        UO.SetWalkUnmountTimer(500);
        var stepResult = UO.Step(2, false);
        if (Truth(stepResult != 7))
        {
            UO.Print("Step was not confirmed: " + Convert.ToString(stepResult));
        }
    }
    finally
    {
        UO.SetWalkUnmountTimer(previous);
    }

    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. Controlla la protezione da un valore troppo basso - Classe script

Parametri e flusso di esecuzione:

  • Dopo che Valore=1 applicato è uguale a 400. L'esempio non sposta il carattere e ripristina la spaziatura originale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.GetWalkUnmountTimer();
        try
        {
            UO.SetWalkUnmountTimer(1);
            var applied = UO.GetWalkUnmountTimer();
            UO.Print("Applied delay, ms: " + Convert.ToString(applied));
        }
        finally
        {
            UO.SetWalkUnmountTimer(previous);
        }

        return null;
    }
}

Implementazione del comando

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

UO.SetWalkUnmountTimer(value) — UO.SetWalkUnmountTimer(Any)

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "setwalkunmounttimer":

                    state.WalkUnmountTimer = ClampMoveTimer(Arg(0), 400);

                    bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer);

                    return InjectionValue.Unit;

UO.Step

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

Firme C#

dynamic UO.Step(object? direction, object? running);

Richiede un singolo passo/rotazione e, se è stato inviato un passo, attende la conferma del server.

Parametri

  • direction — Direzione 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. L'implementazione applica un &7; bit a bit. utilizzare 0..7 per chiarezza.
  • running - true/1 - richiesta di esecuzione, false/0 - passo. I ritardi di movimento del server persistono; Non è un moltiplicatore di velocità.

Valore restituito

int: 7 — il passo viene confermato o viene eseguito solo un giro; 5 — il server ha rifiutato il passaggio; 4 — conferma scaduta (fino a 10000 ms); 3 — passo bloccato dal cliente; 2 — la coda è piena; 0 - guasto generale, arresto o durata insufficiente. Non è true/false: ad esempio, il codice diverso da zero 5 significa fallimento.

Comportamento

  • Una squadra può prima ruotare il personaggio; questo non significa necessariamente passare alla casella successiva.
  • Vengono presi in considerazione moveCheckStamina, moveExitOnDisconnect e moveOpenDoor. Il divieto del server e il divieto locale sono diversi.
  • Non ripetere il comando in loop senza analizzare il risultato e UO.Wait: la coda di movimento e la velocità del server sono limitate.
  • QueueStep sullo streaming del gioco controlla il giocatore, la connessione, la direzione, la coda, il tempo e il traffico locale. Prima di Player.Walk, ciascuna chiamata registra separatamente le generazioni Conferma/Nega della sua sequenza e del Walker; quindi restituisce Risultato insieme a questa istantanea. Step e in sospeso StepControlled controlla solo questa coppia memorizzata, non i campi comuni della richiesta successiva; il giocatore/Walker sostitutivo conclude l'attesa con un rifiuto generale. La conferma di un altro comando regolare non conferma questo passaggio. La rotazione senza movimento resta un caso a parte.

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

1. Passo Est - Sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Direction=2 — E, Corsa=false — passo.
  • Viene controllato il codice esatto 7; Per confermare il movimento, confrontare X/Y prima e dopo.
var result = UO.Step(2, false);
if (Truth(result == 7))
{
    UO.Print("Step accepted or turn completed");
}
else
{
    UO.Print("Movement status: " + Convert.ToString(result));
}

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

2. Distinguere la rotazione dalla traduzione - funzione di script

Parametri e flusso di esecuzione:

  • Direction=0 - N. Le coordinate vengono lette prima e dopo la chiamata.
  • Una posizione invariata è possibile in seguito a rotazione o guasto, quindi il risultato è necessario separatamente.
return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX();
    var y = UO.GetY();
    var result = UO.Step(0, false);
    if (Truth(UO.GetX() == x) && Truth(UO.GetY() == y))
    {
        UO.Print("Position unchanged; status=" + 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. Gestire l'errore del server durante l'esecuzione: classe di script

Parametri e flusso di esecuzione:

  • Direction=4 — S, Running=true.
  • Codice 5: errore del server. UO.Wait=250 ms specifica una pausa per lo script e non garantisce che il tentativo successivo avrà successo.

Velocità di guida standard

Intervallo minimo di passo: camminare - camminare 400 ms, correre 200 ms; cavalcare - camminare 200 ms, correre 100 ms.

Questi sono limiti client standard, non impostazioni definite automaticamente per il tuo shard. La velocità del server e le modalità di volo vengono conteggiate separatamente. I timer degli script possono rallentare il movimento, ma non riducono questi limiti.

Passi, percorsi, Follow, controlli mouse/tasti e mappa utilizzano la coda condivisa del personaggio. La sostituzione del percorso, la svolta o la regolazione della posizione da parte del server non annulla la pausa rimanente dopo la richiesta del passo. Dopo il ritardo, non vi è alcuna raffica veloce per compensare i fotogrammi persi. L'attesa di conferme, gli ostacoli e la scarsa comunicazione possono rallentare il movimento.

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 result = UO.Step(4, true);
        if (Truth(result == 5))
        {
            UO.Print("Server denied the step");
            await Delay(250);
        }

        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.Step(direction, running) — UO.Step(Any,Any)

Parametri: direction (Any), running (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "step":

                    if (state.MoveExitOnDisconnect != 0 && bridge.IsOnline() == 0)

                        return new InjectionValue(0);

                    if (state.MoveCheckStamina > 0 && bridge.Stamina < state.MoveCheckStamina)

                        return new InjectionValue(0);

                    if (state.MoveOpenDoor != 0)

                        bridge.OpenDoor();

                    return new InjectionValue(bridge.Step(Arg(0) & 7, Arg(1) != 0));

UO.StepQ

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

Firme C#

int UO.StepQ(object? direction, object? run);
int UO.StepQ(object? direction, object? run, object? timeout);
int UO.StepQ(object? direction, object? run, object? timeout, object? queue);
int UO.StepQ(object? direction, object? run, object? timeout, object? queue, object? waitForAck);

Richiede un passaggio nella coda; il modulo aggiuntivo potrà attendere che la coda si liberi e venga confermato.

Parametri

  • direction — Direzione 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. L'implementazione applica un &7; bit a bit. utilizzare 0..7 per chiarezza.
  • run - true/1 - richiesta di esecuzione, false/0 - passo. I ritardi di movimento del server persistono; Non è un moltiplicatore di velocità.
  • timeout - Tempo di attesa della coda opzionale in ms. 0/negative non attende il rilascio; con waitForAck=true e timeout=0 è prevista la conferma prima di 10000 ms. Se il valore è positivo, l'attesa della conferma riceve un periodo separato della stessa durata.
  • queue — Flag opzionale, predefinito true. false trasmette forcePacket quando si richiede un passo; non sovrascrive le restrizioni del server né cancella la coda accumulata.
  • waitForAck - false/assente - restituisce immediatamente il risultato dell'istruzione. true — per il passo inviato, attendere conferma/rifiuto.

Valore restituito

int senza waitForAck: 0..255 — sequenza della richiesta inviata, incluso 0 valido; 256 - solo rotazione; -2 — ostacolo sul cliente; -1 - guasto generale/coda piena/spegnimento/resistenza. Con waitForAck=true: 7 - conferma, 5 - errore del server, 4 - timeout; -1/-2/256 mantengono il significato precedente. Il numero 7 nel modulo senza attesa è una sequenza, non una conferma. Controllare codici numerici specifici; se (risultato) per int in C# non è valido.

Comportamento

  • Una squadra può prima ruotare il personaggio; questo non significa necessariamente passare alla casella successiva.
  • Vengono presi in considerazione moveCheckStamina, moveExitOnDisconnect e moveOpenDoor. Il divieto del server e il divieto locale sono diversi.
  • Non ripetere il comando in loop senza analizzare il risultato e UO.Wait: la coda di movimento e la velocità del server sono limitate.
  • Senza attesa, il comando non conferma il cambio di posizione. LastStepQUsedDoor indica un tentativo di apertura della porta, non l'esito del passo.
  • QueueStep sullo streaming del gioco controlla il giocatore, la connessione, la direzione, la coda, il tempo e il traffico locale. Prima di Player.Walk, ciascuna chiamata registra separatamente le generazioni Conferma/Nega della sua sequenza e del Walker; quindi restituisce Risultato insieme a questa istantanea. Step e in sospeso StepControlled controlla solo questa coppia memorizzata, non i campi comuni della richiesta successiva; il giocatore/Walker sostitutivo conclude l'attesa con un rifiuto generale. La conferma di un altro comando regolare non conferma questo passaggio. La rotazione senza movimento resta un caso a parte.

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

1. Ottieni la sequenza senza aspettare: script diretto

Parametri e flusso di esecuzione:

  • direzione=2 — E, corsa=false. Due argomenti indicano l'impostazione normale senza attendere la conferma.
  • sequenza=0 è un successo di stadiazione valido; sequenza=256 significa rotazione.
var sequence = UO.StepQ(2, false);
if (Truth(sequence >= 0) && Truth(sequence <= 255))
{
    UO.Print("Queued sequence: " + Convert.ToString(sequence));
}
else
{
    UO.Print("Queue status: " + Convert.ToString(sequence));
}

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

2. Attendi conferma - funzione script

Parametri e flusso di esecuzione:

  • direction=4 — S, run=true, timeout=1500 SM. coda=true, waitForAck=true.
  • Potrebbero essere necessari fino a due intervalli 1500 ms per attendere un posto e quindi confermare. 256 richiede una considerazione separata della rotazione.
return  RunScenario();
 object? RunScenario()
{
    var status = UO.StepQ(4, true, 1500, true, true);
    if (Truth(status == 7))
    {
        UO.Print("Server confirmed");
    }
    else
    {
        UO.Print("Step status: " + Convert.ToString(status));
    }

    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. Elabora separatamente il muro locale - classe di script

Parametri e flusso di esecuzione:

  • direzione=6 — W, corsa=false; timeout=0 non attende in linea; coda=false richiede forcePacket, waitForAck=false.
  • ForcePacket non dà il diritto di attraversare il muro. Per -2, calcola un percorso diverso invece di inviare nuovamente alla stessa cella.

Velocità di guida standard

Intervallo minimo di passo: camminare - camminare 400 ms, correre 200 ms; cavalcare - camminare 200 ms, correre 100 ms.

Questi sono limiti client standard, non impostazioni definite automaticamente per il tuo shard. La velocità del server e le modalità di volo vengono conteggiate separatamente. I timer degli script possono rallentare il movimento, ma non riducono questi limiti.

Passi, percorsi, Follow, controlli mouse/tasti e mappa utilizzano la coda condivisa del personaggio. La sostituzione del percorso, la svolta o la regolazione della posizione da parte del server non annulla la pausa rimanente dopo la richiesta del passo. Dopo il ritardo, non vi è alcuna raffica veloce per compensare i fotogrammi persi. L'attesa di conferme, gli ostacoli e la scarsa comunicazione possono rallentare il movimento.

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 status = UO.StepQ(6, false, 0, false, false);
        if (Truth(status == -2))
        {
            UO.Print("Local obstacle; calculate another route");
        }

        return null;
    }

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

Implementazione del comando

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

UO.StepQ(direction, run) — UO.StepQ(Any,Any)

Parametri: direction (Any), run (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactStepQ(values))

UO.StepQ(direction, run, timeout) — UO.StepQ(Any,Any,Any)

Parametri: direction (Any), run (Any), timeout (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactStepQ(values))

UO.StepQ(direction, run, timeout, queue) — UO.StepQ(Any,Any,Any,Any)

Parametri: direction (Any), run (Any), timeout (Any), queue (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactStepQ(values))

UO.StepQ(direction, run, timeout, queue, waitForAck) — UO.StepQ(Any,Any,Any,Any,Any)

Parametri: direction (Any), run (Any), timeout (Any), queue (Any), waitForAck (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactStepQ(values))

UO.moveBetweenTwoCorners

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

Firme C#

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

Risoluzione diagonale con due quadrati laterali bloccati.

Parametri

  • value - Nuovo valore facoltativo. 0 proibisce, diverso da zero diventa 1. Il server può rifiutare tale passaggio indipendentemente dalla configurazione del client.

Valore restituito

int è il valore attualmente memorizzato. Senza discussione si limita a leggere; con un argomento restituisce il valore dopo aver applicato le regole precedenti. Questa è un'impostazione, non il risultato del movimento.

Comportamento

  • L'impostazione viene memorizzata nello stato di runtime e viene utilizzata dai comandi corrispondenti all'avvio; la modifica non sovrascrive automaticamente il percorso già creato.
  • La restituzione del valore originale viene mostrata per il completamento normale. Dopo un arresto anomalo, le seguenti righe di ripristino non vengono eseguite.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti, lo stato non cambia.
  • valore è il valore numerico di questa impostazione.
var value = UO.moveBetweenTwoCorners();
UO.Print(Convert.ToString(value));

2. Imposta valore esplicito - Funzione script

Parametri e flusso di esecuzione:

  • valore=0. 0 proibisce, diverso da zero diventa 1. Il server può rifiutare tale passaggio indipendentemente dalla configurazione del client.
  • applicato mostra il valore salvato, non il raggiungimento riuscito dell'obiettivo.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveBetweenTwoCorners(0);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Applicare a una sezione dello script - classe script

Parametri e flusso di esecuzione:

  • precedente memorizza l'impostazione iniziale; NewMoveXY è limitato a 3000 ms.
  • L'ultimo comando ripristina l'impostazione dopo il ritorno al movimento normale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.moveBetweenTwoCorners();
        UO.moveBetweenTwoCorners(0);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveBetweenTwoCorners(previous);
        UO.Print(Convert.ToString(ok));
        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.moveBetweenTwoCorners() — UO.moveBetweenTwoCorners()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "movebetweentwocorners":

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

                    return new InjectionValue(state.MoveBetweenTwoCorners);

UO.moveBetweenTwoCorners(value) — UO.moveBetweenTwoCorners(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "movebetweentwocorners":

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

                    return new InjectionValue(state.MoveBetweenTwoCorners);

UO.moveCheckStamina

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

Firme C#

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

Resistenza minima per i comandi di movimento.

Parametri

  • value - Nuovo valore facoltativo. Intero >=0; il negativo diventa 0. Lo zero disattiva il controllo della soglia.

Valore restituito

int è il valore attualmente memorizzato. Senza discussione si limita a leggere; con un argomento restituisce il valore dopo aver applicato le regole precedenti. Questa è un'impostazione, non il risultato del movimento.

Comportamento

  • L'impostazione viene memorizzata nello stato di runtime e viene utilizzata dai comandi corrispondenti all'avvio; la modifica non sovrascrive automaticamente il percorso già creato.
  • La restituzione del valore originale viene mostrata per il completamento normale. Dopo un arresto anomalo, le seguenti righe di ripristino non vengono eseguite.
  • L'impostazione predefinita è 1. Il valore 0 disabilita questo controllo locale; positivo imposta la resistenza minima. Al di sotto della soglia, il lancio viene rifiutato o il movimento viene interrotto anziché attendere il ripristino della resistenza.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti, lo stato non cambia.
  • valore è il valore numerico di questa impostazione.
var value = UO.moveCheckStamina();
UO.Print(Convert.ToString(value));

2. Imposta valore esplicito - Funzione script

Parametri e flusso di esecuzione:

  • valore=15. Intero >=0; il negativo diventa 0. Lo zero disattiva il controllo della soglia.
  • applicato mostra il valore salvato, non il raggiungimento riuscito dell'obiettivo.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveCheckStamina(15);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Applicare a una sezione dello script - classe script

Parametri e flusso di esecuzione:

  • precedente memorizza l'impostazione iniziale; NewMoveXY è limitato a 3000 ms.
  • L'ultimo comando ripristina l'impostazione dopo il ritorno al movimento normale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.moveCheckStamina();
        UO.moveCheckStamina(15);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveCheckStamina(previous);
        UO.Print(Convert.ToString(ok));
        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.moveCheckStamina() — UO.moveCheckStamina()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "movecheckstamina": if (arguments.Length > 0) state.MoveCheckStamina = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveCheckStamina);

UO.moveCheckStamina(value) — UO.moveCheckStamina(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "movecheckstamina": if (arguments.Length > 0) state.MoveCheckStamina = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveCheckStamina);

UO.moveExitOnDisconnect

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

Firme C#

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

Arresta/rifiuta il movimento quando la connessione viene interrotta.

Parametri

  • value - Nuovo valore facoltativo. 0 si spegne, il diverso da zero diventa 1. La disabilitazione della verifica ti impedisce di spostarti sul server senza una connessione.

Valore restituito

int è il valore attualmente memorizzato. Senza discussione si limita a leggere; con un argomento restituisce il valore dopo aver applicato le regole precedenti. Questa è un'impostazione, non il risultato del movimento.

Comportamento

  • L'impostazione viene memorizzata nello stato di runtime e viene utilizzata dai comandi corrispondenti all'avvio; la modifica non sovrascrive automaticamente il percorso già creato.
  • La restituzione del valore originale viene mostrata per il completamento normale. Dopo un arresto anomalo, le seguenti righe di ripristino non vengono eseguite.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti, lo stato non cambia.
  • valore è il valore numerico di questa impostazione.
var value = UO.moveExitOnDisconnect();
UO.Print(Convert.ToString(value));

2. Imposta valore esplicito - Funzione script

Parametri e flusso di esecuzione:

  • valore=1. 0 si spegne, il diverso da zero diventa 1. La disabilitazione della verifica ti impedisce di spostarti sul server senza una connessione.
  • applicato mostra il valore salvato, non il raggiungimento riuscito dell'obiettivo.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveExitOnDisconnect(1);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Applicare a una sezione dello script - classe script

Parametri e flusso di esecuzione:

  • precedente memorizza l'impostazione iniziale; NewMoveXY è limitato a 3000 ms.
  • L'ultimo comando ripristina l'impostazione dopo il ritorno al movimento normale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.moveExitOnDisconnect();
        UO.moveExitOnDisconnect(1);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveExitOnDisconnect(previous);
        UO.Print(Convert.ToString(ok));
        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.moveExitOnDisconnect() — UO.moveExitOnDisconnect()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "moveexitondisconnect": if (arguments.Length > 0) state.MoveExitOnDisconnect = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveExitOnDisconnect);

UO.moveExitOnDisconnect(value) — UO.moveExitOnDisconnect(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "moveexitondisconnect": if (arguments.Length > 0) state.MoveExitOnDisconnect = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveExitOnDisconnect);

UO.moveHeuristicMult

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

Firme C#

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

Moltiplicatore euristico di Pathfinder come percentuale.

Parametri

  • value - Nuovo valore facoltativo. Il numero intero >=0 viene conservato; prima di cercare almeno 1. Il valore 100 corrisponde alla stima abituale; >100 potrebbe preferire una ricerca più rapida senza garanzia di costo minimo. Quando Ottimizzato=false, viene utilizzato 1.

Valore restituito

int è il valore attualmente memorizzato. Senza discussione si limita a leggere; con un argomento restituisce il valore dopo aver applicato le regole precedenti. Questa è un'impostazione, non il risultato del movimento.

Comportamento

  • L'impostazione viene memorizzata nello stato di runtime e viene utilizzata dai comandi corrispondenti all'avvio; la modifica non sovrascrive automaticamente il percorso già creato.
  • La restituzione del valore originale viene mostrata per il completamento normale. Dopo un arresto anomalo, le seguenti righe di ripristino non vengono eseguite.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti, lo stato non cambia.
  • valore è il valore numerico di questa impostazione.
var value = UO.moveHeuristicMult();
UO.Print(Convert.ToString(value));

2. Imposta valore esplicito - Funzione script

Parametri e flusso di esecuzione:

  • valore=100. Integer >=0 is preserved; prima di cercare almeno 1. Il valore 100 corrisponde alla stima abituale; >100 potrebbe preferire una ricerca più rapida senza garanzia di un costo minimo. Quando Ottimizzato=false, viene utilizzato 1.
  • applicato mostra il valore salvato, non il raggiungimento riuscito dell'obiettivo.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveHeuristicMult(100);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Applicare a una sezione dello script - classe script

Parametri e flusso di esecuzione:

  • precedente memorizza l'impostazione iniziale; NewMoveXY è limitato a 3000 ms.
  • L'ultimo comando ripristina l'impostazione dopo il ritorno al movimento normale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.moveHeuristicMult();
        UO.moveHeuristicMult(100);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveHeuristicMult(previous);
        UO.Print(Convert.ToString(ok));
        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.moveHeuristicMult() — UO.moveHeuristicMult()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "moveheuristicmult": if (arguments.Length > 0) state.MoveHeuristicMultiplier = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveHeuristicMultiplier);

UO.moveHeuristicMult(value) — UO.moveHeuristicMult(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "moveheuristicmult": if (arguments.Length > 0) state.MoveHeuristicMultiplier = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveHeuristicMultiplier);

UO.moveOpenDoor

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

Firme C#

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

Tentativi di aprire le porte nella direzione di marcia.

Parametri

  • value - Nuovo valore facoltativo. 0 si spegne, il diverso da zero diventa 1. Un openDoors esplicito in NewMoveXY/MoveXYZ sostituisce questo flag per tutta la durata della chiamata.

Valore restituito

int è il valore attualmente memorizzato. Senza discussione si limita a leggere; con un argomento restituisce il valore dopo aver applicato le regole precedenti. Questa è un'impostazione, non il risultato del movimento.

Comportamento

  • L'impostazione viene memorizzata nello stato di runtime e viene utilizzata dai comandi corrispondenti all'avvio; la modifica non sovrascrive automaticamente il percorso già creato.
  • La restituzione del valore originale viene mostrata per il completamento normale. Dopo un arresto anomalo, le seguenti righe di ripristino non vengono eseguite.
  • L'impostazione predefinita è 0. A 1 le celle della porta sono considerate transitabili durante A*; prima del passo viene effettuato un tentativo di apertura di una specifica porta adiacente. Se non è presente alcun oggetto porta noto, viene utilizzata la query OpenDoor.
  • Questa bandiera non chiude la porta stessa. Chiudere una porta aperta da un personaggio è un'impostazione client separata; una porta chiusa o un divieto del server possono interrompere il percorso.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti, lo stato non cambia.
  • valore è il valore numerico di questa impostazione.
var value = UO.moveOpenDoor();
UO.Print(Convert.ToString(value));

2. Imposta valore esplicito - Funzione script

Parametri e flusso di esecuzione:

  • valore=1. 0 si spegne, il diverso da zero diventa 1. Un openDoors esplicito in NewMoveXY/MoveXYZ sostituisce questo flag per la durata della chiamata.
  • applicato mostra il valore salvato, non il raggiungimento riuscito dell'obiettivo.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveOpenDoor(1);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Applicare a una sezione dello script - classe script

Parametri e flusso di esecuzione:

  • precedente memorizza l'impostazione iniziale; NewMoveXY è limitato a 3000 ms.
  • L'ultimo comando ripristina l'impostazione dopo il ritorno al movimento normale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.moveOpenDoor();
        UO.moveOpenDoor(1);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveOpenDoor(previous);
        UO.Print(Convert.ToString(ok));
        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.moveOpenDoor() — UO.moveOpenDoor()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "moveopendoor": if (arguments.Length > 0) state.MoveOpenDoor = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveOpenDoor);

UO.moveOpenDoor(value) — UO.moveOpenDoor(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "moveopendoor": if (arguments.Length > 0) state.MoveOpenDoor = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveOpenDoor);

UO.moveThroughCorner

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

Firme C#

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

Risoluzione della diagonale tra le celle con una cella laterale bloccata.

Parametri

  • value - Nuovo valore facoltativo. 0 proibisce, diverso da zero diventa 1. Se entrambe le caselle laterali sono bloccate, viene applicato moveBetweenTwoCorners.

Valore restituito

int è il valore attualmente memorizzato. Senza discussione si limita a leggere; con un argomento restituisce il valore dopo aver applicato le regole precedenti. Questa è un'impostazione, non il risultato del movimento.

Comportamento

  • L'impostazione viene memorizzata nello stato di runtime e viene utilizzata dai comandi corrispondenti all'avvio; la modifica non sovrascrive automaticamente il percorso già creato.
  • La restituzione del valore originale viene mostrata per il completamento normale. Dopo un arresto anomalo, le seguenti righe di ripristino non vengono eseguite.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti, lo stato non cambia.
  • valore è il valore numerico di questa impostazione.
var value = UO.moveThroughCorner();
UO.Print(Convert.ToString(value));

2. Imposta valore esplicito - Funzione script

Parametri e flusso di esecuzione:

  • valore=0. 0 proibisce, diverso da zero diventa 1. Se entrambi i quadrati laterali sono bloccati, viene applicato moveBetweenTwoCorners.
  • applicato mostra il valore salvato, non il raggiungimento riuscito dell'obiettivo.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveThroughCorner(0);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Applicare a una sezione dello script - classe script

Parametri e flusso di esecuzione:

  • precedente memorizza l'impostazione iniziale; NewMoveXY è limitato a 3000 ms.
  • L'ultimo comando ripristina l'impostazione dopo il ritorno al movimento normale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.moveThroughCorner();
        UO.moveThroughCorner(0);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveThroughCorner(previous);
        UO.Print(Convert.ToString(ok));
        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.moveThroughCorner() — UO.moveThroughCorner()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "movethroughcorner": if (arguments.Length > 0) state.MoveThroughCorner = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveThroughCorner);

UO.moveThroughCorner(value) — UO.moveThroughCorner(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "movethroughcorner": if (arguments.Length > 0) state.MoveThroughCorner = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveThroughCorner);

UO.moveThroughNPC

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

Firme C#

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

Consentire tentativi di passaggio attraverso i personaggi.

Parametri

  • value - Nuovo valore facoltativo. Intero >=0, il negativo diventa 0; positivo consente il tentativo. Un avoidMobiles esplicito specifica il vincolo inverso per una singola chiamata.

Valore restituito

int è il valore attualmente memorizzato. Senza discussione si limita a leggere; con un argomento restituisce il valore dopo aver applicato le regole precedenti. Questa è un'impostazione, non il risultato del movimento.

Comportamento

  • L'impostazione viene memorizzata nello stato di runtime e viene utilizzata dai comandi corrispondenti all'avvio; la modifica non sovrascrive automaticamente il percorso già creato.
  • La restituzione del valore originale viene mostrata per il completamento normale. Dopo un arresto anomalo, le seguenti righe di ripristino non vengono eseguite.
  • L'impostazione predefinita è 1000. Il valore 0 salva i personaggi caricati come ostacoli; un valore >0 consente un tentativo di attraversarli. Non si tratta di una soglia di resistenza: i valori 1 e 1000 comprendono lo stesso regime. Resta in vigore il divieto di accesso al server.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti, lo stato non cambia.
  • valore è il valore numerico di questa impostazione.
var value = UO.moveThroughNPC();
UO.Print(Convert.ToString(value));

2. Imposta valore esplicito - Funzione script

Parametri e flusso di esecuzione:

  • valore=0. Intero >=0, il negativo diventa 0; positivo consente il tentativo. Un avoidMobiles esplicito specifica il vincolo inverso per una singola chiamata.
  • applicato mostra il valore salvato, non il raggiungimento riuscito dell'obiettivo.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveThroughNPC(0);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Applicare a una sezione dello script - classe script

Parametri e flusso di esecuzione:

  • precedente memorizza l'impostazione iniziale; NewMoveXY è limitato a 3000 ms.
  • L'ultimo comando ripristina l'impostazione dopo il ritorno al movimento normale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.moveThroughNPC();
        UO.moveThroughNPC(0);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveThroughNPC(previous);
        UO.Print(Convert.ToString(ok));
        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.moveThroughNPC() — UO.moveThroughNPC()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "movethroughnpc": if (arguments.Length > 0) state.MoveThroughNpc = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveThroughNpc);

UO.moveThroughNPC(value) — UO.moveThroughNPC(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "movethroughnpc": if (arguments.Length > 0) state.MoveThroughNpc = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveThroughNpc);

UO.moveTurnCost

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

Firme C#

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

Costo aggiuntivo per cambiare direzione quando si trova un percorso.

Parametri

  • value - Nuovo valore facoltativo. Intero >=0, il negativo diventa 0. Questo è il peso del percorso, non i millisecondi: un passo dritto costa 10, uno diagonale 14, e questa è un'aggiunta per turno.

Valore restituito

int è il valore attualmente memorizzato. Senza discussione si limita a leggere; con un argomento restituisce il valore dopo aver applicato le regole precedenti. Questa è un'impostazione, non il risultato del movimento.

Comportamento

  • L'impostazione viene memorizzata nello stato di runtime e viene utilizzata dai comandi corrispondenti all'avvio; la modifica non sovrascrive automaticamente il percorso già creato.
  • La restituzione del valore originale viene mostrata per il completamento normale. Dopo un arresto anomalo, le seguenti righe di ripristino non vengono eseguite.
  • In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

Esempio semplice

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

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti, lo stato non cambia.
  • valore è il valore numerico di questa impostazione.
var value = UO.moveTurnCost();
UO.Print(Convert.ToString(value));

2. Imposta valore esplicito - Funzione script

Parametri e flusso di esecuzione:

  • valore=14. Intero >=0, il negativo diventa 0. Questo è il peso del percorso, non i millisecondi: un passo dritto costa 10, uno diagonale 14, e questa è un'aggiunta per turno.
  • applicato mostra il valore salvato, non il raggiungimento riuscito dell'obiettivo.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveTurnCost(14);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Applicare a una sezione dello script - classe script

Parametri e flusso di esecuzione:

  • precedente memorizza l'impostazione iniziale; NewMoveXY è limitato a 3000 ms.
  • L'ultimo comando ripristina l'impostazione dopo il ritorno al movimento normale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.moveTurnCost();
        UO.moveTurnCost(14);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveTurnCost(previous);
        UO.Print(Convert.ToString(ok));
        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.moveTurnCost() — UO.moveTurnCost()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "moveturncost": if (arguments.Length > 0) state.MoveTurnCost = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveTurnCost);

UO.moveTurnCost(value) — UO.moveTurnCost(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "moveturncost": if (arguments.Length > 0) state.MoveTurnCost = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveTurnCost);

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally