[PS2][MAIN.SCM] NanoPatcher v0.1

20 Jan 2020, 17:21

Depois de ver o tutorial de scripting no PS2, você começa a escrever seus próprios códigos e/ou portá-los do PC, e depois de algum tempo, começa a adquirir mais experiência e procura criar coisas mais complexas, e isso seria muito bom, se o PS2 não fosse extremamente limitado por não ter uma CLEO, manipulação de memória se torna algo quase impossível, e os outros opcodes então, nem se fala.

Quase impossível? Sim. Quase.

Pensando nisso, eu criei esse pequeno "Patcher", a partir de hacks com variáveis, que são conhecidos antes mesmo da existência da famosa biblioteca CLEO, que abrem um pouco mais os horizontes do modding de PS2, apesar das limitações...

Obs.: As funções WriteMemory e ReadMemory só trabalham com read/write em 4 bytes, o que torna impossível a leitura de booleans e coisas do tipo.

Funções:

write_memory
read_memory
call_function
disable_call

write_memory:

Um pouco óbvio, funciona de maneira semelhante ao opcode write_memory da CLEO.

Uso:

Código: Selecionar tudo

memoryAddress = 0x2B0154 //Endereço a ser alterado
memoryValue = 0x00000000 //Valor a ser colocado
gosub @WriteMemory

read_memory:

Memsma coisa, funcionamento semelhante ao read_memory da CLEO.

Uso:

Código: Selecionar tudo

memoryAddress = 0x2B0154 //Endereço a ser lido
memoryValue = 2@ //Variável que armazenará o valor lido
gosub @ReadMemory

call_function:

Chama uma função.
(explicação melhor: cria um call para a função especificada
no CGame::Process, fazendo com que seja chamada sempre).

Uso:

Código: Selecionar tudo

memoryValue = 0x0C0AAEC0 //Call compilada (jal $002ABB00)
gosub @CallFunction

disable_call:

Desativa a função chamada.
(explicação melhor: Põe um nope onde a call para a função foi criada).

Uso:

Código: Selecionar tudo

gosub @DisableCall

Exemplo práticoAbrir

Código: Selecionar tudo

:script_start
0000: NOP
03A4: name_thread 'TESTE'
{$I CLEO\includes\npatcher_const.txt}

// Desativa a função de mostrar os stats do personagem ao apertar L1
memoryAddress = 0x2B0154
memoryValue = 0x00000000
gosub @WriteMemory

:main_loop

if 00E1:   player 0 pressed_key 10
    jf @disable_call
    memoryValue = 0x0C0AAEC0
    gosub @CallFunction
// Chama a função ao apertar o botão D-Pad Esquerdo, mudando o botão de ativação

goto @main_loop

:disable_call
gosub @DisableCall
goto @main_loop
//Desativa a função chamada, caso o botão não esteja sendo pressionado]


{$I CLEO\includes\npatcher.txt}[spoiler][/spoiler]

DOWNLOAD

Como instalar: Extraia a pasta includes para a pasta CLEO do seu GTA San Andreas de PC.

Autor: Daniel69

20 Jan 2020, 20:10

Para separar um conjunto de bytes pode-se usar multiplicação e divisão.

Para separar apenas 8 bits (1 byte) caso queira ler um boolean ou algo assim:

Código: Selecionar tudo

valor *= 0x1000000
valor /= 0x1000000

O número 0x1000000 é 2 elevado a 24, como 4 bytes são 32 bits, 32 - 24 = 8.
0b1000000000000000000000000

O que acontece é que o número ganha um shift left quando é feita a multiplicação e então um shift right quando é feita a divisão, o resto do número que não couber no espaço da variável "desaparece".

Talvez seja necessário considerar little endian e big endian. Pode ser que seja necessário apenas a divisão.

Código: Selecionar tudo

valor /= 0x1000000

21 Jan 2020, 17:34

Código: Selecionar tudo

:ReadMemory1Byte
memoryAddress -= 0x6B1FF0
memoryAddress /= 4
008B: memoryValue = &0(memoryAddress,1i)
memoryValue *= 0x1000000
memoryValue /= 0x1000000
return

Código: Selecionar tudo

:ReadMemory2Bytes
memoryAddress -= 0x6B1FF0
memoryAddress /= 4
008B: memoryValue = &0(memoryAddress,1i)
memoryValue *= 0x10000
memoryValue /= 0x10000
return

?
Mas WriteMemory realmente não tem como né.

21 Jan 2020, 20:24

Junior_Djjr escreveu: ↑

21 Jan 2020, 17:34

Código: Selecionar tudo

:ReadMemory1Byte
memoryAddress -= 0x6B1FF0
memoryAddress /= 4
008B: memoryValue = &0(memoryAddress,1i)
memoryValue *= 0x1000000
memoryValue /= 0x1000000
return

