snes_utils 0.1.1 → 0.3.0

data/lib/mini_assembler/superfx/definitions.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module SnesUtils
+  module Superfx
+    class Definitions
+      HEX_DIGIT = '[0-9a-f]'
+      REG   = "[rR](\\d{1,2})"
+      LNK   = "([1-4])"
+      HEX   = "\\$?(#{HEX_DIGIT})"
+      HEX8  = "\\$?(#{HEX_DIGIT}{1,2})"
+      HEX16 = "\\$?(#{HEX_DIGIT}{1,4})"
+
+      SINGLE_OPERAND_INSTRUCTIONS = %i[imp imm4 rn rm rel lnk].freeze
+      DOUBLE_OPERAND_INSTRUCTIONS = %i[rn_rn rn_imm8 rn_imm16 rn_addr rn_addrl addr_rn addrl_rn].freeze
+      REL_INSTRUCTIONS = %i[rel].freeze
+      BIT_INSTRUCTIONS = %i[].freeze
+      SFX_INSTRUCTIONS = %i[imm4 rn rm rn_rn rn_imm8 rn_imm16 rn_addr rn_addrl addr_rn addrl_rn].freeze
+      MOV_INSTRUCTIONS = %i[rn_rn]
+      SHORT_ADDR_INSTRUCTIONS = %i[rn_addr addr_rn]
+      INV_DEST_INSTRUCTIONS = %i[addr_rn addrl_rn]
+
+      MODES_REGEXES = {
+        imp: /^$/,             # nothing
+        imm4: /^##{HEX}$/,     # #0-f
+        lnk: /^##{LNK}$/,      # #1-4
+        rn: /^#{REG}$/,        # R1
+        rm: /^\(#{REG}\)$/,    # (R1)
+        rel: /^#{HEX16}$/i,    # label / 1234
+        rn_rn: /^#{REG},#{REG}$/,          # R1, R2
+        rn_imm8: /^#{REG},##{HEX8}$/,      # R1, #12
+        rn_imm16: /^#{REG},##{HEX16}$/,    # R1, #1234
+        rn_addr: /^#{REG},\(#{HEX16}\)$/,   # R1, (1234) ; -> actual data is 1234 / 2
+        rn_addrl: /^#{REG},\(#{HEX16}\)$/, # R1, (1234) ; label
+        addr_rn: /^\(#{HEX16}\),#{REG}$/,   # (1234), R1 ; -> actual data is 1234 / 2
+        addrl_rn: /^\(#{HEX16}\),#{REG}$/, # (1234), R1 ; label
+      }.freeze
+
+      OPCODES_DATA = [
+                      # From game pak ROM to register
+                      { opcode: 0xef, mnemonic: 'GETB',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0xef, mnemonic: 'GETBH', mode: :imp, length: 2, alt: 0x3d },
+                      { opcode: 0xef, mnemonic: 'GETBL', mode: :imp, length: 2, alt: 0x3e },
+                      { opcode: 0xef, mnemonic: 'GETBS', mode: :imp, length: 2, alt: 0x3f },
+                      { opcode: 0xdf, mnemonic: 'GETC',  mode: :imp, length: 1, alt: nil },
+
+                      # From game pak RAM to register
+                      { opcode: 0x4,  mnemonic: 'LDW',   mode: :rm, length: 1, alt: nil },
+                      { opcode: 0x4,  mnemonic: 'LDB',   mode: :rm, length: 1, alt: 0x3d },
+                      { opcode: 0xf,  mnemonic: 'LM',    mode: :rn_addrl, length: 4, alt: 0x3d },
+                      { opcode: 0xa,  mnemonic: 'LMS',   mode: :rn_addr, length: 3, alt: 0x3d },
+
+                      # From register to game pak RAM
+                      { opcode: 0x3,  mnemonic: 'STW',   mode: :rm, length: 1, alt: nil },
+                      { opcode: 0x3,  mnemonic: 'STB',   mode: :rm, length: 2, alt: 0x3d },
+                      { opcode: 0xf,  mnemonic: 'SM',    mode: :addrl_rn, length: 4, alt: 0x3e },
+                      { opcode: 0xa,  mnemonic: 'SMS',   mode: :addr_rn, length: 3, alt: 0x3e },
+                      { opcode: 0x90, mnemonic: 'SBK',   mode: :imp, length: 1, alt: nil },
+
+                      # From register to register
+                      { opcode: 0x2010, mnemonic: 'MOVE', mode: :rn_rn, length: 2, alt: nil },
+                      { opcode: 0x20b0, mnemonic: 'MOVES', mode: :rn_rn, length: 2, alt: nil },
+
+                      # Immediate data to register
+                      { opcode: 0xf,  mnemonic: 'IWT',   mode: :rn_imm16, length: 3, alt: nil },
+                      { opcode: 0xa,  mnemonic: 'IBT',   mode: :rn_imm8, length: 2, alt: nil },
+
+                      # Arithmetic operations
+                      { opcode: 0x5,  mnemonic: 'ADD',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x5,  mnemonic: 'ADD',   mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0x5,  mnemonic: 'ADC',   mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0x5,  mnemonic: 'ADC',   mode: :imm4, length: 2, alt: 0x3f },
+
+                      { opcode: 0x6,  mnemonic: 'SUB',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x6,  mnemonic: 'SUB',   mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0x6,  mnemonic: 'SBC',   mode: :rn, length: 2, alt: 0x3d },
+
+                      { opcode: 0x6,  mnemonic: 'CMP',   mode: :rn, length: 2, alt: 0x3f },
+
+                      { opcode: 0x8,  mnemonic: 'MULT',  mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x8,  mnemonic: 'MULT',  mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0x8,  mnemonic: 'UMULT', mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0x8,  mnemonic: 'UMULT', mode: :imm4, length: 2, alt: 0x3f },
+                      { opcode: 0x9f, mnemonic: 'FMULT', mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x9f, mnemonic: 'LMULT', mode: :imp, length: 2, alt: 0x3d },
+
+                      { opcode: 0x96, mnemonic: 'DIV2',  mode: :imp, length: 2, alt: 0x3d },
+
+                      { opcode: 0xd,  mnemonic: 'INC',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0xe,  mnemonic: 'DEC',   mode: :rn, length: 1, alt: nil },
+
+                      # Logical operations
+                      { opcode: 0x7,  mnemonic: 'AND',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x7,  mnemonic: 'AND',   mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0xc,  mnemonic: 'OR',    mode: :rn, length: 1, alt: nil },
+                      { opcode: 0xc,  mnemonic: 'OR',    mode: :imm4, length: 2, alt: 0x3e },
+                      { opcode: 0x4f, mnemonic: 'NOT',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0xc,  mnemonic: 'XOR',   mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0xc,  mnemonic: 'XOR',   mode: :imm4, length: 2, alt: 0x3f },
+                      { opcode: 0x7,  mnemonic: 'BIC',   mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0x7,  mnemonic: 'BIC',   mode: :imm4, length: 2, alt: 0x3f },
+
+                      # Shift
+                      { opcode: 0x96, mnemonic: 'ASR',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x03, mnemonic: 'LSR',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x04, mnemonic: 'ROL',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x97, mnemonic: 'ROR',   mode: :imp, length: 1, alt: nil },
+
+                      # Byte transfer
+                      { opcode: 0xc0, mnemonic: 'HIB',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x9e, mnemonic: 'LOB',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x70, mnemonic: 'MERGE', mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x95, mnemonic: 'SEX',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x4d, mnemonic: 'SWAP',  mode: :imp, length: 1, alt: nil },
+
+                      # Jump, branch and loop
+                      { opcode: 0x9,  mnemonic: 'JMP',   mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x9,  mnemonic: 'LJMP',  mode: :rn, length: 2, alt: 0x3d },
+                      { opcode: 0x05, mnemonic: 'BRA',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x06, mnemonic: 'BGE',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x07, mnemonic: 'BLT',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x08, mnemonic: 'BNE',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x09, mnemonic: 'BEQ',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0a, mnemonic: 'BPL',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0b, mnemonic: 'BMI',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0c, mnemonic: 'BCC',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0d, mnemonic: 'BCS',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0e, mnemonic: 'BVC',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x0f, mnemonic: 'BVS',   mode: :rel, length: 2, alt: nil },
+                      { opcode: 0x3c, mnemonic: 'LOOP',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x9,  mnemonic: 'LINK',  mode: :imm4, length: 1, alt: nil },
+
+                      # Bank set-up
+                      { opcode: 0xdf, mnemonic: 'ROMB',  mode: :imp, length: 2, alt: 0x3f },
+                      { opcode: 0xdf, mnemonic: 'RAMB',  mode: :imp, length: 2, alt: 0x3e },
+
+                      # Plot related
+                      { opcode: 0x4e, mnemonic: 'CMODE', mode: :imp, length: 2, alt: 0x3d },
+                      { opcode: 0x4e, mnemonic: 'COLOR', mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x4c, mnemonic: 'PLOT',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x4c, mnemonic: 'RPIX',  mode: :imp, length: 2, alt: 0x3d },
+
+                      # Prefix flag
+                      { opcode: 0x3d, mnemonic: 'ALT1',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x3e, mnemonic: 'ALT2',  mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x3f, mnemonic: 'ALT3',  mode: :imp, length: 1, alt: nil },
+
+                      # Prefix register
+                      { opcode: 0xb,  mnemonic: 'FROM',  mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x1,  mnemonic: 'TO',    mode: :rn, length: 1, alt: nil },
+                      { opcode: 0x2,  mnemonic: 'WITH',  mode: :rn, length: 1, alt: nil },
+
+                      # GSU Control
+                      { opcode: 0x02, mnemonic: 'CACHE', mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x01, mnemonic: 'NOP',   mode: :imp, length: 1, alt: nil },
+                      { opcode: 0x00, mnemonic: 'STOP',  mode: :imp, length: 1, alt: nil }].freeze
+    end
+  end
+end

data/lib/mini_assembler/wdc65816/definitions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SnesUtils
   module Wdc65816
     class Definitions
@@ -6,70 +8,70 @@ module SnesUtils
       HEX16 = "\\$?(#{HEX_DIGIT}{3,4})"
       HEX24 = "\\$?(#{HEX_DIGIT}{5,6})"
 
-      SINGLE_OPERAND_INSTRUCTIONS = [:imm, :iml, :imm8, :imm16, :sr, :dp, :dpx, :dpy, :idp, :idx, :idy, :idl, :idly, :isy, :abs, :abx, :aby, :abl, :alx, :ind, :iax, :ial, :rel, :rell]
-      DOUBLE_OPERAND_INSTRUCTIONS = [:bm]
-      REL_INSTRUCTIONS = [:rel, :rell]
-      BIT_INSTRUCTIONS = []
+      SINGLE_OPERAND_INSTRUCTIONS = %i[imm iml imm8 imm16 sr dp dpx dpy idp idx idy idl idly isy abs abx aby abl alx ind iax ial rel rell].freeze
+      DOUBLE_OPERAND_INSTRUCTIONS = [:bm].freeze
+      REL_INSTRUCTIONS = %i[rel rell].freeze
+      BIT_INSTRUCTIONS = [].freeze
 
       MODES_REGEXES = {
-        acc:   /^$/,
-        imp:   /^$/,
-        imm:   /^#{HEX8}$/i,
-        iml:   /^#{HEX16}$/i,
-        imm8:  /^##{HEX8}$/i,
+        acc: /^$/,
+        imp: /^$/,
+        imm: /^#{HEX8}$/i,
+        iml: /^#{HEX16}$/i,
+        imm8: /^##{HEX8}$/i,
         imm16: /^##{HEX16}$/i,
-        sr:    /^#{HEX8},S$/i,
-        dp:    /^#{HEX8}$/i,
-        dpx:   /^#{HEX8},X$/i,
-        dpy:   /^#{HEX8},Y$/i,
-        idp:   /^\(#{HEX8}\)$/i,
-        idx:   /^\(#{HEX8},X\)$/i,
-        idy:   /^\(#{HEX8}\),Y$/i,
-        idl:   /^\[#{HEX8}\]$/i,
-        idly:  /^\[#{HEX8}\],Y$/i,
-        isy:   /^\(#{HEX8},S\),Y$/i,
-        abs:   /^#{HEX16}$/i,
-        abx:   /^#{HEX16},X$/i,
-        aby:   /^#{HEX16},Y$/i,
-        abl:   /^#{HEX24}$/i,
-        alx:   /^#{HEX24},X$/i,
-        ind:   /^\(#{HEX16}\)$/i,
-        iax:   /^\(#{HEX16},X\)$/i,
-        ial:   /^\[#{HEX16}\]$/i,
-        rel:   /^#{HEX16}$/i,
-        rell:  /^#{HEX16}$/i,
-        bm:    /^#{HEX8},#{HEX8}$/i
-      }
+        sr: /^#{HEX8},S$/i,
+        dp: /^#{HEX8}$/i,
+        dpx: /^#{HEX8},X$/i,
+        dpy: /^#{HEX8},Y$/i,
+        idp: /^\(#{HEX8}\)$/i,
+        idx: /^\(#{HEX8},X\)$/i,
+        idy: /^\(#{HEX8}\),Y$/i,
+        idl: /^\[#{HEX8}\]$/i,
+        idly: /^\[#{HEX8}\],Y$/i,
+        isy: /^\(#{HEX8},S\),Y$/i,
+        abs: /^#{HEX16}$/i,
+        abx: /^#{HEX16},X$/i,
+        aby: /^#{HEX16},Y$/i,
+        abl: /^#{HEX24}$/i,
+        alx: /^#{HEX24},X$/i,
+        ind: /^\(#{HEX16}\)$/i,
+        iax: /^\(#{HEX16},X\)$/i,
+        ial: /^\[#{HEX16}\]$/i,
+        rel: /^#{HEX16}$/i,
+        rell: /^#{HEX16}$/i,
+        bm: /^#{HEX8},#{HEX8}$/i
+      }.freeze
 
       MODES_FORMATS = {
-        acc:   "%s",
-        imp:   "%s",
-        imm:   "%s %02X",
-        iml:   "%s %02X",
-        imm8:  "%s #%02X",
-        imm16: "%s #%04X",
-        sr:    "%s %02X,S",
-        dp:    "%s %02X",
-        dpx:   "%s %02X,X",
-        dpy:   "%s %02X,Y",
-        idp:   "%s (%02X)",
-        idx:   "%s (%02X,X)",
-        idy:   "%s (%02X),Y",
-        idl:   "%s [%02X]",
-        idly:  "%s [%02X],Y",
-        isy:   "%s (%02X,S),Y",
-        abs:   "%s %04X",
-        abx:   "%s %04X,X",
-        aby:   "%s %04X,Y",
-        abl:   "%s %06X",
-        alx:   "%s %06X,X",
-        ind:   "%s (%04X)",
-        iax:   "%s (%04X,X)",
-        ial:   "%s [%04X]",
-        rel:   "%s %04X {%s}",
-        rell:  "%s %04X {%s}",
-        bm:    "%s %02X,%02X"
-      }
+        acc: '%s',
+        imp: '%s',
+        imm: '%s %02X',
+        iml: '%s %02X',
+        imm8: '%s #%02X',
+        imm16: '%s #%04X',
+        sr: '%s %02X,S',
+        dp: '%s %02X',
+        dpx: '%s %02X,X',
+        dpy: '%s %02X,Y',
+        idp: '%s (%02X)',
+        idx: '%s (%02X,X)',
+        idy: '%s (%02X),Y',
+        idl: '%s [%02X]',
+        idly: '%s [%02X],Y',
+        isy: '%s (%02X,S),Y',
+        abs: '%s %04X',
+        abx: '%s %04X,X',
+        aby: '%s %04X,Y',
+        abl: '%s %06X',
+        alx: '%s %06X,X',
+        ind: '%s (%04X)',
+        iax: '%s (%04X,X)',
+        ial: '%s [%04X]',
+        rel: '%s %04X {%s}',
+        rell: '%s %04X {%s}',
+        bm: '%s %02X,%02X'
+      }.freeze
 
       OPCODES_DATA = [{ opcode: 0x61, mnemonic: 'ADC', mode: :idx, length: 2 },
                       { opcode: 0x63, mnemonic: 'ADC', mode: :sr, length: 2 },

data/lib/png2snes/png2snes.rb

@@ -1,22 +1,34 @@
 module SnesUtils
   class Png2Snes
-    def initialize(file_path, bpp:4, alpha:nil)
+    CHAR_SIZE = 8
+
+    def initialize(file_path, bpp:4, alpha:nil, mode7: false, m7_palette_offset: nil)
       @file_path = file_path
       @file_dir = File.dirname(@file_path)
       @file_name = File.basename(@file_path, File.extname(@file_path))
       @image = ChunkyPNG::Image.from_file(@file_path)
-      @pixels = pixels_to_bgr5
 
+      @mode7 = mode7
+
+      raise ArgumentError, 'Image width and height must be a multiple of sprite size' if (@image.width % CHAR_SIZE != 0) or (@image.height % CHAR_SIZE != 0)
+
+      @pixels = pixels_to_bgr5
       @palette = @pixels.uniq
-      @char_size = 8
 
-      raise ArgumentError, 'BPP must be 2, 4, or 8' unless [2, 4, 8].include? bpp
-      @bpp = bpp
+      if @mode7
+        raise ArgumentError, 'mode 7 palette offset must be multiple of 16' if m7_palette_offset % 16 != 0
+        raise ArgumentError, 'mode 7 palette offset must be less than 112' if m7_palette_offset > 112
+        @m7_palette_offset = m7_palette_offset
 
-      raise ArgumentError, 'Image width and height must be a multiple of sprite size' if (@image.width % @char_size != 0) or (@image.height % @char_size != 0)
+        unshift_alpha(alpha) if alpha
+        fill_palette
+      else
+        raise ArgumentError, 'BPP must be 2, 4, or 8' unless [2, 4, 8].include? bpp
+        @bpp = bpp
 
-      alpha_first if alpha
-      fill_palette
+        unshift_alpha(alpha) if alpha
+        fill_palette
+      end
     end
 
     def pixels_to_bgr5
@@ -29,17 +41,22 @@ module SnesUtils
       end
     end
 
-    def alpha_first
+    def unshift_alpha(alpha)
+      @palette.unshift(alpha)
     end
 
     def fill_palette
-      target_size = 2**@bpp
+      target_size = @mode7 ? mode_7_pal_size : 2**@bpp
       missing_colors = target_size - @palette.count
       raise ArgumentError, "Palette size too large for target BPP (#{@palette.count})" if missing_colors < 0
 
       @palette += [0] * missing_colors
     end
 
+    def mode_7_pal_size
+      128 - @m7_palette_offset
+    end
+
     def write hex, file_path
       File.open(file_path, 'w+b') do |file|
         file.write([hex.join].pack('H*'))
@@ -48,7 +65,7 @@ module SnesUtils
 
     def write_palette
       palette_hex = @palette.map { |c| ('%04x' % c).scan(/.{2}/).reverse.join }
-      write palette_hex, File.expand_path("#{@file_name}-pal.bin", @file_dir)
+      write palette_hex, File.expand_path("#{@file_name}.pal", @file_dir)
     end
 
     def pixel_indices
@@ -60,16 +77,20 @@ module SnesUtils
     def extract_sprites
       pixel_idx = pixel_indices
 
-      sprite_per_row = @image.width / @char_size
-      sprite_per_col = @image.height / @char_size
+      sprite_per_row = @image.width / CHAR_SIZE
+      sprite_per_col = @image.height / CHAR_SIZE
       sprite_per_sheet =  sprite_per_row * sprite_per_col
 
       sprites = []
       (0..sprite_per_sheet-1).each do |s|
         sprite = []
-        (0..@char_size-1).each do |r|
-          offset = (s/sprite_per_row)*sprite_per_row * @char_size**2 + s % sprite_per_row * @char_size
-          sprite += pixel_idx[offset + r*sprite_per_row*@char_size, @char_size]
+        (0..CHAR_SIZE-1).each do |r|
+          offset = (s/sprite_per_row)*sprite_per_row * CHAR_SIZE**2 + s % sprite_per_row * CHAR_SIZE
+          if @mode7
+            sprite += @pixels[offset + r*sprite_per_row*CHAR_SIZE, CHAR_SIZE]
+          else
+            sprite += pixel_idx[offset + r*sprite_per_row*CHAR_SIZE, CHAR_SIZE]
+          end
         end
         sprites.push(sprite)
       end
@@ -87,7 +108,11 @@ module SnesUtils
     end
 
     def write_image
-      sprite_per_row = @image.width / @char_size
+      @mode7 ? write_image_m7 : write_image_m06
+    end
+
+    def write_image_m06
+      sprite_per_row = @image.width / CHAR_SIZE
       sprites = extract_sprites
       sprites_bitplanes = sprites.map { |s| extract_bitplanes s }
 
@@ -97,9 +122,9 @@ module SnesUtils
 
         bitplane_bits = ""
         sprite_bitplane_pairs.each do |bitplane|
-          (0..@char_size-1).each do |r|
-            offset = r*@char_size
-            bitplane_bits += bitplane[0][offset, @char_size].join + bitplane[1][offset, @char_size].join
+          (0..CHAR_SIZE-1).each do |r|
+            offset = r*CHAR_SIZE
+            bitplane_bits += bitplane[0][offset, CHAR_SIZE].join + bitplane[1][offset, CHAR_SIZE].join
           end
         end
         image_bits += bitplane_bits
@@ -107,8 +132,15 @@ module SnesUtils
       end
 
       image_hex = image_bits.scan(/.{8}/).map { |b| "%02x" % b.to_i(2) }
-      write image_hex, File.expand_path("#{@file_name}.bin", @file_dir)
+      write image_hex, File.expand_path("#{@file_name}.tiles", @file_dir)
     end
 
+    def write_image_m7
+      sprites = extract_sprites
+
+      indices = sprites.flatten.map { |color| "%02x" % (@palette.index(color) + @m7_palette_offset) }
+
+      write indices, File.expand_path("#{@file_name}.tiles", @file_dir)
+    end
   end
 end

data/lib/snes_utils.rb

@@ -1,16 +1,16 @@
 require 'readline'
 require 'chunky_png'
-require 'matrix'
-require 'nokogiri'
-
-require 'byebug'
+require 'csv'
 
 require 'mini_assembler/mini_assembler'
 require 'mini_assembler/definitions'
 require 'mini_assembler/wdc65816/definitions'
 require 'mini_assembler/spc700/definitions'
+require 'mini_assembler/superfx/definitions'
 require 'png2snes/png2snes'
 require 'tmx2snes/tmx2snes'
 
+require 'vas/vas'
+
 module SnesUtils
 end

data/lib/tmx2snes/tmx2snes.rb

@@ -14,14 +14,9 @@ module SnesUtils
       tnm = big_char ? 2 : 1 # big_char : 16x16 tiles. otherwise, 8x8 tiles
       row_offset = 16 * (tnm - 1) # Skip a row in case of 16x16 tiles ( tile #9 starts at index 32)
 
-      doc = Nokogiri::XML(File.open(@file_path))
-      csv_node = doc.xpath('//data').children.first.to_s
-
-      csv = csv_node.split("\n").compact.reject { |e| e.empty? }.map { |row| row.split(',') }
-
-      csv.each do |row|
+      CSV.foreach(@file_path) do |row|
         raise if row.length != 32
-        @tilemap += row.map { |r| (r.to_i - 1)*tnm + row_offset * ((r.to_i - 1)/8).to_i }
+        @tilemap += row.map { |r| (r.to_i)*tnm + row_offset * ((r.to_i)/8).to_i }
       end
 
       raise if @tilemap.length != 32*32