sabrina 0.5.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e428137b1b9c97072a5d0094df0d556abe7ced83
+  data.tar.gz: 558afde8551a7c6ecfea61ccbf4d33d3701d1945
+SHA512:
+  metadata.gz: c71b152645a6f7805c3fccc0c5969e3593e70fcb9173b4d8c8923aa14820dd682501c774ae163b4d7d83f07ab471c1121120f36278080eb34b9ca7c81a06f8d3
+  data.tar.gz: 473823ca339a40dac88ca86a3beb6d65258c3e4c5bced4c57d36b53d6f9a9077881650f5d4c6604bd60e3f253d03e39944dc53c61f66a7faa4c22c0ef5bb5bf4

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Winterbraid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/sabrina.rb

@@ -0,0 +1,46 @@
+# {include:file:README.rdoc}
+module Sabrina; end
+
+require 'set'
+require 'fileutils'
+require 'json'
+
+begin
+  require 'oily_png'
+  Sabrina.const_set(:PNG, 'oily_png')
+rescue
+  require 'chunky_png'
+  Sabrina.const_set(:PNG, 'chunky_png')
+end
+
+require 'sabrina/meta.rb'
+
+require 'sabrina/config.rb'
+require 'sabrina/config/main.rb'
+require 'sabrina/config/charmap_in.rb'
+require 'sabrina/config/charmap_out.rb'
+require 'sabrina/config/charmap_out_special.rb'
+
+require 'sabrina/lz77.rb'
+require 'sabrina/children_manager.rb'
+
+require 'sabrina/bytestream/byte_input.rb'
+require 'sabrina/bytestream/byte_output.rb'
+require 'sabrina/bytestream/rom_operations.rb'
+require 'sabrina/bytestream.rb'
+
+require 'sabrina/sprite.rb'
+require 'sabrina/palette.rb'
+require 'sabrina/gba_string.rb'
+
+require 'sabrina/rom.rb'
+require 'sabrina/monster.rb'
+
+require 'sabrina/plugin/register.rb'
+require 'sabrina/plugin/load.rb'
+require 'sabrina/plugin.rb'
+
+require 'sabrina/plugins/spritesheet.rb'
+require 'sabrina/plugins/stats.rb'
+
+Sabrina::Config.load_user_config

data/lib/sabrina/bytestream.rb

@@ -0,0 +1,266 @@
+module Sabrina
+  # A generic class for dealing with byte data related to 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.
+  #
+  # There should be no need to use this class directly.
+  class Bytestream
+    extend ByteInput
+    include ByteOutput
+    include RomOperations
+
+    # Stores an array of debug strings related to the latest write to ROM.
+    #
+    # @return [Array]
+    # @see RomOperations#write_to_rom
+    attr_reader :last_write
+
+    # The ROM being  used for operations.
+    #
+    # @return [Rom]
+    # @see #rom=
+    attr_reader :rom
+
+    # The index in the ROM table.
+    #
+    # @return [Integer]
+    # @see #index=
+    attr_reader :index
+
+    # The table code to search for data.
+    #
+    # @return [String or Symbol]
+    # @see #table=
+    attr_reader :table
+
+    # The directory for saving files. Should be created if specified but not
+    # existing.
+    #
+    # @return [String]
+    attr_accessor :work_dir
+
+    # The filename to save to, sans the extension. Subclass +to_file+ methods
+    # should take care of adding the right extension.
+    #
+    # @return [String]
+    attr_accessor :filename
+
+    class << self
+      # Takes an integer or a "0x"- or "x"-prefixed string and
+      # converts it to a valid numerical offset.
+      #
+      # @param [Integer] p_offset
+      # @return [Integer]
+      def parse_offset(p_offset)
+        o = p_offset.to_s.downcase
+
+        if /[^0-9a-fx]/ =~ o
+          fail "\'#{p_offset}\' does not look like a valid offset." \
+            ' Supply an integer, or a hex optionally prefixed' \
+            " with \'0x\' or \'x\'."
+        end
+
+        /[a-fx]/ =~ o ? p_offset.rpartition('x').last.hex : p_offset.to_i
+      end
+    end
+
+    # Returns a new instance of Bytestream, taking a hash of arguments
+    # as the option. The hash may contain the following keys, all of
+    # which are optional and init to +nil+ or +false+. Any invalid keys
+    # should be ignored.
+    #
+    # Subclasses should call this method with subclass-specific data.
+    # There should be no need to call this method directly.
+    #
+    # Subclasses should override the +load_settings(h)+ private method
+    # to allow for additional options.
+    #
+    # @param [Hash] h
+    # @option h [Object] :representation The internal representation
+    #   of the byte data. Subclasses should be able to convert bytes
+    #   to and from the representation via the {ByteOutput#present} and
+    #   {ByteOutput#generate_bytes} methods.
+    # @option h [Boolean] :pointer_mode Whether to expect pointers in the
+    #   table instead of actual data. This voids +:index_length+.
+    # @option h [Boolean] :lz77 Whether to read and write ROM data as
+    #   {Lz77}-compressed.
+    # @option h [Boolean] :is_gba_string Whether to read ROM data as
+    #   a GBA-encoded, 0xFF-terminated string.
+    # @option h [Rom] :rom A ROM to be used for reading and writing data.
+    # @option h [Symbol, String] :table The table to read offset data from.
+    #   This should be the name of an option specified in the +rom_data+ hash.
+    #   +:table+ and +:index+ will take precedence over +:offset+ if present.
+    #   This is the recommended way of dealing with monster data,
+    #   as it will allow automagically updating the offset upon writing
+    #   or switching ROMs.
+    # @option h [Integer] :index The index to read from the table.
+    #   See {#index=} for details.
+    # @option h [Integer] :index_length The length of a single table
+    #   entry, necessary for seeking.
+    # @option h [Integer] :offset The position in ROM to read and write to.
+    #   This will only be used if +:table+ or +:index+ are not present.
+    #   See {Bytestream.parse_offset} for details.
+    # @option h [Integer] :length The byte length to read from the ROM.
+    #   This will be ignored if +:lz77+ compression is enabled.
+    def initialize(h = {})
+      # Subclasses may want to override defaults, hence ||=
+      @work_dir ||= nil
+      @filename ||= nil
+
+      @representation ||= nil
+      @bytes_cache ||= nil
+      @lz77_cache ||= nil
+      @length_cache ||= nil
+
+      @last_write ||= nil
+
+      @old_offset ||= nil
+      @old_length ||= nil
+
+      @lz77 ||= false
+      @is_gba_string ||= false
+
+      @rom ||= nil
+      @table ||= nil
+      @index ||= nil
+      @offset ||= nil
+      @length ||= nil
+
+      @pointer_mode ||= false
+      @index_length ||= nil
+
+      load_settings(h)
+      present
+    end
+
+    # Returns the associated offset, first trying the table and then +:offset+.
+    # Returns +nil+ if neither has sufficient data.
+    #
+    # @return [Integer]
+    def offset
+      if @rom && @table && @index
+        return @rom.read_offset_from_table(@table, @index) if @pointer_mode
+        return @rom.table_to_offset(@table, @index, @index_length)
+      end
+      @offset
+    end
+
+    # Returns the offset as a reversed byte string.
+    # This is the format used internally by ROMs to reference data.
+    #
+    # @return [String]
+    def pointer
+      Rom.offset_to_pointer(offset)
+    end
+
+    # Sets the index under which to search for data in the +:table+.
+    # Compared to setting :index=>index in the options hash, this will
+    # assume the index is
+    #
+    # This will clear the internal cache.
+    #
+    # @param [Integer] p_index For monsters, this should be the
+    #   real index (accounting for blank spaces between
+    #   dex numbers 251 and 252) of the monster you want to act on.
+    #   Ideally, a wrapper object should calculate this for you.
+    # @return [self]
+    def index=(p_index)
+      @index = p_index
+      clear_cache
+      @index
+    end
+
+    # Sets the ROM with which the byte data is to be associated.
+    # This is the same as setting +:rom+ in the options hash.
+    #
+    # This will clear the internal cache.
+    #
+    # @param [Rom] p_rom
+    # @return [Rom] new rom.
+    def rom=(p_rom)
+      @rom = p_rom
+      clear_cache(lz77: false)
+      @rom
+    end
+
+    # Sets the table name identifier and optionally the index.
+    # The table identifier should be a key in +rom_data+ config.
+    #
+    # This is the same as setting +:table+, +:index+
+    # in the options hash.
+    #
+    # This will clear the internal cache.
+    #
+    # @param [String, Symbol] p_table
+    # @param [Integer] p_index see {#index=} for details.
+    # @return [self]
+    def table=(p_table, p_index = nil)
+      @table = p_table
+      @index = p_index if p_index
+      clear_cache
+      [@table, @index]
+    end
+
+    # Sets the offset of the data in +:rom+.
+    # This is the same as setting +:offset+ in the options hash.
+    #
+    # This will clear the internal cache.
+    #
+    # @param [Integer, String] p_offset See {Bytestream.parse_offset} for details.
+    # @return [Integer] new offset.
+    def offset=(p_offset)
+      return self if p_offset == @offset
+      @old_offset = @offset
+      @offset = Bytestream.parse_offset(p_offset)
+      clear_cache
+      @offset
+    end
+
+    # Tells the object that the ROM uses {Lz77} compression
+    # for the data.
+    # This is the same as setting +:lz77+=>+true+ in the options hash.
+    #
+    # @return [self]
+    def lz77_mode
+      @lz77 = true
+      self
+    end
+
+    # Tells the object that the data is a GBA-encoded, 0xFF-terminated
+    # string.
+    # This is the same as setting :is_gba_string=>true in the options hash.
+    #
+    # @return [self]
+    def string_mode
+      @is_gba_string = true
+      self
+    end
+
+    private
+
+    # Loads a hash of options. Subclasses should override this to allow
+    # additional options.
+    #
+    # @param [Hash] h see {#initialize}.
+    # @return [self]
+    def load_settings(h)
+      @representation = h.fetch(:representation, @representation)
+      @bytes_cache = h.fetch(:bytes_cache, @bytes_cache)
+
+      @lz77 = h.fetch(:lz77, @lz77 || false)
+      @is_gba_string = h.fetch(:is_gba_string, @is_gba_string)
+
+      @rom = h.fetch(:rom, @rom)
+      @offset = Bytestream.parse_offset(h[:offset]) if h.key?(:offset)
+      @length = h.fetch(:length, @length)
+
+      @table = h.fetch(:table, @table)
+      @index = h.fetch(:index, @index)
+
+      @pointer_mode = h.fetch(:pointer_mode, @pointer_mode)
+      @index_length = h.fetch(:index_length, @index_length)
+      self
+    end
+  end
+end

data/lib/sabrina/bytestream/byte_input.rb

@@ -0,0 +1,126 @@
+module Sabrina
+  class Bytestream
+    # Constructors that allow {Bytestream} to create byte data
+    # from ROMs or other sources. All methods should accept an optional
+    # final hash of options.
+    #
+    # Subclasses should override or add to these methods as necessary,
+    # using the final hash to pass the internal representation and
+    # any other necessary parameters and defaults.
+    module ByteInput
+      # Creates a new {Bytestream} object from bytes.
+      #
+      # @param [String] b
+      # @param [Hash] h see {Bytestream#initialize}
+      # @return [Bytestream]
+      def from_bytes(b, h = {})
+        h.merge!(bytes_cache: b)
+
+        new(h)
+      end
+
+      # Creates a new {Bytestream} object that will read +length+
+      # bytes of data from a ROM +table+ and +index+, expecting each entry
+      # before the index to be +index_length+ bytes.
+      #
+      # @param [Rom] rom
+      # @param [String, Symbol] table a key specified in rom_data config.
+      # @param [Integer] index the index to read from the table.
+      #   For monsters, it should be the real (not dex) number
+      #   of the monster you wish to act on.
+      # @param [Integer] index_length the expected length of a single entry.
+      # @param [Integer] length how many bytes to read from the calculated
+      #   offset.
+      # @param [Hash] h see {Bytestream#initialize}
+      # @return [Bytestream]
+      def from_table(rom, table, index, index_length, length = index_length, h = {})
+        h.merge!(
+          rom: rom,
+          table: table,
+          index: index,
+          index_length: index_length,
+          length: length
+        )
+
+        new(h)
+      end
+
+      # Creates a new {Bytestream} object that will read a pointer
+      # from a ROM table and index. This is the recommended method to
+      # read monster data from a ROM.
+      #
+      # @param [Rom] rom
+      # @param [String, Symbol] table a key specified in rom_data config.
+      # @param [Integer] index the index to read from the table.
+      #   For monsters, it should be the real (not dex) number
+      #   of the monster you wish to act on.
+      # @param [Hash] h see {Bytestream#initialize}
+      # @return [Bytestream]
+      def from_table_as_pointer(rom, table, index, h = {})
+        h.merge!(
+          rom: rom,
+          table: table,
+          index: index,
+          pointer_mode: true
+        )
+
+        new(h)
+      end
+
+      # Creates a new {Bytestream} object by reading +length+
+      # bytes from a ROM offset.
+      #
+      # @param [Rom] rom
+      # @param [Integer, String] offset The offset to seek to in the ROM.
+      #   See {Bytestream.parse_offset} for details.
+      # @param [Integer] length
+      # @param [Hash] h see {Bytestream#initialize}
+      # @return [Bytestream]
+      def from_rom(rom, offset, length = nil, h = {})
+        h.merge!(
+          rom: rom,
+          offset: offset,
+          length: length
+        )
+
+        new(h)
+      end
+
+      # Creates a new {Bytestream} object from a ROM offset, attempting
+      # to read it as {Lz77}-compressed data.
+      #
+      # @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 [Bytestream]
+      def from_rom_as_lz77(rom, offset, h = {})
+        h.merge!(
+          rom: rom,
+          offset: offset,
+          lz77: true
+        )
+
+        new(h)
+      end
+
+      # Same as {#from_bytes}, but takes a hexadecimal string that will be
+      # converted to bytes.
+      #
+      # @param [String] s
+      # @param [Hash] h see {Bytestream#initialize}
+      # @return [Bytestream]
+      def from_hex(s, h = {})
+        if /[^0-9a-fx]/ =~ s.downcase
+          fail "\'#{s}\' does not look like a hex string."
+        end
+
+        b = s.rpartition('x').last.scan(/../).map { |x| x.hex.chr }.join('')
+
+        h.merge!(bytes_cache: b)
+
+        new(h)
+      end
+    end
+  end
+end