Código: Selecionar tudo

:ReadMemory2Bytes
memoryAddress -= 0x6B1FF0
memoryAddress /= 4
008B: memoryValue = &0(memoryAddress,1i)
memoryValue *= 0x10000
memoryValue /= 0x10000
return

?
Mas WriteMemory realmente não tem como né.

Só se lesse primeiro, substituísse o byte e então escrevesse novamente... (lê, separa o valor que já está na variável, usa subtração no valor inteiro e então soma com o valor que queria escrever, algo próximo a isso)

Eu estou em dúvida se a multiplicação será necessária, mas tem que ver se MIPS é little endian ou big endian

21 Jan 2020, 21:09

Fabio escreveu: ↑
21 Jan 2020, 20:24
Junior_Djjr escreveu: ↑
21 Jan 2020, 17:34
Código: Selecionar tudo
:ReadMemory1Byte
memoryAddress -= 0x6B1FF0
memoryAddress /= 4
008B: memoryValue = &0(memoryAddress,1i)
memoryValue *= 0x1000000
memoryValue /= 0x1000000
return
Código: Selecionar tudo
:ReadMemory2Bytes
memoryAddress -= 0x6B1FF0
memoryAddress /= 4
008B: memoryValue = &0(memoryAddress,1i)
memoryValue *= 0x10000
memoryValue /= 0x10000
return
?
Mas WriteMemory realmente não tem como né.
Só se lesse primeiro, substituísse o byte e então escrevesse novamente... (lê, separa o valor que já está na variável, usa subtração no valor inteiro e então soma com o valor que queria escrever, algo próximo a isso)

Eu estou em dúvida se a multiplicação será necessária, mas tem que ver se MIPS é little endian ou big endian

É little endian

22 Jan 2020, 01:56

Fabio escreveu: ↑
21 Jan 2020, 20:24
Só se lesse primeiro, substituísse o byte e então escrevesse novamente... (lê, separa o valor que já está na variável, usa subtração no valor inteiro e então soma com o valor que queria escrever, algo próximo a isso)

Esse é o problema, como separar o valor que está na variável?
Tem que dar um jeito de acessar o valor da variável (criar um get var offset/pointer improvisado), daí na função faz um vai e vem do valor da variável para alterar somente os bytes necessários.

22 Jan 2020, 15:14

Daniel69 escreveu: ↑
21 Jan 2020, 21:09
Fabio escreveu: ↑
21 Jan 2020, 20:24
Junior_Djjr escreveu: ↑
21 Jan 2020, 17:34
Código: Selecionar tudo
:ReadMemory1Byte
memoryAddress -= 0x6B1FF0
memoryAddress /= 4
008B: memoryValue = &0(memoryAddress,1i)
memoryValue *= 0x1000000
memoryValue /= 0x1000000
return
Código: Selecionar tudo
:ReadMemory2Bytes
memoryAddress -= 0x6B1FF0
memoryAddress /= 4
008B: memoryValue = &0(memoryAddress,1i)
memoryValue *= 0x10000
memoryValue /= 0x10000
return
?
Mas WriteMemory realmente não tem como né.
Só se lesse primeiro, substituísse o byte e então escrevesse novamente... (lê, separa o valor que já está na variável, usa subtração no valor inteiro e então soma com o valor que queria escrever, algo próximo a isso)

Eu estou em dúvida se a multiplicação será necessária, mas tem que ver se MIPS é little endian ou big endian
É little endian

Então acredito que precisará apenas da divisão (dependendo da posição que mandar ser lida)

Junior_Djjr escreveu: ↑
22 Jan 2020, 01:56
Fabio escreveu: ↑
21 Jan 2020, 20:24
Só se lesse primeiro, substituísse o byte e então escrevesse novamente... (lê, separa o valor que já está na variável, usa subtração no valor inteiro e então soma com o valor que queria escrever, algo próximo a isso)
Esse é o problema, como separar o valor que está na variável?
Tem que dar um jeito de acessar o valor da variável (criar um get var offset/pointer improvisado), daí na função faz um vai e vem do valor da variável para alterar somente os bytes necessários.

Somando e multiplicando mesmo pra fazer shift left e shift right e ficar apenas o valor desejado com 00 ao redor.

Forum.MixMods

[PS2][MAIN.SCM] NanoPatcher v0.1

[PS2][MAIN.SCM] NanoPatcher v0.1

Re: [PS2][MAIN.SCM] NanoPatcher v0.1

Re: [PS2][MAIN.SCM] NanoPatcher v0.1

Re: [PS2][MAIN.SCM] NanoPatcher v0.1

Re: [PS2][MAIN.SCM] NanoPatcher v0.1

Re: [PS2][MAIN.SCM] NanoPatcher v0.1

Re: [PS2][MAIN.SCM] NanoPatcher v0.1