Skip to content

inn_record

InnRecord

Record of Inn data in an Endless Inn File

Source code in src/eolib/protocol/_generated/pub/server/inn_record.py 
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
class InnRecord:
    """
    Record of Inn data in an Endless Inn File
    """
    _byte_size: int = 0
    _behavior_id: int
    _name_length: int
    _name: str
    _spawn_map: int
    _spawn_x: int
    _spawn_y: int
    _sleep_map: int
    _sleep_x: int
    _sleep_y: int
    _alternate_spawn_enabled: bool
    _alternate_spawn_map: int
    _alternate_spawn_x: int
    _alternate_spawn_y: int
    _questions: tuple[InnQuestionRecord, ...]

    def __init__(self, *, behavior_id: int, name: str, spawn_map: int, spawn_x: int, spawn_y: int, sleep_map: int, sleep_x: int, sleep_y: int, alternate_spawn_enabled: bool, alternate_spawn_map: int, alternate_spawn_x: int, alternate_spawn_y: int, questions: Iterable[InnQuestionRecord]):
        """
        Create a new instance of InnRecord.

        Args:
            behavior_id (int): Behavior ID of the NPC that runs the inn. 0 for default inn (Value range is 0-64008.)
            name (str): (Length must be 252 or less.)
            spawn_map (int): ID of the map the player is sent to after respawning (Value range is 0-64008.)
            spawn_x (int): X coordinate of the map the player is sent to after respawning (Value range is 0-252.)
            spawn_y (int): Y coordinate of the map the player is sent to after respawning (Value range is 0-252.)
            sleep_map (int): ID of the map the player is sent to after sleeping at the inn (Value range is 0-64008.)
            sleep_x (int): X coordinate of the map the player is sent to after sleeping at the inn (Value range is 0-252.)
            sleep_y (int): Y coordinate of the map the player is sent to after sleeping at the inn (Value range is 0-252.)
            alternate_spawn_enabled (bool): Flag for an alternate spawn point. If true, the server will use this alternate spawn map, x, and, y based on some other condition.  In the official server, this is used to respawn new characters on the noob island until they reach a certain level.
            alternate_spawn_map (int): (Value range is 0-64008.)
            alternate_spawn_x (int): (Value range is 0-252.)
            alternate_spawn_y (int): (Value range is 0-252.)
            questions (Iterable[InnQuestionRecord]): (Length must be `3`.)
        """
        self._behavior_id = behavior_id
        self._name = name
        self._name_length = len(self._name)
        self._spawn_map = spawn_map
        self._spawn_x = spawn_x
        self._spawn_y = spawn_y
        self._sleep_map = sleep_map
        self._sleep_x = sleep_x
        self._sleep_y = sleep_y
        self._alternate_spawn_enabled = alternate_spawn_enabled
        self._alternate_spawn_map = alternate_spawn_map
        self._alternate_spawn_x = alternate_spawn_x
        self._alternate_spawn_y = alternate_spawn_y
        self._questions = tuple(questions)

    @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 behavior_id(self) -> int:
        """
        Behavior ID of the NPC that runs the inn. 0 for default inn
        """
        return self._behavior_id

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

    @property
    def spawn_map(self) -> int:
        """
        ID of the map the player is sent to after respawning
        """
        return self._spawn_map

    @property
    def spawn_x(self) -> int:
        """
        X coordinate of the map the player is sent to after respawning
        """
        return self._spawn_x

    @property
    def spawn_y(self) -> int:
        """
        Y coordinate of the map the player is sent to after respawning
        """
        return self._spawn_y

    @property
    def sleep_map(self) -> int:
        """
        ID of the map the player is sent to after sleeping at the inn
        """
        return self._sleep_map

    @property
    def sleep_x(self) -> int:
        """
        X coordinate of the map the player is sent to after sleeping at the inn
        """
        return self._sleep_x

    @property
    def sleep_y(self) -> int:
        """
        Y coordinate of the map the player is sent to after sleeping at the inn
        """
        return self._sleep_y

    @property
    def alternate_spawn_enabled(self) -> bool:
        """
        Flag for an alternate spawn point. If true, the server will use this alternate spawn
        map, x, and, y based on some other condition.

        In the official server, this is used to respawn new characters on the noob island
        until they reach a certain level.
        """
        return self._alternate_spawn_enabled

    @property
    def alternate_spawn_map(self) -> int:
        return self._alternate_spawn_map

    @property
    def alternate_spawn_x(self) -> int:
        return self._alternate_spawn_x

    @property
    def alternate_spawn_y(self) -> int:
        return self._alternate_spawn_y

    @property
    def questions(self) -> tuple[InnQuestionRecord, ...]:
        return self._questions

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

        Args:
            writer (EoWriter): The writer that the data will be serialized to.
            data (InnRecord): The data to serialize.
        """
        old_string_sanitization_mode: bool = writer.string_sanitization_mode
        try:
            if data._behavior_id is None:
                raise SerializationError("behavior_id must be provided.")
            writer.add_short(data._behavior_id)
            if data._name_length is None:
                raise SerializationError("name_length must be provided.")
            writer.add_char(data._name_length)
            if data._name is None:
                raise SerializationError("name must be provided.")
            if len(data._name) > 252:
                raise SerializationError(f"Expected length of name to be 252 or less, got {len(data._name)}.")
            writer.add_fixed_string(data._name, data._name_length, False)
            if data._spawn_map is None:
                raise SerializationError("spawn_map must be provided.")
            writer.add_short(data._spawn_map)
            if data._spawn_x is None:
                raise SerializationError("spawn_x must be provided.")
            writer.add_char(data._spawn_x)
            if data._spawn_y is None:
                raise SerializationError("spawn_y must be provided.")
            writer.add_char(data._spawn_y)
            if data._sleep_map is None:
                raise SerializationError("sleep_map must be provided.")
            writer.add_short(data._sleep_map)
            if data._sleep_x is None:
                raise SerializationError("sleep_x must be provided.")
            writer.add_char(data._sleep_x)
            if data._sleep_y is None:
                raise SerializationError("sleep_y must be provided.")
            writer.add_char(data._sleep_y)
            if data._alternate_spawn_enabled is None:
                raise SerializationError("alternate_spawn_enabled must be provided.")
            writer.add_char(1 if data._alternate_spawn_enabled else 0)
            if data._alternate_spawn_map is None:
                raise SerializationError("alternate_spawn_map must be provided.")
            writer.add_short(data._alternate_spawn_map)
            if data._alternate_spawn_x is None:
                raise SerializationError("alternate_spawn_x must be provided.")
            writer.add_char(data._alternate_spawn_x)
            if data._alternate_spawn_y is None:
                raise SerializationError("alternate_spawn_y must be provided.")
            writer.add_char(data._alternate_spawn_y)
            if data._questions is None:
                raise SerializationError("questions must be provided.")
            if len(data._questions) != 3:
                raise SerializationError(f"Expected length of questions to be exactly 3, got {len(data._questions)}.")
            for i in range(3):
                InnQuestionRecord.serialize(writer, data._questions[i])
        finally:
            writer.string_sanitization_mode = old_string_sanitization_mode

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

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

        Returns:
            InnRecord: The data to serialize.
        """
        old_chunked_reading_mode: bool = reader.chunked_reading_mode
        try:
            reader_start_position: int = reader.position
            behavior_id = reader.get_short()
            name_length = reader.get_char()
            name = reader.get_fixed_string(name_length, False)
            spawn_map = reader.get_short()
            spawn_x = reader.get_char()
            spawn_y = reader.get_char()
            sleep_map = reader.get_short()
            sleep_x = reader.get_char()
            sleep_y = reader.get_char()
            alternate_spawn_enabled = reader.get_char() != 0
            alternate_spawn_map = reader.get_short()
            alternate_spawn_x = reader.get_char()
            alternate_spawn_y = reader.get_char()
            questions = []
            for i in range(3):
                questions.append(InnQuestionRecord.deserialize(reader))
            result = InnRecord(behavior_id=behavior_id, name=name, spawn_map=spawn_map, spawn_x=spawn_x, spawn_y=spawn_y, sleep_map=sleep_map, sleep_x=sleep_x, sleep_y=sleep_y, alternate_spawn_enabled=alternate_spawn_enabled, alternate_spawn_map=alternate_spawn_map, alternate_spawn_x=alternate_spawn_x, alternate_spawn_y=alternate_spawn_y, questions=questions)
            result._byte_size = reader.position - reader_start_position
            return result
        finally:
            reader.chunked_reading_mode = old_chunked_reading_mode

    def __repr__(self):
        return f"InnRecord(byte_size={repr(self._byte_size)}, behavior_id={repr(self._behavior_id)}, name={repr(self._name)}, spawn_map={repr(self._spawn_map)}, spawn_x={repr(self._spawn_x)}, spawn_y={repr(self._spawn_y)}, sleep_map={repr(self._sleep_map)}, sleep_x={repr(self._sleep_x)}, sleep_y={repr(self._sleep_y)}, alternate_spawn_enabled={repr(self._alternate_spawn_enabled)}, alternate_spawn_map={repr(self._alternate_spawn_map)}, alternate_spawn_x={repr(self._alternate_spawn_x)}, alternate_spawn_y={repr(self._alternate_spawn_y)}, questions={repr(self._questions)})"

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.

