Repository navigation
IT UO Topic targeting
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
Home · C# · IDE · UO API · A–Z · Esempi · Lingue
Risposta manuale con cursore target e risposta preimpostata WaitTarget. L'impostazione di un obiettivo previsto e l'esecuzione di un'azione sono operazioni separate.
| Argomento | Comandi e spiegazioni |
|---|---|
| Target | UO.Target |
| TargetID | UO.TargetID |
| TargetToObject | UO.TargetToObject |
| TargetToTile | UO.TargetToTile |
| TargetToXYZ | UO.TargetToXYZ |
| TargetByResource | UO.TargetByResource |
| WaitTarget | UO.WaitTarget |
| WaitTargetObject | UO.WaitTargetObject |
| WaitTargetType | UO.WaitTargetType |
| WaitTargetTile | UO.WaitTargetTile |
| WaitTargetXYZ | UO.WaitTargetXYZ |
| WaitTargetSelf | UO.WaitTargetSelf |
| LastTarget | UO.LastTarget |
| CancelTarget | UO.CancelTarget |
| Client Target Response | UO.ClientRequestObjectTarget · UO.ClientRequestTileTarget · UO.WaitForClientTargetResponse · UO.ClientTargetResponse |
UO.Target · UO.TargetID · UO.Targeting · UO.TargetPresent · UO.TargetToObject · UO.TargetToTile · UO.TargetToXYZ · UO.TargetByResource · UO.LastTarget · UO.LastTargetX · UO.LastTargetY · UO.LastTile · UO.TicksTarget
UO.WaitTarget · UO.WaitTargetObject · UO.WaitTargetType · UO.WaitTargetObjectType · UO.WaitTargetTile · UO.WaitTargetXYZ · UO.WaitTargetSelf · UO.WaitTargetGround · UO.WaitTargetLast · UO.WaitForTarget · UO.IsWaitTargetActive · UO.CancelTarget · UO.CancelWaitTarget
UO.ClientRequestObjectTarget · UO.ClientRequestTileTarget · UO.ClientTargetResponse · UO.ClientTargetResponsePresent · UO.WaitForClientTargetResponse
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
UO.CancelWaitTarget();
UO.WaitTargetObject("self");
UO.UseSkill("Anatomy");Parametri, risultato e tutti gli scenari
if (Truth(UO.TargetPresent()))
{
UO.TargetToXYZ(1445, 1690, 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.CancelTarget();Annulla il cursore attivo e cancella le risposte preparate del mirino.
Non ci sono parametri.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- Le risposte già inviate al server non vengono richiamate.
- La destinazione della richiamata locale viene annullata; Per una destinazione del server attiva, viene inviato un annullamento della destinazione.
- La coda è comune al client: il suo svuotamento vale per le risposte predisposte di tutte le procedure.
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.CancelTarget");
UO.CancelTarget();Parametri e flusso di esecuzione:
- Non ci sono argomenti.
- La risposta in sospeso a self viene eliminata.
UO.WaitTargetSelf();
UO.CancelTarget();Parametri e flusso di esecuzione:
- 1445/1690/0 è un esempio di un nuovo punto nel mondo.
- Le vecchie risposte vengono rimosse prima di impostare un nuovo obiettivo.
return RunScenario();
object? RunScenario()
{
UO.CancelTarget();
UO.WaitTargetXYZ(1445, 1690, 0);
return null;
}Parametri e flusso di esecuzione:
- UO.Wait=1000 ms è una limitazione di questo esempio.
- Viene controllata la coda rimanente, non il successo dell'abilità. Se non è presente il mirino del server, il successivo comando esterno non riceverà la vecchia risposta.
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.WaitTargetSelf();
UO.UseSkill("Anatomy");
await Delay(1000);
if (Truth(UO.IsWaitTargetActive()))
{
UO.CancelTarget();
}
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: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.CancelTarget. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetWaitTargetQueue:bridge.GetWaitTargetQueue(). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsTargeting:bridge.IsTargeting(). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CancelTarget:bridge.CancelTarget(). -
InjectionScript.Runtime.InjectionApiUO.SystemMessage:SystemMessage("Targeting cancelled").
Codice interno di implementazione; non è uno script autonomo.
public void CancelTarget()
{
var waitTargetQueue = bridge.GetWaitTargetQueue();
if (waitTargetQueue.Length > 0 || bridge.IsTargeting() != 0)
{
bridge.CancelTarget();
SystemMessage("Targeting cancelled");
}
else
SystemMessage("Error: no target to cancel");
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.CancelWaitTarget();Cancella le risposte del mirino preparate.
Non ci sono parametri.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- Le risposte già inviate al server non vengono richiamate.
- Il cursore aperto rimane attivo; può essere elaborato manualmente in seguito.
- La coda è comune al client: il suo svuotamento vale per le risposte predisposte di tutte le procedure.
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.CancelWaitTarget");
UO.CancelWaitTarget();Parametri e flusso di esecuzione:
- Non ci sono argomenti.
- La risposta in sospeso a self viene eliminata.
UO.WaitTargetSelf();
UO.CancelWaitTarget();Parametri e flusso di esecuzione:
- 1445/1690/0 è un esempio di un nuovo punto nel mondo.
- Le vecchie risposte vengono rimosse prima di impostare un nuovo obiettivo.
return RunScenario();
object? RunScenario()
{
UO.CancelWaitTarget();
UO.WaitTargetXYZ(1445, 1690, 0);
return null;
}Parametri e flusso di esecuzione:
- UO.Wait=1000 ms è una limitazione di questo esempio.
- Viene controllata la coda rimanente, non il successo dell'abilità. Se non è presente il mirino del server, il successivo comando esterno non riceverà la vecchia risposta.
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.WaitTargetSelf();
UO.UseSkill("Anatomy");
await Delay(1000);
if (Truth(UO.IsWaitTargetActive()))
{
UO.CancelWaitTarget();
}
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: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CancelWaitTarget:bridge.CancelWaitTarget().
Codice interno di implementazione; non è uno script autonomo.
case "cancelwaittarget": bridge.CancelWaitTarget(); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.ClientRequestObjectTarget();Apre un mirino locale per selezionare manualmente un oggetto o un personaggio.
Non ci sono parametri.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- Il risultato precedente di questo runtime viene reimpostato. Il comando ritorna immediatamente, senza attendere un clic.
- Il risultato viene letto ClientTargetResponse dopo WaitForClientTargetResponse o ClientTargetResponsePresent.
- L'interruzione di una procedura in esecuzione rimuove l'ambito ad essa appartenente nel frame più vicino. Se un'altra richiesta ha già sostituito il cursore, l'annullamento non viene influenzato.
- Non è possibile utilizzare contemporaneamente un mirino dell'interfaccia client per due selezioni manuali indipendenti. Non avviare una nuova richiesta finché quella precedente non è stata elaborata.
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.ClientRequestObjectTarget");
UO.ClientRequestObjectTarget();Parametri e flusso di esecuzione:
- 5000: timeout di attesa del clic in millisecondi. La nuova query reimposta il risultato precedente.
- Una serie di cinque campi indica l'oggetto selezionato. il risultato[0] è serial, non type.
UO.ClientRequestObjectTarget();
if (Truth(UO.WaitForClientTargetResponse(5000)))
{
var result = UO.ClientTargetResponse();
if (Truth(ArrayLength(result) == 5))
{
UO.Print("Serial: " + UO.Int2Hex(result[0]));
}
else
{
UO.Print("Selection cancelled");
}
}
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:
- CancelTarget annulla la selezione locale; la callback restituisce un risultato vuoto.
- ClientTargetResponsePresent restituisce 1, ma la lunghezza dell'array è 0. Non accedere al risultato[0] senza controllare la lunghezza.
return RunScenario();
object? RunScenario()
{
UO.ClientRequestObjectTarget();
UO.CancelTarget();
if (Truth(UO.ClientTargetResponsePresent()))
{
var result = UO.ClientTargetResponse();
UO.Print("Fields: " + Convert.ToString(ArrayLength(result)));
}
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 risposta contiene cinque campi; serial è nel risultato[0]. Timeout e cancellazione non producono un serial utilizzabile.
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.ClientRequestObjectTarget();
if (UO.WaitForClientTargetResponse(5000) == 0)
return false;
var result = UO.ClientTargetResponse();
if (((object? [])result).Length != 5 || Convert.ToInt32(result[0]) == 0)
return false;
UO.AddObject("selected_object", result[0]);
UO.Print($"Saved object: {UO.GetName(result[0])}");
return true;
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.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RequestClientTarget:bridge.RequestClientTarget(false).
Codice interno di implementazione; non è uno script autonomo.
case "clientrequestobjecttarget": bridge.RequestClientTarget(false); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.ClientRequestTileTarget();Apre un mirino locale per selezionare manualmente un punto/riquadro o un oggetto.
Non ci sono parametri.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- Il risultato precedente di questo runtime viene reimpostato. Il comando ritorna immediatamente, senza attendere un clic.
- Il risultato viene letto ClientTargetResponse dopo WaitForClientTargetResponse o ClientTargetResponsePresent.
- L'interruzione di una procedura in esecuzione rimuove l'ambito ad essa appartenente nel frame più vicino. Se un'altra richiesta ha già sostituito il cursore, l'annullamento non viene influenzato.
- Non è possibile utilizzare contemporaneamente un mirino dell'interfaccia client per due selezioni manuali indipendenti. Non avviare una nuova richiesta finché quella precedente non è stata elaborata.
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.ClientRequestTileTarget");
UO.ClientRequestTileTarget();Parametri e flusso di esecuzione:
- risultato[1] - graphic, risultato[2]/[3]/[4] - X/Y/Z. La tessera del mondo serial ha un risultato[0] pari a 0.
- Tipo, coordinate e serial sono campi separati. Non è presente alcun indice di livello statico in questo array.
UO.ClientRequestTileTarget();
if (Truth(UO.WaitForClientTargetResponse(5000)))
{
var result = UO.ClientTargetResponse();
if (Truth(ArrayLength(result) == 5))
{
UO.Print("Type: " + UO.Int2Hex(result[1]));
UO.Print(Convert.ToString(result[2]) + "," + Convert.ToString(result[3]) + "," + Convert.ToString(result[4]));
}
}
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:
- Per la cella, X/Y/Z si trovano nei campi 2/3/4. Stringhe di negozi globali; graphic e serial non sostituiscono le coordinate qui.
return RunScenario();
object? RunScenario()
{
UO.ClientRequestTileTarget();
if (UO.WaitForClientTargetResponse(5000) == 0)
return false;
var selection = (object? [])UO.ClientTargetResponse();
if (selection.Length != 5)
return false;
UO.SetGlobal("route.x", Convert.ToString(selection[2]));
UO.SetGlobal("route.y", Convert.ToString(selection[3]));
UO.SetGlobal("route.z", Convert.ToString(selection[4]));
return true;
return null;
}Parametri e flusso di esecuzione:
- CancelTarget sovrascrive il cursore locale. La presenza di una richiamata dopo l'annullamento non significa la presenza di una selezione andata a buon fine.
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.ClientRequestTileTarget();
await WaitAsync(1000);
UO.CancelTarget();
if (UO.ClientTargetResponsePresent() != 0)
{
var result = (object? [])UO.ClientTargetResponse();
UO.Print($"Response after cancel: {result.Length} fields");
}
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.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RequestClientTarget:bridge.RequestClientTarget(true).
Codice interno di implementazione; non è uno script autonomo.
case "clientrequesttiletarget": bridge.RequestClientTarget(true); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.ClientTargetResponse();Copia il risultato dell'ultimo ClientRequest* locale in un array.
Non ci sono parametri.
Matrice di cinque int: [0]=serial oggetto (0 vicino al suolo/statico), [1]=graphic/type, [2]=X, [3]=Y, [4]=Z. Viene restituito un array vuoto prima della selezione, dopo essere stato reimpostato da una nuova richiesta o in caso di annullamento o selezione inappropriata. Manca hue, mappa, indice del livello statico e attributo terreno/statico. Questo non è un oggetto con campi denominati.
- La lettura non consuma il risultato: può essere riletto. Il nuovo ClientRequest* lo sostituisce.
- Controlla sempre ArrayLength(risultato)=5 prima di accedere agli indici.
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.ClientTargetResponse();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- 5000: timeout di attesa del clic in millisecondi. La nuova query reimposta il risultato precedente.
- Una serie di cinque campi indica l'oggetto selezionato. il risultato[0] è serial, non type.
UO.ClientRequestObjectTarget();
if (Truth(UO.WaitForClientTargetResponse(5000)))
{
var result = UO.ClientTargetResponse();
if (Truth(ArrayLength(result) == 5))
{
UO.Print("Serial: " + UO.Int2Hex(result[0]));
}
else
{
UO.Print("Selection cancelled");
}
}
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:
- risultato[1] - graphic, risultato[2]/[3]/[4] - X/Y/Z. La tessera del mondo serial ha un risultato[0] pari a 0.
- Tipo, coordinate e serial sono campi separati. Non è presente alcun indice di livello statico in questo array.
return RunScenario();
object? RunScenario()
{
UO.ClientRequestTileTarget();
if (Truth(UO.WaitForClientTargetResponse(5000)))
{
var result = UO.ClientTargetResponse();
if (Truth(ArrayLength(result) == 5))
{
UO.Print("Type: " + UO.Int2Hex(result[1]));
UO.Print(Convert.ToString(result[2]) + "," + Convert.ToString(result[3]) + "," + Convert.ToString(result[4]));
}
}
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:
- CancelTarget annulla la selezione locale; la callback restituisce un risultato vuoto.
- ClientTargetResponsePresent restituisce 1, ma la lunghezza dell'array è 0. Non accedere al risultato[0] senza controllare la lunghezza.
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.ClientRequestObjectTarget();
UO.CancelTarget();
if (Truth(UO.ClientTargetResponsePresent()))
{
var result = UO.ClientTargetResponse();
UO.Print("Fields: " + Convert.ToString(ArrayLength(result)));
}
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: Nessun parametro.
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClientTargetResponse:bridge.ClientTargetResponse().
Codice interno di implementazione; non è uno script autonomo.
case "clienttargetresponse":
return new InjectionValue(bridge.ClientTargetResponse().Select(value => new InjectionValue(value)).ToArray());Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.ClientTargetResponsePresent();Controlla se è stata ricevuta una risposta all'ultima richiesta di selezione locale.
Non ci sono parametri.
int 1 — la richiamata ha già risposto, inclusa la cancellazione; 0 - la nuova selezione non è stata ancora completata. Il valore 1 non garantisce l'esistenza dell'oggetto: quando cancellato, ClientTargetResponse restituisce un Array vuoto.
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.
- Non indica la presenza di un server visibile e non descrive la coda WaitTarget.
- La lettura del risultato non reimposta questo flag; viene resettato al successivo ClientRequest*.
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.ClientTargetResponsePresent();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- CancelTarget annulla la selezione locale; la callback restituisce un risultato vuoto.
- ClientTargetResponsePresent restituisce 1, ma la lunghezza dell'array è 0. Non accedere al risultato[0] senza controllare la lunghezza.
UO.ClientRequestObjectTarget();
UO.CancelTarget();
if (Truth(UO.ClientTargetResponsePresent()))
{
var result = UO.ClientTargetResponse();
UO.Print("Fields: " + Convert.ToString(ArrayLength(result)));
}
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:
- Vengono controllati sia la disponibilità della risposta che il suo contenuto. L'attributo 1 non è l'oggetto serial.
return RunScenario();
object? RunScenario()
{
UO.ClientRequestObjectTarget();
if (UO.WaitForClientTargetResponse(5000) == 0)
return false;
if (UO.ClientTargetResponsePresent() == 0)
return false;
var response = (object? [])UO.ClientTargetResponse();
return response.Length == 5 && Convert.ToInt32(response[0]) != 0;
return null;
}Parametri e flusso di esecuzione:
- Il polling è limitato a cinque secondi. Se non c'è risposta il cursore viene cancellato; I campi X/Y/Z vengono letti solo dalla risposta completa.
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.ClientRequestTileTarget();
for (int attempt = 0; attempt < 50; attempt++)
{
if (UO.ClientTargetResponsePresent() != 0)
{
var response = (object? [])UO.ClientTargetResponse();
if (response.Length == 5)
UO.Print($"Selected tile: {response[2]},{response[3]},{response[4]}");
return null;
}
await WaitAsync(100);
}
UO.CancelTarget();
UO.Print("Selection timed out");
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. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClientTargetResponsePresent:bridge.ClientTargetResponsePresent().
Codice interno di implementazione; non è uno script autonomo.
case "clienttargetresponsepresent": return new InjectionValue(bridge.ClientTargetResponsePresent());Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.IsWaitTargetActive();Controlla se le risposte preparate rimangono nella coda di destinazione.
Non ci sono parametri.
int 1 - c'è un bersaglio differito non cancellato di un oggetto, tessera o cancellazione della vista successiva; 0 - la coda è vuota. Non ha un cursore aperto; per il cursore utilizzare TargetPresent/Targeting.
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 letta l'intera coda del client. Se più procedure sono in esecuzione contemporaneamente, vengono prese in considerazione le risposte di ciascuna di esse.
- Zero significa solo che non c'è alcuna risposta in sospeso. Non conferma l'uso riuscito di un'abilità o di un incantesimo sul server.
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.IsWaitTargetActive();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Dopo WaitTargetSelf e prima è previsto il server di destinazione 1.
- CancelWaitTarget cancella la coda; il test successivo dà 0.
UO.WaitTargetSelf();
UO.Print(Convert.ToString(UO.IsWaitTargetActive()));
UO.CancelWaitTarget();Parametri e flusso di esecuzione:
- Il controllo non ha parametri. UO.Wait=50 ms, aspettative massime di 20.
- Se la risposta rimane, viene annullata. Aggiungi un controllo separato per il risultato dell'azione del server.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var attempts = 0;
while (Truth(UO.IsWaitTargetActive()) && Truth(attempts < 20))
{
await Delay(50);
attempts = attempts + 1;
}
if (Truth(UO.IsWaitTargetActive()))
{
UO.CancelWaitTarget();
}
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:
- La prima riga mostra le risposte differite, la seconda lo stato della vista.
- Sono possibili una coda senza cursore e un cursore senza coda; questi valori non sono intercambiabili.
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.Print("Queued: " + Convert.ToString(UO.IsWaitTargetActive()));
UO.Print("Cursor: " + Convert.ToString(UO.TargetPresent()));
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.Waiting:Waiting().
Codice interno di implementazione; non è uno script autonomo.
case "iswaittargetactive": return new InjectionValue(Waiting());Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.LastTarget();Legge serial dell'ultimo oggetto target salvato.
Non ci sono parametri.
int - serial/ID, non type e non bool. 0 indica l'assenza di un oggetto-obiettivo; anche terra e statica hanno serial 0, sebbene le coordinate possano essere memorizzate. Tutti i bit 32 vengono mantenuti. Per verificare la presenza di un ID diverso da zero, utilizzare != 0, non > 0 o == true.
- Nessun parametro. Non accende il mirino, non seleziona un nuovo bersaglio, non attacca né invia pacchetti. LastTarget è diverso da LastAttack e LastStatus. La scelta normale self non sostituisce l'ultimo bersaglio; un ClientMarkChar esplicito può cambiarlo.
- A SetEntity vengono conservate le Entità conosciute.X/Y; per un articolo in un contenitore, queste potrebbero essere le coordinate del contenuto. SetLand/SetStatic salva il mondo X/Y del punto selezionato. Il successivo spostamento/rimozione dell'oggetto non modifica le coordinate salvate. Per la posizione attuale usa GetX/GetY(serial).
- Registrazione chiara e World.Clear, anche quando gli script vengono salvati. L'ignoto serial in un contesto esplicito non eredita i precedenti X/Y: diventano 0. Ciò non garantisce che la destinazione esista sul server.
- Leggere serial e X/Y con comandi separati non è atomico. Per l'oggetto target LastTile memorizza la rete X/Y=65535; questa non è una posizione dell'oggetto salvata. Per terra/statico LastTile(1)/(2) leggi selezionato X/Y. lasttarget senza parentesi è un valore live integrato a meno che non venga sovrascritto da una variabile.
- Chiamate World.Clear ClearWorldState: reimposta la richiamata attiva, la destinazione salvata e il pacchetto di riproduzione. Un normale ripristino salva la cronologia. Interno TargetLast invia il pacchetto memorizzato solo al server di destinazione attivo; senza cronologia o per una richiamata locale, non invia nulla e salva la destinazione. Una richiamata del client attivo riceve null una volta come annullamento: ClientTargetResponsePresent diventa 1 quando la risposta è vuota. Una selezione completata non viene nuovamente notificata.
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.LastTarget();
UO.Print("LastTarget: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- valore è l'unico risultato del comando; HEX mostra ID, Converti.ToString è la coordinata. La chiamata non seleziona nulla.
var value = UO.LastTarget();
UO.Print("Saved value: " + Hex(value));
string Hex(object? value) => Convert.ToInt64(value).ToString("X");Parametri e flusso di esecuzione:
- id: salvato serial. Exists verifica la presenza di un oggetto prima di GetX/GetY. Le coordinate salvate e quelle attuali potrebbero differire. Con serial=0 l'esempio stampa il punto selezionato, ma 0 stesso non prova che il punto sia stato selezionato.
return RunScenario();
object? RunScenario()
{
var id = UO.LastTarget();
var x = UO.LastTargetX();
var y = UO.LastTargetY();
UO.Print("Saved XY: " + Convert.ToString(x) + "," + Convert.ToString(y));
if (Truth(id != 0) && Truth(UO.Exists(id)))
{
UO.Print("Live XY: " + Convert.ToString(UO.GetX(id)) + "," + Convert.ToString(UO.GetY(id)));
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- minimo/massimo specifica l'intervallo accettabile del risultato dell'assistente, non i parametri API. L'assistente è completamente definito; -1 è il segnale di uscita dal raggio d'azione. Per ID, il controllo memorizza qualsiasi serial diverso da zero, incluso il bit più significativo, anziché l'intervallo.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var value = ReadTargetValue();
UO.Print("Checked value: " + Convert.ToString(value));
return null;
}
dynamic ReadTargetValue()
{
var value = UO.LastTarget();
if (Truth(value == 0))
{
return -1;
}
return value;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTarget:bridge.LastTarget.
Codice interno di implementazione; non è uno script autonomo.
case "lasttarget": return new InjectionValue(bridge.LastTarget);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.LastTargetX();Legge la coordinata X salvata quando è stato selezionato l'ultimo target.
Non ci sono parametri.
int è la coordinata X salvata, non un pixel dello schermo. Prima/dopo Cancella o per un oggetto sconosciuto - 0; è accettabile anche la coordinata reale 0. Non è bool. Per terra/statico funziona anche con LastTarget()=0.
- Nessun parametro. Non accende il mirino, non seleziona un nuovo bersaglio, non attacca né invia pacchetti. LastTarget è diverso da LastAttack e LastStatus. La scelta normale self non sostituisce l'ultimo bersaglio; un ClientMarkChar esplicito può cambiarlo.
- A SetEntity vengono conservate le Entità conosciute.X/Y; per un articolo in un contenitore, queste potrebbero essere le coordinate del contenuto. SetLand/SetStatic salva il mondo X/Y del punto selezionato. Il successivo spostamento/rimozione dell'oggetto non modifica le coordinate salvate. Per la posizione attuale usa GetX/GetY(serial).
- Registrazione chiara e World.Clear, anche quando gli script vengono salvati. L'ignoto serial in un contesto esplicito non eredita i precedenti X/Y: diventano 0. Ciò non garantisce che la destinazione esista sul server.
- Leggere serial e X/Y con comandi separati non è atomico. Per l'oggetto target LastTile memorizza la rete X/Y=65535; questa non è una posizione dell'oggetto salvata. Per terra/statico LastTile(1)/(2) leggi selezionato X/Y. lasttarget senza parentesi è un valore live integrato a meno che non venga sovrascritto da una variabile.
- Chiamate World.Clear ClearWorldState: reimposta la richiamata attiva, la destinazione salvata e il pacchetto di riproduzione. Un normale ripristino salva la cronologia. Interno TargetLast invia il pacchetto memorizzato solo al server di destinazione attivo; senza cronologia o per una richiamata locale, non invia nulla e salva la destinazione. Una richiamata del client attivo riceve null una volta come annullamento: ClientTargetResponsePresent diventa 1 quando la risposta è vuota. Una selezione completata non viene nuovamente notificata.
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.LastTargetX();
UO.Print("LastTargetX: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- valore è l'unico risultato del comando; HEX mostra ID, Converti.ToString è la coordinata. La chiamata non seleziona nulla.
var value = UO.LastTargetX();
UO.Print("Saved value: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- id: salvato serial. Exists verifica la presenza di un oggetto prima di GetX/GetY. Le coordinate salvate e quelle attuali potrebbero differire. Con serial=0 l'esempio stampa il punto selezionato, ma 0 stesso non prova che il punto sia stato selezionato.
return RunScenario();
object? RunScenario()
{
var id = UO.LastTarget();
var x = UO.LastTargetX();
var y = UO.LastTargetY();
UO.Print("Saved XY: " + Convert.ToString(x) + "," + Convert.ToString(y));
if (Truth(id != 0) && Truth(UO.Exists(id)))
{
UO.Print("Live XY: " + Convert.ToString(UO.GetX(id)) + "," + Convert.ToString(UO.GetY(id)));
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- minimo/massimo specifica l'intervallo accettabile del risultato dell'assistente, non i parametri API. L'assistente è completamente definito; -1 è il segnale di uscita dal raggio d'azione. Per ID, il controllo memorizza qualsiasi serial diverso da zero, incluso il bit più significativo, anziché l'intervallo.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var value = ReadTargetValue(0, 65535);
UO.Print("Checked value: " + Convert.ToString(value));
return null;
}
dynamic ReadTargetValue(dynamic minimum, dynamic maximum)
{
var value = UO.LastTargetX();
if (Truth(value < minimum) || Truth(value > maximum))
{
return -1;
}
return value;
}
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.LastTargetX. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX:bridge.GetX(bridge.LastTarget). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTarget:bridge.LastTarget.
Codice interno di implementazione; non è uno script autonomo.
public int LastTargetX() => bridge is ITargetSnapshotBridge snapshot ? snapshot.LastTargetX : bridge.GetX(bridge.LastTarget);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.LastTargetY();Legge la coordinata Y salvata quando è stato selezionato l'ultimo target.
Non ci sono parametri.
int è la coordinata Y salvata, non un pixel dello schermo. Prima/dopo Cancella o per un oggetto sconosciuto - 0; è accettabile anche la coordinata reale 0. Non è bool. Per terra/statico funziona anche con LastTarget()=0.
- Nessun parametro. Non accende il mirino, non seleziona un nuovo bersaglio, non attacca né invia pacchetti. LastTarget è diverso da LastAttack e LastStatus. La scelta normale self non sostituisce l'ultimo bersaglio; un ClientMarkChar esplicito può cambiarlo.
- A SetEntity vengono conservate le Entità conosciute.X/Y; per un articolo in un contenitore, queste potrebbero essere le coordinate del contenuto. SetLand/SetStatic salva il mondo X/Y del punto selezionato. Il successivo spostamento/rimozione dell'oggetto non modifica le coordinate salvate. Per la posizione attuale usa GetX/GetY(serial).
- Registrazione chiara e World.Clear, anche quando gli script vengono salvati. L'ignoto serial in un contesto esplicito non eredita i precedenti X/Y: diventano 0. Ciò non garantisce che la destinazione esista sul server.
- Leggere serial e X/Y con comandi separati non è atomico. Per l'oggetto target LastTile memorizza la rete X/Y=65535; questa non è una posizione dell'oggetto salvata. Per terra/statico LastTile(1)/(2) leggi selezionato X/Y. lasttarget senza parentesi è un valore live integrato a meno che non venga sovrascritto da una variabile.
- Chiamate World.Clear ClearWorldState: reimposta la richiamata attiva, la destinazione salvata e il pacchetto di riproduzione. Un normale ripristino salva la cronologia. Interno TargetLast invia il pacchetto memorizzato solo al server di destinazione attivo; senza cronologia o per una richiamata locale, non invia nulla e salva la destinazione. Una richiamata del client attivo riceve null una volta come annullamento: ClientTargetResponsePresent diventa 1 quando la risposta è vuota. Una selezione completata non viene nuovamente notificata.
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.LastTargetY();
UO.Print("LastTargetY: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- valore è l'unico risultato del comando; HEX mostra ID, Converti.ToString è la coordinata. La chiamata non seleziona nulla.
var value = UO.LastTargetY();
UO.Print("Saved value: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- id: salvato serial. Exists verifica la presenza di un oggetto prima di GetX/GetY. Le coordinate salvate e quelle attuali potrebbero differire. Con serial=0 l'esempio stampa il punto selezionato, ma 0 stesso non prova che il punto sia stato selezionato.
return RunScenario();
object? RunScenario()
{
var id = UO.LastTarget();
var x = UO.LastTargetX();
var y = UO.LastTargetY();
UO.Print("Saved XY: " + Convert.ToString(x) + "," + Convert.ToString(y));
if (Truth(id != 0) && Truth(UO.Exists(id)))
{
UO.Print("Live XY: " + Convert.ToString(UO.GetX(id)) + "," + Convert.ToString(UO.GetY(id)));
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- minimo/massimo specifica l'intervallo accettabile del risultato dell'assistente, non i parametri API. L'assistente è completamente definito; -1 è il segnale di uscita dal raggio d'azione. Per ID, il controllo memorizza qualsiasi serial diverso da zero, incluso il bit più significativo, anziché l'intervallo.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var value = ReadTargetValue(0, 65535);
UO.Print("Checked value: " + Convert.ToString(value));
return null;
}
dynamic ReadTargetValue(dynamic minimum, dynamic maximum)
{
var value = UO.LastTargetY();
if (Truth(value < minimum) || Truth(value > maximum))
{
return -1;
}
return value;
}
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.LastTargetY. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY:bridge.GetY(bridge.LastTarget). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTarget:bridge.LastTarget.
Codice interno di implementazione; non è uno script autonomo.
public int LastTargetY() => bridge is ITargetSnapshotBridge snapshot ? snapshot.LastTargetY : bridge.GetY(bridge.LastTarget);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
string UO.LastTile();
int UO.LastTile(object? index);Legge l'ultima destinazione riquadro salvata.
-
index- Opzionale int 0..3: 0=graphic, 1=X, 2=Y, 3=Z. Fuori portata - 0. Senza indice, viene restituita la riga dell'intero record.
Senza argomenti string "graphic X Y Z" con campi decimali; con indice - int di un campo. La voce mancante/breve è riempita con zeri.
- NormalizeLastTile completa i campi mancanti fino a quattro. La riga non contiene map/hue/serial. Il valore 0 può significare un reale graphic/coordinata o nessun campo.
- Il comando legge solo la destinazione del riquadro salvato; non crea una destinazione né seleziona una nuova cella. WaitTargetTile("lasttile") utilizza un controllo di presenza del record separato.
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.LastTile();
UO.Print("LastTile: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Legge l'ultima destinazione riquadro salvata.
UO.Print(UO.LastTile());Parametri e flusso di esecuzione:
- NormalizeLastTile completa i campi mancanti fino a quattro. La riga non contiene map/hue/serial. Il valore 0 può significare un reale graphic/coordinata o nessun campo.
return RunScenario();
object? RunScenario()
{
UO.Print(UO.LastTile(1));
UO.Print(UO.LastTile(2));
UO.Print(UO.LastTile(3));
return null;
}Parametri e flusso di esecuzione:
- Il comando legge solo la destinazione del riquadro salvato; non crea una destinazione né seleziona una nuova cella. WaitTargetTile("lasttile") utilizza un controllo di presenza del record separato.
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 graphic = UO.LastTile(0);
var x = UO.LastTile(1);
var y = UO.LastTile(2);
var z = UO.LastTile(3);
UO.Print(Convert.ToString(graphic) + " " + Convert.ToString(x) + " " + Convert.ToString(y) + " " + Convert.ToString(z));
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: string / String.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.LastTile. -
InjectionScript.Runtime.InjectionApiUO.NormalizeLastTile:NormalizeLastTile(bridge.LastTile()). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTile:bridge.LastTile().
Codice interno di implementazione; non è uno script autonomo.
public string LastTile()
{
int[] tileInfo = NormalizeLastTile(bridge.LastTile());
return $"{tileInfo[0]} {tileInfo[1]} {tileInfo[2]} {tileInfo[3]}";
}Parametri: index (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.LastTile. -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(index). -
InjectionScript.Runtime.InjectionApiUO.NormalizeLastTile:NormalizeLastTile(bridge?.LastTile()).
Codice interno di implementazione; non è uno script autonomo.
public int LastTile(InjectionValue index)
{
var i = NumberConversions.ToInt(index);
if (i < 0 || i > 3)
return 0;
return NormalizeLastTile(bridge?.LastTile())[i];
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.Target();
void UO.Target(object? @object);
void UO.Target(object? targetKey, object? target);
void UO.Target(object? targetKey, object? target, object? targetType, object? @type, object? x, object? y, object? z);Annulla/imposta la destinazione prevista o invia un pacchetto destinazione esplicito.
-
object— Un argomento: serial/alias viene inserito in WaitTargetObject. Senza argomenti - CancelTarget. -
targetKey— Nelle forme 2/7 degli argomenti int della query di destinazione ID, solitamente UO.TargetID(). Viene passato direttamente nel pacchetto e non è necessario premere un tasto. -
target- Modulo 2: serial/alias o "lasttile". Forma 7: oggetto serial; "ground" lascia serial=0. - Solo modulo
targetType- 7: tipo di protocollo target, solitamente oggetto 0, riquadro 1. Ridotto a byte. - Solo forma
type- 7: graphic e coordinate mondiali per tessera/oggetto sconosciuto; graphic/X/Y vengono ridotti a ushort, da Z a sbyte. Per un bridge di entità noto, li sostituisce con i campi dell'entità effettivi. - Solo forma
x- 7: graphic e coordinate mondiali per tessera/oggetto sconosciuto; graphic/X/Y vengono ridotti a ushort, da Z a sbyte. Per un bridge di entità noto, li sostituisce con i campi dell'entità effettivi. - Solo forma
y- 7: graphic e coordinate mondiali per tessera/oggetto sconosciuto; graphic/X/Y vengono ridotti a ushort, da Z a sbyte. Per un bridge di entità noto, li sostituisce con i campi dell'entità effettivi. - Solo forma
z- 7: graphic e coordinate mondiali per tessera/oggetto sconosciuto; graphic/X/Y vengono ridotti a ushort, da Z a sbyte. Per un bridge di entità noto, li sostituisce con i campi dell'entità effettivi.
void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.
- I moduli senza/uno argomento vanno avanti ExecuteLegacyManualAlias e controllano la coda. I moduli 2/7 chiamano Target direttamente e inviano Send_TargetObject, non la coda del target successivo.
- Nella forma 2, "lasttile" prende il graphic/X/Y/Z della tessera bersaglio memorizzata; la sua assenza visualizza un messaggio. Anche un alias di oggetto sconosciuto visualizza un messaggio. La forma 7 con targetType=0 tenta di risolvere serial; gli altri tipi lasciano serial=0.
- Bridge.Target non controlla il cursore/corrispondenza attivo targetKey; passare la corrente ID. Non utilizzare la vecchia chiave della richiesta precedente. La chiamata non attende di essere accettata dal server.
- Le forme esplicite degli argomenti 2/7 inviano il pacchetto direttamente: il negativo serial diventa 0, targetKey viene ridotto a uint; questo ramo non cancella il cursore/coda locale né aggiorna TicksTarget. TargetToObject/TargetToTile utilizza un percorso diverso per l'obiettivo attivo del cliente.
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.Target");
UO.Target();Parametri e flusso di esecuzione:
- Annulla/imposta la destinazione prevista o invia un pacchetto destinazione esplicito.
UO.Target("self");
UO.Print(UO.Waiting());
UO.Target();Parametri e flusso di esecuzione:
- I moduli senza/uno argomento vanno avanti ExecuteLegacyManualAlias e controllano la coda. I moduli 2/7 chiamano Target direttamente e inviano Send_TargetObject, non la coda del target successivo.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.TargetPresent()))
{
UO.Target(UO.TargetID(), "self");
}
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:
- Bridge.Target non controlla il cursore/corrispondenza attivo targetKey; passare la corrente ID. Non utilizzare la vecchia chiave della richiesta precedente. La chiamata non attende di essere accettata 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.TargetPresent()))
{
UO.Target(UO.TargetID(), "ground", 1, 0, UO.GetX(), UO.GetY(), 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;
}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.WaitTargetObject:WaitTargetObject(arguments[0].ToString()). -
InjectionScript.Runtime.InjectionValue.ToString:arguments[0].ToString(). -
InjectionScript.Runtime.InjectionApiUO.CancelTarget:CancelTarget().
Codice interno di implementazione; non è uno script autonomo.
case "target":
if (arguments.Length > 0) WaitTargetObject(arguments[0].ToString());
else CancelTarget();
break;Parametri: object (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetObject:WaitTargetObject(arguments[0].ToString()). -
InjectionScript.Runtime.InjectionValue.ToString:arguments[0].ToString(). -
InjectionScript.Runtime.InjectionApiUO.CancelTarget:CancelTarget().
Codice interno di implementazione; non è uno script autonomo.
case "target":
if (arguments.Length > 0) WaitTargetObject(arguments[0].ToString());
else CancelTarget();
break;Parametri: targetKey (Any), target (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Target. -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(targetKey). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTile:bridge.LastTile(). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Target:bridge.Target(key, 0, 1, tile[0], tile[1], tile[2], tile[3]). -
InjectionScript.Runtime.InjectionApiUO.SystemMessage:SystemMessage("UO.Target: lasttile is unavailable"). -
InjectionScript.Runtime.InjectionApiUO.TryGetObject:TryGetObject(target, out int serial).
Codice interno di implementazione; non è uno script autonomo.
public void Target(InjectionValue targetKey, InjectionValue target)
{
int key = NumberConversions.ToInt(targetKey);
string selector = target.Kind == InjectionValueKind.String ? target.String : string.Empty;
if (selector.Equals("lasttile", StringComparison.OrdinalIgnoreCase))
{
int[] tile = bridge.LastTile() ?? Array.Empty<int>();
if (tile.Length >= 4)
bridge.Target(key, 0, 1, tile[0], tile[1], tile[2], tile[3]);
else
SystemMessage("UO.Target: lasttile is unavailable");
return;
}
if (TryGetObject(target, out int serial))
bridge.Target(key, serial, 0, 0, 0, 0, 0);
else
SystemMessage($"UO.Target: invalid target '{selector}'");
}Parametri: targetKey (Any), target (Any), targetType (Any), type (Any), x (Any), y (Any), z (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Target. -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(targetType). -
InjectionScript.Runtime.InjectionApiUO.TryGetObject:TryGetObject(target, out serial). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Target:bridge.Target ( NumberConversions.ToInt(targetKey), serial, targetTypeValue, ResolveType(type), NumberConversions.ToInt(x), NumberConversions.ToInt(y), NumberConversions.ToInt(z) ). -
InjectionScript.Runtime.InjectionApiUO.ResolveType:ResolveType(type).
Codice interno di implementazione; non è uno script autonomo.
public void Target
(
InjectionValue targetKey,
InjectionValue target,
InjectionValue targetType,
InjectionValue type,
InjectionValue x,
InjectionValue y,
InjectionValue z
)
{
int targetTypeValue = NumberConversions.ToInt(targetType);
string selector = target.Kind == InjectionValueKind.String ? target.String : string.Empty;
int serial = 0;
if (targetTypeValue == 0 && !selector.Equals("ground", StringComparison.OrdinalIgnoreCase))
TryGetObject(target, out serial);
bridge.Target
(
NumberConversions.ToInt(targetKey),
serial,
targetTypeValue,
ResolveType(type),
NumberConversions.ToInt(x),
NumberConversions.ToInt(y),
NumberConversions.ToInt(z)
);
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.TargetByResource(object? objID, object? resource);Cerca un oggetto in graphic, prepara un determinato bersaglio e utilizza l'oggetto trovato.
-
objID— Oggetto seriale/ID: int, stringa numerica/esadecimale o alias stabilito, ad esempio "lasttarget". Questo non è graphic/type. Controllare l'oggetto caricato prima di agire. -
resource— Elemento grafico/type da cercare, ResolveType consentito; questo non è il numero del campo risorsa di Pascal API.
void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.
- In questa implementazione, FindType(ResolveType(Resource), -1, 0, -1, true) cerca un elemento. Se trovato != 0, primo bridge.WaitTargetObject(ObjID), poi bridge.UseObject(trovato).
- Non è stato trovato nulla: nulla è installato o utilizzato. Il comando non invia un pacchetto destinazione-risorsa separato; scope=0 seleziona gli oggetti con RootContainer=Player.Serial, inclusi i contenuti/equipaggiamenti dell'inventario; recursive=true viene passato al bridge, ma questo ramo scope0 stesso utilizza RootContainer.
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.TargetByResource");
UO.TargetByResource("self", "0x0E21");Parametri e flusso di esecuzione:
- Cerca un oggetto in graphic, prepara un determinato bersaglio e utilizza l'oggetto trovato.
UO.TargetByResource("self", "0x0E21");Parametri e flusso di esecuzione:
- In questa implementazione, FindType(ResolveType(Resource), -1, 0, -1, true) cerca un elemento. Se trovato != 0, primo bridge.WaitTargetObject(ObjID), poi bridge.UseObject(trovato).
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Exists("lasttarget")))
{
UO.TargetByResource("lasttarget", "0x0E21");
}
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:
- Non è stato trovato nulla: nulla è installato o utilizzato. Il comando non invia un pacchetto destinazione-risorsa separato; scope=0 seleziona gli oggetti con RootContainer=Player.Serial, inclusi i contenuti/equipaggiamenti dell'inventario; recursive=true viene passato al bridge, ma questo ramo scope0 stesso utilizza RootContainer.
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.TargetByResource("self", "0x0E21");
UO.Print(UO.Waiting());
UO.CancelWaitTarget();
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: objID (Any), resource (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FindType:bridge.FindType(ResolveType(arguments[1]), -1, 0, -1, true). -
InjectionScript.Runtime.InjectionApiUO.ResolveType:ResolveType(arguments[1]). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitTargetObject:bridge.WaitTargetObject(Arg(0)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.UseObject:bridge.UseObject(found).
Codice interno di implementazione; non è uno script autonomo.
case "targetbyresource":
{
int found = bridge.FindType(ResolveType(arguments[1]), -1, 0, -1, true);
if (found != 0) { bridge.WaitTargetObject(Arg(0)); bridge.UseObject(found); }
return InjectionValue.Unit;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.TargetID();Legge l'ID del cursore di destinazione corrente.
Non ci sono parametri.
int - 32 bit ID del cursore, non serial dell'ultimo oggetto. Se non è presente alcun cursore, viene restituito 0. Se è impostato il bit più significativo, int è negativo; Int2Hex salva i suoi bit. Il reale cursorID=0 e l'ambito locale possono anche dare 0: controlla TargetPresent per l'attività. In questo client, la speciale sostituzione non nulla per il null ID non viene utilizzata.
- LastTarget/GetSerial("lasttarget") si riferisce all'oggetto selezionato, TargetID si riferisce alla richiesta di destinazione. Questi valori non possono essere sostituiti tra loro.
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.TargetID();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Non ci sono argomenti.
- Int2Hex ti permette di vedere tutti i bit di ID, incluso il bit più significativo.
if (Truth(UO.TargetPresent()))
{
UO.Print(UO.Int2Hex(UO.TargetID()));
}
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:
- cursore — ID del mirino, object — serial dell'oggetto.
- In TargetToObject, viene passato object, non il cursore.
return RunScenario();
object? RunScenario()
{
var cursor = UO.TargetID();
var targetSerial = UO.GetSerial("lasttarget");
UO.Print("Cursor: " + UO.Int2Hex(cursor));
UO.Print("Object: " + targetSerial);
return null;
}Parametri e flusso di esecuzione:
- 1000: timeout di attesa in millisecondi.
- Il segno dell'occorrenza è il risultato WaitForTarget; Per questo il segno del cursore non viene controllato.
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.WaitForTarget(1000)))
{
var cursor = UO.TargetID();
UO.Print("Request: " + UO.Int2Hex(cursor));
}
else
{
UO.Print("No cursor arrived");
}
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:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetTargetCursorId:bridge.GetTargetCursorId().
Codice interno di implementazione; non è uno script autonomo.
case "targetid": return new InjectionValue(bridge.GetTargetCursorId());Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.TargetPresent();Verifica la presenza di un cursore di selezione della destinazione attivo nel client.
Non ci sono parametri.
int 1 - TargetManager.IsTargeting installato; 0 - nessun cursore attivo. Viene presa in considerazione anche la destinazione della richiamata locale. Questo non è serial o lo stato della coda WaitTarget.
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.
- Legge lo stato una volta; non attende la visualizzazione del cursore.
- Per attendere il mirino del server dopo un'azione di gioco, usa WaitForTarget. Per il risultato del locale ClientRequest* - WaitForClientTargetResponse.
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.TargetPresent();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Non ci sono argomenti.
- Viene visualizzato 1 o 0.
UO.Print(Convert.ToString(UO.TargetPresent()));Parametri e flusso di esecuzione:
- La condizione è controllata dal cursore attivo.
- CancelTarget in questo client cancella anche le risposte preparate.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.TargetPresent()))
{
UO.CancelTarget();
}
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:
- UseSkill richiede la capacità, WaitForTarget attende fino a 3000 ms.
- TargetToObject risponde solo al target del server attivo; Se c'è un timeout, il ramo non viene eseguito.
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.UseSkill("Anatomy");
if (Truth(UO.WaitForTarget(3000)))
{
if (Truth(UO.TargetPresent()))
{
UO.TargetToObject("self");
}
}
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:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.IsTargeting:IsTargeting().
Codice interno di implementazione; non è uno script autonomo.
case "targetpresent": return new InjectionValue(IsTargeting());Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.TargetToObject(object? objID);Risponde immediatamente a un oggetto serial di destinazione del server già attivo.
-
objID— Numero seriale/ID di un elemento o carattere, numero o stringa esadecimale/decimale, self/backpack/lasttarget/lastobject o nome salvato AddObject. Questo non è type. Prima di agire su un oggetto con nome, controlla Exists; un alias non risolto dà serial 0.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- Senza un cursore del server attivo, non fa nulla e non crea una risposta differita. Per la preparazione preliminare, utilizzare WaitTargetObject/WaitTargetTile/WaitTargetXYZ.
- Il ClientRequest* locale e altri punti di richiamata non vengono elaborati da questo comando.
- Il server determina se la destinazione è valida. Per una memoria esaurita serial, ID viene inviato con zero campi grafici/coordinate.
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.TargetToObject");
UO.TargetToObject("self");Parametri e flusso di esecuzione:
- I parametri definiscono il carattere stesso.
- Non viene aggiunto nulla alla coda dell'ambito futuro.
if (Truth(UO.TargetPresent()))
{
UO.TargetToObject("self");
}
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:
- 3000 — attesa massima in millisecondi; L'azione che ha richiesto la vista deve essere eseguita in precedenza.
- Il comando viene chiamato solo dopo la comparsa della vista; l'azione di gioco potrebbe quindi terminare con un guasto del server.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.WaitForTarget(3000)))
{
UO.TargetToObject("self");
}
else
{
UO.Print("Target timeout");
}
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:
- CancelTarget chiude la vecchia vista e cancella la coda.
- In assenza di un nuovo ambito, la sfida non crea anticipazione. L'output della coda rimane 0 a meno che un altro script non lo abbia modificato.
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.CancelTarget();
UO.TargetToObject("self");
UO.Print("Queued: " + Convert.ToString(UO.IsWaitTargetActive()));
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: objID (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TargetToObject:bridge.TargetToObject(Arg(0)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "targettoobject": bridge.TargetToObject(Arg(0)); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.TargetToTile(object? tile, object? x, object? y, object? z);Risponde immediatamente a un server di destinazione già attivo con le coordinate del riquadro.
-
tile- Immagine/riquadro type, 0..65535, non serial. Zero indica un target di coordinate senza grafica specificata. -
x— Coordinata del mondo X sulla mappa corrente, 0..65535. Questo non è un pixel dello schermo o una coordinata Gump. -
y— Coordinata Y del mondo sulla mappa corrente, 0..65535. -
z- Altezza del punto di gioco, per un bersaglio a rete utilizzare -128..127. Questo non è un pavimento o uno strato di attrezzature.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- Senza un cursore del server attivo, non fa nulla e non crea una risposta differita. Per la preparazione preliminare, utilizzare WaitTargetObject/WaitTargetTile/WaitTargetXYZ.
- Il ClientRequest* locale e altri punti di richiamata non vengono elaborati da questo comando.
- Un bersaglio con graphic=0 richiede un mirino; Il mirino dell'oggetto non accetta il terreno.
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.TargetToTile");
UO.TargetToTile(0x0CCA, 1445, 1690, 0);Parametri e flusso di esecuzione:
- I parametri danno un esempio di punto reale: sostituire le coordinate e graphic con i valori desiderati.
- Non viene aggiunto nulla alla coda dell'ambito futuro.
if (Truth(UO.TargetPresent()))
{
UO.TargetToTile(0x0CCA, 1445, 1690, 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:
- 3000 — attesa massima in millisecondi; L'azione che ha richiesto la vista deve essere eseguita in precedenza.
- Il comando viene chiamato solo dopo la comparsa della vista; l'azione di gioco potrebbe quindi terminare con un guasto del server.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.WaitForTarget(3000)))
{
UO.TargetToTile(0x0CCA, 1445, 1690, 0);
}
else
{
UO.Print("Target timeout");
}
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:
- CancelTarget chiude la vecchia vista e cancella la coda.
- In assenza di un nuovo ambito, la sfida non crea anticipazione. L'output della coda rimane 0 a meno che un altro script non lo abbia modificato.
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.CancelTarget();
UO.TargetToTile(0x0CCA, 1445, 1690, 0);
UO.Print("Queued: " + Convert.ToString(UO.IsWaitTargetActive()));
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: tile (Any), x (Any), y (Any), z (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TargetToTile:bridge.TargetToTile(Arg(0), Arg(1), Arg(2), Arg(3)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "targettotile":
bridge.TargetToTile(Arg(0), Arg(1), Arg(2), Arg(3)); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.TargetToXYZ(object? x, object? y, object? z);Risponde immediatamente a un server di destinazione già attivo con le coordinate del riquadro.
-
x— Coordinata del mondo X sulla mappa corrente, 0..65535. Questo non è un pixel dello schermo o una coordinata Gump. -
y— Coordinata Y del mondo sulla mappa corrente, 0..65535. -
z- Altezza del punto di gioco, per un bersaglio a rete utilizzare -128..127. Questo non è un pavimento o uno strato di attrezzature.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- Senza un cursore del server attivo, non fa nulla e non crea una risposta differita. Per la preparazione preliminare, utilizzare WaitTargetObject/WaitTargetTile/WaitTargetXYZ.
- Il ClientRequest* locale e altri punti di richiamata non vengono elaborati da questo comando.
- Un bersaglio con graphic=0 richiede un mirino; Il mirino dell'oggetto non accetta il terreno.
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.TargetToXYZ");
UO.TargetToXYZ(1445, 1690, 0);Parametri e flusso di esecuzione:
- I parametri danno un esempio di punto reale: sostituire le coordinate e graphic con i valori desiderati.
- Non viene aggiunto nulla alla coda dell'ambito futuro.
if (Truth(UO.TargetPresent()))
{
UO.TargetToXYZ(1445, 1690, 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:
- 3000 — attesa massima in millisecondi; L'azione che ha richiesto la vista deve essere eseguita in precedenza.
- Il comando viene chiamato solo dopo la comparsa della vista; l'azione di gioco potrebbe quindi terminare con un guasto del server.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.WaitForTarget(3000)))
{
UO.TargetToXYZ(1445, 1690, 0);
}
else
{
UO.Print("Target timeout");
}
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:
- CancelTarget chiude la vecchia vista e cancella la coda.
- In assenza di un nuovo ambito, la sfida non crea anticipazione. L'output della coda rimane 0 a meno che un altro script non lo abbia modificato.
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.CancelTarget();
UO.TargetToXYZ(1445, 1690, 0);
UO.Print("Queued: " + Convert.ToString(UO.IsWaitTargetActive()));
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: x (Any), y (Any), z (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TargetToTile:bridge.TargetToTile(0, Arg(0), Arg(1), Arg(2)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "targettoxyz":
bridge.TargetToTile(0, Arg(0), Arg(1), Arg(2)); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Targeting();Verifica la presenza di un cursore di selezione della destinazione attivo nel client.
Non ci sono parametri.
int 1 - TargetManager.IsTargeting installato; 0 - nessun cursore attivo. Viene presa in considerazione anche la destinazione della richiamata locale. Questo non è serial o lo stato della coda WaitTarget.
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.
- Legge lo stato una volta; non attende la visualizzazione del cursore.
- Per attendere il mirino del server dopo un'azione di gioco, usa WaitForTarget. Per il risultato del locale ClientRequest* - WaitForClientTargetResponse.
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.Targeting();
UO.Print("Targeting: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Non ci sono argomenti.
- Viene visualizzato 1 o 0.
UO.Print(Convert.ToString(UO.Targeting()));Parametri e flusso di esecuzione:
- La condizione è controllata dal cursore attivo.
- CancelTarget in questo client cancella anche le risposte preparate.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Targeting()))
{
UO.CancelTarget();
}
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:
- UseSkill richiede la capacità, WaitForTarget attende fino a 3000 ms.
- TargetToObject risponde solo al target del server attivo; Se c'è un timeout, il ramo non viene eseguito.
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.UseSkill("Anatomy");
if (Truth(UO.WaitForTarget(3000)))
{
if (Truth(UO.Targeting()))
{
UO.TargetToObject("self");
}
}
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.IsTargeting. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsTargeting:bridge.IsTargeting().
Codice interno di implementazione; non è uno script autonomo.
public int IsTargeting() => bridge.IsTargeting();Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.TicksTarget();Legge l'ultimo timestamp di provisioning del target tramite WaitTargetObject/WaitTargetTile e le relative shell chiamanti.
Non ci sono parametri.
int — il valore di UO.Timer al momento della preparazione, in decimi di secondo dall'inizio del runtime. Prima del primo allenamento di questo tipo - 0. Questo è un segno, non una durata di attesa, non un millisecondo e non un obiettivo ID.
- Immediato TargetToObject/TargetToTile/TargetToXYZ non prepara la coda e non aggiorna questo contrassegno.
- Alcuni comandi di ricerca inseriscono la risposta direttamente attraverso il bridge; TicksTarget non è l'ora universale di qualsiasi modifica del target.
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.TicksTarget();
UO.Print("TicksTarget: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Non ci sono argomenti; WaitTargetSelf aggiorna la quota.
- il timbro si misura in decimi di secondo.
UO.WaitTargetSelf();
var stamp = UO.TicksTarget();
UO.Print(Convert.ToString(stamp));
UO.CancelWaitTarget();Parametri e flusso di esecuzione:
- UO.Wait=250 millisecondi.
- A causa della natura discreta del voto, il tempo trascorso è solitamente 2 o 3 anziché 250.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
UO.WaitTargetObject("self");
await Delay(250);
var elapsed = UO.Timer() - UO.TicksTarget();
UO.Print("Tenths: " + Convert.ToString(elapsed));
UO.CancelWaitTarget();
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- selfId - int serial del tuo personaggio.
- La forma numerica aggiorna il segno come la forma stringa; TicksTarget non ha parametri.
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 selfId = UO.Hex2Int(UO.GetSerial("self"));
UO.WaitTargetObject(selfId);
UO.Print(Convert.ToString(UO.TicksTarget()));
UO.CancelWaitTarget();
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: int / Integer.
Durante la chiamata:
Codice interno di implementazione; non è uno script autonomo.
public int TicksTarget() => ticksTarget;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.WaitForClientTargetResponse(object? maxWaitTimeMS);Attende il completamento della selezione locale ClientRequestObjectTarget/ClientRequestTileTarget.
-
maxWaitTimeMS— Tempo massimo in millisecondi. 0 e valori negativi danno un controllo, senza attendere indefinitamente.
int 1 - la risposta è già stata ricevuta, compreso l'annullamento; 0 - il timeout è scaduto. Per 1, controlla ancora la lunghezza di ClientTargetResponse. Con 0 il cursore stesso non si chiude automaticamente.
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.
- L'attesa avviene nel thread dello script a intervalli fino a 25 ms e viene interrotta interrompendo lo script.
- Senza il precedente ClientRequest* la nuova selezione non parte.
Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.
Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.
Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.
object? result = UO.WaitForClientTargetResponse(5000);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- 5000: timeout di attesa del clic in millisecondi. La nuova query reimposta il risultato precedente.
- Una serie di cinque campi indica l'oggetto selezionato. il risultato[0] è serial, non type.
UO.ClientRequestObjectTarget();
if (Truth(UO.WaitForClientTargetResponse(5000)))
{
var result = UO.ClientTargetResponse();
if (Truth(ArrayLength(result) == 5))
{
UO.Print("Serial: " + UO.Int2Hex(result[0]));
}
else
{
UO.Print("Selection cancelled");
}
}
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:
- risultato[1] - graphic, risultato[2]/[3]/[4] - X/Y/Z. La tessera del mondo serial ha un risultato[0] pari a 0.
- Tipo, coordinate e serial sono campi separati. Non è presente alcun indice di livello statico in questo array.
return RunScenario();
object? RunScenario()
{
UO.ClientRequestTileTarget();
if (Truth(UO.WaitForClientTargetResponse(5000)))
{
var result = UO.ClientTargetResponse();
if (Truth(ArrayLength(result) == 5))
{
UO.Print("Type: " + UO.Int2Hex(result[1]));
UO.Print(Convert.ToString(result[2]) + "," + Convert.ToString(result[3]) + "," + Convert.ToString(result[4]));
}
}
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:
- Il timeout è specificato in millisecondi. Un'attesa riuscita significa una risposta, il cui contenuto deve essere controllato separatamente.
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.ClientRequestTileTarget();
int ready = UO.WaitForClientTargetResponse(3000);
if (ready == 0)
{
UO.CancelTarget();
UO.Print("Selection timed out");
return false;
}
var response = (object? [])UO.ClientTargetResponse();
if (response.Length != 5)
return false;
UO.Print($"Tile coordinates: {response[2]}, {response[3]}, {response[4]}");
return true;
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: maxWaitTimeMS (Any)
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitForClientTargetResponse:bridge.WaitForClientTargetResponse(Arg(0)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "waitforclienttargetresponse": return new InjectionValue(bridge.WaitForClientTargetResponse(Arg(0)));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.WaitForTarget(object? maxWaitTimeMS);Attende la visualizzazione del cursore di destinazione attivo entro il timeout.
-
maxWaitTimeMS- Attesa massima in millisecondi. Valori zero e negativi danno un controllo immediato; Non è un'attesa infinita.
int 1 — il cursore era attivo durante la verifica; 0 - timeout senza cursore. Anche la destinazione della richiamata locale soddisfa questo test. Questa non è una conferma dell'utilizzo del WaitTarget preparato: la risposta automatica potrebbe aver già utilizzato il cursore prima del controllo.
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 controllo viene eseguito con pause fino a 25 ms nel thread dello script e può essere interrotto arrestandolo.
- Il metodo in sé non crea un mirino né seleziona un bersaglio.
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.WaitForTarget(3000);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- MaxWaitTimeMS=3000, quindi viene selezionato self.
- WaitTargetSelf non è preimpostato: questo esempio risponde esplicitamente.
UO.UseSkill("Anatomy");
if (Truth(UO.WaitForTarget(3000)))
{
UO.TargetToObject("self");
}
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:
- MaxWaitTimeMS=0.
- pronto - 1 o 0; Non c'è una lunga pausa.
return RunScenario();
object? RunScenario()
{
var ready = UO.WaitForTarget(0);
UO.Print(Convert.ToString(ready));
return null;
}Parametri e flusso di esecuzione:
- 500 - mezzo secondo.
- L'assenza di visuale può significare che l'azione è fallita o viene elaborata automaticamente: controlla il registro del gioco.
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.WaitForTarget(500) == 0))
{
UO.CancelWaitTarget();
UO.Print("Cursor did not arrive");
}
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: maxWaitTimeMS (Any)
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitUntilTargeting:bridge.WaitUntilTargeting(Arg(0)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "waitfortarget": return new InjectionValue(bridge.WaitUntilTargeting(Arg(0)));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.WaitTarget(object? target);
void UO.WaitTarget(object? target, object? @type);
void UO.WaitTarget(object? target, object? @type, object? color);
void UO.WaitTarget(object? target, object? @type, object? color, object? distance);
void UO.WaitTarget(object? target, object? @type, object? color, object? distance, object? notoriety);
void UO.WaitTarget(object? target, object? @type, object? color, object? distance, object? notoriety, object? nearest);
void UO.WaitTarget(object? target, object? @type, object? color, object? distance, object? notoriety, object? nearest, object? maxZ);Posiziona serial nella coda della richiesta di destinazione successiva o seleziona una destinazione utilizzando i filtri.
-
target— Il positivo consentito serial/alias viene impostato direttamente, gli altri parametri vengono ignorati. 0 o -1 abilita la ricerca; un'altra sentinella numerica cancella il prossimo bersaglio. -
type- Opzionale graphic/type o digita maschera; -1 senza limitazioni. I tipi con nome vengono risolti da ResolveType/ParseTypeMask. -
color- Opzionale hue: -1 o 0xFFFF senza limitazioni. -
distance- Distanza massima opzionale nelle celle; l'impostazione predefinita è GetFindDistance. L'analisi ResolveCompactDistance consente valori speciali in base all'impostazione di ricerca. -
notoriety- Notorietà numero/maschera opzionale. Una maschera non vuota limita i candidati mobili; senza di esso vengono considerati i cellulari e gli oggetti world. -
nearest- Opzionale bool, predefinito true: ordina per distanza, quindi serial. -
maxZ— Ass. massimo opzionale (Z-selfZ), predefinito GetFindVertical.
void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.
- Durante la ricerca, esclude self, serial=0, l'elenco normale da ignorare e i filtri selezionati con nome type; i duplicati vengono rimossi. Il positivo diretto serial non supera questi filtri.
- La ricerca legge solo gli oggetti caricati. Nessuna corrispondenza/sentinella non valida: messaggio e CancelNextTarget. Una selezione riuscita richiama WaitTargetObject e aggiorna TicksTarget. WaitTarget stesso non utilizza l'elemento, non apre la destinazione e non attende che il server lo elabori.
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.WaitTarget");
UO.WaitTarget("self");Parametri e flusso di esecuzione:
- Posiziona serial nella coda della richiesta di destinazione successiva o seleziona una destinazione utilizzando i filtri.
UO.WaitTarget("self");Parametri e flusso di esecuzione:
- Durante la ricerca, esclude self, serial=0, l'elenco normale da ignorare e i filtri selezionati con nome type; i duplicati vengono rimossi. Il positivo diretto serial non supera questi filtri.
return RunScenario();
object? RunScenario()
{
UO.WaitTarget(0, -1, -1, 10, 3, true, 20);
return null;
}Parametri e flusso di esecuzione:
- La ricerca legge solo gli oggetti caricati. Nessuna corrispondenza/sentinella non valida: messaggio e CancelNextTarget. Una selezione riuscita richiama WaitTargetObject e aggiorna TicksTarget. WaitTarget stesso non utilizza l'elemento, non apre la destinazione e non attende che il server lo elabori.
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.WaitTarget("lasttarget");
UO.Print(UO.Waiting());
UO.CancelWaitTarget();
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: target (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [WaitTarget]. -
InjectionScript.Runtime.InjectionApiUO.CompactWaitTarget:CompactWaitTarget(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 =>
{
CompactWaitTarget(values);
return InjectionValue.Unit;
}Parametri: target (Any), type (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [WaitTarget]. -
InjectionScript.Runtime.InjectionApiUO.CompactWaitTarget:CompactWaitTarget(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 =>
{
CompactWaitTarget(values);
return InjectionValue.Unit;
}Parametri: target (Any), type (Any), color (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [WaitTarget]. -
InjectionScript.Runtime.InjectionApiUO.CompactWaitTarget:CompactWaitTarget(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 =>
{
CompactWaitTarget(values);
return InjectionValue.Unit;
}Parametri: target (Any), type (Any), color (Any), distance (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [WaitTarget]. -
InjectionScript.Runtime.InjectionApiUO.CompactWaitTarget:CompactWaitTarget(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 =>
{
CompactWaitTarget(values);
return InjectionValue.Unit;
}Parametri: target (Any), type (Any), color (Any), distance (Any), notoriety (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [WaitTarget]. -
InjectionScript.Runtime.InjectionApiUO.CompactWaitTarget:CompactWaitTarget(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 =>
{
CompactWaitTarget(values);
return InjectionValue.Unit;
}
UO.WaitTarget(target, type, color, distance, notoriety, nearest) — UO.WaitTarget(Any,Any,Any,Any,Any,Any)
Parametri: target (Any), type (Any), color (Any), distance (Any), notoriety (Any), nearest (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [WaitTarget]. -
InjectionScript.Runtime.InjectionApiUO.CompactWaitTarget:CompactWaitTarget(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 =>
{
CompactWaitTarget(values);
return InjectionValue.Unit;
}
UO.WaitTarget(target, type, color, distance, notoriety, nearest, maxZ) — UO.WaitTarget(Any,Any,Any,Any,Any,Any,Any)
Parametri: target (Any), type (Any), color (Any), distance (Any), notoriety (Any), nearest (Any), maxZ (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.Register [WaitTarget]. -
InjectionScript.Runtime.InjectionApiUO.CompactWaitTarget:CompactWaitTarget(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 =>
{
CompactWaitTarget(values);
return InjectionValue.Unit;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.WaitTargetGround(object? @type);
void UO.WaitTargetGround(object? @type, object? color);Cerca un oggetto in graphic/hue e lo inserisce nella coda del bersaglio successivo.
-
type- Grafico/type int, stringa esadecimale o set denominato type. Questo non è un articolo serial. -
color- Opzionale int hue; predefinito -1 - qualsiasi colore.
void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.
- Ambito: ground/selettore contenitore 1 senza ricerca ricorsiva. Bridge.FindType restituisce il serial trovato; quando viene chiamato il bridge serial>0.WaitTargetObject. Questi metodi non aggiornano direttamente il runtime TicksTarget.
- Nessun elemento: messaggio e CancelNextTarget. La ricerca può cambiare il generale FindItem/FoundItems; Il comando non utilizza l'elemento trovato e non attende il cursore.
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.WaitTargetGround");
UO.WaitTargetGround("0x0E21");Parametri e flusso di esecuzione:
- Cerca un oggetto in graphic/hue e lo inserisce nella coda del bersaglio successivo.
UO.WaitTargetGround("0x0E21");Parametri e flusso di esecuzione:
- Ambito: ground/selettore contenitore 1 senza ricerca ricorsiva. Bridge.FindType restituisce il serial trovato; quando viene chiamato il bridge serial>0.WaitTargetObject. Questi metodi non aggiornano direttamente il runtime TicksTarget.
return RunScenario();
object? RunScenario()
{
UO.WaitTargetGround("0x0E21", -1);
return null;
}Parametri e flusso di esecuzione:
- Nessun elemento: messaggio e CancelNextTarget. La ricerca può cambiare il generale FindItem/FoundItems; Il comando non utilizza l'elemento trovato e non attende il cursore.
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.WaitTargetGround("0x0E21", -1);
UO.Print(UO.Waiting());
UO.CancelWaitTarget();
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: type (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetGround. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetGround:WaitTargetGround(type, new InjectionValue(-1)).
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetGround(InjectionValue type) => WaitTargetGround(type, new InjectionValue(-1));Parametri: type (Any), color (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetGround. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FindType:bridge.FindType(ResolveType(type), NumberConversions.ToInt(color), 1, -1, false). -
InjectionScript.Runtime.InjectionApiUO.ResolveType:ResolveType(type). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(color). -
InjectionScript.Runtime.InjectionApiUO.SystemMessage:SystemMessage("No ground item found. Next target request will be canceled"). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CancelNextTarget:bridge.CancelNextTarget(). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitTargetObject:bridge.WaitTargetObject(item).
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetGround(InjectionValue type, InjectionValue color)
{
int item = bridge.FindType(ResolveType(type), NumberConversions.ToInt(color), 1, -1, false);
if (item <= 0)
{
SystemMessage("No ground item found. Next target request will be canceled");
bridge.CancelNextTarget();
}
else
bridge.WaitTargetObject(item);
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.WaitTargetLast();Prepara una risposta al server di destinazione successivo tramite l'alias lasttarget.
Non ci sono parametri.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- La squadra prepara solo una risposta: non utilizza l'oggetto, l'abilità o l'incantesimo stesso. La successiva destinazione del server riceve la destinazione preparata durante l'elaborazione del frame client.
- Le chiamate consecutive formano una coda client comune. Gli oggetti e i target delle coordinate vengono elaborati uno alla volta; le finestre di selezione locale ClientRequest*/Info/container non lo consumano.
- CancelWaitTarget cancella la coda. TerminateAll lo pulisce completamente; l'arresto di una procedura ancora in esecuzione invalida anche le sue risposte in sospeso. Il completamento di una procedura breve normalmente non cancella il target preparato.
- L'invio di una risposta non garantisce l'azione sul server: verifica il raggio d'azione, l'accessibilità dell'oggetto, la visibilità e le regole di azione. Per controllare, usa il risultato del gioco e accedi.
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.WaitTargetLast");
UO.WaitTargetLast();Parametri e flusso di esecuzione:
- Non ci sono argomenti; viene utilizzato lasttarget.
- Il comando non apre la vista ed esegue l'azione stessa.
UO.WaitTargetLast();Parametri e flusso di esecuzione:
- lasttarget deve risolversi nel personaggio caricato per questa abilità.
- Il controllo Exists elimina l'oggetto sconosciuto; la scelta del tipo di oggetto e la validità della competenza rimangono condizioni dello script.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Exists("lasttarget")))
{
UO.CancelWaitTarget();
UO.WaitTargetLast();
UO.UseSkill("Anatomy");
}
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:
- IsWaitTargetActive controlla la coda di risposta.
- CancelWaitTarget non prepara senza chiudere il mirino personalizzato già aperto.
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.WaitTargetLast();
if (Truth(UO.IsWaitTargetActive()))
{
UO.CancelWaitTarget();
}
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.WaitTargetLast. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetObject:WaitTargetObject("lasttarget").
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetLast() => WaitTargetObject("lasttarget");Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.WaitTargetObject(object? objID);
void UO.WaitTargetObject(object? id1, object? id2);Prepara una o due risposte serial consecutive alle visualizzazioni del server.
-
objID / id1 / id2— Numero seriale/ID di un elemento o carattere, numero o stringa esadecimale/decimale, self/backpack/lasttarget/lastobject o nome salvato AddObject. Questo non è type. Prima di agire su un oggetto con nome, controlla Exists; un alias non risolto dà serial 0. Un singolo argomento specifica un obiettivo. Le forme numeriche e di stringa si aggiornano TicksTarget allo stesso modo. -
objID— Numero seriale/ID di un elemento o carattere, numero o stringa esadecimale/decimale, self/backpack/lasttarget/lastobject o nome salvato AddObject. Questo non è type. Prima di agire su un oggetto con nome, controlla Exists; un alias non risolto dà serial 0. Un singolo argomento specifica un obiettivo. Le forme numeriche e di stringa si aggiornano TicksTarget allo stesso modo. -
id1— Numero seriale/ID di un elemento o carattere, numero o stringa esadecimale/decimale, self/backpack/lasttarget/lastobject o nome salvato AddObject. Questo non è type. Prima di agire su un oggetto con nome, controlla Exists; un alias non risolto dà serial 0. Il primo obiettivo del modulo è con due righe. -
id2— Numero seriale/ID di un elemento o carattere, numero o stringa esadecimale/decimale, self/backpack/lasttarget/lastobject o nome salvato AddObject. Questo non è type. Prima di agire su un oggetto con nome, controlla Exists; un alias non risolto dà serial 0. Il secondo scopo del modulo è con due righe; si applica al successivo ambito individuale.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- La squadra prepara solo una risposta: non utilizza l'oggetto, l'abilità o l'incantesimo stesso. La successiva destinazione del server riceve la destinazione preparata durante l'elaborazione del frame client.
- Le chiamate consecutive formano una coda client comune. Gli oggetti e i target delle coordinate vengono elaborati uno alla volta; le finestre di selezione locale ClientRequest*/Info/container non lo consumano.
- CancelWaitTarget cancella la coda. TerminateAll lo pulisce completamente; l'arresto di una procedura ancora in esecuzione invalida anche le sue risposte in sospeso. Il completamento di una procedura breve normalmente non cancella il target preparato.
- L'invio di una risposta non garantisce l'azione sul server: verifica il raggio d'azione, l'accessibilità dell'oggetto, la visibilità e le regole di azione. Per controllare, usa il risultato del gioco e accedi.
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.WaitTargetObject");
UO.WaitTargetObject("self");Parametri e flusso di esecuzione:
- id="self" - serial del tuo personaggio. CancelWaitTarget rimuove le risposte precedentemente preparate.
- UseSkill richiede un'abilità; la vista del suo server riceve un bersaglio preparato.
UO.CancelWaitTarget();
UO.WaitTargetObject("self");
UO.UseSkill("Anatomy");Parametri e flusso di esecuzione:
- objectId - esempio serial: sostituisci con il tuo. Questo non è graphic/type.
- Qui l'obiettivo è appena stato preparato. Il passaggio successivo dello script dovrebbe richiamare un'azione che effettivamente si aspetta target.
return RunScenario();
object? RunScenario()
{
var objectId = 0x40001234;
if (Truth(UO.Exists(objectId)))
{
UO.WaitTargetObject(objectId);
UO.Print("Object target prepared");
}
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:
- sorgente e destinazione sono nomi predefiniti AddObject. GetSerial restituisce le righe corrispondenti alla forma id1/id2.
- Il primo server utilizza il primo, il secondo il secondo. Adatto solo per azioni con due mirini sequenziali; Elimina un secondo bersaglio non necessario prima di intraprendere un'altra azione.
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 first = UO.GetSerial("source");
var second = UO.GetSerial("destination");
if (Truth(UO.Exists(first)) && Truth(UO.Exists(second)))
{
UO.CancelWaitTarget();
UO.WaitTargetObject(first, second);
}
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: objID (Any/String)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetObject:WaitTargetObject(Arg(0)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Codice interno di implementazione; non è uno script autonomo.
case "waittargetobject": WaitTargetObject(Arg(0)); return InjectionValue.Unit;Parametri: objID (Any/String)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetObject. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetObject:WaitTargetObject(GetObject(id)). -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(id).
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetObject(string id) => WaitTargetObject(GetObject(id));Parametri: id1 (String), id2 (String)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetObject. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetObject:WaitTargetObject(GetObject(id1), GetObject(id2)). -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(id1).
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetObject(string id1, string id2) => WaitTargetObject(GetObject(id1), GetObject(id2));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.WaitTargetObjectType(object? id, object? @type);
void UO.WaitTargetObjectType(object? id, object? @type, object? color);Prepara due bersagli sequenziali: un oggetto dato e un oggetto trovato sul terreno.
-
id— Oggetto seriale/ID: int, stringa numerica/esadecimale o alias stabilito, ad esempio "lasttarget". Questo non è graphic/type. Controllare l'oggetto caricato prima di agire. -
type- Grafico/type del secondo elemento, int/esadecimale/denominato type. -
color- Opzionale hue del secondo argomento; -1 qualsiasi per impostazione predefinita.
void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.
- Consente prima da serial a GetObject; il secondo cerca FindType(type,color,1,-1,false). Se entrambi sono positivi, chiama bridge.WaitTargetObject(primo,secondo). L'ordine degli obiettivi viene mantenuto.
- Se almeno un obiettivo manca/non è positivo - messaggio e CancelNextTarget, entrambi gli obiettivi non vengono impostati. Il ramo non aggiorna TicksTarget e non utilizza l'elemento.
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.WaitTargetObjectType");
UO.WaitTargetObjectType("self", "0x0E21");Parametri e flusso di esecuzione:
- Prepara due bersagli sequenziali: un oggetto dato e un oggetto trovato sul terreno.
UO.WaitTargetObjectType("self", "0x0E21");Parametri e flusso di esecuzione:
- Consente prima da serial a GetObject; il secondo cerca FindType(type,color,1,-1,false). Se entrambi sono positivi, chiama bridge.WaitTargetObject(primo,secondo). L'ordine degli obiettivi viene mantenuto.
return RunScenario();
object? RunScenario()
{
UO.WaitTargetObjectType("lasttarget", "0x0E21", -1);
return null;
}Parametri e flusso di esecuzione:
- Se almeno un obiettivo manca/non è positivo - messaggio e CancelNextTarget, entrambi gli obiettivi non vengono impostati. Il ramo non aggiorna TicksTarget e non utilizza l'elemento.
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.WaitTargetObjectType("self", "0x0E21", -1);
UO.Print(UO.Waiting());
UO.CancelWaitTarget();
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: id (Any), type (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetObjectType. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetObjectType:WaitTargetObjectType(id, type, new InjectionValue(-1)).
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetObjectType(InjectionValue id, InjectionValue type)
=> WaitTargetObjectType(id, type, new InjectionValue(-1));Parametri: id (Any), type (Any), color (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetObjectType. -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(id). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FindType:bridge.FindType(ResolveType(type), NumberConversions.ToInt(color), 1, -1, false). -
InjectionScript.Runtime.InjectionApiUO.ResolveType:ResolveType(type). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(color). -
InjectionScript.Runtime.InjectionApiUO.SystemMessage:SystemMessage("UO.WaitTargetObjectType: object or ground item not found"). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CancelNextTarget:bridge.CancelNextTarget(). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitTargetObject:bridge.WaitTargetObject(first, second).
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetObjectType(InjectionValue id, InjectionValue type, InjectionValue color)
{
int first = GetObject(id);
int second = bridge.FindType(ResolveType(type), NumberConversions.ToInt(color), 1, -1, false);
if (first <= 0 || second <= 0)
{
SystemMessage("UO.WaitTargetObjectType: object or ground item not found");
bridge.CancelNextTarget();
return;
}
bridge.WaitTargetObject(first, second);
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.WaitTargetSelf();Prepara una risposta al server di destinazione successivo tramite l'alias self.
Non ci sono parametri.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- La squadra prepara solo una risposta: non utilizza l'oggetto, l'abilità o l'incantesimo stesso. La successiva destinazione del server riceve la destinazione preparata durante l'elaborazione del frame client.
- Le chiamate consecutive formano una coda client comune. Gli oggetti e i target delle coordinate vengono elaborati uno alla volta; le finestre di selezione locale ClientRequest*/Info/container non lo consumano.
- CancelWaitTarget cancella la coda. TerminateAll lo pulisce completamente; l'arresto di una procedura ancora in esecuzione invalida anche le sue risposte in sospeso. Il completamento di una procedura breve normalmente non cancella il target preparato.
- L'invio di una risposta non garantisce l'azione sul server: verifica il raggio d'azione, l'accessibilità dell'oggetto, la visibilità e le regole di azione. Per controllare, usa il risultato del gioco e accedi.
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.WaitTargetSelf");
UO.WaitTargetSelf();Parametri e flusso di esecuzione:
- Non ci sono argomenti; viene utilizzato self.
- Il comando non apre la vista ed esegue l'azione stessa.
UO.WaitTargetSelf();Parametri e flusso di esecuzione:
- self deve risolversi nel personaggio caricato per questa abilità.
- Il controllo Exists elimina l'oggetto sconosciuto; la scelta del tipo di oggetto e la validità della competenza rimangono condizioni dello script.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Exists("self")))
{
UO.CancelWaitTarget();
UO.WaitTargetSelf();
UO.UseSkill("Anatomy");
}
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:
- IsWaitTargetActive controlla la coda di risposta.
- CancelWaitTarget non prepara senza chiudere il mirino personalizzato già aperto.
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.WaitTargetSelf();
if (Truth(UO.IsWaitTargetActive()))
{
UO.CancelWaitTarget();
}
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.WaitTargetSelf. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetObject:WaitTargetObject("self").
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetSelf() => WaitTargetObject("self");Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.WaitTargetTile(object? selector);
void UO.WaitTargetTile(object? x, object? y, object? z);
void UO.WaitTargetTile(object? @type, object? x, object? y, object? z);Prepara un target di coordinate con grafica a riquadri opzionale.
-
selector- Solo nella forma ad un argomento: la stringa "lasttile" che ripete il punto memorizzato. -
type- Immagine/riquadro type, 0..65535, non serial. Zero indica un target di coordinate senza grafica specificata. Presente in forma di quattro argomenti; nella forma x/y/z è uguale a 0. -
x— Coordinata del mondo X sulla mappa corrente, 0..65535. Questo non è un pixel dello schermo o una coordinata Gump. -
y— Coordinata Y del mondo sulla mappa corrente, 0..65535. -
z- Altezza del punto di gioco, per un bersaglio a rete utilizzare -128..127. Questo non è un pavimento o uno strato di attrezzature.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- La squadra prepara solo una risposta: non utilizza l'oggetto, l'abilità o l'incantesimo stesso. La successiva destinazione del server riceve la destinazione preparata durante l'elaborazione del frame client.
- Le chiamate consecutive formano una coda client comune. Gli oggetti e i target delle coordinate vengono elaborati uno alla volta; le finestre di selezione locale ClientRequest*/Info/container non lo consumano.
- CancelWaitTarget cancella la coda. TerminateAll lo pulisce completamente; l'arresto di una procedura ancora in esecuzione invalida anche le sue risposte in sospeso. Il completamento di una procedura breve normalmente non cancella il target preparato.
- L'invio di una risposta non garantisce l'azione sul server: verifica il raggio d'azione, l'accessibilità dell'oggetto, la visibilità e le regole di azione. Per controllare, usa il risultato del gioco e accedi.
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.WaitTargetTile");
UO.WaitTargetTile("lasttile");Parametri e flusso di esecuzione:
- x=1445, y=1690, z=0; il type mancante è uguale a 0.
- Questo è il punto del mondo. Il comando non sposta il personaggio né posiziona l'oggetto nel gump.
UO.CancelWaitTarget();
UO.WaitTargetTile(1445, 1690, 0);Parametri e flusso di esecuzione:
- type=0x0CCA — esempio di grafica; usa il vero type della tessera selezionata. x/y/z è la sua posizione mondiale.
- La grafica e le coordinate devono descrivere l'oggetto della mappa desiderato; il server verifica la validità del target.
return RunScenario();
object? RunScenario()
{
UO.CancelWaitTarget();
UO.WaitTargetTile(0x0CCA, 1445, 1690, 0);
return null;
}Parametri e flusso di esecuzione:
- Il selettore consente solo la stringa lasttile, senza distinzione tra maiuscole e minuscole. Un'altra stringa o numero nella forma di un argomento causa un errore.
- Vengono utilizzati gli ultimi campi del riquadro in TargetManager. Prima della prima scelta, possono essere zero: seleziona prima il punto desiderato nel gioco. Tre o quattro argomenti consentono di impostarlo in modo esplicito.
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.WaitTargetTile("lasttile");
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: selector (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetTile. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTile:bridge.LastTile(). -
InjectionScript.Runtime.InjectionApiUO.SystemMessage:SystemMessage("UO.WaitTargetTile: lasttile is unavailable; next target request canceled."). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CancelNextTarget:bridge.CancelNextTarget(). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitTargetTile:bridge.WaitTargetTile(tile[0], tile[1], tile[2], tile[3]). -
InjectionScript.Runtime.InjectionApiUO.Timer:Timer().
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetTile(InjectionValue selector)
{
string name = selector.Kind == InjectionValueKind.String
? (selector.String ?? string.Empty).Trim()
: string.Empty;
if (!name.Equals("lasttile", StringComparison.OrdinalIgnoreCase))
throw new NativeSubrutineException("UO.WaitTargetTile(one argument) accepts only 'lasttile'.");
int[] tile = bridge.LastTile() ?? Array.Empty<int>();
if (tile.Length < 4)
{
SystemMessage("UO.WaitTargetTile: lasttile is unavailable; next target request canceled.");
bridge.CancelNextTarget();
return;
}
bridge.WaitTargetTile(tile[0], tile[1], tile[2], tile[3]);
ticksTarget = Timer();
}Parametri: x (Any), y (Any), z (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetTile. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetTile:WaitTargetTile(new InjectionValue(0), x, y, z).
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetTile(InjectionValue x, InjectionValue y, InjectionValue z)
=> WaitTargetTile(new InjectionValue(0), x, y, z);Parametri: type (Any), x (Any), y (Any), z (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetTile. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitTargetTile:bridge.WaitTargetTile(ResolveType(type), NumberConversions.ToInt(x), NumberConversions.ToInt(y), NumberConversions.ToInt(z)). -
InjectionScript.Runtime.InjectionApiUO.ResolveType:ResolveType(type). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(x). -
InjectionScript.Runtime.InjectionApiUO.Timer:Timer().
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetTile(InjectionValue type, InjectionValue x, InjectionValue y, InjectionValue z)
{
bridge.WaitTargetTile(ResolveType(type), NumberConversions.ToInt(x), NumberConversions.ToInt(y), NumberConversions.ToInt(z));
ticksTarget = Timer();
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.WaitTargetType(object? @type);
void UO.WaitTargetType(object? @type, object? color);Cerca un oggetto in graphic/hue e lo inserisce nella coda del bersaglio successivo.
-
type- Grafico/type int, stringa esadecimale o set denominato type. Questo non è un articolo serial. -
color- Opzionale int hue; predefinito -1 - qualsiasi colore.
void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.
- Ambito: Zaino con ricerca ricorsiva. Bridge.FindType restituisce il serial trovato; quando viene chiamato il bridge serial>0.WaitTargetObject. Questi metodi non aggiornano direttamente il runtime TicksTarget.
- Nessun elemento: messaggio e CancelNextTarget. La ricerca può cambiare il generale FindItem/FoundItems; Il comando non utilizza l'elemento trovato e non attende il cursore.
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.WaitTargetType");
UO.WaitTargetType("0x0E21");Parametri e flusso di esecuzione:
- Cerca un oggetto in graphic/hue e lo inserisce nella coda del bersaglio successivo.
UO.WaitTargetType("0x0E21");Parametri e flusso di esecuzione:
- Ambito: Zaino con ricerca ricorsiva. Bridge.FindType restituisce il serial trovato; quando viene chiamato il bridge serial>0.WaitTargetObject. Questi metodi non aggiornano direttamente il runtime TicksTarget.
return RunScenario();
object? RunScenario()
{
UO.WaitTargetType("0x0E21", -1);
return null;
}Parametri e flusso di esecuzione:
- Nessun elemento: messaggio e CancelNextTarget. La ricerca può cambiare il generale FindItem/FoundItems; Il comando non utilizza l'elemento trovato e non attende il cursore.
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.WaitTargetType("0x0E21", -1);
UO.Print(UO.Waiting());
UO.CancelWaitTarget();
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: type (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetType. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetType:WaitTargetType(ResolveType(type), -1). -
InjectionScript.Runtime.InjectionApiUO.ResolveType:ResolveType(type).
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetType(InjectionValue type) => WaitTargetType(ResolveType(type), -1);Parametri: type (Any), color (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.WaitTargetType. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetType:WaitTargetType(ResolveType(type), NumberConversions.ToInt(color)). -
InjectionScript.Runtime.InjectionApiUO.ResolveType:ResolveType(type). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(color).
Codice interno di implementazione; non è uno script autonomo.
public void WaitTargetType(InjectionValue type, InjectionValue color)
=> WaitTargetType(ResolveType(type), NumberConversions.ToInt(color));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.WaitTargetXYZ(object? x, object? y, object? z);Prepara un bersaglio coordinato con graphic=0 per la prossima vista del server.
-
x— Coordinata del mondo X sulla mappa corrente, 0..65535. Questo non è un pixel dello schermo o una coordinata Gump. -
y— Coordinata Y del mondo sulla mappa corrente, 0..65535. -
z- Altezza del punto di gioco, per un bersaglio a rete utilizzare -128..127. Questo non è un pavimento o uno strato di attrezzature.
void - nessun valore restituito. Chiama su una linea separata; non utilizzare come true/false, serial o type. Metadati object? per i moduli compatibili non cambia il risultato effettivo void.
- La squadra prepara solo una risposta: non utilizza l'oggetto, l'abilità o l'incantesimo stesso. La successiva destinazione del server riceve la destinazione preparata durante l'elaborazione del frame client.
- Le chiamate consecutive formano una coda client comune. Gli oggetti e i target delle coordinate vengono elaborati uno alla volta; le finestre di selezione locale ClientRequest*/Info/container non lo consumano.
- CancelWaitTarget cancella la coda. TerminateAll lo pulisce completamente; l'arresto di una procedura ancora in esecuzione invalida anche le sue risposte in sospeso. Il completamento di una procedura breve normalmente non cancella il target preparato.
- L'invio di una risposta non garantisce l'azione sul server: verifica il raggio d'azione, l'accessibilità dell'oggetto, la visibilità e le regole di azione. Per controllare, usa il risultato del gioco e accedi.
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.WaitTargetXYZ");
UO.WaitTargetXYZ(1445, 1690, 0);Parametri e flusso di esecuzione:
- X=1445, Y=1690, Z=0. Il grafico è uguale a 0.
- La risposta verrà inviata quando verrà visualizzata la vista delle coordinate del server.
UO.WaitTargetXYZ(1445, 1690, 0);Parametri e flusso di esecuzione:
- X/Y/Z vengono letti dal tuo personaggio.
- Questo è un bersaglio coordinato, non un bersaglio object sul serial del personaggio. Per quest'ultimo è necessario WaitTargetSelf.
return RunScenario();
object? RunScenario()
{
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
UO.WaitTargetXYZ(x, y, z);
return null;
}Parametri e flusso di esecuzione:
- Sostituisci le coordinate con il punto di estrazione. UseType cerca una pala type=0x0F39 di qualsiasi colore nello zaino.
- Se non è disponibile uno strumento adatto, rimuovere il preparato tramite CancelWaitTarget prima di passare ad un'altra azione.
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.CancelWaitTarget();
UO.WaitTargetXYZ(1445, 1690, 0);
UO.UseType(0x0F39, -1);
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: x (Any), y (Any), z (Any)
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.WaitTargetTile:WaitTargetTile(new InjectionValue(0), arguments[0], arguments[1], arguments[2]).
Codice interno di implementazione; non è uno script autonomo.
case "waittargetxyz": WaitTargetTile(new InjectionValue(0), arguments[0], arguments[1], arguments[2]); return InjectionValue.Unit;ClassicUO — Bad Newbie & C# Scripts IDE