[Devlog] Emulador de WarRock CP1

Aprovechando que refactorizo el game server, voy a comentar a grandes rasgos cómo va el tema de los paquetes. Ayer me preguntaron por otro sitio y me parece interesante, así que allá vamos.

En líneas generales, WarRock usa el puerto 5330 y 5340 para comunicarse por TCP con el servidor. Los paquetes están "cifrados" con una clave XOR que lleva años rota (el cómo lo puedo contar en otro post si hay interés) y tan solo hay que descrifar, sanear y responder. Un ejemplo simplón puede ser el login packet:

Si imprimimos a pelo el paquete tal cual llega cuando intentamos hacer login, recibimos esto:

b'\xf7\xf3\xf6\xfa\xfa\xf0\xf2\xf7\xe3\xf7\xf0\xf6\xf1\xe3\xf0\xf2\xf6\xf1\xf7\xf6\xf3\xf2\xf3\xf4\xe3\xf3\xe3\xa7\xa2\xb1\xa8\xb1\xa2\xb3\xb7\xac\xb1\xe3\xa7\xa2\xb1\xa8\xb1\xa2\xb3\xb7\xac\xb1\xe3\xf3\xe3\xf3\xe3\xc9'

La "b" es la forma que tiene Python de indicarme que estoy imprimiendo una cadena de caracteres que representa bytes, es decir, una cadena de bytes. El resto es el paquete tal cual.

Aunque yo ya conozco la clave XOR, quiero aclarar que es bastante fácil romperla si sabéis que el username y password que he puesto es darkraptor/darkraptor y de alguna manera, esta información le tiene que llegar al servidor. SURPRISE, una vez descifrado, veréis que está en texto plano.

Las claves XOR son estas:

class ClientXorKeys:
    SEND = 0x96
    RECEIVE = 0xC3

Importante: WarRock está programado en C#. Sabemos esto entre otras cosas porque cuando yo era un chavalín, pushearon los .pdb por error en un update y bueno xddd no es la primera vez que se ha filtrado algo del debug. ¿Por qué esto es importante? Porque para tomar muchas decisiones "por defecto", podemos limitarnos a pensar en cómo funcionaba el C# de aquella por defecto. ¿En qué unidades se expresa el tiempo en las librerías más comunes? ¿Con qué tipos mandarían los paquetes? Pista: casi todo es un ushort en el juego xd Puedes desbordar el cliente mandando valores suficientemente grandes en los paquetes jaja.

Para "descifrar" el paquete hacemos algo tal que así

    def xor_decrypt(self, packet_buffer: bytearray, xor_key: int) -> str:
        # Decrypt the bytes with the XORKey.
        this_buffer = bytearray(packet_buffer)
        for i in range(len(this_buffer)):
            this_buffer[i] = this_buffer[i] ^ xor_key

    # Return the decrypted packet
    decoded_buffer = this_buffer.decode("utf-8")
    return decoded_buffer

Y obtenemos algo como:

INFO:root:IN:: 40599314 4352 3152450107 0 darkraptor darkraptor 0 0 

El INFO:root:IN:: es mi logger, lo que sigue es el paquete, en bloques.

La estructura del paquete es tal que así:

1. Un encabezado de 2 bloques: los ticks del cliente y el id del paquete, en este caso 4352 o 0x1100 como lo veréis en muchas sources por ahí. Es básicamente lo mismo en hexadecimal.

2. Los datos per sé. En este caso el primer bloque lo ignoro para este paquete porque no está bien documentado qué es en el capítulo 1. Esto es bastante común al hacer emuladores, no sabemos de antemano qué es todo. Estoy seguro de que tengo algo en mi PC ppal pero como estoy de reformas en casa pues

Los dos siguientes bloques son el usuario y la contraseña y los dos últimos están vacíos en el primer login, pero sirven para reportar el Displayname (nickname) y el session id en los relogs. Esto lo se porque si respondemos al paquete y salimos y entramos del server, podemos ver cómo estos bloques cambian en función de lo que hemos añadido.

Ahora solo tenemos que montar la lógica para verificar si la información del cliente es verídica, si podemos creernos la conexión y en caso afirmativo responder con nuestro propio paquete. La lógica me la voy a saltar porque es bastante típica y la tenéis en el repo, pero un "OutPacket" es tal que así:

from wcps_core.constants import ErrorCodes as corerr
from wcps_core.packets import OutPacket

from wcps_auth.packets.packet_list import PacketList, ClientXorKeys

from wcps_auth.sessions import SessionManager
from wcps_auth.error_codes import ServerListError


class ServerList(OutPacket):
    def __init__(self, error_code: ServerListError, u=None):
        super().__init__(packet_id=PacketList.SERVER_LIST, xor_key=ClientXorKeys.SEND)
        if error_code != corerr.SUCCESS or not u:
            self.append(error_code)
        else:
            self.append(corerr.SUCCESS)
            self.append(1)  # ID
            self.append(0)  # unknown
            self.append(u.username)  # userid
            self.append(
                "NULL"
            )  # user PW. whatever is put here will be sent back if logged again
            self.append(u.displayname)
            self.append(u.session_id)  # current session ID
            self.append(
                0
            )  # unknown??? whatever is put here will be sent back if logged again
            self.append(0)  # unknown
            self.append(u.rights)  # rights
            self.append(
                1
            )  # Old servers say to append 1.11025 for PF20, but seems to be working atm.

        # get all authorized servers
        session_manager = SessionManager()
        all_servers_sessions = session_manager.get_all_authorized_servers()

        # The 2008 client can handle up to 31 servers
        self.append(len(all_servers_sessions))

        for session in all_servers_sessions:
            s = session["server"]  # Get the actual server
            self.append(s.id)  # Server ID
            self.append(s.name)
            self.append(s.address)
            self.append(s.port)
            # Current pop. Assumed to be x/3600. In the future, maybe
            # do fractions for servers with smaller capacity
            self.append(s.current_players)
            self.append(s.server_type)

        self.fill(-1, 4)  # ID?/NAME?/MASTER?/Unknown
        self.append(0)  # unknown
        self.append(0)  # unknown

Como podéis ver, todavía hay algunos bloques que no se lo que hacen, pero no me preocupa. Cuando recupere mi PC ppal puedo hacer algo de investigación al respecto, aunque no son críticos para para este cliente. Es importante recordar que en WarRock hay mucho contenido sin usar por el sistema de versiones que tenía.

Y para construir el paquete, la clase abstracta de la que derivan todos los paquetes del servidor a su vez implementa esta función:

    def build(self, encrypted: bool = True) -> bytearray | bytes:
        full_packet = " ".join(self.blocks)
        # End of packet character
        full_packet += chr(0xA)
        full_packet = full_packet.encode("utf-8")

    if encrypted:
        full_packet = self.xor_encrypt(packet=full_packet)

    return full_packet

Como podéis ver, hay que añadir algnos caracteres a pelo en el paquete, pero lo demás es bastante lógico. Ensamblar la cadena, pasarlo por el XOR de vuelta y enviar.

EDIT: DAOS CUENTA de que pongo "NULL" en el campo de password a mano porque si no el cliente se lo traga y almacena COMO UN CAMPEÓN y luego más tarde lo manda como parte de otro paquete. IMAGINAD la broma de ir mandando las contraseñas por ahí.

EDIT2: la forma de iterar en la función de descifrado es manifiestamente mejorable pero cuando la hice estaba empezando con Python y tenía todas las manías de otros idiomas. Prometo arreglarla en un futuro.

Como ya adelanté, después de un

He decidido que el próximo sistema que vamos a dejar implementado entero es la tienda de armas, que nos meterá en una madriguera de conejo larga pero divertida.

Motivos

1. Implementar los chats implica en cierto modo implementar las salas, ya que había varios tipos del mismo: lobby / room / clan / channel / whisper así de memoria.

2. Implementar las salas nos llevará a implementar los sistemas de la partida propiamente dichos y para eso necesitamos al menos el inventario y las armas funcionando.

3. Podríamos implementar los canales, realmente el paquete no devuelve mucho PERO internamente aprovechamos la señal del InPacket para mandar la lista de salas de ese canal y la lista de usuarios en ese canal (ahora mismo está "a mano"). Además el canal es un buen objeto para encargarse de enrutar las peticiones de chat a través de una referencia de usuarios en dicho canal.

¿Qué nos queda? La tienda. La tienda puede parece accesoria, pero pensad que:

1. Ya tenemos completo el paquete de bienvenida y eso implicaba tener un sistema de equipamiento e inventario básico capaz de convertir la info de la DB en las cadenas de texto que espera el paquete.

2. Nos llevará a desempaquetar del cliente la base de datos (un fichero) de armas, objetos y recursos y llevarlos ya al lado del servidor. Esto nos permitirá sanear el input que nos manda el usuario acerca de armas e items durante el resto del juego.

3. Interacciona con otros sistemas ya listos y podemos ver si lo hemos hecho bien: el premium y su fecha de expiración, el reloj del servidor, el propio sistema de inventario.

Plan de acción

Fijaos en este esquema lamentable hecho en Impress

Estos ficheros gobiernan prácticamente todas las definiciones de objetos del juego. ¿Cómo lo se? Porque como ya comenté, cuando hace un lustro monté el primer server, estaba muy metido en el mundillo del modding (COD4 sobre todo) y aunque no sabía mucho de programar, si sabía de lo otro. Gracias al servidor privado aproveché para entender cómo funcionaba el cliente de pé a pá e incluso metimos mapas y más armas (todo sin usar en el cliente) mi equipo y yo. Por lo tanto, se bastante bien con quién me juego los cuartos.

El primer "problema"

Como estoy de reforma y no tengo mis antiguas herramientas de cliente disponibles en el portátil, tendré que hacerlas de 0. Que TBQH no me viene mal. Esto implica que hay que desarrollar algo para desempaquetar los ficheros binarios.

Por ejemplo si yo abro items.bin a pelo

EBF6FAFADD8C9E83929AF7849283839E99908ADDDEEB819285849E9899E9DDDEDE919E9B9288819285849E9899F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7EADEE2DDDEEBF8819285849E9899E9DDDEEB8592849882859492E9DDDEDE98BEBBF7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7F7EADE96DDDEDE80B8B8B3

Salvo que F7 representa espacios en blanco, pues muy legible no parece. Hay que desempaquetarlo.

Paso 1: XOR

Por suerte no tengo que romper la clave XOR que usan estos ficheros para cifrar su contenido, ya que recuerdo que era 215 xd Pero sabed que es fácil sacarla por fuerza bruta ya que solo hay 255 valores posibles.

Me construyo un diccionario tal que así:

    def initialize_hex_table(self):
        for i in range(256):
            hex_key = f"{i:02X}"
            self.ht_decrypt_buffer[hex_key] = i ^ 215

1. Itero sobre todo los posibles valores de un byte que van de 0 a 255
2. Convierto el valor del byte en su representación hexadecimal de dos dígitos. Por ejemplo: 15 pasa a ser 0F si no recuerdo mal.
3. Aplico la clave XOR al byte y lo guardo en el diccionario, donde cada llave es el valor hexadecimal y cada valor, el resultado del XOR

Paso 2: descifrar

Creo otra función que use el diccionario ya generado para procesar el contenido del fichero y devolver los valores correctos.

def decrypt_content(self, hex_string):
        byte_array = bytearray(self.ht_decrypt_buffer[hex_string[i:i+2]] for i in range(0, len(hex_string), 2))
        try:
            return byte_array.decode('utf-8')
        except UnicodeDecodeError:
            print("ERROR: Decryption output cannot be decoded with UTF-8.")
            return None

1. Tomando como argumento una cadena hexadecimal completa, la procesamos en bloques de dos caracteres hexadecimales. Cada carácter va a ser un byte en hexadecimal.
2. Por cada pareja, miramos a qué valor corresponde en nuestro diccionario.
3. El resultado lo almacenamos en un array de bytes Es decir, al terminar tenemos un array de bytes con todos los valores en su equivalente XOR (o descifrado si lo preferís).

Finalmente, pasamos el array de bytes a su equivalente UTF8, es decir, que transforme estos valores en función de la tabla de equivalencia bytes - caracter de UTF8. La cadena que he puesto al principio pasa a ser:

<!--
[ITEM SETTING]
        <VERSION>
                FILE_VERSION                =   5
        </VERSION>
        <RESOURCE>
                Oil                             =       A
                Wood

Paso 3: consumir ficheros completos

Con todo esto, solo tengo que hacerme un pequeño script que consuma ficheros enteros y los decodifique:

import binascii
import os

class BinHandler:
    def __init__(self):
        self.ht_decrypt_buffer = {}
        self.lstb_output_buffer = []
        self.initialize_hex_table()

def initialize_hex_table(self):
    for i in range(256):
        hex_key = f"{i:02X}"
        self.ht_decrypt_buffer[hex_key] = i ^ 215

def decrypt_content(self, hex_string):
    byte_array = bytearray(self.ht_decrypt_buffer[hex_string[i:i+2]] for i in range(0, len(hex_string), 2))
    try:
        return byte_array.decode('utf-8')
    except UnicodeDecodeError:
        print("Warning: Decryption output cannot be decoded with UTF-8.")
        return byte_array.decode('latin1')  # Son caracteres coreanos CREO, que los ignore

def main():
    with open("items.bin", mode="r") as encrypted:
        encrypted_file = encrypted.read()
    

# Initialize BinHandler
handler = BinHandler()

# Decrypt content
try:
    decrypted_content = handler.decrypt_content(encrypted_file)
    print("Decrypted content: saved!")
    with open("items.bin.decoded", "w") as out:
        out.write(decrypted_content)
    
except Exception as e:
    print(f"Failed to read or parse the file. Error: {e}")

if __name__ == "__main__":
    main()

El script no es ninguna maravilla y lo tendré que retocar un poco para dejarlo como una aplicación de línea de comandos, pero lo importante es que ya puedo abrir los ficheros binarios y pensar si pasarlos todos a la base de datos (escogiendo lo que necesito) u otras ideas que tengo jeje.

Parte 2 coming soon

Bueno ahora que tengo algo más de tiempo y estoy menos hasta los coj**nes de parsear cadenas, explico la parte dos.

Lo primero, recordad que WarRock era casi todo client-side, pero sin embargo, justamente la acción de cambiar de arma va por paquete. Es decir, que no puedes cambiar de arma del inventario (aunque las haya inyectado) sin implementar también el paquete correspondiente. Y ya que hacemos las cosas, las hacemos bien ¿no?

En #22 ya comenté cómo descifrar los ficheros binarios que controlan muchos aspectos del sistema de armamento, vehículos, items y extras. Lo que han hecho otros desarrolladores es proceder a dumpear todo a una base de datos. En este caso, no quería hacerlo así por 2 motivos:

1. Mi experiencia previa con el cliente y estos servers es que el grueso de estos datos acaba cargándose 1 vez al principio del todo en el servidor y no se modifican. ¿Por qué? Porque tiene poco sentido hacerlo sin cambiar además los binarios del cliente y reconstruir el FCL. Para propagar esos cambios tienes que parar el server, crear un update y reiniciar. Más que tablas SQL con sus consultas, acaban siendo una enorme pila de datos que solo se leen y ocasionalmente alguien edita a mano.

2. El grueso de esta información es contenido "sin usar" en capítulo 1. Parte es rescatable y funcional (again, modificando cliente tb), parte es inútil. No hace falta añadir aún más carga al SQL con datos que solo se leen 1 vez y que encima muchos son innecesarios.

Paso 1: minar los datos de los binarios descifrados

Como para construir una tabla en base de datos siempre hay tiempo, sobre todo si partimos de ficheros estandar como JSON, CSV etc. me propuse lo siguiente: parsear lo que a mi criterio necesito de esos binarios y meterlos en un JSON del siglo 21 o incluso en un CSV. Adelanto ya que esto se lo he dejado a chatGPT. Sabiendo la estructura de los ficheros, es bastante fácil que haga algo potable y yo me ahorro trabajo.

Como podéis ver, un único fichero (items.bin) de 14k líneas tiene todas las armas, los extras, los "recursos", los accesorios para el personaje (que el CP1 ni siquiera tenía) y ya de paso los vehículos (EQUIPMENT) y su armamenteo (E_WEAPONS) por separado. ¿Por qué los vehículos se llaman Equipment? Pues ni puta idea.

De antemano, cosas que no necesito:

1. Los resources no tienen uso en los pservers. Que yo sepa.
2. Todo lo que hay en "character" es inútil porque en WarRock CP1 no había costumes ni nada de las puta mierda gachas que metieron luego.
3. Equipment y E_Weapons es el sistema de vehículos y hasta que no implementemos UO/BG no son necesarios.

Sabiendo esto, divido toda esa info en 3 tablas CSV:

1. items.csv -> Conservamos la información que nos dicta si el cliente considera el item "en activo", así como su código de ITEM (4 letras) y su tipo (resource/character/weapon/loquesea)

code,english,active,source
AA01,OIL,FALSE,RESOURCE
AB01,OAK,FALSE,RESOURCE
AC01,GRANITIC,FALSE,RESOURCE
AD01,IRON_ORE,FALSE,RESOURCE
AE01,COTTON,FALSE,RESOURCE
BA01,SUIT,FALSE,CHARACTER
BB02,SHIRT,FALSE,CHARACTER
BC01,PANTS,FALSE,CHARACTER
BD02,GLASSES,FALSE,CHARACTER

TODO ITEM está compuesto por un código de 4 letras que desgrano más abajo.

2. item_shop.csv Como su propio nombre indica, he extraido la info. que se que se usa en la tienda y tiene sentido tenerla en el servidor. Algunos aspectos son visuales (como la etiqueta de NEW!!!!) y no tiene sentido traerlos.

code,is_buyable,buy_type,buy_option,cost,required_bp,required_premium
AA01,FALSE,9,0,0,0,1
AB01,FALSE,9,0,0,0,1
AC01,FALSE,9,0,0,0,1
AD01,FALSE,9,0,0,0,1
AE01,FALSE,9,0,0,0,1
BA01,FALSE,9,0,0,0,1
BB02,FALSE,9,0,0,0,1
BC01,FALSE,9,0,0,0,1
BD02,FALSE,9,0,0,0,1

¿Qué son los BP? Battle points creo, no se usan pero no lo tengo 100% claro y me cuesta -1 sacarlo... El required_premium estoy al 75% seguro de haberlo parseado bien, pero me enteraré mejor cuando pueda acceder a mi PC ppal y a mis herramientas de cliente + notas.

Y por último, de las armas de fuego (no vehículos por ahora), sacamos los valores de daño, distancia y demás.

code,power,personal,surface,air,ship
DA01,400,"100,80,60","0,0,0","0,0,0","0,0,0"
DA02,200,"100,80,60","0,0,0","0,0,0","0,0,0"
DA03,400,"100,80,60","0,0,0","0,0,0","0,0,0"
DA04,400,"100,80,60","0,0,0","0,0,0","0,0,0"
DB01,320,"100,80,60","0,0,0","0,0,0","0,0,0"
DB02,520,"100,80,60","0,0,0","0,0,0","0,0,0"
DB03,290,"100,80,60","0,0,0","0,0,0","0,0,0"
DB04,520,"100,80,60","0,0,0","0,0,0","0,0,0"
DB05,280,"100,80,60","0,0,0","0,0,0","0,0,0"

La chasca como parábola, magazines etc. no tiene sentido sacarla porque el servidor no puede mandarle ningún paquete al cliente que sobrescriba esa info, sadly.

Paso 2: reconstruir el sistema de slots en el servidor

El grueso de los servidores privados que he visto tiene unas tablas server side enormes de 1s y 0s por cada arma, slot y clase para saber si puede o no usarse en este slot. En mi caso, voy a hacer algo más sencillo, pero tan o más funcional que lo que se suele hacer. Y sin base de datos.

El sistema de letras de WarRock

Bien, pues WarRock funciona con este complejísimo sistema para asignar a los items un código de 4 caracteres:

• La primera letra es una de [A-B-C-D-E-F] donde A es item de tipo recurso, B es de tipo character, C es de tipo EXTRA, D es un arma, E es un vehículo y F es un arma de vehículo/asiento de vehículo.

• La segunda letra la sacamos del mismo items.bin Al principio, hay una sección llamada item settings que la gente suele ignorar, pero contiene LAS FUCKING DEFINICIONES del item type o qué tipo de item representa cada código. Por ejemplo, para las armas:

<WEAPON>
		Dagger                          =	A
		Pistol                          =	B
		Rifle                           =	C
		Rifle2                          =	D
		Rifle3                          =	E
		SubmachineGun(SMG)              =	F
		Sniper                          =	G
		MachineGun                      =	H
		Shotgun                         =	I
		AntitankWeapon                  =	J
		Ground_to_AirWeapon             =	K
		AntitankMine                    =	L
		Grenade                         =	M
		Grenade_Combatant               =	N
		ExtraAmmo                       =	O
		Bomb                            =	P
		MedicKit                        =	Q
		Spanner                         =	R
		AllClass_Paid                   =	S
		MachineGun2                     =	T
		Engineer_Paid                   =	U
		Medic_Paid                      =	V
		AllClass                        =	W
		Scout_Paid                      =	X
		Comabatant_Paid                 =	Y
		HeavyWeapons_Paid               =	Z
	</WEAPON>

Por ejemplo un arma DC es un arma de tipo Rifle tal y como veis en el código de arriba. Los siguientes 2 caracteres son una numeración que va hasta el 99. DC01-DC02-DC03 etc.

Paso 3: armas permitidas por slot y clase

Toda esta chapa viene por mi rechazo a tener una tabla kilométrica de 1s y os que nos diga si un item se puede equipar en un slot o no. Si abrimos el segundo fichero .bin que señalé en el esquema de #25, branches.bin, veremos algo así:

<!--
	[ENGINEER]
		<BASIC INFO>
			BRANCH                      =		ENGINEER
			STR                         =		100
			STR RATE                    =		1.0
			CON                         =		90
			CON RATE                    =		0.9
			DEX                         =		95
			DEX RATE                    =		0.8
			STM                         =		100
			STM RATE                    =		1.1
			WIZ                         =		120
			WIZ RATE                    =		1.2
		</BASIC INFO>
		<SLOT INFO>
			0SLOT ITEM                   =		DA02
			0SLOT CODE                   =		A
			1SLOT ITEM                   =		DB01
			1SLOT CODE                   =		B
			2SLOT ITEM                   =		DF01
			2SLOT CODE                   =		D,F
			3SLOT ITEM                   =		DR01
			3SLOT CODE                   =		R
			4SLOT ITEM                   =		0
			4SLOT CODE                   =		D,I,M,O,F
			5SLOT ITEM                   =		0
			5SLOT CODE                   =		S,U,P
			6SLOT ITEM                   =		0
			6SLOT CODE                   =		0
			7SLOT ITEM                   =		0
			7SLOT CODE                   =		0
		</SLOT INFO>
		<PC_CAFE PREMIUM ITEM>
			PREMIUM ITEM                =		DF02
		</PC_CAFE PREMIUM ITEM>
	[/ENGINEER]

Los atributos rollo DnD no se usan, así que los podéis ignorar. Pero la segunda parte nos dice exactamente qué tipo de arma (DC, DG DE etc.) puede ir en cada slot de cada clase y además nos dice el arma por defecto de ese slot. Son 8 slots, del 0 al 7.

Paso 4: Llevármelo todo al servidor

Ahora que ya tengo toda la info delante, es "fácil": puedo convertir todas las relaciones clase-slot-letra en un diccionario constante tal que así:

