map

EO map file data structures.

See Also

• eolib.protocol._generated.map

MapWarp

Warp EMF entity

Source code in src/eolib/protocol/_generated/map/map_warp.py

class MapWarp:
    """
    Warp EMF entity
    """
    _byte_size: int = 0
    _destination_map: int
    _destination_coords: Coords
    _level_required: int
    _door: int

    def __init__(self, *, destination_map: int, destination_coords: Coords, level_required: int, door: int):
        """
        Create a new instance of MapWarp.

        Args:
            destination_map (int): (Value range is 0-64008.)
            destination_coords (Coords): 
            level_required (int): (Value range is 0-252.)
            door (int): (Value range is 0-64008.)
        """
        self._destination_map = destination_map
        self._destination_coords = destination_coords
        self._level_required = level_required
        self._door = door

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def destination_map(self) -> int:
        return self._destination_map

    @property
    def destination_coords(self) -> Coords:
        return self._destination_coords

    @property
    def level_required(self) -> int:
        return self._level_required

    @property
    def door(self) -> int:
        return self._door

    @staticmethod
    def serialize(writer: EoWriter, data: "MapWarp") -> None:
        """
        Serializes an instance of `MapWarp` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapWarp): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._destination_map is None:
                raise SerializationError("destination_map must be provided.")
            writer.add_short(data._destination_map)
            if data._destination_coords is None:
                raise SerializationError("destination_coords must be provided.")
            Coords.serialize(writer, data._destination_coords)
            if data._level_required is None:
                raise SerializationError("level_required must be provided.")
            writer.add_char(data._level_required)
            if data._door is None:
                raise SerializationError("door must be provided.")
            writer.add_short(data._door)
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapWarp":
        """
        Deserializes an instance of `MapWarp` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapWarp: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            destination_map = reader.get_short()
            destination_coords = Coords.deserialize(reader)
            level_required = reader.get_char()
            door = reader.get_short()
            result = MapWarp(destination_map=destination_map, destination_coords=destination_coords, level_required=level_required, door=door)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapWarp(byte_size={repr(self._byte_size)}, destination_map={repr(self._destination_map)}, destination_coords={repr(self._destination_coords)}, level_required={repr(self._level_required)}, door={repr(self._door)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

destination_map: int property

destination_coords: Coords property

level_required: int property

door: int property

__init__(*, destination_map, destination_coords, level_required, door)

Create a new instance of MapWarp.

Parameters:

Name	Type	Description	Default
destination_map	int	(Value range is 0-64008.)	required
destination_coords	Coords		required
level_required	int	(Value range is 0-252.)	required
door	int	(Value range is 0-64008.)	required

Source code in src/eolib/protocol/_generated/map/map_warp.py

def __init__(self, *, destination_map: int, destination_coords: Coords, level_required: int, door: int):
    """
    Create a new instance of MapWarp.

    Args:
        destination_map (int): (Value range is 0-64008.)
        destination_coords (Coords): 
        level_required (int): (Value range is 0-252.)
        door (int): (Value range is 0-64008.)
    """
    self._destination_map = destination_map
    self._destination_coords = destination_coords
    self._level_required = level_required
    self._door = door

serialize(writer, data) staticmethod

Serializes an instance of MapWarp to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapWarp	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_warp.py

@staticmethod
def serialize(writer: EoWriter, data: "MapWarp") -> None:
    """
    Serializes an instance of `MapWarp` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapWarp): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._destination_map is None:
            raise SerializationError("destination_map must be provided.")
        writer.add_short(data._destination_map)
        if data._destination_coords is None:
            raise SerializationError("destination_coords must be provided.")
        Coords.serialize(writer, data._destination_coords)
        if data._level_required is None:
            raise SerializationError("level_required must be provided.")
        writer.add_char(data._level_required)
        if data._door is None:
            raise SerializationError("door must be provided.")
        writer.add_short(data._door)
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapWarp from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapWarp	MapWarp	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_warp.py

@staticmethod
def deserialize(reader: EoReader) -> "MapWarp":
    """
    Deserializes an instance of `MapWarp` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapWarp: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        destination_map = reader.get_short()
        destination_coords = Coords.deserialize(reader)
        level_required = reader.get_char()
        door = reader.get_short()
        result = MapWarp(destination_map=destination_map, destination_coords=destination_coords, level_required=level_required, door=door)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

SerializationError

Bases: Exception

Represents an error in serializing a protocol data structure.

Source code in src/eolib/protocol/serialization_error.py

class SerializationError(Exception):
    """
    Represents an error in serializing a protocol data structure.
    """

    def __init__(self, message: str):
        """
        Constructs a SerializationError with the specified error message.

        Args:
            message (str): The error message.
        """
        super().__init__(message)

__init__(message)

Constructs a SerializationError with the specified error message.

Parameters:

Name	Type	Description	Default
message	str	The error message.	required

Source code in src/eolib/protocol/serialization_error.py

def __init__(self, message: str):
    """
    Constructs a SerializationError with the specified error message.

    Args:
        message (str): The error message.
    """
    super().__init__(message)

EoWriter

Source code in src/eolib/data/eo_writer.py

class EoWriter:
    def __init__(self):
        self.data = bytearray()
        self._string_sanitization_mode = False

    def add_byte(self, value: int) -> None:
        """
        Adds a raw byte to the writer data.

        Args:
            value (int): The byte to add.

        Raises:
            ValueError: If the value is above `0xFF`.
        """
        self._check_number_size(value, 0xFF)
        self.data.append(value)

    def add_bytes(self, bytes: bytes) -> None:
        """
        Adds raw bytes to the writer data.

        Args:
            bytes (bytes): The bytes to add.
        """
        self.data.extend(bytes)

    def add_char(self, number: int) -> None:
        """
        Adds an encoded 1-byte integer to the writer data.

        Args:
            number (int): The number to encode and add.

        Raises:
            ValueError: If the value is not below `CHAR_MAX`.
        """
        self._check_number_size(number, CHAR_MAX - 1)
        number_bytes = encode_number(number)
        self._add_bytes_with_length(number_bytes, 1)

    def add_short(self, number: int) -> None:
        """
        Adds an encoded 2-byte integer to the writer data.

        Args:
            number (int): The number to encode and add.

        Raises:
            ValueError: If the value is not below `SHORT_MAX`.
        """
        self._check_number_size(number, SHORT_MAX - 1)
        number_bytes = encode_number(number)
        self._add_bytes_with_length(number_bytes, 2)

    def add_three(self, number: int) -> None:
        """
        Adds an encoded 3-byte integer to the writer data.

        Args:
            number (int): The number to encode and add.

        Raises:
            ValueError: If the value is not below `THREE_MAX`.
        """
        self._check_number_size(number, THREE_MAX - 1)
        number_bytes = encode_number(number)
        self._add_bytes_with_length(number_bytes, 3)

    def add_int(self, number: int) -> None:
        """
        Adds an encoded 4-byte integer to the writer data.

        Args:
            number (int): The number to encode and add.

        Raises:
            ValueError: If the value is not below `INT_MAX`.
        """
        self._check_number_size(number, INT_MAX - 1)
        number_bytes = encode_number(number)
        self._add_bytes_with_length(number_bytes, 4)

    def add_string(self, string: str) -> None:
        """
        Adds a string to the writer data.

        Args:
            string (str): The string to be added.
        """
        string_bytes = self._encode_ansi(string)
        self._sanitize_string(string_bytes)
        self.add_bytes(string_bytes)

    def add_fixed_string(self, string: str, length: int, padded: bool = False) -> None:
        """
        Adds a fixed-length string to the writer data.

        Args:
            string (str): The string to be added.
            length (int): The expected length of the string.
            padded (bool, optional): True if the string should be padded to the length with
                trailing `0xFF` bytes. Defaults to False.
        """
        self._check_string_length(string, length, padded)
        string_bytes = self._encode_ansi(string)
        self._sanitize_string(string_bytes)
        if padded:
            string_bytes = self._add_padding(string_bytes, length)
        self.add_bytes(string_bytes)

    def add_encoded_string(self, string: str) -> None:
        """
        Adds an encoded string to the writer data.

        Args:
            string (str): The string to be encoded and added.
        """
        string_bytes = self._encode_ansi(string)
        self._sanitize_string(string_bytes)
        encode_string(string_bytes)
        self.add_bytes(string_bytes)

    def add_fixed_encoded_string(self, string: str, length: int, padded: bool = False) -> None:
        """
        Adds a fixed-length encoded string to the writer data.

        Args:
            string (str): The string to be encoded and added.
            length (int): The expected length of the string.
            padded (bool, optional): True if the string should be padded to the length with
                trailing `0xFF` bytes. Defaults to False.
        """
        self._check_string_length(string, length, padded)
        string_bytes = self._encode_ansi(string)
        self._sanitize_string(string_bytes)
        if padded:
            string_bytes = self._add_padding(string_bytes, length)
        encode_string(string_bytes)
        self.add_bytes(string_bytes)

    @property
    def string_sanitization_mode(self) -> bool:
        """
        Gets the string sanitization mode for the writer.

        Returns:
            bool: True if string sanitization is enabled.
        """
        return self._string_sanitization_mode

    @string_sanitization_mode.setter
    def string_sanitization_mode(self, string_sanitization_mode: bool) -> None:
        self._string_sanitization_mode = string_sanitization_mode

    def to_bytearray(self) -> bytearray:
        """
        Gets the writer data as a byte array.

        Returns:
            bytearray: A copy of the writer data as a byte array.
        """
        return self.data.copy()

    def __len__(self) -> int:
        """
        Gets the length of the writer data.

        Returns:
            int: The length of the writer data.
        """
        return len(self.data)

    def _add_bytes_with_length(self, bytes: bytes, bytes_length: int) -> None:
        """
        Adds raw bytes with a specified length to the writer data.

        Args:
            bytes (bytes): The bytes to add.
            bytes_length (int): The number of bytes to add.
        """
        self.data.extend(bytes[:bytes_length])

    def _sanitize_string(self, bytes: bytearray) -> None:
        if self.string_sanitization_mode:
            for i in range(len(bytes)):
                if bytes[i] == 0xFF:  # 'ÿ'
                    bytes[i] = 0x79  # 'y'

    @staticmethod
    def _check_number_size(number: int, max_value: int) -> None:
        if number > max_value:
            raise ValueError(f"Value {number} exceeds maximum of {max_value}.")

    @staticmethod
    def _add_padding(bytes: bytearray, length: int) -> bytearray:
        if len(bytes) == length:
            return bytes

        result = bytearray(length)
        result[: len(bytes)] = bytes
        result[len(bytes) :] = bytearray([0xFF] * (length - len(bytes)))

        return result

    @staticmethod
    def _check_string_length(string: str, length: int, padded: bool) -> None:
        if padded:
            if length >= len(string):
                return
            raise ValueError(f'Padded string "{string}" is too large for a length of {length}.')

        if len(string) != length:
            raise ValueError(f'String "{string}" does not have expected length of {length}.')

    @staticmethod
    def _encode_ansi(string: str) -> bytearray:
        """
        Encodes string to windows-1252 bytes.

        Args:
            string (str): The string to encode.

        Returns:
            bytearray: The encoded string.
        """
        return bytearray(string, 'windows-1252', 'replace')

data = bytearray() instance-attribute

string_sanitization_mode: bool property writable

Gets the string sanitization mode for the writer.

Returns:

Name	Type	Description
bool	bool	True if string sanitization is enabled.

__init__()

Source code in src/eolib/data/eo_writer.py

def __init__(self):
    self.data = bytearray()
    self._string_sanitization_mode = False

add_byte(value)

Adds a raw byte to the writer data.

Parameters:

Name	Type	Description	Default
value	int	The byte to add.	required

Raises:

Type	Description
ValueError	If the value is above 0xFF.

Source code in src/eolib/data/eo_writer.py

def add_byte(self, value: int) -> None:
    """
    Adds a raw byte to the writer data.

    Args:
        value (int): The byte to add.

    Raises:
        ValueError: If the value is above `0xFF`.
    """
    self._check_number_size(value, 0xFF)
    self.data.append(value)

add_bytes(bytes)

Adds raw bytes to the writer data.

Parameters:

Name	Type	Description	Default
bytes	bytes	The bytes to add.	required

Source code in src/eolib/data/eo_writer.py

def add_bytes(self, bytes: bytes) -> None:
    """
    Adds raw bytes to the writer data.

    Args:
        bytes (bytes): The bytes to add.
    """
    self.data.extend(bytes)

add_char(number)

Adds an encoded 1-byte integer to the writer data.

Parameters:

Name	Type	Description	Default
number	int	The number to encode and add.	required

Raises:

Type	Description
ValueError	If the value is not below CHAR_MAX.

Source code in src/eolib/data/eo_writer.py

def add_char(self, number: int) -> None:
    """
    Adds an encoded 1-byte integer to the writer data.

    Args:
        number (int): The number to encode and add.

    Raises:
        ValueError: If the value is not below `CHAR_MAX`.
    """
    self._check_number_size(number, CHAR_MAX - 1)
    number_bytes = encode_number(number)
    self._add_bytes_with_length(number_bytes, 1)

add_short(number)

Adds an encoded 2-byte integer to the writer data.

Parameters:

Name	Type	Description	Default
number	int	The number to encode and add.	required

Raises:

Type	Description
ValueError	If the value is not below SHORT_MAX.

Source code in src/eolib/data/eo_writer.py

def add_short(self, number: int) -> None:
    """
    Adds an encoded 2-byte integer to the writer data.

    Args:
        number (int): The number to encode and add.

    Raises:
        ValueError: If the value is not below `SHORT_MAX`.
    """
    self._check_number_size(number, SHORT_MAX - 1)
    number_bytes = encode_number(number)
    self._add_bytes_with_length(number_bytes, 2)

add_three(number)

Adds an encoded 3-byte integer to the writer data.

Parameters:

Name	Type	Description	Default
number	int	The number to encode and add.	required

Raises:

Type	Description
ValueError	If the value is not below THREE_MAX.

Source code in src/eolib/data/eo_writer.py

def add_three(self, number: int) -> None:
    """
    Adds an encoded 3-byte integer to the writer data.

    Args:
        number (int): The number to encode and add.

    Raises:
        ValueError: If the value is not below `THREE_MAX`.
    """
    self._check_number_size(number, THREE_MAX - 1)
    number_bytes = encode_number(number)
    self._add_bytes_with_length(number_bytes, 3)

add_int(number)

Adds an encoded 4-byte integer to the writer data.

Parameters:

Name	Type	Description	Default
number	int	The number to encode and add.	required

Raises:

Type	Description
ValueError	If the value is not below INT_MAX.

Source code in src/eolib/data/eo_writer.py

def add_int(self, number: int) -> None:
    """
    Adds an encoded 4-byte integer to the writer data.

    Args:
        number (int): The number to encode and add.

    Raises:
        ValueError: If the value is not below `INT_MAX`.
    """
    self._check_number_size(number, INT_MAX - 1)
    number_bytes = encode_number(number)
    self._add_bytes_with_length(number_bytes, 4)

add_string(string)

Adds a string to the writer data.

Parameters:

Name	Type	Description	Default
string	str	The string to be added.	required

Source code in src/eolib/data/eo_writer.py

def add_string(self, string: str) -> None:
    """
    Adds a string to the writer data.

    Args:
        string (str): The string to be added.
    """
    string_bytes = self._encode_ansi(string)
    self._sanitize_string(string_bytes)
    self.add_bytes(string_bytes)

add_fixed_string(string, length, padded=False)

Adds a fixed-length string to the writer data.

Parameters:

Name	Type	Description	Default
string	str	The string to be added.	required
length	int	The expected length of the string.	required
padded	bool	True if the string should be padded to the length with trailing 0xFF bytes. Defaults to False.	False

Source code in src/eolib/data/eo_writer.py

def add_fixed_string(self, string: str, length: int, padded: bool = False) -> None:
    """
    Adds a fixed-length string to the writer data.

    Args:
        string (str): The string to be added.
        length (int): The expected length of the string.
        padded (bool, optional): True if the string should be padded to the length with
            trailing `0xFF` bytes. Defaults to False.
    """
    self._check_string_length(string, length, padded)
    string_bytes = self._encode_ansi(string)
    self._sanitize_string(string_bytes)
    if padded:
        string_bytes = self._add_padding(string_bytes, length)
    self.add_bytes(string_bytes)

add_encoded_string(string)

Adds an encoded string to the writer data.

Parameters:

Name	Type	Description	Default
string	str	The string to be encoded and added.	required

Source code in src/eolib/data/eo_writer.py

def add_encoded_string(self, string: str) -> None:
    """
    Adds an encoded string to the writer data.

    Args:
        string (str): The string to be encoded and added.
    """
    string_bytes = self._encode_ansi(string)
    self._sanitize_string(string_bytes)
    encode_string(string_bytes)
    self.add_bytes(string_bytes)

add_fixed_encoded_string(string, length, padded=False)

Adds a fixed-length encoded string to the writer data.

Parameters:

Name	Type	Description	Default
string	str	The string to be encoded and added.	required
length	int	The expected length of the string.	required
padded	bool	True if the string should be padded to the length with trailing 0xFF bytes. Defaults to False.	False

Source code in src/eolib/data/eo_writer.py

def add_fixed_encoded_string(self, string: str, length: int, padded: bool = False) -> None:
    """
    Adds a fixed-length encoded string to the writer data.

    Args:
        string (str): The string to be encoded and added.
        length (int): The expected length of the string.
        padded (bool, optional): True if the string should be padded to the length with
            trailing `0xFF` bytes. Defaults to False.
    """
    self._check_string_length(string, length, padded)
    string_bytes = self._encode_ansi(string)
    self._sanitize_string(string_bytes)
    if padded:
        string_bytes = self._add_padding(string_bytes, length)
    encode_string(string_bytes)
    self.add_bytes(string_bytes)

to_bytearray()

Gets the writer data as a byte array.

Returns:

Name	Type	Description
bytearray	bytearray	A copy of the writer data as a byte array.

Source code in src/eolib/data/eo_writer.py

def to_bytearray(self) -> bytearray:
    """
    Gets the writer data as a byte array.

    Returns:
        bytearray: A copy of the writer data as a byte array.
    """
    return self.data.copy()

__len__()

Gets the length of the writer data.

Returns:

Name	Type	Description
int	int	The length of the writer data.

Source code in src/eolib/data/eo_writer.py

def __len__(self) -> int:
    """
    Gets the length of the writer data.

    Returns:
        int: The length of the writer data.
    """
    return len(self.data)

EoReader

Bases: object

A class for reading EO data from a sequence of bytes.

EoReader features a chunked reading mode, which is important for accurate emulation of the official game client.

See documentation for chunked reading: https://github.com/Cirras/eo-protocol/blob/master/docs/chunks.md

Source code in src/eolib/data/eo_reader.py

class EoReader(object):
    """
    A class for reading EO data from a sequence of bytes.

    `EoReader` features a chunked reading mode, which is important for accurate emulation of
    the official game client.

    See documentation for chunked reading:
    https://github.com/Cirras/eo-protocol/blob/master/docs/chunks.md
    """

    _data: memoryview
    _position: int
    _chunked_reading_mode: bool
    _chunk_start: int
    _next_break: int

    def __init__(self, data: bytes):
        """
        Creates a new `EoReader` instance for the specified data.

        Args:
            data (bytes): The byte array containing the input data.
        """
        self._data = memoryview(data)
        self._position = 0
        self._chunked_reading_mode = False
        self._chunk_start = 0
        self._next_break = -1

    def slice(self, index: Optional[int] = None, length: Optional[int] = None) -> "EoReader":
        """
        Creates a new `EoReader` whose input data is a shared subsequence of this reader's
        data.

        The input data of the new reader will start at position `index` in this reader and contain
        up to `length` bytes. The two reader's position and chunked reading mode will be
        independent.

        The new reader's position will be zero, and its chunked reading mode will be false.

        Args:
            index (int, optional): The position in this reader at which the data of the new reader
                will start; must be non-negative. Defaults to the current reader position.
            length (int, optional): The length of the shared subsequence of data to supply to the
                new reader; must be non-negative. Defaults to the length of the remaining data
                starting from `index`.

        Returns:
            EoReader: The new reader.

        Raises:
            ValueError: If `index` or `length` is negative.
        """
        if index is None:
            index = self.position
        if length is None:
            length = max(0, len(self._data) - index)

        if index < 0:
            raise ValueError(f"negative index: {index}")

        if length < 0:
            raise ValueError(f"negative length: {length}")

        begin = max(0, min(len(self._data), index))
        end = begin + min(len(self._data) - begin, length)

        return EoReader(self._data[begin:end])

    def get_byte(self) -> int:
        """
        Reads a raw byte from the input data.

        Returns:
            int: A raw byte.
        """
        return self._read_byte()

    def get_bytes(self, length: int) -> bytearray:
        """
        Reads an array of raw bytes from the input data.

        Args:
            length (int): The number of bytes to read.

        Returns:
            bytearray: An array of raw bytes.
        """
        return self._read_bytes(length)

    def get_char(self) -> int:
        """
        Reads an encoded 1-byte integer from the input data.

        Returns:
            int: A decoded 1-byte integer.
        """
        return decode_number(self._read_bytes(1))

    def get_short(self) -> int:
        """
        Reads an encoded 2-byte integer from the input data.

        Returns:
            int: A decoded 2-byte integer.
        """
        return decode_number(self._read_bytes(2))

    def get_three(self) -> int:
        """
        Reads an encoded 3-byte integer from the input data.

        Returns:
            int: A decoded 3-byte integer.
        """
        return decode_number(self._read_bytes(3))

    def get_int(self) -> int:
        """
        Reads an encoded 4-byte integer from the input data.

        Returns:
            int: A decoded 4-byte integer.
        """
        return decode_number(self._read_bytes(4))

    def get_string(self) -> str:
        """
        Reads a string from the input data.

        Returns:
            str: A string.
        """
        string_bytes = self._read_bytes(self.remaining)
        return self._decode_ansi(string_bytes)

    def get_fixed_string(self, length: int, padded: bool = False) -> str:
        """
        Reads a string with a fixed length from the input data.

        Args:
            length (int): The length of the string.
            padded (bool, optional): True if the string is padded with trailing `0xFF` bytes.

        Returns:
            str: A decoded string.

        Raises:
            ValueError: If the length is negative.
        """
        if length < 0:
            raise ValueError("Negative length")
        bytes_ = self._read_bytes(length)
        if padded:
            bytes_ = self._remove_padding(bytes_)
        return self._decode_ansi(bytes_)

    def get_encoded_string(self) -> str:
        """
        Reads an encoded string from the input data.

        Returns:
            str: A decoded string.
        """
        bytes_ = self._read_bytes(self.remaining)
        decode_string(bytes_)
        return self._decode_ansi(bytes_)

    def get_fixed_encoded_string(self, length: int, padded: bool = False) -> str:
        """
        Reads an encoded string with a fixed length from the input data.

        Args:
            length (int): The length of the string.
            padded (bool, optional): True if the string is padded with trailing `0xFF` bytes.

        Returns:
            str: A decoded string.

        Raises:
            ValueError: If the length is negative.
        """
        if length < 0:
            raise ValueError("Negative length")
        bytes_ = self._read_bytes(length)
        decode_string(bytes_)
        if padded:
            bytes_ = self._remove_padding(bytes_)
        return self._decode_ansi(bytes_)

    @property
    def chunked_reading_mode(self) -> bool:
        """
        bool: Gets or sets the chunked reading mode for the reader.

        In chunked reading mode:
        - The reader will treat `0xFF` bytes as the end of the current chunk.
        - `next_chunk()` can be called to move to the next chunk.
        """
        return self._chunked_reading_mode

    @chunked_reading_mode.setter
    def chunked_reading_mode(self, chunked_reading_mode: bool) -> None:
        self._chunked_reading_mode = chunked_reading_mode
        if self._next_break == -1:
            self._next_break = self._find_next_break_index()

    @property
    def remaining(self) -> int:
        """
        int: If chunked reading mode is enabled, gets the number of bytes remaining in the current
            chunk. Otherwise, gets the total number of bytes remaining in the input data.
        """
        if self.chunked_reading_mode:
            return self._next_break - min(self.position, self._next_break)
        else:
            return len(self._data) - self.position

    def next_chunk(self) -> None:
        """
        Moves the reader position to the start of the next chunk in the input data.

        Raises:
            RuntimeError: If not in chunked reading mode.
        """
        if not self.chunked_reading_mode:
            raise RuntimeError("Not in chunked reading mode.")

        self._position = self._next_break
        if self._position < len(self._data):
            # Skip the break byte
            self._position += 1

        self._chunk_start = self._position
        self._next_break = self._find_next_break_index()

    @property
    def position(self) -> int:
        """
        int: Gets the current position in the input data.
        """
        return self._position

    def _read_byte(self) -> int:
        """
        Reads a raw byte from the input data.

        Returns:
            int: A raw byte.
        """
        if self.remaining > 0:
            byte = self._data[self._position]
            self._position += 1
            return byte
        return 0

    def _read_bytes(self, length) -> bytearray:
        """
        Reads an array of raw bytes from the input data.

        Args:
            length (int): The number of bytes to read.

        Returns:
            bytearray: An array of raw bytes.
        """
        length = min(length, self.remaining)

        result = bytearray(self._data[self._position : self._position + length])
        self._position += length

        return result

    def _find_next_break_index(self) -> int:
        """
        Finds the index of the next break byte (0xFF) in the input data.

        Returns:
            int: The index of the next break byte, or the length of the data if not found.
        """
        for i in range(self._chunk_start, len(self._data)):
            if self._data[i] == 0xFF:
                return i
        return len(self._data)

    @staticmethod
    def _remove_padding(array: bytearray) -> bytearray:
        """
        Removes padding (trailing 0xFF bytes) from a sequence of bytes.

        Args:
            array (bytearray): The sequence of bytes.

        Returns:
            bytearray: The bytes without padding.
        """
        padding_start = array.find(bytes([0xFF]))
        if padding_start != -1:
            return array[:padding_start]
        return array

    @staticmethod
    def _decode_ansi(bytes: bytearray) -> str:
        """
        Decodes windows-1252 bytes to a string.

        Args:
            bytes (bytearray): The sequence of bytes to decode.

        Returns:
            str: The decoded string.
        """
        return bytes.decode('windows-1252', 'replace')

chunked_reading_mode: bool property writable

bool: Gets or sets the chunked reading mode for the reader.

In chunked reading mode: - The reader will treat 0xFF bytes as the end of the current chunk. - next_chunk() can be called to move to the next chunk.

remaining: int property

If chunked reading mode is enabled, gets the number of bytes remaining in the current

chunk. Otherwise, gets the total number of bytes remaining in the input data.

position: int property

int: Gets the current position in the input data.

__init__(data)

Creates a new EoReader instance for the specified data.

Parameters:

Name	Type	Description	Default
data	bytes	The byte array containing the input data.	required

Source code in src/eolib/data/eo_reader.py

def __init__(self, data: bytes):
    """
    Creates a new `EoReader` instance for the specified data.

    Args:
        data (bytes): The byte array containing the input data.
    """
    self._data = memoryview(data)
    self._position = 0
    self._chunked_reading_mode = False
    self._chunk_start = 0
    self._next_break = -1

slice(index=None, length=None)

Creates a new EoReader whose input data is a shared subsequence of this reader's data.

The input data of the new reader will start at position index in this reader and contain up to length bytes. The two reader's position and chunked reading mode will be independent.

The new reader's position will be zero, and its chunked reading mode will be false.

Parameters:

Name	Type	Description	Default
index	int	The position in this reader at which the data of the new reader will start; must be non-negative. Defaults to the current reader position.	None
length	int	The length of the shared subsequence of data to supply to the new reader; must be non-negative. Defaults to the length of the remaining data starting from index.	None

Returns:

Name	Type	Description
EoReader	EoReader	The new reader.

Raises:

Type	Description
ValueError	If index or length is negative.

Source code in src/eolib/data/eo_reader.py

def slice(self, index: Optional[int] = None, length: Optional[int] = None) -> "EoReader":
    """
    Creates a new `EoReader` whose input data is a shared subsequence of this reader's
    data.

    The input data of the new reader will start at position `index` in this reader and contain
    up to `length` bytes. The two reader's position and chunked reading mode will be
    independent.

    The new reader's position will be zero, and its chunked reading mode will be false.

    Args:
        index (int, optional): The position in this reader at which the data of the new reader
            will start; must be non-negative. Defaults to the current reader position.
        length (int, optional): The length of the shared subsequence of data to supply to the
            new reader; must be non-negative. Defaults to the length of the remaining data
            starting from `index`.

    Returns:
        EoReader: The new reader.

    Raises:
        ValueError: If `index` or `length` is negative.
    """
    if index is None:
        index = self.position
    if length is None:
        length = max(0, len(self._data) - index)

    if index < 0:
        raise ValueError(f"negative index: {index}")

    if length < 0:
        raise ValueError(f"negative length: {length}")

    begin = max(0, min(len(self._data), index))
    end = begin + min(len(self._data) - begin, length)

    return EoReader(self._data[begin:end])

get_byte()

Reads a raw byte from the input data.

Returns:

Name	Type	Description
int	int	A raw byte.

Source code in src/eolib/data/eo_reader.py

def get_byte(self) -> int:
    """
    Reads a raw byte from the input data.

    Returns:
        int: A raw byte.
    """
    return self._read_byte()

get_bytes(length)

Reads an array of raw bytes from the input data.

Parameters:

Name	Type	Description	Default
length	int	The number of bytes to read.	required

Returns:

Name	Type	Description
bytearray	bytearray	An array of raw bytes.

Source code in src/eolib/data/eo_reader.py

def get_bytes(self, length: int) -> bytearray:
    """
    Reads an array of raw bytes from the input data.

    Args:
        length (int): The number of bytes to read.

    Returns:
        bytearray: An array of raw bytes.
    """
    return self._read_bytes(length)

get_char()

Reads an encoded 1-byte integer from the input data.

Returns:

Name	Type	Description
int	int	A decoded 1-byte integer.

Source code in src/eolib/data/eo_reader.py

def get_char(self) -> int:
    """
    Reads an encoded 1-byte integer from the input data.

    Returns:
        int: A decoded 1-byte integer.
    """
    return decode_number(self._read_bytes(1))

get_short()

Reads an encoded 2-byte integer from the input data.

Returns:

Name	Type	Description
int	int	A decoded 2-byte integer.

Source code in src/eolib/data/eo_reader.py

def get_short(self) -> int:
    """
    Reads an encoded 2-byte integer from the input data.

    Returns:
        int: A decoded 2-byte integer.
    """
    return decode_number(self._read_bytes(2))

get_three()

Reads an encoded 3-byte integer from the input data.

Returns:

Name	Type	Description
int	int	A decoded 3-byte integer.

Source code in src/eolib/data/eo_reader.py

def get_three(self) -> int:
    """
    Reads an encoded 3-byte integer from the input data.

    Returns:
        int: A decoded 3-byte integer.
    """
    return decode_number(self._read_bytes(3))

get_int()

Reads an encoded 4-byte integer from the input data.

Returns:

Name	Type	Description
int	int	A decoded 4-byte integer.

Source code in src/eolib/data/eo_reader.py

def get_int(self) -> int:
    """
    Reads an encoded 4-byte integer from the input data.

    Returns:
        int: A decoded 4-byte integer.
    """
    return decode_number(self._read_bytes(4))

get_string()

Reads a string from the input data.

Returns:

Name	Type	Description
str	str	A string.

Source code in src/eolib/data/eo_reader.py

def get_string(self) -> str:
    """
    Reads a string from the input data.

    Returns:
        str: A string.
    """
    string_bytes = self._read_bytes(self.remaining)
    return self._decode_ansi(string_bytes)

get_fixed_string(length, padded=False)

Reads a string with a fixed length from the input data.

Parameters:

Name	Type	Description	Default
length	int	The length of the string.	required
padded	bool	True if the string is padded with trailing 0xFF bytes.	False

Returns:

Name	Type	Description
str	str	A decoded string.

Raises:

Type	Description
ValueError	If the length is negative.

Source code in src/eolib/data/eo_reader.py

def get_fixed_string(self, length: int, padded: bool = False) -> str:
    """
    Reads a string with a fixed length from the input data.

    Args:
        length (int): The length of the string.
        padded (bool, optional): True if the string is padded with trailing `0xFF` bytes.

    Returns:
        str: A decoded string.

    Raises:
        ValueError: If the length is negative.
    """
    if length < 0:
        raise ValueError("Negative length")
    bytes_ = self._read_bytes(length)
    if padded:
        bytes_ = self._remove_padding(bytes_)
    return self._decode_ansi(bytes_)

get_encoded_string()

Reads an encoded string from the input data.

Returns:

Name	Type	Description
str	str	A decoded string.

Source code in src/eolib/data/eo_reader.py

def get_encoded_string(self) -> str:
    """
    Reads an encoded string from the input data.

    Returns:
        str: A decoded string.
    """
    bytes_ = self._read_bytes(self.remaining)
    decode_string(bytes_)
    return self._decode_ansi(bytes_)

get_fixed_encoded_string(length, padded=False)

Reads an encoded string with a fixed length from the input data.

Parameters:

Name	Type	Description	Default
length	int	The length of the string.	required
padded	bool	True if the string is padded with trailing 0xFF bytes.	False

Returns:

Name	Type	Description
str	str	A decoded string.

Raises:

Type	Description
ValueError	If the length is negative.

Source code in src/eolib/data/eo_reader.py

def get_fixed_encoded_string(self, length: int, padded: bool = False) -> str:
    """
    Reads an encoded string with a fixed length from the input data.

    Args:
        length (int): The length of the string.
        padded (bool, optional): True if the string is padded with trailing `0xFF` bytes.

    Returns:
        str: A decoded string.

    Raises:
        ValueError: If the length is negative.
    """
    if length < 0:
        raise ValueError("Negative length")
    bytes_ = self._read_bytes(length)
    decode_string(bytes_)
    if padded:
        bytes_ = self._remove_padding(bytes_)
    return self._decode_ansi(bytes_)

next_chunk()

Moves the reader position to the start of the next chunk in the input data.

Raises:

Type	Description
RuntimeError	If not in chunked reading mode.

Source code in src/eolib/data/eo_reader.py

def next_chunk(self) -> None:
    """
    Moves the reader position to the start of the next chunk in the input data.

    Raises:
        RuntimeError: If not in chunked reading mode.
    """
    if not self.chunked_reading_mode:
        raise RuntimeError("Not in chunked reading mode.")

    self._position = self._next_break
    if self._position < len(self._data):
        # Skip the break byte
        self._position += 1

    self._chunk_start = self._position
    self._next_break = self._find_next_break_index()

MapWarpRowTile

A single tile in a row of warp entities

Source code in src/eolib/protocol/_generated/map/map_warp_row_tile.py

class MapWarpRowTile:
    """
    A single tile in a row of warp entities
    """
    _byte_size: int = 0
    _x: int
    _warp: MapWarp

    def __init__(self, *, x: int, warp: MapWarp):
        """
        Create a new instance of MapWarpRowTile.

        Args:
            x (int): (Value range is 0-252.)
            warp (MapWarp): 
        """
        self._x = x
        self._warp = warp

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def x(self) -> int:
        return self._x

    @property
    def warp(self) -> MapWarp:
        return self._warp

    @staticmethod
    def serialize(writer: EoWriter, data: "MapWarpRowTile") -> None:
        """
        Serializes an instance of `MapWarpRowTile` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapWarpRowTile): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._x is None:
                raise SerializationError("x must be provided.")
            writer.add_char(data._x)
            if data._warp is None:
                raise SerializationError("warp must be provided.")
            MapWarp.serialize(writer, data._warp)
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapWarpRowTile":
        """
        Deserializes an instance of `MapWarpRowTile` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapWarpRowTile: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            x = reader.get_char()
            warp = MapWarp.deserialize(reader)
            result = MapWarpRowTile(x=x, warp=warp)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapWarpRowTile(byte_size={repr(self._byte_size)}, x={repr(self._x)}, warp={repr(self._warp)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

x: int property

warp: MapWarp property

__init__(*, x, warp)

Create a new instance of MapWarpRowTile.

Parameters:

Name	Type	Description	Default
x	int	(Value range is 0-252.)	required
warp	MapWarp		required

Source code in src/eolib/protocol/_generated/map/map_warp_row_tile.py

def __init__(self, *, x: int, warp: MapWarp):
    """
    Create a new instance of MapWarpRowTile.

    Args:
        x (int): (Value range is 0-252.)
        warp (MapWarp): 
    """
    self._x = x
    self._warp = warp

serialize(writer, data) staticmethod

Serializes an instance of MapWarpRowTile to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapWarpRowTile	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_warp_row_tile.py

@staticmethod
def serialize(writer: EoWriter, data: "MapWarpRowTile") -> None:
    """
    Serializes an instance of `MapWarpRowTile` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapWarpRowTile): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._x is None:
            raise SerializationError("x must be provided.")
        writer.add_char(data._x)
        if data._warp is None:
            raise SerializationError("warp must be provided.")
        MapWarp.serialize(writer, data._warp)
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapWarpRowTile from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapWarpRowTile	MapWarpRowTile	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_warp_row_tile.py

@staticmethod
def deserialize(reader: EoReader) -> "MapWarpRowTile":
    """
    Deserializes an instance of `MapWarpRowTile` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapWarpRowTile: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        x = reader.get_char()
        warp = MapWarp.deserialize(reader)
        result = MapWarpRowTile(x=x, warp=warp)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

MapWarpRow

A row of warp entities

Source code in src/eolib/protocol/_generated/map/map_warp_row.py

class MapWarpRow:
    """
    A row of warp entities
    """
    _byte_size: int = 0
    _y: int
    _tiles_count: int
    _tiles: tuple[MapWarpRowTile, ...]

    def __init__(self, *, y: int, tiles: Iterable[MapWarpRowTile]):
        """
        Create a new instance of MapWarpRow.

        Args:
            y (int): (Value range is 0-252.)
            tiles (Iterable[MapWarpRowTile]): (Length must be 252 or less.)
        """
        self._y = y
        self._tiles = tuple(tiles)
        self._tiles_count = len(self._tiles)

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def y(self) -> int:
        return self._y

    @property
    def tiles(self) -> tuple[MapWarpRowTile, ...]:
        return self._tiles

    @staticmethod
    def serialize(writer: EoWriter, data: "MapWarpRow") -> None:
        """
        Serializes an instance of `MapWarpRow` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapWarpRow): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._y is None:
                raise SerializationError("y must be provided.")
            writer.add_char(data._y)
            if data._tiles_count is None:
                raise SerializationError("tiles_count must be provided.")
            writer.add_char(data._tiles_count)
            if data._tiles is None:
                raise SerializationError("tiles must be provided.")
            if len(data._tiles) > 252:
                raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
            for i in range(data._tiles_count):
                MapWarpRowTile.serialize(writer, data._tiles[i])
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapWarpRow":
        """
        Deserializes an instance of `MapWarpRow` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapWarpRow: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            y = reader.get_char()
            tiles_count = reader.get_char()
            tiles = []
            for i in range(tiles_count):
                tiles.append(MapWarpRowTile.deserialize(reader))
            result = MapWarpRow(y=y, tiles=tiles)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapWarpRow(byte_size={repr(self._byte_size)}, y={repr(self._y)}, tiles={repr(self._tiles)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

y: int property

tiles: tuple[MapWarpRowTile, ...] property

__init__(*, y, tiles)

Create a new instance of MapWarpRow.

Parameters:

Name	Type	Description	Default
y	int	(Value range is 0-252.)	required
tiles	Iterable[MapWarpRowTile]	(Length must be 252 or less.)	required

Source code in src/eolib/protocol/_generated/map/map_warp_row.py

def __init__(self, *, y: int, tiles: Iterable[MapWarpRowTile]):
    """
    Create a new instance of MapWarpRow.

    Args:
        y (int): (Value range is 0-252.)
        tiles (Iterable[MapWarpRowTile]): (Length must be 252 or less.)
    """
    self._y = y
    self._tiles = tuple(tiles)
    self._tiles_count = len(self._tiles)

serialize(writer, data) staticmethod

Serializes an instance of MapWarpRow to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapWarpRow	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_warp_row.py

@staticmethod
def serialize(writer: EoWriter, data: "MapWarpRow") -> None:
    """
    Serializes an instance of `MapWarpRow` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapWarpRow): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._y is None:
            raise SerializationError("y must be provided.")
        writer.add_char(data._y)
        if data._tiles_count is None:
            raise SerializationError("tiles_count must be provided.")
        writer.add_char(data._tiles_count)
        if data._tiles is None:
            raise SerializationError("tiles must be provided.")
        if len(data._tiles) > 252:
            raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
        for i in range(data._tiles_count):
            MapWarpRowTile.serialize(writer, data._tiles[i])
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapWarpRow from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapWarpRow	'MapWarpRow'	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_warp_row.py

@staticmethod
def deserialize(reader: EoReader) -> "MapWarpRow":
    """
    Deserializes an instance of `MapWarpRow` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapWarpRow: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        y = reader.get_char()
        tiles_count = reader.get_char()
        tiles = []
        for i in range(tiles_count):
            tiles.append(MapWarpRowTile.deserialize(reader))
        result = MapWarpRow(y=y, tiles=tiles)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

Coords

Map coordinates

Source code in src/eolib/protocol/_generated/coords.py

class Coords:
    """
    Map coordinates
    """
    _byte_size: int = 0
    _x: int
    _y: int

    def __init__(self, *, x: int, y: int):
        """
        Create a new instance of Coords.

        Args:
            x (int): (Value range is 0-252.)
            y (int): (Value range is 0-252.)
        """
        self._x = x
        self._y = y

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def x(self) -> int:
        return self._x

    @property
    def y(self) -> int:
        return self._y

    @staticmethod
    def serialize(writer: EoWriter, data: "Coords") -> None:
        """
        Serializes an instance of `Coords` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (Coords): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._x is None:
                raise SerializationError("x must be provided.")
            writer.add_char(data._x)
            if data._y is None:
                raise SerializationError("y must be provided.")
            writer.add_char(data._y)
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "Coords":
        """
        Deserializes an instance of `Coords` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            Coords: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            x = reader.get_char()
            y = reader.get_char()
            result = Coords(x=x, y=y)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"Coords(byte_size={repr(self._byte_size)}, x={repr(self._x)}, y={repr(self._y)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

x: int property

y: int property

__init__(*, x, y)

Create a new instance of Coords.

Parameters:

Name	Type	Description	Default
x	int	(Value range is 0-252.)	required
y	int	(Value range is 0-252.)	required

Source code in src/eolib/protocol/_generated/coords.py

def __init__(self, *, x: int, y: int):
    """
    Create a new instance of Coords.

    Args:
        x (int): (Value range is 0-252.)
        y (int): (Value range is 0-252.)
    """
    self._x = x
    self._y = y

serialize(writer, data) staticmethod

Serializes an instance of Coords to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	Coords	The data to serialize.	required

Source code in src/eolib/protocol/_generated/coords.py

@staticmethod
def serialize(writer: EoWriter, data: "Coords") -> None:
    """
    Serializes an instance of `Coords` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (Coords): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._x is None:
            raise SerializationError("x must be provided.")
        writer.add_char(data._x)
        if data._y is None:
            raise SerializationError("y must be provided.")
        writer.add_char(data._y)
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of Coords from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
Coords	Coords	The data to serialize.

Source code in src/eolib/protocol/_generated/coords.py

@staticmethod
def deserialize(reader: EoReader) -> "Coords":
    """
    Deserializes an instance of `Coords` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        Coords: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        x = reader.get_char()
        y = reader.get_char()
        result = Coords(x=x, y=y)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

ProtocolEnumMeta

Bases: EnumMeta

Source code in src/eolib/protocol/protocol_enum_meta.py

class ProtocolEnumMeta(EnumMeta):
    def __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1):
        if names is not None:
            return super().__call__(
                value, names=names, module=module, qualname=qualname, type=type, start=start
            )
        try:
            return super().__call__(value, module=module, qualname=qualname, type=type, start=start)
        except ValueError:
            unrecognized = int.__new__(cls, value)
            unrecognized._name_ = f"Unrecognized({int(value)})"
            unrecognized._value_ = value
            return unrecognized

__call__(value, names=None, *, module=None, qualname=None, type=None, start=1)

Source code in src/eolib/protocol/protocol_enum_meta.py

def __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1):
    if names is not None:
        return super().__call__(
            value, names=names, module=module, qualname=qualname, type=type, start=start
        )
    try:
        return super().__call__(value, module=module, qualname=qualname, type=type, start=start)
    except ValueError:
        unrecognized = int.__new__(cls, value)
        unrecognized._name_ = f"Unrecognized({int(value)})"
        unrecognized._value_ = value
        return unrecognized

MapType

Bases: IntEnum

Source code in src/eolib/protocol/_generated/map/map_type.py

class MapType(IntEnum, metaclass=ProtocolEnumMeta):
    Normal = 0
    Pk = 3

Normal = 0 class-attribute instance-attribute

Pk = 3 class-attribute instance-attribute

MapTimedEffect

Bases: IntEnum

A timed effect that can occur on a map

Source code in src/eolib/protocol/_generated/map/map_timed_effect.py

class MapTimedEffect(IntEnum, metaclass=ProtocolEnumMeta):
    """
    A timed effect that can occur on a map
    """
    None_ = 0
    HpDrain = 1
    TpDrain = 2
    Quake1 = 3
    Quake2 = 4
    Quake3 = 5
    Quake4 = 6

None_ = 0 class-attribute instance-attribute

HpDrain = 1 class-attribute instance-attribute

TpDrain = 2 class-attribute instance-attribute

Quake1 = 3 class-attribute instance-attribute

Quake2 = 4 class-attribute instance-attribute

Quake3 = 5 class-attribute instance-attribute

Quake4 = 6 class-attribute instance-attribute

MapTileSpec

Bases: IntEnum

The type of a tile on a map

Source code in src/eolib/protocol/_generated/map/map_tile_spec.py

class MapTileSpec(IntEnum, metaclass=ProtocolEnumMeta):
    """
    The type of a tile on a map
    """
    Wall = 0
    ChairDown = 1
    ChairLeft = 2
    ChairRight = 3
    ChairUp = 4
    ChairDownRight = 5
    ChairUpLeft = 6
    ChairAll = 7
    Reserved8 = 8
    Chest = 9
    Reserved10 = 10
    Reserved11 = 11
    Reserved12 = 12
    Reserved13 = 13
    Reserved14 = 14
    Reserved15 = 15
    BankVault = 16
    NpcBoundary = 17
    Edge = 18
    FakeWall = 19
    Board1 = 20
    Board2 = 21
    Board3 = 22
    Board4 = 23
    Board5 = 24
    Board6 = 25
    Board7 = 26
    Board8 = 27
    Jukebox = 28
    Jump = 29
    Water = 30
    Reserved31 = 31
    Arena = 32
    AmbientSource = 33
    TimedSpikes = 34
    Spikes = 35
    HiddenSpikes = 36

Wall = 0 class-attribute instance-attribute

ChairDown = 1 class-attribute instance-attribute

ChairLeft = 2 class-attribute instance-attribute

ChairRight = 3 class-attribute instance-attribute

ChairUp = 4 class-attribute instance-attribute

ChairDownRight = 5 class-attribute instance-attribute

ChairUpLeft = 6 class-attribute instance-attribute

ChairAll = 7 class-attribute instance-attribute

Reserved8 = 8 class-attribute instance-attribute

Chest = 9 class-attribute instance-attribute

Reserved10 = 10 class-attribute instance-attribute

Reserved11 = 11 class-attribute instance-attribute

Reserved12 = 12 class-attribute instance-attribute

Reserved13 = 13 class-attribute instance-attribute

Reserved14 = 14 class-attribute instance-attribute

Reserved15 = 15 class-attribute instance-attribute

BankVault = 16 class-attribute instance-attribute

NpcBoundary = 17 class-attribute instance-attribute

Edge = 18 class-attribute instance-attribute

FakeWall = 19 class-attribute instance-attribute

Board1 = 20 class-attribute instance-attribute

Board2 = 21 class-attribute instance-attribute

Board3 = 22 class-attribute instance-attribute

Board4 = 23 class-attribute instance-attribute

Board5 = 24 class-attribute instance-attribute

Board6 = 25 class-attribute instance-attribute

Board7 = 26 class-attribute instance-attribute

Board8 = 27 class-attribute instance-attribute

Jukebox = 28 class-attribute instance-attribute

Jump = 29 class-attribute instance-attribute

Water = 30 class-attribute instance-attribute

Reserved31 = 31 class-attribute instance-attribute

Arena = 32 class-attribute instance-attribute

AmbientSource = 33 class-attribute instance-attribute

TimedSpikes = 34 class-attribute instance-attribute

Spikes = 35 class-attribute instance-attribute

HiddenSpikes = 36 class-attribute instance-attribute

MapTileSpecRowTile

A single tile in a row of tilespecs

Source code in src/eolib/protocol/_generated/map/map_tile_spec_row_tile.py

class MapTileSpecRowTile:
    """
    A single tile in a row of tilespecs
    """
    _byte_size: int = 0
    _x: int
    _tile_spec: MapTileSpec

    def __init__(self, *, x: int, tile_spec: MapTileSpec):
        """
        Create a new instance of MapTileSpecRowTile.

        Args:
            x (int): (Value range is 0-252.)
            tile_spec (MapTileSpec): 
        """
        self._x = x
        self._tile_spec = tile_spec

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def x(self) -> int:
        return self._x

    @property
    def tile_spec(self) -> MapTileSpec:
        return self._tile_spec

    @staticmethod
    def serialize(writer: EoWriter, data: "MapTileSpecRowTile") -> None:
        """
        Serializes an instance of `MapTileSpecRowTile` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapTileSpecRowTile): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._x is None:
                raise SerializationError("x must be provided.")
            writer.add_char(data._x)
            if data._tile_spec is None:
                raise SerializationError("tile_spec must be provided.")
            writer.add_char(int(data._tile_spec))
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapTileSpecRowTile":
        """
        Deserializes an instance of `MapTileSpecRowTile` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapTileSpecRowTile: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            x = reader.get_char()
            tile_spec = MapTileSpec(reader.get_char())
            result = MapTileSpecRowTile(x=x, tile_spec=tile_spec)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapTileSpecRowTile(byte_size={repr(self._byte_size)}, x={repr(self._x)}, tile_spec={repr(self._tile_spec)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

x: int property

tile_spec: MapTileSpec property

__init__(*, x, tile_spec)

Create a new instance of MapTileSpecRowTile.

Parameters:

Name	Type	Description	Default
x	int	(Value range is 0-252.)	required
tile_spec	MapTileSpec		required

Source code in src/eolib/protocol/_generated/map/map_tile_spec_row_tile.py

def __init__(self, *, x: int, tile_spec: MapTileSpec):
    """
    Create a new instance of MapTileSpecRowTile.

    Args:
        x (int): (Value range is 0-252.)
        tile_spec (MapTileSpec): 
    """
    self._x = x
    self._tile_spec = tile_spec

serialize(writer, data) staticmethod

Serializes an instance of MapTileSpecRowTile to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapTileSpecRowTile	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_tile_spec_row_tile.py

@staticmethod
def serialize(writer: EoWriter, data: "MapTileSpecRowTile") -> None:
    """
    Serializes an instance of `MapTileSpecRowTile` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapTileSpecRowTile): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._x is None:
            raise SerializationError("x must be provided.")
        writer.add_char(data._x)
        if data._tile_spec is None:
            raise SerializationError("tile_spec must be provided.")
        writer.add_char(int(data._tile_spec))
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapTileSpecRowTile from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapTileSpecRowTile	MapTileSpecRowTile	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_tile_spec_row_tile.py

@staticmethod
def deserialize(reader: EoReader) -> "MapTileSpecRowTile":
    """
    Deserializes an instance of `MapTileSpecRowTile` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapTileSpecRowTile: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        x = reader.get_char()
        tile_spec = MapTileSpec(reader.get_char())
        result = MapTileSpecRowTile(x=x, tile_spec=tile_spec)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

MapTileSpecRow

A row of tilespecs

Source code in src/eolib/protocol/_generated/map/map_tile_spec_row.py

class MapTileSpecRow:
    """
    A row of tilespecs
    """
    _byte_size: int = 0
    _y: int
    _tiles_count: int
    _tiles: tuple[MapTileSpecRowTile, ...]

    def __init__(self, *, y: int, tiles: Iterable[MapTileSpecRowTile]):
        """
        Create a new instance of MapTileSpecRow.

        Args:
            y (int): (Value range is 0-252.)
            tiles (Iterable[MapTileSpecRowTile]): (Length must be 252 or less.)
        """
        self._y = y
        self._tiles = tuple(tiles)
        self._tiles_count = len(self._tiles)

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def y(self) -> int:
        return self._y

    @property
    def tiles(self) -> tuple[MapTileSpecRowTile, ...]:
        return self._tiles

    @staticmethod
    def serialize(writer: EoWriter, data: "MapTileSpecRow") -> None:
        """
        Serializes an instance of `MapTileSpecRow` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapTileSpecRow): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._y is None:
                raise SerializationError("y must be provided.")
            writer.add_char(data._y)
            if data._tiles_count is None:
                raise SerializationError("tiles_count must be provided.")
            writer.add_char(data._tiles_count)
            if data._tiles is None:
                raise SerializationError("tiles must be provided.")
            if len(data._tiles) > 252:
                raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
            for i in range(data._tiles_count):
                MapTileSpecRowTile.serialize(writer, data._tiles[i])
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapTileSpecRow":
        """
        Deserializes an instance of `MapTileSpecRow` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapTileSpecRow: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            y = reader.get_char()
            tiles_count = reader.get_char()
            tiles = []
            for i in range(tiles_count):
                tiles.append(MapTileSpecRowTile.deserialize(reader))
            result = MapTileSpecRow(y=y, tiles=tiles)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapTileSpecRow(byte_size={repr(self._byte_size)}, y={repr(self._y)}, tiles={repr(self._tiles)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

y: int property

tiles: tuple[MapTileSpecRowTile, ...] property

__init__(*, y, tiles)

Create a new instance of MapTileSpecRow.

Parameters:

Name	Type	Description	Default
y	int	(Value range is 0-252.)	required
tiles	Iterable[MapTileSpecRowTile]	(Length must be 252 or less.)	required

Source code in src/eolib/protocol/_generated/map/map_tile_spec_row.py

def __init__(self, *, y: int, tiles: Iterable[MapTileSpecRowTile]):
    """
    Create a new instance of MapTileSpecRow.

    Args:
        y (int): (Value range is 0-252.)
        tiles (Iterable[MapTileSpecRowTile]): (Length must be 252 or less.)
    """
    self._y = y
    self._tiles = tuple(tiles)
    self._tiles_count = len(self._tiles)

serialize(writer, data) staticmethod

Serializes an instance of MapTileSpecRow to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapTileSpecRow	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_tile_spec_row.py

@staticmethod
def serialize(writer: EoWriter, data: "MapTileSpecRow") -> None:
    """
    Serializes an instance of `MapTileSpecRow` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapTileSpecRow): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._y is None:
            raise SerializationError("y must be provided.")
        writer.add_char(data._y)
        if data._tiles_count is None:
            raise SerializationError("tiles_count must be provided.")
        writer.add_char(data._tiles_count)
        if data._tiles is None:
            raise SerializationError("tiles must be provided.")
        if len(data._tiles) > 252:
            raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
        for i in range(data._tiles_count):
            MapTileSpecRowTile.serialize(writer, data._tiles[i])
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapTileSpecRow from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapTileSpecRow	'MapTileSpecRow'	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_tile_spec_row.py

@staticmethod
def deserialize(reader: EoReader) -> "MapTileSpecRow":
    """
    Deserializes an instance of `MapTileSpecRow` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapTileSpecRow: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        y = reader.get_char()
        tiles_count = reader.get_char()
        tiles = []
        for i in range(tiles_count):
            tiles.append(MapTileSpecRowTile.deserialize(reader))
        result = MapTileSpecRow(y=y, tiles=tiles)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

MapSign

Sign EMF entity

Source code in src/eolib/protocol/_generated/map/map_sign.py

class MapSign:
    """
    Sign EMF entity
    """
    _byte_size: int = 0
    _coords: Coords
    _string_data_length: int
    _string_data: str
    _title_length: int

    def __init__(self, *, coords: Coords, string_data: str, title_length: int):
        """
        Create a new instance of MapSign.

        Args:
            coords (Coords): 
            string_data (str): (Length must be 64007 or less.)
            title_length (int): (Value range is 0-252.)
        """
        self._coords = coords
        self._string_data = string_data
        self._string_data_length = len(self._string_data)
        self._title_length = title_length

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def coords(self) -> Coords:
        return self._coords

    @property
    def string_data(self) -> str:
        return self._string_data

    @property
    def title_length(self) -> int:
        return self._title_length

    @staticmethod
    def serialize(writer: EoWriter, data: "MapSign") -> None:
        """
        Serializes an instance of `MapSign` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapSign): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._coords is None:
                raise SerializationError("coords must be provided.")
            Coords.serialize(writer, data._coords)
            if data._string_data_length is None:
                raise SerializationError("string_data_length must be provided.")
            writer.add_short(data._string_data_length + 1)
            if data._string_data is None:
                raise SerializationError("string_data must be provided.")
            if len(data._string_data) > 64007:
                raise SerializationError(f"Expected length of string_data to be 64007 or less, got {len(data._string_data)}.")
            writer.add_fixed_encoded_string(data._string_data, data._string_data_length, False)
            if data._title_length is None:
                raise SerializationError("title_length must be provided.")
            writer.add_char(data._title_length)
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapSign":
        """
        Deserializes an instance of `MapSign` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapSign: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            coords = Coords.deserialize(reader)
            string_data_length = reader.get_short() - 1
            string_data = reader.get_fixed_encoded_string(string_data_length, False)
            title_length = reader.get_char()
            result = MapSign(coords=coords, string_data=string_data, title_length=title_length)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapSign(byte_size={repr(self._byte_size)}, coords={repr(self._coords)}, string_data={repr(self._string_data)}, title_length={repr(self._title_length)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

coords: Coords property

string_data: str property

title_length: int property

__init__(*, coords, string_data, title_length)

Create a new instance of MapSign.

Parameters:

Name	Type	Description	Default
coords	Coords		required
string_data	str	(Length must be 64007 or less.)	required
title_length	int	(Value range is 0-252.)	required

Source code in src/eolib/protocol/_generated/map/map_sign.py

def __init__(self, *, coords: Coords, string_data: str, title_length: int):
    """
    Create a new instance of MapSign.

    Args:
        coords (Coords): 
        string_data (str): (Length must be 64007 or less.)
        title_length (int): (Value range is 0-252.)
    """
    self._coords = coords
    self._string_data = string_data
    self._string_data_length = len(self._string_data)
    self._title_length = title_length

serialize(writer, data) staticmethod

Serializes an instance of MapSign to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapSign	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_sign.py

@staticmethod
def serialize(writer: EoWriter, data: "MapSign") -> None:
    """
    Serializes an instance of `MapSign` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapSign): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._coords is None:
            raise SerializationError("coords must be provided.")
        Coords.serialize(writer, data._coords)
        if data._string_data_length is None:
            raise SerializationError("string_data_length must be provided.")
        writer.add_short(data._string_data_length + 1)
        if data._string_data is None:
            raise SerializationError("string_data must be provided.")
        if len(data._string_data) > 64007:
            raise SerializationError(f"Expected length of string_data to be 64007 or less, got {len(data._string_data)}.")
        writer.add_fixed_encoded_string(data._string_data, data._string_data_length, False)
        if data._title_length is None:
            raise SerializationError("title_length must be provided.")
        writer.add_char(data._title_length)
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapSign from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapSign	MapSign	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_sign.py

@staticmethod
def deserialize(reader: EoReader) -> "MapSign":
    """
    Deserializes an instance of `MapSign` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapSign: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        coords = Coords.deserialize(reader)
        string_data_length = reader.get_short() - 1
        string_data = reader.get_fixed_encoded_string(string_data_length, False)
        title_length = reader.get_char()
        result = MapSign(coords=coords, string_data=string_data, title_length=title_length)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

MapNpc

NPC spawn EMF entity

Source code in src/eolib/protocol/_generated/map/map_npc.py

class MapNpc:
    """
    NPC spawn EMF entity
    """
    _byte_size: int = 0
    _coords: Coords
    _id: int
    _spawn_type: int
    _spawn_time: int
    _amount: int

    def __init__(self, *, coords: Coords, id: int, spawn_type: int, spawn_time: int, amount: int):
        """
        Create a new instance of MapNpc.

        Args:
            coords (Coords): 
            id (int): (Value range is 0-64008.)
            spawn_type (int): (Value range is 0-252.)
            spawn_time (int): (Value range is 0-64008.)
            amount (int): (Value range is 0-252.)
        """
        self._coords = coords
        self._id = id
        self._spawn_type = spawn_type
        self._spawn_time = spawn_time
        self._amount = amount

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def coords(self) -> Coords:
        return self._coords

    @property
    def id(self) -> int:
        return self._id

    @property
    def spawn_type(self) -> int:
        return self._spawn_type

    @property
    def spawn_time(self) -> int:
        return self._spawn_time

    @property
    def amount(self) -> int:
        return self._amount

    @staticmethod
    def serialize(writer: EoWriter, data: "MapNpc") -> None:
        """
        Serializes an instance of `MapNpc` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapNpc): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._coords is None:
                raise SerializationError("coords must be provided.")
            Coords.serialize(writer, data._coords)
            if data._id is None:
                raise SerializationError("id must be provided.")
            writer.add_short(data._id)
            if data._spawn_type is None:
                raise SerializationError("spawn_type must be provided.")
            writer.add_char(data._spawn_type)
            if data._spawn_time is None:
                raise SerializationError("spawn_time must be provided.")
            writer.add_short(data._spawn_time)
            if data._amount is None:
                raise SerializationError("amount must be provided.")
            writer.add_char(data._amount)
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapNpc":
        """
        Deserializes an instance of `MapNpc` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapNpc: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            coords = Coords.deserialize(reader)
            id = reader.get_short()
            spawn_type = reader.get_char()
            spawn_time = reader.get_short()
            amount = reader.get_char()
            result = MapNpc(coords=coords, id=id, spawn_type=spawn_type, spawn_time=spawn_time, amount=amount)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapNpc(byte_size={repr(self._byte_size)}, coords={repr(self._coords)}, id={repr(self._id)}, spawn_type={repr(self._spawn_type)}, spawn_time={repr(self._spawn_time)}, amount={repr(self._amount)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

coords: Coords property

id: int property

spawn_type: int property

spawn_time: int property

amount: int property

__init__(*, coords, id, spawn_type, spawn_time, amount)

Create a new instance of MapNpc.

Parameters:

Name	Type	Description	Default
coords	Coords		required
id	int	(Value range is 0-64008.)	required
spawn_type	int	(Value range is 0-252.)	required
spawn_time	int	(Value range is 0-64008.)	required
amount	int	(Value range is 0-252.)	required

Source code in src/eolib/protocol/_generated/map/map_npc.py

def __init__(self, *, coords: Coords, id: int, spawn_type: int, spawn_time: int, amount: int):
    """
    Create a new instance of MapNpc.

    Args:
        coords (Coords): 
        id (int): (Value range is 0-64008.)
        spawn_type (int): (Value range is 0-252.)
        spawn_time (int): (Value range is 0-64008.)
        amount (int): (Value range is 0-252.)
    """
    self._coords = coords
    self._id = id
    self._spawn_type = spawn_type
    self._spawn_time = spawn_time
    self._amount = amount

serialize(writer, data) staticmethod

Serializes an instance of MapNpc to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapNpc	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_npc.py

@staticmethod
def serialize(writer: EoWriter, data: "MapNpc") -> None:
    """
    Serializes an instance of `MapNpc` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapNpc): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._coords is None:
            raise SerializationError("coords must be provided.")
        Coords.serialize(writer, data._coords)
        if data._id is None:
            raise SerializationError("id must be provided.")
        writer.add_short(data._id)
        if data._spawn_type is None:
            raise SerializationError("spawn_type must be provided.")
        writer.add_char(data._spawn_type)
        if data._spawn_time is None:
            raise SerializationError("spawn_time must be provided.")
        writer.add_short(data._spawn_time)
        if data._amount is None:
            raise SerializationError("amount must be provided.")
        writer.add_char(data._amount)
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapNpc from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapNpc	MapNpc	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_npc.py

@staticmethod
def deserialize(reader: EoReader) -> "MapNpc":
    """
    Deserializes an instance of `MapNpc` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapNpc: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        coords = Coords.deserialize(reader)
        id = reader.get_short()
        spawn_type = reader.get_char()
        spawn_time = reader.get_short()
        amount = reader.get_char()
        result = MapNpc(coords=coords, id=id, spawn_type=spawn_type, spawn_time=spawn_time, amount=amount)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

MapMusicControl

Bases: IntEnum

How background music should be played on a map

Source code in src/eolib/protocol/_generated/map/map_music_control.py

class MapMusicControl(IntEnum, metaclass=ProtocolEnumMeta):
    """
    How background music should be played on a map
    """
    InterruptIfDifferentPlayOnce = 0
    InterruptPlayOnce = 1
    FinishPlayOnce = 2
    InterruptIfDifferentPlayRepeat = 3
    InterruptPlayRepeat = 4
    FinishPlayRepeat = 5
    InterruptPlayNothing = 6

InterruptIfDifferentPlayOnce = 0 class-attribute instance-attribute

InterruptPlayOnce = 1 class-attribute instance-attribute

FinishPlayOnce = 2 class-attribute instance-attribute

InterruptIfDifferentPlayRepeat = 3 class-attribute instance-attribute

InterruptPlayRepeat = 4 class-attribute instance-attribute

FinishPlayRepeat = 5 class-attribute instance-attribute

InterruptPlayNothing = 6 class-attribute instance-attribute

MapLegacyDoorKey

Legacy EMF entity used to specify a key on a door

Source code in src/eolib/protocol/_generated/map/map_legacy_door_key.py

class MapLegacyDoorKey:
    """
    Legacy EMF entity used to specify a key on a door
    """
    _byte_size: int = 0
    _coords: Coords
    _key: int

    def __init__(self, *, coords: Coords, key: int):
        """
        Create a new instance of MapLegacyDoorKey.

        Args:
            coords (Coords): 
            key (int): (Value range is 0-64008.)
        """
        self._coords = coords
        self._key = key

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def coords(self) -> Coords:
        return self._coords

    @property
    def key(self) -> int:
        return self._key

    @staticmethod
    def serialize(writer: EoWriter, data: "MapLegacyDoorKey") -> None:
        """
        Serializes an instance of `MapLegacyDoorKey` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapLegacyDoorKey): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._coords is None:
                raise SerializationError("coords must be provided.")
            Coords.serialize(writer, data._coords)
            if data._key is None:
                raise SerializationError("key must be provided.")
            writer.add_short(data._key)
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapLegacyDoorKey":
        """
        Deserializes an instance of `MapLegacyDoorKey` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapLegacyDoorKey: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            coords = Coords.deserialize(reader)
            key = reader.get_short()
            result = MapLegacyDoorKey(coords=coords, key=key)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapLegacyDoorKey(byte_size={repr(self._byte_size)}, coords={repr(self._coords)}, key={repr(self._key)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

coords: Coords property

key: int property

__init__(*, coords, key)

Create a new instance of MapLegacyDoorKey.

Parameters:

Name	Type	Description	Default
coords	Coords		required
key	int	(Value range is 0-64008.)	required

Source code in src/eolib/protocol/_generated/map/map_legacy_door_key.py

def __init__(self, *, coords: Coords, key: int):
    """
    Create a new instance of MapLegacyDoorKey.

    Args:
        coords (Coords): 
        key (int): (Value range is 0-64008.)
    """
    self._coords = coords
    self._key = key

serialize(writer, data) staticmethod

Serializes an instance of MapLegacyDoorKey to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapLegacyDoorKey	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_legacy_door_key.py

@staticmethod
def serialize(writer: EoWriter, data: "MapLegacyDoorKey") -> None:
    """
    Serializes an instance of `MapLegacyDoorKey` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapLegacyDoorKey): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._coords is None:
            raise SerializationError("coords must be provided.")
        Coords.serialize(writer, data._coords)
        if data._key is None:
            raise SerializationError("key must be provided.")
        writer.add_short(data._key)
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapLegacyDoorKey from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapLegacyDoorKey	MapLegacyDoorKey	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_legacy_door_key.py

@staticmethod
def deserialize(reader: EoReader) -> "MapLegacyDoorKey":
    """
    Deserializes an instance of `MapLegacyDoorKey` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapLegacyDoorKey: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        coords = Coords.deserialize(reader)
        key = reader.get_short()
        result = MapLegacyDoorKey(coords=coords, key=key)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

MapItem

Item spawn EMF entity

Source code in src/eolib/protocol/_generated/map/map_item.py

class MapItem:
    """
    Item spawn EMF entity
    """
    _byte_size: int = 0
    _coords: Coords
    _key: int
    _chest_slot: int
    _item_id: int
    _spawn_time: int
    _amount: int

    def __init__(self, *, coords: Coords, key: int, chest_slot: int, item_id: int, spawn_time: int, amount: int):
        """
        Create a new instance of MapItem.

        Args:
            coords (Coords): 
            key (int): (Value range is 0-64008.)
            chest_slot (int): (Value range is 0-252.)
            item_id (int): (Value range is 0-64008.)
            spawn_time (int): (Value range is 0-64008.)
            amount (int): (Value range is 0-16194276.)
        """
        self._coords = coords
        self._key = key
        self._chest_slot = chest_slot
        self._item_id = item_id
        self._spawn_time = spawn_time
        self._amount = amount

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def coords(self) -> Coords:
        return self._coords

    @property
    def key(self) -> int:
        return self._key

    @property
    def chest_slot(self) -> int:
        return self._chest_slot

    @property
    def item_id(self) -> int:
        return self._item_id

    @property
    def spawn_time(self) -> int:
        return self._spawn_time

    @property
    def amount(self) -> int:
        return self._amount

    @staticmethod
    def serialize(writer: EoWriter, data: "MapItem") -> None:
        """
        Serializes an instance of `MapItem` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapItem): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._coords is None:
                raise SerializationError("coords must be provided.")
            Coords.serialize(writer, data._coords)
            if data._key is None:
                raise SerializationError("key must be provided.")
            writer.add_short(data._key)
            if data._chest_slot is None:
                raise SerializationError("chest_slot must be provided.")
            writer.add_char(data._chest_slot)
            if data._item_id is None:
                raise SerializationError("item_id must be provided.")
            writer.add_short(data._item_id)
            if data._spawn_time is None:
                raise SerializationError("spawn_time must be provided.")
            writer.add_short(data._spawn_time)
            if data._amount is None:
                raise SerializationError("amount must be provided.")
            writer.add_three(data._amount)
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapItem":
        """
        Deserializes an instance of `MapItem` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapItem: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            coords = Coords.deserialize(reader)
            key = reader.get_short()
            chest_slot = reader.get_char()
            item_id = reader.get_short()
            spawn_time = reader.get_short()
            amount = reader.get_three()
            result = MapItem(coords=coords, key=key, chest_slot=chest_slot, item_id=item_id, spawn_time=spawn_time, amount=amount)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapItem(byte_size={repr(self._byte_size)}, coords={repr(self._coords)}, key={repr(self._key)}, chest_slot={repr(self._chest_slot)}, item_id={repr(self._item_id)}, spawn_time={repr(self._spawn_time)}, amount={repr(self._amount)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

coords: Coords property

key: int property

chest_slot: int property

item_id: int property

spawn_time: int property

amount: int property

__init__(*, coords, key, chest_slot, item_id, spawn_time, amount)

Create a new instance of MapItem.

Parameters:

Name	Type	Description	Default
coords	Coords		required
key	int	(Value range is 0-64008.)	required
chest_slot	int	(Value range is 0-252.)	required
item_id	int	(Value range is 0-64008.)	required
spawn_time	int	(Value range is 0-64008.)	required
amount	int	(Value range is 0-16194276.)	required

Source code in src/eolib/protocol/_generated/map/map_item.py

def __init__(self, *, coords: Coords, key: int, chest_slot: int, item_id: int, spawn_time: int, amount: int):
    """
    Create a new instance of MapItem.

    Args:
        coords (Coords): 
        key (int): (Value range is 0-64008.)
        chest_slot (int): (Value range is 0-252.)
        item_id (int): (Value range is 0-64008.)
        spawn_time (int): (Value range is 0-64008.)
        amount (int): (Value range is 0-16194276.)
    """
    self._coords = coords
    self._key = key
    self._chest_slot = chest_slot
    self._item_id = item_id
    self._spawn_time = spawn_time
    self._amount = amount

serialize(writer, data) staticmethod

Serializes an instance of MapItem to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapItem	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_item.py

@staticmethod
def serialize(writer: EoWriter, data: "MapItem") -> None:
    """
    Serializes an instance of `MapItem` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapItem): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._coords is None:
            raise SerializationError("coords must be provided.")
        Coords.serialize(writer, data._coords)
        if data._key is None:
            raise SerializationError("key must be provided.")
        writer.add_short(data._key)
        if data._chest_slot is None:
            raise SerializationError("chest_slot must be provided.")
        writer.add_char(data._chest_slot)
        if data._item_id is None:
            raise SerializationError("item_id must be provided.")
        writer.add_short(data._item_id)
        if data._spawn_time is None:
            raise SerializationError("spawn_time must be provided.")
        writer.add_short(data._spawn_time)
        if data._amount is None:
            raise SerializationError("amount must be provided.")
        writer.add_three(data._amount)
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapItem from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapItem	MapItem	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_item.py

@staticmethod
def deserialize(reader: EoReader) -> "MapItem":
    """
    Deserializes an instance of `MapItem` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapItem: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        coords = Coords.deserialize(reader)
        key = reader.get_short()
        chest_slot = reader.get_char()
        item_id = reader.get_short()
        spawn_time = reader.get_short()
        amount = reader.get_three()
        result = MapItem(coords=coords, key=key, chest_slot=chest_slot, item_id=item_id, spawn_time=spawn_time, amount=amount)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

MapGraphicRowTile

A single tile in a row of map graphics

Source code in src/eolib/protocol/_generated/map/map_graphic_row_tile.py

class MapGraphicRowTile:
    """
    A single tile in a row of map graphics
    """
    _byte_size: int = 0
    _x: int
    _graphic: int

    def __init__(self, *, x: int, graphic: int):
        """
        Create a new instance of MapGraphicRowTile.

        Args:
            x (int): (Value range is 0-252.)
            graphic (int): (Value range is 0-64008.)
        """
        self._x = x
        self._graphic = graphic

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def x(self) -> int:
        return self._x

    @property
    def graphic(self) -> int:
        return self._graphic

    @staticmethod
    def serialize(writer: EoWriter, data: "MapGraphicRowTile") -> None:
        """
        Serializes an instance of `MapGraphicRowTile` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapGraphicRowTile): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._x is None:
                raise SerializationError("x must be provided.")
            writer.add_char(data._x)
            if data._graphic is None:
                raise SerializationError("graphic must be provided.")
            writer.add_short(data._graphic)
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapGraphicRowTile":
        """
        Deserializes an instance of `MapGraphicRowTile` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapGraphicRowTile: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            x = reader.get_char()
            graphic = reader.get_short()
            result = MapGraphicRowTile(x=x, graphic=graphic)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapGraphicRowTile(byte_size={repr(self._byte_size)}, x={repr(self._x)}, graphic={repr(self._graphic)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

x: int property

graphic: int property

__init__(*, x, graphic)

Create a new instance of MapGraphicRowTile.

Parameters:

Name	Type	Description	Default
x	int	(Value range is 0-252.)	required
graphic	int	(Value range is 0-64008.)	required

Source code in src/eolib/protocol/_generated/map/map_graphic_row_tile.py

def __init__(self, *, x: int, graphic: int):
    """
    Create a new instance of MapGraphicRowTile.

    Args:
        x (int): (Value range is 0-252.)
        graphic (int): (Value range is 0-64008.)
    """
    self._x = x
    self._graphic = graphic

serialize(writer, data) staticmethod

Serializes an instance of MapGraphicRowTile to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapGraphicRowTile	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_graphic_row_tile.py

@staticmethod
def serialize(writer: EoWriter, data: "MapGraphicRowTile") -> None:
    """
    Serializes an instance of `MapGraphicRowTile` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapGraphicRowTile): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._x is None:
            raise SerializationError("x must be provided.")
        writer.add_char(data._x)
        if data._graphic is None:
            raise SerializationError("graphic must be provided.")
        writer.add_short(data._graphic)
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapGraphicRowTile from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapGraphicRowTile	MapGraphicRowTile	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_graphic_row_tile.py

@staticmethod
def deserialize(reader: EoReader) -> "MapGraphicRowTile":
    """
    Deserializes an instance of `MapGraphicRowTile` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapGraphicRowTile: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        x = reader.get_char()
        graphic = reader.get_short()
        result = MapGraphicRowTile(x=x, graphic=graphic)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

MapGraphicRow

A row in a layer of map graphics

Source code in src/eolib/protocol/_generated/map/map_graphic_row.py

class MapGraphicRow:
    """
    A row in a layer of map graphics
    """
    _byte_size: int = 0
    _y: int
    _tiles_count: int
    _tiles: tuple[MapGraphicRowTile, ...]

    def __init__(self, *, y: int, tiles: Iterable[MapGraphicRowTile]):
        """
        Create a new instance of MapGraphicRow.

        Args:
            y (int): (Value range is 0-252.)
            tiles (Iterable[MapGraphicRowTile]): (Length must be 252 or less.)
        """
        self._y = y
        self._tiles = tuple(tiles)
        self._tiles_count = len(self._tiles)

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def y(self) -> int:
        return self._y

    @property
    def tiles(self) -> tuple[MapGraphicRowTile, ...]:
        return self._tiles

    @staticmethod
    def serialize(writer: EoWriter, data: "MapGraphicRow") -> None:
        """
        Serializes an instance of `MapGraphicRow` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapGraphicRow): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._y is None:
                raise SerializationError("y must be provided.")
            writer.add_char(data._y)
            if data._tiles_count is None:
                raise SerializationError("tiles_count must be provided.")
            writer.add_char(data._tiles_count)
            if data._tiles is None:
                raise SerializationError("tiles must be provided.")
            if len(data._tiles) > 252:
                raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
            for i in range(data._tiles_count):
                MapGraphicRowTile.serialize(writer, data._tiles[i])
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapGraphicRow":
        """
        Deserializes an instance of `MapGraphicRow` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapGraphicRow: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            y = reader.get_char()
            tiles_count = reader.get_char()
            tiles = []
            for i in range(tiles_count):
                tiles.append(MapGraphicRowTile.deserialize(reader))
            result = MapGraphicRow(y=y, tiles=tiles)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapGraphicRow(byte_size={repr(self._byte_size)}, y={repr(self._y)}, tiles={repr(self._tiles)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

y: int property

tiles: tuple[MapGraphicRowTile, ...] property

__init__(*, y, tiles)

Create a new instance of MapGraphicRow.

Parameters:

Name	Type	Description	Default
y	int	(Value range is 0-252.)	required
tiles	Iterable[MapGraphicRowTile]	(Length must be 252 or less.)	required

Source code in src/eolib/protocol/_generated/map/map_graphic_row.py

def __init__(self, *, y: int, tiles: Iterable[MapGraphicRowTile]):
    """
    Create a new instance of MapGraphicRow.

    Args:
        y (int): (Value range is 0-252.)
        tiles (Iterable[MapGraphicRowTile]): (Length must be 252 or less.)
    """
    self._y = y
    self._tiles = tuple(tiles)
    self._tiles_count = len(self._tiles)

serialize(writer, data) staticmethod

Serializes an instance of MapGraphicRow to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapGraphicRow	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_graphic_row.py

@staticmethod
def serialize(writer: EoWriter, data: "MapGraphicRow") -> None:
    """
    Serializes an instance of `MapGraphicRow` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapGraphicRow): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._y is None:
            raise SerializationError("y must be provided.")
        writer.add_char(data._y)
        if data._tiles_count is None:
            raise SerializationError("tiles_count must be provided.")
        writer.add_char(data._tiles_count)
        if data._tiles is None:
            raise SerializationError("tiles must be provided.")
        if len(data._tiles) > 252:
            raise SerializationError(f"Expected length of tiles to be 252 or less, got {len(data._tiles)}.")
        for i in range(data._tiles_count):
            MapGraphicRowTile.serialize(writer, data._tiles[i])
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapGraphicRow from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapGraphicRow	'MapGraphicRow'	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_graphic_row.py

@staticmethod
def deserialize(reader: EoReader) -> "MapGraphicRow":
    """
    Deserializes an instance of `MapGraphicRow` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapGraphicRow: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        y = reader.get_char()
        tiles_count = reader.get_char()
        tiles = []
        for i in range(tiles_count):
            tiles.append(MapGraphicRowTile.deserialize(reader))
        result = MapGraphicRow(y=y, tiles=tiles)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

MapGraphicLayer

A layer of map graphics

Source code in src/eolib/protocol/_generated/map/map_graphic_layer.py

class MapGraphicLayer:
    """
    A layer of map graphics
    """
    _byte_size: int = 0
    _graphic_rows_count: int
    _graphic_rows: tuple[MapGraphicRow, ...]

    def __init__(self, *, graphic_rows: Iterable[MapGraphicRow]):
        """
        Create a new instance of MapGraphicLayer.

        Args:
            graphic_rows (Iterable[MapGraphicRow]): (Length must be 252 or less.)
        """
        self._graphic_rows = tuple(graphic_rows)
        self._graphic_rows_count = len(self._graphic_rows)

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def graphic_rows(self) -> tuple[MapGraphicRow, ...]:
        return self._graphic_rows

    @staticmethod
    def serialize(writer: EoWriter, data: "MapGraphicLayer") -> None:
        """
        Serializes an instance of `MapGraphicLayer` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (MapGraphicLayer): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._graphic_rows_count is None:
                raise SerializationError("graphic_rows_count must be provided.")
            writer.add_char(data._graphic_rows_count)
            if data._graphic_rows is None:
                raise SerializationError("graphic_rows must be provided.")
            if len(data._graphic_rows) > 252:
                raise SerializationError(f"Expected length of graphic_rows to be 252 or less, got {len(data._graphic_rows)}.")
            for i in range(data._graphic_rows_count):
                MapGraphicRow.serialize(writer, data._graphic_rows[i])
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "MapGraphicLayer":
        """
        Deserializes an instance of `MapGraphicLayer` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            MapGraphicLayer: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            graphic_rows_count = reader.get_char()
            graphic_rows = []
            for i in range(graphic_rows_count):
                graphic_rows.append(MapGraphicRow.deserialize(reader))
            result = MapGraphicLayer(graphic_rows=graphic_rows)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"MapGraphicLayer(byte_size={repr(self._byte_size)}, graphic_rows={repr(self._graphic_rows)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

graphic_rows: tuple[MapGraphicRow, ...] property

__init__(*, graphic_rows)

Create a new instance of MapGraphicLayer.

Parameters:

Name	Type	Description	Default
graphic_rows	Iterable[MapGraphicRow]	(Length must be 252 or less.)	required

Source code in src/eolib/protocol/_generated/map/map_graphic_layer.py

def __init__(self, *, graphic_rows: Iterable[MapGraphicRow]):
    """
    Create a new instance of MapGraphicLayer.

    Args:
        graphic_rows (Iterable[MapGraphicRow]): (Length must be 252 or less.)
    """
    self._graphic_rows = tuple(graphic_rows)
    self._graphic_rows_count = len(self._graphic_rows)

serialize(writer, data) staticmethod

Serializes an instance of MapGraphicLayer to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	MapGraphicLayer	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/map_graphic_layer.py

@staticmethod
def serialize(writer: EoWriter, data: "MapGraphicLayer") -> None:
    """
    Serializes an instance of `MapGraphicLayer` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (MapGraphicLayer): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._graphic_rows_count is None:
            raise SerializationError("graphic_rows_count must be provided.")
        writer.add_char(data._graphic_rows_count)
        if data._graphic_rows is None:
            raise SerializationError("graphic_rows must be provided.")
        if len(data._graphic_rows) > 252:
            raise SerializationError(f"Expected length of graphic_rows to be 252 or less, got {len(data._graphic_rows)}.")
        for i in range(data._graphic_rows_count):
            MapGraphicRow.serialize(writer, data._graphic_rows[i])
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of MapGraphicLayer from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
MapGraphicLayer	'MapGraphicLayer'	The data to serialize.

Source code in src/eolib/protocol/_generated/map/map_graphic_layer.py

@staticmethod
def deserialize(reader: EoReader) -> "MapGraphicLayer":
    """
    Deserializes an instance of `MapGraphicLayer` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        MapGraphicLayer: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        graphic_rows_count = reader.get_char()
        graphic_rows = []
        for i in range(graphic_rows_count):
            graphic_rows.append(MapGraphicRow.deserialize(reader))
        result = MapGraphicLayer(graphic_rows=graphic_rows)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode

Emf

Endless Map File

Source code in src/eolib/protocol/_generated/map/emf.py

class Emf:
    """
    Endless Map File
    """
    _byte_size: int = 0
    _rid: tuple[int, ...]
    _name: str
    _type: MapType
    _timed_effect: MapTimedEffect
    _music_id: int
    _music_control: MapMusicControl
    _ambient_sound_id: int
    _width: int
    _height: int
    _fill_tile: int
    _map_available: bool
    _can_scroll: bool
    _relog_x: int
    _relog_y: int
    _npcs_count: int
    _npcs: tuple[MapNpc, ...]
    _legacy_door_keys_count: int
    _legacy_door_keys: tuple[MapLegacyDoorKey, ...]
    _items_count: int
    _items: tuple[MapItem, ...]
    _tile_spec_rows_count: int
    _tile_spec_rows: tuple[MapTileSpecRow, ...]
    _warp_rows_count: int
    _warp_rows: tuple[MapWarpRow, ...]
    _graphic_layers: tuple[MapGraphicLayer, ...]
    _signs_count: int
    _signs: tuple[MapSign, ...]

    def __init__(self, *, rid: Iterable[int], name: str, type: MapType, timed_effect: MapTimedEffect, music_id: int, music_control: MapMusicControl, ambient_sound_id: int, width: int, height: int, fill_tile: int, map_available: bool, can_scroll: bool, relog_x: int, relog_y: int, npcs: Iterable[MapNpc], legacy_door_keys: Iterable[MapLegacyDoorKey], items: Iterable[MapItem], tile_spec_rows: Iterable[MapTileSpecRow], warp_rows: Iterable[MapWarpRow], graphic_layers: Iterable[MapGraphicLayer], signs: Iterable[MapSign]):
        """
        Create a new instance of Emf.

        Args:
            rid (Iterable[int]): (Length must be `2`.) (Element value range is 0-64008.)
            name (str): (Length must be `24` or less.)
            type (MapType): 
            timed_effect (MapTimedEffect): 
            music_id (int): (Value range is 0-252.)
            music_control (MapMusicControl): 
            ambient_sound_id (int): (Value range is 0-64008.)
            width (int): (Value range is 0-252.)
            height (int): (Value range is 0-252.)
            fill_tile (int): (Value range is 0-64008.)
            map_available (bool): 
            can_scroll (bool): 
            relog_x (int): (Value range is 0-252.)
            relog_y (int): (Value range is 0-252.)
            npcs (Iterable[MapNpc]): (Length must be 252 or less.)
            legacy_door_keys (Iterable[MapLegacyDoorKey]): (Length must be 252 or less.)
            items (Iterable[MapItem]): (Length must be 252 or less.)
            tile_spec_rows (Iterable[MapTileSpecRow]): (Length must be 252 or less.)
            warp_rows (Iterable[MapWarpRow]): (Length must be 252 or less.)
            graphic_layers (Iterable[MapGraphicLayer]): The 9 layers of map graphics. Order is [Ground, Object, Overlay, Down Wall, Right Wall, Roof, Top, Shadow, Overlay2] (Length must be `9`.)
            signs (Iterable[MapSign]): (Length must be 252 or less.)
        """
        self._rid = tuple(rid)
        self._name = name
        self._type = type
        self._timed_effect = timed_effect
        self._music_id = music_id
        self._music_control = music_control
        self._ambient_sound_id = ambient_sound_id
        self._width = width
        self._height = height
        self._fill_tile = fill_tile
        self._map_available = map_available
        self._can_scroll = can_scroll
        self._relog_x = relog_x
        self._relog_y = relog_y
        self._npcs = tuple(npcs)
        self._npcs_count = len(self._npcs)
        self._legacy_door_keys = tuple(legacy_door_keys)
        self._legacy_door_keys_count = len(self._legacy_door_keys)
        self._items = tuple(items)
        self._items_count = len(self._items)
        self._tile_spec_rows = tuple(tile_spec_rows)
        self._tile_spec_rows_count = len(self._tile_spec_rows)
        self._warp_rows = tuple(warp_rows)
        self._warp_rows_count = len(self._warp_rows)
        self._graphic_layers = tuple(graphic_layers)
        self._signs = tuple(signs)
        self._signs_count = len(self._signs)

    @property
    def byte_size(self) -> int:
        """
        Returns the size of the data that this was deserialized from.

        Returns:
            int: The size of the data that this was deserialized from.
        """
        return self._byte_size

    @property
    def rid(self) -> tuple[int, ...]:
        return self._rid

    @property
    def name(self) -> str:
        return self._name

    @property
    def type(self) -> MapType:
        return self._type

    @property
    def timed_effect(self) -> MapTimedEffect:
        return self._timed_effect

    @property
    def music_id(self) -> int:
        return self._music_id

    @property
    def music_control(self) -> MapMusicControl:
        return self._music_control

    @property
    def ambient_sound_id(self) -> int:
        return self._ambient_sound_id

    @property
    def width(self) -> int:
        return self._width

    @property
    def height(self) -> int:
        return self._height

    @property
    def fill_tile(self) -> int:
        return self._fill_tile

    @property
    def map_available(self) -> bool:
        return self._map_available

    @property
    def can_scroll(self) -> bool:
        return self._can_scroll

    @property
    def relog_x(self) -> int:
        return self._relog_x

    @property
    def relog_y(self) -> int:
        return self._relog_y

    @property
    def npcs(self) -> tuple[MapNpc, ...]:
        return self._npcs

    @property
    def legacy_door_keys(self) -> tuple[MapLegacyDoorKey, ...]:
        return self._legacy_door_keys

    @property
    def items(self) -> tuple[MapItem, ...]:
        return self._items

    @property
    def tile_spec_rows(self) -> tuple[MapTileSpecRow, ...]:
        return self._tile_spec_rows

    @property
    def warp_rows(self) -> tuple[MapWarpRow, ...]:
        return self._warp_rows

    @property
    def graphic_layers(self) -> tuple[MapGraphicLayer, ...]:
        """
        The 9 layers of map graphics.
        Order is [Ground, Object, Overlay, Down Wall, Right Wall, Roof, Top, Shadow, Overlay2]
        """
        return self._graphic_layers

    @property
    def signs(self) -> tuple[MapSign, ...]:
        return self._signs

    @staticmethod
    def serialize(writer: EoWriter, data: "Emf") -> None:
        """
        Serializes an instance of `Emf` to the provided `EoWriter`.

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (Emf): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            writer.add_fixed_string("EMF", 3, False)
            if data._rid is None:
                raise SerializationError("rid must be provided.")
            if len(data._rid) != 2:
                raise SerializationError(f"Expected length of rid to be exactly 2, got {len(data._rid)}.")
            for i in range(2):
                writer.add_short(data._rid[i])
            if data._name is None:
                raise SerializationError("name must be provided.")
            if len(data._name) > 24:
                raise SerializationError(f"Expected length of name to be 24 or less, got {len(data._name)}.")
            writer.add_fixed_encoded_string(data._name, 24, True)
            if data._type is None:
                raise SerializationError("type must be provided.")
            writer.add_char(int(data._type))
            if data._timed_effect is None:
                raise SerializationError("timed_effect must be provided.")
            writer.add_char(int(data._timed_effect))
            if data._music_id is None:
                raise SerializationError("music_id must be provided.")
            writer.add_char(data._music_id)
            if data._music_control is None:
                raise SerializationError("music_control must be provided.")
            writer.add_char(int(data._music_control))
            if data._ambient_sound_id is None:
                raise SerializationError("ambient_sound_id must be provided.")
            writer.add_short(data._ambient_sound_id)
            if data._width is None:
                raise SerializationError("width must be provided.")
            writer.add_char(data._width)
            if data._height is None:
                raise SerializationError("height must be provided.")
            writer.add_char(data._height)
            if data._fill_tile is None:
                raise SerializationError("fill_tile must be provided.")
            writer.add_short(data._fill_tile)
            if data._map_available is None:
                raise SerializationError("map_available must be provided.")
            writer.add_char(1 if data._map_available else 0)
            if data._can_scroll is None:
                raise SerializationError("can_scroll must be provided.")
            writer.add_char(1 if data._can_scroll else 0)
            if data._relog_x is None:
                raise SerializationError("relog_x must be provided.")
            writer.add_char(data._relog_x)
            if data._relog_y is None:
                raise SerializationError("relog_y must be provided.")
            writer.add_char(data._relog_y)
            writer.add_char(0)
            if data._npcs_count is None:
                raise SerializationError("npcs_count must be provided.")
            writer.add_char(data._npcs_count)
            if data._npcs is None:
                raise SerializationError("npcs must be provided.")
            if len(data._npcs) > 252:
                raise SerializationError(f"Expected length of npcs to be 252 or less, got {len(data._npcs)}.")
            for i in range(data._npcs_count):
                MapNpc.serialize(writer, data._npcs[i])
            if data._legacy_door_keys_count is None:
                raise SerializationError("legacy_door_keys_count must be provided.")
            writer.add_char(data._legacy_door_keys_count)
            if data._legacy_door_keys is None:
                raise SerializationError("legacy_door_keys must be provided.")
            if len(data._legacy_door_keys) > 252:
                raise SerializationError(f"Expected length of legacy_door_keys to be 252 or less, got {len(data._legacy_door_keys)}.")
            for i in range(data._legacy_door_keys_count):
                MapLegacyDoorKey.serialize(writer, data._legacy_door_keys[i])
            if data._items_count is None:
                raise SerializationError("items_count must be provided.")
            writer.add_char(data._items_count)
            if data._items is None:
                raise SerializationError("items must be provided.")
            if len(data._items) > 252:
                raise SerializationError(f"Expected length of items to be 252 or less, got {len(data._items)}.")
            for i in range(data._items_count):
                MapItem.serialize(writer, data._items[i])
            if data._tile_spec_rows_count is None:
                raise SerializationError("tile_spec_rows_count must be provided.")
            writer.add_char(data._tile_spec_rows_count)
            if data._tile_spec_rows is None:
                raise SerializationError("tile_spec_rows must be provided.")
            if len(data._tile_spec_rows) > 252:
                raise SerializationError(f"Expected length of tile_spec_rows to be 252 or less, got {len(data._tile_spec_rows)}.")
            for i in range(data._tile_spec_rows_count):
                MapTileSpecRow.serialize(writer, data._tile_spec_rows[i])
            if data._warp_rows_count is None:
                raise SerializationError("warp_rows_count must be provided.")
            writer.add_char(data._warp_rows_count)
            if data._warp_rows is None:
                raise SerializationError("warp_rows must be provided.")
            if len(data._warp_rows) > 252:
                raise SerializationError(f"Expected length of warp_rows to be 252 or less, got {len(data._warp_rows)}.")
            for i in range(data._warp_rows_count):
                MapWarpRow.serialize(writer, data._warp_rows[i])
            if data._graphic_layers is None:
                raise SerializationError("graphic_layers must be provided.")
            if len(data._graphic_layers) != 9:
                raise SerializationError(f"Expected length of graphic_layers to be exactly 9, got {len(data._graphic_layers)}.")
            for i in range(9):
                MapGraphicLayer.serialize(writer, data._graphic_layers[i])
            if data._signs_count is None:
                raise SerializationError("signs_count must be provided.")
            writer.add_char(data._signs_count)
            if data._signs is None:
                raise SerializationError("signs must be provided.")
            if len(data._signs) > 252:
                raise SerializationError(f"Expected length of signs to be 252 or less, got {len(data._signs)}.")
            for i in range(data._signs_count):
                MapSign.serialize(writer, data._signs[i])
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

    @staticmethod
    def deserialize(reader: EoReader) -> "Emf":
        """
        Deserializes an instance of `Emf` from the provided `EoReader`.

        Args:
            reader (EoReader): The writer that the data will be serialized to.

        Returns:
            Emf: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            reader.get_fixed_string(3, False)
            rid = []
            for i in range(2):
                rid.append(reader.get_short())
            name = reader.get_fixed_encoded_string(24, True)
            type = MapType(reader.get_char())
            timed_effect = MapTimedEffect(reader.get_char())
            music_id = reader.get_char()
            music_control = MapMusicControl(reader.get_char())
            ambient_sound_id = reader.get_short()
            width = reader.get_char()
            height = reader.get_char()
            fill_tile = reader.get_short()
            map_available = reader.get_char() != 0
            can_scroll = reader.get_char() != 0
            relog_x = reader.get_char()
            relog_y = reader.get_char()
            reader.get_char()
            npcs_count = reader.get_char()
            npcs = []
            for i in range(npcs_count):
                npcs.append(MapNpc.deserialize(reader))
            legacy_door_keys_count = reader.get_char()
            legacy_door_keys = []
            for i in range(legacy_door_keys_count):
                legacy_door_keys.append(MapLegacyDoorKey.deserialize(reader))
            items_count = reader.get_char()
            items = []
            for i in range(items_count):
                items.append(MapItem.deserialize(reader))
            tile_spec_rows_count = reader.get_char()
            tile_spec_rows = []
            for i in range(tile_spec_rows_count):
                tile_spec_rows.append(MapTileSpecRow.deserialize(reader))
            warp_rows_count = reader.get_char()
            warp_rows = []
            for i in range(warp_rows_count):
                warp_rows.append(MapWarpRow.deserialize(reader))
            graphic_layers = []
            for i in range(9):
                graphic_layers.append(MapGraphicLayer.deserialize(reader))
            signs_count = reader.get_char()
            signs = []
            for i in range(signs_count):
                signs.append(MapSign.deserialize(reader))
            result = Emf(rid=rid, name=name, type=type, timed_effect=timed_effect, music_id=music_id, music_control=music_control, ambient_sound_id=ambient_sound_id, width=width, height=height, fill_tile=fill_tile, map_available=map_available, can_scroll=can_scroll, relog_x=relog_x, relog_y=relog_y, npcs=npcs, legacy_door_keys=legacy_door_keys, items=items, tile_spec_rows=tile_spec_rows, warp_rows=warp_rows, graphic_layers=graphic_layers, signs=signs)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"Emf(byte_size={repr(self._byte_size)}, rid={repr(self._rid)}, name={repr(self._name)}, type={repr(self._type)}, timed_effect={repr(self._timed_effect)}, music_id={repr(self._music_id)}, music_control={repr(self._music_control)}, ambient_sound_id={repr(self._ambient_sound_id)}, width={repr(self._width)}, height={repr(self._height)}, fill_tile={repr(self._fill_tile)}, map_available={repr(self._map_available)}, can_scroll={repr(self._can_scroll)}, relog_x={repr(self._relog_x)}, relog_y={repr(self._relog_y)}, npcs={repr(self._npcs)}, legacy_door_keys={repr(self._legacy_door_keys)}, items={repr(self._items)}, tile_spec_rows={repr(self._tile_spec_rows)}, warp_rows={repr(self._warp_rows)}, graphic_layers={repr(self._graphic_layers)}, signs={repr(self._signs)})"

byte_size: int property

Returns the size of the data that this was deserialized from.

Returns:

Name	Type	Description
int	int	The size of the data that this was deserialized from.

rid: tuple[int, ...] property

name: str property

type: MapType property

timed_effect: MapTimedEffect property

music_id: int property

music_control: MapMusicControl property

ambient_sound_id: int property

width: int property

height: int property

fill_tile: int property

map_available: bool property

can_scroll: bool property

relog_x: int property

relog_y: int property

npcs: tuple[MapNpc, ...] property

legacy_door_keys: tuple[MapLegacyDoorKey, ...] property

items: tuple[MapItem, ...] property

tile_spec_rows: tuple[MapTileSpecRow, ...] property

warp_rows: tuple[MapWarpRow, ...] property

graphic_layers: tuple[MapGraphicLayer, ...] property

The 9 layers of map graphics. Order is [Ground, Object, Overlay, Down Wall, Right Wall, Roof, Top, Shadow, Overlay2]

signs: tuple[MapSign, ...] property

__init__(*, rid, name, type, timed_effect, music_id, music_control, ambient_sound_id, width, height, fill_tile, map_available, can_scroll, relog_x, relog_y, npcs, legacy_door_keys, items, tile_spec_rows, warp_rows, graphic_layers, signs)

Create a new instance of Emf.

Parameters:

Name	Type	Description	Default
rid	Iterable[int]	(Length must be 2.) (Element value range is 0-64008.)	required
name	str	(Length must be 24 or less.)	required
type	MapType		required
timed_effect	MapTimedEffect		required
music_id	int	(Value range is 0-252.)	required
music_control	MapMusicControl		required
ambient_sound_id	int	(Value range is 0-64008.)	required
width	int	(Value range is 0-252.)	required
height	int	(Value range is 0-252.)	required
fill_tile	int	(Value range is 0-64008.)	required
map_available	bool		required
can_scroll	bool		required
relog_x	int	(Value range is 0-252.)	required
relog_y	int	(Value range is 0-252.)	required
npcs	Iterable[MapNpc]	(Length must be 252 or less.)	required
legacy_door_keys	Iterable[MapLegacyDoorKey]	(Length must be 252 or less.)	required
items	Iterable[MapItem]	(Length must be 252 or less.)	required
tile_spec_rows	Iterable[MapTileSpecRow]	(Length must be 252 or less.)	required
warp_rows	Iterable[MapWarpRow]	(Length must be 252 or less.)	required
graphic_layers	Iterable[MapGraphicLayer]	The 9 layers of map graphics. Order is [Ground, Object, Overlay, Down Wall, Right Wall, Roof, Top, Shadow, Overlay2] (Length must be 9.)	required
signs	Iterable[MapSign]	(Length must be 252 or less.)	required

Source code in src/eolib/protocol/_generated/map/emf.py

def __init__(self, *, rid: Iterable[int], name: str, type: MapType, timed_effect: MapTimedEffect, music_id: int, music_control: MapMusicControl, ambient_sound_id: int, width: int, height: int, fill_tile: int, map_available: bool, can_scroll: bool, relog_x: int, relog_y: int, npcs: Iterable[MapNpc], legacy_door_keys: Iterable[MapLegacyDoorKey], items: Iterable[MapItem], tile_spec_rows: Iterable[MapTileSpecRow], warp_rows: Iterable[MapWarpRow], graphic_layers: Iterable[MapGraphicLayer], signs: Iterable[MapSign]):
    """
    Create a new instance of Emf.

    Args:
        rid (Iterable[int]): (Length must be `2`.) (Element value range is 0-64008.)
        name (str): (Length must be `24` or less.)
        type (MapType): 
        timed_effect (MapTimedEffect): 
        music_id (int): (Value range is 0-252.)
        music_control (MapMusicControl): 
        ambient_sound_id (int): (Value range is 0-64008.)
        width (int): (Value range is 0-252.)
        height (int): (Value range is 0-252.)
        fill_tile (int): (Value range is 0-64008.)
        map_available (bool): 
        can_scroll (bool): 
        relog_x (int): (Value range is 0-252.)
        relog_y (int): (Value range is 0-252.)
        npcs (Iterable[MapNpc]): (Length must be 252 or less.)
        legacy_door_keys (Iterable[MapLegacyDoorKey]): (Length must be 252 or less.)
        items (Iterable[MapItem]): (Length must be 252 or less.)
        tile_spec_rows (Iterable[MapTileSpecRow]): (Length must be 252 or less.)
        warp_rows (Iterable[MapWarpRow]): (Length must be 252 or less.)
        graphic_layers (Iterable[MapGraphicLayer]): The 9 layers of map graphics. Order is [Ground, Object, Overlay, Down Wall, Right Wall, Roof, Top, Shadow, Overlay2] (Length must be `9`.)
        signs (Iterable[MapSign]): (Length must be 252 or less.)
    """
    self._rid = tuple(rid)
    self._name = name
    self._type = type
    self._timed_effect = timed_effect
    self._music_id = music_id
    self._music_control = music_control
    self._ambient_sound_id = ambient_sound_id
    self._width = width
    self._height = height
    self._fill_tile = fill_tile
    self._map_available = map_available
    self._can_scroll = can_scroll
    self._relog_x = relog_x
    self._relog_y = relog_y
    self._npcs = tuple(npcs)
    self._npcs_count = len(self._npcs)
    self._legacy_door_keys = tuple(legacy_door_keys)
    self._legacy_door_keys_count = len(self._legacy_door_keys)
    self._items = tuple(items)
    self._items_count = len(self._items)
    self._tile_spec_rows = tuple(tile_spec_rows)
    self._tile_spec_rows_count = len(self._tile_spec_rows)
    self._warp_rows = tuple(warp_rows)
    self._warp_rows_count = len(self._warp_rows)
    self._graphic_layers = tuple(graphic_layers)
    self._signs = tuple(signs)
    self._signs_count = len(self._signs)

serialize(writer, data) staticmethod

Serializes an instance of Emf to the provided EoWriter.

Parameters:

Name	Type	Description	Default
writer	EoWriter	The writer that the data will be serialized to.	required
data	Emf	The data to serialize.	required

Source code in src/eolib/protocol/_generated/map/emf.py

@staticmethod
def serialize(writer: EoWriter, data: "Emf") -> None:
    """
    Serializes an instance of `Emf` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (Emf): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        writer.add_fixed_string("EMF", 3, False)
        if data._rid is None:
            raise SerializationError("rid must be provided.")
        if len(data._rid) != 2:
            raise SerializationError(f"Expected length of rid to be exactly 2, got {len(data._rid)}.")
        for i in range(2):
            writer.add_short(data._rid[i])
        if data._name is None:
            raise SerializationError("name must be provided.")
        if len(data._name) > 24:
            raise SerializationError(f"Expected length of name to be 24 or less, got {len(data._name)}.")
        writer.add_fixed_encoded_string(data._name, 24, True)
        if data._type is None:
            raise SerializationError("type must be provided.")
        writer.add_char(int(data._type))
        if data._timed_effect is None:
            raise SerializationError("timed_effect must be provided.")
        writer.add_char(int(data._timed_effect))
        if data._music_id is None:
            raise SerializationError("music_id must be provided.")
        writer.add_char(data._music_id)
        if data._music_control is None:
            raise SerializationError("music_control must be provided.")
        writer.add_char(int(data._music_control))
        if data._ambient_sound_id is None:
            raise SerializationError("ambient_sound_id must be provided.")
        writer.add_short(data._ambient_sound_id)
        if data._width is None:
            raise SerializationError("width must be provided.")
        writer.add_char(data._width)
        if data._height is None:
            raise SerializationError("height must be provided.")
        writer.add_char(data._height)
        if data._fill_tile is None:
            raise SerializationError("fill_tile must be provided.")
        writer.add_short(data._fill_tile)
        if data._map_available is None:
            raise SerializationError("map_available must be provided.")
        writer.add_char(1 if data._map_available else 0)
        if data._can_scroll is None:
            raise SerializationError("can_scroll must be provided.")
        writer.add_char(1 if data._can_scroll else 0)
        if data._relog_x is None:
            raise SerializationError("relog_x must be provided.")
        writer.add_char(data._relog_x)
        if data._relog_y is None:
            raise SerializationError("relog_y must be provided.")
        writer.add_char(data._relog_y)
        writer.add_char(0)
        if data._npcs_count is None:
            raise SerializationError("npcs_count must be provided.")
        writer.add_char(data._npcs_count)
        if data._npcs is None:
            raise SerializationError("npcs must be provided.")
        if len(data._npcs) > 252:
            raise SerializationError(f"Expected length of npcs to be 252 or less, got {len(data._npcs)}.")
        for i in range(data._npcs_count):
            MapNpc.serialize(writer, data._npcs[i])
        if data._legacy_door_keys_count is None:
            raise SerializationError("legacy_door_keys_count must be provided.")
        writer.add_char(data._legacy_door_keys_count)
        if data._legacy_door_keys is None:
            raise SerializationError("legacy_door_keys must be provided.")
        if len(data._legacy_door_keys) > 252:
            raise SerializationError(f"Expected length of legacy_door_keys to be 252 or less, got {len(data._legacy_door_keys)}.")
        for i in range(data._legacy_door_keys_count):
            MapLegacyDoorKey.serialize(writer, data._legacy_door_keys[i])
        if data._items_count is None:
            raise SerializationError("items_count must be provided.")
        writer.add_char(data._items_count)
        if data._items is None:
            raise SerializationError("items must be provided.")
        if len(data._items) > 252:
            raise SerializationError(f"Expected length of items to be 252 or less, got {len(data._items)}.")
        for i in range(data._items_count):
            MapItem.serialize(writer, data._items[i])
        if data._tile_spec_rows_count is None:
            raise SerializationError("tile_spec_rows_count must be provided.")
        writer.add_char(data._tile_spec_rows_count)
        if data._tile_spec_rows is None:
            raise SerializationError("tile_spec_rows must be provided.")
        if len(data._tile_spec_rows) > 252:
            raise SerializationError(f"Expected length of tile_spec_rows to be 252 or less, got {len(data._tile_spec_rows)}.")
        for i in range(data._tile_spec_rows_count):
            MapTileSpecRow.serialize(writer, data._tile_spec_rows[i])
        if data._warp_rows_count is None:
            raise SerializationError("warp_rows_count must be provided.")
        writer.add_char(data._warp_rows_count)
        if data._warp_rows is None:
            raise SerializationError("warp_rows must be provided.")
        if len(data._warp_rows) > 252:
            raise SerializationError(f"Expected length of warp_rows to be 252 or less, got {len(data._warp_rows)}.")
        for i in range(data._warp_rows_count):
            MapWarpRow.serialize(writer, data._warp_rows[i])
        if data._graphic_layers is None:
            raise SerializationError("graphic_layers must be provided.")
        if len(data._graphic_layers) != 9:
            raise SerializationError(f"Expected length of graphic_layers to be exactly 9, got {len(data._graphic_layers)}.")
        for i in range(9):
            MapGraphicLayer.serialize(writer, data._graphic_layers[i])
        if data._signs_count is None:
            raise SerializationError("signs_count must be provided.")
        writer.add_char(data._signs_count)
        if data._signs is None:
            raise SerializationError("signs must be provided.")
        if len(data._signs) > 252:
            raise SerializationError(f"Expected length of signs to be 252 or less, got {len(data._signs)}.")
        for i in range(data._signs_count):
            MapSign.serialize(writer, data._signs[i])
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of Emf from the provided EoReader.

Parameters:

Name	Type	Description	Default
reader	EoReader	The writer that the data will be serialized to.	required

Returns:

Name	Type	Description
Emf	'Emf'	The data to serialize.

Source code in src/eolib/protocol/_generated/map/emf.py

@staticmethod
def deserialize(reader: EoReader) -> "Emf":
    """
    Deserializes an instance of `Emf` from the provided `EoReader`.

    Args:
        reader (EoReader): The writer that the data will be serialized to.

    Returns:
        Emf: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        reader.get_fixed_string(3, False)
        rid = []
        for i in range(2):
            rid.append(reader.get_short())
        name = reader.get_fixed_encoded_string(24, True)
        type = MapType(reader.get_char())
        timed_effect = MapTimedEffect(reader.get_char())
        music_id = reader.get_char()
        music_control = MapMusicControl(reader.get_char())
        ambient_sound_id = reader.get_short()
        width = reader.get_char()
        height = reader.get_char()
        fill_tile = reader.get_short()
        map_available = reader.get_char() != 0
        can_scroll = reader.get_char() != 0
        relog_x = reader.get_char()
        relog_y = reader.get_char()
        reader.get_char()
        npcs_count = reader.get_char()
        npcs = []
        for i in range(npcs_count):
            npcs.append(MapNpc.deserialize(reader))
        legacy_door_keys_count = reader.get_char()
        legacy_door_keys = []
        for i in range(legacy_door_keys_count):
            legacy_door_keys.append(MapLegacyDoorKey.deserialize(reader))
        items_count = reader.get_char()
        items = []
        for i in range(items_count):
            items.append(MapItem.deserialize(reader))
        tile_spec_rows_count = reader.get_char()
        tile_spec_rows = []
        for i in range(tile_spec_rows_count):
            tile_spec_rows.append(MapTileSpecRow.deserialize(reader))
        warp_rows_count = reader.get_char()
        warp_rows = []
        for i in range(warp_rows_count):
            warp_rows.append(MapWarpRow.deserialize(reader))
        graphic_layers = []
        for i in range(9):
            graphic_layers.append(MapGraphicLayer.deserialize(reader))
        signs_count = reader.get_char()
        signs = []
        for i in range(signs_count):
            signs.append(MapSign.deserialize(reader))
        result = Emf(rid=rid, name=name, type=type, timed_effect=timed_effect, music_id=music_id, music_control=music_control, ambient_sound_id=ambient_sound_id, width=width, height=height, fill_tile=fill_tile, map_available=map_available, can_scroll=can_scroll, relog_x=relog_x, relog_y=relog_y, npcs=npcs, legacy_door_keys=legacy_door_keys, items=items, tile_spec_rows=tile_spec_rows, warp_rows=warp_rows, graphic_layers=graphic_layers, signs=signs)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode