Repository navigation
IT UO Topic movement
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
Home · C# · IDE · UO API · A–Z · Esempi · Lingue
Movimento dei personaggi, costruzione del percorso, porte, ostacoli e ritardi nei passi. I comandi per spostare gli oggetti si trovano in Oggetti → Moving Oggetti.
UO.Move · UO.MoveXY · UO.MoveXYZ · UO.NewMoveXY · UO.Step · UO.StepQ · UO.PMove · UO.MoveOn · UO.MoveOff · UO.MoverStop · UO.CancelMove · UO.Moving · UO.IsMoving · UO.GetRun · UO.IsRunning · UO.AlwaysRun · UO.FixWalk
UO.Dir · UO.Direction · UO.GetDir · UO.GetDirection · UO.CalcDir · UO.PredictedDirection
UO.GetPathArray · UO.GetPathArray3D · UO.AddStep · UO.AddDir
UO.OpenDoor · UO.LastStepQUsedDoor
UO.moveBetweenTwoCorners · UO.moveCheckStamina · UO.moveExitOnDisconnect · UO.moveHeuristicMult · UO.moveOpenDoor · UO.moveThroughCorner · UO.moveThroughNPC · UO.moveTurnCost
UO.PredictedX · UO.PredictedY · UO.PredictedZ
UO.GetRunMountTimer · UO.GetRunUnMountTimer · UO.GetWalkMountTimer · UO.GetWalkUnmountTimer · UO.SetRunMountTimer · UO.SetRunUnmountTimer · UO.SetWalkMountTimer · UO.SetWalkUnmountTimer
Ogni carta comando ha diversi scenari indipendenti: codice diretto, funzioni e classi. Di seguito sono selezionati brevi scenari; restrizioni e un'analisi completa sono nelle carte.
Parametri, risultato e tutti gli scenari
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, risultato e tutti gli scenari
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
var path = UO.GetPathArray3D(x, y, z, x + 4, y, z, UO.WorldNum(), 0, 0, false);
if (Truth(ArrayLength(path) > 0))
{
UO.Print("Steps: " + Convert.ToString(ArrayLength(path) - 1));
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.AddDir(object? directions);-
directionsè una stringa salvata nell'elenco legacy. Il significato e il formato del valore dipendono dallo script compatibile che lo utilizza.
void. L'iscrizione aggiunta non costituisce conferma del movimento.
- Il valore viene aggiunto all'elenco
AddDirdello stato di runtime corrente. La chiamata stessa non trasmette un pacchetto di movimento, non sposta il carattere e non dispone di un getter pubblico documentato per leggere questo elenco.
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.AddDir");
UO.AddDir("E");1. Salva la direzione come voce compatibile con la versione precedente senza spostare il personaggio. - sceneggiatura diretta
Parametri e flusso di esecuzione:
- Salva la direzione come voce compatibile con la versione precedente senza spostare il personaggio.
UO.AddDir("E");Parametri e flusso di esecuzione:
- Passa il valore dalla variabile all'elenco legacy AddDir.
return RunScenario();
object? RunScenario()
{
var directionEntry = "north-east";
UO.AddDir(directionEntry);
return null;
}3. Ogni chiamata aggiunge un'altra voce di stringa allo stato di runtime. - lezione di sceneggiatura
Parametri e flusso di esecuzione:
- Ogni chiamata aggiunge un'altra voce di stringa allo stato di runtime.
- Anche la procedura ausiliaria non invia un comando di 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()
{
AddLegacyDirection("W");
return null;
}
void AddLegacyDirection(dynamic entry)
{
UO.AddDir(entry);
}
}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: directions (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::LegacyList:LegacyList(name). -
InjectionScript.Runtime.InjectionValue.ToString:value.ToString().
Codice interno di implementazione; non è uno script autonomo.
case "adddir":
case "addfindlist":
case "addgate":
case "addrecall":
case "addstep":
LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));
break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.AddStep(object? directions);-
directionsè il valore che il runtime converte in testo e aggiunge all'elenco di compatibilitàAddStep. La direzione in sé non è interpretabile.
void. La chiamata non restituisce un valore e non conferma lo spostamento.
- Ogni chiamata aggiunge una rappresentazione di stringa dell'argomento all'elenco
AddStepdello stato di runtime corrente. Questa voce legacy non invia un comando di movimento e non dispone di un getter pubblico nell'implementazione corrente.
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.AddStep");
UO.AddStep(2);Parametri e flusso di esecuzione:
- Scrivere il valore nell'elenco legacy; il personaggio non si muove.
UO.AddStep(2);2. Passa valore di testo: viene memorizzato come record anziché eseguito come direzione. - funzione di script
Parametri e flusso di esecuzione:
- Passa valore di testo: viene memorizzato come record anziché eseguito come direzione.
return RunScenario();
object? RunScenario()
{
var legacyValue = "east";
UO.AddStep(legacyValue);
return null;
}3. Ogni chiamata aggiunge una voce separata a AddStep del runtime corrente. - lezione di sceneggiatura
Parametri e flusso di esecuzione:
- Ogni chiamata aggiunge una voce separata a AddStep del runtime corrente.
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.AddStep(1);
UO.AddStep(2);
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: directions (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::LegacyList:LegacyList(name). -
InjectionScript.Runtime.InjectionValue.ToString:value.ToString().
Codice interno di implementazione; non è uno script autonomo.
case "adddir":
case "addfindlist":
case "addgate":
case "addrecall":
case "addstep":
LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));
break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.AlwaysRun();
void UO.AlwaysRun(object? enabled);Legge o modifica l'impostazione di funzionamento costante dell'attuale profilo ClassicUO.
-
enabled-0disabilita il funzionamento costante; qualsiasi valore diverso da zero lo attiva.
La forma senza argomenti restituisce 1 se l'impostazione è abilitata, 0 altrimenti. La forma dell'argomento restituisce null.
- Il valore viene letto dal profilo corrente. L'impostazione cambia
AlwaysRune salva il profilo corrente. Senza un profilo attivo, il getter restituisce0e il setter segnala un errore nel registro del client e non modifica l'impostazione.
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.AlwaysRun();
UO.Print("AlwaysRun: " + Convert.ToString(result));1. Leggi l'impostazione; 1 significa che il funzionamento costante è abilitato. - sceneggiatura diretta
Parametri e flusso di esecuzione:
- Leggi l'impostazione; 1 significa che il funzionamento costante è abilitato.
var isAlwaysRunning = UO.AlwaysRun();
UO.Print(Convert.ToString(isAlwaysRunning));Parametri e flusso di esecuzione:
- Abilita la corsa costante e salva le impostazioni del profilo corrente.
return RunScenario();
object? RunScenario()
{
UO.AlwaysRun(1);
return null;
}Parametri e flusso di esecuzione:
- Disabilita l'esecuzione costante solo se è attualmente abilitata.
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(UO.AlwaysRun() != 0))
{
UO.AlwaysRun(0);
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}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.AlwaysRun. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.AlwaysRun:bridge.AlwaysRun().
Codice interno di implementazione; non è uno script autonomo.
public int AlwaysRun() => bridge.AlwaysRun();Parametri: enabled (Integer)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.AlwaysRun. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.AlwaysRun:bridge.AlwaysRun(enabled).
Codice interno di implementazione; non è uno script autonomo.
public void AlwaysRun(int enabled) => bridge.AlwaysRun(enabled);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.CalcDir(object? xfrom, object? yfrom, object? xto, object? yto);Calcola la direzione da un punto del mondo a un altro. Il personaggio non si muove.
-
xfrom— Coordinata X del punto iniziale. -
yfrom— Coordinata Y del punto iniziale. -
xto— La coordinata di assegnazione X. -
yto— La coordinata di assegnazione Y.
int — codice direzione: 0=nord, 1=nordest, 2=est, 3=sudest, 4=sud, 5=sudovest, 6=ovest, 7=nordovest. I punti corrispondenti danno 100. Questo non è un bool: 0 significa nord, non fallimento; 1 significa nord-est, non successo. Non passare 100 al comando passo come direzione.
- Calcola solo le coordinate: nessun batch, nessuna attesa, nessun caricamento della mappa, nessun controllo degli ostacoli, nessuna Z, nessuna mappa del mondo. La squadra non cerca un percorso percorribile e non garantisce il raggiungimento dell'obiettivo. I punti devono appartenere allo stesso sistema di coordinate; evitare gli ostacoli può allungare il percorso.
- Sono necessari tutti e quattro i parametri. Invia le coordinate mondiali int nell'intervallo documentato 0..65535. object? nella firma indica un adattatore universale, non il ID dell'articolo. Questi comandi non hanno valori predefiniti, coordinate all'interno del baule, quinto Z e sovraccarico con un oggetto.
- Si sottraggono le coordinate originali a quelle di destinazione, quindi si controllano i segni delle differenze. Y decrescente è il nord, X crescente è l'est. Se cambiano entrambe le coordinate, la diagonale viene scelta indipendentemente dall'entità delle differenze. Se entrambe le differenze sono zero - 100.
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.CalcDir(100, 100, 101, 100);
UO.Print("CalcDir: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Origine (100,100), destinazione (101,100): X aumenta, Y non cambia. Ritorni principali int 2 - est. Il comando di spostamento non viene chiamato.
- int — codice direzione: 0=nord, 1=nordest, 2=est, 3=sudest, 4=sud, 5=sudovest, 6=ovest, 7=nordovest. I punti corrispondenti danno 100. Questo non è un bool: 0 significa nord, non fallimento; 1 significa nord-est, non successo. Non passare 100 al comando passo come direzione.
- Si sottraggono le coordinate originali a quelle di destinazione, quindi si controllano i segni delle differenze. Y decrescente è il nord, X crescente è l'est. Se cambiano entrambe le coordinate, la diagonale viene scelta indipendentemente dall'entità delle differenze. Se entrambe le differenze sono zero - 100.
return UO.CalcDir(100,100,101,100);Parametri e flusso di esecuzione:
- Entrambi i punti sono uguali (100,100). direzione=100 significa una corrispondenza, quindi Main restituisce string "già lì". In punti diversi, funzionerà un altro ramo. Viene selezionato 100, non true.
- int — codice direzione: 0=nord, 1=nordest, 2=est, 3=sudest, 4=sud, 5=sudovest, 6=ovest, 7=nordovest. I punti corrispondenti danno 100. Questo non è un bool: 0 significa nord, non fallimento; 1 significa nord-est, non successo. Non passare 100 al comando passo come direzione.
- Si sottraggono le coordinate originali a quelle di destinazione, quindi si controllano i segni delle differenze. Y decrescente è il nord, X crescente è l'est. Se cambiano entrambe le coordinate, la diagonale viene scelta indipendentemente dall'entità delle differenze. Se entrambe le differenze sono zero - 100.
return RunScenario();
object? RunScenario()
{
var direction = UO.CalcDir(100, 100, 100, 100);
if (Truth(direction == 100))
{
return "already there";
}
return "different point";
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:
- Passando da (20,20) a (19,21), X diminuisce, Y aumenta: UO.CalcDir restituisce 5. RebuildDirection mostra tutti i rami di questo algoritmo e fornisce anche 5. Ritorni principali "5:5". Tutti e quattro i parametri dell'assistente hanno lo stesso significato di coordinate.
- int — codice direzione: 0=nord, 1=nordest, 2=est, 3=sudest, 4=sud, 5=sudovest, 6=ovest, 7=nordovest. I punti corrispondenti danno 100. Questo non è un bool: 0 significa nord, non fallimento; 1 significa nord-est, non successo. Non passare 100 al comando passo come direzione.
- Si sottraggono le coordinate originali a quelle di destinazione, quindi si controllano i segni delle differenze. Y decrescente è il nord, X crescente è l'est. Se cambiano entrambe le coordinate, la diagonale viene scelta indipendentemente dall'entità delle differenze. Se entrambe le differenze sono zero - 100.
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 actual = UO.CalcDir(20, 20, 19, 21);
var rebuilt = RebuildDirection(20, 20, 19, 21);
return Convert.ToString(actual) + ":" + Convert.ToString(rebuilt);
return null;
}
dynamic RebuildDirection(dynamic Xfrom, dynamic Yfrom, dynamic Xto, dynamic Yto)
{
var dx = Xto - Xfrom;
var dy = Yto - Yfrom;
if (Truth(dx == 0) && Truth(dy == 0))
{
return 100;
}
if (Truth(dx == 0))
{
if (Truth(dy < 0))
{
return 0;
}
return 4;
}
if (Truth(dy == 0))
{
if (Truth(dx > 0))
{
return 2;
}
return 6;
}
if (Truth(dx > 0))
{
if (Truth(dy < 0))
{
return 1;
}
return 3;
}
if (Truth(dy > 0))
{
return 5;
}
return 7;
}
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: xfrom (Any), yfrom (Any), xto (Any), yto (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.CalculateDirection:CalculateDirection(Arg(0), Arg(1), Arg(2), Arg(3)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "calcdir": return new InjectionValue(CalculateDirection(Arg(0), Arg(1), Arg(2), Arg(3)));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.CancelMove();Disabilita consentendo ulteriori movimenti da parte dello script tramite MoveOff.
Non ci sono parametri.
void: nessun valore restituito.
- Chiama MoveOff, che mette il runtime/manager nello stato MoveEnabled=false. Per abilitare nuovamente il movimento, è necessario MoveOn. Il comando non esegue il rollback dei passaggi già inviati.
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.CancelMove");
UO.CancelMove();Parametri e flusso di esecuzione:
- I seguenti comandi di movimento rispettano la risoluzione disattivata.
UO.CancelMove();Parametri e flusso di esecuzione:
- MoveOn ripristina esplicitamente la risoluzione.
return RunScenario();
object? RunScenario()
{
UO.CancelMove();
UO.MoveOn();
return null;
}Parametri e flusso di esecuzione:
- Una connessione disconnessa viene utilizzata come condizione per impedire i passaggi successivi.
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(UO.Connected())))
{
UO.CancelMove();
}
return null;
}
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: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
InjectionScript.Runtime.InjectionApiUO.MoveOff:MoveOff().
Codice interno di implementazione; non è uno script autonomo.
case "cancelmove": MoveOff(); break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Dir();Legge la direzione del carattere dal modello client.
Non ci sono parametri.
int — direzione mobile senza bit di corsa: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Per sconosciuto, mobile restituisce 0, che significa anche nord.
- I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
- C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
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.Dir();
UO.Print("Dir: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti si riferisce a self. La direzione del personaggio viene memorizzata in valore.
- Convert.ToString converte il numero da emettere e non cambia il significato del risultato.
var value = UO.Dir();
UO.Print("Dir: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Il valore viene letto una volta senza argomenti. La direzione del carattere viene utilizzata nel calcolo o nella condizione mostrata.
- Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.
return RunScenario();
object? RunScenario()
{
var value = UO.Dir();
if (Truth(value == 2))
{
UO.Print("Facing east");
}
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:
- Entrambe le chiamate senza argomento leggono il loro valore corrente. UO.Wait(1000) dà una pausa in millisecondi tra gli scatti.
- Cambiamento rispetto: direzione del personaggio. Un esempio non cambia nulla al mondo e non aspetta all'infinito. Gli eventi entro questo secondo potrebbero essere persi.
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 before = UO.Dir();
await Delay(1000);
var after = UO.Dir();
if (Truth(before != after))
{
UO.Print("Before: " + Convert.ToString(before) + "; after: " + 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;
}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.RegisterCharacterGetterAliases [Dir]. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
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.
() => bridge.GetDir(bridge.Self)Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Direction();Legge la direzione del carattere dal modello client.
Non ci sono parametri.
int — direzione mobile senza bit di corsa: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Per sconosciuto, mobile restituisce 0, che significa anche nord.
- I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
- C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
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.Direction();
UO.Print("Direction: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti si riferisce a self. La direzione del personaggio viene memorizzata in valore.
- Convert.ToString converte il numero da emettere e non cambia il significato del risultato.
var value = UO.Direction();
UO.Print("Direction: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Il valore viene letto una volta senza argomenti. La direzione del carattere viene utilizzata nel calcolo o nella condizione mostrata.
- Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.
return RunScenario();
object? RunScenario()
{
var value = UO.Direction();
if (Truth(value == 2))
{
UO.Print("Facing east");
}
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:
- Entrambe le chiamate senza argomento leggono il loro valore corrente. UO.Wait(1000) dà una pausa in millisecondi tra gli scatti.
- Cambiamento rispetto: direzione del personaggio. Un esempio non cambia nulla al mondo e non aspetta all'infinito. Gli eventi entro questo secondo potrebbero essere persi.
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 before = UO.Direction();
await Delay(1000);
var after = UO.Direction();
if (Truth(before != after))
{
UO.Print("Before: " + Convert.ToString(before) + "; after: " + 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;
}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.RegisterCharacterGetterAliases [Direction]. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
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.
() => bridge.GetDir(bridge.Self)Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.FixWalk();Stampa un avviso che la patch del client nativo legacy FixWalk non è richiesta da ClassicUO.
Non ci sono parametri.
void: nessun valore restituito.
- Il ramo ExecuteLegacyManualAlias chiama solo SystemMessage. Non corregge il movimento, la voce, i contenitori o il protocollo di rete.
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.FixWalk");
UO.FixWalk();Parametri e flusso di esecuzione:
- Il messaggio descrive la mancata necessità della vecchia patch.
UO.FixWalk();Parametri e flusso di esecuzione:
- La procedura di compatibilità non modifica il mondo di gioco.
return RunScenario();
object? RunScenario()
{
CompatibilityNotice();
return null;
}
void CompatibilityNotice()
{
UO.FixWalk();
}Parametri e flusso di esecuzione:
- Dopo il messaggio diagnostico, l'esecuzione continua.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
UO.FixWalk();
UO.Print("continued");
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. -
InjectionScript.Runtime.InjectionApiUO.SystemMessage:SystemMessage($"{name}: obsolete native-client patch; ClassicUO does not require it.").
Codice interno di implementazione; non è uno script autonomo.
case "boxhack":
case "fixtalk":
case "fixwalk":
SystemMessage($"{name}: obsolete native-client patch; ClassicUO does not require it.");
break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Follow();
int UO.Follow(object? target);
int UO.Follow(object? target, object? distance);
int UO.Follow(object? target, object? distance, object? running);
int UO.Follow(object? target, object? distance, object? running, object? stopConditions);
int UO.Follow(object? x, object? y, object? z, object? distance, object? running);
int UO.Follow(object? x, object? y, object? z, object? distance, object? running, object? stopConditions);Abilita il tracciamento in background del carattere caricato/NPC o il movimento verso i punti X, Y, Z. Durante il movimento, il client controlla le condizioni di arresto trasmesse; lo script continua l'esecuzione immediatamente dopo la chiamata.
-
target— Carattere seriale/NPC: int, stringa esadecimale/decimale, lasttarget o nome precedentemente salvato tramite AddObject. Queste non sono graphic/type o coordinate. Non puoi seguire te stesso o un oggetto. 0 smette di seguire. Senza argomenti, anche Follow() lo ferma; la vista non appare. -
distance— Tolleranza X/Y nelle celle: massima |dx| e |dy|. Per il carattere int 1..18, default 1; La differenza Z fino a 16 è accettabile. Per il punto int 0..18, l'argomento è obbligatorio: 0 richiede X/Y esatti, 2 consente di fermarsi entro due celle; Z deve corrispondere esattamente. Un valore non valido non sostituisce il comportamento precedente. -
running- Valore compatibile con bool: true/1 - corsa, false/0 - camminata; l'impostazione predefinita è true. Rimangono i limiti di velocità del server, resistenza, paralisi e ostacoli. Il flag non accelera i passaggi del server. -
stopConditions— Matrice opzionale di condizioni di arresto: quarto argomento per carattere, sesto per coordinate. Ogni elemento è un array di esattamente tre valori [campo, confronto, soglia]. campo e confronto sono stringhe, la soglia è int/double; true/false (1/0) sono adatti per i flag. L'attivazione di QUALSIASI condizione viene terminata da Follow (OR). Un array vuoto non aggiunge condizioni. Il numero di elementi non è limitato agli elementi fissi 3/5/10, ma è limitato dalla memoria; Gli elenchi di grandi dimensioni vengono controllati in blocchi. I campi e le unità consentiti sono elencati di seguito; un campo sconosciuto, un operatore o un modulo di matrice non valido provoca un errore prima che il precedente Follow venga sostituito. -
x- Solo moduli con argomenti 5/6: coordinate del mondo intero sulla mappa corrente, 0..65535 e all'interno dei confini della mappa caricata. Queste non sono coordinate window/gump o serial. Non è previsto alcun trasferimento su un'altra carta. -
y- Solo moduli con argomenti 5/6: coordinate del mondo intero sulla mappa corrente, 0..65535 e all'interno dei confini della mappa caricata. Queste non sono coordinate window/gump o serial. Non è previsto alcun trasferimento su un'altra carta. -
z— Solo forme con argomenti 5/6: altezza del mondo intero -128..127. Questa altezza è necessaria per il completamento, quindi specificare la Z della superficie disponibile del pavimento desiderato. Non ci sono valori "qualsiasi Z" separati o selezione automatica dell'altezza.
int 1 (true) — la modalità seguente è stata accettata dal client o è stata completata una richiesta di arresto; int 0 (false) - non è stato caricato alcun personaggio adatto, il giocatore non è disponibile/morto, il bersaglio non è visibile, la distanza non è corretta o il client non supporta la squadra. Questo non è il risultato dell'arrivo, né serial, né il numero di passi. In C# utilizzare if (risultato != 0) o if (risultato == 1); il risultato è di tipo int, non bool. Errori di tipo/nome oggetto sconosciuto possono causare un errore di script. Per le coordinate, 0 significa anche X/Y/Z non valido o tolleranza. 1 significa accettare solo l'attività in background; l'arrivo e la futura occupazione devono ancora essere confermati.
- Esattamente una modalità Follow per cliente: carattere o coordinate. Una chiamata riuscita sostituisce nuovamente la destinazione e i parametri. Una sfida fallita non annulla il goal precedente. Per seguire un personaggio, questi deve essere già nella lista dei Mobiles caricati entro ClientViewRange; il punto delle coordinate potrebbe essere più lontano dalla vista.
- Quando si raggiunge una certa distanza dal personaggio, la camminata si interrompe, ma la modalità rimane attiva e riprende il movimento quando il bersaglio si allontana. Vicino al punto fiduciale, l'attività viene completata se vengono soddisfatte la tolleranza X/Y e la Z esatta. Il comando non segnala una raggiungibilità garantita del percorso una volta lanciato.
- Follow(), Follow(0), MoverStop(), il movimento manuale del mouse/freccia, un nuovo percorso di script o il seguito del client standard interromperanno questa modalità. Anche TerminateAll/Terminate("all") lo ferma. L'annullamento di uno script proprietario ancora in esecuzione lo interrompe Follow.
- Entrambe le modalità terminano quando la mappa o il personaggio cambiano, il giocatore muore o la connessione viene interrotta. Inoltre, seguire il personaggio si interrompe quando il bersaglio scompare dalla memoria/visualizzazione. La comparsa successiva di un bersaglio non attiva automaticamente la modalità: è necessario un nuovo Follow.
- La chiusura di IDE non interrompe la modalità. La terminazione normale di uno script in esecuzione lascia Follow abilitato. Una pausa dello script non è di per sé una pausa per quella modalità client; prima della pausa, usa Follow(0) quando il movimento deve fermarsi.
- Pathfinder calcola il percorso in blocchi nel flusso di gioco; una ricerca incompleta non viene riavviata. Per mobile il normale aggiornamento del percorso è limitato a 500 ms. Dopo un guasto o la conclusione di una rotta senza avvicinamento, i primi tre ritardi tra tentativi sono 1000 ms, quindi 2000, 4000 e un massimo di 5000 ms. Il contatore dei rimbalzi viene azzerato quando cambia il giocatore X/Y/Z o il bersaglio; la modifica del target può ridurre l'attesa fino a 500 ms. Non esiste un limite generale al numero di ripetizioni per un target mobile disponibile: la modalità può rimanere attiva senza spostarsi, quindi impostarla su trascorso o interromperla esplicitamente. L'attività di coordinate termina quando il percorso fallisce completamente.
- Campi distanza/tempo: distanza: distanza corrente dal bersaglio nelle celle max(abs(dx),abs(dy)); altezza - differenza assoluta Z in unità mondiali; trascorsi - millisecondi da quando questo Follow è stato accettato. distanza > 12 si ferma quando ci si sposta oltre 12 celle, trascorse >= 30000 - dopo 30 secondi. Un Follow ripetuto con successo riavvia nuovamente il conto alla rovescia.
- Lo stato del tuo personaggio: self.hp / self.mana / self.stam - valori attuali; self.hppercent / self.manapercent / self.stampercent - percentuali 0..100 dal massimo corrispondente. Massimo sconosciuto (<=0) significa valore sconosciuto: la condizione per questa caratteristica non viene attivata, piuttosto che ricevere il 0 fittizio.
- Campi logici per il tuo personaggio: self.poisoned (avvelenato), self.paralyzed (paralizzato), self.hidden (nascosto). Valori 1/0. Nell'array delle condizioni Follow, la regola per il campo "self.paralyzed" con l'operatore "=" e il valore true smette di seguire quando è paralizzato. Questo è il nome stringa del campo regola, non la variabile C# self.
- Campi obiettivo: target.dead - morto mobile, target.hidden - nascosto, target.visible - visibile al client (non CheckLOS), target.hp / target.hppercent - caricato HP/percent. Se HP max non è noto, la condizione HP fallisce. Il server può inviare la scala relativa HP del carattere di qualcun altro, quindi hppercent è più conveniente per questo.
- Campi target aggiuntivi: target.notorietà - status 0..7 (0 sconosciuto, 1 Innocente, 2 Alleato, 3 Grigio, 4 Criminale, 5 Nemico, 6 Assassino, 7 Invulnerabile); bersaglio.body — numerico graphic del corpo. Questi non sono vestiti type. Ad esempio target.notoriety != 2 interrompe il tracciamento quando viene perso lo stato di Alleato.
- Una copia delle condizioni viene acquisita quando viene richiamata, comprese le soglie numeriche. La modifica dell'array/variabile di origine non aggiorna la modalità; ripeti Follow con il nuovo array. La modalità annullata non riprende automaticamente quando la condizione non è più soddisfatta.
- Le condizioni vengono controllate sia durante il movimento che quando il personaggio è già vicino al bersaglio. Un elenco regolare di un massimo di 64 elementi viene controllato in un frame di gioco, il controllo successivo non avviene prima di 250 ms. Un elenco più ampio: 64 elementi per fotogramma, quindi una pausa 250 ms. Il campo trascorso potrebbe fermarsi oltre la soglia per la durata del controllo/frame: non è un timer preciso.
- Finché non viene completato il primo controllo dell'intero elenco, non inizia un nuovo percorso. Se la condizione è già soddisfatta, Follow restituirà 1 per la richiesta accettata, quindi si fermerà all'aggiornamento senza il primo passaggio. Potrebbero essere già stati inviati pacchetti di passi del movimento precedente.
- Le nuove condizioni non disabilitano i motivi di stop obbligatori: perdita di bersaglio/giocatore/carta/link, morte del giocatore, cancellazione del proprietario, Terminate tutto e movimento manuale/altro. Il codice dello script non viene eseguito nel thread del gioco; Vengono controllati solo i valori locali elencati.
- Forme di coordinate: Follow(x,y,z,distanza,corsa) e Follow(x,y,z,distanza,corsa,stopConditions). I primi cinque argomenti sono obbligatori. Follow(x,y,z) non è una scorciatoia per le coordinate: i tre argomenti significano comunque target,distanza,corsa.
- In modalità coordinate, la distanza nella condizione indica la distanza X/Y rimanente dal punto, l'altezza è la differenza assoluta dalla sua Z; trascorso e tutti i self.* funzionano come al solito. I campi target.* non sono validi: il punto non ha HP, corpo o stato. Il tentativo di passarli provoca un errore di script finché la vecchia modalità non viene sostituita.
- Le condizioni vengono controllate prima del primo percorso, durante il suo calcolo e mentre il personaggio si muove. L'attivazione di qualsiasi condizione rimuove l'attività e cancella il percorso ad essa appartenente. La frequenza e l'elaborazione di elenchi di grandi dimensioni sono le stesse che seguono un carattere; i passaggi già inviati al server potrebbero essere completati.
- L'attività di coordinate termina quando viene raggiunto il punto oppure la ricerca e il movimento falliscono/terminano senza raggiungerlo. Non vengono attivati tentativi infiniti fino a un punto irraggiungibile. I normali ricalcoli interni di Pathfinder per gli ostacoli vengono mantenuti. Una volta completata, l'abbandono della posizione non riprende l'attività.
- Se Pathfinder ha già inviato gli ultimi passaggi e completato il percorso, ma tali passaggi sono ancora in esecuzione/in attesa di conferma, l'attività continua a verificare le condizioni. La coda dei passaggi inviati in sé non viene cancellata: deve essere elaborata dal normale meccanismo di spostamento e conferma del server.
- La lista può essere assemblata tramite List.Add a DO ... fine del ciclo o FOR e poi passata una volta a checks.ToArray() come ultimo argomento della forma appropriata. Non è necessario richiamare nuovamente Follow ad ogni iterazione: questo sostituisce la modalità e azzera il tempo trascorso. Il numero di righe non è limitato a un numero limitato, ma l'insieme di campi supportati è limitato ai campi elencati sopra.
- After 2000 ms without changing X/Y/Z player mobile-Follow can re-request a path to a stationary target. Il controllo viene eseguito solo quando si verifica la scadenza successiva, al di fuori della ricerca, dopo il rilascio di Player.Steps e della coda Walker e quando è consentito il passaggio successivo. There is no cost to moving at a slow pace and waiting for confirmations; I passaggi inviati non vengono cancellati. La coordinata Follow non lancia tale ripetizione infinita esterna: il ripristino del suo percorso è gestito dal Pathfinder limitato.
- 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 controller confronta il numero della propria richiesta di movimento, non il fatto AutoWalking: la fine naturale del percorso non è considerata un comando estraneo. StopOwnedPath trasferisce il numero memorizzato a StopAutoWalkIfRequestGeneration. La nuova richiesta esterna termina la vecchia Follow; fermarlo non cancella il nuovo percorso di qualcun altro.
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.Follow();
UO.Print("Follow: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- leader — serial dell'ultimo bersaglio. L'unità conferma l'accettazione del regime, non l'arrivo. Dopo la fine del metodo, la modalità continua a funzionare fino all'arresto/perdita del bersaglio.
var leader = UO.GetSerial("lasttarget");
var accepted = UO.Follow(leader);
if (Truth(Truth(accepted) == true))
{
UO.Print("Following is enabled; script continues");
}
else
{
UO.Print("Select a loaded nearby character");
}
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:
- UO.Wait viene misurato in millisecondi. Follow(0) disattiva la modalità follow generale; i successivi movimenti del bersaglio non causano più movimento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var leader = UO.GetSerial("lasttarget");
if (Truth(UO.Follow(leader, 3, false) == 1))
{
await Delay(10000);
UO.Follow(0);
UO.Print("Following stopped");
}
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:
- distanza=2, corsa=true; aspettative massime di 20 oltre 500 ms. Exists verifica la presenza di un oggetto, ma non la raggiungibilità del percorso.
finallyinterrompe la modalità durante l'uscita/errore normale; La cancellazione di emergenza del proprietario viene inoltre gestita dal cliente.
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 leader = UO.GetSerial("leader");
if (Truth(UO.Follow(leader, 2, true) == 0))
{
UO.Print("Cannot start following");
return null;
}
try
{
var attempts = 0;
while (Truth(attempts < 20) && Truth(UO.Exists(leader)))
{
await Delay(500);
attempts = attempts + 1;
}
}
finally
{
UO.Follow();
}
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:
- Arresto per QUALSIASI condizione: il bersaglio è più lontano di 12 celle O il nostro HP non sono trascorsi più di 40% O 30 secondi. Questo non è AND. StopWhen è fornito per intero, può essere incluso in Include. Uno significa accettazione, non arrivo.
var leader = UO.GetSerial("lasttarget");
dynamic[] conditions = new dynamic[checked((int)(2) + 1)];
conditions[0] = StopWhen("distance", ">", 12);
conditions[1] = StopWhen("self.hppercent", "<=", 40);
conditions[2] = StopWhen("elapsed", ">=", 30000);
var accepted = UO.Follow(leader, 2, true, conditions);
if (Truth(accepted == 0))
{
UO.Print("Cannot follow this target");
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}
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:
- Ci fermiamo se il bersaglio è scomparso/morto/non è più alleato, non è rimasta più di 5 resistenza o se la differenza in Z ha superato 16. false significa camminare. ToArray passa un elenco di righe di condizione; la dimensione non è specificata in anticipo. Se il bersaglio non è più un alleato, il movimento non inizierà.
return RunScenario();
object? RunScenario()
{
var checks = new List<object?>();
checks.Add(StopWhen("target.hidden", "=", true));
checks.Add(StopWhen("target.dead", "=", true));
checks.Add(StopWhen("target.notoriety", "<>", 2));
checks.Add(StopWhen("self.stam", "<=", 5));
checks.Add(StopWhen("height", ">", 16));
var leader = UO.GetSerial("lasttarget");
var conditions = checks.ToArray();
UO.Follow(leader, 2, false, conditions);
return null;
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}Parametri e flusso di esecuzione:
- Distanza mantenuta 1, condizione di arresto <=3; controllando ogni 250 ms potresti notare un risultato ritardato. Timeout 15000 ms non consente il tracciamento indefinitamente. Restituire Follow significa comunque accettare, non raggiungere i tre quadrati.
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()
{
dynamic[] conditions = new dynamic[checked((int)(1) + 1)];
conditions[0] = StopWhen("distance", "<=", 3);
conditions[1] = StopWhen("elapsed", ">=", 15000);
UO.Follow(UO.GetSerial("lasttarget"), 1, true, conditions);
return null;
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}
}Parametri e flusso di esecuzione:
- mentre raccoglie una condizione separata per ciascun elemento status. Fermati allo stato 5 OR 6, possiedi HP <=40% OR dopo 30000 ms. Gli stati vuoti salteranno il ciclo, ma rimarranno le due condizioni successive. Aggiungi nuove righe fino a Follow; una successiva modifica alla Lista non modifica la copia già installata. Per i controlli dei precedenti, non è necessario ripetere il corpo del ciclo.
var statuses = new List<object?>();
statuses.Add(5);
statuses.Add(6);
var checks = new List<object?>();
var index = 0;
while (index < statuses.Count)
{
checks.Add(StopWhen("target.notoriety", "=", statuses[index]));
index += 1;
}
checks.Add(StopWhen("self.hppercent", "<=", 40));
checks.Add(StopWhen("elapsed", ">=", 30000));
var accepted = UO.Follow(UO.GetSerial("lasttarget"), 2, true, checks.ToArray());
if (Truth(accepted == 0))
{
UO.Print("Select a loaded nearby character");
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;8. Proprie espressioni alla fine del ciclo UNTIL e una fermata obbligatoria a Finalmente - funzione dello script
Parametri e flusso di esecuzione:
- StopEscort(leader, startedAt) restituisce bool compatibile 1/0: bersaglio oltre 12 celle O proprio HP <=30 O 30 secondi sono trascorsi. Aggiungi || (un'altra_condizione); Per una combinazione obbligatoria di due controlli, utilizzare (condizioneA && condizioneB). Sconosciuto HP può essere letto come 0; l'esempio quindi si rifiuta di iniziare. Mentre lo script è in esecuzione, controlla le espressioni circa ogni 250 ms; sospendere lo script sospende questi controlli. Infine invia un arresto in caso di uscita/errore normale; La cancellazione del proprietario viene inoltre tracciata dal cliente. Se il target è scomparso e il client si è già fermato Follow, questo ciclo terminerà alle sue condizioni, non oltre il controllo del timeout. Per lavorare dopo la fine del metodo, utilizzare il quarto argomento, come negli esempi precedenti.
return RunScenario();
object? RunScenario()
{
var leader = UO.GetSerial("lasttarget");
var startedAt = Now();
if (Truth(leader == "0x00000000") || Truth(StopEscort(leader, startedAt)))
{
return null;
}
if (Truth(UO.Follow(leader, 2, true) == 0))
{
return null;
}
try
{
do
{
UO.Wait(250);
}
while (!StopEscort(leader, startedAt));
}
finally
{
UO.Follow(0);
}
return null;
}
dynamic StopEscort(dynamic leader, dynamic startedAt)
{
return (UO.GetDistance(leader) > 12) || (UO.GetHP("self") <= 30) || (Now() - startedAt >= 30000);
}
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:
- Cinque argomenti: X=1445, Y=1690, Z=0, tolleranza X/Y=0, esegui. Il reso 1 significa accettazione, non arrivo già completato. Una volta lì, l'attività si spegnerà completamente. Per interrompere manualmente in anticipo, chiamare UO.Follow(0).
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var accepted = UO.Follow(1445, 1690, 0, 0, true);
if (Truth(accepted == 0))
{
UO.Print("Coordinate task was not accepted");
}
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:
- A HP <=40%, paralisi, o dopo 30 secondi, il client interrompe il suo percorso attuale. Altrimenti, l'attività terminerà entro due celle X/Y di (1445,1690), rigorosamente a Z=0. I controlli continuano sia durante la ricerca del percorso che durante lo spostamento; Questo non è un controllo una tantum prima dell'inizio. target.* non si applica qui.
var checks = new List<object?>();
checks.Add(StopWhen("self.hppercent", "<=", 40));
checks.Add(StopWhen("self.paralyzed", "=", true));
checks.Add(StopWhen("elapsed", ">=", 30000));
UO.Follow(1445, 1690, 0, 2, true, checks.ToArray());
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}Parametri e flusso di esecuzione:
- distance=0 nella chiamata specifica un arrivo esatto, ma la condizione distance<=3 termina l'attività prima, quando il controllo successivo rileva tale distanza. false significa camminare. Anche la differenza Z>16 o 20000 ms interrompe l'attività. La direzione non garantisce la percorribilità; sostituire l'offset con il punto del percorso.
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 RunScenario();
object? RunScenario()
{
var checks = new List<object?>();
checks.Add(StopWhen("distance", "<=", 3));
checks.Add(StopWhen("height", ">", 16));
checks.Add(StopWhen("elapsed", ">=", 20000));
var x = UO.GetX("self") + 10;
var y = UO.GetY("self");
var z = UO.GetZ("self");
UO.Follow(x, y, z, 0, false, checks.ToArray());
return null;
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}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.Register [Follow]. -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]).
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(bridge is IApiFollowBridge follow
? follow.Follow(count == 0 ? 0 : GetObject(values[0]),
count < 2 ? 1 : NumberConversions.ToInt(values[1]),
count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)Parametri: target (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]).
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(bridge is IApiFollowBridge follow
? follow.Follow(count == 0 ? 0 : GetObject(values[0]),
count < 2 ? 1 : NumberConversions.ToInt(values[1]),
count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)Parametri: target (Any), distance (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]).
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(bridge is IApiFollowBridge follow
? follow.Follow(count == 0 ? 0 : GetObject(values[0]),
count < 2 ? 1 : NumberConversions.ToInt(values[1]),
count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)Parametri: target (Any), distance (Any), running (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]).
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(bridge is IApiFollowBridge follow
? follow.Follow(count == 0 ? 0 : GetObject(values[0]),
count < 2 ? 1 : NumberConversions.ToInt(values[1]),
count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)Parametri: target (Any), distance (Any), running (Any), stopConditions (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.FollowStopCondition.Parse:FollowStopCondition.Parse(values[3]). -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]). -
InjectionScript.Runtime.InjectionApiUO.ToBoolean:ToBoolean(values[2]).
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 =>
{
FollowStopCondition[] conditions = FollowStopCondition.Parse(values[3]);
return new InjectionValue(bridge is IApiConditionalFollowBridge follow
? follow.Follow(GetObject(values[0]), NumberConversions.ToInt(values[1]), ToBoolean(values[2]), conditions) : 0);
}Parametri: x (Any), y (Any), z (Any), distance (Any), running (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.FollowStopCondition.Parse:FollowStopCondition.Parse(values[5], coordinateGoal: true). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[0]). -
InjectionScript.Runtime.InjectionApiUO.ToBoolean:ToBoolean(values[4]).
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 =>
{
FollowStopCondition[] conditions = count == 6
? FollowStopCondition.Parse(values[5], coordinateGoal: true) : Array.Empty<FollowStopCondition>();
return new InjectionValue(bridge is IApiCoordinateFollowBridge follow
? follow.FollowPoint(NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]),
NumberConversions.ToInt(values[2]), NumberConversions.ToInt(values[3]), ToBoolean(values[4]), conditions) : 0);
}Parametri: x (Any), y (Any), z (Any), distance (Any), running (Any), stopConditions (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.FollowStopCondition.Parse:FollowStopCondition.Parse(values[5], coordinateGoal: true). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[0]). -
InjectionScript.Runtime.InjectionApiUO.ToBoolean:ToBoolean(values[4]).
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 =>
{
FollowStopCondition[] conditions = count == 6
? FollowStopCondition.Parse(values[5], coordinateGoal: true) : Array.Empty<FollowStopCondition>();
return new InjectionValue(bridge is IApiCoordinateFollowBridge follow
? follow.FollowPoint(NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]),
NumberConversions.ToInt(values[2]), NumberConversions.ToInt(values[3]), ToBoolean(values[4]), conditions) : 0);
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetDir();
int UO.GetDir(object? id);Legge la direzione del carattere dal modello client.
-
id— Oggetto opzionale solo nelle forme a parametro singolo specificate: serial numero/stringa esadecimale, "self", "lasttarget" o nome AddObject. Questo non è graphic/type. Senza discussione si legge il proprio carattere. Prima di leggere un altro oggetto, controlla UO.Exists; un nome sconosciuto non apre l'ambito.
int — direzione mobile senza bit di corsa: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Per sconosciuto, mobile restituisce 0, che significa anche nord.
- I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
- C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
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.GetDir();
UO.Print("GetDir: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti si riferisce a self. La direzione del personaggio viene memorizzata in valore.
- Convert.ToString converte il numero da emettere e non cambia il significato del risultato.
var value = UO.GetDir();
UO.Print("GetDir: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Il valore viene letto una volta senza argomenti. La direzione del carattere viene utilizzata nel calcolo o nella condizione mostrata.
- Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.
return RunScenario();
object? RunScenario()
{
var value = UO.GetDir();
if (Truth(value == 2))
{
UO.Print("Facing east");
}
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:
- Il singolo argomento seleziona l'oggetto lasttarget; il suo serial deve essere noto al cliente. Il grafico/type non viene trasferito qui.
- I dati di un altro oggetto potrebbero essere sconosciuti anche se Exists è positivo. Per le coordinate di un oggetto in una borsa si ottiene la posizione del contenitore e non il punto mondiale.
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(UO.Exists("lasttarget")))
{
var targetValue = UO.GetDir("lasttarget");
UO.Print("Selected value: " + Convert.ToString(targetValue));
}
else
{
UO.Print("Target is not loaded");
}
return null;
}
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.GetDir. -
InjectionScript.Runtime.InjectionApiUO.GetDir:GetDir("self").
Codice interno di implementazione; non è uno script autonomo.
public int GetDir() => GetDir("self");Parametri: id (Integer/String)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.GetDir. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(id).
Codice interno di implementazione; non è uno script autonomo.
public int GetDir(int id) => bridge.GetDir(id);Parametri: id (Integer/String)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.GetDir. -
InjectionScript.Runtime.InjectionApiUO.GetDir:GetDir(GetObject(id)). -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(id).
Codice interno di implementazione; non è uno script autonomo.
public int GetDir(string id) => GetDir(GetObject(id));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetDirection();
dynamic UO.GetDirection(object? objID);Legge la direzione del carattere dal modello client.
-
objID— Oggetto opzionale solo nelle forme a parametro singolo specificate: serial numero/stringa esadecimale, "self", "lasttarget" o nome AddObject. Questo non è graphic/type. Senza discussione si legge il proprio carattere. Prima di leggere un altro oggetto, controlla UO.Exists; un nome sconosciuto non apre l'ambito.
int — direzione mobile senza bit di corsa: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Per sconosciuto, mobile restituisce 0, che significa anche nord.
- I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
- C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
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.GetDirection();
UO.Print("GetDirection: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti si riferisce a self. La direzione del personaggio viene memorizzata in valore.
- Convert.ToString converte il numero da emettere e non cambia il significato del risultato.
var value = UO.GetDirection();
UO.Print("GetDirection: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Il valore viene letto una volta senza argomenti. La direzione del carattere viene utilizzata nel calcolo o nella condizione mostrata.
- Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.
return RunScenario();
object? RunScenario()
{
var value = UO.GetDirection();
if (Truth(value == 2))
{
UO.Print("Facing east");
}
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:
- Il singolo argomento seleziona l'oggetto lasttarget; il suo serial deve essere noto al cliente. Il grafico/type non viene trasferito qui.
- I dati di un altro oggetto potrebbero essere sconosciuti anche se Exists è positivo. Per le coordinate di un oggetto in una borsa si ottiene la posizione del contenitore e non il punto mondiale.
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(UO.Exists("lasttarget")))
{
var targetValue = UO.GetDirection("lasttarget");
UO.Print("Selected value: " + Convert.ToString(targetValue));
}
else
{
UO.Print("Target is not loaded");
}
return null;
}
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.RegisterCharacterGetterAliases [GetDirection]. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
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.
() => bridge.GetDir(bridge.Self)Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.
Parametri: objID (Any)
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(Arg(0)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "getdirection": return new InjectionValue(bridge.GetDir(Arg(0)));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetPathArray(object? xdst, object? ydst, object? optimized, object? accuracy);Restituisce il percorso dalla posizione attuale del personaggio a X/Y senza eseguire alcuna mossa.
-
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 consente transizioni diagonali; false lascia quattro direzioni diritte in questa forma compatibile. Questo è diverso dal significato ottimizzato di MoveXY. -
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.
Matrice di record [x,y,z], ogni campo è un int. [0] dell'array esterno è il punto iniziale; l'ultima voce rientra nella tolleranza target specificata. Il numero di passaggi è ArrayLength(percorso)-1 solo per un array non vuoto. Un array vuoto [] significa che non è stato ottenuto il percorso valido completo (bersaglio/mappa irraggiungibile, restrizioni o limite di ricerca). Se il punto iniziale è già adatto, viene restituito un record e il numero di passaggi è 0. Il percorso parziale non viene restituito.
- La squadra calcola solo il percorso; non avvia il movimento né apre le porte. Per eseguire, utilizzare NewMoveXY/MoveXYZ e controllare il proprio risultato.
- La ricerca evita gli ostacoli considerando che le mosse adiacenti hanno lo stesso costo; su una mappa costante si cerca il percorso con il minor numero di passi. Viene controllata l’effettiva pervietà di ciascuna costola, compresa l’altezza e i limiti delle diagonali del cliente.
- Non più di 4096 nodi aperti e non più di 4096 passi. Il limite di lavoro può risultare in una matrice vuota anche se è presente un percorso lungo e complesso; dividere i percorsi lunghi in sezioni.
- Nel client, il calcolo è suddiviso in porzioni fino a 32 nodi con un controllo del budget di circa 1 ms tra i nodi. L'annullamento viene controllato tra una porzione e l'altra. La lettura della carta rimane nel thread del gioco; non è una promessa di un tempo di lettura fisso del singolo disco.
- La mappa può cambiare dopo la verifica: i personaggi si muovono, le porte si chiudono, il server corregge la situazione. L'array risultante è un piano per i dati locali disponibili, non una conferma del server.
- SetBadLocation esclude le celle, SetBadObject esclude le aree attorno a oggetti del mondo caricati idonei. Viene utilizzata un'istantanea degli elenchi di runtime al momento della richiesta; i divieti di un altro lancio non vengono ereditati. La validità della cella iniziale non viene controllata: è specificata dal codice chiamante. Non è possibile utilizzare una Z arbitraria all'interno di un muro come posizione iniziale valida.
- La carta attuale, la fonte X/Y/Z e il bersaglio Z vengono presi dal personaggio. Tolleranza Z=255. Non sono presenti filtri mobili/statici aggiuntivi o autorizzazioni per porte chiuse nel formato a quattro argomenti.
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.GetPathArray(UO.GetX() + 5, UO.GetY(), true, 0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Xdst: cinque celle a est; Ydst ex; Ottimizzato=true; Precisione=0.
- il conteggio include il punto di partenza. La sottrazione 1 viene eseguita solo dopo aver verificato la presenza di un array non vuoto.
var path = UO.GetPathArray(UO.GetX() + 5, UO.GetY(), true, 0);
var count = ArrayLength(path);
if (Truth(count > 0))
{
UO.Print("Steps: " + Convert.ToString(count - 1));
}
else
{
UO.Print("Complete path is unavailable");
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
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:
- Obiettivo 1445/1690; Ottimizzato=false esclude le diagonali; Precisione=1 risolve la cella più vicina nel quadrato di tolleranza.
- punto[0]/[1]/[2] - X/Y/Z. Non è graphic, serial o di tipo superficiale.
return RunScenario();
object? RunScenario()
{
var path = UO.GetPathArray(1445, 1690, false, 1);
var i = 0;
while (Truth(i < ArrayLength(path)))
{
var point = path[i];
UO.Print(Convert.ToString(point[0]) + "," + Convert.ToString(point[1]) + "," + Convert.ToString(point[2]));
i = i + 1;
}
return null;
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
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:
- La prima squadra conta solo il percorso. Il secondo controlla/esegue nuovamente il movimento, callback=0, timeout=5000.
- Se devi solo andare, il preliminare GetPathArray è facoltativo e aggiunge lavoro.
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 x = UO.GetX() + 3;
var y = UO.GetY();
var path = UO.GetPathArray(x, y, true, 0);
if (Truth(ArrayLength(path) > 0))
{
var ok = UO.NewMoveXY(x, y, true, 0, false, 0, 5000);
UO.Print("Movement result: " + Convert.ToString(ok));
}
return null;
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
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)
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.BuildPortablePath:BuildPortablePath(bridge.GetX(bridge.Self), bridge.GetY(bridge.Self), bridge.GetZ(bridge.Self), Arg(0), Arg(1), bridge.GetZ(bridge.Self), bridge.WorldNumber, Arg(3), 255, Arg(2) != 0, false). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX:bridge.GetX(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY:bridge.GetY(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetZ:bridge.GetZ(bridge.Self). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WorldNumber:bridge.WorldNumber.
Codice interno di implementazione; non è uno script autonomo.
case "getpatharray":
return BuildPortablePath(bridge.GetX(bridge.Self), bridge.GetY(bridge.Self), bridge.GetZ(bridge.Self),
Arg(0), Arg(1), bridge.GetZ(bridge.Self), bridge.WorldNumber, Arg(3), 255, Arg(2) != 0, false);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance, object? avoidMobiles);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance, object? avoidMobiles, object? avoidStatics);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance, object? avoidMobiles, object? avoidStatics, object? allowDoors);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance, object? avoidMobiles, object? avoidStatics, object? allowDoors, object? allowDiagonal);Calcola una matrice del percorso completo tra due punti nel mondo con controllo dell'altezza e filtri aggiuntivi.
-
startX- Mondo iniziale X, 0..65535. -
startY- Mondo iniziale Y, 0..65535. -
startZ— Altezza iniziale -128..127. -
finishX— Obiettivo del mondo X, 0..65535. -
finishY— Obiettivo del mondo Y, 0..65535. -
finishZ— Altezza target -128..127. -
map— Numero della carta attualmente caricata, ad esempio UO.WorldNum(). L'altra mappa fornisce un array vuoto che include la corrispondenza X/Y/Z. -
accuracyXY— 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. -
accuracyZ— Tolleranza altezza: abs (Z effettiva - Z richiesta), limitata da 0..255. Lo zero richiede un'altitudine precisa; 255 disabilita virtualmente il limite Z. -
run- Flag di esecuzione compatibile richiesto. La richiesta non sposta nulla; in questo formato, Ottimizzato è sempre true, quindi l'esecuzione non modifica la sequenza di celle o il numero di passaggi. -
maxSteps— Limite facoltativo sul numero di bordi del percorso, senza punto iniziale. 0/negativo/assente utilizza il limite generale 4096. Qui vengono considerate le cellule, in contrasto con i cambiamenti osservati in NewMoveXY. -
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. -
avoidMobiles- true esclude i caratteri caricati X/Y, eccetto self, tramite snapshot all'inizio della chiamata; L'altezza di questo filtro non viene presa in considerazione. L'impostazione predefinita è false. Si applica ancora il normale controllo di autorizzazione del cliente. -
avoidStatics- true esclude una cella con qualsiasi ingresso statico, anche attraversabile o ad altezza diversa. L'impostazione predefinita è false. Si tratta di un filtro rigoroso e non solo di un divieto di muri invalicabili. -
allowDoors- true consente un tentativo di percorso attraverso una tessera porta trovata, anche se la porta chiusa fallisce il normale controllo. L'impostazione predefinita è false. La porta non si apre; accesso, Z e permeabilità dovranno essere ricontrollati in fase di esecuzione. -
allowDiagonal- true/assente consente otto direzioni con controllo dell'angolo; false - solo quattro direzioni in avanti.
Matrice di record [x,y,z], ogni campo è un int. [0] dell'array esterno è il punto iniziale; l'ultima voce rientra nella tolleranza target specificata. Il numero di passaggi è ArrayLength(percorso)-1 solo per un array non vuoto. Un array vuoto [] significa che non è stato ottenuto il percorso valido completo (bersaglio/mappa irraggiungibile, restrizioni o limite di ricerca). Se il punto iniziale è già adatto, viene restituito un record e il numero di passaggi è 0. Il percorso parziale non viene restituito.
- La squadra calcola solo il percorso; non avvia il movimento né apre le porte. Per eseguire, utilizzare NewMoveXY/MoveXYZ e controllare il proprio risultato.
- La ricerca evita gli ostacoli considerando che le mosse adiacenti hanno lo stesso costo; su una mappa costante si cerca il percorso con il minor numero di passi. Viene controllata l’effettiva pervietà di ciascuna costola, compresa l’altezza e i limiti delle diagonali del cliente.
- Non più di 4096 nodi aperti e non più di 4096 passi. Il limite di lavoro può risultare in una matrice vuota anche se è presente un percorso lungo e complesso; dividere i percorsi lunghi in sezioni.
- Nel client, il calcolo è suddiviso in porzioni fino a 32 nodi con un controllo del budget di circa 1 ms tra i nodi. L'annullamento viene controllato tra una porzione e l'altra. La lettura della carta rimane nel thread del gioco; non è una promessa di un tempo di lettura fisso del singolo disco.
- La mappa può cambiare dopo la verifica: i personaggi si muovono, le porte si chiudono, il server corregge la situazione. L'array risultante è un piano per i dati locali disponibili, non una conferma del server.
- SetBadLocation esclude le celle, SetBadObject esclude le aree attorno a oggetti del mondo caricati idonei. Viene utilizzata un'istantanea degli elenchi di runtime al momento della richiesta; i divieti di un altro lancio non vengono ereditati. La validità della cella iniziale non viene controllata: è specificata dal codice chiamante. Non è possibile utilizzare una Z arbitraria all'interno di un muro come posizione iniziale valida.
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.GetPathArray3D(UO.GetX(), UO.GetY(), UO.GetZ(), UO.GetX() + 4, UO.GetY(), UO.GetZ(), UO.WorldNum(), 0, 0, false);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- I primi tre valori sono gli originali X/Y/Z; i prossimi tre sono lo scopo.
- map=WorldNum(), accuracyXY=0, accuracyZ=0 richiedono una posizione precisa. run=false non attiva la camminata.
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
var path = UO.GetPathArray3D(x, y, z, x + 4, y, z, UO.WorldNum(), 0, 0, false);
if (Truth(ArrayLength(path) > 0))
{
UO.Print("Steps: " + Convert.ToString(ArrayLength(path) - 1));
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
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:
- Obiettivo 1445/1690/20; accuracyXY=1, accuracyZ=2; run=true rimane un flag di compatibilità.
- maxSteps=80, maxDistance=30; avoidMobiles=true, avoidStatics=false, allowDoors=true, allowDiagonal=false. L'array potrebbe essere vuoto.
- L'altezza delle porte è un presupposto di pianificazione; non vi è alcuna garanzia di apertura e passaggio.
return RunScenario();
object? RunScenario()
{
var path = UO.GetPathArray3D(UO.GetX(), UO.GetY(), UO.GetZ(), 1445, 1690, 20, UO.WorldNum(), 1, 2, true, 80, 30, true, false, true, false);
UO.Print("Points: " + Convert.ToString(ArrayLength(path)));
return null;
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;Parametri e flusso di esecuzione:
- accuracyXY=2/accuracyZ=5 risolve il punto adatto più vicino; maxSteps=100.
- last è l'ultima voce nel piano, non la posizione attuale del personaggio. La squadra non lo sposta.
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 path = UO.GetPathArray3D(UO.GetX(), UO.GetY(), UO.GetZ(), 1445, 1690, 0, UO.WorldNum(), 2, 5, false, 100);
var count = ArrayLength(path);
if (Truth(count > 0))
{
var last = path[count - 1];
UO.Print("X=" + Convert.ToString(last[0]) + " Y=" + Convert.ToString(last[1]) + " Z=" + Convert.ToString(last[2]));
}
return null;
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
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.
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any)
Risultato: dynamic / Array.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(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 => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any)
Risultato: dynamic / Array.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(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 => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any)
Risultato: dynamic / Array.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(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 => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance, avoidMobiles) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any), avoidMobiles (Any)
Risultato: dynamic / Array.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(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 => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance, avoidMobiles, avoidStatics) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any), avoidMobiles (Any), avoidStatics (Any)
Risultato: dynamic / Array.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(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 => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance, avoidMobiles, avoidStatics, allowDoors) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any), avoidMobiles (Any), avoidStatics (Any), allowDoors (Any)
Risultato: dynamic / Array.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(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 => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance, avoidMobiles, avoidStatics, allowDoors, allowDiagonal) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any), avoidMobiles (Any), avoidStatics (Any), allowDoors (Any), allowDiagonal (Any)
Risultato: dynamic / Array.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(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 => CompactGetPathArray3D(values)Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetRun();
int UO.GetRun(object? id);Controlla la bandiera in esecuzione nell'ultima direzione nota mobile.
-
id— Obbligatorio serial/ID di un oggetto specifico: int, stringa esadecimale o alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse o il nome AddObject. Questo non è graphic/type. Il nome non specificato si risolve in 0; il comando non apre alcuna nuova destinazione. GetRun ha anche la forma GetRun() per self.
int 1 - caricato mobile ha l'attributo Direction.Running. int 0 - manca l'attributo, l'oggetto non è mobile, sconosciuto o eliminato. L'ultimo flag in esecuzione può essere mantenuto dopo l'arresto. Questa non è l'attività del percorso, non la velocità o il numero di passi rimanenti. Per spostare self usa anche Moving().
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.
- Viene letto il modello client locale; Non ci sono richieste al server, nessuna attesa o spostamento.
- Il risultato si riferisce al momento della lettura. Dopo UO.Wait o altra azione, l'oggetto e i suoi flag potrebbero cambiare.
- L'ultimo flag in esecuzione può essere mantenuto dopo l'arresto. Questa non è l'attività del percorso, non la velocità o il numero di passi rimanenti. Per spostare self usa anche Moving().
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.GetRun("self");
UO.Print("GetRun: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- L'argomento self seleziona esplicitamente il suo carattere. stato - solo 1/0.
- L'ultimo flag in esecuzione può essere mantenuto dopo l'arresto. Questa non è l'attività del percorso, non la velocità o il numero di passi rimanenti. Per spostare self usa anche Moving().
var state = UO.GetRun("self");
var moving = UO.Moving();
UO.Print("Running flag: " + Convert.ToString(state));
UO.Print("Self movement active: " + Convert.ToString(moving));Parametri e flusso di esecuzione:
- IsNpc esclude soggetto e oggetto sconosciuto. target memorizza un singolo serial anziché un riferimento live a un lasttarget mutevole.
- Il risultato si riferisce al campo Direction.Running. I dati vengono aggiornati solo dopo che il client ha ricevuto lo stato appropriato.
return RunScenario();
object? RunScenario()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var state = UO.GetRun(target);
UO.Print("Selected mobile state 1/0: " + Convert.ToString(state));
}
else
{
UO.Print("No loaded mobile selected");
}
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:
- UO.Wait(500): pausa in millisecondi. Successivamente, viene controllato separatamente che mobile esista ancora.
- Vengono confrontate due immagini. Le modifiche intermedie potrebbero non essere perse e questa non è una sottoscrizione continua agli eventi del server.
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 target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var before = UO.GetRun(target);
await Delay(500);
if (Truth(UO.IsNPC(target)))
{
var after = UO.GetRun(target);
if (Truth(before != after))
{
UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
}
else
{
UO.Print("Mobile left the local world");
}
}
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: Nessun parametro.
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.GetRun. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetRun:bridge.GetRun(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
Codice interno di implementazione; non è uno script autonomo.
public int GetRun() => bridge.GetRun(bridge.Self);Parametri: id (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.GetRun. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetRun:bridge.GetRun(GetObject(id)). -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(id).
Codice interno di implementazione; non è uno script autonomo.
public int GetRun(InjectionValue id) => bridge.GetRun(GetObject(id));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetRunMountTimer();Mostra l'intervallo configurato di un passo di corsa del cavallo in millisecondi. Utile per verificare la modalità, stimare i tempi e salvare l'impostazione prima di rallentare temporaneamente.
Non ci sono parametri.
int da 100 a 2000 compreso - intervallo configurato in millisecondi. L'impostazione predefinita è 100. Questo è il numero di volte, non true/false, non ID e non il numero di celle passate.
- 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.
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.GetRunMountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- UO.GetRunMountTimer() viene chiamato senza argomenti. delayMs — intervallo di corsa a cavallo; le altre modalità non vengono misurate qui.
var delayMs = UO.GetRunMountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Parametri e flusso di esecuzione:
- passi=5 è il numero di passi da valutare, non un parametro di comando. La moltiplicazione dà solo il contributo dei ritardi configurati; non è una promessa dell'orario di arrivo o un timeout del percorso.
return RunScenario();
object? RunScenario()
{
var steps = 5;
var delayMs = UO.GetRunMountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Parametri e flusso di esecuzione:
- precedente viene confrontato con 100 ms. Viene impostato l'intervallo standard, le altre tre modalità vengono salvate. Il personaggio non si sposta da nessuna parte dalla sfida stessa.
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();
if (Truth(previous > 100))
{
UO.SetRunMountTimer(100);
}
return null;
}
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: dynamic / Any.
Durante la chiamata:
Codice interno di implementazione; non è uno script autonomo.
case "getrunmounttimer": return new InjectionValue(state.RunMountTimer);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetRunUnMountTimer();Mostra l'intervallo configurato di un passo di camminata in millisecondi. Utile per verificare la modalità, stimare i tempi e salvare l'impostazione prima di rallentare temporaneamente.
Non ci sono parametri.
int da 200 a 2000 compreso - intervallo configurato in millisecondi. L'impostazione predefinita è 200. Questo è il numero di volte, non true/false, non ID e non il numero di celle passate.
- 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.
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.GetRunUnMountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- UO.GetRunUnmountTimer() viene chiamato senza argomenti. delayMs - intervallo di corsa a piedi; le altre modalità non vengono misurate qui.
var delayMs = UO.GetRunUnMountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Parametri e flusso di esecuzione:
- passi=5 è il numero di passi da valutare, non un parametro di comando. La moltiplicazione dà solo il contributo dei ritardi configurati; non è una promessa dell'orario di arrivo o un timeout del percorso.
return RunScenario();
object? RunScenario()
{
var steps = 5;
var delayMs = UO.GetRunUnMountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Parametri e flusso di esecuzione:
- precedente viene confrontato con 200 ms. Viene impostato l'intervallo standard, le altre tre modalità vengono salvate. Il personaggio non si sposta da nessuna parte dalla sfida stessa.
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();
if (Truth(previous > 200))
{
UO.SetRunUnmountTimer(200);
}
return null;
}
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: dynamic / Any.
Durante la chiamata:
Codice interno di implementazione; non è uno script autonomo.
case "getrununmounttimer": return new InjectionValue(state.RunUnmountTimer);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetWalkMountTimer();Mostra l'intervallo configurato di un passo della camminata a cavallo in millisecondi. Utile per verificare la modalità, stimare i tempi e salvare l'impostazione prima di rallentare temporaneamente.
Non ci sono parametri.
int da 200 a 2000 compreso - intervallo configurato in millisecondi. L'impostazione predefinita è 200. Questo è il numero di volte, non true/false, non ID e non il numero di celle passate.
- 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 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.GetWalkMountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- UO.GetWalkMountTimer() viene chiamato senza argomenti. delayMs — intervallo di camminata a cavallo; le altre modalità non vengono misurate qui.
var delayMs = UO.GetWalkMountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Parametri e flusso di esecuzione:
- passi=5 è il numero di passi da valutare, non un parametro di comando. La moltiplicazione dà solo il contributo dei ritardi configurati; non è una promessa dell'orario di arrivo o un timeout del percorso.
return RunScenario();
object? RunScenario()
{
var steps = 5;
var delayMs = UO.GetWalkMountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Parametri e flusso di esecuzione:
- precedente viene confrontato con 200 ms. Viene impostato l'intervallo standard, le altre tre modalità vengono salvate. Il personaggio non si sposta da nessuna parte dalla sfida stessa.
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();
if (Truth(previous > 200))
{
UO.SetWalkMountTimer(200);
}
return null;
}
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: dynamic / Any.
Durante la chiamata:
Codice interno di implementazione; non è uno script autonomo.
case "getwalkmounttimer": return new InjectionValue(state.WalkMountTimer);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetWalkUnmountTimer();Mostra l'intervallo configurato di un passo di camminata in millisecondi. Utile per verificare la modalità, stimare i tempi e salvare l'impostazione prima di rallentare temporaneamente.
Non ci sono parametri.
int da 400 a 2000 compreso - intervallo configurato in millisecondi. L'impostazione predefinita è 400. Questo è il numero di volte, non true/false, non ID e non il numero di celle passate.
- 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 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.GetWalkUnmountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- UO.GetWalkUnmountTimer() viene chiamato senza argomenti. delayMs — intervallo di camminata; le altre modalità non vengono misurate qui.
var delayMs = UO.GetWalkUnmountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Parametri e flusso di esecuzione:
- passi=5 è il numero di passi da valutare, non un parametro di comando. La moltiplicazione dà solo il contributo dei ritardi configurati; non è una promessa dell'orario di arrivo o un timeout del percorso.
return RunScenario();
object? RunScenario()
{
var steps = 5;
var delayMs = UO.GetWalkUnmountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Parametri e flusso di esecuzione:
- precedente viene confrontato con 400 ms. Viene impostato l'intervallo standard, le altre tre modalità vengono salvate. Il personaggio non si sposta da nessuna parte dalla sfida stessa.
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();
if (Truth(previous > 400))
{
UO.SetWalkUnmountTimer(400);
}
return null;
}
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: dynamic / Any.
Durante la chiamata:
Codice interno di implementazione; non è uno script autonomo.
case "getwalkunmounttimer": return new InjectionValue(state.WalkUnmountTimer);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.IsMoving();Controlla il movimento del tuo personaggio.
Non ci sono parametri.
int bool (1/0): 1 - Pathfinder automatico è attivo o ci sono ancora passaggi nella coda del personaggio; 0 - mancano entrambi oppure il personaggio non è caricato. Questa non è una conferma del raggiungimento di un obiettivo o del numero di passaggi.
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.
- I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
- C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
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.IsMoving();
UO.Print("IsMoving: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Le parentesi vuote leggono self. attivo — numero 1 o 0; Il testo del messaggio serve come esempio di elaborazione del ramo.
- 1 - il Pathfinder automatico è attivo o ci sono ancora dei passaggi nella coda del personaggio; 0 - mancano entrambi o il personaggio non è caricato. Questa non è una conferma del raggiungimento di un obiettivo o del numero di passaggi.
var active = UO.IsMoving();
if (Truth(active))
{
UO.Print("State is active");
}
else
{
UO.Print("State is inactive or unavailable");
}
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:
- Il comando non ha argomenti oggetto: anche dopo Exists(self), legge solo il proprio stato.
- Exists(self) controlla il carico del giocatore separatamente dal flag richiesto. Il mondo può cambiare tra un controllo e l'altro.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Exists("self")))
{
var state = UO.IsMoving();
UO.Print("State 1/0: " + Convert.ToString(state));
}
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:
- Le due chiamate senza argomenti leggono self; UO.Wait(500) - pausa per mezzo secondo.
- Vengono confrontate due istantanee di flag. Le transizioni tra le inquadrature possono essere saltate; non è un abbonamento a tutti gli eventi del server.
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 before = UO.IsMoving();
await Delay(500);
var after = UO.IsMoving();
if (Truth(before != after))
{
UO.Print("State changed from " + Convert.ToString(before) + " to " + 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;
}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.IsMoving. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsMoving:bridge.IsMoving().
Codice interno di implementazione; non è uno script autonomo.
public int IsMoving() => bridge.IsMoving();Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.IsRunning(object? objID);Controlla la bandiera in esecuzione nell'ultima direzione nota mobile.
-
objID— Obbligatorio serial/ID di un oggetto specifico: int, stringa esadecimale o alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse o nome AddObject. Questo non è graphic/type. Il nome non specificato si risolve in 0; il comando non apre alcuna nuova destinazione. L'argomento è obbligatorio; per te, supera self.
int 1 - caricato mobile ha l'attributo Direction.Running. int 0 - manca l'attributo, l'oggetto non è mobile, sconosciuto o eliminato. L'ultimo flag in esecuzione può essere mantenuto dopo l'arresto. Questa non è l'attività del percorso, non la velocità o il numero di passi rimanenti. Per spostare self usa anche Moving().
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.
- Viene letto il modello client locale; Non ci sono richieste al server, nessuna attesa o spostamento.
- Il risultato si riferisce al momento della lettura. Dopo UO.Wait o altra azione, l'oggetto e i suoi flag potrebbero cambiare.
- L'ultimo flag in esecuzione può essere mantenuto dopo l'arresto. Questa non è l'attività del percorso, non la velocità o il numero di passi rimanenti. Per spostare self usa anche Moving().
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.IsRunning("self");
UO.Print("IsRunning: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- L'argomento self seleziona esplicitamente il suo carattere. stato - solo 1/0.
- L'ultimo flag in esecuzione può essere mantenuto dopo l'arresto. Questa non è l'attività del percorso, non la velocità o il numero di passi rimanenti. Per spostare self usa anche Moving().
var state = UO.IsRunning("self");
var moving = UO.Moving();
UO.Print("Running flag: " + Convert.ToString(state));
UO.Print("Self movement active: " + Convert.ToString(moving));Parametri e flusso di esecuzione:
- IsNpc esclude soggetto e oggetto sconosciuto. target memorizza un singolo serial anziché un riferimento live a un lasttarget mutevole.
- Il risultato si riferisce al campo Direction.Running. I dati vengono aggiornati solo dopo che il client ha ricevuto lo stato appropriato.
return RunScenario();
object? RunScenario()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var state = UO.IsRunning(target);
UO.Print("Selected mobile state 1/0: " + Convert.ToString(state));
}
else
{
UO.Print("No loaded mobile selected");
}
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:
- UO.Wait(500): pausa in millisecondi. Successivamente, viene controllato separatamente che mobile esista ancora.
- Vengono confrontate due immagini. Le modifiche intermedie potrebbero non essere perse e questa non è una sottoscrizione continua agli eventi del server.
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 target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var before = UO.IsRunning(target);
await Delay(500);
if (Truth(UO.IsNPC(target)))
{
var after = UO.IsRunning(target);
if (Truth(before != after))
{
UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
}
else
{
UO.Print("Mobile left the local world");
}
}
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: objID (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetRun:bridge.GetRun(Arg(0, bridge.Self)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0, bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
Codice interno di implementazione; non è uno script autonomo.
case "isrunning": return new InjectionValue(bridge.GetRun(Arg(0, bridge.Self)));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.LastStepQUsedDoor();
dynamic UO.LastStepQUsedDoor(object? value);Legge o modifica manualmente il flag di tentativo di apertura della porta dell'ultimo comando StepQ.
-
value— Intero facoltativo. Esattamente questo numero viene memorizzato con l'argomento; senza argomenti, la lettura viene eseguita.
int — segno salvato. Il solito StepQ lo resetta a 0 e, quando moveOpenDoor è abilitato, registra il risultato di TryOpenDoorForStep: 1 se viene rilevato un tentativo, 0 altrimenti. Il modulo manuale consente altri numeri. Questa non è una porta serial o la conferma della sua apertura.
- Il controllo non legge lo stato della porta dal server. La chiamata di fallback OpenDoor non modifica la tacca di zero.
- Se StepQ fallisce anticipatamente a causa della connessione/durata, il ripristino non è ancora stato eseguito, quindi il valore precedente potrebbe rimanere.
- 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 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.LastStepQUsedDoor();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Senza argomenti, viene letto il numero memorizzato.
- Non usarlo come ID per UseObject.
UO.Print(Convert.ToString(UO.LastStepQUsedDoor()));Parametri e flusso di esecuzione:
- value=0 cancella il segno precedente. direzione=2 — E; corri=false.
- Il risultato StepQ e il segno della porta hanno significati diversi.
return RunScenario();
object? RunScenario()
{
UO.LastStepQUsedDoor(0);
var status = UO.StepQ(2, false);
UO.Print(Convert.ToString(UO.LastStepQUsedDoor()));
return null;
}Parametri e flusso di esecuzione:
- precedente: valore salvato.
- Il ripristino manuale non esegue alcuna azione sulla porta.
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.LastStepQUsedDoor();
UO.LastStepQUsedDoor(0);
UO.Print(Convert.ToString(UO.LastStepQUsedDoor()));
UO.LastStepQUsedDoor(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: Nessun parametro.
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "laststepquseddoor":
if (arguments.Length > 0) state.LastStepUsedDoor = Arg(0);
return new InjectionValue(state.LastStepUsedDoor);Parametri: value (Any)
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "laststepquseddoor":
if (arguments.Length > 0) state.LastStepUsedDoor = Arg(0);
return new InjectionValue(state.LastStepUsedDoor);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Move();Legge se esiste un percorso automatico o passaggi di caratteri non ancora completati.
Non ci sono parametri.
int 1 — Pathfinder è attivo o i passaggi rimangono nella coda di animazione del personaggio; 0 - mancano entrambi o il personaggio non è caricato. Questo non è il numero di passi, il risultato del raggiungimento di un obiettivo precedente o il segno di come si tiene premuto il mouse.
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 comando legge solo lo stato. Se il risultato è diverso da zero, viene aggiornato il timer compatibile TicksAnim. Vengono conteggiati anche i passaggi richiesti dal mouse/tasti mentre rimangono in coda.
- Per interrompere il percorso automatico, utilizzare MoverStop. MoveOff controlla altri passaggi della tastiera.
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.Move();
UO.Print("Move: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Non ci sono argomenti.
- 0 non dimostra che l'obiettivo sia stato raggiunto: il percorso avrebbe potuto essere cancellato.
UO.Print("Movement active or queued: " + Convert.ToString(UO.Move()));Parametri e flusso di esecuzione:
- 100 attende oltre 50 ms imposta il limite approssimativo di 5 secondi.
- Effettuare questa prova non avvia né arresta di per sé il movimento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var attempts = 0;
while (Truth(UO.Move()) && Truth(attempts < 100))
{
await Delay(50);
attempts = attempts + 1;
}
UO.Print("Still moving: " + Convert.ToString(UO.Move()));
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:
- Move() controlla l'attività, MoverStop() rimuove il percorso.
- I pacchetti già inviati possono ancora essere confermati dal server.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
if (Truth(UO.Move()))
{
UO.MoverStop();
}
return null;
}
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.Move. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Move:bridge.Move(). -
InjectionScript.Runtime.InjectionApiUO.Timer:Timer().
Codice interno di implementazione; non è uno script autonomo.
public int Move()
{
int result = bridge.Move();
if (result != 0)
ticksAnim = Timer();
return result;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.MoveOff();Disabilita i passaggi chiave PMove compatibili.
Non ci sono parametri.
void - nessun valore restituito. Chiama su una linea separata; non è true/false o il numero di passi.
- Modifica il flag MoveEnabled nello stato di runtime. Questo non è un blocco caratteri universale: NewMoveXY, MoveXYZ, Step e mouse non sono controllati da questo flag.
- MoveOff non arresta un Pathfinder già in esecuzione; richiede MoverStop.
- 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.MoveOff");
UO.MoveOff();Parametri e flusso di esecuzione:
- Non ci sono argomenti.
- Il flag PMove viene modificato, senza alcun valore restituito.
UO.MoveOff();Parametri e flusso di esecuzione:
- MoveOn abilita i passaggi chiave prima di PMove; MoveOff si spegne dopo il normale completamento.
- Questi sono comandi sequenziali; un flag disabilitato non significa un arresto di emergenza per tutte le procedure.
return RunScenario();
object? RunScenario()
{
UO.MoveOn();
UO.PMove(UO.GetX() + 1, UO.GetY());
UO.MoveOff();
return null;
}Parametri e flusso di esecuzione:
- Le due squadre controllano diversi meccanismi di movimento.
- Move() legge il percorso automatico; non considerarlo un test di MoveEnabled.
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.MoveOff();
UO.MoverStop();
UO.Print(Convert.ToString(UO.Move()));
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.MoveOff. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.EnableMove:bridge.EnableMove(false).
Codice interno di implementazione; non è uno script autonomo.
public void MoveOff() => bridge.EnableMove(false);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.MoveOn();Abilita i passaggi chiave PMove compatibili.
Non ci sono parametri.
void - nessun valore restituito. Chiama su una linea separata; non è true/false o il numero di passi.
- Modifica il flag MoveEnabled nello stato di runtime. Questo non è un blocco caratteri universale: NewMoveXY, MoveXYZ, Step e mouse non sono controllati da questo flag.
- MoveOff non arresta un Pathfinder già in esecuzione; richiede MoverStop.
- 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.MoveOn");
UO.MoveOn();Parametri e flusso di esecuzione:
- Non ci sono argomenti.
- Il flag PMove viene modificato, senza alcun valore restituito.
UO.MoveOn();Parametri e flusso di esecuzione:
- MoveOn abilita i passaggi chiave prima di PMove; MoveOff si spegne dopo il normale completamento.
- Questi sono comandi sequenziali; un flag disabilitato non significa un arresto di emergenza per tutte le procedure.
return RunScenario();
object? RunScenario()
{
UO.MoveOn();
UO.PMove(UO.GetX() + 1, UO.GetY());
UO.MoveOff();
return null;
}Parametri e flusso di esecuzione:
- MoveOn abilita i passaggi chiave PMove compatibili e non restituisce un valore. Il risultato del movimento viene controllato tramite coordinate; MoveOn non controlla tutte le modalità di 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.MoveOn();
int destinationX = UO.GetX() + 1;
int destinationY = UO.GetY();
UO.PMove(destinationX, destinationY);
UO.Print($"Reached requested tile: {UO.GetX() == destinationX && UO.GetY() == destinationY}");
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.MoveOn. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.EnableMove:bridge.EnableMove(true).
Codice interno di implementazione; non è uno script autonomo.
public void MoveOn() => bridge.EnableMove(true);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.MoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running);Sposta il carattere su X/Y con cinque parametri richiesti e attende il risultato.
-
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à.
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.
- 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 target Z viene preso quando viene chiamato, tolleranza Z=255. Per ulteriori restrizioni, utilizzare NewMoveXY; per selezionare l'altezza - MoveXYZ.
- 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.
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.MoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Xdst: due celle a est; Ydst non cambia.
- Ottimizzato=true, Precisione=0, In esecuzione=false. La chiamata restituisce il risultato una volta completata.
var ok = UO.MoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false);
UO.Print(Convert.ToString(ok));Parametri e flusso di esecuzione:
- Xdst/Ydst vengono letti dall'oggetto selezionato; deve essere un oggetto del mondo, non un oggetto all'interno del contenitore.
- Precisione=1 ti permette di avvicinarti; In esecuzione=true. Le altezze non si limitano a questa sfida.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Exists("lasttarget")))
{
var ok = UO.MoveXY(UO.GetX("lasttarget"), UO.GetY("lasttarget"), true, 1, true);
UO.Print("Approach result: " + Convert.ToString(ok));
}
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:
- Sostituisci il bersaglio 1445/1690 con il tuo. La soglia di resistenza è impostata da un'impostazione separata, non dal sesto parametro MoveXY.
- Dopo una restituzione normale, viene ripristinato il valore originale. Se si verifica un'interruzione, non verranno eseguite ulteriori righe.
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 previous = UO.moveCheckStamina();
UO.moveCheckStamina(15);
var ok = UO.MoveXY(1445, 1690, true, 0, false);
UO.moveCheckStamina(previous);
UO.Print(Convert.ToString(ok));
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: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any)
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::MoveTo:MoveTo(Arg(0), Arg(1), bridge.GetZ(bridge.Self), Arg(3), Arg(4) != 0, 255, Arg(2) != 0). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetZ:bridge.GetZ(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
Codice interno di implementazione; non è uno script autonomo.
case "movexy":
return new InjectionValue(MoveTo(Arg(0), Arg(1), bridge.GetZ(bridge.Self), Arg(3), Arg(4) != 0, 255, Arg(2) != 0));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running);
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running, object? timeout);
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running, object? timeout, object? maxSteps);
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running, object? timeout, object? maxSteps, object? avoidMobiles);
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running, object? timeout, object? maxSteps, object? avoidMobiles, object? openDoors);Sposta il personaggio in un punto del mondo con tolleranze orizzontali e verticali separate.
-
x- Richiesto int: coordinate mondiali della destinazione X, 0..65535, sulla mappa corrente. Non la coordinata gump. -
y- Richiesto int: coordinate mondiali della destinazione Y, 0..65535, sulla mappa corrente. -
z- Obbligatorio int: altitudine mondiale target -128..127. Questa è l'altezza della superficie, non il numero del piano. -
accuracyXY— Richiesto int. Tolleranza per X e Y nelle celle: entrambe le deviazioni devono rientrare in questa tolleranza. Il valore è limitato all'intervallo 0..20; 0 richiede X/Y precisi. -
accuracyZ— Richiesto int. Tolleranza altezza: abs (Z effettiva - Z richiesta), limitata da 0..255. Lo zero richiede un'altitudine precisa; 255 disabilita virtualmente il limite Z. -
running— Flag booleano obbligatorio. 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. Il conto alla rovescia inizia dopo che il percorso è stato accettato per l'esecuzione; questo non è un limite rigido alla durata dell'intera chiamata insieme alla preparazione del percorso. -
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. -
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.
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.
- Come funziona, passo 1: controlla le coordinate, la connessione configurata e le condizioni di durata. Se il carattere è già all'interno di accuracyXY e accuracyZ, ritorna immediatamente 1 senza un nuovo percorso.
- Passo 2: costruisce un percorso sulla mappa corrente tenendo conto dell'altezza della superficie, degli ostacoli e delle condizioni di passaggio selezionate. La modalità ottimizzata è abilitata nel comando qui; Non è necessario passare tale parametro a MoveXYZ.
- Passo 3: inizia a camminare o correre lungo il percorso e attende il risultato nella procedura corrente. La riga successiva alla chiamata viene eseguita al termine; l'interfaccia client continua a funzionare.
- Passo 4: Se un passo fallisce o si verifica un nuovo ostacolo, il cliente può ricalcolare il percorso dalla posizione attuale. I tentativi sono limitati. Quando si verifica un timeout o viene raggiunto il limite dei movimenti osservabili oltre il target, il movimento si ferma con 0.
- Passaggio 5: al termine del movimento, confronta gli effettivi X/Y/Z del cliente con il target. Sono obbligatori sia abs(X-x)<=accuracyXY, abs(Y-y)<=accuracyXY che abs(Z-z)<=accuracyZ. Ad esempio, per il target 1279/540/20 con tolleranze 1 e 2 X=1278..1280, Y=539..541 sono adatti, Z=18..22.
- La forma minima contiene sei argomenti: UO.MoveXYZ(1279,540,20,1,2,true). Ulteriori argomenti vengono aggiunti a destra nell'ordine timeout, maxSteps, avoidMobiles, openDoors. Per specificare openDoors è necessario superare anche le posizioni precedenti; gli spazi vuoti tra le virgole non sono supportati.
- Differenza da NewMoveXY: MoveXYZ prende l'altezza del target come terzo argomento. NewMoveXY ha un terzo argomento di Ottimizzato; Non puoi trasferire l'altitudine lì. MoveXYZ non dispone di callback in questo runtime.
- 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.
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.MoveXYZ(UO.GetX() + 1, UO.GetY(), UO.GetZ(), 0, 0, false);
UO.Print("MoveXYZ: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- x/y/z è il punto target. accuracyXY=0 e accuracyZ=0 richiedono una posizione precisa.
- correre=false - camminare. Se la superficie adiacente ha un'altezza diversa, il risultato potrebbe essere 0.
var ok = UO.MoveXYZ(UO.GetX() + 1, UO.GetY(), UO.GetZ(), 0, 0, false);
UO.Print(Convert.ToString(ok));Parametri e flusso di esecuzione:
- Preparazione: il personaggio deve essere nel gioco e il punto deve esistere sulla mappa corrente. 1279/540/20 sono coordinate di allenamento: sostituiscile con il tuo punto disponibile, inclusa l'altezza effettiva della superficie.
-
- destinationX=1279 è il primo argomento, la coordinata mondiale X del bersaglio.
-
- destinationY=540 è il secondo argomento, la coordinata mondiale Y del bersaglio.
-
- destinationZ=20 — terzo argomento, altezza. La squadra deve trovare un passaggio o una scala; il valore 20 di per sé non si trasferisce al pavimento.
-
- accuracyXY=1 ti consente di finire entro una cella lungo ciascuna coordinata orizzontale. È adatta anche la cella diagonalmente adiacente.
-
- accuracyZ=2 consente altezze da 18 a 22 compreso. Una corrispondenza X/Y su un altro piano non è sufficiente per avere successo.
-
- running=true richiede esecuzione. Per camminare, sostituisci true con false.
-
- timeout=8000 limita l'attesa dopo l'inizio del percorso a otto secondi. Trascorso questo tempo, mentre il movimento è ancora in corso, il comando lo ferma e restituisce 0.
-
- maxSteps=100 limita il numero di cambiamenti di posizione osservati. Questo non è il numero esatto di quadrati attraversati; possono verificarsi più passaggi tra i sondaggi.
-
- avoidMobiles=true impedisce di passare attraverso i caratteri presi in considerazione nel calcolo del percorso.
-
- openDoors=true consente tentativi di aprire porte lungo il percorso. Questo flag non aggira una porta chiusa o le restrizioni del server.
- raggiunto riceve int 1 o 0 al termine della chiamata. se raggiunto == 1 esegue il ramo con successo; altrimenti gestisce il mancato raggiungimento dell'obiettivo senza ripetere all'infinito il comando.
- L'ultima riga stampa l'attuale X/Y/Z per il controllo. Se la procedura si interrompe, non verranno eseguite ulteriori righe, incluso questo output.
return RunScenario();
object? RunScenario()
{
var destinationX = 1279;
var destinationY = 540;
var destinationZ = 20;
var accuracyXY = 1;
var accuracyZ = 2;
dynamic running = true;
var timeout = 8000;
var maxSteps = 100;
dynamic avoidMobiles = true;
dynamic openDoors = true;
var reached = UO.MoveXYZ(destinationX, destinationY, destinationZ, accuracyXY, accuracyZ, running, timeout, maxSteps, avoidMobiles, openDoors);
if (Truth(reached == 1))
{
UO.Print("Destination reached");
}
else
{
UO.Print("Destination not reached; check the path and limits");
}
UO.Print("Position: " + Convert.ToString(UO.GetX()) + "," + Convert.ToString(UO.GetY()) + "," + Convert.ToString(UO.GetZ()));
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:
- x/y/z=1445/1690/0; accuracyXY=1, accuracyZ=3; running=true.
- timeout=5000, maxSteps=60 dei movimenti osservati, avoidMobiles=true e openDoors=false.
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 ok = UO.MoveXYZ(1445, 1690, 0, 1, 3, true, 5000, 60, true, false);
UO.Print("Result: " + Convert.ToString(ok));
return null;
}
}Parametri e flusso di esecuzione:
- Le righe con # sono commenti C#: vengono salvate durante la copia e non vengono eseguite. L'esempio contiene entrambe le parti necessarie: la funzione GoToPoint e la procedura eseguibile Main.
- Tutti e sei i parametri GoToPoint vengono passati a MoveXYZ senza modifiche. All'interno della funzione sono specificati quattro parametri aggiuntivi: 8000 ms, 100 cambiamenti di posizione osservati, spostamento dei caratteri e apertura della porta.
- Allo scopo sono adatti 1279/540/20 con tolleranze 1/2 X=1278..1280, Y=539..541, Z=18..22. Un punto ad un'altra quota oltre 18..22 non è considerato raggiunto.
- Questo è un wrapper attorno al comando reale e non una seconda implementazione del pathfinding nello script. Non chiama un GetPathArray extra e non attiva infiniti tentativi. Se non viene raggiunto, la procedura chiamante riceve 0 e sceglie un'ulteriore azione.
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.
var reached = GoToPoint(1279, 540, 20, 1, 2, true);
if (Truth(Truth(reached) == true))
{
UO.Print("Destination reached");
}
else
{
UO.Print("Destination not reached");
}
dynamic GoToPoint(dynamic x, dynamic y, dynamic z, dynamic accuracyXY, dynamic accuracyZ, dynamic running)
{
var timeout = 8000;
var maxSteps = 100;
dynamic avoidMobiles = true;
dynamic openDoors = true;
var reached = UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout, maxSteps, avoidMobiles, openDoors);
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: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(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(CompactMoveXYZ(values))
UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout) — UO.MoveXYZ(Any,Any,Any,Any,Any,Any,Any)
Parametri: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any), timeout (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(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(CompactMoveXYZ(values))
UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout, maxSteps) — UO.MoveXYZ(Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any), timeout (Any), maxSteps (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(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(CompactMoveXYZ(values))
UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout, maxSteps, avoidMobiles) — UO.MoveXYZ(Any,Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any), timeout (Any), maxSteps (Any), avoidMobiles (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(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(CompactMoveXYZ(values))
UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout, maxSteps, avoidMobiles, openDoors) — UO.MoveXYZ(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Parametri: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any), timeout (Any), maxSteps (Any), avoidMobiles (Any), openDoors (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(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(CompactMoveXYZ(values))Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.MoverStop();Interrompe il percorso automatico di Pathfinder.
Non ci sono parametri.
void - nessun valore restituito. Chiama su una linea separata; non è true/false o il numero di passi.
- Rimuove il movimento automatico locale. I passaggi già inviati e le conferme del server non vengono richiamati.
- Questo non è TerminateAll: l'esecuzione delle restanti righe di script e di altre procedure continua.
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.MoverStop");
UO.MoverStop();Parametri e flusso di esecuzione:
- Non ci sono argomenti.
- Il comando non restituisce un codice di successo.
UO.MoverStop();Parametri e flusso di esecuzione:
- Move() legge il movimento automatico.
- Print — messaggio di script locale; non è una conferma del server.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Move()))
{
UO.MoverStop();
UO.Print("Route stopped");
}
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:
- UO.Wait=100 ms consente al client di elaborare gli eventi successivi.
- Dopo l'arresto le coordinate vengono lette separatamente; il ritardo non garantisce la ricezione di tutti i riconoscimenti di rete.
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()
{
UO.MoverStop();
await Delay(100);
UO.Print(Convert.ToString(UO.GetX()) + "," + Convert.ToString(UO.GetY()));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}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.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.StopMoving:bridge.StopMoving().
Codice interno di implementazione; non è uno script autonomo.
case "moverstop": bridge.StopMoving(); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Moving();Controlla il movimento del tuo personaggio.
Non ci sono parametri.
int bool (1/0): 1 - Pathfinder automatico è attivo o ci sono ancora passaggi nella coda del personaggio; 0 - mancano entrambi oppure il personaggio non è caricato. Questa non è una conferma del raggiungimento di un obiettivo o del numero di passaggi.
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.
- I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
- C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
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.Moving();
UO.Print("Moving: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Le parentesi vuote leggono self. attivo — numero 1 o 0; Il testo del messaggio serve come esempio di elaborazione del ramo.
- 1 - il Pathfinder automatico è attivo o ci sono ancora dei passaggi nella coda del personaggio; 0 - mancano entrambi o il personaggio non è caricato. Questa non è una conferma del raggiungimento di un obiettivo o del numero di passaggi.
var active = UO.Moving();
if (Truth(active))
{
UO.Print("State is active");
}
else
{
UO.Print("State is inactive or unavailable");
}
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:
- Il comando non ha argomenti oggetto: anche dopo Exists(self), legge solo il proprio stato.
- Exists(self) controlla il carico del giocatore separatamente dal flag richiesto. Il mondo può cambiare tra un controllo e l'altro.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Exists("self")))
{
var state = UO.Moving();
UO.Print("State 1/0: " + Convert.ToString(state));
}
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:
- Le due chiamate senza argomenti leggono self; UO.Wait(500) - pausa per mezzo secondo.
- Vengono confrontate due istantanee di flag. Le transizioni tra le inquadrature possono essere saltate; non è un abbonamento a tutti gli eventi del server.
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 before = UO.Moving();
await Delay(500);
var after = UO.Moving();
if (Truth(before != after))
{
UO.Print("State changed from " + Convert.ToString(before) + " to " + 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;
}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.RegisterCharacterGetterAliases [Moving]. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsMoving:bridge.IsMoving().
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.
() => bridge.IsMoving()Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.
ClassicUO — Bad Newbie & C# Scripts IDE