Repository navigation
IT UO Topic files json data
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
Home · C# · IDE · UO API · A–Z · Esempi · Lingue
File, JSON, array e raccolte C# e helper compatibili UO. Le funzioni integrate C# sono scritte senza UO.
| Argomento | Comandi e spiegazioni |
|---|---|
| File | C# e libreria standard |
| JSON Analizza | C# e libreria standard |
| JSON Carica | C# e libreria standard)) |
| JSON Salva | C# e libreria standard |
| JSON Stringa | C# e libreria standard |
| Elenco | C# e libreria standard |
| Dizionario | C# e libreria standard |
| Array | C# e libreria standard · C# e libreria standard |
| MemoryStream | C# e libreria standard |
UO.GetArrayLength · UO.GetWord · UO.GetWordCount
C# e libreria standard · C# e libreria standard · C# e libreria standard
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
dynamic[] amounts = new dynamic[checked((int)(2) + 1)];
amounts[0] = 50;
amounts[1] = 75;
amounts[2] = 25;
var total = 0;
for (int index = (int)(0); index <= UO.GetArrayLength(amounts) - 1; index += (int)(1))
{
total += amounts[index];
}
return total;Parametri, risultato e tutti gli scenari
return ReadX("move 1445 1690");
dynamic ReadX(dynamic text)
{
if (Truth(UO.GetWordCount(text) != 3))
{
return -1;
}
if (Truth(UO.GetWord(text, 0) != "move"))
{
return -1;
}
var xText = UO.GetWord(text, 1);
if (!(Truth(IsNumeric(xText))))
{
return -1;
}
var x = Convert.ToDouble(xText);
if (Truth(Convert.ToString(x) == "NaN") || Truth(x < 0) || Truth(x > 65535))
{
return -1;
}
if (Truth(x != Math.Truncate(x)))
{
return -1;
}
return Convert.ToInt32(x);
}
bool IsNumeric(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _);
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.GetArrayLength(object? arg);Conta le celle immediate dell'array per un'iterazione limitata e una lettura sicura dell'indice.
int >= 0. Un Array vuoto e un valore di altro tipo danno 0: il risultato da solo non può verificarne il tipo. Questa è una quantità, non un bool e non l'ultimo indice.
- Controllo locale: non invia una richiesta al server, non sposta elementi né modifica l'array. Gli esempi contengono dati di addestramento, non inventario in tempo reale.
- Controlla il tipo di valore e legge Array.Length senza attraversare o sommare. la dichiarazione dei valori della variabile (2) crea tre celle, indici 0..2, comprese quelle vuote.
- Gli elementi nidificati non vengono conteggiati in modo ricorsivo. Per una stringa c'è Len, per Lista/Dizionario c'è il loro Count. UO.GetArrayLength è un nome compatibile per lo stesso assegno locale.
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.GetArrayLength(new[] { 10, 20, 30 });
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parametri e flusso di esecuzione:
- la dichiarazione degli importi variabili (2) crea tre voci. Il ciclo ripete gli indici 0..2 e restituisce 150. Le quantità vengono aggiunte dal ciclo, non da ArrayLength.
- Controllo locale: non invia una richiesta al server, non sposta elementi né modifica l'array. Gli esempi contengono dati di addestramento, non inventario in tempo reale.
dynamic[] amounts = new dynamic[checked((int)(2) + 1)];
amounts[0] = 50;
amounts[1] = 75;
amounts[2] = 25;
var total = 0;
for (int index = (int)(0); index <= UO.GetArrayLength(amounts) - 1; index += (int)(1))
{
total += amounts[index];
}
return total;Parametri e flusso di esecuzione:
- Ci sono due punti dell'array nel percorso, ciascuno con tre celle di coordinate. Il risultato è 2|3, non sei. Il personaggio non si muove.
- Controllo locale: non invia una richiesta al server, non sposta elementi né modifica l'array. Gli esempi contengono dati di addestramento, non inventario in tempo reale.
return RunScenario();
object? RunScenario()
{
dynamic[] first = new dynamic[checked((int)(2) + 1)];
first[0] = 100;
first[1] = 200;
first[2] = 0;
dynamic[] second = new dynamic[checked((int)(2) + 1)];
second[0] = 101;
second[1] = 200;
second[2] = 0;
dynamic[] route = new dynamic[checked((int)(1) + 1)];
route[0] = first;
route[1] = second;
return Convert.ToString(UO.GetArrayLength(route)) + "|" + Convert.ToString(UO.GetArrayLength(route[0]));
return null;
}Parametri e flusso di esecuzione:
- La linea dà 0; Main non restituisce alcun percorso prima di accedere all'indice. Il controllo è adatto anche per un Array vuoto, ma non fa distinzione tra questi casi.
- Controllo locale: non invia una richiesta al server, non sposta elementi né modifica l'array. Gli esempi contengono dati di addestramento, non inventario in tempo reale.
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 route = "not an array";
if (Truth(UO.GetArrayLength(route) == 0))
{
return "no route";
}
return route[0];
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: arg (Any)
Risultato: dynamic / Any.
Durante la chiamata:
Codice interno di implementazione; non è uno script autonomo.
public static InjectionValue GetArrayLength(InjectionValue arg) => arg.Kind==InjectionValueKind.Array?new InjectionValue(arg.Array.Length):InjectionValue.Zero;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
string UO.GetWord(object? value, object? wordIndex);
string UO.GetWord(object? value, object? wordIndex, object? delimiter);Ottiene una singola parola o campo dal testo. Utile per analizzare coordinate, un elenco di priorità o impostazioni di script salvate.
-
value— Stringa di origine. La funzione analizza esattamente il testo trasmesso: non legge da sola la rivista, il file, l'attrezzatura o il mondo. -
wordIndex— Indice intero della parola da 0: 0 è il primo, 1 è il secondo. Un indice negativo e un indice non inferiore al numero di parole restituiscono una stringa vuota. -
delimiter— Delimitatore opzionale. Senza di esso, con "" o con un singolo spazio " ", il testo viene diviso da qualsiasi carattere di spazio Unicode, comprese tabulazioni e ritorni a capo. Un altro delimitatore è la sequenza esatta nella sua interezza: "::" significa due due punti di fila, non tutti i due punti. Le parti vuote vengono scartate; le parti non vuote non vengono ritagliate.
string: parte non vuota selezionata o "" se non è presente alcun indice. Questo è testo, non ID, type o un numero: per un numero, seleziona IsNumeric separatamente e converti il valore.
- Funziona localmente, senza pacchetti o azioni di gioco. GetWord e UO.GetWord chiamano lo stesso gestore; Anche GetWordCount e UO.GetWordCount sono uguali. Ogni chiamata ri-suddivide l'intero testo. Nel ciclo, salva la quantità in anticipo; Per analisi ripetute di grandi dimensioni, è preferibile archiviare i campi già analizzati in un array. Questo non è un parser CSV: le virgolette non proteggono i delimitatori, le colonne vuote vengono perse.
- GetWord · GetWordCount · IsNumeric
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.GetWord("red green blue", 1);
UO.Print("GetWord: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- ReadX riceve la stringa "move 1445 1690". Prova tre parole e il nome mossa; l'indice 1 seleziona X. IsNumeric controlla il testo, Converti. ToInt32 restituisce 1445. Questa è solo una ripartizione della configurazione; il personaggio non si muove. Se il modulo non è corretto, viene restituito -1.
- ReadX richiede anche l'intero X nell'intervallo 0..65535 prima di Convert.ToInt32; NaN, infinito e frazionario X vengono rifiutati. Y non è testato qui.
return ReadX("move 1445 1690");
dynamic ReadX(dynamic text)
{
if (Truth(UO.GetWordCount(text) != 3))
{
return -1;
}
if (Truth(UO.GetWord(text, 0) != "move"))
{
return -1;
}
var xText = UO.GetWord(text, 1);
if (!(Truth(IsNumeric(xText))))
{
return -1;
}
var x = Convert.ToDouble(xText);
if (Truth(Convert.ToString(x) == "NaN") || Truth(x < 0) || Truth(x > 65535))
{
return -1;
}
if (Truth(x != Math.Truncate(x)))
{
return -1;
}
return Convert.ToInt32(x);
}
bool IsNumeric(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _);
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:
- PriorityAt ottiene la lista "mago||tank|archer|" e indice=1. Separatore | scarta gli elementi vuoti, quindi il risultato è tank. I nomi sono arbitrari; qui non registrano ClassMask né controllano gli indumenti. Utilizza le stesse regole di divisione durante il conteggio e la selezione.
return RunScenario();
object? RunScenario()
{
return PriorityAt("mage||tank|archer|", 1);
return null;
}
dynamic PriorityAt(dynamic names, dynamic index)
{
return UO.GetWord(names, index, "|");
}Parametri e flusso di esecuzione:
- ReadPlace divide "Britain::Bank:west" con il delimitatore esatto ::. L'indice 1 restituisce Bank:west, lasciando i due punti interni. Se non ci sono esattamente due parti non vuote, l'helper restituisce "". Gli spazi attorno alle parti vengono preservati.
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()
{
return ReadPlace("Britain::Bank:west");
return null;
}
dynamic ReadPlace(dynamic text)
{
if (Truth(UO.GetWordCount(text, "::") != 2))
{
return "";
}
return UO.GetWord(text, 1, "::");
}
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: value (String), wordIndex (Integer)
Risultato: string / String.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApi.GetWord. -
InjectionScript.Runtime.InjectionApi.GetWord:GetWord(value,wordIndex," ").
Codice interno di implementazione; non è uno script autonomo.
private static string GetWord(string value,int wordIndex) => GetWord(value,wordIndex," ");Parametri: value (String), wordIndex (Integer), delimiter (String)
Risultato: string / String.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApi.GetWord. -
InjectionScript.Runtime.InjectionApi.SplitWords:SplitWords(value,delimiter).
Codice interno di implementazione; non è uno script autonomo.
private static string GetWord(string value,int wordIndex,string delimiter)
{
var words=SplitWords(value,delimiter);return wordIndex>=0&&wordIndex<words.Length?words[wordIndex]:string.Empty;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetWordCount(object? value);
int UO.GetWordCount(object? value, object? delimiter);Conta i campi di testo non vuoti. Consente di verificare il numero di coordinate prima dell'analisi e di determinare i limiti di enumerazione dell'elenco.
-
value— Stringa di origine. La funzione analizza esattamente il testo trasmesso: non legge da sola la rivista, il file, l'attrezzatura o il mondo. -
delimiter— Delimitatore opzionale. Senza di esso, con "" o con un singolo spazio " ", il testo viene diviso da qualsiasi carattere di spazio Unicode, comprese tabulazioni e ritorni a capo. Un altro delimitatore è la sequenza esatta nella sua interezza: "::" significa due due punti di fila, non tutti i due punti. Le parti vuote vengono scartate; le parti non vuote non vengono ritagliate.
int — numero di parti non vuote. Una stringa vuota e una stringa solo delimitata producono 0. Questo è un contatore, non un bool: anche 2 è un risultato valido; controlla il conteggio > 0 o la quantità esatta di cui hai bisogno.
- Funziona localmente, senza pacchetti o azioni di gioco. GetWord e UO.GetWord chiamano lo stesso gestore; Anche GetWordCount e UO.GetWordCount sono uguali. Ogni chiamata ri-suddivide l'intero testo. Nel ciclo, salva la quantità in anticipo; Per analisi ripetute di grandi dimensioni, è preferibile archiviare i campi già analizzati in un array. Questo non è un parser CSV: le virgolette non proteggono i delimitatori, le colonne vuote vengono perse.
- GetWord · GetWordCount · IsNumeric
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.GetWordCount("red green blue");
UO.Print("GetWordCount: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- HasPoint accetta "1445 1690 0". Richiede esattamente tre parole e testo numerico in ciascuna, quindi restituisce 1; altrimenti 0. Questo è solo un controllo del modulo e non della validità della mappa, dei confini delle coordinate o della percorribilità. GetWordCount qui restituisce 3 e bool viene restituito dal nostro helper.
- HasPoint rifiuta inoltre NaN e gli infiniti, che IsNumeric stesso può accettare. Sono ammessi numeri finiti frazionari; Prima del movimento è necessario un controllo separato di tutte le coordinate del gioco.
return HasPoint("1445 1690 0");
dynamic HasPoint(dynamic text)
{
if (Truth(UO.GetWordCount(text) != 3))
{
return 0;
}
var i = 0;
while (Truth(i < 3))
{
if (!(Truth(IsNumeric(UO.GetWord(text, i)))))
{
return 0;
}
var value = Convert.ToString(Convert.ToDouble(UO.GetWord(text, i)));
if (Truth(value == "NaN") || Truth(value == "Infinity") || Truth(value == "-Infinity"))
{
return 0;
}
i = i + 1;
}
return 1;
}
bool IsNumeric(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _);
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:
- JoinPriorities ottiene "mago||tank|archer|". Conta tre elementi non vuoti una volta, scorre gli indici 0..2 e restituisce "mago > carro armato > arciere". Inizio, fine e ripetizione | non creare una priorità separata.
return RunScenario();
object? RunScenario()
{
return JoinPriorities("mage||tank|archer|");
return null;
}
dynamic JoinPriorities(dynamic names)
{
var count = UO.GetWordCount(names, "|");
var i = 0;
var result = "";
while (Truth(i < count))
{
if (Truth(i > 0))
{
result = result + " > ";
}
result = result + UO.GetWord(names, i, "|");
i = i + 1;
}
return result;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parametri e flusso di esecuzione:
- CountPlaces ottiene "Britain::Bank:west::". Il separatore :: fornisce due campi, il campo vuoto finale viene rimosso: il risultato è 2. Singolo: Bank:west non divide il testo all'interno. Questo non è un elenco di città dal client, ma un esempio del formato di configurazione.
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()
{
return CountPlaces("Britain::Bank:west::");
return null;
}
dynamic CountPlaces(dynamic text)
{
return UO.GetWordCount(text, "::");
}
}C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
Parametri: value (String)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApi.GetWordCount. -
InjectionScript.Runtime.InjectionApi.GetWordCount:GetWordCount(value," ").
Codice interno di implementazione; non è uno script autonomo.
private static int GetWordCount(string value) => GetWordCount(value," ");Parametri: value (String), delimiter (String)
Risultato: int / Integer.
Durante la chiamata:
-
InjectionScript.Runtime.InjectionApi.GetWordCount. -
InjectionScript.Runtime.InjectionApi.SplitWords:SplitWords(value,delimiter).
Codice interno di implementazione; non è uno script autonomo.
private static int GetWordCount(string value,string delimiter) => SplitWords(value,delimiter).Length;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Random(object? max);
int UO.Random(object? min, object? max);Restituisce un numero intero casuale. Il nuovo modulo UO.Random(min, max) seleziona il numero DAL min AL max compreso. Viene mantenuta la forma precedente UO.Random(max): seleziona da 0 a max−1. Il risultato può essere memorizzato in una variabile e utilizzato come ritardo, coordinata, indice o condizione.
-
min— Il primo argomento della forma a due argomenti SOLO è il limite inferiore incluso, un numero intero da −2147483648 a 2147483647. Può essere negativo, zero o positivo. Non dovrebbe essere superiore al massimo Nella forma ad un argomento non c'è un minimo e il numero passato significa massimo. -
max— Nella forma a due argomenti, il secondo argomento, incluso il limite superiore int da −2147483648 a 2147483647. Nella precedente forma ad un argomento, un singolo argomento, limite superiore ESCLUSI, un numero intero da 0 a 2147483647; Random(0) restituisce 0. Non è consentito un massimo negativo sotto forma di un argomento.
int è un numero intero pseudo-casuale. Con due argomenti min ≤ risultato ≤ max; entrambi i confini possono cadere. Con un argomento positivo 0 ≤ risultato < max. È accettabile ripetere un numero estratto in precedenza: la squadra non seleziona numeri senza ripetizioni.
- Sono supportate esattamente due forme: UO.Random(max) e UO.Random(min, max). Una chiamata senza argomenti non viene registrata. Per un intervallo "da e a", utilizzare due argomenti.
- Random(5, 5) restituisce sempre 5. Random(10, 1) segnala un errore di intervallo: i confini non vengono scambiati silenziosamente. Random(-10, -1) è corretto perché −10 è inferiore a −1.
- Entrambi i confini sono numeri interi int; per le frazioni decimali è possibile selezionare unità intere della scala desiderata e quindi dividere. Ad esempio, Random(0, 100) / 100.0 fornisce valori discreti da 0 a 1 con incrementi di 0,01.
- L'intervallo completo di Random(-2147483648, 2147483647) è accettabile. L'implementazione non aggiunge 1 a max int e quindi non eccede al limite superiore. Per intervalli ampi, viene utilizzato lo scarto dei valori aggiuntivi in modo che il resto della divisione non distorca la selezione.
- La chiamata calcola il numero localmente, non invia pacchetti e non si interrompe. Per una pausa casuale, passa il risultato a UO.Wait. Lo script dovrebbe mantenere la latenza minima richiesta dal server.
- Memorizza il risultato in var se hai bisogno dello stesso numero più volte. Due chiamate separate a Random possono restituire valori diversi. Il comando non verifica se la casella selezionata è valida per il movimento o il trasferimento: questo viene verificato dal corrispondente comando di gioco.
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.Random(10);
UO.Print("Random: " + Convert.ToString(result));Parametri e flusso di esecuzione:
- il minimo diventa inferiore=1, il massimo diventa superiore=6. Ci sono esattamente sei valori possibili: 1, 2, 3, 4, 5 e 6.
- il rotolo memorizza un numero ricevuto. Print visualizza esattamente questo; Convert.ToString converte int in una stringa. Eseguendolo nuovamente si potrebbe ottenere lo stesso numero.
var lower = 1;
var upper = 6;
var roll = UO.Random(lower, upper);
UO.Print("Roll: " + Convert.ToString(roll));Parametri e flusso di esecuzione:
- min=350 e max=700 definiscono i limiti di ritardo abilitati. Il risultato, come 350, 512 o 700, viene scritto in ritardo.
- UO.Wait riceve un argomento di ritardo in millisecondi. La pausa avviene in UO.Wait; Random calcola solo il numero.
- Scegli il limite inferiore in base alle azioni e ai requisiti del tuo server. Il ritardo casuale non sostituisce l'attesa della risposta del server se l'azione successiva necessita di tale risposta.
return RunScenario();
object? RunScenario()
{
var delay = UO.Random(350, 700);
UO.Print("Waiting " + Convert.ToString(delay) + " ms");
UO.Wait(delay);
UO.Print("Wait finished");
return null;
}Parametri e flusso di esecuzione:
- min=1, max=3: la scelta è 1, 2 o 3. Ogni ramo corrisponde a uno dei numeri validi.
- La chiamata a Random viene eseguita una volta prima dell'if. Se lo richiami in ciascuna condizione, queste saranno elezioni diverse.
- Sostituisci Print con le azioni desiderate nel tuo script, mantenendo i controlli di condizione, intervallo e risposta del server per tali azioni.
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 choice = UO.Random(1, 3);
if (Truth(choice == 1))
{
UO.Print("First action");
}
else
{
if (Truth(choice == 2))
{
UO.Print("Second action");
}
else
{
UO.Print("Third action");
}
}
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:
- Primo Random: min=50, max=90, risultato x. Secondo: min=60, max=100, risultato y. Queste sono due coordinate indipendenti all'interno del contenitore, non coordinate dello schermo o coordinate della mappa.
- In MassMove ritardo=350 ms, quantità=10 elementi interi, type=0 è determinato dal primo trasferimento manuale, destinazione=backpack, x/y sono presi dalle variabili, z=0.
- Dopo il comando trascinare il campione con il mouse dal contenitore originale. L'intera inclusione di MassMove utilizza una posizione selezionata. La randomizzazione della posizione di ogni singolo elemento richiede un ciclo con MoveItem separato anziché una singola chiamata a MassMove.
- Seleziona l'intervallo X/Y all'interno dell'area disponibile del tuo zaino. Il server può modificare la posizione degli elementi.
var x = UO.Random(50, 90);
var y = UO.Random(60, 100);
UO.MassMove(350, 10, 0, "backpack", x, y, 0);
UO.Print("Drag a source item; position: " + Convert.ToString(x) + ", " + Convert.ToString(y));Parametri e flusso di esecuzione:
- In entrambe le chiamate sono possibili min=−2 e max=2: −2, −1, 0, 1, 2. GetX/GetY legge le coordinate del carattere senza argomenti.
- x/y è solo una cella calcolata in un quadrato attorno al carattere. Questo esempio non inizia a spostare o lanciare oggetti.
- Una cella casuale può essere impraticabile o oltre il confine della mappa. Prima dell'azione di gioco, utilizza le coordinate appropriate e i controlli del percorso.
return RunScenario();
object? RunScenario()
{
var offsetX = UO.Random(-2, 2);
var offsetY = UO.Random(-2, 2);
var x = UO.GetX() + offsetX;
var y = UO.GetY() + offsetY;
UO.Print("Candidate tile: " + Convert.ToString(x) + ", " + Convert.ToString(y));
return null;
}Parametri e flusso di esecuzione:
- In Random(count) c'è solo max=10: nessun limite superiore, 0..9 possibile. Il numero 10 non appare.
- In Random(0, count−1) min=0 e max=9 inclusi: l'intervallo valido è lo stesso, ma la chiamata effettua una nuova scelta indipendente.
- il conteggio deve essere positivo per la selezione dell'indice. Il caso speciale compatibile Random(0)=0 non significa che la raccolta vuota ha un elemento nell'indice 0.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var count = 10;
var index = UO.Random(count);
var equivalent = UO.Random(0, count - 1);
UO.Print("Index 0..9: " + Convert.ToString(index));
UO.Print("Another independent index: " + Convert.ToString(equivalent));
return null;
}
}Parametri e flusso di esecuzione:
- min=7 e max=7 danno un unico risultato 7.
- min=−100 e max=−50 danno solo numeri negativi, inclusi entrambi i confini.
- L'ultima chiamata copre l'intero bit 32 int con segno. Il suo risultato può essere positivo, negativo o zero.
- I confini vengono passati dal più piccolo al più grande. La chiamata errata a Random(10, 1) si interrompe con il messaggio min non deve superare max; non è necessario utilizzarlo per un intervallo invertito.
var fixedValue = UO.Random(7, 7);
var negative = UO.Random(-100, -50);
var signedValue = UO.Random(-2147483648, 2147483647);
UO.Print("Fixed: " + Convert.ToString(fixedValue));
UO.Print("Negative: " + Convert.ToString(negative));
UO.Print("Signed Integer: " + Convert.ToString(signedValue));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: max (Integer)
Risultato: int / Integer.
Durante la chiamata:
Codice interno di implementazione; non è uno script autonomo.
public int Random(int max)
{
lock (randomSync) return random.Next(max);
}Parametri: min (Integer), max (Integer)
Risultato: int / Integer.
Durante la chiamata:
Codice interno di implementazione; non è uno script autonomo.
public int Random(int min, int max)
{
if (min > max)
throw new NativeSubrutineException("UO.Random(min, max): min must not exceed max.");
if (min == max) return min;
long count = (long)max - min + 1;
lock (randomSync)
{
if (count <= int.MaxValue)
return (int)(min + (long)random.Next((int)count));
// Inclusive Int32.MaxValue and the full signed range must not
// overflow. Rejection avoids modulo bias; reuse the four bytes.
const ulong domain = 1UL << 32;
ulong limit = domain - domain % (ulong)count;
uint sample;
do
{
random.NextBytes(randomRangeBytes);
sample = BitConverter.ToUInt32(randomRangeBytes, 0);
} while (sample >= limit);
return (int)(min + (long)(sample % (ulong)count));
}
}ClassicUO — Bad Newbie & C# Scripts IDE