class Object(object):
Type = ObjectType
Properties = ObjectProperties
Identifier = ObjectIdentifier
version_format = "<I"
version_parser = FileStruct(version_format)
valid_version = 119
# First 2 bytes decide which constructor(?) to use, 1 for .mob files, -1 for .pro files
# There is also something called obj dif file, probably patch related.
constructor_type_format = "H"
# .mob files:
unknown_data_format = "30s"
raw_identifier_format = "16s" # matches file name, unique per entity per map
raw_type_format = "I" # If that does not fail reads 2 more bytes
full_format = "<" + "".join((constructor_type_format, unknown_data_format,
raw_identifier_format, raw_type_format))
full_parser = FileStruct(full_format)
def __init__(self, version: int, type: ObjectType,
identifier: ObjectIdentifier, properties: ObjectProperties):
self.version = version
self.type = type
self.identifier = identifier
@classmethod
def read_from(cls, obj_file: io.FileIO) -> "Object":
version, = cls.version_parser.unpack_from_file(obj_file)
if (version != cls.valid_version):
raise TypeError("Arkanum does not support object version %d" %
version)
constructor, unknown_data, raw_identifier, raw_type = cls.full_parser.unpack_from_file(
obj_file)
type = Object.Type(raw_type)
properties = Object.Properties.read_from(obj_file, obj_type=type)
return Object(version=version,
type=type,
identifier=Object.Identifier(raw_identifier),
properties=properties)
def write_to(self, obj_file: io.FileIO) -> None:
raise NotImplementedError()
def read(cls, sector_blocked_file_path: str) -> "SectorBlockades":
with open(sector_blocked_file_path, "rb") as sector_blocked_file:
length, = cls.length_parser.unpack_from_file(sector_blocked_file)
raw_blocked_sectors_parser = FileStruct("<%d%s" % (length, cls.data_format))
raw_blocked_sectors = raw_blocked_sectors_parser.unpack_from_file(sector_blocked_file)
# Convert raw to real.
blocked_sectors = []
for raw_blocked_sector in raw_blocked_sectors:
blocked_sectors.append((raw_blocked_sector & 0xFFF, raw_blocked_sector >> 26))
return BlockedSectors(file_path=sector_blocked_file_path, blocked_sectors=blocked_sectors)
class DatFooter(object):
class Constants(object):
marker = b"1TAD"
guid_format = "16s"
marker_format = "4s" # Should always equal "1TAD" ?
file_names_size_format = "I" # Total allocation size for file names (we will probably ignore this)
footer_plus_entries_size_format = "I"
full_format = "<" + guid_format + marker_format + file_names_size_format + footer_plus_entries_size_format
parser = FileStruct(full_format)
def __init__(self, guid: bytes, marker: bytes, file_names_size: int,
footer_plus_entries_size: int):
assert marker == self.Constants.marker
self.guid = guid
self.file_names_size = file_names_size
self.footer_plus_entries_size = footer_plus_entries_size
@classmethod
def read_from(cls, dat_file: io.FileIO) -> "DatFooter":
guid, marker, file_names_size, footer_plus_entries_size = DatFooter.parser.unpack_from_file(
dat_file)
return DatFooter(guid=guid,
marker=marker,
file_names_size=file_names_size,
footer_plus_entries_size=footer_plus_entries_size)
@property
def marker(self) -> str:
return self.Constants.marker
class DatEntry(object):
class Flags(object):
is_compressed = 0x002
is_directory = 0x400
padding_format = "4x" # Its always saved as zero, but in memory its usually a 32bit pointer to the name.
flags_format = "I"
full_size_format = "I"
compressed_size_format = "I"
location_format = "I"
full_format = "<" + padding_format + flags_format + full_size_format + compressed_size_format + location_format
parser = FileStruct(full_format)
def __init__(self, flags: int, full_size: int, compressed_size: int,
location: int):
self.is_compressed = bool(flags & self.Flags.is_compressed)
self.is_directory = bool(flags & self.Flags.is_directory)
self.full_size = full_size
self.compressed_size = compressed_size
self.location = location
@classmethod
def read_from(cls, dat_file: io.FileIO) -> "DatEntry":
flags, full_size, compressed_size, location = DatEntry.parser.unpack_from_file(
dat_file)
return DatEntry(flags=flags,
full_size=full_size,
compressed_size=compressed_size,
location=location)
class SectorBlockades(object):
"""
Binary file format:
- Blocked (1 bit) * 4096
"""
raw_blockades_format = "<512B"
raw_blockades_parser = FileStruct(raw_blockades_format)
def __init__(self, raw_blockades: List[Any]):
self.raw_blockades = raw_blockades
def __len__(self) -> int:
return len(self.raw_blockades)
def __getitem__(self, index: int) -> int:
return self.raw_blockades[index]
@classmethod
def read_from(cls, sector_file: io.FileIO) -> "SectorBlockades":
raw_blockades = cls.raw_blockades_parser.unpack_from_file(sector_file)
return SectorBlockades(raw_blockades=raw_blockades)
def write_to(self, sector_file: io.FileIO) -> None:
self.raw_blockades_parser.pack_into_file(sector_file,
self.raw_blockades)
def write(self, sector_blocked_file_path: str) -> None:
with open(sector_blocked_file_path, "wb") as sector_blocked_file:
length = len(self)
if (length == 0):
return
self.length_parser.pack_into_file(sector_blocked_file, length)
# Convert real to raw.
raw_blocked_sectors = []
for sector_x, sector_y in self:
raw_blocked_sectors.append(sector_x | (sector_y << 26))
raw_blocked_sectors_parser = FileStruct("<%d%s" % (length, self.data_format))
raw_blocked_sectors_parser.pack_into_file(sector_blocked_file, *raw_blocked_sectors)
def write_to(self, sector_file: io.FileIO) -> None:
count = len(self.raw_lights)
self.count_parser.pack_into_file(sector_file, count)
if (count > 0):
fmt = "<" + self.raw_format * count
FileStruct(fmt).pack_into_file(sector_file, *self.raw_lights)
class SectorRoofs(object):
"""
Binary file format:
- Roof (4 bytes) * 256
"""
type_format = "<I"
raw_roofs_format = "<256I"
type_parser = FileStruct(type_format)
raw_roofs_parser = FileStruct(raw_roofs_format)
def __init__(self, type: int, raw_roofs: List[Any]):
self.type = type
self.raw_roofs = raw_roofs
def __len__(self) -> int:
return len(self.raw_roofs)
def __getitem__(self, index: int) -> int:
return self.raw_roofs[index]
@classmethod
def read_from(cls, sector_file: io.FileIO) -> "SectorRoofs":
type, = cls.type_parser.unpack_from_file(sector_file)
if type == 0:
raw_roofs = cls.raw_roofs_parser.unpack_from_file(sector_file)
else:
raw_roofs = []
return SectorRoofs(type=type, raw_roofs=raw_roofs)
def write_to(self, sector_file: io.FileIO) -> None:
self.type_parser.pack_into_file(sector_file, self.type)
if self.type == 0:
self.raw_roofs_parser.pack_into_file(sector_file, *self.raw_roofs)
def read(cls, sector_blocked_file_path: str) -> "SectorBlockades":
with open(sector_blocked_file_path, "rb") as sector_blocked_file:
length, = cls.length_parser.unpack_from_file(sector_blocked_file)
raw_blocked_sectors_parser = FileStruct("<%d%s" %
(length, cls.data_format))
raw_blocked_sectors = raw_blocked_sectors_parser.unpack_from_file(
sector_blocked_file)
# Convert raw to real.
blocked_sectors = []
for raw_blocked_sector in raw_blocked_sectors:
blocked_sectors.append(
(raw_blocked_sector & 0xFFF, raw_blocked_sector >> 26))
return BlockedSectors(file_path=sector_blocked_file_path,
blocked_sectors=blocked_sectors)
def write(self, sector_blocked_file_path: str) -> None:
with open(sector_blocked_file_path, "wb") as sector_blocked_file:
length = len(self)
if (length == 0):
return
self.length_parser.pack_into_file(sector_blocked_file, length)
# Convert real to raw.
raw_blocked_sectors = []
for sector_x, sector_y in self:
raw_blocked_sectors.append(sector_x | (sector_y << 26))
raw_blocked_sectors_parser = FileStruct("<%d%s" %
(length, self.data_format))
raw_blocked_sectors_parser.pack_into_file(sector_blocked_file,
*raw_blocked_sectors)
def read_from(cls, sector_file: io.FileIO) -> "SectorLights":
count, = cls.count_parser.unpack_from_file(sector_file)
if (count > 0):
fmt = "<" + cls.raw_format * count
raw_lights = FileStruct(fmt).unpack_from_file(sector_file)
else:
raw_lights = []
return SectorLights(raw_lights)
class SectorTileScripts(object):
"""
Binary file format:
- Tile scripts count (4 bytes)
- Tile script (24 bytes) * count
Binary file format per tile script:
- ? (4 bytes)
- Index of tile in sector (2 bytes)
- ? (2 bytes)
- Flags (4 bytes)
- Counters (4 bytes)
- Script ID (4 bytes)
- ? (4 bytes)
"""
count_format = "<I"
raw_format = "24s"
count_parser = FileStruct(count_format)
def __init__(self, raw_scripts: List[Any] = []):
self.raw_scripts = raw_scripts
def __len__(self) -> int:
return len(self.raw_scripts)
def __getitem__(self, index: int) -> int:
return self.raw_scripts[index]
@classmethod
def read_from(cls, sector_file: io.FileIO) -> "SectorTileScripts":
count, = cls.count_parser.unpack_from_file(sector_file)
if (count > 0):
fmt = "<" + cls.raw_format * count
raw_scripts = FileStruct(fmt).unpack_from_file(sector_file)
else:
raw_scripts = []
return SectorTileScripts(raw_scripts=raw_scripts)
def write_to(self, sector_file: io.FileIO) -> None:
count = len(self.raw_scripts)
count_data = self.count_parser.pack_into_file(sector_file, count)
if (count > 0):
fmt = "<" + self.raw_format * count
raw_data = FileStruct(fmt).pack_into_file(sector_file,
*self.raw_scripts)
class SectorObjects(object):
length_format = "I"
length_parser = FileStruct("<" + length_format)
def __init__(self, objects: List[Any] = []):
self.objects = objects
def __len__(self):
return len(self.objects)
def __getitem__(self, index: int) -> Object:
return self.objects[index]
def __iter__(self):
return iter(self.objects)
@classmethod
def read_from(cls, sector_file: io.FileIO) -> "SectorInfo":
# Save current position in file
tell = sector_file.tell()
# Go to end of file minus size of length.
sector_file.seek(-cls.length_parser.size, 2)
length, = cls.length_parser.unpack_from_file(sector_file)
print(length)
objects = []
if length:
# Go back to saved position
sector_file.seek(tell)
for _ in range(length):
objects.append(Object.read_from(sector_file))
return SectorObjects(objects=objects)
def write_to(self, sector_file: io.FileIO) -> None:
for obj in self:
obj.write_to(sector_file)
self.length_parser.pack_into_file(sector_file, len(self))
class SectorTiles(object):
"""
Binary file format:
- Tile (4 bytes) * 4096
Binary file format per tile (old notes: might be little or big endian):
First byte:
- Flipped (1 bit)
- Unknown (4 bits)
- Flippable (2 bits)
Second byte:
- Outdoor (1 bit)
- Variant (3 bits) (tile file name ending with a, b, ..., or h)
- Rotation (4 bits)
Third / Fourth byte:
- Some index (6 bits) # Probably indicates the art file prefix to use.
- Some index (6 bits) # In my notes its stated to always be the same as the former,
# but its probably the other terrain in a transition.
- Unknown (4 bits)
"""
raw_tiles_format = "<4096I"
raw_tiles_parser = FileStruct(raw_tiles_format)
def __len__(self) -> int:
return len(self.raw_tiles)
def __getitem__(self, index: int) -> int:
return self.raw_tiles[index]
def __init__(self, raw_tiles: List[Any]):
self.raw_tiles = raw_tiles
@classmethod
def read_from(cls, sector_file: io.FileIO) -> "SectorTiles":
raw_tiles = cls.raw_tiles_parser.unpack_from_file(sector_file)
return SectorTiles(raw_tiles)
def write_to(self, sector_file: io.FileIO) -> None:
raw_tiles_data = self.raw_tiles_parser.pack_into_file(
sector_file, *self.raw_tiles)
class MapProperties(object):
# This is the original map type (The type of the tiles the map was created with), here it is saved in 4 bytes
# And in terrain.tdf it is saved as 8 bytes as well for some reason.
# This value seems to have little impact (I didn't find yet what uses it, since so far everything i saw used data
# directly from the sectors descriptors)
# In 'arcanum1.dat' under 'terrain/forest to snowy plains' there is actually a mismatch with terrain.tdf (That is
# the only one) so i assume that the value in the here is more important (since the tdf value is the wrong one).
# The values here fit the values in 'arcanum1.dat' under 'terrain/terrain.mes'
original_type_format = "I"
# This seems to be some kind of a computer stamps, and it seems to only server as informational value.
# When creating maps with worldEd The whole value can change between computers, on one of my computers the value
# also change a bit each restart (Only the second byte) on the other the number is always consistent.
stamp_format = "I"
tile_rows_format = "Q"
tile_cols_format = "Q"
full_format = "<" + original_type_format + stamp_format + tile_rows_format + tile_cols_format
parser = FileStruct(full_format)
def __init__(self, file_path: str, original_type: int, stamp: int,
tile_rows: int, tile_cols: int):
self.file_path = file_path
self.original_type = original_type
self.stamp = stamp
self.tile_rows = tile_rows
self.tile_cols = tile_cols
@classmethod
def read(cls, map_properties_file_path: str) -> "MapProperties":
with open(map_properties_file_path, "rb") as map_properties_file:
original_type, stamp, tile_rows, tile_cols = cls.parser.unpack_from_file(
map_properties_file)
return MapProperties(file_path=map_properties_file_path,
original_type=original_type,
stamp=stamp,
tile_rows=tile_rows,
tile_cols=tile_cols)
class SectorLights(object):
"""
Binary file format:
- Light count (4 bytes)
- Light (48 bytes) * Light count
"""
count_format = "<I"
raw_format = "48s"
count_parser = FileStruct(count_format)
def __init__(self, raw_lights: List[Any]):
self.raw_lights = raw_lights
def __len__(self) -> int:
return len(self.raw_lights)
def __getitem__(self, index: int) -> int:
return self.raw_lights[index]
@classmethod
def read_from(cls, sector_file: io.FileIO) -> "SectorLights":
count, = cls.count_parser.unpack_from_file(sector_file)
if (count > 0):
fmt = "<" + cls.raw_format * count
raw_lights = FileStruct(fmt).unpack_from_file(sector_file)
else:
raw_lights = []
return SectorLights(raw_lights)
def write_to(self, sector_file: io.FileIO) -> None:
count = len(self.raw_lights)
self.count_parser.pack_into_file(sector_file, count)
if (count > 0):
fmt = "<" + self.raw_format * count
FileStruct(fmt).pack_into_file(sector_file, *self.raw_lights)
class BlockedSectors(Sequence):
"""
If a sector is present in this object it is "blocked on the world map".
"""
length_format = "<I"
length_parser = FileStruct(length_format)
data_format = "Q"
def __init__(self,
file_path: str,
blocked_sectors: List[Tuple[int, int]] = []):
self.blocked_sectors = blocked_sectors
self.file_path = file_path
def __getitem__(self, index: int) -> Tuple[int, int]:
return self.blocked_sectors[index]
def __len__(self) -> int:
return len(self.blocked_sectors)
@classmethod
def read(cls, sector_blocked_file_path: str) -> "SectorBlockades":
with open(sector_blocked_file_path, "rb") as sector_blocked_file:
length, = cls.length_parser.unpack_from_file(sector_blocked_file)
raw_blocked_sectors_parser = FileStruct("<%d%s" %
(length, cls.data_format))
raw_blocked_sectors = raw_blocked_sectors_parser.unpack_from_file(
sector_blocked_file)
# Convert raw to real.
blocked_sectors = []
for raw_blocked_sector in raw_blocked_sectors:
blocked_sectors.append(
(raw_blocked_sector & 0xFFF, raw_blocked_sector >> 26))
return BlockedSectors(file_path=sector_blocked_file_path,
blocked_sectors=blocked_sectors)
def write(self, sector_blocked_file_path: str) -> None:
with open(sector_blocked_file_path, "wb") as sector_blocked_file:
length = len(self)
if (length == 0):
return
self.length_parser.pack_into_file(sector_blocked_file, length)
# Convert real to raw.
raw_blocked_sectors = []
for sector_x, sector_y in self:
raw_blocked_sectors.append(sector_x | (sector_y << 26))
raw_blocked_sectors_parser = FileStruct("<%d%s" %
(length, self.data_format))
raw_blocked_sectors_parser.pack_into_file(sector_blocked_file,
*raw_blocked_sectors)
class Dat(object):
number_of_entries_parser = FileStruct("<I")
file_name_length_parser = FileStruct("<I")
def __init__(self, dat_file: io.FileIO, footer: DatFooter,
name_to_entry: Dict[str, DatEntry]):
self.dat_file = dat_file
self.footer = footer
self.name_to_entry = name_to_entry
@classmethod
def open(cls, dat_file_path: str) -> "Dat":
dat_file = open(dat_file_path, "rb")
dat_file.seek(-DatFooter.parser.size, io.SEEK_END)
footer = DatFooter.read_from(dat_file)
dat_file.seek(-footer.footer_plus_entries_size, io.SEEK_END)
number_of_entries, = cls.number_of_entries_parser.unpack_from_file(
dat_file)
name_to_entry = OrderedDict() # type: Dict[str, DatEntry]
for _ in range(number_of_entries):
file_name_length, = cls.file_name_length_parser.unpack_from_file(
dat_file)
file_name = dat_file.read(
file_name_length -
1).decode() # we don't want to save the last null
dat_file.read(1) # to skip the null byte
name_to_entry[file_name] = DatEntry.read_from(dat_file)
return Dat(dat_file=dat_file,
footer=footer,
name_to_entry=name_to_entry)
def __contains__(self, name: str) -> bool:
return name in self.name_to_entry
def __getitem__(self, name: str) -> bytes:
entry = self.name_to_entry[name]
if entry.is_directory:
return b""
self.dat_file.seek(entry.location, io.SEEK_SET)
raw_data = self.dat_file.read(entry.compressed_size)
if entry.is_compressed:
return zlib.decompress(raw_data)
else:
return raw_data
def keys(self) -> Iterable[str]:
return self.name_to_entry.keys()
class ObjectProperties(object):
flags_parsers = (
FileStruct("<H"), # 0
FileStruct("<H4B"), # 1
FileStruct("<H8B"), # 2
FileStruct("<H12B"), # 3
FileStruct("<H16B"), # 4
FileStruct("<H20B") # 5
)
# Mapping from type to tuple of all (field name, parser)
type_fields = (Fields.wall_fields, Fields.portal_fields,
Fields.container_fields, Fields.scenery_fields,
Fields.projectile_fields, Fields.weapon_fields,
Fields.ammo_fields, Fields.armor_fields, Fields.gold_fields,
Fields.food_fields, Fields.scroll_fields, Fields.key_fields,
Fields.keyring_fields, Fields.written_fields,
Fields.generic_fields, Fields.player_fields,
Fields.critter_fields, Fields.trap_fields)
# Size in bytes of included field flags.
# len(Fields.type) / 32
type_flags_length = (
3, # 00 Wall
3, # 01 Portal
3, # 02 Container
3, # 03 Scenery
0, # 04 Projectile
4, # 05 Weapon
4, # 06 Ammo
4, # 07 Armor
4, # 08 Gold
4, # 09 Food
4, # 10 Scroll
4, # 11 Key
4, # 12 KeyRing
4, # 13 Written
4, # 14 Generic
5, # 15 Player
5, # 16 Critter
3 # 17 Trap
)
@classmethod
def read_from(cls,
obj_file: io.FileIO,
obj_type: ObjectType = None) -> "ObjectProperties":
raise NotImplementedError()
field_count, *raw_flags = cls.flags_parsers[
cls.type_flags_length[obj_type]].unpack_from_file(obj_file)
# Bytes to bit array.
flags = np.fliplr(
np.unpackbits(np.array(raw_flags,
dtype=np.uint8)).reshape(-1, 8)).flatten()
if (field_count != np.sum(flags)):
raise RuntimeError(
"Field count doesn't match actual: %d versus %d" %
(field_count, np.sum(flags)))
# Parse fields from file
raw_fields = {}
for index in np.nonzero(flags)[0]:
name, parse_func = cls.type_fields[obj_type][index]
print(name)
raw_fields[name] = parse_func(obj_file)
class SectorInfo(object):
"""
Binary file format:
- Type (4 bytes)
- Info (varying bytes)
type 0:
- Nothing
type 1:
- Script tile count (4 bytes)
# List of tile scripts (n * 24 bytes)
type 2:
- all of type 1
- Sector Script Flags (4 bytes)
- Sector Script Counters (4 * 1 byte)
- Sector Script ID (4 bytes)
type 3:
- all of type 2
- Town Map ID (4 bytes)
- Magick/Tech aptitude (4 bytes signed)
- Light Scheme (4 bytes)
- NULL (4 bytes)
- Music ID (4 bytes)
- Ambient ID (4 bytes)
type 4: (Default, WorldEd always(?) saves as type 4)
- all of type 3
- Blocked tile array (64 * 64 bits)
"""
# Figure out whether unchanging bits have meaning
class Type(object):
NO_INFO = 0x00AA0000
TILE_SCRIPTS = 0x00AA0001
ALL_SCRIPTS = 0x00AA0002
BASIC = 0x00AA0003
FULL = 0x00AA0004
type_format = "<I"
type_parser = FileStruct(type_format)
script_flags_format = "I"
script_counters_format = "I"
script_id_format = "I"
sector_script_format = script_flags_format + script_counters_format + script_id_format
town_map_format = "I"
magick_aptitude_format = "i"
light_scheme_format = "I"
unknown_format = "I" # Always 0
music_format = "I"
ambient_format = "I"
blockades_format = "512B"
basic_format = (town_map_format + magick_aptitude_format +
light_scheme_format + unknown_format + music_format +
ambient_format)
sector_script_parser = FileStruct("<" + sector_script_format)
basic_parser = FileStruct("<" + sector_script_format + basic_format)
full_parser = FileStruct("<" + sector_script_format + basic_format +
blockades_format)
def __init__(self,
type: int = Type.FULL,
tile_scripts: SectorTileScripts = None,
sector_script: (int, int, int) = (0, 0, 0),
town_map: int = 0,
magick_aptitude: int = 0,
light_scheme: int = 0,
music: int = 0,
ambient: int = 0,
blockades: List[Any] = []):
self.type = type
self.tile_scripts = tile_scripts
self.sector_script = sector_script
self.town_map = town_map
self.magick_aptitude = magick_aptitude
self.light_scheme = light_scheme
self.music = music
self.ambient = ambient
self.blockades = blockades
def __len__(self) -> int:
return len(self.raw_blockades)
def __getitem__(self, index: int) -> int:
return self.raw_blockades[index]
@classmethod
def read_from(cls, sector_file: io.FileIO) -> "SectorInfo":
type, = cls.type_parser.unpack_from_file(sector_file)
if type == cls.Type.NO_INFO:
return SectorInfo(type=type)
tile_scripts = SectorTileScripts.read_from(sector_file)
if type == cls.Type.TILE_SCRIPTS:
return SectorInfo(type=type, tile_scripts=tile_scripts)
elif type == cls.Type.ALL_SCRIPTS:
sector_script = cls.sector_script_parser.unpack_from_file(
sector_file)
return SectorInfo(type=type,
tile_scripts=tile_scripts,
sector_script=sector_script)
elif type == cls.Type.BASIC:
(sector_script_flags, sector_script_counters, sector_script_id,
town_map, magick_aptitude, light_scheme, _, music,
ambient) = cls.basic_parser.unpack_from_file(sector_file)
sector_script = (sector_script_flags, sector_script_counters,
sector_script_id)
return SectorInfo(type=type,
tile_scripts=tile_scripts,
sector_script=sector_script,
town_map=town_map,
magick_aptitude=magick_aptitude,
light_scheme=light_scheme,
music=music,
ambient=ambient)
elif type == cls.Type.FULL:
(sector_script_flags, sector_script_counters, sector_script_id,
town_map, magick_aptitude, light_scheme, _, music, ambient,
*blockades) = cls.full_parser.unpack_from_file(sector_file)
sector_script = (sector_script_flags, sector_script_counters,
sector_script_id)
return SectorInfo(type=type,
tile_scripts=tile_scripts,
sector_script=sector_script,
town_map=town_map,
magick_aptitude=magick_aptitude,
light_scheme=light_scheme,
music=music,
ambient=ambient,
blockades=blockades)
else:
raise NotImplementedError("Can not handle unknown type %d" %
(type))
def write_to(self, sector_file: io.FileIO) -> None:
self.type_parser.pack_into_file(sector_file, self.type)
if self.type == self.Type.NO_INFO:
return
self.tile_scripts.write_to(sector_file)
if self.type == self.Type.ALL_SCRIPTS:
self.sector_script_parser.pack_into_file(sector_file,
*self.sector_script)
elif self.type == self.Type.BASIC:
self.basic_parser.pack_into_file(sector_file, *self.sector_script,
self.town_map,
self.magick_aptitude,
self.light_scheme, 0, self.music,
self.ambient)
elif self.type == self.Type.FULL:
self.full_parser.pack_into_file(sector_file, *self.sector_script,
self.town_map,
self.magick_aptitude,
self.light_scheme, 0, self.music,
self.ambient, *self.blockades)