sabrina 0.5.5

data/lib/sabrina/config/charmap_out.rb

@@ -0,0 +1,144 @@
+Sabrina::Config.load(
+  charmap_out: {
+    '00' => ' ',
+    '01' => 'A',
+    '02' => '?',
+    '03' => 'A',
+    '04' => 'C',
+    '05' => 'E',
+    '06' => 'E',
+    '07' => 'E',
+    '08' => 'E',
+    '09' => '?',
+    '0B' => 'I',
+    '0C' => 'I',
+    '0D' => '?',
+    '0E' => '?',
+    '0F' => 'O',
+    '10' => 'Œ',
+    '11' => 'U',
+    '12' => '?',
+    '13' => 'U',
+    '14' => '?',
+    '15' => '?',
+    '16' => 'à',
+    '17' => '?',
+    '19' => 'ç',
+    '1A' => 'è',
+    '1B' => 'é',
+    '1C' => 'ê',
+    '1D' => 'ë',
+    '1E' => '?',
+    '20' => 'î',
+    '21' => 'ï',
+    '22' => '?',
+    '23' => '?',
+    '24' => 'ô',
+    '25' => 'œ',
+    '26' => 'ù',
+    '27' => '?',
+    '28' => 'û',
+    '29' => '?',
+    '2A' => '?',
+    '2B' => '?',
+    '2D' => '&',
+    '2E' => '+',
+    '35' => '',
+    '36' => ';',
+    '51' => '?',
+    '52' => '?',
+    '5A' => '?',
+    '5B' => '%',
+    '5C' => '(',
+    '5D' => ')',
+    '68' => 'â',
+    '6F' => '?',
+    '85' => '<',
+    '86' => '>',
+    'A1' => '0',
+    'A2' => '1',
+    'A3' => '2',
+    'A4' => '3',
+    'A5' => '4',
+    'A6' => '5',
+    'A7' => '6',
+    'A8' => '7',
+    'A9' => '8',
+    'AA' => '9',
+    'AB' => '!',
+    'AC' => '?',
+    'AD' => '.',
+    'AE' => '-',
+    'AF' => '·',
+    'B1' => '«',
+    'B2' => '»',
+    'B3' => '/',
+    'B4' => "\\",
+    'B5' => '♂',
+    'B6' => '♀',
+    'B7' => '$',
+    'B8' => ',',
+    'B9' => '*',
+    'BA' => '/',
+    'BB' => 'A',
+    'BC' => 'B',
+    'BD' => 'C',
+    'BE' => 'D',
+    'BF' => 'E',
+    'C0' => 'F',
+    'C1' => 'G',
+    'C2' => 'H',
+    'C3' => 'I',
+    'C4' => 'J',
+    'C5' => 'K',
+    'C6' => 'L',
+    'C7' => 'M',
+    'C8' => 'N',
+    'C9' => 'O',
+    'CA' => 'P',
+    'CB' => 'Q',
+    'CC' => 'R',
+    'CD' => 'S',
+    'CE' => 'T',
+    'CF' => 'U',
+    'D0' => 'V',
+    'D1' => 'W',
+    'D2' => 'X',
+    'D3' => 'Y',
+    'D4' => 'Z',
+    'D5' => 'a',
+    'D6' => 'b',
+    'D7' => 'c',
+    'D8' => 'd',
+    'D9' => 'e',
+    'DA' => 'f',
+    'DB' => 'g',
+    'DC' => 'h',
+    'DD' => 'i',
+    'DE' => 'j',
+    'DF' => 'k',
+    'E0' => 'l',
+    'E1' => 'm',
+    'E2' => 'n',
+    'E3' => 'o',
+    'E4' => 'p',
+    'E5' => 'q',
+    'E6' => 'r',
+    'E7' => 's',
+    'E8' => 't',
+    'E9' => 'u',
+    'EA' => 'v',
+    'EB' => 'w',
+    'EC' => 'x',
+    'ED' => 'y',
+    'EE' => 'z',
+    'F1' => '?',
+    'F2' => '?',
+    'F3' => 'U',
+    'F4' => '?',
+    'F5' => '?',
+    'F6' => 'ü',
+    'FE' => "\n",
+    'FF' => '$'
+  }
+)

data/lib/sabrina/config/charmap_out_special.rb

@@ -0,0 +1,28 @@
+Sabrina::Config.load(
+  charmap_out_special: {
+    '34' => '[Lv]',
+    '53' => '[pk]',
+    '54' => '[mn]',
+    '55' => '[po]',
+    '56' => '[ké]',
+    '57' => '[bl]',
+    '58' => '[oc]',
+    '59' => '[k]',
+    '79' => '[U]',
+    '7A' => '[D]',
+    '7B' => '[L]',
+    '7C' => '[R]',
+    'B0' => '...',
+    'EF' => '|>|',
+    'F0' => ' =>',
+    'F7' => '|A|',
+    'F8' => '|V|',
+    'F9' => '|<|',
+    'FA' => '|nb|',
+    'FB' => '|nb2|',
+    'FC' => '|FC|',
+    'FD' => '|FD|',
+    'FE' => '|br|',
+    'FF' => '|end|'
+  }
+)

data/lib/sabrina/config/main.rb

@@ -0,0 +1,105 @@
+Sabrina::Config.load(
+  log_file: 'sabrina.log',
+
+  rom_defaults: {
+    title: 'Default ROM',
+
+    dex_blank_start: 252,
+    dex_blank_length: 25,
+    dex_length: 440,
+
+    name_length: 11,
+    stats_length: 28,
+    item_length: 44,
+    ability_length: 13,
+    type_length: 7,
+
+    frames: [1, 1],
+    special_frames: {
+      385 => [4, 4],
+      410 => [2, 2]
+    },
+
+    free_space_start: '0x740000',
+
+    name_table: '0x245EE0',
+
+    front_table: '0x2350AC',
+    back_table: '0x23654C',
+    palette_table: '0x23730C',
+    shinypal_table: '0x2380cc',
+
+    stats_table: '0x254784',
+    item_table: '0x3DB028',
+    ability_table: '0x24FC40',
+    type_table: '0x24F1A0'
+  },
+
+  rom_data: {
+    BPRE: {
+      title: 'FireRed (E)',
+
+      name_table: '0x245EE0',
+
+      front_table: '0x2350AC',
+      back_table: '0x23654C',
+      palette_table: '0x23730C',
+      shinypal_table: '0x2380cc',
+
+      stats_table: '0x254784',
+      item_table: '0x3DB028',
+      ability_table: '0x24FC40',
+      type_table: '0x24F1A0'
+    },
+
+    BPEE: {
+      title: 'Emerald (E)',
+
+      frames: [2, 1],
+
+      name_table: '0x3185C8',
+
+      front_table: '0x30A18C',
+      back_table: '0x3028B8',
+      palette_table: '0x303678',
+      shinypal_table: '0x304438',
+
+      stats_table: '0x3203CC',
+      item_table: '0x5839A0',
+      ability_table: '0x31B6DB',
+      type_table: '0x31AE38'
+    },
+
+    AXVE: {
+      title: 'Ruby (E)',
+
+      name_table: '0x1F716C',
+
+      front_table: '0x1E8354',
+      back_table: '0x1E97F4',
+      palette_table: '0x1EA5B4',
+      shinypal_table: '0x1EB374',
+
+      stats_table: '0x1FEC18',
+      item_table: '0x3C5564',
+      ability_table: '0x1FA248',
+      type_table: '0x1F9870'
+    },
+
+    MrDS: {
+      title: "MrDollSteak's Decap and Attack Rombase",
+
+      name_table: '0x245EE0',
+
+      front_table: '0x2350AC',
+      back_table: '0x23654C',
+      palette_table: '0x23730C',
+      shinypal_table: '0x2380cc',
+
+      stats_table: '0x254784',
+      item_table: '0x3DB028',
+      ability_table: '0x950000',
+      type_table: '0x961B50'
+    }
+  }
+)

data/lib/sabrina/gba_string.rb

@@ -0,0 +1,156 @@
+module Sabrina
+  # A class for dealing with string data stored on a ROM.
+  #
+  # It is required that +:rom+ and either +:table+ and +:index+ (recommended)
+  # or +:offset+ be set in order to enable writing back to a ROM file.
+  class GBAString < Bytestream
+    # The byte to recognize as a blank character (space) for
+    # line breaking.
+    BLANK = "\x00"
+
+    # The byte used to right-pad short strings to the desired length.
+    FILLER = "\x00"
+
+    # The line break byte.
+    NEWLINE = "\xFE"
+
+    # The byte recognized as the end of GBA-encoded string data.
+    TERMINATOR = "\xFF"
+
+    # The fallback byte for GBA encoding.
+    MISSING_HEX = "\x00"
+
+    # The fallback character for GBA decoding.
+    MISSING_CHR = '?'
+
+    # An input string ending with this character will be treated as
+    # already terminated.
+    TERMINATOR_CHR = '$'
+
+    class << self
+      # Creates a new {GBAString} object from a ROM offset, attempting
+      # to read it as a GBA-encoded, 0xFF-terminated string.
+      #
+      # @param [Rom] rom
+      # @param [Integer, String] offset The offset to seek to in the ROM.
+      #   See {Bytestream.parse_offset} for details.
+      # @param [Hash] h see {Bytestream#initialize}
+      # @return [GBAString]
+      def from_rom(rom, offset, h = {})
+        h.merge!(rom: rom, offset: offset)
+
+        new(h)
+      end
+
+      # Same as {ByteInput#from_table}, but allows +index_length+
+      # to default to 11 (the typical value for a monster name table)
+      # and requires no +length+ due to implicit string mode.
+      #
+      # @return [GBAString]
+      # @see ByteInput#from_table
+      def from_table(rom, table, index, index_length = 11, h = {})
+        super(rom, table, index, index_length, nil, h)
+      end
+
+      # Creates a new {GBAString} object from a string,
+      # encoding it to GBA format and optionally normalizing to
+      # +length+ and breaking within +break_range+.
+      #
+      # @param [String] s
+      # @param [Integer] length
+      # @param [Range] break_range
+      # @param [Hash] h see {Bytestream#initialize}
+      # @return [GBAString]
+      def from_string(s, break_range = nil, length = nil, h = {})
+        length ||= (s.end_with?('$') ? s.length : s.length + 1)
+
+        h.merge!(
+          representation: s,
+          length: length,
+          break_range: break_range
+        )
+
+        new(h)
+      end
+    end
+
+    # Same as {Bytestream#initialize}, but with +:is_gba_string+
+    # set to true by default and support for the following extra
+    # options.
+    #
+    # @param [Hash] h
+    # @option h [Range] :break_range where in the string to try and
+    #   insert a newline.
+    # @see Bytestream#initialize
+    def initialize(h = {})
+      @is_gba_string = true
+      @break_range = nil
+
+      super
+    end
+
+    # Attempts to decode the byte data as a GBA-encoded string.
+    #
+    # @return [String]
+    def present
+      return @representation if @representation
+
+      charmap = Config.charmap_out
+      # charmap.merge!(Config.charmap_out_special) if special
+
+      a = []
+      to_bytes.each_char do |x|
+        hexcode = format('%02X', x.each_byte.to_a[0])
+        a.push(charmap.fetch(hexcode, MISSING_CHR))
+      end
+
+      @representation = a.join('')
+    end
+
+    # Encodes the internal string data to a GBA-encoded byte stream.
+    #
+    # @return [String]
+    def generate_bytes
+      s = present.dup
+
+      a = s.scan(/./).map do |x|
+        hexcode = Config.charmap_in.fetch(x, MISSING_HEX)
+        hexcode.hex.chr
+      end
+
+      if @length
+        if a.length > @length
+          a.slice!(@length..-1)
+        else
+          a << FILLER until a.length >= @length
+        end
+        a[-1] = TERMINATOR
+      else
+        a << TERMINATOR
+      end
+
+      if @break_range
+        break_index = @break_range.first + (a[@break_range].rindex(BLANK) || 3)
+        a[break_index] = NEWLINE
+      end
+
+      a.map { |x| x.force_encoding('ASCII-8BIT') }
+        .join(''.force_encoding('ASCII-8BIT'))
+    end
+
+    # Returns the string representation with the end of string mark trimmed.
+    #
+    # @return [String]
+    def to_s
+      present.dup.chomp('$')
+    end
+
+    private
+
+    # @see {Bytestream#load_settings}
+    def load_settings(h)
+      @break_range = h.fetch(:break_range, @break_range)
+      super
+    end
+  end
+end

data/lib/sabrina/lz77.rb

@@ -0,0 +1,161 @@
+module Sabrina
+  # An utility module for compressing and decompressing data in a
+  # GBA-compliant {http://en.wikipedia.org/wiki/LZ77_and_LZ78 LZ77} format.
+  #
+  # This has mostly been ported directly from
+  # {https://github.com/thekaratekid552/Secret-Tool/blob/master/lib/Tools/LZ77.py
+  # Gen III Hacking Suite}'s corresponding tool by thekaratekid552 and
+  # contributors.
+  #
+  # Credit goes to thekaratekid552, Jambo51, Shiny Quagsire,
+  # DoesntKnowHowToPlay, Interdpth.
+  module Lz77
+    class << self
+      # Decompresses data from +offset+ in the ROM file as Lz77. This returns a
+      # hash consisting of the uncompressed +:stream+ and the +:original_length+
+      # of the compressed data, but the latter value is currently inaccurate and
+      # should not be relied upon for wiping old data.
+      #
+      # @param [Rom] rom
+      # @param [Integer] offset
+      # @return [Hash] contains the uncompressed data as +:stream+, the
+      #   estimated original compressed length as +:original_length+, and
+      #   the original compressed data as +:original_stream+.
+      def uncompress(rom, offset)
+        f = rom.file
+        f.seek(offset)
+
+        test = f.read(1)
+        unless test == "\x10"
+          fail "Offset #{offset} in #{rom.filename} does not appear" \
+            " to be lz77 data. (Found #{ format('%02X', test.unpack('C')) })"
+        end
+
+        target_length = Bytestream.from_bytes(f.read(3).reverse).to_i
+
+        data = ''
+
+        loop do
+          bit_field = format('%08b', f.read(1).unpack('C').first)
+
+          bit_field.each_char do |x|
+            if data.length >= target_length
+              compressed_length = f.pos - offset
+              compressed_length += 1 until compressed_length % 4 == 0
+              original = rom.read(offset, compressed_length)
+              return {
+                stream: data.slice(0, target_length),
+                original_stream: original,
+                original_length: compressed_length
+              }
+            end
+            next data << f.read(1) if x == '0'
+
+            r5 = f.read(1).unpack('C').first
+            store = r5
+            r6 = 3
+            r3 = (r5 >> 4) + r6
+            r6 = store
+            r5 = r6 & 0xF
+            r12 = r5 << 8
+            r6 = f.read(1).unpack('C').first
+            r5 = r6 | r12
+            r12 = r5 + 1
+
+            r3.times do
+              unless (r5 = data[-r12])
+                fail "Decompression failed at offset #{offset} in" \
+                  " #{rom.filename}. Possible corrupted file or unknown" \
+                  " compression method. #{[bit_field, r3, r5, r6, r12]}"
+              end
+              data << r5
+            end
+          end
+        end
+      end
+
+      # Compresses the supplied stream of bytes as GBA-compliant Lz77 data.
+      #
+      # @param [String] data
+      # @return [String] the compressed data.
+      def compress(data)
+        compressed = "\x10"
+        compressed <<
+          Bytestream.from_hex(format('%06X', data.length)).to_b.reverse
+
+        index = 0
+        w = 0xFFF
+        window = ''
+        lookahead = ''
+
+        loop do
+          bits = ''
+          check = nil
+          current_chunk = ''
+
+          8.times do
+            window = (index < w ? data[0, index] : data[(index % w)..index])
+            lookahead = data[index..-1]
+
+            if lookahead.nil? || lookahead.empty?
+              unless bits.empty?
+                while bits.length < 8
+                  bits << '0'
+                  current_chunk << "\x00"
+                end
+                compressed <<
+                  Bytestream.from_hex(format('%02x', bits.to_i(2))).to_b <<
+                  current_chunk
+              end
+              break
+            end
+
+            check = window.index(lookahead[0..2])
+            if check
+              bits << '1'
+              length = 2
+              store_length = 0
+              store_check = 0
+              while check && length < 18
+                store_length = length
+                length += 1
+                store_check = check
+                check = window.index(lookahead[0, length])
+              end
+              index += store_length
+              store_length -= 3
+              position = window.length - 1 - store_check
+              store_length = store_length << 12
+              current_chunk <<
+                Bytestream.from_hex(format('%04X', (store_length | position))).to_b
+            else
+              index += 1
+              bits << '0'
+              current_chunk << lookahead[0]
+            end
+          end # 8.times
+
+          if lookahead.nil? || lookahead.empty?
+            unless bits.empty?
+              while bits.length < 8
+                bits << '0'
+                current_chunk << "\x00"
+              end
+              compressed <<
+                Bytestream.from_hex(format('%02x', bits.to_i(2))).to_b <<
+                current_chunk
+            end
+            break
+          end
+
+          compressed <<
+            Bytestream.from_hex(format('%02x', bits.to_i(2))).to_b <<
+            current_chunk
+        end # loop
+
+        compressed << "\x00" until compressed.length % 4 == 0
+        compressed
+      end # compress
+    end
+  end
+end