《Another Code 两种记忆》汉化笔记

import struct

# Thanks to: Jason Harley
# Reference: https://github.com/Jas2o/KyleHyde/blob/main/KyleHyde/Formats/HotelDusk/Decompress.cs
def decompress(compressed: bytearray | bytes) -> bytearray:
  header, sizeun, sizeco, zero = struct.unpack("<4I", compressed[:0x10])
  if header == 0x00da3d12:
    return bytearray(compressed[0x10:])
  elif header != 0x01da3d12:
    return bytearray(compressed)

  uncompressed = bytearray(sizeun)
  uncompressed_pos = 0
  compressed_pos = 0x10
  while compressed_pos < sizeco + 0x10:
    input = compressed[compressed_pos]
    compressed_pos += 1
    for i in range(8):
      if compressed_pos >= sizeco + 0x10:
        break
      bits_i = input & 1
      input >>= 1
      if bits_i:
        uncompressed[uncompressed_pos] = compressed[compressed_pos]
        compressed_pos += 1
        uncompressed_pos += 1
      else:
        offset, len = struct.unpack("<HB", compressed[compressed_pos : compressed_pos + 3])
        offset = (offset + 0xff + 4) & 0xffff
        len += 4
        compressed_pos += 3

        while offset < uncompressed_pos - 0x10000:
          offset += 0x10000

        if offset < 0 or offset + len >= sizeun:
          for x in range(len):
            uncompressed[uncompressed_pos + x] = 0
        else:
          for x in range(len):
            uncompressed[uncompressed_pos + x] = uncompressed[offset + x]

        uncompressed_pos += len

  return uncompressed

import struct

def compress(uncompressed: bytearray | bytes) -> bytearray:
  def find_largest(uncompressed: bytearray | bytes, uncompressed_pos: int) -> tuple[int, int, int]:
    start = max(0, uncompressed_pos - 0x10000)
    before = uncompressed[start :]
    after = uncompressed[uncompressed_pos : uncompressed_pos + 4]
    
    max_len = 0
    max_len_offset = -1
    offset = before.find(after)
    while offset > -1 and start + offset < uncompressed_pos:
      this_len = 4
      while offset + this_len < len(before) and uncompressed_pos + this_len < len(uncompressed) and this_len < 0x103 and before[offset + this_len] == uncompressed[uncompressed_pos + this_len]:
        this_len += 1

      if this_len > max_len:
        max_len = this_len
        max_len_offset = start + offset
      offset = before.find(after, offset + max_len)

    if max_len_offset != -1:
      return 0, max_len_offset, max_len

    if uncompressed[uncompressed_pos:uncompressed_pos + 4] == b"\0\0\0\0":
      zero_pos = uncompressed_pos + 4
      while zero_pos < len(uncompressed) and zero_pos < uncompressed_pos + 0x103 and uncompressed[zero_pos] == 0:
        zero_pos += 1
      if zero_pos < 0xffff:
        zero_len = zero_pos - uncompressed_pos
        return 0, 0x10000 - zero_len, zero_len

    return 1, 0, 0

  compressed = bytearray()
  compressed.extend(struct.pack("<4I", 0x01da3d12, len(uncompressed), 0, 0))

  uncompressed_pos = 0
  bits = 0
  while uncompressed_pos < len(uncompressed):
    bits_pos = len(compressed)
    compressed.append(0)
    bits = 0
    for i in range(8):
      if uncompressed_pos >= len(uncompressed):
        break

      bits_i, max_len_offset, max_len = find_largest(uncompressed, uncompressed_pos)

      if bits_i == 0:
        real_offset = (max_len_offset + 0x10000 - 0xff - 4) & 0xffff
        real_len = max_len - 4
        compressed.extend(struct.pack("<HB", real_offset, real_len))
        uncompressed_pos += max_len
      else:
        compressed.append(uncompressed[uncompressed_pos])
        uncompressed_pos += 1

      bits |= (bits_i << i)
    compressed[bits_pos] = bits

  if len(compressed) - 0x10 > len(uncompressed):
    compressed = bytearray()
    compressed.extend(struct.pack("<4I", 0x00da3d12, len(uncompressed), 0xffffffff, 0))
    compressed.extend(uncompressed)
  else:
    compressed[0x08:0x0c] = struct.pack("<I", len(compressed) - 0x10)
  return compressed

def get_xy_objh_1234(width: int, height: int) -> Generator[tuple[int, int], Any, None]:
  for y_1 in range(0, height, 8):
    for x_1 in range(0, width, 8):
      for y_2 in range(8):
        for x_2 in range(8):
          yield x_1 + x_2, y_1 + y_2

def get_xy_tile(width: int, height: int) -> Generator[tuple[int, int], Any, None]:
  for y in range(height):
    for x in range(width):
      yield x, height - y - 1