Skip to content

IT UO Topic conversion compatibility

Jump to bottom
Codex edited this page Oct 12, 2026 · 4 revisions

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Conversione e compatibilità

Home · C# · IDE · UO API · A–Z · Esempi · Lingue

Converte numeri, serial e formati di script legacy. Un nome compatibile può avere restrizioni o un'operazione esplicitamente vietata: questo è indicato sulla carta.

Sezioni

Argomento Comandi e spiegazioni
Hex / int UO.Hex2Int · UO.Int2Hex
EUO ↔ Injection UO.EUO2ID · UO.EUO2Type · UO.EUO2Inj · UO.Inj2EUO
EasyUO UO.GetEasyUO · UO.SetEasyUO
Conversione di tipo C# e libreria standard C# e libreria standard C# e libreria standard C# e libreria standard C# e libreria standard · C# e libreria standard

Tutti i comandi del tema

Conversione

UO.Hex2Int · UO.Int2Hex · UO.ScanInt · UO.EUO2ID · UO.EUO2Inj · UO.EUO2Type · UO.Inj2EUO

Limiti di compatibilità

UO.BoxHack · UO.ShutdownWindows

Esempi sull'argomento

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.

UO.Int2Hex

Parametri, risultato e tutti gli scenari

UO.Print(UO.Int2Hex(1073746484));

UO.EUO2ID

Parametri, risultato e tutti gli scenari

var value = UO.EUO2ID("B");
UO.Print(Convert.ToString(value));

Riferimento completo dei comandi

UO.BoxHack

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Firme C#

void UO.BoxHack();

Stampa un avviso che la patch del client nativo legacy BoxHack non è richiesta da ClassicUO.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Il ramo ExecuteLegacyManualAlias chiama solo SystemMessage. Non corregge il movimento, la voce, i contenitori o il protocollo di rete.

Script C# autonomi

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.

Esempio semplice

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.BoxHack");
UO.BoxHack();

1. Avviso di compatibilità - Script diretto

Parametri e flusso di esecuzione:

  • Il messaggio descrive la mancata necessità della vecchia patch.
UO.BoxHack();

2. Procedura di chiamata - funzione script

Parametri e flusso di esecuzione:

  • La procedura di compatibilità non modifica il mondo di gioco.
return  RunScenario();
 object? RunScenario()
{
    CompatibilityNotice();
    return null;
}

void CompatibilityNotice()
{
    UO.BoxHack();
}

3. Continuazione dello script - Classe di script

Parametri e flusso di esecuzione:

  • Dopo il messaggio diagnostico, l'esecuzione continua.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.BoxHack();
        UO.Print("continued");
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

UO.BoxHack() — UO.BoxHack()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "boxhack":

                case "fixtalk":

                case "fixwalk":

                    SystemMessage($"{name}: obsolete native-client patch; ClassicUO does not require it.");

                    break;

UO.EUO2ID

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Firme C#

dynamic UO.EUO2ID(object? euo);

Decodifica la notazione letterale EasyUO in radice 26 con A=0.

Parametri

  • euo — Stringa/valore EasyUO. Le lettere vengono convertite in maiuscolo; i caratteri non alfabetici vengono saltati.

Valore restituito

int — il valore numerico risultante a 32 bit; questa non è una stringa esadecimale.

Comportamento

  • Calcola in sequenza valore=valore*26+(lettera-A). L'accumulatore uint viene eseguito senza controllo, quindi l'overflow avvolge i bit 32. La stringa vuota e la stringa senza lettere danno 0. Non cerca nessun oggetto nel mondo.

Script C# autonomi

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.

Esempio semplice

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.EUO2ID("B");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Valore a lettera singola: script diretto

Parametri e flusso di esecuzione:

  • B codifica il numero 1.
var value = UO.EUO2ID("B");
UO.Print(Convert.ToString(value));

2. Caratteri diversi dalle lettere: funzione dello script

Parametri e flusso di esecuzione:

  • Il caso non è importante; Il trattino e il punto esclamativo vengono saltati.
return  RunScenario();
 object? RunScenario()
{
    var value = UO.EUO2ID("b-!");
    UO.Print(Convert.ToString(value));
    return null;
}

3. Voce nulla: classe di script

Parametri e flusso di esecuzione:

  • A codifica zero; il risultato non indica l'oggetto trovato.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var value = UO.EUO2ID("A");
        UO.Print(Convert.ToString(value));
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

UO.EUO2ID(euo) — UO.EUO2ID(Any)