behavior_id: int property

Behavior ID of the NPC that runs the inn. 0 for default inn

name: str property

spawn_map: int property

ID of the map the player is sent to after respawning

spawn_x: int property

X coordinate of the map the player is sent to after respawning

spawn_y: int property

Y coordinate of the map the player is sent to after respawning

sleep_map: int property

ID of the map the player is sent to after sleeping at the inn

sleep_x: int property

X coordinate of the map the player is sent to after sleeping at the inn

sleep_y: int property

Y coordinate of the map the player is sent to after sleeping at the inn

alternate_spawn_enabled: bool property

Flag for an alternate spawn point. If true, the server will use this alternate spawn map, x, and, y based on some other condition.

In the official server, this is used to respawn new characters on the noob island until they reach a certain level.

alternate_spawn_map: int property

alternate_spawn_x: int property

alternate_spawn_y: int property

questions: tuple[InnQuestionRecord, ...] property

__init__(*, behavior_id, name, spawn_map, spawn_x, spawn_y, sleep_map, sleep_x, sleep_y, alternate_spawn_enabled, alternate_spawn_map, alternate_spawn_x, alternate_spawn_y, questions)

Create a new instance of InnRecord.

Parameters:

Name Type Description Default
behavior_id int

Behavior ID of the NPC that runs the inn. 0 for default inn (Value range is 0-64008.)

 required