BranchSlotCodes = {
        Classes.ENGINEER: {
            0: [WeaponTypes.DAGGER],
            1: [WeaponTypes.PISTOL],
            2: [WeaponTypes.RIFLE2, WeaponTypes.SMG],
            3: [WeaponTypes.SPANNER],
            4: [WeaponTypes.RIFLE2, WeaponTypes.SHOTGUN, WeaponTypes.GRENADE, WeaponTypes.EXTRA_AMMO, WeaponTypes.SMG],
            5: [WeaponTypes.ALLCLASS_PAID, WeaponTypes.ENGINEER_PAID, WeaponTypes.BOMB],
            6: [],
            7: []
        },
        Classes.MEDIC: {
            0: [WeaponTypes.DAGGER],
            1: [WeaponTypes.PISTOL],
            2: [WeaponTypes.RIFLE2, WeaponTypes.SMG],
            3: [WeaponTypes.MEDIC_KIT],
            4: [WeaponTypes.RIFLE2, WeaponTypes.SHOTGUN, WeaponTypes.GRENADE, WeaponTypes.EXTRA_AMMO, WeaponTypes.SMG],
            5: [WeaponTypes.ALLCLASS_PAID, WeaponTypes.MEDIC_PAID],
            6: [],
            7: []
        },
        Classes.SNIPER: {
            0: [WeaponTypes.DAGGER],
            1: [WeaponTypes.PISTOL],
            2: [WeaponTypes.SNIPER],
            3: [WeaponTypes.GRENADE_COMBATANT],
            4: [WeaponTypes.EXTRA_AMMO],
            5: [WeaponTypes.ALLCLASS_PAID, WeaponTypes.SCOUT_PAID],
            6: [],
            7: []
        },
        Classes.ASSAULT: {
            0: [WeaponTypes.DAGGER],
            1: [WeaponTypes.PISTOL],
            2: [WeaponTypes.RIFLE, WeaponTypes.RIFLE2, WeaponTypes.RIFLE3],
            3: [WeaponTypes.GRENADE_COMBATANT],
            4: [WeaponTypes.RIFLE, WeaponTypes.RIFLE2, WeaponTypes.RIFLE3, WeaponTypes.MACHINE_GUN, WeaponTypes.SHOTGUN, WeaponTypes.EXTRA_AMMO],
            5: [WeaponTypes.ALLCLASS_PAID, WeaponTypes.COMBATANT_PAID],
            6: [],
            7: []
        },
        Classes.HEAVY: {
            0: [WeaponTypes.DAGGER],
            1: [WeaponTypes.PISTOL],
            2: [WeaponTypes.ANTITANK_WEAPON, WeaponTypes.GROUND_TO_AIR_WEAPON],
            3: [WeaponTypes.ANTITANK_MINE],
            4: [WeaponTypes.ANTITANK_WEAPON, WeaponTypes.GROUND_TO_AIR_WEAPON, WeaponTypes.GRENADE, WeaponTypes.EXTRA_AMMO, WeaponTypes.MACHINE_GUN2],
            5: [WeaponTypes.ALLCLASS_PAID, WeaponTypes.HEAVY_WEAPONS_PAID],
            6: [],
            7: []
        }
}

Y mis tablas .CSV cargarlas en el servidor como una especie de singleton al igual que una configuración cualquiera. Consigo lo mismo pero con menor complejidad (no tengo que escribir más queries) y además soy muy fan de pandas para leer tablas así que :shrug:

Paso 5: Implementar el cambio de arma

Como ya os adelanté, mi forma de hacer las cosas es quizás menos emocionante (no vamos a ver tiros pronto) pero me permite ir haciendo bola de nieve conforme las dependencias de funcionalidad se van resolviendo. Como ya completé el primer paquete incluyendo el inventario, extenderlo para cambiar de arma no era difícil.

Así que cuando el cliente me manda esto:

        # 31184385 29970 0 3 D 2 DC02 2

yo primero lo saneo así