Parametri: euo (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "euo2id":

                case "euo2type": return new InjectionValue(DecodeEasyUoId(Text(0)));

UO.EUO2Inj

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Firme C#

string UO.EUO2Inj(object? easyValue);

Decodifica la notazione letterale EasyUO in radice 26 con A=0.

Parametri

  • easyValue — Stringa/valore EasyUO. Le lettere vengono convertite in maiuscolo; i caratteri non alfabetici vengono saltati.

Valore restituito

string è la stringa esadecimale dell'Iniezione del risultante serial.

Comportamento

  • Calcola in sequenza valore=valore*26+(lettera-A). L'accumulatore uint viene eseguito senza controllo, quindi l'overflow avvolge i bit 32. La stringa vuota e la stringa senza lettere danno 0. Non cerca nessun oggetto nel mondo.

Script C# autonomi

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.

Esempio semplice

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.EUO2Inj("B");
UO.Print("EUO2Inj: " + Convert.ToString(result));

1. Valore a lettera singola: script diretto

Parametri e flusso di esecuzione:

  • B codifica il numero 1.
var value = UO.EUO2Inj("B");
UO.Print(Convert.ToString(value));

2. Caratteri diversi dalle lettere: funzione dello script

Parametri e flusso di esecuzione:

  • Il caso non è importante; Il trattino e il punto esclamativo vengono saltati.
return  RunScenario();
 object? RunScenario()
{
    var value = UO.EUO2Inj("b-!");
    UO.Print(Convert.ToString(value));
    return null;
}

3. Voce nulla: classe di script

Parametri e flusso di esecuzione:

  • A codifica zero; il risultato non indica l'oggetto trovato.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var value = UO.EUO2Inj("A");
        UO.Print(Convert.ToString(value));
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

UO.EUO2Inj(easyValue) — UO.EUO2Inj(Any)

Parametri: easyValue (Any)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string EUO2Inj(InjectionValue easyValue)

        {

            uint value = 0;

            foreach (char c in easyValue.ToString().ToUpperInvariant())

            {

                if (c < 'A' || c > 'Z')

                    continue;

                value = unchecked(value * 26 + (uint)(c - 'A'));

            }

            return NumberConversions.ToHex(unchecked((int)value));

        }

UO.EUO2Type

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Firme C#

dynamic UO.EUO2Type(object? euo);

Decodifica la notazione letterale EasyUO in radice 26 con A=0.

Parametri

  • euo — Stringa/valore EasyUO. Le lettere vengono convertite in maiuscolo; i caratteri non alfabetici vengono saltati.

Valore restituito

int — il valore numerico risultante a 32 bit; questa non è una stringa esadecimale.

Comportamento

  • Calcola in sequenza valore=valore*26+(lettera-A). L'accumulatore uint viene eseguito senza controllo, quindi l'overflow avvolge i bit 32. La stringa vuota e la stringa senza lettere danno 0. Non cerca nessun oggetto nel mondo.

Script C# autonomi

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.

Esempio semplice

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.EUO2Type("B");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Valore a lettera singola: script diretto

Parametri e flusso di esecuzione:

  • B codifica il numero 1.
var value = UO.EUO2Type("B");
UO.Print(Convert.ToString(value));

2. Caratteri diversi dalle lettere: funzione dello script

Parametri e flusso di esecuzione:

  • Il caso non è importante; Il trattino e il punto esclamativo vengono saltati.
return  RunScenario();
 object? RunScenario()
{
    var value = UO.EUO2Type("b-!");
    UO.Print(Convert.ToString(value));
    return null;
}

3. Voce nulla: classe di script

Parametri e flusso di esecuzione:

  • A codifica zero; il risultato non indica l'oggetto trovato.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var value = UO.EUO2Type("A");
        UO.Print(Convert.ToString(value));
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

UO.EUO2Type(euo) — UO.EUO2Type(Any)

Parametri: euo (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "euo2id":

                case "euo2type": return new InjectionValue(DecodeEasyUoId(Text(0)));

UO.Hex2Int

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Firme C#

int UO.Hex2Int(object? value);

Converte un valore numerico o un testo numerico in un int.

Parametri

  • value — Testo int, double, double o testo esadecimale con 0x. Sono ammessi spazi attorno ai bordi e al cartello. Le stringhe alias "self"/"lasttarget" non sono consentite qui.

Valore restituito

int con 32 bit; esadecimale 0xFFFFFFFF dà -1. double viene troncato a zero con un controllo dell'intervallo. Array e null in NumberConversions.ToInt danno come risultato 0.

Comportamento

  • Nonostante il nome, è accettato il testo decimale. Il testo non valido dà FormatException, il tipo non supportato dà InvalidCastException; overflow double: errore di conversione.
  • La formattazione inversa è UO.Int2Hex. Una trasformazione non prova l'esistenza di un oggetto.

Script C# autonomi

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.

Esempio semplice

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.Hex2Int("0x40001234");
UO.Print("Hex2Int: " + Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Converte un valore numerico o un testo numerico in un int.
UO.Print(UO.Hex2Int("0x40001234"));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Nonostante il nome, è accettato il testo decimale. Il testo non valido dà FormatException, il tipo non supportato dà InvalidCastException; overflow double: errore di conversione.
return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.Hex2Int("255"));
    UO.Print(UO.Hex2Int("0xFFFFFFFF"));
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • La formattazione inversa è UO.Int2Hex. Una trasformazione non prova l'esistenza di un oggetto.
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 number = UO.Hex2Int("0x000000FF");
        UO.Print(UO.Int2Hex(number));
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

UO.Hex2Int(value) — UO.Hex2Int(Any)

Parametri: value (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Hex2Int(InjectionValue value) => NumberConversions.ToInt(value);

UO.Inj2EUO

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Firme C#

string UO.Inj2EUO(object? serialValue);

Codifica il numero di bit 32 serial con le lettere A..Z per EasyUO.

Parametri

  • serialValue — Numero fino a NumberConversions.ToInt, quindi uint senza segno con bit conservati. Per un alias, prendi prima GetSerial/Hex2Int.

Valore restituito

string sono le solite cifre di base 26 con A=0..Z=25. Zero dà "A". Questo non è un nome esadecimale o di oggetto.

Comportamento

  • L'algoritmo inserisce la lettera A + valore % 26 a sinistra e divide uint per 26 a zero. Questa è la conversione del progetto, non il numero di colonna di Excel A1.
  • EUO2Inj esegue la conversione inversa in una stringa esadecimale. La codifica non crea un oggetto e non lo richiede al client.

Script C# autonomi

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.

Esempio semplice

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.Inj2EUO(0);
UO.Print("Inj2EUO: " + Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Codifica il numero di bit 32 serial con le lettere A..Z per EasyUO.
UO.Print(UO.Inj2EUO(0));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • L'algoritmo inserisce la lettera A + valore % 26 a sinistra e divide uint per 26 a zero. Questa è la conversione del progetto, non il numero di colonna di Excel A1.
return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.Inj2EUO(26));
    UO.Print(UO.Inj2EUO(25));
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • EUO2Inj esegue la conversione inversa in una stringa esadecimale. La codifica non crea un oggetto e non lo richiede al client.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var value = UO.Hex2Int("0x40001234");
        var encoded = UO.Inj2EUO(value);
        UO.Print(encoded);
        UO.Print(UO.EUO2Inj(encoded));
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

UO.Inj2EUO(serialValue) — UO.Inj2EUO(Any)

Parametri: serialValue (Any)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string Inj2EUO(InjectionValue serialValue)

        {

            uint value = unchecked((uint)NumberConversions.ToInt(serialValue));

            if (value == 0)

                return "A";

            var result = new StringBuilder();

            while (value > 0)

            {

                result.Insert(0, (char)('A' + value % 26));

                value /= 26;

            }

            return result.ToString();

        }

UO.Int2Hex

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Firme C#

string UO.Int2Hex(object? value);

Formatta int come una stringa esadecimale serial.

Parametri

  • value - int o testo numerico/esadecimale; double viene troncato a zero con un controllo di overflow. Impossibile trovare l'alias dell'oggetto.

Valore restituito

string "0xXXXXXXXX": otto cifre esadecimali, tutti 32 bit int. Un valore negativo è rappresentato nel complemento a due.

Comportamento

  • NumberConversions.ToInt esegue la conversione, quindi ToHex utilizza il formato X8. Ad esempio -1 restituisce "0xFFFFFFFF". Il testo numerico non valido causa un errore; questo non è un test per l'esistenza di serial.
  • Per rappresentare un numero è sufficiente la conversione; la presenza dell'oggetto viene verificata da UO.Exists separatamente.

Script C# autonomi

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.

Esempio semplice

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.Int2Hex(1073746484);
UO.Print("Int2Hex: " + Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Formatta int come una stringa esadecimale serial.
UO.Print(UO.Int2Hex(1073746484));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • NumberConversions.ToInt esegue la conversione, quindi ToHex utilizza il formato X8. Ad esempio -1 restituisce "0xFFFFFFFF". Il testo numerico non valido causa un errore; questo non è un test per l'esistenza di serial.
return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.Int2Hex(-1));
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Per rappresentare un numero è sufficiente la conversione; la presenza dell'oggetto viene verificata da UO.Exists separatamente.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var encoded = UO.Int2Hex(255);
        UO.Print(encoded);
        UO.Print(UO.Hex2Int(encoded));
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

UO.Int2Hex(value) — UO.Int2Hex(Any)

Parametri: value (Any)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string Int2Hex(InjectionValue value) => NumberConversions.ToHex(NumberConversions.ToInt(value));

UO.ScanInt

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Firme C#

int UO.ScanInt(object? textValue, object? startValue);

Trova il primo numero con segno double/hex nella stringa, a partire dalla posizione.

Parametri

  • textValue: SMS tramite ToString. Cerca la prima corrispondenza dell'espressione regolare [-+]?(?:0[xX][0-9A-Fa-f]+|\d+).
  • startValue — int, posizione zero UTF-16. Limitato a 0..text.Length; non indicizzare da 1.

Valore restituito

int è il primo numero a 32 bit riconosciuto. Non c'è corrispondenza o il numero non va bene - 0; uno zero reale dà anche 0.

Comportamento

  • Regex.Match viene applicato a Substring(start). Se la prima corrispondenza non riesce a convertire TryStr2Int, i numeri successivi non vengono cercati. La parte frazionaria, come .5, non è inclusa nel token numerico.
  • Un inizio negativo diventa 0, un inizio oltre la fine della riga diventa text.Length e il risultato è 0. La linea originale non cambia.

Script C# autonomi

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.

Esempio semplice

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.ScanInt("gold=123", 0);
UO.Print("ScanInt: " + Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Trova il primo numero con segno double/hex nella stringa, a partire dalla posizione.
UO.Print(UO.ScanInt("gold=123", 0));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Regex.Match viene applicato a Substring(start). Se la prima corrispondenza non riesce a convertire TryStr2Int, i numeri successivi non vengono cercati. La parte frazionaria, come .5, non è inclusa nel token numerico.
return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.ScanInt("-7 0xFF", 3));
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Un inizio negativo diventa 0, un inizio oltre la fine della riga diventa text.Length e il risultato è 0. La linea originale non cambia.
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 text = "count=0x20";
        var amount = UO.ScanInt(text, 6);
        UO.Print(amount);
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

UO.ScanInt(textValue, startValue) — UO.ScanInt(Any,Any)

Parametri: textValue (Any), startValue (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int ScanInt(InjectionValue textValue, InjectionValue startValue)

        {

            string text = textValue.ToString() ?? string.Empty;

            int start = Math.Max(0, Math.Min(text.Length, NumberConversions.ToInt(startValue)));

            Match match = Regex.Match(text.Substring(start), @"[-+]?(?:0[xX][0-9A-Fa-f]+|\d+)", RegexOptions.CultureInvariant);

            return match.Success && NumberConversions.TryStr2Int(match.Value, out int value) ? value : 0;

        }

UO.ShutdownWindows

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Firme C#

void UO.ShutdownWindows(object? state);

Rifiuta sempre un tentativo di arresto di Windows da uno script.

Parametri

  • state — L'argomento legacy è memorizzato nella firma, ma non viene utilizzato: qualsiasi chiamata viene bloccata.

Valore restituito

Non esiste un risultato normale: NativeSubrutineException con il messaggio "shutdownwindows è bloccato intenzionalmente: gli script potrebbero non arrestare Windows."

Comportamento

  • ExecuteLegacyManualAlias genera immediatamente un'eccezione. Non viene eseguito alcun arresto, riavvio o avvio di un processo esterno.
  • Tutti e tre gli esempi mostrano deliberatamente chiamate proibite e falliscono quando vengono eseguiti. Non possono essere utilizzati come condizione per un arresto corretto.

Script C# autonomi

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.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

try { UO.ShutdownWindows(0); }
catch (Exception error) { UO.Print(error.Message); }

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Rifiuta sempre un tentativo di arresto di Windows da uno script.
UO.ShutdownWindows(0);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • ExecuteLegacyManualAlias genera immediatamente un'eccezione. Non viene eseguito alcun arresto, riavvio o avvio di un processo esterno.
return  RunScenario();
 object? RunScenario()
{
    UO.ShutdownWindows(1);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Tutti e tre gli esempi mostrano deliberatamente chiamate proibite e falliscono quando vengono eseguiti. Non possono essere utilizzati come condizione per un arresto corretto.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.Print("The next command is expected to fail");
        UO.ShutdownWindows(0);
        return null;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

UO.ShutdownWindows(state) — UO.ShutdownWindows(Any)

Parametri: state (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "shutdownwindows":

                    throw new NativeSubrutineException("shutdownwindows is intentionally blocked: scripts may not shut down Windows.");

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally