snes_utils 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d649dce97b8d4385763f9fc18ee9917cff690b938beac9f281b1f13666b7dbd1
+  data.tar.gz: 206fc1e24eb2acfda9380ce3295beec7c402f9076eaebd2bcafcde6df19c0283
+SHA512:
+  metadata.gz: 598b0c6c67ca081027148860638653eed841e3492f748ccc0173cf63fbe2f4a2a0fe4f3c4b00f31f46c7f357adaa112ca13cdd7f303f750cc2c60472c055ae65
+  data.tar.gz: ba437c0b86b96a60eb141edfc9a8a80f59ca39d352013d31fd1181b251d571da0234827d68bc415af44d2ba67e0dc47d649ad9bfe9aa759c08e425d36567860e

data/bin/mini_assembler

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'snes_utils'
+
+options = {}
+OptionParser.new do |opts|
+  opts.on('-f', '--file FILENAME', 'ROM file') { |o| options[:filename] = o }
+end.parse!
+
+SnesUtils::MiniAssembler.new(options[:filename]).run

data/bin/png2snes

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'snes_utils'
+
+options = {}
+OptionParser.new do |opts|
+  opts.on('-f', '--file FILENAME', 'PNG source file') { |o| options[:filename] = o }
+end.parse!
+
+raise OptionParser::MissingArgument, 'Must specify PNG source file' if options[:filename].nil?
+
+c = SnesUtils::Png2Snes.new options[:filename]
+c.write_palette
+c.write_image

data/bin/tmx2snes

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'snes_utils'
+
+options = {}
+OptionParser.new do |opts|
+  opts.on('-f', '--file FILENAME', 'TMX source file') { |o| options[:filename] = o }
+  opts.on('-s', '--tile-size TILESIZE', '8 or 16') { |o| options[:tile_size] = o.to_i }
+end.parse!
+
+raise OptionParser::MissingArgument, 'Must specify TMX source file' if options[:filename].nil?
+raise 'Wrong size : must either be 8 or 16' unless [8, 16].include? options[:tile_size]
+
+t = SnesUtils::Tmx2Snes.new options[:filename], big_char: options[:tile_size] == 16
+
+t.write

data/lib/mini_assembler/definitions.rb

@@ -0,0 +1,347 @@
+module SnesUtils
+  class Definitions
+    HEX_DIGIT = '[0-9a-f]'
+    HEX8  = "\\$?(#{HEX_DIGIT}{1,2})"
+    HEX16 = "\\$?(#{HEX_DIGIT}{3,4})"
+    HEX24 = "\\$?(#{HEX_DIGIT}{5,6})"
+
+    MODES_REGEXES = {
+      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
+    }
+
+    BYTE_LOC_REGEX = /^#{HEX_DIGIT}{1,4}$/i
+    BYTE_RANGE_REGEX = /^(#{HEX_DIGIT}{1,4})\.+(#{HEX_DIGIT}{1,4})$/i
+    BYTE_SEQUENCE_REGEX = /^(#{HEX_DIGIT}{1,4}):\s*([0-9a-f ]+)$/i
+    DISASSEMBLE_REGEX = /^(#{HEX_DIGIT}{,4})l/i
+    SWITCH_BANK_REGEX = /^(#{HEX_DIGIT}{1,2})\/$/i
+    FLIP_MX_REG_REGEX = /^([01])=([xm])$/i
+    WRITE_REGEX = /^\.write\s*(.*)$/i
+    INCBIN_REGEX = /^(#{HEX_DIGIT}{1,4}):\s*\.incbin\s+(.*)$/i
+    READ_REGEX = /^\.read\s+(.*)$/i
+
+    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"
+    }
+
+    OPCODES_DATA = [{ opcode: 0x61, mnemonic: 'ADC', mode: :idx, length: 2 },
+                    { opcode: 0x63, mnemonic: 'ADC', mode: :sr, length: 2 },
+                    { opcode: 0x65, mnemonic: 'ADC', mode: :dp, length: 2 },
+                    { opcode: 0x67, mnemonic: 'ADC', mode: :idl, length: 2 },
+                    { opcode: 0x69, mnemonic: 'ADC', mode: :imm8, length: 2, m: 1 },
+                    { opcode: 0x69, mnemonic: 'ADC', mode: :imm16, length: 3, m: 0 },
+                    { opcode: 0x6d, mnemonic: 'ADC', mode: :abs, length: 3 },
+                    { opcode: 0x6f, mnemonic: 'ADC', mode: :abl, length: 4 },
+                    { opcode: 0x71, mnemonic: 'ADC', mode: :idy, length: 2 },
+                    { opcode: 0x72, mnemonic: 'ADC', mode: :idp, length: 2 },
+                    { opcode: 0x73, mnemonic: 'ADC', mode: :isy, length: 2 },
+                    { opcode: 0x75, mnemonic: 'ADC', mode: :dpx, length: 2 },
+                    { opcode: 0x77, mnemonic: 'ADC', mode: :idly, length: 2 },
+                    { opcode: 0x79, mnemonic: 'ADC', mode: :aby, length: 3 },
+                    { opcode: 0x7d, mnemonic: 'ADC', mode: :abx, length: 3 },
+                    { opcode: 0x7f, mnemonic: 'ADC', mode: :alx, length: 4 },
+                    { opcode: 0xe1, mnemonic: 'SBC', mode: :idx, length: 2 },
+                    { opcode: 0xe3, mnemonic: 'SBC', mode: :sr, length: 2 },
+                    { opcode: 0xe5, mnemonic: 'SBC', mode: :dp, length: 2 },
+                    { opcode: 0xe7, mnemonic: 'SBC', mode: :idl, length: 2 },
+                    { opcode: 0xe9, mnemonic: 'SBC', mode: :imm8, length: 2, m: 1 },
+                    { opcode: 0xe9, mnemonic: 'SBC', mode: :imm16, length: 3, m: 0 },
+                    { opcode: 0xed, mnemonic: 'SBC', mode: :abs, length: 3 },
+                    { opcode: 0xef, mnemonic: 'SBC', mode: :abl, length: 4 },
+                    { opcode: 0xf1, mnemonic: 'SBC', mode: :idy, length: 2 },
+                    { opcode: 0xf2, mnemonic: 'SBC', mode: :idp, length: 2 },
+                    { opcode: 0xf3, mnemonic: 'SBC', mode: :isy, length: 2 },
+                    { opcode: 0xf5, mnemonic: 'SBC', mode: :dpx, length: 2 },
+                    { opcode: 0xf7, mnemonic: 'SBC', mode: :idly, length: 2 },
+                    { opcode: 0xf9, mnemonic: 'SBC', mode: :aby, length: 3 },
+                    { opcode: 0xfd, mnemonic: 'SBC', mode: :abx, length: 3 },
+                    { opcode: 0xff, mnemonic: 'SBC', mode: :alx, length: 4 },
+                    { opcode: 0xc1, mnemonic: 'CMP', mode: :idx, length: 2 },
+                    { opcode: 0xc3, mnemonic: 'CMP', mode: :sr, length: 2 },
+                    { opcode: 0xc5, mnemonic: 'CMP', mode: :dp, length: 2 },
+                    { opcode: 0xc7, mnemonic: 'CMP', mode: :idl, length: 2 },
+                    { opcode: 0xc9, mnemonic: 'CMP', mode: :imm8, length: 2, m: 1 },
+                    { opcode: 0xc9, mnemonic: 'CMP', mode: :imm16, length: 3, m: 0 },
+                    { opcode: 0xcd, mnemonic: 'CMP', mode: :abs, length: 3 },
+                    { opcode: 0xcf, mnemonic: 'CMP', mode: :abl, length: 4 },
+                    { opcode: 0xd1, mnemonic: 'CMP', mode: :idy, length: 2 },
+                    { opcode: 0xd2, mnemonic: 'CMP', mode: :idp, length: 2 },
+                    { opcode: 0xd3, mnemonic: 'CMP', mode: :isy, length: 2 },
+                    { opcode: 0xd5, mnemonic: 'CMP', mode: :dpx, length: 2 },
+                    { opcode: 0xd7, mnemonic: 'CMP', mode: :idly, length: 2 },
+                    { opcode: 0xd9, mnemonic: 'CMP', mode: :aby, length: 3 },
+                    { opcode: 0xdd, mnemonic: 'CMP', mode: :abx, length: 3 },
+                    { opcode: 0xdf, mnemonic: 'CMP', mode: :alx, length: 4 },
+                    { opcode: 0xe0, mnemonic: 'CPX', mode: :imm8, length: 2, x: 1 },
+                    { opcode: 0xe0, mnemonic: 'CPX', mode: :imm16, length: 3, x: 0 },
+                    { opcode: 0xe4, mnemonic: 'CPX', mode: :dp, length: 2 },
+                    { opcode: 0xec, mnemonic: 'CPX', mode: :abs, length: 3 },
+                    { opcode: 0xc0, mnemonic: 'CPY', mode: :imm8, length: 2, x: 1 },
+                    { opcode: 0xc0, mnemonic: 'CPY', mode: :imm16, length: 3, x: 0 },
+                    { opcode: 0xc4, mnemonic: 'CPY', mode: :dp, length: 2 },
+                    { opcode: 0xcc, mnemonic: 'CPY', mode: :abs, length: 3 },
+                    { opcode: 0x3a, mnemonic: 'DEC', mode: :acc, length: 1 },
+                    { opcode: 0xc6, mnemonic: 'DEC', mode: :dp, length: 2 },
+                    { opcode: 0xce, mnemonic: 'DEC', mode: :abs, length: 3 },
+                    { opcode: 0xd6, mnemonic: 'DEC', mode: :dpx, length: 2 },
+                    { opcode: 0xde, mnemonic: 'DEC', mode: :abx, length: 3 },
+                    { opcode: 0xca, mnemonic: 'DEX', mode: :imp, length: 1 },
+                    { opcode: 0x88, mnemonic: 'DEY', mode: :imp, length: 1 },
+                    { opcode: 0x1a, mnemonic: 'INC', mode: :acc, length: 1 },
+                    { opcode: 0xe6, mnemonic: 'INC', mode: :dp, length: 2 },
+                    { opcode: 0xee, mnemonic: 'INC', mode: :abs, length: 3 },
+                    { opcode: 0xf6, mnemonic: 'INC', mode: :dpx, length: 2 },
+                    { opcode: 0xfe, mnemonic: 'INC', mode: :abx, length: 3 },
+                    { opcode: 0xe8, mnemonic: 'INX', mode: :imp, length: 1 },
+                    { opcode: 0xc8, mnemonic: 'INY', mode: :imp, length: 1 },
+                    { opcode: 0x21, mnemonic: 'AND', mode: :idx, length: 2 },
+                    { opcode: 0x23, mnemonic: 'AND', mode: :sr, length: 2 },
+                    { opcode: 0x25, mnemonic: 'AND', mode: :dp, length: 2 },
+                    { opcode: 0x27, mnemonic: 'AND', mode: :idl, length: 2 },
+                    { opcode: 0x29, mnemonic: 'AND', mode: :imm8, length: 2, m: 1 },
+                    { opcode: 0x29, mnemonic: 'AND', mode: :imm16, length: 3, m: 0 },
+                    { opcode: 0x2d, mnemonic: 'AND', mode: :abs, length: 3 },
+                    { opcode: 0x2f, mnemonic: 'AND', mode: :abl, length: 4 },
+                    { opcode: 0x31, mnemonic: 'AND', mode: :idy, length: 2 },
+                    { opcode: 0x32, mnemonic: 'AND', mode: :idp, length: 2 },
+                    { opcode: 0x33, mnemonic: 'AND', mode: :isy, length: 2 },
+                    { opcode: 0x35, mnemonic: 'AND', mode: :dpx, length: 2 },
+                    { opcode: 0x37, mnemonic: 'AND', mode: :idly, length: 2 },
+                    { opcode: 0x39, mnemonic: 'AND', mode: :aby, length: 3 },
+                    { opcode: 0x3d, mnemonic: 'AND', mode: :abx, length: 3 },
+                    { opcode: 0x3f, mnemonic: 'AND', mode: :alx, length: 4 },
+                    { opcode: 0x41, mnemonic: 'EOR', mode: :idx, length: 2 },
+                    { opcode: 0x43, mnemonic: 'EOR', mode: :sr, length: 2 },
+                    { opcode: 0x45, mnemonic: 'EOR', mode: :dp, length: 2 },
+                    { opcode: 0x47, mnemonic: 'EOR', mode: :idl, length: 2 },
+                    { opcode: 0x49, mnemonic: 'EOR', mode: :imm8, length: 2, m: 1 },
+                    { opcode: 0x49, mnemonic: 'EOR', mode: :imm16, length: 3, m: 0 },
+                    { opcode: 0x4d, mnemonic: 'EOR', mode: :abs, length: 3 },
+                    { opcode: 0x4f, mnemonic: 'EOR', mode: :abl, length: 4 },
+                    { opcode: 0x51, mnemonic: 'EOR', mode: :idy, length: 2 },
+                    { opcode: 0x52, mnemonic: 'EOR', mode: :idp, length: 2 },
+                    { opcode: 0x53, mnemonic: 'EOR', mode: :isy, length: 2 },
+                    { opcode: 0x55, mnemonic: 'EOR', mode: :dpx, length: 2 },
+                    { opcode: 0x57, mnemonic: 'EOR', mode: :idly, length: 2 },
+                    { opcode: 0x59, mnemonic: 'EOR', mode: :aby, length: 3 },
+                    { opcode: 0x5d, mnemonic: 'EOR', mode: :abx, length: 3 },
+                    { opcode: 0x5f, mnemonic: 'EOR', mode: :alx, length: 4 },
+                    { opcode: 0x01, mnemonic: 'ORA', mode: :idx, length: 2 },
+                    { opcode: 0x03, mnemonic: 'ORA', mode: :sr, length: 2 },
+                    { opcode: 0x05, mnemonic: 'ORA', mode: :dp, length: 2 },
+                    { opcode: 0x07, mnemonic: 'ORA', mode: :idl, length: 2 },
+                    { opcode: 0x09, mnemonic: 'ORA', mode: :imm8, length: 2, m: 1 },
+                    { opcode: 0x09, mnemonic: 'ORA', mode: :imm16, length: 3, m: 0 },
+                    { opcode: 0x0d, mnemonic: 'ORA', mode: :abs, length: 3 },
+                    { opcode: 0x0f, mnemonic: 'ORA', mode: :abl, length: 4 },
+                    { opcode: 0x11, mnemonic: 'ORA', mode: :idy, length: 2 },
+                    { opcode: 0x12, mnemonic: 'ORA', mode: :idp, length: 2 },
+                    { opcode: 0x13, mnemonic: 'ORA', mode: :isy, length: 2 },
+                    { opcode: 0x15, mnemonic: 'ORA', mode: :dpx, length: 2 },
+                    { opcode: 0x17, mnemonic: 'ORA', mode: :idly, length: 2 },
+                    { opcode: 0x19, mnemonic: 'ORA', mode: :aby, length: 3 },
+                    { opcode: 0x1d, mnemonic: 'ORA', mode: :abx, length: 3 },
+                    { opcode: 0x1f, mnemonic: 'ORA', mode: :alx, length: 4 },
+                    { opcode: 0x24, mnemonic: 'BIT', mode: :dp, length: 2 },
+                    { opcode: 0x2c, mnemonic: 'BIT', mode: :abs, length: 3 },
+                    { opcode: 0x34, mnemonic: 'BIT', mode: :dpx, length: 2 },
+                    { opcode: 0x3c, mnemonic: 'BIT', mode: :abx, length: 3 },
+                    { opcode: 0x89, mnemonic: 'BIT', mode: :imm8, length: 2, m: 1 },
+                    { opcode: 0x89, mnemonic: 'BIT', mode: :imm16, length: 3, m: 0 },
+                    { opcode: 0x14, mnemonic: 'TRB', mode: :dp, length: 2 },
+                    { opcode: 0x1c, mnemonic: 'TRB', mode: :abs, length: 3 },
+                    { opcode: 0x04, mnemonic: 'TSB', mode: :dp, length: 2 },
+                    { opcode: 0x0c, mnemonic: 'TSB', mode: :abs, length: 3 },
+                    { opcode: 0x06, mnemonic: 'ASL', mode: :dp, length: 2 },
+                    { opcode: 0x0a, mnemonic: 'ASL', mode: :acc, length: 1 },
+                    { opcode: 0x0e, mnemonic: 'ASL', mode: :abs, length: 3 },
+                    { opcode: 0x16, mnemonic: 'ASL', mode: :dpx, length: 2 },
+                    { opcode: 0x1e, mnemonic: 'ASL', mode: :abx, length: 3 },
+                    { opcode: 0x46, mnemonic: 'LSR', mode: :dp, length: 2 },
+                    { opcode: 0x4a, mnemonic: 'LSR', mode: :acc, length: 1 },
+                    { opcode: 0x4e, mnemonic: 'LSR', mode: :abs, length: 3 },
+                    { opcode: 0x56, mnemonic: 'LSR', mode: :dpx, length: 2 },
+                    { opcode: 0x5e, mnemonic: 'LSR', mode: :abx, length: 3 },
+                    { opcode: 0x26, mnemonic: 'ROL', mode: :dp, length: 2 },
+                    { opcode: 0x2a, mnemonic: 'ROL', mode: :acc, length: 1 },
+                    { opcode: 0x2e, mnemonic: 'ROL', mode: :abs, length: 3 },
+                    { opcode: 0x36, mnemonic: 'ROL', mode: :dpx, length: 2 },
+                    { opcode: 0x3e, mnemonic: 'ROL', mode: :abx, length: 3 },
+                    { opcode: 0x66, mnemonic: 'ROR', mode: :dp, length: 2 },
+                    { opcode: 0x6a, mnemonic: 'ROR', mode: :acc, length: 1 },
+                    { opcode: 0x6e, mnemonic: 'ROR', mode: :abs, length: 3 },
+                    { opcode: 0x76, mnemonic: 'ROR', mode: :dpx, length: 2 },
+                    { opcode: 0x7e, mnemonic: 'ROR', mode: :abx, length: 3 },
+                    { opcode: 0x90, mnemonic: 'BCC', mode: :rel, length: 2 },
+                    { opcode: 0xb0, mnemonic: 'BCS', mode: :rel, length: 2 },
+                    { opcode: 0xf0, mnemonic: 'BEQ', mode: :rel, length: 2 },
+                    { opcode: 0x30, mnemonic: 'BMI', mode: :rel, length: 2 },
+                    { opcode: 0xd0, mnemonic: 'BNE', mode: :rel, length: 2 },
+                    { opcode: 0x10, mnemonic: 'BPL', mode: :rel, length: 2 },
+                    { opcode: 0x80, mnemonic: 'BRA', mode: :rel, length: 2 },
+                    { opcode: 0x50, mnemonic: 'BVC', mode: :rel, length: 2 },
+                    { opcode: 0x70, mnemonic: 'BVS', mode: :rel, length: 2 },
+                    { opcode: 0x82, mnemonic: 'BRL', mode: :rell, length: 3 },
+                    { opcode: 0x4c, mnemonic: 'JMP', mode: :abs, length: 3 },
+                    { opcode: 0x5c, mnemonic: 'JMP', mode: :abl, length: 4 },
+                    { opcode: 0x6c, mnemonic: 'JMP', mode: :ind, length: 3 },
+                    { opcode: 0x7c, mnemonic: 'JMP', mode: :iax, length: 3 },
+                    { opcode: 0xdc, mnemonic: 'JMP', mode: :ial, length: 3 },
+                    { opcode: 0x22, mnemonic: 'JSL', mode: :abl, length: 4 },
+                    { opcode: 0x20, mnemonic: 'JSR', mode: :abs, length: 3 },
+                    { opcode: 0xfc, mnemonic: 'JSR', mode: :iax, length: 3 },
+                    { opcode: 0x6b, mnemonic: 'RTL', mode: :imp, length: 1 },
+                    { opcode: 0x60, mnemonic: 'RTS', mode: :imp, length: 1 },
+                    { opcode: 0x00, mnemonic: 'BRK', mode: :imm, length: 2 },
+                    { opcode: 0x02, mnemonic: 'COP', mode: :imm, length: 2 },
+                    { opcode: 0x40, mnemonic: 'RTI', mode: :imp, length: 1 },
+                    { opcode: 0x18, mnemonic: 'CLC', mode: :imp, length: 1 },
+                    { opcode: 0xd8, mnemonic: 'CLD', mode: :imp, length: 1 },
+                    { opcode: 0x58, mnemonic: 'CLI', mode: :imp, length: 1 },
+                    { opcode: 0xb8, mnemonic: 'CLV', mode: :imp, length: 1 },
+                    { opcode: 0x38, mnemonic: 'SEC', mode: :imp, length: 1 },
+                    { opcode: 0xf8, mnemonic: 'SED', mode: :imp, length: 1 },
+                    { opcode: 0x78, mnemonic: 'SEI', mode: :imp, length: 1 },
+                    { opcode: 0xc2, mnemonic: 'REP', mode: :imm8, length: 2 },
+                    { opcode: 0xe2, mnemonic: 'SEP', mode: :imm8, length: 2 },
+                    { opcode: 0xa1, mnemonic: 'LDA', mode: :idx, length: 2 },
+                    { opcode: 0xa3, mnemonic: 'LDA', mode: :sr, length: 2 },
+                    { opcode: 0xa5, mnemonic: 'LDA', mode: :dp, length: 2 },
+                    { opcode: 0xa7, mnemonic: 'LDA', mode: :idl, length: 2 },
+                    { opcode: 0xa9, mnemonic: 'LDA', mode: :imm8, length: 2, m: 1 },
+                    { opcode: 0xa9, mnemonic: 'LDA', mode: :imm16, length: 3, m: 0 },
+                    { opcode: 0xad, mnemonic: 'LDA', mode: :abs, length: 3 },
+                    { opcode: 0xaf, mnemonic: 'LDA', mode: :abl, length: 4 },
+                    { opcode: 0xb1, mnemonic: 'LDA', mode: :idy, length: 2 },
+                    { opcode: 0xb2, mnemonic: 'LDA', mode: :idp, length: 2 },
+                    { opcode: 0xb3, mnemonic: 'LDA', mode: :isy, length: 2 },
+                    { opcode: 0xb5, mnemonic: 'LDA', mode: :dpx, length: 2 },
+                    { opcode: 0xb7, mnemonic: 'LDA', mode: :idly, length: 2 },
+                    { opcode: 0xb9, mnemonic: 'LDA', mode: :aby, length: 3 },
+                    { opcode: 0xbd, mnemonic: 'LDA', mode: :abx, length: 3 },
+                    { opcode: 0xbf, mnemonic: 'LDA', mode: :alx, length: 4 },
+                    { opcode: 0xa2, mnemonic: 'LDX', mode: :imm8, length: 2, x: 1 },
+                    { opcode: 0xa2, mnemonic: 'LDX', mode: :imm16, length: 3, x: 0 },
+                    { opcode: 0xa6, mnemonic: 'LDX', mode: :dp, length: 2 },
+                    { opcode: 0xae, mnemonic: 'LDX', mode: :abs, length: 3 },
+                    { opcode: 0xb6, mnemonic: 'LDX', mode: :dpy, length: 2 },
+                    { opcode: 0xbe, mnemonic: 'LDX', mode: :aby, length: 3 },
+                    { opcode: 0xa0, mnemonic: 'LDY', mode: :imm8, length: 2, x: 1 },
+                    { opcode: 0xa0, mnemonic: 'LDY', mode: :imm16, length: 3, x: 0 },
+                    { opcode: 0xa4, mnemonic: 'LDY', mode: :dp, length: 2 },
+                    { opcode: 0xac, mnemonic: 'LDY', mode: :abs, length: 3 },
+                    { opcode: 0xb4, mnemonic: 'LDY', mode: :dpx, length: 2 },
+                    { opcode: 0xbc, mnemonic: 'LDY', mode: :abx, length: 3 },
+                    { opcode: 0x81, mnemonic: 'STA', mode: :idx, length: 2 },
+                    { opcode: 0x83, mnemonic: 'STA', mode: :sr, length: 2 },
+                    { opcode: 0x85, mnemonic: 'STA', mode: :dp, length: 2 },
+                    { opcode: 0x87, mnemonic: 'STA', mode: :idl, length: 2 },
+                    { opcode: 0x8d, mnemonic: 'STA', mode: :abs, length: 3 },
+                    { opcode: 0x8f, mnemonic: 'STA', mode: :abl, length: 4 },
+                    { opcode: 0x91, mnemonic: 'STA', mode: :idy, length: 2 },
+                    { opcode: 0x92, mnemonic: 'STA', mode: :idp, length: 2 },
+                    { opcode: 0x93, mnemonic: 'STA', mode: :isy, length: 2 },
+                    { opcode: 0x95, mnemonic: 'STA', mode: :dpx, length: 2 },
+                    { opcode: 0x97, mnemonic: 'STA', mode: :idly, length: 2 },
+                    { opcode: 0x99, mnemonic: 'STA', mode: :aby, length: 3 },
+                    { opcode: 0x9d, mnemonic: 'STA', mode: :abx, length: 3 },
+                    { opcode: 0x9f, mnemonic: 'STA', mode: :alx, length: 4 },
+                    { opcode: 0x86, mnemonic: 'STX', mode: :dp, length: 2 },
+                    { opcode: 0x8e, mnemonic: 'STX', mode: :abs, length: 3 },
+                    { opcode: 0x96, mnemonic: 'STX', mode: :dpy, length: 2 },
+                    { opcode: 0x84, mnemonic: 'STY', mode: :dp, length: 2 },
+                    { opcode: 0x8c, mnemonic: 'STY', mode: :abs, length: 3 },
+                    { opcode: 0x94, mnemonic: 'STY', mode: :dpx, length: 2 },
+                    { opcode: 0x64, mnemonic: 'STZ', mode: :dp, length: 2 },
+                    { opcode: 0x74, mnemonic: 'STZ', mode: :dpx, length: 2 },
+                    { opcode: 0x9c, mnemonic: 'STZ', mode: :abs, length: 3 },
+                    { opcode: 0x9e, mnemonic: 'STZ', mode: :abx, length: 3 },
+                    { opcode: 0x54, mnemonic: 'MVN', mode: :bm, length: 3 },
+                    { opcode: 0x44, mnemonic: 'MVP', mode: :bm, length: 3 },
+                    { opcode: 0xea, mnemonic: 'NOP', mode: :imp, length: 1 },
+                    { opcode: 0x42, mnemonic: 'WDM', mode: :imm, length: 2 },
+                    { opcode: 0xf4, mnemonic: 'PEA', mode: :iml, length: 3 },
+                    { opcode: 0xd4, mnemonic: 'PEI', mode: :dp, length: 2 },
+                    { opcode: 0x62, mnemonic: 'PER', mode: :rell, length: 3 },
+                    { opcode: 0x48, mnemonic: 'PHA', mode: :imp, length: 1 },
+                    { opcode: 0xda, mnemonic: 'PHX', mode: :imp, length: 1 },
+                    { opcode: 0x5a, mnemonic: 'PHY', mode: :imp, length: 1 },
+                    { opcode: 0x68, mnemonic: 'PLA', mode: :imp, length: 1 },
+                    { opcode: 0xfa, mnemonic: 'PLX', mode: :imp, length: 1 },
+                    { opcode: 0x7a, mnemonic: 'PLY', mode: :imp, length: 1 },
+                    { opcode: 0x8b, mnemonic: 'PHB', mode: :imp, length: 1 },
+                    { opcode: 0x0b, mnemonic: 'PHD', mode: :imp, length: 1 },
+                    { opcode: 0x4b, mnemonic: 'PHK', mode: :imp, length: 1 },
+                    { opcode: 0x08, mnemonic: 'PHP', mode: :imp, length: 1 },
+                    { opcode: 0xab, mnemonic: 'PLB', mode: :imp, length: 1 },
+                    { opcode: 0x2b, mnemonic: 'PLD', mode: :imp, length: 1 },
+                    { opcode: 0x28, mnemonic: 'PLP', mode: :imp, length: 1 },
+                    { opcode: 0xdb, mnemonic: 'STP', mode: :imp, length: 1 },
+                    { opcode: 0xcb, mnemonic: 'WAI', mode: :imp, length: 1 },
+                    { opcode: 0xaa, mnemonic: 'TAX', mode: :imp, length: 1 },
+                    { opcode: 0xa8, mnemonic: 'TAY', mode: :imp, length: 1 },
+                    { opcode: 0xba, mnemonic: 'TSX', mode: :imp, length: 1 },
+                    { opcode: 0x8a, mnemonic: 'TXA', mode: :imp, length: 1 },
+                    { opcode: 0x9a, mnemonic: 'TXS', mode: :imp, length: 1 },
+                    { opcode: 0x9b, mnemonic: 'TXY', mode: :imp, length: 1 },
+                    { opcode: 0x98, mnemonic: 'TYA', mode: :imp, length: 1 },
+                    { opcode: 0xbb, mnemonic: 'TYX', mode: :imp, length: 1 },
+                    { opcode: 0x5b, mnemonic: 'TCD', mode: :imp, length: 1 },
+                    { opcode: 0x1b, mnemonic: 'TCS', mode: :imp, length: 1 },
+                    { opcode: 0x7b, mnemonic: 'TDC', mode: :imp, length: 1 },
+                    { opcode: 0x3b, mnemonic: 'TSC', mode: :imp, length: 1 },
+                    { opcode: 0xeb, mnemonic: 'XBA', mode: :imp, length: 1 },
+                    { opcode: 0xfb, mnemonic: 'XCE', mode: :imp, length: 1 }].freeze
+  end
+end

data/lib/mini_assembler/mini_assembler.rb

@@ -0,0 +1,326 @@
+module SnesUtils
+  Readline.completion_proc = proc do |input|
+    Definitions::OPCODES_DATA.map { |row| row[:mnemonic] }
+                               .select { |mnemonic| mnemonic.upcase.start_with?(input.upcase) }
+  end
+
+  class MiniAssembler
+    def initialize(filename = nil)
+      if filename && File.file?(filename)
+        file = File.open(filename)
+        @memory = file.each_byte.map { |b| hex(b) }
+      else
+        @memory = []
+      end
+
+      @normal_mode = true
+
+      @current_addr = 0
+      @current_bank_no = 0
+      @accumulator_flag = 1
+      @index_flag = 1
+
+      @next_addr_to_list = 0
+    end
+
+    def run
+      while line = getline
+        result = parse_line(line.strip.chomp)
+        puts result if result
+      end
+
+      puts
+    end
+
+    def hex(num, rjust_len = 2)
+      num.to_s(16).rjust(rjust_len, '0').upcase
+    end
+
+    def write(filename = 'out.smc')
+      filename = filename.empty? ? 'out.smc' : filename
+
+      File.open(filename, 'w+b') do |file|
+        file.write([@memory.map { |i| i ? i : '00' }.join].pack('H*'))
+      end
+
+      filename
+    end
+
+    def incbin(filename, addr)
+      return 0 unless File.file?(filename)
+
+      file = File.open(filename)
+      bytes = file.each_byte.map { |b| hex(b) }
+
+      replace_memory_range(addr, addr + bytes.size - 1, bytes)
+
+      bytes.size
+    end
+
+    def read(filename)
+      return 0 unless File.file?(filename)
+
+      file = File.open(filename)
+
+      instructions = []
+
+      file.each_with_index do |raw_line, line_no|
+        line = raw_line.split(';').first.strip.chomp
+        next if line.empty?
+
+        instruction, length, address = parse_instruction(line)
+        return "Error at line #{line_no + 1}" unless instruction
+
+        instructions << [instruction, length, address]
+        @current_addr = address + length
+      end
+
+      disassembled_instructions = []
+      instructions.map do |instruction_arr|
+        instruction, length, address = instruction_arr
+        replace_memory_range(address, address+length-1, instruction)
+        disassembled_instructions << disassemble_range(address, 1, length > 2).join
+      end
+
+      return disassembled_instructions
+    end
+
+    def detect_opcode_data_from_mnemonic(mnemonic, operand)
+      Definitions::OPCODES_DATA.detect do |row|
+        mode = row[:mode]
+        regex = Definitions::MODES_REGEXES[mode]
+        row[:mnemonic] == mnemonic && regex =~ operand
+      end
+    end
+
+    def detect_opcode_data_from_opcode(opcode, force_length)
+      Definitions::OPCODES_DATA.detect do |row|
+        if row[:m]
+          accumulator_flag = force_length ? 0 : @accumulator_flag
+          row[:opcode] == opcode && row[:m] == accumulator_flag
+        elsif row[:x]
+          index_flag = force_length ? 0 : @index_flag
+          row[:opcode] == opcode && row[:x] == index_flag
+        else
+          row[:opcode] == opcode
+        end
+      end
+    end
+
+    def full_address(address)
+      (@current_bank_no << 16) | address
+    end
+
+    def address_human(addr=nil)
+      address = full_address(addr || @current_addr)
+      bank = address >> 16
+      addr = (((address>>8)&0xFF) << 8) | (address&0xFF)
+      "#{hex(bank)}/#{hex(addr, 4)}"
+    end
+
+    def memory_loc(address)
+      @memory[full_address(address)]
+    end
+
+    def memory_range(start_addr, end_addr)
+      start_full_addr = full_address(start_addr)
+      end_full_addr = full_address(end_addr)
+
+      return [] if start_full_addr > end_full_addr || start_full_addr >= @memory.length
+
+      @memory[start_full_addr..end_full_addr]
+    end
+
+    def replace_memory_range(start_addr, end_addr, bytes)
+      start_full_addr = full_address(start_addr)
+      end_full_addr = full_address(end_addr)
+
+      @memory[start_full_addr..end_full_addr] = bytes
+
+      true
+    end
+
+    def getline
+      prompt = @normal_mode ? "(#{@accumulator_flag}=m #{@index_flag}=x)*" : "(#{address_human})!"
+      Readline.readline(prompt, true)
+    end
+
+    def parse_line(line)
+      if @normal_mode
+        if line == '!'
+          @normal_mode = false
+          return
+        elsif matches = Definitions::WRITE_REGEX.match(line)
+          filename = matches[1].strip.chomp
+          out_filename = write(filename)
+          return "Written #{@memory.size} bytes to file #{out_filename}"
+        elsif matches = Definitions::READ_REGEX.match(line)
+          filename = matches[1].strip.chomp
+          return read(filename)
+        elsif matches = Definitions::INCBIN_REGEX.match(line)
+          start_addr = matches[1].to_i(16)
+          filename = matches[2].strip.chomp
+          nb_bytes = incbin(filename, start_addr)
+
+          return "Inserted #{nb_bytes} bytes at #{address_human(start_addr)}"
+        elsif Definitions::BYTE_LOC_REGEX =~ line
+          return memory_loc(line.to_i(16))
+        elsif matches = Definitions::BYTE_RANGE_REGEX.match(line)
+          start_addr = matches[1].to_i(16)
+          end_addr = matches[2].to_i(16)
+
+          padding_count = start_addr % 8
+          padding = (1..padding_count).map { |b| '  ' }
+          arr = memory_range(start_addr, end_addr)
+          return if arr.empty?
+
+          padded_arr = arr.insert(8-padding_count, *padding).each_slice(8).to_a
+          return padded_arr.each_with_index.map do |row, idx|
+            if idx == 0
+              line_addr = start_addr
+            else
+              line_addr = start_addr - padding_count + idx * 8
+            end
+            ["#{address_human(line_addr)}-", *row].join(' ')
+          end.join("\n")
+        elsif matches = Definitions::BYTE_SEQUENCE_REGEX.match(line)
+          addr = matches[1].to_i(16)
+          bytes = matches[2].delete(' ').scan(/.{1,2}/).map { |b| hex(b.to_i(16)) }
+          replace_memory_range(addr, addr + bytes.length - 1, bytes)
+          return
+        elsif matches = Definitions::DISASSEMBLE_REGEX.match(line)
+          start = matches[1].empty? ? @next_addr_to_list : matches[1].to_i(16)
+          return disassemble_range(start, 20).join("\n")
+        elsif matches = Definitions::SWITCH_BANK_REGEX.match(line)
+          target_bank_no = matches[1].to_i(16)
+          @current_bank_no = target_bank_no
+          @current_addr = @current_bank_no << 16
+          @next_addr_to_list = 0
+          return
+        elsif matches = Definitions::FLIP_MX_REG_REGEX.match(line)
+          val = matches[1]
+          reg = matches[2]
+
+          if reg.downcase == 'm'
+            @accumulator_flag = val.to_i
+          elsif reg.downcase == 'x'
+            @index_flag = val.to_i
+          end
+
+          return
+        end
+      else
+        if line == ''
+          @normal_mode = true
+          return
+        else
+          instruction, length, address = parse_instruction(line)
+          return 'error' unless instruction
+
+          replace_memory_range(address, address+length-1, instruction)
+          @current_addr = address + length
+          return disassemble_range(address, 1, length > 2).join
+        end
+      end
+    end
+
+    def parse_address(line)
+      return @current_addr if line.index(':').nil?
+      line.split(':').first.to_i(16)
+    end
+
+    def parse_instruction(line)
+      current_address = parse_address(line)
+      instruction = line.split(':').last.split(' ')
+      mnemonic = instruction[0].upcase
+      raw_operand = instruction[1].to_s
+
+      opcode_data = detect_opcode_data_from_mnemonic(mnemonic, raw_operand)
+
+      return unless opcode_data
+
+      opcode = hex(opcode_data[:opcode])
+      mode = opcode_data[:mode]
+      length = opcode_data[:length]
+
+      operand_matches = Definitions::MODES_REGEXES[mode].match(raw_operand)
+      if mode == :bm
+        operand = "#{operand_matches[1]}#{operand_matches[2]}".to_i(16)
+      else
+        operand = operand_matches[1]&.to_i(16)
+      end
+
+      if operand
+        if %i[rel rell].include? mode
+          relative_addr = operand - current_address - length
+          return if mode == :rel && (relative_addr < -128 || relative_addr > 127)
+          return if mode == :rell && (relative_addr < -32768 || relative_addr > 32767)
+
+          relative_addr = (2**(8*(length-1))) + relative_addr if relative_addr < 0
+
+          param_bytes = hex(relative_addr, 2*(length-1)).scan(/.{2}/).reverse.join
+        else
+          param_bytes = hex(operand, 2*(length-1)).scan(/.{2}/).reverse.join
+        end
+      end
+
+      encoded_result = "#{opcode}#{param_bytes}"
+
+      return [encoded_result.scan(/.{2}/), length, current_address]
+    end
+
+    def auto_update_flags(opcode, operand)
+      if 0xc2 == opcode
+        @index_flag = 0 if (operand & 0x10) == 0x10
+        @accumulator_flag = 0 if (operand & 0x20) == 0x20
+      elsif 0xe2 == opcode
+        @index_flag = 1 if (operand & 0x10) == 0x10
+        @accumulator_flag = 1 if (operand & 0x20) == 0x20
+      end
+    end
+
+    def disassemble_range(start, count, force_length = false)
+      next_idx = start
+      instructions = []
+      count.times do
+        byte = memory_loc(next_idx)
+        break unless byte
+        opcode = byte.to_i(16)
+
+        opcode_data = detect_opcode_data_from_opcode(opcode, force_length)
+
+        mnemonic = opcode_data[:mnemonic]
+        mode = opcode_data[:mode]
+        length = opcode_data[:length]
+
+        format = Definitions::MODES_FORMATS[mode]
+
+        operand = memory_range(next_idx+1, next_idx+length-1).reverse.join.to_i(16)
+
+        hex_encoded_instruction = memory_range(next_idx, next_idx+length-1)
+        prefix = ["#{address_human(next_idx)}:", *hex_encoded_instruction].join(' ')
+
+        auto_update_flags(opcode, operand)
+
+        if mode == :bm
+          operand = operand.to_s(16).scan(/.{2}/).map { |op| op.to_i(16) }
+        elsif %i[rel rell].include? mode
+          limit = mode == :rel ? 0x7f : 0x7fff
+          offset = mode == :rel ? 0x100 : 0x10000
+          rjust_len = mode == :rel ? 2 : 4
+          relative_addr = operand > limit ? operand - offset : operand
+          relative_addr_s = "#{relative_addr.positive? ? '+' : '-'}#{hex(relative_addr.abs, rjust_len)}"
+          absolute_addr = next_idx + length + relative_addr
+          absolute_addr += 0x10000 if absolute_addr.negative?
+          operand = [absolute_addr, relative_addr_s]
+        end
+
+        instructions << "#{prefix.ljust(30)} #{format % [mnemonic, *operand]}"
+        next_idx += length
+      end
+
+      @next_addr_to_list = next_idx
+      return instructions
+    end
+  end
+end

data/lib/png2snes/png2snes.rb

@@ -0,0 +1,114 @@
+module SnesUtils
+  class Png2Snes
+    def initialize(file_path, bpp:4, alpha: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
+
+      @palette = @pixels.uniq
+      @char_size = 8
+
+      raise ArgumentError, 'BPP must be 2, 4, or 8' unless [2, 4, 8].include? bpp
+      @bpp = bpp
+
+      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)
+
+      alpha_first if alpha
+      fill_palette
+    end
+
+    def pixels_to_bgr5
+      @image.pixels.map do |c|
+        r = ((c >> 24) & 0xff) >> 3
+        g = ((c >> 16) & 0xff) >> 3
+        b = ((c >>  8) & 0xff) >> 3
+
+        r | (g << 5) | (b << 10)
+      end
+    end
+
+    def alpha_first
+    end
+
+    def fill_palette
+      target_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 write hex, file_path
+      File.open(file_path, 'w+b') do |file|
+        file.write([hex.join].pack('H*'))
+      end
+    end
+
+    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)
+    end
+
+    def pixel_indices
+      pix_idx = @pixels.map { |p| @palette.index(p) }
+      pix_idx_bin = pix_idx.map { |i| "%0#{@bpp}b" % i }
+      pix_idx_bin.map { |i| i.reverse }
+    end
+
+    def extract_sprites
+      pixel_idx = pixel_indices
+
+      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]
+        end
+        sprites.push(sprite)
+      end
+
+      sprites
+    end
+
+    def extract_bitplanes sprite
+      bitplanes = []
+      (0..@bpp-1).each do |plane|
+        bitplanes.push sprite.map { |p| p[plane] }
+      end
+
+      bitplanes
+    end
+
+    def write_image
+      sprite_per_row = @image.width / @char_size
+      sprites = extract_sprites
+      sprites_bitplanes = sprites.map { |s| extract_bitplanes s }
+
+      image_bits = ""
+      sprites_bitplanes.each do |sprite_bitplanes|
+        sprite_bitplane_pairs = sprite_bitplanes.each_slice(2).to_a
+
+        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
+          end
+        end
+        image_bits += bitplane_bits
+
+      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)
+    end
+
+  end
+end

data/lib/snes_utils.rb

@@ -0,0 +1,14 @@
+require 'readline'
+require 'chunky_png'
+require 'matrix'
+require 'nokogiri'
+
+require 'byebug'
+
+require 'mini_assembler/mini_assembler'
+require 'mini_assembler/definitions'
+require 'png2snes/png2snes'
+require 'tmx2snes/tmx2snes'
+
+module SnesUtils
+end

data/lib/tmx2snes/tmx2snes.rb

@@ -0,0 +1,57 @@
+module SnesUtils
+  class Tmx2Snes
+    def initialize(file_path, big_char:false, palette:0, v:false, h:false, p:false)
+      raise unless File.file? file_path
+      @file_path = file_path
+      @file_dir = File.dirname(@file_path)
+      @file_name = File.basename(@file_path, File.extname(@file_path))
+      @tilemap = []
+      raise if palette < 0 || palette > 7
+      @palette = palette
+      @v_flip = v ? "1" : "0"
+      @h_flip = h ? "1" : "0"
+      @prio_bg3 = p ? "1" : "0"
+      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|
+        raise if row.length != 32
+        @tilemap += row.map { |r| (r.to_i - 1)*tnm + row_offset * ((r.to_i - 1)/8).to_i }
+      end
+
+      raise if @tilemap.length != 32*32
+      dummy = 1023 # TODO: check max tile per tileset
+      raise if @tilemap.map { |t| t < 0 || t > dummy }.include? true
+    end
+
+    def tile_to_data tile
+      tile_name = "%010b" % tile
+      palette_name = "%03b" % @palette
+
+      tile_hl = @v_flip + @h_flip + @prio_bg3 + palette_name + tile_name
+      tile_data = tile_hl.scan(/.{8}/)
+      tile_data.reverse.map { |b| "%02x" % b.to_i(2) }
+
+    end
+
+    def tilemap_to_data
+      bg_sc_data = []
+      @tilemap.each do |tile|
+        bg_sc_data.push(tile_to_data(tile))
+      end
+      bg_sc_data
+    end
+
+    def write
+      out = File.expand_path("#{@file_name}.map", @file_dir)
+      File.open(out, 'w+b') do |file|
+        file.write([tilemap_to_data.join].pack('H*'))
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: snes_utils
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vivien Bihl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rb-readline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: A collection of tools to create or edit SNES games
+email: vivienbihl@gmail.com
+executables:
+- mini_assembler
+- png2snes
+- tmx2snes
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/mini_assembler
+- bin/png2snes
+- bin/tmx2snes
+- lib/mini_assembler/definitions.rb
+- lib/mini_assembler/mini_assembler.rb
+- lib/png2snes/png2snes.rb
+- lib/snes_utils.rb
+- lib/tmx2snes/tmx2snes.rb
+homepage: https://rubygems.org/gems/snes_utils
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/vivi168/SNES_Utils
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: SNES Utils
+test_files: []