def load(self, reader):
start = reader.tell()
Editable.load(self, reader)
self.matdict.load(reader)
reader.seek(start + self.texmatdict_offset)
self.texmatdict.load(reader)
reader.seek(start + self.palmatdict_offset)
self.palmatdict.load(reader)
self.materials = []
self.tex_map = {}
self.pal_map = {}
for i in range(self.texmatdict.num):
idx_ofs, idx_num, bound = struct.unpack('HBB',
self.texmatdict.data[i])
reader.seek((idx_ofs & 0xFFFF) + start)
for j in range(idx_num):
idx = reader.readUInt8()
if idx in self.tex_map and not bound:
continue
self.tex_map[idx] = i
for i in range(self.palmatdict.num):
idx_ofs, idx_num, bound = struct.unpack('HBB',
self.palmatdict.data[i])
reader.seek((idx_ofs & 0xFFFF) + start)
for j in range(idx_num):
idx = reader.readUInt8()
if idx in self.pal_map and not bound:
continue
self.pal_map[idx] = i
for i in range(self.matdict.num):
ofs, = struct.unpack('I', self.matdict.data[i])
reader.seek(ofs + start)
self.materials.append(Material(reader=reader))
def load(self, reader):
Editable.load(self, reader)
if self.flag_ & self.FLAG_NO_SCALE:
self.scale_s_fx32 = 4096
self.scale_t_fx32 = 4096
else:
self.scale_s_fx32 = reader.readInt32()
self.scale_t_fx32 = reader.readInt32()
if self.flag_ & self.FLAG_NO_ROTATE:
self.rot_sin_fx32 = 0
self.rot_cos_fx32 = 0
else:
self.rot_sin_fx32 = reader.readInt32()
self.rot_cos_fx32 = reader.readInt32()
if self.flag_ & self.FLAG_NO_TRANSLATE:
self.trans_s_fx32 = 0
self.trans_t_fx32 = 0
else:
self.trans_s_fx32 = reader.readInt32()
self.trans_t_fx32 = reader.readInt32()
if self.flag_ & self.FLAG_EFFECT_MATRIX:
self.effect = [reader.readInt32() for i in range(16)]
def load(self, reader):
reader = BinaryIO.reader(reader)
start = reader.tell()
Editable.load(self, reader)
self.records = {}
for record_ofs, record_name in zip(self.record_offsets,
self.record_names):
if not record_ofs:
continue
reader.seek(start + record_ofs)
num = reader.readUInt32()
if record_name == 'SEQARC':
offsets = []
for i in range(num):
offsets.append((reader.readUInt32(), reader.readUInt32()))
entries = []
for i, (offset, sub_offset) in enumerate(offsets):
reader.seek(start + offset)
name = reader.readString()
reader.seek(start + sub_offset)
prefix = (record_name, name)
entries += self.load_entries(reader, start, prefix, num)
else:
entries = self.load_entries(reader, start, (record_name, ),
num)
self.records[record_name] = entries
def load(self, reader):
reader = BinaryIO.reader(reader)
Editable.load(self, reader)
if self.game.is_hgss():
self.block1 = reader.read(self.ublock1_size)
"""entry_size = Permission(self.game).get_size()
# self.permissions = [Permission(self.game, reader=reader)
# for i in range(self.permission_size/entry_size)]
self.permissions = Editable()
self.permissions.array('entries', Permission(self.game).base_struct,
length=self.permission_size/entry_size)
self.permissions.freeze()
self.permissions.load(reader)
entry_size = MapObject(self.game).get_size()
self.objects = [MapObject(self.game, reader=reader)
for i in range(self.objects_size/entry_size)]"""
entry = Permission(self.game)
# TODO: non-fixed w/h
self.permissions = Collection2d(entry.base_struct, 0x20, 0x20)
self.permissions.load(reader)
entry = MapObject(self.game)
self.objects = SizedCollection(
entry.base_struct, self.objects_size/entry.get_size())
self.objects.load(reader)
self.bmd = reader.read(self.bmd_size) # TODO later
self.bdhc = reader.read(self.bdhc_size)
def load(self):
self.map = {}
with self.game.open('arm9.dec.bin') as handle:
reader = BinaryIO.reader(handle)
reader.seek(self.game.type_icon_table[1])
Editable.load(self, BinaryIO.reader(reader))
return self
def load(self, reader):
reader = BinaryIO.reader(reader)
Editable.load(self, reader)
self.name = reader.read(self.namelen)
"""land_data_block = Editable()
land_data_block.array('entries', land_data_block.uint16,
length=self.width*self.height)
land_data_block.freeze()
self.land_data_maps = land_data_block.load(reader)
print(len(reader.read()))"""
with self.simulate():
if self.has_map_definition_ids:
self.map_definitions = Collection2d(self.uint16, self.width,
self.height)
self.map_definitions.load(reader)
else:
self.map_definitions = None
if self.has_mystery_zone:
self.mystery_details = Collection2d(self.uint8, self.width,
self.height)
self.mystery_details.load(reader)
else:
self.mystery_details = None
self.land_data_maps = Collection2d(self.uint16, self.width,
self.height)
self.land_data_maps.load(reader)
def load(self, reader):
Editable.load(self, reader)
self.entries = []
for i in range(self.num):
start = reader.readUInt32()
stop = start + reader.readUInt32()
reader.read(8)
self.entries.append(slice(start, stop))
def save(self):
with self.game.open('overlays_dez',
'overlay_{0:04}.bin'.format(
self.game.overworld_sprite_table[0]),
mode='r+') as handle:
writer = BinaryIO.writer(handle)
writer.seek(self.game.overworld_sprite_table[1])
Editable.save(self, writer)
def load(self, reader):
Editable.load(self, reader)
assert self.magic == 'RGCN', 'Expected RGCN got '.format(self.magic)
self.char.load(reader)
if self.numblocks > 1:
self.cpos.load(reader)
self.cpos.loaded = True
else:
self.cpos.loaded = False
def load(self, reader):
Editable.load(self, reader)
if self.trainer.hold_items:
self.item = reader.readUInt16()
if self.trainer.movesets:
self.moves = [reader.readUInt16() for i in range(4)]
if self.trainer.game.is_hgss():
self.seal_capsule = reader.readUInt16()
return self
def load(self):
self.map = {}
with self.game.open(
'overlays_dez', 'overlay_{0:04}.bin'.format(
self.game.overworld_sprite_table[0])) as handle:
reader = BinaryIO.reader(handle)
reader.seek(self.game.overworld_sprite_table[1])
Editable.load(self, BinaryIO.reader(reader))
for sprite in self.table:
self.map[sprite.sprite_id] = sprite
return self
def load(self, reader):
reader = BinaryIO.reader(reader)
start = reader.tell()
Editable.load(self, reader)
self.glyphs = []
# TODO: glyph reading
self.glyphs = SizedCollection(Glyph().base_struct, length=self.num)
self.glyphs.load(reader)
self.widths = []
reader.seek(start + self.footer_offset)
for i in range(self.num):
self.widths.append(reader.readUInt8())
def __init__(self):
Editable.__init__(self)
self.files = None
self.restrict('files')
self.project = Project()
self.restrict('project')
self.game_name = None
self.game_code = None
self.region_code = None
self.color = '#E5E4E2'
self.header = None
self.config = {}
def __init__(self, reader=None):
Editable.__init__(self)
self.string('magic', length=4, default='NARC')
self.uint16('endian', default=0xFFFE)
self.uint16('version', default=0x102)
self.uint32('size_')
self.uint16('headersize')
self.uint16('numblocks', default=3)
self.fatb = FATB(self)
self.fntb = FNTB(self)
self.fimg = FIMG(self)
self.freeze()
if reader is not None:
self.load(reader)
def load(self, reader):
reader = BinaryIO.reader(reader)
start = reader.tell()
Editable.load(self, reader)
assert self.magic == 'SDAT'
for block_ofs, block in zip(
self.block_offsets,
[self.symb, self.info, self.fat, self.file]):
if not block_ofs.block_offset:
continue
reader.seek(start + block_ofs.block_offset)
block.load(reader)
self.file.files = []
for entry in self.fat.entries:
reader.seek(start + entry.start)
self.file.files.append(reader.read(entry.stop - entry.start))
def save(self, writer):
self.flag_ = 0
if self.scale_s_fx32 == self.scale_t_fx32 == 4096:
self.flag_ |= self.FLAG_NO_SCALE
if self.rot_sin_fx32 == self.rot_cos_fx32 == 0:
self.flag_ |= self.FLAG_NO_ROTATE
if self.trans_s_fx32 == self.trans_t_fx32 == 0:
self.flag_ |= self.FLAG_NO_TRANSLATE
if self.effect:
if len(self.effect) != 16:
raise ValueError('Effect matrix must be 4x4 as 16 entries')
self.flag_ |= self.FLAG_EFFECT_MATRIX
writer = Editable.save(self, writer)
if not self.flag_ & self.FLAG_NO_SCALE:
writer.writeInt32(self.scale_s_fx32)
writer.writeInt32(self.scale_t_fx32)
if not self.flag_ & self.FLAG_NO_ROTATE:
writer.writeInt32(self.rot_sin_fx32)
writer.writeInt32(self.rot_cos_fx32)
if not self.flag_ & self.FLAG_NO_TRANSLATE:
writer.writeInt32(self.trans_s_fx32)
writer.writeInt32(self.trans_t_fx32)
if self.flag_ & self.FLAG_EFFECT_MATRIX:
for value in self.effect:
writer.writeInt32(value)
return writer
def save(self, writer):
start = writer.tell()
writer = Editable.save(self, writer)
writer = self.nodes.save(writer)
ofs = writer.tell() - start
with writer.seek(start + self.get_offset('sbc_offset')):
writer.writeUInt32(ofs)
for command in self.sbc:
writer.writeUInt8(command)
ofs = writer.tell() - start
with writer.seek(start + self.get_offset('mat_offset')):
writer.writeUInt32(ofs)
writer = self.materials.save(writer)
ofs = writer.tell() - start
with writer.seek(start + self.get_offset('shp_offset')):
writer.writeUInt32(ofs)
writer = self.shapes.save(writer)
ofs = writer.tell() - start
with writer.seek(start + self.get_offset('size_')):
writer.writeUInt32(ofs)
return writer
def load(self, reader):
reader = BinaryIO.reader(reader)
start = reader.tell()
Editable.load(self, reader)
assert self.magic == 'BMD0', 'Expected BMD0 got '.format(self.magic)
block_offsets = []
for i in range(self.numblocks):
block_offsets.append(reader.readUInt32())
reader.seek(start + block_offsets[0])
self.mdl.load(reader)
if self.numblocks > 1:
reader.seek(start + block_offsets[1])
self.tex.load(reader)
self.tex.loaded = True
else:
self.tex.loaded = False
def save(self, writer):
old_datasize = self.datasize
if self.cgr.encryption != NCGR.ENCRYPTION_NONE:
self.encrypt(self.cgr.encryption)
self.datasize = len(self.data)
self.size_ += self.datasize - old_datasize
writer = Editable.save(self, writer)
writer.write(self.data)
return writer
def save(self, writer=None):
writer = BinaryIO.writer(writer)
start = writer.tell()
writer = Editable.save(self, writer)
if self.game.is_hgss():
writer.write(self.block1)
self.ublock1_size = len(self.block1)
writer = self.permissions.save(writer)
self.permission_size = self.permissions.get_size()
writer = self.objects.save(writer)
self.objects_size = self.objects.get_size()
writer.write(self.bmd)
self.bmd_size = len(self.bmd)
writer.write(self.bdhc)
self.bdhc_size = len(self.bdhc)
with writer.seek(start):
Editable.save(self, writer)
return writer
def save(self, writer=None):
idx = 1
blocks = [0] * 4
for block_id in range(4):
for bit in range(32):
if idx in self.tms:
blocks[block_id] |= 1 << bit
idx += 1
return Editable.save(self, writer)
def save(self, writer=None):
self.namelen = len(self.name)
writer = Editable.save(self, writer)
writer.write(self.name)
if self.has_map_definition_ids:
writer = self.map_definitions.save(writer)
if self.has_mystery_zone:
writer = self.mystery_details.save(writer)
writer = self.land_data_maps.save(writer)
return writer
def save(self, writer):
writer = Editable.save(self, writer)
if self.trainer.hold_items:
writer.writeUInt16(self.item)
if self.trainer.movesets:
for move in self.moves:
writer.writeUInt16(move)
if self.trainer.game.is_hgss():
writer.writeUInt16(self.seal_capsule)
return writer
def save(self, writer=None):
writer = BinaryIO.writer(writer)
start = writer.tell()
writer = Editable.save(self, writer)
writer = self.char.save(writer)
if self.cpos.loaded:
writer = self.cpos.save(writer)
size = writer.tell() - start
with writer.seek(start + self.get_offset('size_')):
writer.writeUInt32(size)
return writer
def load(self, reader):
start = reader.tell()
Editable.load(self, reader)
self.nodes.load(reader)
assert self.nodes.nodedict.num == self.num_nodes
self.sbc = []
reader.seek(start + self.sbc_offset)
for i in range(self.mat_offset - self.sbc_offset):
self.sbc.append(reader.readUInt8()) # SBC
reader.seek(start + self.mat_offset)
self.materials.load(reader)
assert self.materials.matdict.num == self.num_materials,\
(self.materials.matdict.num, self.num_materials)
reader.seek(start + self.shp_offset)
self.shapes.load(reader)
assert self.shapes.shapedict.num == self.num_shapes
def save(self, writer):
start = writer.tell()
writer = Editable.save(self, writer)
rel = writer.tell()
for file_id, entry in enumerate(self.narc.fatb.entries):
writer.writePadding(entry.start + rel)
writer.write(self.files[file_id])
writer.writeAlign(4)
size = writer.tell() - start
with writer.seek(start + self.get_offset('size_')):
writer.writeUInt32(size)
return writer
def save(self, writer):
start = writer.tell()
self._data.num = self.num
writer = Editable.save(self, writer)
for entry in self.entries:
writer.writeUInt32(entry.start)
writer.writeUInt32(entry.stop)
writer.writeAlign(4)
size = writer.tell() - start
with writer.seek(start + self.get_offset('size_')):
writer.writeUInt32(size)
return writer
def save(self, writer=None):
writer = BinaryIO.writer(writer)
start = writer.tell()
writer = Editable.save(self, writer)
writer = self.fatb.save(writer)
writer = self.fntb.save(writer)
writer = self.fimg.save(writer)
writer.writeAlign(4)
size = writer.tell() - start
with writer.seek(start + self.get_offset('size_')):
writer.writeUInt32(size)
return writer
def save(self, writer=None):
writer = BinaryIO.writer(writer)
start = writer.tell()
self.mdldict.num = len(self.models)
writer = Editable.save(self, writer)
writer = self.mdldict.save(writer)
for i in range(self.mdldict.num):
writer = self.models[i].save(writer)
size = writer.tell() - start
with writer.seek(start + self.get_offset('size_')):
writer.writeUInt32(size)
return writer
def load(self, reader):
reader = BinaryIO.reader(reader)
start = reader.tell()
Editable.load(self, reader)
self.records = {}
for i, record_ofs in enumerate(self.record_offsets):
if not record_ofs:
continue
reader.seek(start + record_ofs)
num = reader.readUInt32()
offsets = SizedCollection(self.uint32, length=num)
offsets.load(reader=reader)
first_entry = expected = reader.tell() - start
template_entry = self.record_classes[i]()
entry_size = template_entry.get_size()
for offset in offsets.entries:
if offset != expected:
break
else:
entries = SizedCollection(template_entry.base_struct,
length=num)
entries.load(reader=reader)
self.records[SYMB.record_names[i]] = entries
continue
adjusted_num = (max(offsets.entries[:] + [first_entry]) -
first_entry) / entry_size + 1
entries = SizedCollection(template_entry.base_struct,
length=adjusted_num)
entries.load(reader=reader)
new_entries = SizedCollection(self.record_classes[i]().base_struct,
length=num)
for idx, offset in enumerate(offsets.entries):
if not offset: # what are these entries even?
new_entries[idx].file_id = 0
continue
target = (offset - first_entry) / entry_size
new_entries[idx] = entries.entries[target]
self.records[SYMB.record_names[i]] = new_entries