class EquipmentHandler(PacketHandler):
    async def process(self, u: "User") -> None:
        # 31184385 29970 0 3 D 2 DC02 2

    # Determine if the item is being equipped or unequipped
    is_item_equip = not bool(int(self.get_block(0)))
    target_branch = int(self.get_block(1))
    alt_target_slot = int(self.get_block(3))
    weapon_code = self.get_block(4)
    target_slot = int(self.get_block(5))

    item_database = ItemDatabase()

    if not u.authorized:
        return

    if target_slot >= MAX_WEAPONS_SLOTS:
        return

    if target_branch >= MAX_CLASSES:
        await u.disconnect()
        return

    if len(weapon_code) != 4:
        return

    if not item_database.item_exists(code=weapon_code):
        return  # Item does not exist

    # Let admins use inactive items
    if not item_database.is_active(weapon_code) and u.rights <= 3:
        await u.disconnect()  # Potential cheater. Log?

    if not u.inventory.has_item(weapon_code) and weapon_code not in DefaultWeapon.DEFAULTS:
        await u.disconnect()  # Potential cheater/scripter. Log?

    # Check if the item is already equipped in the target branch
    equipped_in_slot = u.inventory.equipment.is_equipped_in_class(
        target_class=target_branch, weapon=weapon_code
    )

    if not is_item_equip:  # Unequipping the item
        if equipped_in_slot >= 0:
            u.inventory.equipment.remove_item_from_slot(
                target_class=target_branch,
                target_slot=alt_target_slot
            )

            unequip_packet = PacketFactory.create_packet(
                packet_id=PacketList.EQUIPMENT,
                error_code=1,
                target_class=target_branch,
                new_loadout=u.inventory.equipment.loadout[target_branch]
            )
            await u.send(unequip_packet.build())
            return

    if equipped_in_slot >= 0:
        # Item is already equipped
        already_equipped_packet = PacketFactory.create_packet(
            packet_id=PacketList.EQUIPMENT,
            error_code=EquipmentError.ALREADY_EQUIPPED
        )
        await u.send(already_equipped_packet.build())
        return

    # Final check: Can the weapon be placed in the target slot?
    valid_codes_for_slot = BranchSlotCodes[target_branch][target_slot]
    weapon_subtype = weapon_code[1]

    if weapon_subtype in valid_codes_for_slot:
        # Perform the actual equipment
        u.inventory.equipment.add_item_to_slot(
            target_class=target_branch,
            target_slot=target_slot,
            item_code=weapon_code
        )

        equip_packet = PacketFactory.create_packet(
            packet_id=PacketList.EQUIPMENT,
            error_code=1,
            target_class=target_branch,
            new_loadout=u.inventory.equipment.loadout[target_branch]
        )
        await u.send(equip_packet.build())
    else:
        # Weapon cannot be placed in the target slot
        unsuitable_packet = PacketFactory.create_packet(
            packet_id=PacketList.EQUIPMENT,
            error_code=EquipmentError.INVALID_BRANCH
        )
        await u.send(unsuitable_packet.build())

Y mando el paquete correspondiente, luego de reconstruir el inventario.

Próximos pasos

Tenemos ya un sistema de inventario y un sistema para controlar y sanear el equipamiento. Tenemos el reloj y el premium funcionando. Tenemos los datos del cliente que nos dicen cuánto costaban las armas y sus requisitos.... Pues obviamente vamos a por la tienda.

Perdón por el tocho xd

#27
Se tarda casi más en explicarlo que en hacerlo. Es una parte del emulador bastante árida salvo que te guste entender cómo funciona el cliente internamente, por lo que hay pocas imágenes y más texto. Lo bueno es que hoy debería poder rematar la tienda entera sin mucho problema y eso motiva bastante porque es muy visual y cualquiera que haya jugado a este juego ha pasado por la tienda miles de veces.

Cuando me ponga con la creación de salas y paquetes de juego si se va a poner la cosa bonita. Se juntan aspectos técnicos como rematar el UDP (o los jugadores no se ven) o mandar paquetes entre lobby/sala/jugadores con otros más visuales como reprogramar los modos de juego o rehacer el cálculo del daño de cada arma. La mayoría de los paquetes "de juego" realmente son el mismo paquete id (30000) donde el cambio de un byte (posición 4) determina qué significan los bytes del fondo y ni yo me acuerdo bien de todos jeje