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

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

1 · 2

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

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.

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

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.

• 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.
• UO.LimitMove controlla la distanza: 2000 per impostazione iniziale, zero senza limite. Non esistono limiti nascosti di 4096 passi/nodi o 10000 nodi. Il lavoro procede in sezioni interrompibili. GetPathArray rispetta la soglia di stamina moveThroughNPC e moveOpenDoor.
• 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.

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.

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));

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;

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;
}

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);
}

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;

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

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

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Register [NewMoveXY].
• InjectionScript.Runtime.InjectionApiUO.CompactNewMoveXY: CompactNewMoveXY(values).

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))

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

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Register [NewMoveXY].
• InjectionScript.Runtime.InjectionApiUO.CompactNewMoveXY: CompactNewMoveXY(values).

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))

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

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Register [NewMoveXY].
• InjectionScript.Runtime.InjectionApiUO.CompactNewMoveXY: CompactNewMoveXY(values).

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))

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

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Register [NewMoveXY].
• InjectionScript.Runtime.InjectionApiUO.CompactNewMoveXY: CompactNewMoveXY(values).

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))

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:

• InjectionScript.Runtime.InjectionApiUO.Register [NewMoveXY].
• InjectionScript.Runtime.InjectionApiUO.CompactNewMoveXY: CompactNewMoveXY(values).

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))

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:

• InjectionScript.Runtime.InjectionApiUO.Register [NewMoveXY].
• InjectionScript.Runtime.InjectionApiUO.CompactNewMoveXY: CompactNewMoveXY(values).

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))

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:

• InjectionScript.Runtime.InjectionApiUO.Register [NewMoveXY].
• InjectionScript.Runtime.InjectionApiUO.CompactNewMoveXY: CompactNewMoveXY(values).

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))

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:

• InjectionScript.Runtime.InjectionApiUO.Register [NewMoveXY].
• InjectionScript.Runtime.InjectionApiUO.CompactNewMoveXY: CompactNewMoveXY(values).

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))

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:

• InjectionScript.Runtime.InjectionApiUO.Register [NewMoveXY].
• InjectionScript.Runtime.InjectionApiUO.CompactNewMoveXY: CompactNewMoveXY(values).

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))

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

void UO.OpenDoor();

Richiede che la porta venga aperta per il personaggio.

Non ci sono parametri.

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

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

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.

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();

Parametri e flusso di esecuzione:

• Richiede che la porta venga aperta per il personaggio.

UO.OpenDoor();

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;

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;
    }
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

PMove attende la ricerca del percorso e il termine del movimento. XY richiede coordinate esatte; XYZ richiede anche l’altezza indicata. Restituisce void: confrontare le coordinate reali. NewMoveXY o MoveXYZ forniscono un risultato numerico. Nessun limite implicito di 30 secondi.

UO.PMove

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

int UO.PredictedDirection();

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

Non ci sono parametri.

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

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

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.

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));

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));

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;

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;
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ReadPredictedCoordinate: ReadPredictedCoordinate(3).

Codice interno di implementazione; non è uno script autonomo.

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

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

int UO.PredictedX();

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

Non ci sono parametri.

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

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

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.

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));

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));

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;

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;
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ReadPredictedCoordinate: ReadPredictedCoordinate(0).

Codice interno di implementazione; non è uno script autonomo.

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

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

int UO.PredictedY();

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

Non ci sono parametri.

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

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

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.

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));

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));

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;

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;
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ReadPredictedCoordinate: ReadPredictedCoordinate(1).

Codice interno di implementazione; non è uno script autonomo.

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

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

int UO.PredictedZ();

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

Non ci sono parametri.

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

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

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.

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));

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));

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;

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;
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ReadPredictedCoordinate: ReadPredictedCoordinate(2).

Codice interno di implementazione; non è uno script autonomo.

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

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

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.

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

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.

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

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.

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);

Parametri e flusso di esecuzione:

• Valore=100 — millisecondi. La chiamata imposta il movimento successivo, ma non avvia un percorso.

UO.SetRunMountTimer(100);

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;

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;
    }
}

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

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ClampMoveTimer: ClampMoveTimer(Arg(0), 100).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetMovementTimers: bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer).

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;

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

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.

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

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.

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

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.

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);

Parametri e flusso di esecuzione:

• Valore=200 — millisecondi. La chiamata imposta il movimento successivo, ma non avvia un percorso.

UO.SetRunUnmountTimer(200);

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;

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;
    }
}

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

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ClampMoveTimer: ClampMoveTimer(Arg(0), 200).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetMovementTimers: bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer).

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;

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

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.

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

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.

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

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.

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);

Parametri e flusso di esecuzione:

• Valore=200 — millisecondi. La chiamata imposta il movimento successivo, ma non avvia un percorso.

UO.SetWalkMountTimer(200);

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;

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;
    }
}

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

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ClampMoveTimer: ClampMoveTimer(Arg(0), 200).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetMovementTimers: bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer).

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;

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

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.

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

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.

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

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.

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);

Parametri e flusso di esecuzione:

• Valore=400 — millisecondi. La chiamata imposta il movimento successivo, ma non avvia un percorso.

UO.SetWalkUnmountTimer(400);

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;

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;
    }
}

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

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ClampMoveTimer: ClampMoveTimer(Arg(0), 400).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetMovementTimers: bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer).

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;

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

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

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

• 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à.

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.

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

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.

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));

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;

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;

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.

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;
}

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

Parametri: direction (Any), running (Any)

Risultato: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsOnline: bridge.IsOnline().
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.OpenDoor: bridge.OpenDoor().
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Step: bridge.Step(Arg(0) & 7, Arg(1) != 0).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Stamina: bridge.Stamina.

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));

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

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.

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

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.

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

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.

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));

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;

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;

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.

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;
}