Repository navigation
IT UO Topic character Part 2
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
Home · C# · IDE · UO API · A–Z · Esempi · Lingue
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetHidden();
int UO.GetHidden(object? arg0);Mette alla prova la furtività del personaggio.
-
value— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.
Flag numerico int: 1 (condizione soddisfatta), 0 (condizione non soddisfatta). Questo è un flag numerico: in C# controlla risultato != 0 o risultato == 0. Il confronto diretto di int con true/false e if (risultato) non è consentito. 1 - mobile ha IsHidden, 0 non ha flag o mobile manca. Questa è una bandiera del server, non una visibilità dietro un muro.
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 il modello locale: non apre il target, non richiede lo stato, non cambia il flag e non invia il pacchetto. Un oggetto distrutto è considerato mancante anche prima che la voce venga cancellata dal dizionario.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
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.GetHidden();
UO.Print("GetHidden: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Le parentesi vuote leggono self. attivo salva il risultato una volta; true e false definiscono due rami. Print visualizza solo un messaggio di esempio.
var active = UO.GetHidden();
if (Truth(Truth(active) == true))
{
UO.Print("State is active");
}
else
{
UO.Print("State is inactive or unavailable");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- lasttarget – oggetto precedentemente selezionato. Exists ne verifica la presenza. obj è l'unico parametro ReadState; la funzione restituisce il risultato del comando senza modifiche. La sua definizione è inclusa nel codice copiato.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
if (Truth(UO.Exists("lasttarget")))
{
var observed = ReadState("lasttarget");
UO.Print("State 1/0: " + Convert.ToString(observed));
}
return null;
}
dynamic ReadState(dynamic obj)
{
return UO.GetHidden(obj);
}
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:
- Due chiamate senza argomenti leggono self, UO.Wait(500) imposta 500 millisecondi. Vengono confrontate due immagini; le transizioni intermedie possono essere saltate. Non esiste un'attesa infinita.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = UO.GetHidden();
await Delay(500);
var after = UO.GetHidden();
if (Truth(before != after))
{
UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetInt();
int UO.GetInt(object? arg0);Legge l'intelligenza attuale (Intelligence, INT) del personaggio.
-
ObjID— ObjID solo nella forma mostrata, con un argomento: numero di carattere serial, stringa esadecimale decimale/0x, "self", "lasttarget" o nome AddObject. Seleziona un oggetto diverso da graphic/type. Senza argomenti, viene letto il carattere corrente.
int — punti statistici attuali, 0..65535 nel modello client; non percentuale, ID, abilità, modalità di blocco o bool. 0 significa anche carattere mancante/cancellato o oggetto inaccessibile. Confrontare con il requisito numerico, non == true. Questo non è un limite statistico o un valore base garantito senza modificatori.
- Sono supportati () per self e (ObjID) per un oggetto esplicito. Non ci sono altri argomenti facoltativi.
- Legge Player.Intelligence se Player esiste e non è stato distrutto; altrimenti 0. Un personaggio morto presente non è un oggetto rimosso. La statistica non viene calcolata da HP, mana o resistenza.
- GetStr/GetInt/GetDex accetta ObjID. I dati PlayerMobile sono disponibili solo per self; per un altro serial - 0, anche per mobile caricato. Le caratteristiche di qualcun altro non vengono sostituite o indovinate.
- Invoca letture sul flusso di gioco con la possibilità di annullare l'attesa tramite script. Non interroga lo stato, non apre il target, non invia un pacchetto, non cambia le caratteristiche e non aggiunge ritardo.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- Nomi caratteristici equivalenti con UO. e senza di essa, non fa distinzione tra maiuscole e minuscole:
Int Intelligence GetInt GetIntelligence. - ExecuteClientApiCompatibility.Arg prima risolve il nome dell'oggetto, quindi converte il numero. Una stringa non numerica sconosciuta provoca un errore di conversione, non un obiettivo. double è ridotto a int, Array/void è ridotto a 0. Per selezionare un personaggio, usa il serial corretto, non tali trasformazioni.
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.GetInt();
UO.Print("GetInt: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato numerico; Convert.ToString lo formatta semplicemente per la rivista. Non ci sono argomenti o azioni dei personaggi.
var value = UO.GetInt();
UO.Print("Intelligence: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- prima e dopo 1000 ms separati; UO.Wait aggiunto all'esempio. change=after-before può essere positivo, zero o negativo. Di per sé, non distingue tra tutti gli aggiornamenti intermedi e l'uscita dal mondo.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetInt();
await Delay(1000);
var after = UO.GetInt();
var change = after - before;
UO.Print("Change: " + Convert.ToString(change));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=80 è un esempio di requisito, non di limite del cliente. AttributeAtLeast(minimo) rifiuta il carattere mancante, legge la caratteristica una volta e restituisce bool: true o false se >= minimo. Il significato logico è dato dal confronto, non dalla caratteristica stessa.
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()
{
if (Truth(Truth(AttributeAtLeast(80)) == true))
{
UO.Print("Requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic AttributeAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetInt();
return value >= minimum;
}
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:
- id è il risultato di UO.Self(), non type. AddObject memorizza ID come statSubject senza ambito perché è specificato il secondo argomento. Entrambe le chiamate selezionano lo stesso carattere, ma le letture non sono atomiche.
var id = UO.Self();
if (Truth(id != 0))
{
UO.AddObject("statSubject", id);
var direct = UO.GetInt(id);
var byName = UO.GetInt("statSubject");
UO.Print("Direct: " + Convert.ToString(direct) + "; alias: " + Convert.ToString(byName));
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetIntelligence();Legge l'intelligenza attuale (Intelligence, INT) del personaggio.
Non ci sono parametri.
int — punti statistici attuali, 0..65535 nel modello client; non percentuale, ID, abilità, modalità di blocco o bool. 0 significa anche carattere mancante/cancellato o oggetto inaccessibile. Confrontare con il requisito numerico, non == true. Questo non è un limite statistico o un valore base garantito senza modificatori.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- Legge Player.Intelligence se Player esiste e non è stato distrutto; altrimenti 0. Un personaggio morto presente non è un oggetto rimosso. La statistica non viene calcolata da HP, mana o resistenza.
- GetStr/GetInt/GetDex accetta ObjID. I dati PlayerMobile sono disponibili solo per self; per un altro serial - 0, anche per mobile caricato. Le caratteristiche di qualcun altro non vengono sostituite o indovinate.
- Invoca letture sul flusso di gioco con la possibilità di annullare l'attesa tramite script. Non interroga lo stato, non apre il target, non invia un pacchetto, non cambia le caratteristiche e non aggiunge ritardo.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- Nomi caratteristici equivalenti con UO. e senza di essa, non fa distinzione tra maiuscole e minuscole:
Int Intelligence GetInt GetIntelligence.
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.GetIntelligence();
UO.Print("GetIntelligence: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato numerico; Convert.ToString lo formatta semplicemente per la rivista. Non ci sono argomenti o azioni dei personaggi.
var value = UO.GetIntelligence();
UO.Print("Intelligence: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- prima e dopo 1000 ms separati; UO.Wait aggiunto all'esempio. change=after-before può essere positivo, zero o negativo. Di per sé, non distingue tra tutti gli aggiornamenti intermedi e l'uscita dal mondo.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetIntelligence();
await Delay(1000);
var after = UO.GetIntelligence();
var change = after - before;
UO.Print("Change: " + Convert.ToString(change));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=80 è un esempio di requisito, non di limite del cliente. AttributeAtLeast(minimo) rifiuta il carattere mancante, legge la caratteristica una volta e restituisce bool: true o false se >= minimo. Il significato logico è dato dal confronto, non dalla caratteristica stessa.
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()
{
if (Truth(Truth(AttributeAtLeast(80)) == true))
{
UO.Print("Requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic AttributeAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetIntelligence();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetLife();Legge l'integrità attuale dal modello locale.
Non ci sono parametri.
int è il valore del campo Hits, non la percentuale e non bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.GetLife();
UO.Print("GetLife: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.GetLife();
UO.Print("GetLife: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetLife();
var maximum = UO.GetMaxHP();
if (Truth(maximum > 0) && Truth(value * 100 / maximum < 50))
{
UO.Print("Health below half of the known maximum");
}
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:
- Questo nome non ha la forma con ID. ReadValue senza parametri legge self; le due chiamate sono separate da UO.Wait(1000). Confrontando due istantanee potrebbero non essere rilevate modifiche intermedie.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = ReadValue();
await Delay(1000);
var after = ReadValue();
UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
return null;
}
dynamic ReadValue()
{
return UO.GetLife();
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetLuck();Legge il contatore dello stato del tuo personaggio: punti fortuna.
Non ci sono parametri.
int — punti fortuna, 0..65535 nel modello client. 0 può essere un valore reale, nessun dato o un giocatore scomparso/distrutto. Questa è una quantità, non bool, ID o type: 1 significa un'unità, non successo. Il comando non esegue iterazioni sugli oggetti e non restituisce un array.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.Luck se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- Luck legge i punti fortuna del server memorizzati come UInt16 dallo stato type >= 4. Questa non è una percentuale, un numero casuale o una garanzia della qualità del bottino. Durante la lettura, il cliente non calcola il tasso di rilascio e non aggiunge bonus all'equipaggiamento.
- CharacterStatus controlla il corpo richiesto prima dell'aggiornamento. Weight è disponibile nel suo stato esteso, slot - da type 3, Luck - da type 4, server WeightMax - da type 5. Un pacchetto compatto/vecchio senza un contatore opzionale lascia la cache precedente. Il nuovo Player inizia da zero; la chiamata non dimostra il ricevimento di un nuovo status.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
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.GetLuck();
UO.Print("GetLuck: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza una chiamata senza argomento al proprio carattere; Convert.ToString formatta il numero del log senza cambiarne il significato.
var value = UO.GetLuck();
UO.Print("Luck: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- UO.Wait(500) separa il prima e il dopo di 500 millisecondi. difference can be positive, zero or negative; Gli aggiornamenti temporanei e le modifiche ai personaggi potrebbero essere saltati. La pausa è un esempio.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetLuck();
await Delay(500);
var after = UO.GetLuck();
var difference = after - before;
UO.Print("Counter change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- LuckAtLeast(minimo) riceve un requisito numerico; 1000 è un esempio, non un limite o una percentuale. Rifiuta l'assenza di un Giocatore, legge fortuna una volta e restituisce bool: true o false per valore >= minimo. La fortuna in sé non è bool. I punti memorizzati nella cache vengono confrontati e non vengono previsti i bottini.
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()
{
if (Truth(Truth(LuckAtLeast(1000)) == true))
{
UO.Print("Local check passed");
}
else
{
UO.Print("Local check failed or data unavailable");
}
return null;
}
dynamic LuckAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetLuck();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetMana();
dynamic UO.GetMana(object? arg0);Legge il mana attuale dal modello locale.
-
ObjID— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.
int è il valore del campo Mana, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.GetMana();
UO.Print("GetMana: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.GetMana();
UO.Print("GetMana: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetMana();
if (Truth(value >= 10))
{
UO.Print("At least ten mana points are known");
}
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:
- lasttarget — oggetto precedentemente selezionato; Exists verifica la disponibilità. obj è l'unico parametro di ReadValue. La funzione restituisce il numero del comando invariato e viene fornito nella sua interezza.
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()
{
if (Truth(UO.Exists("lasttarget")))
{
var value = ReadValue("lasttarget");
UO.Print("Selected value: " + Convert.ToString(value));
}
return null;
}
dynamic ReadValue(dynamic obj)
{
return UO.GetMana(obj);
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetMaxHP();
int UO.GetMaxHP(object? arg0);Legge l'integrità massima dal modello locale.
-
ObjID— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare. -
id— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.
int è il valore del campo HitsMax, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.GetMaxHP();
UO.Print("GetMaxHP: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.GetMaxHP();
UO.Print("GetMaxHP: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetMaxHP();
if (Truth(value > 0))
{
UO.Print("Known HP percent: " + Convert.ToString(UO.GetHP() * 100 / value));
}
else
{
UO.Print("HP maximum unavailable");
}
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:
- lasttarget — oggetto precedentemente selezionato; Exists verifica la disponibilità. obj è l'unico parametro di ReadValue. La funzione restituisce il numero del comando invariato e viene fornito nella sua interezza.
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()
{
if (Truth(UO.Exists("lasttarget")))
{
var value = ReadValue("lasttarget");
UO.Print("Selected value: " + Convert.ToString(value));
}
return null;
}
dynamic ReadValue(dynamic obj)
{
return UO.GetMaxHP(obj);
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetMaxLife();Legge l'integrità massima dal modello locale.
Non ci sono parametri.
int è il valore del campo HitsMax, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.GetMaxLife();
UO.Print("GetMaxLife: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.GetMaxLife();
UO.Print("GetMaxLife: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetMaxLife();
if (Truth(value > 0))
{
UO.Print("Known HP percent: " + Convert.ToString(UO.GetHP() * 100 / value));
}
else
{
UO.Print("HP maximum unavailable");
}
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:
- Questo nome non ha la forma con ID. ReadValue senza parametri legge self; le due chiamate sono separate da UO.Wait(1000). Confrontando due istantanee potrebbero non essere rilevate modifiche intermedie.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = ReadValue();
await Delay(1000);
var after = ReadValue();
UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
return null;
}
dynamic ReadValue()
{
return UO.GetMaxLife();
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetMaxMana();
dynamic UO.GetMaxMana(object? arg0);Legge il mana massimo dal modello locale.
-
ObjID— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.
int è il valore del campo ManaMax, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.GetMaxMana();
UO.Print("GetMaxMana: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.GetMaxMana();
UO.Print("GetMaxMana: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetMaxMana();
if (Truth(value > 0))
{
UO.Print("Mana percent: " + Convert.ToString(UO.Mana() * 100 / value));
}
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:
- lasttarget — oggetto precedentemente selezionato; Exists verifica la disponibilità. obj è l'unico parametro di ReadValue. La funzione restituisce il numero del comando invariato e viene fornito nella sua interezza.
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()
{
if (Truth(UO.Exists("lasttarget")))
{
var value = ReadValue("lasttarget");
UO.Print("Selected value: " + Convert.ToString(value));
}
return null;
}
dynamic ReadValue(dynamic obj)
{
return UO.GetMaxMana(obj);
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetMaxStam();
dynamic UO.GetMaxStam(object? arg0);Legge la resistenza massima dal modello locale.
-
ObjID— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.
int è il valore del campo StaminaMax, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.GetMaxStam();
UO.Print("GetMaxStam: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.GetMaxStam();
UO.Print("GetMaxStam: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetMaxStam();
if (Truth(value > 0))
{
UO.Print("Stamina percent: " + Convert.ToString(UO.Stamina() * 100 / value));
}
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:
- lasttarget — oggetto precedentemente selezionato; Exists verifica la disponibilità. obj è l'unico parametro di ReadValue. La funzione restituisce il numero del comando invariato e viene fornito nella sua interezza.
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()
{
if (Truth(UO.Exists("lasttarget")))
{
var value = ReadValue("lasttarget");
UO.Print("Selected value: " + Convert.ToString(value));
}
return null;
}
dynamic ReadValue(dynamic obj)
{
return UO.GetMaxStam(obj);
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetMaxStamina();Legge la resistenza massima dal modello locale.
Non ci sono parametri.
int è il valore del campo StaminaMax, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.GetMaxStamina();
UO.Print("GetMaxStamina: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.GetMaxStamina();
UO.Print("GetMaxStamina: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetMaxStamina();
if (Truth(value > 0))
{
UO.Print("Stamina percent: " + Convert.ToString(UO.Stamina() * 100 / value));
}
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:
- Questo nome non ha la forma con ID. ReadValue senza parametri legge self; le due chiamate sono separate da UO.Wait(1000). Confrontando due istantanee potrebbero non essere rilevate modifiche intermedie.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = ReadValue();
await Delay(1000);
var after = ReadValue();
UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
return null;
}
dynamic ReadValue()
{
return UO.GetMaxStamina();
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetMaxWeight();Legge il contatore dello stato del tuo personaggio: peso massimo in pietre.
Non ci sono parametri.
int — peso massimo in pietre, 0..65535 nel modello client. 0 può essere un valore reale, nessun dato o un giocatore scomparso/distrutto. Questa è una quantità, non bool, ID o type: 1 significa un'unità, non successo. Il comando non esegue iterazioni sugli oggetti e non restituisce un array.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.WeightMax se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- MaxWeight legge la cache WeightMax. Lo stato nativo type >= 5 imposta il limite del server su UInt16, anche se è uguale a 0. Il vecchio stato esteso lo calcola una volta alla ricezione: protocollo UO >= 5.0.0a - 7 * floor(Convert.ToString / 2) + 40; quello più vecchio è Convert.ToString * 4 + 25. Il risultato viene salvato come UInt16; i valori estremi vengono avvolti modulo 65536. Converti.ToString=101 dà rispettivamente 390 o 429. Quando si modifica Convert.ToString separatamente, il getter stesso non ricalcola il limite.
- CharacterStatus controlla il corpo richiesto prima dell'aggiornamento. Weight è disponibile nel suo stato esteso, slot - da type 3, Luck - da type 4, server WeightMax - da type 5. Un pacchetto compatto/vecchio senza un contatore opzionale lascia la cache precedente. Il nuovo Player inizia da zero; la chiamata non dimostra il ricevimento di un nuovo status.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
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.GetMaxWeight();
UO.Print("GetMaxWeight: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza una chiamata senza argomento al proprio carattere; Convert.ToString formatta il numero del log senza cambiarne il significato.
var value = UO.GetMaxWeight();
UO.Print("WeightMax: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- UO.Wait(500) separa il prima e il dopo di 500 millisecondi. difference can be positive, zero or negative; Gli aggiornamenti temporanei e le modifiche ai personaggi potrebbero essere saltati. La pausa è un esempio.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetMaxWeight();
await Delay(500);
var after = UO.GetMaxWeight();
var difference = after - before;
UO.Print("Counter change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- CanCarry(extra) ottiene un peso extra in pietre; 10 è un esempio, non il numero di stack. Rifiuta extra negativo, nessun giocatore o massimo <= 0, legge il peso e il limite attuali, quindi restituisce bool: true o false con extra <= massimo - corrente. La sottrazione evita l'eccesso di corrente + extra. In caso di sovraccarico, il risultato è false anche per extra=0. Questa è una valutazione locale, non una risoluzione del server; le letture non sono atomiche e il peso zero potrebbe essere sconosciuto.
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()
{
if (Truth(Truth(CanCarry(10)) == true))
{
UO.Print("Local check passed");
}
else
{
UO.Print("Local check failed or data unavailable");
}
return null;
}
dynamic CanCarry(dynamic extra)
{
if (Truth(extra < 0) || Truth(UO.Self() == 0))
{
return false;
}
var current = UO.Weight();
var maximum = UO.GetMaxWeight();
if (Truth(maximum <= 0))
{
return false;
}
return extra <= maximum - current;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetParalisa();
int UO.GetParalisa(object? arg0);Controlla il flag di paralisi del personaggio noto al client.
-
value- Opzionale serial/ID mobile: numero, stringa esadecimale, self, lasttarget o altro nome di oggetto standard o nome AddObject. Questo non è graphic/type. Senza argomento, viene utilizzato self. Il nome sconosciuto viene risolto in 0; l'obiettivo non si apre.
Flag numerico int: 1 (condizione soddisfatta) - caricato mobile ha flag IsParalyzed; 0 (condizione non soddisfatta) - nessun flag, mobile sconosciuto, eliminato o l'oggetto è un elemento. Questo non è un momento di paralisi e non garantisce la capacità di muoversi con un risultato di 0.
- Usa Paralyzed per controllare la bandiera della paralisi. Le opzioni Is/Get, GetParalisa, Frozen e GetLocked leggono lo stesso flag.
- Il comando legge solo i dati locali. Non applica né rimuove la paralisi, non ne attende la fine e non invia una richiesta di aggiornamento al server.
- Il risultato di questo comando è di tipo int: usa if (valore != 0) o if (valore == 0). Non sono consentiti confronti diretti con true/false e if (valore) in C#. Il valore conserva il significato del flag, non la quantità o ID.
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.GetParalisa();
UO.Print("GetParalisa: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Le parentesi vuote selezionano self. lo stato memorizza un'istantanea della bandiera; true è la costante numerica 1.
- Un risultato di false non esclude un muro, mancanza di resistenza o altro motivo per fermarsi.
var state = UO.GetParalisa();
if (Truth(Truth(state) == true))
{
UO.Print("Paralysis flag is set");
}
else
{
UO.Print("Paralysis flag is absent or unavailable");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- target memorizza la stringa esadecimale serial dell'ultimo target. IsNpc controlla che sia il mobile caricato, giocatori compresi.
- Il comando con l'argomento legge target. Non sceglie un nuovo personaggio né cambia lasttarget.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var state = UO.GetParalisa(target);
UO.Print("Selected mobile paralysis 1/0: " + Convert.ToString(state));
}
else
{
UO.Print("No loaded mobile selected");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Non più di 10 pause per 100 ms. Ogni chiamata senza argomento rilegge self.
- Dopo il ciclo, la presenza di self viene controllata separatamente. Questa è un'osservazione per circa un secondo più l'esecuzione dei comandi e non una rimozione garantita della paralisi.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var attempts = 0;
while (Truth(Truth(UO.GetParalisa()) == true) && Truth(attempts < 10))
{
await Delay(100);
attempts = attempts + 1;
}
if (Truth(UO.IsNPC("self")))
{
if (Truth(Truth(UO.GetParalisa()) == false))
{
UO.Print("Paralysis flag is clear");
}
else
{
UO.Print("Still paralyzed");
}
}
else
{
UO.Print("Self is unavailable");
}
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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetParalysed();
int UO.GetParalysed(object? arg0);Controlla il flag di paralisi del personaggio noto al client.
-
value- Opzionale serial/ID mobile: numero, stringa esadecimale, self, lasttarget o altro nome di oggetto standard o nome AddObject. Questo non è graphic/type. Senza argomento, viene utilizzato self. Il nome sconosciuto viene risolto in 0; l'obiettivo non si apre.
Flag numerico int: 1 (condizione soddisfatta) - caricato mobile ha flag IsParalyzed; 0 (condizione non soddisfatta) - nessun flag, mobile sconosciuto, eliminato o l'oggetto è un elemento. Questo non è un momento di paralisi e non garantisce la capacità di muoversi con un risultato di 0.
- Usa Paralyzed per controllare la bandiera della paralisi. Le opzioni Is/Get, GetParalisa, Frozen e GetLocked leggono lo stesso flag.
- Il comando legge solo i dati locali. Non applica né rimuove la paralisi, non ne attende la fine e non invia una richiesta di aggiornamento al server.
- Il risultato di questo comando è di tipo int: usa if (valore != 0) o if (valore == 0). Non sono consentiti confronti diretti con true/false e if (valore) in C#. Il valore conserva il significato del flag, non la quantità o ID.
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.GetParalysed();
UO.Print("GetParalysed: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Le parentesi vuote selezionano self. lo stato memorizza un'istantanea della bandiera; true è la costante numerica 1.
- Un risultato di false non esclude un muro, mancanza di resistenza o altro motivo per fermarsi.
var state = UO.GetParalysed();
if (Truth(Truth(state) == true))
{
UO.Print("Paralysis flag is set");
}
else
{
UO.Print("Paralysis flag is absent or unavailable");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- target memorizza la stringa esadecimale serial dell'ultimo target. IsNpc controlla che sia il mobile caricato, giocatori compresi.
- Il comando con l'argomento legge target. Non sceglie un nuovo personaggio né cambia lasttarget.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var state = UO.GetParalysed(target);
UO.Print("Selected mobile paralysis 1/0: " + Convert.ToString(state));
}
else
{
UO.Print("No loaded mobile selected");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Non più di 10 pause per 100 ms. Ogni chiamata senza argomento rilegge self.
- Dopo il ciclo, la presenza di self viene controllata separatamente. Questa è un'osservazione per circa un secondo più l'esecuzione dei comandi e non una rimozione garantita della paralisi.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var attempts = 0;
while (Truth(Truth(UO.GetParalysed()) == true) && Truth(attempts < 10))
{
await Delay(100);
attempts = attempts + 1;
}
if (Truth(UO.IsNPC("self")))
{
if (Truth(Truth(UO.GetParalysed()) == false))
{
UO.Print("Paralysis flag is clear");
}
else
{
UO.Print("Still paralyzed");
}
}
else
{
UO.Print("Self is unavailable");
}
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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetParalyzed();
int UO.GetParalyzed(object? arg0);Controlla il flag di paralisi del personaggio noto al client.
-
value- Opzionale serial/ID mobile: numero, stringa esadecimale, self, lasttarget o altro nome di oggetto standard o nome AddObject. Questo non è graphic/type. Senza argomento, viene utilizzato self. Il nome sconosciuto viene risolto in 0; l'obiettivo non si apre.
Flag numerico int: 1 (condizione soddisfatta) - caricato mobile ha flag IsParalyzed; 0 (condizione non soddisfatta) - nessun flag, mobile sconosciuto, eliminato o l'oggetto è un elemento. Questo non è un momento di paralisi e non garantisce la capacità di muoversi con un risultato di 0.
- Usa Paralyzed per controllare la bandiera della paralisi. Le opzioni Is/Get, GetParalisa, Frozen e GetLocked leggono lo stesso flag.
- Il comando legge solo i dati locali. Non applica né rimuove la paralisi, non ne attende la fine e non invia una richiesta di aggiornamento al server.
- Il risultato di questo comando è di tipo int: usa if (valore != 0) o if (valore == 0). Non sono consentiti confronti diretti con true/false e if (valore) in C#. Il valore conserva il significato del flag, non la quantità o ID.
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.GetParalyzed();
UO.Print("GetParalyzed: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Le parentesi vuote selezionano self. lo stato memorizza un'istantanea della bandiera; true è la costante numerica 1.
- Un risultato di false non esclude un muro, mancanza di resistenza o altro motivo per fermarsi.
var state = UO.GetParalyzed();
if (Truth(Truth(state) == true))
{
UO.Print("Paralysis flag is set");
}
else
{
UO.Print("Paralysis flag is absent or unavailable");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- target memorizza la stringa esadecimale serial dell'ultimo target. IsNpc controlla che sia il mobile caricato, giocatori compresi.
- Il comando con l'argomento legge target. Non sceglie un nuovo personaggio né cambia lasttarget.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var state = UO.GetParalyzed(target);
UO.Print("Selected mobile paralysis 1/0: " + Convert.ToString(state));
}
else
{
UO.Print("No loaded mobile selected");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Non più di 10 pause per 100 ms. Ogni chiamata senza argomento rilegge self.
- Dopo il ciclo, la presenza di self viene controllata separatamente. Questa è un'osservazione per circa un secondo più l'esecuzione dei comandi e non una rimozione garantita della paralisi.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var attempts = 0;
while (Truth(Truth(UO.GetParalyzed()) == true) && Truth(attempts < 10))
{
await Delay(100);
attempts = attempts + 1;
}
if (Truth(UO.IsNPC("self")))
{
if (Truth(Truth(UO.GetParalyzed()) == false))
{
UO.Print("Paralysis flag is clear");
}
else
{
UO.Print("Still paralyzed");
}
}
else
{
UO.Print("Self is unavailable");
}
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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetPhysicalResist();Legge il campo di resistenza del personaggio attuale: armatura/resistenza fisica.
Non ci sono parametri.
int: valore dello stato con segno, -32768..32767 nel modello client. Il valore negativo viene mantenuto. 0 può essere resistenza reale, mancanza di dati o giocatore scomparso/distrutto; GetResist fornisce anche 0 per un selettore sconosciuto. Questo non è un bool, ID, limite di abilità o resistenza. 1 significa un punto, non un successo.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.PhysicalResistance se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- PhysicalResistance - campo armatura/stato del server: il server classico può trasmettere il valore dell'armatura e le regole con resistenze possono trasmettere resistenza fisica. API non converte dall'uno all'altro e non calcola la percentuale di riduzione del danno. Armor e gli alias fisici leggono lo stesso campo.
- CharacterStatus controlla il corpo richiesto prima di modificare il nome, la salute e le proprie caratteristiche, quindi traduce ogni parola di resistenza in una parola firmata Int16. Un corpo obbligatorio tagliato non modifica i dati precedenti. La coda opzionale type 6 mantiene le stesse regole; i comandi di resistenza non leggono i limiti massimi da esso.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
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.GetPhysicalResist();
UO.Print("GetPhysicalResist: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato di una chiamata. Convert.ToString formatta il numero per il registro. Non ci sono argomenti: puoi leggere il tuo personaggio.
var value = UO.GetPhysicalResist();
UO.Print("PhysicalResistance: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Tra prima e dopo ci sono UO.Wait(500) millisecondi; difference can be negative. Interim updates may be missed. La pausa si riferisce all'esempio, non al ritardo API.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetPhysicalResist();
await Delay(500);
var after = UO.GetPhysicalResist();
var difference = after - before;
UO.Print("Resistance change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=50 è un esempio di requisito, non di limite del cliente. ResistanceAtLeast rifiuta il Giocatore mancante, legge un valore e restituisce bool: true o false se valore >= minimo. La resistenza stessa non è bool. La funzione è completamente dichiarata di seguito.
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()
{
if (Truth(Truth(ResistanceAtLeast(50)) == true))
{
UO.Print("Local resistance requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic ResistanceAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetPhysicalResist();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
dynamic UO.GetPlayerStatusText(object? arg0);Genera un breve testo con il nome e la salute dell'oggetto.
-
ObjID— Seriale/ID di un oggetto specifico: int, stringa decimale/esadecimale o set alias self, backpack, lasttarget, lastobject o nome AddObject. Questo non è graphic/type.
string nel formato "nome HP/MaxHP". Ad esempio "Raven 75/100". Per un oggetto sconosciuto, solitamente "0/0" con uno spazio iniziale. Questo è testo, non struttura, bool o un gump di stato aperto.
- GetName/GetHP/GetMaxHP vengono letti senza richiedere un aggiornamento. Non analizzare il testo in base allo spazio per ottenere ID o HP: il nome può contenere spazi, utilizzare comandi getter separati per i numeri.
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.GetPlayerStatusText("self");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- ObjID=self - carattere corrente.
- Print mostra il testo finito nel diario.
UO.Print(UO.GetPlayerStatusText("self"));Parametri e flusso di esecuzione:
- ObjID=serial dell'ultimo target.
- Exists impedisce l'output di un oggetto sconosciuto come 0/0.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(target)))
{
UO.Print(UO.GetPlayerStatusText(target));
}
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:
- 500 - millisecondi tra le letture.
- Viene confrontato il testo del nome/HP, non tutte le caratteristiche del carattere.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = UO.GetPlayerStatusText("self");
await Delay(500);
var after = UO.GetPlayerStatusText("self");
if (Truth(before != after))
{
UO.Print(after);
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetPoisonResist();Legge il campo di resistenza del personaggio attuale: veleno.
Non ci sono parametri.
int: valore dello stato con segno, -32768..32767 nel modello client. Il valore negativo viene mantenuto. 0 può essere resistenza reale, mancanza di dati o giocatore scomparso/distrutto; GetResist fornisce anche 0 per un selettore sconosciuto. Questo non è un bool, ID, limite di abilità o resistenza. 1 significa un punto, non un successo.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.PoisonResistance se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- I campi elementari sono estesi CharacterStatus (0x11), type >= 4. Il comando stesso non controlla l'epoca del server. Lo stato compatto/vecchio senza questi campi lascia la cache precedente; Il nuovo Giocatore è inizialmente 0. La Resistenza al Veleno non è una bandiera Poisoned; Inoltre non è un'abilità di resistenza agli incantesimi.
- CharacterStatus controlla il corpo richiesto prima di modificare il nome, la salute e le proprie caratteristiche, quindi traduce ogni parola di resistenza in una parola firmata Int16. Un corpo obbligatorio tagliato non modifica i dati precedenti. La coda opzionale type 6 mantiene le stesse regole; i comandi di resistenza non leggono i limiti massimi da esso.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
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.GetPoisonResist();
UO.Print("GetPoisonResist: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato di una chiamata. Convert.ToString formatta il numero per il registro. Non ci sono argomenti: puoi leggere il tuo personaggio.
var value = UO.GetPoisonResist();
UO.Print("PoisonResistance: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Tra prima e dopo ci sono UO.Wait(500) millisecondi; difference can be negative. Interim updates may be missed. La pausa si riferisce all'esempio, non al ritardo API.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetPoisonResist();
await Delay(500);
var after = UO.GetPoisonResist();
var difference = after - before;
UO.Print("Resistance change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=50 è un esempio di requisito, non di limite del cliente. ResistanceAtLeast rifiuta il Giocatore mancante, legge un valore e restituisce bool: true o false se valore >= minimo. La resistenza stessa non è bool. La funzione è completamente dichiarata di seguito.
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()
{
if (Truth(Truth(ResistanceAtLeast(50)) == true))
{
UO.Print("Local resistance requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic ResistanceAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetPoisonResist();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetPoisoned();
int UO.GetPoisoned(object? arg0);Controlla l'avvelenamento del personaggio.
-
value— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.
Flag numerico int: 1 (condizione soddisfatta), 0 (condizione non soddisfatta). Questo è un flag numerico: in C# controlla risultato != 0 o risultato == 0. Il confronto diretto di int con true/false e if (risultato) non è consentito. 1 - mobile ha IsPoisoned, 0 non ha flag o mobile manca. Il grado di veleno e il tempo rimanente non vengono restituiti.
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 il modello locale: non apre il target, non richiede lo stato, non cambia il flag e non invia il pacchetto. Un oggetto distrutto è considerato mancante anche prima che la voce venga cancellata dal dizionario.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Per Poisoned/Flying viene presa in considerazione la versione del protocollo: fino a 7.0.0.0 il bit 0x04 significa veleno; iniziando con 7.0.0.0 significa fuga e il veleno viene immagazzinato separatamente. Il volo non viene calcolato da Z.
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.GetPoisoned();
UO.Print("GetPoisoned: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Le parentesi vuote leggono self. attivo salva il risultato una volta; true e false definiscono due rami. Print visualizza solo un messaggio di esempio.
var active = UO.GetPoisoned();
if (Truth(Truth(active) == true))
{
UO.Print("State is active");
}
else
{
UO.Print("State is inactive or unavailable");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- lasttarget – oggetto precedentemente selezionato. Exists ne verifica la presenza. obj è l'unico parametro ReadState; la funzione restituisce il risultato del comando senza modifiche. La sua definizione è inclusa nel codice copiato.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
if (Truth(UO.Exists("lasttarget")))
{
var observed = ReadState("lasttarget");
UO.Print("State 1/0: " + Convert.ToString(observed));
}
return null;
}
dynamic ReadState(dynamic obj)
{
return UO.GetPoisoned(obj);
}
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:
- Due chiamate senza argomenti leggono self, UO.Wait(500) imposta 500 millisecondi. Vengono confrontate due immagini; le transizioni intermedie possono essere saltate. Non esiste un'attesa infinita.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = UO.GetPoisoned();
await Delay(500);
var after = UO.GetPoisoned();
if (Truth(before != after))
{
UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetRace();Legge la razza del personaggio dal modello client.
Non ci sono parametri.
int — 1=umano, 2=elfo, 3=gargoyle secondo il modello del client. 0 significa nessun carattere caricato. Non è body/graphic e non serial.
- I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
- Queste sono funzioni di lettura: assegnando il risultato a una variabile si salva lo snapshot. Non cambia le caratteristiche del personaggio. I nomi non fanno distinzione tra maiuscole e minuscole; utilizzare esattamente la forma mostrata con il numero di argomenti richiesto.
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.GetRace();
UO.Print("GetRace: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti si riferisce a self. La razza del personaggio viene memorizzata come valore.
- Convert.ToString converte il numero da emettere e non cambia il significato del risultato.
var value = UO.GetRace();
UO.Print("GetRace: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Il valore viene letto una volta senza argomenti. La razza del personaggio viene utilizzata nel calcolo o nella condizione mostrata.
- Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetRace();
if (Truth(value == 3))
{
UO.Print("Player race is gargoyle");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Entrambe le chiamate senza argomento leggono il loro valore corrente. UO.Wait(1000) dà una pausa in millisecondi tra gli scatti.
- Cambiamento rispetto: razza del personaggio. Un esempio non cambia nulla al mondo e non aspetta all'infinito. Gli eventi entro questo secondo potrebbero essere persi.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = UO.GetRace();
await Delay(1000);
var after = UO.GetRace();
if (Truth(before != after))
{
UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetResist(object? arg0);Legge una delle resistenze del tuo personaggio utilizzando un selettore numerico o di stringa.
-
resistance— è richiesta la resistenza. Numeri: 0=fisico, 1=fuoco, 2=freddo, 3=veleno, 4=energia. Linee: fisico/fisico/armatura, fuoco, freddo, veleno, energia. Le maiuscole e gli spazi finali vengono ignorati. Non c'è serial, type, hue, vista o secondo argomento.
int: valore dello stato con segno, -32768..32767 nel modello client. Il valore negativo viene mantenuto. 0 può essere resistenza reale, mancanza di dati o giocatore scomparso/distrutto; GetResist fornisce anche 0 per un selettore sconosciuto. Questo non è un bool, ID, limite di abilità o resistenza. 1 significa un punto, non un successo.
- GetResistance distingue innanzitutto il tipo di valore: le stringhe "1" e "0" sono nomi sconosciuti, danno 0 e non sono selettori numerici. Una non stringa double scarta la frazione a zero: 1.9 -> fuoco, -0.9 -> fisico. true=1 seleziona il fuoco, false=0 seleziona il fisico; Anche l'array/null viene convertito in 0. Utilizzare un numero intero esplicito o un nome valido. I nomi AddObject non sono ammessi.
- GetResistance seleziona esattamente un campo bridge. Numeri/nomi sconosciuti danno int 0 senza leggere il campo. Il comando non rimuove atomicamente cinque valori e non modifica la resistenza.
- PhysicalResistance - campo armatura/stato del server: il server classico può trasmettere il valore dell'armatura e le regole con resistenze possono trasmettere resistenza fisica. API non converte dall'uno all'altro e non calcola la percentuale di riduzione del danno. Armor e gli alias fisici leggono lo stesso campo.
- I campi elementari sono estesi CharacterStatus (0x11), type >= 4. Il comando stesso non controlla l'epoca del server. Lo stato compatto/vecchio senza questi campi lascia la cache precedente; Il nuovo Giocatore è inizialmente 0. La Resistenza al Veleno non è una bandiera Poisoned; Inoltre non è un'abilità di resistenza agli incantesimi.
- CharacterStatus controlla il corpo richiesto prima di modificare il nome, la salute e le proprie caratteristiche, quindi traduce ogni parola di resistenza in una parola firmata Int16. Un corpo obbligatorio tagliato non modifica i dati precedenti. La coda opzionale type 6 mantiene le stesse regole; i comandi di resistenza non leggono i limiti massimi da esso.
- Invoca letture sul flusso di gioco con la possibilità di annullare l'attesa tramite script. Non interroga lo stato, non apre il target, non invia un pacchetto, non cambia le caratteristiche e non aggiunge ritardo.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
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.GetResist("fire");
UO.Print("GetResist: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Resistance=" FiRe " seleziona il fuoco dopo aver rimosso gli spazi finali e non fa distinzione tra maiuscole e minuscole. il valore rimane un numero con segno; la vista non appare.
var value = UO.GetResist(" FiRe ");
UO.Print("Fire resistance: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- 2 seleziona freddo; "veleno" - veleno. Questi sono selettori, non serial. Il confronto di due istantanee restituisce bool; La Resistenza al Veleno non dice se un personaggio è avvelenato.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var cold = UO.GetResist(2);
var poison = UO.GetResist("poison");
if (Truth(cold < poison))
{
UO.Print("Cold resistance is lower");
}
else
{
UO.Print("Cold resistance is equal or higher");
}
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=50 è un esempio di requisito, non di limite del cliente. ResistanceAtLeast rifiuta il Giocatore mancante, legge un valore e restituisce bool: true o false se valore >= minimo. La resistenza stessa non è bool. La funzione è completamente dichiarata di seguito.
- il selettore viene passato dalla funzione a GetResist senza modifiche; l'esempio usa "fuoco". La funzione verifica la presenza del Giocatore, ma non convalida il selettore arbitrario e non conferma la freschezza dello stato. Utilizza il selettore dall'elenco sopra.
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()
{
if (Truth(Truth(ResistanceAtLeast("fire", 50)) == true))
{
UO.Print("Local fire resistance requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic ResistanceAtLeast(dynamic selector, dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetResist(selector);
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetResistCold();Legge il campo di resistenza del personaggio attuale: freddo.
Non ci sono parametri.
int: valore dello stato con segno, -32768..32767 nel modello client. Il valore negativo viene mantenuto. 0 può essere resistenza reale, mancanza di dati o giocatore scomparso/distrutto; GetResist fornisce anche 0 per un selettore sconosciuto. Questo non è un bool, ID, limite di abilità o resistenza. 1 significa un punto, non un successo.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.ColdResistance se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- I campi elementari sono estesi CharacterStatus (0x11), type >= 4. Il comando stesso non controlla l'epoca del server. Lo stato compatto/vecchio senza questi campi lascia la cache precedente; Il nuovo Giocatore è inizialmente 0. La Resistenza al Veleno non è una bandiera Poisoned; Inoltre non è un'abilità di resistenza agli incantesimi.
- CharacterStatus controlla il corpo richiesto prima di modificare il nome, la salute e le proprie caratteristiche, quindi traduce ogni parola di resistenza in una parola firmata Int16. Un corpo obbligatorio tagliato non modifica i dati precedenti. La coda opzionale type 6 mantiene le stesse regole; i comandi di resistenza non leggono i limiti massimi da esso.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
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.GetResistCold();
UO.Print("GetResistCold: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato di una chiamata. Convert.ToString formatta il numero per il registro. Non ci sono argomenti: puoi leggere il tuo personaggio.
var value = UO.GetResistCold();
UO.Print("ColdResistance: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Tra prima e dopo ci sono UO.Wait(500) millisecondi; difference can be negative. Interim updates may be missed. La pausa si riferisce all'esempio, non al ritardo API.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetResistCold();
await Delay(500);
var after = UO.GetResistCold();
var difference = after - before;
UO.Print("Resistance change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=50 è un esempio di requisito, non di limite del cliente. ResistanceAtLeast rifiuta il Giocatore mancante, legge un valore e restituisce bool: true o false se valore >= minimo. La resistenza stessa non è bool. La funzione è completamente dichiarata di seguito.
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()
{
if (Truth(Truth(ResistanceAtLeast(50)) == true))
{
UO.Print("Local resistance requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic ResistanceAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetResistCold();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetResistEnergy();Legge il campo di resistenza del personaggio attuale: energia.
Non ci sono parametri.
int: valore dello stato con segno, -32768..32767 nel modello client. Il valore negativo viene mantenuto. 0 può essere resistenza reale, mancanza di dati o giocatore scomparso/distrutto; GetResist fornisce anche 0 per un selettore sconosciuto. Questo non è un bool, ID, limite di abilità o resistenza. 1 significa un punto, non un successo.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.EnergyResistance se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- I campi elementari sono estesi CharacterStatus (0x11), type >= 4. Il comando stesso non controlla l'epoca del server. Lo stato compatto/vecchio senza questi campi lascia la cache precedente; Il nuovo Giocatore è inizialmente 0. La Resistenza al Veleno non è una bandiera Poisoned; Inoltre non è un'abilità di resistenza agli incantesimi.
- CharacterStatus controlla il corpo richiesto prima di modificare il nome, la salute e le proprie caratteristiche, quindi traduce ogni parola di resistenza in una parola firmata Int16. Un corpo obbligatorio tagliato non modifica i dati precedenti. La coda opzionale type 6 mantiene le stesse regole; i comandi di resistenza non leggono i limiti massimi da esso.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
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.GetResistEnergy();
UO.Print("GetResistEnergy: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato di una chiamata. Convert.ToString formatta il numero per il registro. Non ci sono argomenti: puoi leggere il tuo personaggio.
var value = UO.GetResistEnergy();
UO.Print("EnergyResistance: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Tra prima e dopo ci sono UO.Wait(500) millisecondi; difference can be negative. Interim updates may be missed. La pausa si riferisce all'esempio, non al ritardo API.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetResistEnergy();
await Delay(500);
var after = UO.GetResistEnergy();
var difference = after - before;
UO.Print("Resistance change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=50 è un esempio di requisito, non di limite del cliente. ResistanceAtLeast rifiuta il Giocatore mancante, legge un valore e restituisce bool: true o false se valore >= minimo. La resistenza stessa non è bool. La funzione è completamente dichiarata di seguito.
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()
{
if (Truth(Truth(ResistanceAtLeast(50)) == true))
{
UO.Print("Local resistance requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic ResistanceAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetResistEnergy();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetResistFire();Legge il campo di resistenza del personaggio attuale: fuoco.
Non ci sono parametri.
int: valore dello stato con segno, -32768..32767 nel modello client. Il valore negativo viene mantenuto. 0 può essere resistenza reale, mancanza di dati o giocatore scomparso/distrutto; GetResist fornisce anche 0 per un selettore sconosciuto. Questo non è un bool, ID, limite di abilità o resistenza. 1 significa un punto, non un successo.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.FireResistance se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- I campi elementari sono estesi CharacterStatus (0x11), type >= 4. Il comando stesso non controlla l'epoca del server. Lo stato compatto/vecchio senza questi campi lascia la cache precedente; Il nuovo Giocatore è inizialmente 0. La Resistenza al Veleno non è una bandiera Poisoned; Inoltre non è un'abilità di resistenza agli incantesimi.
- CharacterStatus controlla il corpo richiesto prima di modificare il nome, la salute e le proprie caratteristiche, quindi traduce ogni parola di resistenza in una parola firmata Int16. Un corpo obbligatorio tagliato non modifica i dati precedenti. La coda opzionale type 6 mantiene le stesse regole; i comandi di resistenza non leggono i limiti massimi da esso.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
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.GetResistFire();
UO.Print("GetResistFire: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato di una chiamata. Convert.ToString formatta il numero per il registro. Non ci sono argomenti: puoi leggere il tuo personaggio.
var value = UO.GetResistFire();
UO.Print("FireResistance: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Tra prima e dopo ci sono UO.Wait(500) millisecondi; difference can be negative. Interim updates may be missed. La pausa si riferisce all'esempio, non al ritardo API.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetResistFire();
await Delay(500);
var after = UO.GetResistFire();
var difference = after - before;
UO.Print("Resistance change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=50 è un esempio di requisito, non di limite del cliente. ResistanceAtLeast rifiuta il Giocatore mancante, legge un valore e restituisce bool: true o false se valore >= minimo. La resistenza stessa non è bool. La funzione è completamente dichiarata di seguito.
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()
{
if (Truth(Truth(ResistanceAtLeast(50)) == true))
{
UO.Print("Local resistance requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic ResistanceAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetResistFire();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetResistPhysical();Legge il campo di resistenza del personaggio attuale: armatura/resistenza fisica.
Non ci sono parametri.
int: valore dello stato con segno, -32768..32767 nel modello client. Il valore negativo viene mantenuto. 0 può essere resistenza reale, mancanza di dati o giocatore scomparso/distrutto; GetResist fornisce anche 0 per un selettore sconosciuto. Questo non è un bool, ID, limite di abilità o resistenza. 1 significa un punto, non un successo.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.PhysicalResistance se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- PhysicalResistance - campo armatura/stato del server: il server classico può trasmettere il valore dell'armatura e le regole con resistenze possono trasmettere resistenza fisica. API non converte dall'uno all'altro e non calcola la percentuale di riduzione del danno. Armor e gli alias fisici leggono lo stesso campo.
- CharacterStatus controlla il corpo richiesto prima di modificare il nome, la salute e le proprie caratteristiche, quindi traduce ogni parola di resistenza in una parola firmata Int16. Un corpo obbligatorio tagliato non modifica i dati precedenti. La coda opzionale type 6 mantiene le stesse regole; i comandi di resistenza non leggono i limiti massimi da esso.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
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.GetResistPhysical();
UO.Print("GetResistPhysical: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato di una chiamata. Convert.ToString formatta il numero per il registro. Non ci sono argomenti: puoi leggere il tuo personaggio.
var value = UO.GetResistPhysical();
UO.Print("PhysicalResistance: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Tra prima e dopo ci sono UO.Wait(500) millisecondi; difference can be negative. Interim updates may be missed. La pausa si riferisce all'esempio, non al ritardo API.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetResistPhysical();
await Delay(500);
var after = UO.GetResistPhysical();
var difference = after - before;
UO.Print("Resistance change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=50 è un esempio di requisito, non di limite del cliente. ResistanceAtLeast rifiuta il Giocatore mancante, legge un valore e restituisce bool: true o false se valore >= minimo. La resistenza stessa non è bool. La funzione è completamente dichiarata di seguito.
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()
{
if (Truth(Truth(ResistanceAtLeast(50)) == true))
{
UO.Print("Local resistance requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic ResistanceAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetResistPhysical();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetResistPoison();Legge il campo di resistenza del personaggio attuale: veleno.
Non ci sono parametri.
int: valore dello stato con segno, -32768..32767 nel modello client. Il valore negativo viene mantenuto. 0 può essere resistenza reale, mancanza di dati o giocatore scomparso/distrutto; GetResist fornisce anche 0 per un selettore sconosciuto. Questo non è un bool, ID, limite di abilità o resistenza. 1 significa un punto, non un successo.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.PoisonResistance se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- I campi elementari sono estesi CharacterStatus (0x11), type >= 4. Il comando stesso non controlla l'epoca del server. Lo stato compatto/vecchio senza questi campi lascia la cache precedente; Il nuovo Giocatore è inizialmente 0. La Resistenza al Veleno non è una bandiera Poisoned; Inoltre non è un'abilità di resistenza agli incantesimi.
- CharacterStatus controlla il corpo richiesto prima di modificare il nome, la salute e le proprie caratteristiche, quindi traduce ogni parola di resistenza in una parola firmata Int16. Un corpo obbligatorio tagliato non modifica i dati precedenti. La coda opzionale type 6 mantiene le stesse regole; i comandi di resistenza non leggono i limiti massimi da esso.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
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.GetResistPoison();
UO.Print("GetResistPoison: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato di una chiamata. Convert.ToString formatta il numero per il registro. Non ci sono argomenti: puoi leggere il tuo personaggio.
var value = UO.GetResistPoison();
UO.Print("PoisonResistance: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Tra prima e dopo ci sono UO.Wait(500) millisecondi; difference can be negative. Interim updates may be missed. La pausa si riferisce all'esempio, non al ritardo API.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetResistPoison();
await Delay(500);
var after = UO.GetResistPoison();
var difference = after - before;
UO.Print("Resistance change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=50 è un esempio di requisito, non di limite del cliente. ResistanceAtLeast rifiuta il Giocatore mancante, legge un valore e restituisce bool: true o false se valore >= minimo. La resistenza stessa non è bool. La funzione è completamente dichiarata di seguito.
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()
{
if (Truth(Truth(ResistanceAtLeast(50)) == true))
{
UO.Print("Local resistance requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic ResistanceAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetResistPoison();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetSex();Legge il sesso e il codice razziale dal modello client.
Non ci sono parametri.
int - codice compatibile: 0=maschio umano, 1=femmina umana, 2=maschio elfo, 3=femmina elfo, 4=maschio gargoyle, 5=femmina gargoyle. Anche senza carattere è 0, quindi controlla la disponibilità di Exists(self). Questa non è una semplice femmina bool.
- I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
- Queste sono funzioni di lettura: assegnando il risultato a una variabile si salva lo snapshot. Non cambia le caratteristiche del personaggio. I nomi non fanno distinzione tra maiuscole e minuscole; utilizzare esattamente la forma mostrata con il numero di argomenti richiesto.
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.GetSex();
UO.Print("GetSex: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti si riferisce a self. Il sesso e il codice razziale vengono memorizzati nel valore.
- Convert.ToString converte il numero da emettere e non cambia il significato del risultato.
var value = UO.GetSex();
UO.Print("GetSex: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Il valore viene letto una volta senza argomenti. Il sesso e il codice razza vengono utilizzati nel calcolo o nella condizione mostrata.
- Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetSex();
if (Truth(value == 4) || Truth(value == 5))
{
UO.Print("Gargoyle sex/race code");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Entrambe le chiamate senza argomento leggono il loro valore corrente. UO.Wait(1000) dà una pausa in millisecondi tra gli scatti.
- Il cambiamento viene confrontato: genere e codice razziale. Un esempio non cambia nulla al mondo e non aspetta all'infinito. Gli eventi entro questo secondo potrebbero essere persi.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = UO.GetSex();
await Delay(1000);
var after = UO.GetSex();
if (Truth(before != after))
{
UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetStam();
dynamic UO.GetStam(object? arg0);Legge la resistenza attuale dal modello locale.
-
ObjID— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.
int è il valore del campo Stamina, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.GetStam();
UO.Print("GetStam: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.GetStam();
UO.Print("GetStam: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetStam();
if (Truth(value < 15))
{
UO.Print("Known stamina is below the movement threshold of 15");
}
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:
- lasttarget — oggetto precedentemente selezionato; Exists verifica la disponibilità. obj è l'unico parametro di ReadValue. La funzione restituisce il numero del comando invariato e viene fornito nella sua interezza.
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()
{
if (Truth(UO.Exists("lasttarget")))
{
var value = ReadValue("lasttarget");
UO.Print("Selected value: " + Convert.ToString(value));
}
return null;
}
dynamic ReadValue(dynamic obj)
{
return UO.GetStam(obj);
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetStamina();Legge la resistenza attuale dal modello locale.
Non ci sono parametri.
int è il valore del campo Stamina, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.GetStamina();
UO.Print("GetStamina: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.GetStamina();
UO.Print("GetStamina: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetStamina();
if (Truth(value < 15))
{
UO.Print("Known stamina is below the movement threshold of 15");
}
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:
- Questo nome non ha la forma con ID. ReadValue senza parametri legge self; le due chiamate sono separate da UO.Wait(1000). Confrontando due istantanee potrebbero non essere rilevate modifiche intermedie.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = ReadValue();
await Delay(1000);
var after = ReadValue();
UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
return null;
}
dynamic ReadValue()
{
return UO.GetStamina();
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetStatLockState(object? arg0);Legge la modalità di modifica delle caratteristiche locali.
-
statNum- Numero caratteristico obbligatorio: 0 - Converti.ToString, 1 - DEX, 2 - INT. Questo non è il suo valore corrente e non il nome della stringa.
int: 0 - aumento, 1 - diminuzione, 2 - blocco. Questo è un codice di modalità, non true/false. Per un numero esterno a 0..2 restituisce −1. Se il carattere manca, per impostazione predefinita viene restituito un numero valido 0; questa non è una conferma dello stato del server.
- La lettura viene effettuata tramite Invoke sul thread di gioco in base ai dati già ricevuti; i pacchetti di rete non vengono inviati. L'abilità non viene utilizzata né allenata. Due richieste: due snapshot separati.
- Numero caratteristico obbligatorio: 0 - Convert.ToString, 1 - DEX, 2 - INT. Questo non è il suo valore corrente e non il nome della stringa.
- ExecuteClientApiCompatibility seleziona il ramo di comando. Il testo legge il selettore delle abilità, Arg legge i numeri numerici e le modalità. Un argomento non convertibile potrebbe fallire la chiamata con un errore di conversione.
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.GetStatLockState(0);
UO.Print("GetStatLockState: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Nell'esempio, il selettore e, durante la registrazione, la modalità sono specificati esplicitamente. La prima riga seleziona un'abilità per nome o una caratteristica per numero. Print visualizza solo il risultato.
var selector = 0;
var mode = UO.GetStatLockState(selector);
UO.Print(Convert.ToString(mode));Parametri e flusso di esecuzione:
- La soglia 95.1 e le modalità 0/1/2 sono fornite come esempio. −1 viene controllato prima di cambiare modalità. Dopo la scrittura viene letta solo la copia locale; non sta aspettando che il server risponda.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var mode = UO.GetStatLockState(0);
if (Truth(mode == 2))
{
UO.Print("Locked");
}
else
{
if (Truth(mode == -1))
{
UO.Print("Unknown selector");
}
else
{
UO.Print("Mode: " + Convert.ToString(mode));
}
}
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:
- Tutto il codice helper è riportato di seguito Main. il selettore seleziona un'abilità/caratteristica, la modalità imposta la modalità di registrazione. ReadValue/ReadMode restituisce il numero originale; ApplyMode controlla gli argomenti, esegue l'azione e non restituisce un valore. UO.Wait(1000) nell'esempio di lettura separa due immagini.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = ReadMode(0);
await Delay(1000);
var after = ReadMode(0);
UO.Print(Convert.ToString(before) + " -> " + Convert.ToString(after));
return null;
}
dynamic ReadMode(dynamic selector)
{
return UO.GetStatLockState(selector);
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.GetStatus(object? arg0);Invia una richiesta al server per lo stato del mobile specificato.
-
id— Numero seriale dell'oggetto o nome supportato di self/backpack/lasttarget/oggetto salvato; le stringhe numeriche e le stringhe 0x vengono risolte dal runtime.
void: nessun valore restituito.
- string-form resolves name via GetObject; The int-form renders serial directly. Il bridge chiama GameActions.RequestMobileStatus(world,serial,true). Il comando non restituisce dati e non attende una risposta. Leggi GetHP/GetMaxHP e altri getter separatamente dopo l'aggiornamento mondiale.
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.GetStatus");
UO.GetStatus("self");Parametri e flusso di esecuzione:
- Una richiesta di stato viene inviata senza attendere una risposta.
UO.GetStatus("self");Parametri e flusso di esecuzione:
- Il modulo int invia la stessa richiesta.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var id = UO.Self();
UO.GetStatus(id);
return null;
}Parametri e flusso di esecuzione:
- Una pausa non garantisce una nuova risposta; i getter restituiscono il modello locale corrente.
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.GetStatus("self");
await Delay(500);
UO.Print(Convert.ToString(UO.GetHP()) + "/" + Convert.ToString(UO.GetMaxHP()));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetStr();
int UO.GetStr(object? arg0);Legge la potenza attuale (Strength, Convert.ToString) del carattere.
-
ObjID— ObjID solo nella forma mostrata, con un argomento: numero di carattere serial, stringa esadecimale decimale/0x, "self", "lasttarget" o nome AddObject. Seleziona un oggetto diverso da graphic/type. Senza argomenti, viene letto il carattere corrente.
int — punti statistici attuali, 0..65535 nel modello client; non percentuale, ID, abilità, modalità di blocco o bool. 0 significa anche carattere mancante/cancellato o oggetto inaccessibile. Confrontare con il requisito numerico, non == true. Questo non è un limite statistico o un valore base garantito senza modificatori.
- Sono supportati () per self e (ObjID) per un oggetto esplicito. Non ci sono altri argomenti facoltativi.
- Legge Player.Strength se Player esiste e non è stato distrutto; altrimenti 0. Un personaggio morto presente non è un oggetto rimosso. La statistica non viene calcolata da HP, mana o resistenza.
- GetStr/GetInt/GetDex accetta ObjID. I dati PlayerMobile sono disponibili solo per self; per un altro serial - 0, anche per mobile caricato. Le caratteristiche di qualcun altro non vengono sostituite o indovinate.
- Invoca letture sul flusso di gioco con la possibilità di annullare l'attesa tramite script. Non interroga lo stato, non apre il target, non invia un pacchetto, non cambia le caratteristiche e non aggiunge ritardo.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- Nomi caratteristici equivalenti con UO. e senza di essa, non fa distinzione tra maiuscole e minuscole:
Convert.ToString Strength GetStr GetStrength. - ExecuteClientApiCompatibility.Arg prima risolve il nome dell'oggetto, quindi converte il numero. Una stringa non numerica sconosciuta provoca un errore di conversione, non un obiettivo. double è ridotto a int, Array/void è ridotto a 0. Per selezionare un personaggio, usa il serial corretto, non tali trasformazioni.
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.GetStr();
UO.Print("GetStr: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato numerico; Convert.ToString lo formatta semplicemente per la rivista. Non ci sono argomenti o azioni dei personaggi.
var value = UO.GetStr();
UO.Print("Strength: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- prima e dopo 1000 ms separati; UO.Wait aggiunto all'esempio. change=after-before può essere positivo, zero o negativo. Di per sé, non distingue tra tutti gli aggiornamenti intermedi e l'uscita dal mondo.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetStr();
await Delay(1000);
var after = UO.GetStr();
var change = after - before;
UO.Print("Change: " + Convert.ToString(change));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=80 è un esempio di requisito, non di limite del cliente. AttributeAtLeast(minimo) rifiuta il carattere mancante, legge la caratteristica una volta e restituisce bool: true o false se >= minimo. Il significato logico è dato dal confronto, non dalla caratteristica stessa.
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()
{
if (Truth(Truth(AttributeAtLeast(80)) == true))
{
UO.Print("Requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic AttributeAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetStr();
return value >= minimum;
}
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:
- id è il risultato di UO.Self(), non type. AddObject memorizza ID come statSubject senza ambito perché è specificato il secondo argomento. Entrambe le chiamate selezionano lo stesso carattere, ma le letture non sono atomiche.
var id = UO.Self();
if (Truth(id != 0))
{
UO.AddObject("statSubject", id);
var direct = UO.GetStr(id);
var byName = UO.GetStr("statSubject");
UO.Print("Direct: " + Convert.ToString(direct) + "; alias: " + Convert.ToString(byName));
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetStrength();Legge la potenza attuale (Strength, Convert.ToString) del carattere.
Non ci sono parametri.
int — punti statistici attuali, 0..65535 nel modello client; non percentuale, ID, abilità, modalità di blocco o bool. 0 significa anche carattere mancante/cancellato o oggetto inaccessibile. Confrontare con il requisito numerico, non == true. Questo non è un limite statistico o un valore base garantito senza modificatori.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- Legge Player.Strength se Player esiste e non è stato distrutto; altrimenti 0. Un personaggio morto presente non è un oggetto rimosso. La statistica non viene calcolata da HP, mana o resistenza.
- GetStr/GetInt/GetDex accetta ObjID. I dati PlayerMobile sono disponibili solo per self; per un altro serial - 0, anche per mobile caricato. Le caratteristiche di qualcun altro non vengono sostituite o indovinate.
- Invoca letture sul flusso di gioco con la possibilità di annullare l'attesa tramite script. Non interroga lo stato, non apre il target, non invia un pacchetto, non cambia le caratteristiche e non aggiunge ritardo.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- Nomi caratteristici equivalenti con UO. e senza di essa, non fa distinzione tra maiuscole e minuscole:
Convert.ToString Strength GetStr GetStrength.
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.GetStrength();
UO.Print("GetStrength: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato numerico; Convert.ToString lo formatta semplicemente per la rivista. Non ci sono argomenti o azioni dei personaggi.
var value = UO.GetStrength();
UO.Print("Strength: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- prima e dopo 1000 ms separati; UO.Wait aggiunto all'esempio. change=after-before può essere positivo, zero o negativo. Di per sé, non distingue tra tutti gli aggiornamenti intermedi e l'uscita dal mondo.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetStrength();
await Delay(1000);
var after = UO.GetStrength();
var change = after - before;
UO.Print("Change: " + Convert.ToString(change));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=80 è un esempio di requisito, non di limite del cliente. AttributeAtLeast(minimo) rifiuta il carattere mancante, legge la caratteristica una volta e restituisce bool: true o false se >= minimo. Il significato logico è dato dal confronto, non dalla caratteristica stessa.
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()
{
if (Truth(Truth(AttributeAtLeast(80)) == true))
{
UO.Print("Requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic AttributeAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.GetStrength();
return value >= minimum;
}
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 · 繁體中文 · 日本語 · 한국어
dynamic UO.GetTitle(object? arg0);Legge il titolo del personaggio noto al cliente: ad esempio professione o firma dopo il nome.
-
ObjID— Richiesto l'oggetto serial/ID, non type e non cliloc. Accetta int, stringa decimale/esadecimale, self, backpack, lasttarget, trovaelemento o nome AddObject. 0 significa nessun oggetto.
string — testo del campo Titolo per dispositivi mobili. Stringa vuota se il titolo è sconosciuto, l'oggetto non è un carattere o manca ID. Non è serial, un nome completo o un array di proprietà. GetAltName utilizza lo stesso campo di GetTitle.
- La chiamata stessa legge i dati locali, non attende il server e non invia un solo clic. Per richiedere un nome/titolo utilizzare da solo ClickOnObject; la risposta arriva in modo asincrono.
- Per un carattere esistente è accettabile anche una stringa vuota. Il controllo Exists risponde ad un'altra domanda: se l'oggetto è caricato.
- In questa implementazione, il nome alternativo viene mappato nel campo Titolo del personaggio.
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.GetTitle("self");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- ObjID=self — carattere del client corrente.
- titolo contiene solo il titolo; un campo vuoto non significa un errore di script.
var title = UO.GetTitle("self");
UO.Print(title);Parametri e flusso di esecuzione:
- ObjID=id — serial dell'ultimo target. GetName e il titolo vengono letti separatamente.
- La destinazione dell'elemento non ha un campo Titolo e fornirà una stringa vuota.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
var title = UO.GetTitle(id);
if (Truth(title != ""))
{
UO.Print(UO.GetName(id) + " " + title);
}
}
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:
- 350 — esempio di pausa in millisecondi dopo un singolo clic; questo non è un parametro getter.
- Il server potrebbe rispondere più tardi o non trasferire il titolo. Conserva la gestione della stringa vuota.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
UO.ClickOnObject(id);
UO.Wait(350);
UO.Print(UO.GetTitle(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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetWeight();Legge il contatore dello stato del tuo personaggio: peso attuale in pietre.
Non ci sono parametri.
int — peso attuale in pietre, 0..65535 nel modello client. 0 può essere un valore reale, nessun dato o un giocatore scomparso/distrutto. Questa è una quantità, non bool, ID o type: 1 significa un'unità, non successo. Il comando non esegue iterazioni sugli oggetti e non restituisce un array.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- La lettura nel thread del gioco richiede Player.Weight se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
- Weight legge il peso totale riportato dal server in pietre. Il peso del corpo, dell'attrezzatura e delle borse incluse nell'importo è determinato dalle regole dello Shard. Il team non attraversa i contenitori, non somma il peso degli articoli o aggiorna i bagagli chiusi. Questa non è la proprietà Weight di un singolo articolo, né il numero di articoli.
- CharacterStatus controlla il corpo richiesto prima dell'aggiornamento. Weight è disponibile nel suo stato esteso, slot - da type 3, Luck - da type 4, server WeightMax - da type 5. Un pacchetto compatto/vecchio senza un contatore opzionale lascia la cache precedente. Il nuovo Player inizia da zero; la chiamata non dimostra il ricevimento di un nuovo status.
- RegisterCharacterGetterAliases aggiunge funzioni senza argomenti mancanti e nomi in linea per il campo. I rami di compatibilità esistenti leggono lo stesso campo bridge. Il caso del nome non è importante; intrinseco senza parentesi viene riletto se non viene sovrascritto da una variabile.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
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.GetWeight();
UO.Print("GetWeight: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza una chiamata senza argomento al proprio carattere; Convert.ToString formatta il numero del log senza cambiarne il significato.
var value = UO.GetWeight();
UO.Print("Weight: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- UO.Wait(500) separa il prima e il dopo di 500 millisecondi. difference can be positive, zero or negative; Gli aggiornamenti temporanei e le modifiche ai personaggi potrebbero essere saltati. La pausa è un esempio.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.GetWeight();
await Delay(500);
var after = UO.GetWeight();
var difference = after - before;
UO.Print("Counter change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- CanCarry(extra) ottiene un peso extra in pietre; 10 è un esempio, non il numero di stack. Rifiuta extra negativo, nessun giocatore o massimo <= 0, legge il peso e il limite attuali, quindi restituisce bool: true o false con extra <= massimo - corrente. La sottrazione evita l'eccesso di corrente + extra. In caso di sovraccarico, il risultato è false anche per extra=0. Questa è una valutazione locale, non una risoluzione del server; le letture non sono atomiche e il peso zero potrebbe essere sconosciuto.
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()
{
if (Truth(Truth(CanCarry(10)) == true))
{
UO.Print("Local check passed");
}
else
{
UO.Print("Local check failed or data unavailable");
}
return null;
}
dynamic CanCarry(dynamic extra)
{
if (Truth(extra < 0) || Truth(UO.Self() == 0))
{
return false;
}
var current = UO.GetWeight();
var maximum = UO.MaxWeight();
if (Truth(maximum <= 0))
{
return false;
}
return extra <= maximum - current;
}
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 · 繁體中文 · 日本語 · 한국어
int UO.GetYellowBar(object? arg0);Controlla il flag giallo della barra della salute mobile.
-
id— Obbligatorio serial/ID di un oggetto specifico: int, stringa esadecimale o alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse o nome AddObject. Questo non è graphic/type. Il nome non specificato si risolve in 0; il comando non apre alcuna nuova destinazione. L'argomento è obbligatorio; per te, supera self. -
ObjID— Obbligatorio serial/ID di un oggetto specifico: int, stringa esadecimale o alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse o nome AddObject. Questo non è graphic/type. Il nome non specificato si risolve in 0; il comando non apre alcuna nuova destinazione. L'argomento è obbligatorio; per te, supera self. -
MobID— Obbligatorio serial/ID di un oggetto specifico: int, stringa esadecimale o alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse o nome AddObject. Questo non è graphic/type. Il nome non specificato si risolve in 0; il comando non apre alcuna nuova destinazione. L'argomento è obbligatorio; per te, supera self.
int 1 - caricato mobile ha l'attributo IsYellowHits. int 0 - manca l'attributo, l'oggetto non è mobile, sconosciuto o eliminato. Questo è un flag server/compatibile, non un colore del tema IDE o una quantità HP. L'assenza di un flag non dimostra vulnerabilità: il server può indicare la protezione in modo diverso.
Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.
- Viene letto il modello client locale; Non ci sono richieste al server, nessuna attesa o spostamento.
- Il risultato si riferisce al momento della lettura. Dopo UO.Wait o altra azione, l'oggetto e i suoi flag potrebbero cambiare.
- Questo è un flag server/compatibile, non il colore del tema IDE o la quantità HP. L'assenza di un flag non dimostra vulnerabilità: il server può indicare la protezione in modo diverso.
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.GetYellowBar("self");
UO.Print("GetYellowBar: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- L'argomento self seleziona esplicitamente il suo carattere. stato - solo 1/0.
- Questo è un flag server/compatibile, non il colore del tema IDE o la quantità HP. L'assenza di un flag non dimostra vulnerabilità: il server può indicare la protezione in modo diverso.
var state = UO.GetYellowBar("self");
var hp = UO.GetHP("self");
UO.Print("Yellow flag: " + Convert.ToString(state));
UO.Print("Known HP: " + Convert.ToString(hp));Parametri e flusso di esecuzione:
- IsNpc esclude soggetto e oggetto sconosciuto. target memorizza un singolo serial anziché un riferimento live a un lasttarget mutevole.
- Il risultato si riferisce al campo IsYellowHits. I dati vengono aggiornati solo dopo che il client ha ricevuto lo stato appropriato.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var state = UO.GetYellowBar(target);
UO.Print("Selected mobile state 1/0: " + Convert.ToString(state));
}
else
{
UO.Print("No loaded mobile selected");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- UO.Wait(500): pausa in millisecondi. Successivamente, viene controllato separatamente che mobile esista ancora.
- Vengono confrontate due immagini. Le modifiche intermedie potrebbero non essere perse e questa non è una sottoscrizione continua agli eventi del server.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var before = UO.GetYellowBar(target);
await Delay(500);
if (Truth(UO.IsNPC(target)))
{
var after = UO.GetYellowBar(target);
if (Truth(before != after))
{
UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
}
else
{
UO.Print("Mobile left the local world");
}
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.Gold();Legge la quantità di oro dallo stato attuale del personaggio.
Non ci sono parametri.
int/double — somma non negativa 0..4294967295. Fino a 2147483647 compreso, viene restituito un int, sopra - un double (Double), che rappresenta esattamente qualsiasi intero senza segno 32 bit. 0 significa anche nessun giocatore attualmente non eliminato o importo ricevuto. Non è bool, ID, numero di stack o attraversamento di zaino/banca.
- Non ci sono parametri. Legge la cache Player.Gold da CharacterStatus (0x11). Il server determina quale oro è incluso nel suo contatore; la squadra non fruga le borse né chiede saldi bancari. Nessun giocatore/giocatore distrutto - 0; un regalo fantasma può mantenere un importo di status.
- ReadGoldValue legge bridge.Gold una volta. Il vecchio bridge C# mantiene la firma Int32 e trasmette bit UInt32. la conversione non controllata ripristina la somma senza segno; una piccola quantità diventa int, una grande quantità diventa double. La parte più significativa non rende più il saldo negativo. La conversione è locale, non ci sono pacchetti.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
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.Gold();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- importo memorizza un risultato; Convert.ToString lo formatta per la rivista. L’oro non viene cercato, trasportato o speso.
var amount = UO.Gold();
UO.Print("Status gold: " + Convert.ToString(amount));Parametri e flusso di esecuzione:
- price=3000000000.0 è un esempio di prezzo, non di limite. CanAfford(prezzo) rifiuta un prezzo negativo o nessun giocatore, legge l'importo una volta e restituisce bool: true o false se importo >= prezzo. L'importo in sé non è bool. La funzione è completamente definita di seguito.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var price = 3000000000.0;
if (Truth(Truth(CanAfford(price)) == true))
{
UO.Print("Local balance is sufficient");
}
else
{
UO.Print("Local check failed");
}
return null;
}
dynamic CanAfford(dynamic price)
{
if (Truth(price < 0) || Truth(UO.Self() == 0))
{
return false;
}
var amount = UO.Gold();
return amount >= price;
}
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:
- prima/dopo separa UO.Wait(500) millisecondi. differenza=dopo-prima può essere negativa quando il saldo diminuisce; Non si tratta di un overflow del contatore fisso senza segno. Potrebbero mancare aggiornamenti temporanei e modifiche ai personaggi.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = UO.Gold();
await Delay(500);
var after = UO.Gold();
var difference = after - before;
UO.Print("Balance change: " + Convert.ToString(difference));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.HP();Legge l'integrità attuale dal modello locale.
Non ci sono parametri.
int è il valore del campo Hits, non la percentuale e non bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.
- Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
- Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
- La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.
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.HP();
UO.Print("HP: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.
var value = UO.HP();
UO.Print("HP: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.HP();
var maximum = UO.GetMaxHP();
if (Truth(maximum > 0) && Truth(value * 100 / maximum < 50))
{
UO.Print("Health below half of the known maximum");
}
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:
- Questo nome non ha la forma con ID. ReadValue senza parametri legge self; le due chiamate sono separate da UO.Wait(1000). Confrontando due istantanee potrebbero non essere rilevate modifiche intermedie.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = ReadValue();
await Delay(1000);
var after = ReadValue();
UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
return null;
}
dynamic ReadValue()
{
return UO.HP();
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Hidden();
int UO.Hidden(object? arg0);Mette alla prova la furtività del personaggio.
-
idText— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare. -
id— Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.
Flag numerico int: 1 (condizione soddisfatta), 0 (condizione non soddisfatta). Questo è un flag numerico: in C# controlla risultato != 0 o risultato == 0. Il confronto diretto di int con true/false e if (risultato) non è consentito. 1 - mobile ha IsHidden, 0 non ha flag o mobile manca. Questa è una bandiera del server, non una visibilità dietro un muro.
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 il modello locale: non apre il target, non richiede lo stato, non cambia il flag e non invia il pacchetto. Un oggetto distrutto è considerato mancante anche prima che la voce venga cancellata dal dizionario.
- Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
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.Hidden();
UO.Print("Hidden: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Le parentesi vuote leggono self. attivo salva il risultato una volta; true e false definiscono due rami. Print visualizza solo un messaggio di esempio.
var active = UO.Hidden();
if (Truth(Truth(active) == true))
{
UO.Print("State is active");
}
else
{
UO.Print("State is inactive or unavailable");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- lasttarget – oggetto precedentemente selezionato. Exists ne verifica la presenza. obj è l'unico parametro ReadState; la funzione restituisce il risultato del comando senza modifiche. La sua definizione è inclusa nel codice copiato.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
if (Truth(UO.Exists("lasttarget")))
{
var observed = ReadState("lasttarget");
UO.Print("State 1/0: " + Convert.ToString(observed));
}
return null;
}
dynamic ReadState(dynamic obj)
{
return UO.Hidden(obj);
}
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:
- Due chiamate senza argomenti leggono self, UO.Wait(500) imposta 500 millisecondi. Vengono confrontate due immagini; le transizioni intermedie possono essere saltate. Non esiste un'attesa infinita.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = UO.Hidden();
await Delay(500);
var after = UO.Hidden();
if (Truth(before != after))
{
UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Int();Legge l'intelligenza attuale (Intelligence, INT) del personaggio.
Non ci sono parametri.
int — punti statistici attuali, 0..65535 nel modello client; non percentuale, ID, abilità, modalità di blocco o bool. 0 significa anche carattere mancante/cancellato o oggetto inaccessibile. Confrontare con il requisito numerico, non == true. Questo non è un limite statistico o un valore base garantito senza modificatori.
- Il comando non accetta argomenti. Usa le firme esatte sopra.
- Legge Player.Intelligence se Player esiste e non è stato distrutto; altrimenti 0. Un personaggio morto presente non è un oggetto rimosso. La statistica non viene calcolata da HP, mana o resistenza.
- GetStr/GetInt/GetDex accetta ObjID. I dati PlayerMobile sono disponibili solo per self; per un altro serial - 0, anche per mobile caricato. Le caratteristiche di qualcun altro non vengono sostituite o indovinate.
- Invoca letture sul flusso di gioco con la possibilità di annullare l'attesa tramite script. Non interroga lo stato, non apre il target, non invia un pacchetto, non cambia le caratteristiche e non aggiunge ritardo.
- Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
- Nomi caratteristici equivalenti con UO. e senza di essa, non fa distinzione tra maiuscole e minuscole:
Int Intelligence GetInt GetIntelligence.
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.Int();
UO.Print("Int: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- value memorizza il risultato numerico; Convert.ToString lo formatta semplicemente per la rivista. Non ci sono argomenti o azioni dei personaggi.
var value = UO.Int();
UO.Print("Intelligence: " + Convert.ToString(value));Parametri e flusso di esecuzione:
- prima e dopo 1000 ms separati; UO.Wait aggiunto all'esempio. change=after-before può essere positivo, zero o negativo. Di per sé, non distingue tra tutti gli aggiornamenti intermedi e l'uscita dal mondo.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.Int();
await Delay(1000);
var after = UO.Int();
var change = after - before;
UO.Print("Change: " + Convert.ToString(change));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- minimo=80 è un esempio di requisito, non di limite del cliente. AttributeAtLeast(minimo) rifiuta il carattere mancante, legge la caratteristica una volta e restituisce bool: true o false se >= minimo. Il significato logico è dato dal confronto, non dalla caratteristica stessa.
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()
{
if (Truth(Truth(AttributeAtLeast(80)) == true))
{
UO.Print("Requirement met");
}
else
{
UO.Print("Requirement not met or no player");
}
return null;
}
dynamic AttributeAtLeast(dynamic minimum)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var value = UO.Int();
return value >= minimum;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}ClassicUO — Bad Newbie & C# Scripts IDE