name str

(Length must be 252 or less.)

 required
spawn_map int

ID of the map the player is sent to after respawning (Value range is 0-64008.)

 required
spawn_x int

X coordinate of the map the player is sent to after respawning (Value range is 0-252.)

 required
spawn_y int

Y coordinate of the map the player is sent to after respawning (Value range is 0-252.)

 required
sleep_map int

ID of the map the player is sent to after sleeping at the inn (Value range is 0-64008.)

 required
sleep_x int

X coordinate of the map the player is sent to after sleeping at the inn (Value range is 0-252.)

 required
sleep_y int

Y coordinate of the map the player is sent to after sleeping at the inn (Value range is 0-252.)

 required
alternate_spawn_enabled bool

Flag for an alternate spawn point. If true, the server will use this alternate spawn map, x, and, y based on some other condition. In the official server, this is used to respawn new characters on the noob island until they reach a certain level.

 required
alternate_spawn_map int

(Value range is 0-64008.)

 required
alternate_spawn_x int

(Value range is 0-252.)

 required
alternate_spawn_y int

(Value range is 0-252.)

 required
questions Iterable[InnQuestionRecord]

(Length must be 3.)

 required
Source code in src/eolib/protocol/_generated/pub/server/inn_record.py 
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def __init__(self, *, behavior_id: int, name: str, spawn_map: int, spawn_x: int, spawn_y: int, sleep_map: int, sleep_x: int, sleep_y: int, alternate_spawn_enabled: bool, alternate_spawn_map: int, alternate_spawn_x: int, alternate_spawn_y: int, questions: Iterable[InnQuestionRecord]):
    """
    Create a new instance of InnRecord.

    Args:
        behavior_id (int): Behavior ID of the NPC that runs the inn. 0 for default inn (Value range is 0-64008.)
        name (str): (Length must be 252 or less.)
        spawn_map (int): ID of the map the player is sent to after respawning (Value range is 0-64008.)
        spawn_x (int): X coordinate of the map the player is sent to after respawning (Value range is 0-252.)
        spawn_y (int): Y coordinate of the map the player is sent to after respawning (Value range is 0-252.)
        sleep_map (int): ID of the map the player is sent to after sleeping at the inn (Value range is 0-64008.)
        sleep_x (int): X coordinate of the map the player is sent to after sleeping at the inn (Value range is 0-252.)
        sleep_y (int): Y coordinate of the map the player is sent to after sleeping at the inn (Value range is 0-252.)
        alternate_spawn_enabled (bool): Flag for an alternate spawn point. If true, the server will use this alternate spawn map, x, and, y based on some other condition.  In the official server, this is used to respawn new characters on the noob island until they reach a certain level.
        alternate_spawn_map (int): (Value range is 0-64008.)
        alternate_spawn_x (int): (Value range is 0-252.)
        alternate_spawn_y (int): (Value range is 0-252.)
        questions (Iterable[InnQuestionRecord]): (Length must be `3`.)
    """
    self._behavior_id = behavior_id
    self._name = name
    self._name_length = len(self._name)
    self._spawn_map = spawn_map
    self._spawn_x = spawn_x
    self._spawn_y = spawn_y
    self._sleep_map = sleep_map
    self._sleep_x = sleep_x
    self._sleep_y = sleep_y
    self._alternate_spawn_enabled = alternate_spawn_enabled
    self._alternate_spawn_map = alternate_spawn_map
    self._alternate_spawn_x = alternate_spawn_x
    self._alternate_spawn_y = alternate_spawn_y
    self._questions = tuple(questions)

serialize(writer, data) staticmethod

