def __load_from_file__(self, spath):
with open(spath, 'rb') as file:
reader = FileStream(file)
# Header (0x40 bytes)
num_enemies = reader.read_int()
rest_of_header = reader.read_string(0x3E)
# Enemy Data (0x50=80 bytes each)
for i in range(num_enemies):
enemy = SetEnemy.from_reader(reader)
self.enemies.append(enemy)
def print(self, idx):
s = str(idx).ljust(3) + ","
s += FileStream.int_array_to_hex(self.u1) + ","
s += FileStream.int_to_hex(self.id) + ","
s += FileStream.int_array_to_hex(self.u2) + ","
# s += FileStream.float_to_hex(self.x) + ","
# s += FileStream.float_to_hex(self.y) + ","
s += FileStream.int_array_to_hex(self.u3) + ","
s += FileStream.int_to_hex(self.k1) + ","
s += FileStream.int_array_to_hex(self.u4) + ","
s += self.type.rjust(8) + ","
s += FileStream.int_array_to_hex(self.u5) + ","
print(s)
def save(self, spath=None):
if spath is None:
spath = self.path
with open(spath, 'wb') as file:
writer = FileStream(file)
writer.write_int(len(self.enemies))
writer.write_int_array([0] * 31)
for enemy in self.enemies:
enemy.write_to_stream(writer)
def save(self, spath: Path = None):
# print("SAVE ", [im.mode for idx, im in enumerate(self.textures)])
if spath is None:
spath = self.path
with open(spath, 'wb') as file:
writer = FileStream(file)
writer.write_byte_array(self.header)
for idx, im_texture in enumerate(self.textures):
offset = writer.tell()
orig_im = im_texture.transpose(Image.FLIP_TOP_BOTTOM)
with io.BytesIO() as io_bytes:
orig_im.save(io_bytes, format="TGA")
# For some reason the TGA header flag is not being set correctly, so load our local copy of it
io_bytes.getbuffer()[17] = self.flags[idx]
im_bytes = io_bytes.getvalue()[:-26]
writer.write(im_bytes)
# print(f"[Writing] IDX: {idx}, Offset: {offset}, Size: {len(im_bytes)}, Mode: {orig_im.mode}")
writer.write(self.unparsed_bytes)
print("Saved to", spath)
def __load_textures__(self, reader: FileStream):
while True:
if reader.finished_reading():
break
offset = reader.tell()
im_data = io.BytesIO(reader.read_remaining_bytes())
try:
# Load image, flip it, and store it
im: Image.Image = Image.open(im_data)
im = im.transpose(Image.FLIP_TOP_BOTTOM)
self.textures.append(im)
# For some reason the TGA header flag is not being set correctly for some files so let's save it from the raw TGA header bytes
self.flags.append(im_data.getbuffer()[17])
# Figure out where exactly the next image begins
if im.mode == "RGBA":
bytes_per_pixel = RGBA_BYTES_PER_PIXEL
im_header_size = RGBA_HEADER_SIZE
elif im.mode == "P":
bytes_per_pixel = P_BYTES_PER_PIXEL
im_header_size = P_HEADER_SIZE
size = (im.width * im.height *
bytes_per_pixel) + im_header_size
reader.seek(offset + size)
# print(f"[Reading] IDX: {len(self.flags)-1}, Offset: {offset}, Size: {size}, Mode: {im.mode}")
except IOError:
print("Couldn't read image")
break
# print("READ ", [im.mode for idx, im in enumerate(self.textures)])
if not reader.finished_reading():
self.unparsed_bytes = reader.read_remaining_bytes()
print(
"Could not parse all the bytes of the WPG. Unparsed byte count: ",
len(self.unparsed_bytes))
def write_to_stream(self, writer: FileStream):
writer.write_int_array(self.u1)
writer.write_int(self.id)
writer.write_int_array(self.u2)
writer.write_float(self.x)
writer.write_float(self.y)
writer.write_int_array(self.u3)
writer.write_int(self.k1)
writer.write_int_array(self.u4)
writer.write_string(self.type, pad_bytes=8)
writer.write_int_array(self.u5)
def __load_header__(self, reader: FileStream):
self.header = reader.read_byte_array(WPG_HEADER_SIZE)
def __load_from_file__(self, path: Path):
with open(path, 'rb') as file:
reader = FileStream(file)
self.__load_header__(reader)
self.__load_textures__(reader)
def save(self, spath=None):
self.__recalculate__()
if spath is None:
spath = self.path
with open(spath, 'wb') as file:
writer = FileStream(file)
if len(self.omcb_header) > 0:
writer.write_string(self.omcb_header)
writer.write_int(self.size)
writer.write_int(0)
writer.write_string(self.header)
writer.write_int(self.size)
writer.write_int(self.text_count)
writer.write_int_array(self.offsets)
writer.write_string_array(self.files)
for idx, text_bytes in enumerate(self.texts_raw):
if self.has_extras():
extra_bytes = self.extras[idx].to_byte_array()
writer.write_int_array(extra_bytes)
writer.write_int_array(text_bytes)
writer.write_int(0xFFFF)
def __load_from_file__(self, path: Path):
with open(path, 'rb') as file:
reader = FileStream(file)
self.header = reader.read(0x820)
self.mpeg1_video = reader.read_remaining_bytes()