[Devlog] Emulador de WarRock CP1

DO_READY_CLICK=0x32,
DO_MAP_CLICK=0x33,
DO_TYPE_CLICK=0x34,
DO_ROUND_CLICK=0x35,
DO_TIME_CLICK=0x36,
DO_KILL_CLICK=0x37,
DO_TEAM_CLICK=0x38,
DO_SCORE_CLICK=0x39,
DO_HOLD_CLICK=0x3A,
DO_PING_CLICK=0x3B,
DO_VOTERATE_CLICK=0x3C,
DO_VOTE_KICK=0x3D,
DO_AUTOSTART_CLICK=0x3E,
DO_AILEVEL_CLICK=0x3F,
DO_BRANCH_CLICK=0x64,
DO_HEALING_PLAYER=0x65,
DO_HEALING_UNIT=0x66,
DO_DAMAGED_PLAYER=0x67,
DO_DAMAGED_UNIT=0x68,
DO_RELOAD_PLAYER=0x69,
DO_PLAYER_REGEN=0x96,
DO_UNIT_REGEN=0x97,
DO_PLAYER_DIE=0x98,
DO_UNIT_DIE=0x99,
DO_PLAYER_DENY=0x9A,
DO_CHANGE_WEAPONS=0x9B,
DO_TOTALWAR=0xA5,
DO_SUMMON_UNIT=0xA6,
DO_REWARD_CHEAT=0xA7,
DO_COMBAT_SUPPORT=0xA8,
DO_SUMMON_COOLTIME=0xA9,
DO_CONQUEST_CAMP=0x9C,
DO_SUICIDE=0x9D,
DO_SUICIDE_UNIT=0x9E,
DO_FIRE_ARTILLERY=0x9F,
DO_ITEM_DROP=0x190,
DO_ITEM_PICKUP=0x191,
DO_OBJECT_RIDE=0xC8,
DO_OBJECT_CHANGE_SEAT=0xC9,
DO_OBJECT_ALIGHT=0xCA,
DO_OBJECT_NETSTART=0xCB,
DO_DUMMY_PACKET=0x12C,
DO_GO=0x193,
DO_CRASH_OBJECT=0x1F4,
DO_INVALID_BULLET=0x6B,
DO_ISHERO=0x2BC,
DO_HERO_SKILL=0x2BD,
DO_HERO_HEAL_SKILL=0x2BE,
DO_HACK_PREVENT=0x320,
DO_AI_DAMAGE_SP=0x384,
DO_AI_ITEM_DROP=0x385,
DO_AI_ITEM_PICKUP=0x386,
DO_AI_ITEM_DELETE=0x387,
DO_TRACE_GAS=0x388,
DO_RANDOM_ITEM_DROP=0x15E,
DO_RANDOM_ITEM_PICKUP=0x15F,
DO_INFECTION_SKILL=0x2BF

class ChangeMapHandler(GameProcessHandler):
    async def handle(self):
        if self.player.id != self.room.master_slot:  # This player is not the master
            # TODO: log this? Cheater?
            return

    if self.room.state != RoomStatus.WAITING:
        return

    new_map = int(self.get_block(2))
    this_room_mode = self.room.game_mode
    this_room_channel = self.room.channel.type

    # Is this a valid map?
    map_database = MapDatabase()

    is_active = map_database.get_map_status(map_id=new_map)
    available_channels = map_database.get_map_channels(map_id=new_map)
    available_modes = map_database.get_map_modes(map_id=new_map)

    # Map inactive or not available for this channel
    # TODO: some of this stuff may be cheating. Log it
    if not is_active or not available_channels[this_room_channel]:
        return

    # Map mode is invalid
    if not available_modes[this_room_mode]:
        return

    self.room.current_map = new_map

    self.update_lobby = True
    self.answer = True

class GameProcessHandler(abc.ABC):
    def __init__(self):

    self.packet = None
    self.error_code = 1
    self.lock = asyncio.Lock()

    # The subpacket ID as defined in the packet_list.py i.e. DO_READY_CLICK
    self.sub_packet = None
    # The player that the packet is aimed at
    self.player = None
    # Unused?
    self.room_slot = 0
    # Should we resend the packet?
    self.answer = False
    # Should we update the lobby
    self.update_lobby = False
    # If the user that triggered the packet also the target?
    self.self_target = False
    # Are we sending map data
    self.map_data = False
    # The full packet
    self.blocks = []

@abc.abstractmethod
async def handle(self):
    pass

def get_block(self, block_id: int) -> str:
    return self.blocks[block_id]

async def process(self, user: "User", in_packet: InPacket):
    # Basically we copy the full packet minus the first two blocks of ticks
    self.blocks = in_packet.blocks
    # bytearray(b'30398946 30000 0 1 2 53 1 0 4 0 0 0 0 0 0 0 \n')
    # TODO: Check if it's defined in the packet_list?
    if self.blocks[3].isdigit():
        self.sub_packet = int(self.blocks[3])
        self.packet = in_packet

        async with self.lock:
            # Get rid of the first bytes of the block since we are not touching them
            self.blocks = self.blocks[4:]
            self.room = user.room

            # Get the player instance of the user for the room
            self.player = user.room.players[user.room_slot]

            if self.player is None:
                logging.error(
                    f"Could not find player slot for {user.room_slot} at {self.room.id}"
                )
                return
            else:
                self.room_slot = self.player.id

                await self.handle()

                if self.answer:
                    if self.error_code == corerr.SUCCESS:
                        new_packet = []
                        new_packet.append(self.error_code)
                        new_packet.append(self.room_slot)
                        new_packet.append(self.room.id)
                        new_packet.append(
                            in_packet.blocks[2]
                        )  # 2 or 0 is the value
                        new_packet.append(self.sub_packet)

                        # Copy the rest of the packet as modified by the handlers
                        new_packet.extend(self.blocks)
                    else:
                        new_packet = [self.error_code]

                    # Build the actual packet
                    game_data_packet = PacketFactory.create_packet(
                        packet_id=PacketList.DO_GAME_PROCESS, blocks=new_packet
                    )
                    print(f"Final packet {game_data_packet.blocks}")
                    if self.error_code > corerr.SUCCESS or self.self_target:
                        await user.send(game_data_packet.build())
                    else:
                        await self.room.send(game_data_packet.build())

                    if self.map_data:
                        logging.info("Implement map data packet here")

                    if self.update_lobby:
                        channel_users = await user.this_server.channels[
                            user.channel
                        ].get_users()

                        room_update = PacketFactory.create_packet(
                            packet_id=PacketList.DO_ROOM_INFO_CHANGE,
                            room_to_update=self.room,
                            update_type=RoomUpdateType.UPDATE,
                        )
                        for chuser in channel_users:
                            if (
                                chuser.room is None
                                and chuser.room_page == self.room.room_page
                            ):
                                await chuser.send(room_update.build())
    else:
        logging.error(f"Unknown subpacket format {self.blocks[3]}, {self.blocks}")

def set_block(self, block_id: int, value: str) -> None:
    self.blocks[block_id] = value