Repository navigation
IT UO Topic client connection
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
Home · C# · IDE · UO API · A–Z · Esempi · Lingue
Connessione, stato di accesso al mondo, latenza, indirizzo del server ed elenco dei caratteri.
| Argomento | Comandi e spiegazioni |
|---|---|
| Connect | UO.Connect |
| Disconnect | UO.Disconnect |
| Connected | UO.Connected |
| Online | UO.Online |
| Ping | UO.GetPing |
| Server IP | UO.GameServerIPString |
| Shard Name | UO.ShardName |
| Shard Path | UO.ShardPath |
| Elenco caratteri | UO.GetCharsListForShard |
| Resend | UO.Resend |
| CheckLag | UO.CheckLag |
UO.Connect · UO.Disconnect · UO.Connected · UO.Online · UO.IsOnline · UO.ConnectedTime · UO.DisconnectedTime · UO.GetPing · UO.CheckLag · UO.GameServerIPString · UO.ShardName · UO.ShardPath · UO.GetCharsListForShard · UO.Resend · UO.CloseUO
Ogni carta comando ha diversi scenari indipendenti: codice diretto, funzioni e classi. Di seguito sono selezionati brevi scenari; restrizioni e un'analisi completa sono nelle carte.
Parametri, risultato e tutti gli scenari
if (Truth(Truth(UO.Connected()) == false))
{
return null;
}
UO.UseSkill("Hiding");
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri, risultato e tutti gli scenari
var address = UO.GameServerIPString();
UO.Print(address);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.CheckLag();
dynamic UO.CheckLag(object? timeoutMS);
int UO.CheckLag(object? timeout, object? retries);Controlla se è stata ricevuta una nuova risposta dal server di gioco entro il tempo assegnato. Utile prima di continuare lo script dopo un ritardo di rete.
-
timeout— timeout / timeoutMS — tempo di attesa per un tentativo in millisecondi, convertito in int. Un valore negativo è limitato a zero. Con 0 si può inviare la richiesta, ma non si attende risposta; Non è un timeout infinito. -
timeoutMS— timeout / timeoutMS — tempo di attesa per un tentativo in millisecondi, convertito in int. Un valore negativo è limitato a zero. Con 0 si può inviare la richiesta, ma non si attende risposta; Non è un timeout infinito. -
retries- tentativi - Numero TOTALE di tentativi, non il numero di ripetizioni aggiuntive. Converte in int ed è limitato dal basso a uno. Ad esempio, (250, 3) - fino a tre tentativi a 250 ms; una risposta positiva completa il controllo in anticipo.
Flag numerico int: 1 (condizione soddisfatta) - nuova risposta ricevuta; 0 (condizione non soddisfatta) - la richiesta è impossibile o il tempo limite è scaduto. Registrazione del singolo parametro object? in realtà restituisce questo int. Questo non è il valore del ping o il numero di tentativi.
- CheckLag() effettua un tentativo, aspettando fino a 10000 ms. CheckLag(timeoutMS) - un tentativo con l'aspettativa specificata. CheckLag(timeout, tentativi) ripete il controllo fino all'esaurimento del successo o fino all'esaurimento del numero totale di tentativi.
- L'attesa ritarda lo script chiamante anziché confermare l'azione di gioco. Il comando non si riconnette e non modifica le impostazioni di rete. Il server potrebbe non rispondere all'eco: il guasto di per sé non dimostra che la connessione si è interrotta. La tempistica dipende anche dalla programmazione dei flussi; Non chiamare il controllo attivo su ogni frame. L'arresto dello script interrompe l'attesa.
- UO.GetPing · UO.CheckLag · UO.IsOnline
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.CheckLag();
UO.Print("CheckLag: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Un modulo senza parametri può attendere fino a 10 secondi. true significa una nuova risposta eco. Nascondersi viene richiamato da un comando separato e può essere ignorato dalle meccaniche di gioco.
if (Truth(Truth(UO.CheckLag()) == true))
{
UO.UseSkill("Hiding");
}
else
{
UO.Print("No fresh server response");
}
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:
- 250 — in attesa di un tentativo, 3 — tentativi totali. In caso di successo, non verranno effettuati ulteriori tentativi; con 0 lo script non prosegue. Questa non è una misurazione del ping 250 ms o tre ripetizioni aggiuntive.
return RunScenario();
object? RunScenario()
{
var responsive = UO.CheckLag(250, 3);
if (Truth(responsive == 0))
{
UO.Print("No response after the allowed attempts");
return null;
}
UO.Print("Fresh response received; the script can continue");
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:
- CanContinue(timeoutMs, tentativi) controlla prima UO.IsOnline, quindi l'ultima risposta. false e 0 sono equivalenti per questo predicato. I tentativi 500 ms e 2 sono specificati separatamente; La funzione non attiva la riconnessione automatica.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
if (!(Truth(CanContinue(500, 2))))
{
return null;
}
UO.UseSkill("Hiding");
return null;
}
dynamic CanContinue(dynamic timeoutMs, dynamic attempts)
{
if (Truth(Truth(UO.IsOnline()) == false))
{
return false;
}
return Truth(Truth(UO.CheckLag(timeoutMs, attempts)) == true);
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.CheckLag. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CheckLag:bridge.CheckLag(10_000).
Codice interno di implementazione; non è uno script autonomo.
public int CheckLag() => bridge.CheckLag(10_000);Parametri: timeoutMS (Any)
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CheckLag:bridge.CheckLag(Arg(0, 10_000)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0, 10_000).
Codice interno di implementazione; non è uno script autonomo.
case "checklag": return new InjectionValue(bridge.CheckLag(Arg(0, 10_000)));Parametri: timeout (Any), retries (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.CheckLag. -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(timeout). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CheckLag:bridge.CheckLag(timeoutMs).
Codice interno di implementazione; non è uno script autonomo.
public int CheckLag(InjectionValue timeout, InjectionValue retries)
{
int timeoutMs = Math.Max(0, NumberConversions.ToInt(timeout));
int attempts = Math.Max(1, NumberConversions.ToInt(retries));
for (int attempt = 0; attempt < attempts; attempt++)
{
if (bridge.CheckLag(timeoutMs) != 0)
return 1;
}
return 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.CloseUO();Richiede all'applicazione client corrente di uscire tramite Client.Game.Exit.
Non ci sono parametri.
void: nessun valore restituito.
- CloseUO viene inviato allo stesso bridge.CloseHandle. L'uscita viene eseguita nel thread del gioco; se manca Client.Game, non viene eseguita alcuna azione. Il comando non è l'arresto di un gump separato.
Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.
Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.
Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.
UO.Print("Calling UO.CloseUO");
UO.CloseUO();Parametri e flusso di esecuzione:
- La chiamata richiede la chiusura dell'applicazione client.
UO.CloseUO();Parametri e flusso di esecuzione:
- L'esempio mostra una condizione controllata; il valore 0 mantiene il client aperto.
return RunScenario();
object? RunScenario()
{
var finishClient = 0;
if (Truth(finishClient))
{
UO.CloseUO();
}
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:
- Un helper completamente dichiarato consente l'abilitazione esplicita dell'uscita.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
FinishClient(0);
return null;
}
void FinishClient(dynamic enabled)
{
if (Truth(enabled))
{
UO.CloseUO();
}
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CloseHandle:bridge.CloseHandle().
Codice interno di implementazione; non è uno script autonomo.
case "closeuo": bridge.CloseHandle(); break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.Connect();Richiede la connessione o la riconnessione della sessione client corrente.
Non ci sono parametri.
void: nessun valore restituito.
- In una sessione manager, chiama SessionControl.RequestConnect. Nel client autonomo, la connessione attiva/preparata viene lasciata invariata.
- Per GameScene prevede una riconnessione salvata per non cambiare scena durante il suo Aggiornamento. LoginScene utilizza l'account corrente e la password salvata, attiva la riconnessione e chiama Connect con il frammento/personaggio ricordato anche quando la riconnessione automatica è disattivata.
- La squadra non aspetta di entrare nel mondo. Controllare UO.Connected dopo un'attesa separata se ulteriori azioni richiedono una connessione.
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.Connect");
UO.Connect();Parametri e flusso di esecuzione:
- La chiamata avvia solo una connessione.
UO.Connect();Parametri e flusso di esecuzione:
- La verifica può evitare una nuova richiesta.
return RunScenario();
object? RunScenario()
{
if (!(Truth(UO.Connected())))
{
UO.Connect();
}
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:
- L'attesa 1000 ms non garantisce l'ingresso; l'output mostra il flag corrente effettivo.
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.Connect();
await Delay(1000);
UO.Print(Convert.ToString(UO.Connected()));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ConnectClient:bridge.ConnectClient().
Codice interno di implementazione; non è uno script autonomo.
case "connect": bridge.ConnectClient(); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.Connected();Controlla se la sessione corrente è nel mondo di gioco e se la sua connessione di gioco è aperta. Utilizzare prima di un'azione del personaggio o mentre si attende l'ingresso.
Non ci sono parametri.
int. 1 - c'è un giocatore, una carta caricata e una presa di gioco attiva contemporaneamente; altrimenti 0. Una finestra client aperta, un elenco di caratteri o una connessione TCP in fase di accesso non significa 1. 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.
Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.
- Non ci sono parametri: serial, type, nome del carattere e IP non possono essere trasferiti. UO.Online(), UO.Connected() e UO.IsOnline() controllano la stessa cosa. Questo è lo stato del proprietario della sessione specificata, non di un altro profilo manager.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
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.Connected();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- false è equivalente a 0. return termina Main su UseSkill. Nascondersi è l'unico parametro di UseSkill, il nome dell'abilità. Con 1 lo script chiede solo di utilizzare l'abilità; il risultato dipende dallo stato del personaggio e del server.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
if (Truth(Truth(UO.Connected()) == false))
{
return null;
}
UO.UseSkill("Hiding");
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Il confronto con 0 controlla la connessione corrente, non l'impostazione di riconnessione automatica. Connect senza argomenti utilizza le impostazioni salvate e non attende il completamento del login. La ripetizione di un comando durante un accesso già avviato non dovrebbe creare una seconda sessione.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Connected() == 0))
{
UO.Connect();
}
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:
- WaitForWorld(timeoutMs) è una funzione definita dall'utente completamente mostrata, non un comando integrato. 5000 — budget in ms, UO.Wait(50) — intervallo di controllo. Un valore negativo dà false; 0 consente solo un mondo già pronto. Timer misura i secondi, quindi la differenza viene moltiplicata per 1000. La pausa automatica deve essere disattivata in anticipo, altrimenti Principale esce. La funzione non richiama Connect e non cancella l'input avviato allo scadere del tempo.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
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.GetPauseScriptOnDisconnectStatus()))
{
return null;
}
if (Truth(await WaitForWorld(5000)))
{
UO.UseSkill("Hiding");
}
return null;
}
async Task<dynamic> WaitForWorld(dynamic timeoutMs)
{
if (Truth(timeoutMs < 0))
{
return false;
}
var started = Environment.TickCount;
while (!(Truth(UO.Connected())))
{
if (Truth((Environment.TickCount - started) * 1000.0 >= timeoutMs))
{
return false;
}
await Delay(50);
}
return true;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsOnline:bridge.IsOnline().
Codice interno di implementazione; non è uno script autonomo.
case "connected": return new InjectionValue(bridge.IsOnline());Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.ConnectedTime();Restituisce il timbro del calendario dell'ultimo ingresso riuscito del personaggio nel mondo. Ti aiuta a capire se la connessione è cambiata durante l'attesa o la pausa prima di continuare la stessa attività.
Non ci sono parametri.
double: numero di giorni da 1899-12-30, parte frazionaria - ora del giorno (OLE Data di automazione). 0 significa che questo proprietario della sessione non è ancora entrato nel mondo. Dopo la disconnessione viene mantenuto l'ultimo contrassegno immesso. Non si tratta di un bool o di una durata in secondi.
- Non ci sono argomenti. La cronologia è comune per gli script dello stesso proprietario della sessione: avvio ritardato, pausa e chiusura IDE non cambiano i contrassegni. Un nuovo processo di sessione inizia una nuova storia; non è un registro di tutte le connessioni.
- Un tentativo di accesso fallito senza che il personaggio appaia nel mondo non è considerato un accesso riuscito. I controlli offline ripetuti non modificano l'orario di spegnimento. Per lo stato corrente, utilizzare UO.Connected() anziché una data diversa da zero.
- Gli orologi vengono presi dall'orologio locale del computer. La differenza moltiplicata per 86400 dà i secondi di calendario; La modifica dell'orologio/fuso orario potrebbe distorcere i risultati. Per i timeout, utilizzare monotonico Timer(). Le singole chiamate non formano un'istantanea atomica; lo stesso segno non è una connessione ID univoca.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
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.ConnectedTime();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- 0 controlla l'assenza di input in questo particolare processo. Connect utilizza il profilo salvato e richiede solo il login. Questo esempio non ripristina intenzionalmente una connessione già terminata.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
if (Truth(UO.ConnectedTime() == 0))
{
UO.Connect();
}
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:
- 30.0 — monitoraggio del budget in pochi secondi Timer; 250 — intervallo UO.Wait in ms. Dopo aver modificato il contrassegno di immissione, CancelWaitTarget cancella il target differito precedente. Se non c'è nessun nuovo input, il ciclo termina senza questa azione.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var login = UO.ConnectedTime();
var started = Environment.TickCount;
while (Truth(Environment.TickCount - started < 30.0))
{
if (Truth(UO.Connected()) && Truth(UO.ConnectedTime() != login))
{
UO.CancelWaitTarget();
return null;
}
await Delay(250);
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- SameConnection(login) restituisce bool. Salviamo il contrassegno, aspettiamo 500 ms, quindi vietiamo la continuazione se non c'è connessione o se l'ingresso cambia. Si tratta di un nuovo test e non di una garanzia della futura disponibilità del server.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
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 login = UO.ConnectedTime();
await Delay(500);
if (!(Truth(SameConnection(login))))
{
return null;
}
UO.AddToSystemJournal("Same connection; continue this batch");
return null;
}
dynamic SameConnection(dynamic login)
{
return Truth(login != 0) && Truth(UO.Connected()) && Truth(UO.ConnectedTime() == login);
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.UpdateConnectionState:UpdateConnectionState().
Codice interno di implementazione; non è uno script autonomo.
case "connectedtime":
UpdateConnectionState();
return new InjectionValue(state.ConnectedTime == default(DateTime) ? 0d : state.ConnectedTime.ToOADate());Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.Disconnect();Disconnette il trasporto client corrente o installato e prepara gli script per la riconnessione.
Non ci sono parametri.
void: nessun valore restituito.
- Se la riconnessione automatica è disattivata, BeginScriptControlledDisconnect salva l'operatore che effettua la chiamata per UO.Connect successivo. La sessione del manager riceve RequestDisconnect.
- Il client autonomo chiama Socket.Disconnect e PrepareForReconnect. Quando la riconnessione globale è abilitata, pianifica esplicitamente la transizione della scena salvata. In LoginScene cancella il popup e restituisce Main.
- Il ritorno a void non riporta il risultato della riconnessione. Lo stato della connessione viene letto separatamente; Le impostazioni di riconnessione automatica possono avviare un nuovo accesso.
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.Disconnect");
UO.Disconnect();Parametri e flusso di esecuzione:
- Il comando annulla sia il trasporto attivo che quello installato.
UO.Disconnect();Parametri e flusso di esecuzione:
- Con AR disattivato, l'operatore chiamante può raggiungere Connect da solo.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
UO.Disconnect();
await Delay(1000);
UO.Connect();
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));Parametri e flusso di esecuzione:
- La condizione utilizza un flag locale per la sessione corrente.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
if (Truth(UO.Connected()))
{
UO.Disconnect();
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.DisconnectClient:bridge.DisconnectClient().
Codice interno di implementazione; non è uno script autonomo.
case "disconnect": bridge.DisconnectClient(); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.DisconnectedTime();Restituisce il timbro del calendario dell'ultima volta che la connessione al gioco è stata persa. È necessario per diagnosticare un'interruzione e stimare la durata di una connessione completata e non per determinare il numero di tentativi di accesso.
Non ci sono parametri.
double: numero di giorni da 1899-12-30 con parte frazionaria del giorno. Dopo l'interruzione: il momento in cui il cliente ha notato l'interruzione; prima della prima interruzione è l'ora in cui è stato creato il proprietario della sessione. Questo non è un flag offline e nemmeno i millisecondi.
- Non ci sono argomenti. La cronologia è comune per gli script dello stesso proprietario della sessione: avvio ritardato, pausa e chiusura IDE non cambiano i contrassegni. Un nuovo processo di sessione inizia una nuova storia; non è un registro di tutte le connessioni.
- Un tentativo di accesso fallito senza che il personaggio appaia nel mondo non è considerato un accesso riuscito. I controlli offline ripetuti non modificano l'orario di spegnimento. Per lo stato corrente, utilizzare UO.Connected() anziché una data diversa da zero.
- Gli orologi vengono presi dall'orologio locale del computer. La differenza moltiplicata per 86400 dà i secondi di calendario; La modifica dell'orologio/fuso orario potrebbe distorcere i risultati. Per i timeout, utilizzare monotonico Timer(). Le singole chiamate non formano un'istantanea atomica; lo stesso segno non è una connessione ID univoca.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
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.DisconnectedTime();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- CompletedConnectionSeconds() restituisce secondi o -1 se non c'è alcuna connessione completata o l'input è cambiato tra una lettura e l'altra. 86400 — secondi in un giorno. Viene ricalcolata solo l'ultima coppia ingresso/interruzione; La funzione non riepiloga la cronologia di tutte le sessioni.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
var seconds = CompletedConnectionSeconds();
if (Truth(seconds >= 0))
{
UO.AddToSystemJournal("Completed connection seconds: " + Convert.ToString(seconds));
}
dynamic CompletedConnectionSeconds()
{
var login = UO.ConnectedTime();
var loss = UO.DisconnectedTime();
if (Truth(login == 0) || Truth(loss < login) || Truth(UO.Connected()))
{
return -1;
}
if (Truth(UO.ConnectedTime() != login))
{
return -1;
}
return (loss - login) * 86400.0;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Quando la pausa automatica è abilitata, questo controller si chiude immediatamente; Per funzionare offline deve essere disattivato in anticipo. Dopo UO.Wait(1000) offline e il segno di interruzione precedente vengono nuovamente controllati. Connect non garantisce il successo e non sostituisce l'impostazione di riconnessione automatica.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
if (Truth(UO.GetPauseScriptOnDisconnectStatus()))
{
return null;
}
if (Truth(UO.Connected()))
{
return null;
}
var loss = UO.DisconnectedTime();
await Delay(1000);
if (!(Truth(UO.Connected())) && Truth(UO.DisconnectedTime() == loss))
{
UO.Connect();
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Il confronto con previousLoss rileva una pausa anche dopo che il rientro è già avvenuto. 30 monitoraggio del limite dei secondi mentre lo script è in esecuzione, WaitAsync(250) libera il thread tra i controlli. È possibile combinare più interruzioni in un'unica notifica.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
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 previousLoss = UO.DisconnectedTime();
var started = Environment.TickCount;
while (Truth(Environment.TickCount - started < 30.0))
{
if (Truth(UO.DisconnectedTime() != previousLoss))
{
UO.AddToSystemJournal("A connection loss occurred; check the session");
return null;
}
await Delay(250);
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.UpdateConnectionState:UpdateConnectionState().
Codice interno di implementazione; non è uno script autonomo.
case "disconnectedtime":
UpdateConnectionState();
return new InjectionValue(state.DisconnectedTime.ToOADate());Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GameServerIPString();Legge l'indirizzo del server configurato dalle impostazioni globali del client.
Non ci sono parametri.
string — Impostazioni.GlobalSettings.IP o una stringa vuota se non è presente alcun valore.
- GameServerAddress nel bridge corrente legge l'impostazione globale IP. Questa non è una richiesta DNS/network, né controlla l'indirizzo effettivo del peer; una sessione del gestore può avere i propri parametri di connessione.
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.GameServerIPString();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Viene restituita l'impostazione globale corrente IP.
var address = UO.GameServerIPString();
UO.Print(address);Parametri e flusso di esecuzione:
- Un valore vuoto indica nessuna configurazione e non un errore di rete misurato.
return RunScenario();
object? RunScenario()
{
var address = UO.GameServerIPString();
if (Truth(Len(address) == 0))
{
UO.Print("no configured address");
}
return null;
}
int Len(object? value) => Convert.ToString(value)?.Length ?? 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- La variabile memorizza la stringa ottenuta dalla prima chiamata.
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 address = UO.GameServerIPString();
await Delay(100);
UO.Print(address);
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GameServerAddress:bridge.GameServerAddress.
Codice interno di implementazione; non è uno script autonomo.
case "gameserveripstring": return new InjectionValue(bridge.GameServerAddress);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetCharsListForShard();Restituisce i nomi dei personaggi dello shard corrente noto al client.
Non ci sono parametri.
Matrice di stringhe. Non ci sono nomi conosciuti e il carattere corrente è un array vuoto.
- La sessione del manager recita SessionControl.Characters. In modalità standalone, LastCharacterManager viene utilizzato prima per account/server; se la lista è vuota, leggi LoginScene.Caratteri senza nomi vuoti; quindi l'attuale Player.Name viene utilizzato come unico elemento.
- Questi sono nomi famosi a livello locale; il comando non richiede un elenco completo dal server e non garantisce l'aggiornamento della cache.
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.GetCharsListForShard();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Il ciclo opera su un array effettivo di nomi noti.
var names = UO.GetCharsListForShard();
for (int i = (int)(0); i <= ArrayLength(names)-1; i += (int)(1))
{
UO.Print(names[i]);
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;Parametri e flusso di esecuzione:
- L'indice 0 viene utilizzato solo per un array non vuoto.
return RunScenario();
object? RunScenario()
{
var names = UO.GetCharsListForShard();
if (Truth(ArrayLength(names) > 0))
{
UO.Print(names[0]);
}
return null;
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- La dimensione dell'elenco non indica il numero di slot account sul server.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var names = UO.GetCharsListForShard();
UO.Print(Convert.ToString(ArrayLength(names)));
return null;
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.StringArray:StringArray(bridge.GetCharactersForCurrentShard()). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetCharactersForCurrentShard:bridge.GetCharactersForCurrentShard().
Codice interno di implementazione; non è uno script autonomo.
case "getcharslistforshard": return StringArray(bridge.GetCharactersForCurrentShard());Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetPing();
int UO.GetPing(object? timeout);Legge il ritardo di risposta del server di gioco. Senza discussione, utilizza l'ultima dimensione; con un timeout richiede una nuova risposta.
-
timeout— timeout / timeoutMS — tempo di attesa per un tentativo in millisecondi, convertito in int. Un valore negativo è limitato a zero. Con 0 si può inviare la richiesta, ma non si attende risposta; Non è un timeout infinito.
int, millisecondi. Valore >= 0 – misura; Sono accettabili anche 0 ms. -1 - nessuna misurazione: per un modulo con un argomento, la richiesta non è stata completata o la risposta non è stata ricevuta in tempo. Questo NON è bool; 0 non può essere considerato un fallimento e -1 un successo.
- GetPing() non invia nulla e legge immediatamente l'ultimo ServerPing. Il vecchio valore di per sé non dimostra che la connessione ora funzioni. Questa è l'ultima misurazione dell'eco del server, non il ping dell'indicatore TCP livellato/backup e non il ping ICMP (host). GetPing(timeout) attende una nuova risposta e quindi legge l'ultima misurazione del server.
- L'attesa ritarda lo script chiamante anziché confermare l'azione di gioco. Il comando non si riconnette e non modifica le impostazioni di rete. Il server potrebbe non rispondere all'eco: il guasto di per sé non dimostra che la connessione si è interrotta. La tempistica dipende anche dalla programmazione dei flussi; Non chiamare il controllo attivo su ogni frame. L'arresto dello script interrompe l'attesa.
- UO.GetPing · UO.CheckLag · UO.IsOnline
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.GetPing();
UO.Print("GetPing: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- Leggi la cache senza una nuova richiesta di rete. L'esempio seleziona 50 o 200 ms per attendere lo script stesso a una soglia di 250 ms. La dimensione sconosciuta viene elaborata separatamente. Questi numeri rappresentano un'impostazione di esempio, non un limite universale del server.
var pingMs = UO.GetPing();
if (Truth(pingMs < 0))
{
UO.Print("No server latency sample");
return null;
}
var delayMs = 50;
if (Truth(pingMs > 250))
{
delayMs = 200;
}
await Delay(delayMs);
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- 1000: attesa massima per una nuova risposta in millisecondi. A -1 la procedura termina. Se la misurazione ha esito positivo viene richiesto di nascondere; una risposta eco non dimostra l'uso riuscito dell'abilità.
return RunScenario();
object? RunScenario()
{
var pingMs = UO.GetPing(1000);
if (Truth(pingMs == -1))
{
UO.Print("No fresh server response");
return null;
}
UO.UseSkill("Hiding");
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:
- MeanPing(campioni, timeoutMs) mostrato per intero: 3 tentativi a 500 ms; le misurazioni non riuscite sono escluse dalla media. Se non ce ne sono di riusciti, viene restituito -1. campioni limitati a 1–10; UO.Wait(100) riduce il tasso di richieste tra i tentativi.
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 meanMs = await MeanPing(3, 500);
if (Truth(meanMs < 0))
{
UO.Print("No successful samples");
}
else
{
UO.Print("Measured mean, ms: " + Convert.ToString(meanMs));
}
return null;
}
async Task<dynamic> MeanPing(dynamic samples, dynamic timeoutMs)
{
if (Truth(samples < 1) || Truth(samples > 10))
{
return -1;
}
var total = 0;
var count = 0;
for (int i = (int)(1); i <= samples; i += (int)(1))
{
var current = UO.GetPing(timeoutMs);
if (Truth(current >= 0))
{
total = total + current;
count = count + 1;
}
await Delay(100);
}
if (Truth(count == 0))
{
return -1;
}
return total / count;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.GetPing. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetPing:bridge.GetPing().
Codice interno di implementazione; non è uno script autonomo.
public int GetPing() => bridge.GetPing();Parametri: timeout (Any)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.GetPing. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetPing:bridge.GetPing(Math.Max(0, NumberConversions.ToInt(timeout))). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(timeout).
Codice interno di implementazione; non è uno script autonomo.
public int GetPing(InjectionValue timeout) => bridge.GetPing(Math.Max(0, NumberConversions.ToInt(timeout)));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.IsOnline();Controlla se la sessione corrente è nel mondo di gioco e se la sua connessione di gioco è aperta. Utilizzare prima di un'azione del personaggio o mentre si attende l'ingresso.
Non ci sono parametri.
int. 1 - c'è un giocatore, una carta caricata e una presa di gioco attiva contemporaneamente; altrimenti 0. Una finestra client aperta, un elenco di caratteri o una connessione TCP in fase di accesso non significa 1. 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.
Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.
- Non ci sono parametri: serial, type, nome del carattere e IP non possono essere trasferiti. UO.Online(), UO.Connected() e UO.IsOnline() controllano la stessa cosa. Questo è lo stato del proprietario della sessione specificata, non di un altro profilo manager.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
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.IsOnline();
UO.Print("IsOnline: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- false è equivalente a 0. return termina Main su UseSkill. Nascondersi è l'unico parametro di UseSkill, il nome dell'abilità. Con 1 lo script chiede solo di utilizzare l'abilità; il risultato dipende dallo stato del personaggio e del server.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
if (Truth(Truth(UO.IsOnline()) == false))
{
return null;
}
UO.UseSkill("Hiding");
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Il confronto con 0 controlla la connessione corrente, non l'impostazione di riconnessione automatica. Connect senza argomenti utilizza le impostazioni salvate e non attende il completamento del login. La ripetizione di un comando durante un accesso già avviato non dovrebbe creare una seconda sessione.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.IsOnline() == 0))
{
UO.Connect();
}
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:
- WaitForWorld(timeoutMs) è una funzione definita dall'utente completamente mostrata, non un comando integrato. 5000 — budget in ms, UO.Wait(50) — intervallo di controllo. Un valore negativo dà false; 0 consente solo un mondo già pronto. Timer misura i secondi, quindi la differenza viene moltiplicata per 1000. La pausa automatica deve essere disattivata in anticipo, altrimenti Principale esce. La funzione non richiama Connect e non cancella l'input avviato allo scadere del tempo.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
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.GetPauseScriptOnDisconnectStatus()))
{
return null;
}
if (Truth(await WaitForWorld(5000)))
{
UO.UseSkill("Hiding");
}
return null;
}
async Task<dynamic> WaitForWorld(dynamic timeoutMs)
{
if (Truth(timeoutMs < 0))
{
return false;
}
var started = Environment.TickCount;
while (!(Truth(UO.IsOnline())))
{
if (Truth((Environment.TickCount - started) * 1000.0 >= timeoutMs))
{
return false;
}
await Delay(50);
}
return true;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.IsOnline. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsOnline:bridge.IsOnline().
Codice interno di implementazione; non è uno script autonomo.
public int IsOnline() => bridge.IsOnline();Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Online();Controlla se la sessione corrente è nel mondo di gioco e se la sua connessione di gioco è aperta. Utilizzare prima di un'azione del personaggio o mentre si attende l'ingresso.
Non ci sono parametri.
int. 1 - c'è un giocatore, una carta caricata e una presa di gioco attiva contemporaneamente; altrimenti 0. Una finestra client aperta, un elenco di caratteri o una connessione TCP in fase di accesso non significa 1. 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.
Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.
- Non ci sono parametri: serial, type, nome del carattere e IP non possono essere trasferiti. UO.Online(), UO.Connected() e UO.IsOnline() controllano la stessa cosa. Questo è lo stato del proprietario della sessione specificata, non di un altro profilo manager.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
- UO.Wait impiega millisecondi. La pausa automatica quando si perde la connessione e la pausa manuale ritardano l'esecuzione degli esempi: il controllo del timeout continuerà solo dopo la rimozione della pausa. Questi comandi non riattivano la pausa e non abilitano la riconnessione automatica.
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.Online();
UO.Print("Online: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- false è equivalente a 0. return termina Main su UseSkill. Nascondersi è l'unico parametro di UseSkill, il nome dell'abilità. Con 1 lo script chiede solo di utilizzare l'abilità; il risultato dipende dallo stato del personaggio e del server.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
if (Truth(Truth(UO.Online()) == false))
{
return null;
}
UO.UseSkill("Hiding");
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Il confronto con 0 controlla la connessione corrente, non l'impostazione di riconnessione automatica. Connect senza argomenti utilizza le impostazioni salvate e non attende il completamento del login. La ripetizione di un comando durante un accesso già avviato non dovrebbe creare una seconda sessione.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.Online() == 0))
{
UO.Connect();
}
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:
- WaitForWorld(timeoutMs) è una funzione definita dall'utente completamente mostrata, non un comando integrato. 5000 — budget in ms, UO.Wait(50) — intervallo di controllo. Un valore negativo dà false; 0 consente solo un mondo già pronto. Timer misura i secondi, quindi la differenza viene moltiplicata per 1000. La pausa automatica deve essere disattivata in anticipo, altrimenti Principale esce. La funzione non richiama Connect e non cancella l'input avviato allo scadere del tempo.
- Il comando legge solo lo stato locale. Non invia ping, non si connette, non si ferma e non controlla la disponibilità di Internet. Dopo la lettura, la connessione potrebbe cambiare; 1 non garantisce il successo dell'azione successiva.
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.GetPauseScriptOnDisconnectStatus()))
{
return null;
}
if (Truth(await WaitForWorld(5000)))
{
UO.UseSkill("Hiding");
}
return null;
}
async Task<dynamic> WaitForWorld(dynamic timeoutMs)
{
if (Truth(timeoutMs < 0))
{
return false;
}
var started = Environment.TickCount;
while (!(Truth(UO.Online())))
{
if (Truth((Environment.TickCount - started) * 1000.0 >= timeoutMs))
{
return false;
}
await Delay(50);
}
return true;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Online]. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsOnline:bridge.IsOnline().
La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.
Codice interno di implementazione; non è uno script autonomo.
() => bridge.IsOnline()Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.Resend();Invia una richiesta per risincronizzare il mondo.
Non ci sono parametri.
void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.
- Resync invia NetClient.Socket.Send_Resync al thread del gioco. Si tratta di una richiesta di aggiornamento, non di una riconnessione o di una conferma della ricezione dei dati.
- Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.
Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.
Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.
Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.
UO.Print("Calling UO.Resend");
UO.Resend();Parametri e flusso di esecuzione:
- Invia una richiesta per risincronizzare il mondo.
UO.Resend();Parametri e flusso di esecuzione:
- Resync invia NetClient.Socket.Send_Resync al thread del gioco. Si tratta di una richiesta di aggiornamento, non di una riconnessione o di una conferma della ricezione dei dati.
return RunScenario();
object? RunScenario()
{
if (Truth(UO.IsOnline()))
{
UO.Resend();
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
UO.Resend();
UO.Wait(500);
UO.Print(UO.GetX());
return null;
}
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: void / Unit.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Resync:bridge.Resync().
Codice interno di implementazione; non è uno script autonomo.
case "resend": bridge.Resync(); break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.ShardName();Legge il nome del frammento.
Non ci sono parametri.
string — testo del campo del ponte.ShardName; senza dati disponibili è possibile una stringa vuota. Questo non è un segno di connessione e non è un numerico ID.
- ExecuteClientApiCompatibility restituisce bridge.ShardName senza modificare la selezione del profilo o del server.
- Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
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.ShardName();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Legge il nome del frammento.
var value = UO.ShardName();
UO.Print(value);Parametri e flusso di esecuzione:
- ExecuteClientApiCompatibility restituisce bridge.ShardName senza modificare la selezione del profilo o del server.
return RunScenario();
object? RunScenario()
{
var value = UO.ShardName();
if (Truth(Len(value) > 0))
{
UO.TextPrint(value);
}
return null;
}
int Len(object? value) => Convert.ToString(value)?.Length ?? 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var before = UO.ShardName();
UO.Wait(500);
var after = UO.ShardName();
UO.Print(before = after);
return null;
}
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ShardName:bridge.ShardName.
Codice interno di implementazione; non è uno script autonomo.
case "shardname":
case "profileshardname": return new InjectionValue(bridge.ShardName);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.ShardPath();Legge il percorso del profilo corrente.
Non ci sono parametri.
string — testo del campo del ponte.CurrentProfilePath; senza dati disponibili è possibile una stringa vuota. Questo non è un segno di connessione e non è un numerico ID.
- ExecuteClientApiCompatibility restituisce bridge.CurrentProfilePath senza modificare la selezione del profilo o del server.
- Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
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.ShardPath();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- Legge il percorso del profilo corrente.
var value = UO.ShardPath();
UO.Print(value);Parametri e flusso di esecuzione:
- ExecuteClientApiCompatibility restituisce bridge.CurrentProfilePath senza modificare la selezione del profilo o del server.
return RunScenario();
object? RunScenario()
{
var value = UO.ShardPath();
if (Truth(Len(value) > 0))
{
UO.TextPrint(value);
}
return null;
}
int Len(object? value) => Convert.ToString(value)?.Length ?? 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var before = UO.ShardPath();
UO.Wait(500);
var after = UO.ShardPath();
UO.Print(before = after);
return null;
}
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: Nessun parametro.
Risultato: dynamic / Any.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CurrentProfilePath:bridge.CurrentProfilePath.
Codice interno di implementazione; non è uno script autonomo.
case "shardpath":
case "clientprofilepath": return new InjectionValue(bridge.CurrentProfilePath);ClassicUO — Bad Newbie & C# Scripts IDE