Serializes an instance of InnRecord to the provided EoWriter.

Parameters:

Name Type Description Default
writer EoWriter

The writer that the data will be serialized to.

 required
data InnRecord

The data to serialize.

 required
Source code in src/eolib/protocol/_generated/pub/server/inn_record.py 
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
@staticmethod
def serialize(writer: EoWriter, data: "InnRecord") -> None:
    """
    Serializes an instance of `InnRecord` to the provided `EoWriter`.

    Args:
        writer (EoWriter): The writer that the data will be serialized to.
        data (InnRecord): The data to serialize.
    """
    old_string_sanitization_mode: bool = writer.string_sanitization_mode
    try:
        if data._behavior_id is None:
            raise SerializationError("behavior_id must be provided.")
        writer.add_short(data._behavior_id)
        if data._name_length is None:
            raise SerializationError("name_length must be provided.")
        writer.add_char(data._name_length)
        if data._name is None:
            raise SerializationError("name must be provided.")
        if len(data._name) > 252:
            raise SerializationError(f"Expected length of name to be 252 or less, got {len(data._name)}.")
        writer.add_fixed_string(data._name, data._name_length, False)
        if data._spawn_map is None:
            raise SerializationError("spawn_map must be provided.")
        writer.add_short(data._spawn_map)
        if data._spawn_x is None:
            raise SerializationError("spawn_x must be provided.")
        writer.add_char(data._spawn_x)
        if data._spawn_y is None:
            raise SerializationError("spawn_y must be provided.")
        writer.add_char(data._spawn_y)
        if data._sleep_map is None:
            raise SerializationError("sleep_map must be provided.")
        writer.add_short(data._sleep_map)
        if data._sleep_x is None:
            raise SerializationError("sleep_x must be provided.")
        writer.add_char(data._sleep_x)
        if data._sleep_y is None:
            raise SerializationError("sleep_y must be provided.")
        writer.add_char(data._sleep_y)
        if data._alternate_spawn_enabled is None:
            raise SerializationError("alternate_spawn_enabled must be provided.")
        writer.add_char(1 if data._alternate_spawn_enabled else 0)
        if data._alternate_spawn_map is None:
            raise SerializationError("alternate_spawn_map must be provided.")
        writer.add_short(data._alternate_spawn_map)
        if data._alternate_spawn_x is None:
            raise SerializationError("alternate_spawn_x must be provided.")
        writer.add_char(data._alternate_spawn_x)
        if data._alternate_spawn_y is None:
            raise SerializationError("alternate_spawn_y must be provided.")
        writer.add_char(data._alternate_spawn_y)
        if data._questions is None:
            raise SerializationError("questions must be provided.")
        if len(data._questions) != 3:
            raise SerializationError(f"Expected length of questions to be exactly 3, got {len(data._questions)}.")
        for i in range(3):
            InnQuestionRecord.serialize(writer, data._questions[i])
    finally:
        writer.string_sanitization_mode = old_string_sanitization_mode

deserialize(reader) staticmethod

Deserializes an instance of InnRecord 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
InnRecord 'InnRecord'

The data to serialize.
Source code in src/eolib/protocol/_generated/pub/server/inn_record.py 
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@staticmethod
def deserialize(reader: EoReader) -> "InnRecord":
    """
    Deserializes an instance of `InnRecord` from the provided `EoReader`.

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

    Returns:
        InnRecord: The data to serialize.
    """
    old_chunked_reading_mode: bool = reader.chunked_reading_mode
    try:
        reader_start_position: int = reader.position
        behavior_id = reader.get_short()
        name_length = reader.get_char()
        name = reader.get_fixed_string(name_length, False)
        spawn_map = reader.get_short()
        spawn_x = reader.get_char()
        spawn_y = reader.get_char()
        sleep_map = reader.get_short()
        sleep_x = reader.get_char()
        sleep_y = reader.get_char()
        alternate_spawn_enabled = reader.get_char() != 0
        alternate_spawn_map = reader.get_short()
        alternate_spawn_x = reader.get_char()
        alternate_spawn_y = reader.get_char()
        questions = []
        for i in range(3):
            questions.append(InnQuestionRecord.deserialize(reader))
        result = InnRecord(behavior_id=behavior_id, name=name, spawn_map=spawn_map, spawn_x=spawn_x, spawn_y=spawn_y, sleep_map=sleep_map, sleep_x=sleep_x, sleep_y=sleep_y, alternate_spawn_enabled=alternate_spawn_enabled, alternate_spawn_map=alternate_spawn_map, alternate_spawn_x=alternate_spawn_x, alternate_spawn_y=alternate_spawn_y, questions=questions)
        result._byte_size = reader.position - reader_start_position
        return result
    finally:
        reader.chunked_reading_mode = old_chunked_reading_mode