sabrina 0.5.5

data/lib/sabrina/plugin/load.rb

@@ -0,0 +1,43 @@
+module Sabrina
+  class Plugin
+    # Allows to load plugins. Add +load_plugins+ at the end of your class's
+    # +initialize+ call.
+    module Load
+      class << self
+        # Exposes +#append_features+.
+        def include_in(obj)
+          append_features(obj) unless obj.include?(self)
+        end
+      end
+
+      attr_reader :plugins
+
+      private
+
+      # Generates plugin instances. This should be called from
+      # the target class's init.
+      #
+      # @return [0]
+      def load_plugins
+        self.class.plugins.each do |plugin|
+          n = plugin.short_name
+
+          plugin.features.each do |f|
+            feature_all_sym = f.to_sym
+            feature_this_sym = "#{f}_#{n}"
+            unless respond_to?(feature_all_sym)
+              define_singleton_method(feature_all_sym, plugin.feature_all(f))
+            end
+            unless respond_to?(feature_this_sym)
+              define_singleton_method(feature_this_sym, plugin.feature_this(f, n))
+            end
+          end
+
+          define_singleton_method(n, -> { @plugins[n] }) unless respond_to?(n)
+          @plugins[n] = plugin.new(self)
+        end
+        0
+      end
+    end
+  end
+end

data/lib/sabrina/plugin/register.rb

@@ -0,0 +1,32 @@
+module Sabrina
+  class Plugin
+    # Allows to register plugins.
+    module Register
+      # Lists all currently registered plugins.
+      #
+      # @return [Set]
+      def plugins
+        @plugins.to_a
+      end
+
+      # Registers a new plugin for handling a specific subset of monster
+      # data.
+      #
+      # @return [0]
+      # @see Plugin
+      def register_plugin(plugin)
+        @plugins ||= Set.new
+        @plugins << plugin
+      end
+
+      # Lists all currently available features.
+      #
+      # @return [Set]
+      def features
+        s = Set.new
+        @plugins.each { |x| s += x.features }
+        s
+      end
+    end
+  end
+end

data/lib/sabrina/plugins/spritesheet.rb

@@ -0,0 +1,196 @@
+module Sabrina
+  module Plugins
+    # This {Plugin} provides an abstraction for manipulating all
+    # {Sprite Sprites} and {Palette Palettes} associated with a {Monster}.
+    #
+    # @see Plugin
+    class Spritesheet < Plugin
+      include ChildrenManager
+
+      # @see Plugin::ENHANCES
+      ENHANCES = Monster
+
+      # @see Plugin::PLUGIN_NAME
+      PLUGIN_NAME = 'Spritesheet'
+
+      # @see Plugin::SHORT_NAME
+      SHORT_NAME = 'spritesheet'
+
+      # @see Plugin::FEATURES
+      FEATURES = Set.new [:reread, :write, :save, :load]
+
+      # @!attribute rom
+      #   The current working ROM file.
+      #   @return [Rom]
+      # @!method rom=(r)
+      #   The current working ROM file.
+      #   @param [Rom] r
+      #   @return [Rom]
+      # @!attribute index
+      #   The real index of the monster.
+      #   @return [Integer]
+      # @!method index=(i)
+      #   The real index of the monster.
+      #   @param [Integer] i
+      #   @return [Integer]
+      attr_children :rom, :index
+
+      # The palettes used by the sprites.
+      #
+      # @return [Array]
+      attr_reader :palettes
+
+      # The sprites.
+      #
+      # @return [Array]
+      attr_reader :sprites
+
+      # Generates a new Spritesheet object.
+      #
+      # @return [Spritesheet]
+      def initialize(monster)
+        @monster = monster
+        @rom = monster.rom
+        @index = monster.index
+
+        @palettes = [
+          Palette.from_table(@monster.rom, :palette_table, @monster.index),
+          Palette.from_table(@monster.rom, :shinypal_table, @monster.index)
+        ]
+
+        @sprites = [
+          Sprite.from_table(@monster.rom, :front_table, @monster.index),
+          Sprite.from_table(@monster.rom, :back_table, @monster.index)
+        ]
+      end
+
+      # @return [Array]
+      # @see ChildrenManager
+      def children
+        @sprites + @palettes
+      end
+
+      # Justify sprites to the target ROM count as per ROM {Config}, assuming
+      # 64x64 frame size.
+      def justify
+        @sprites.map(&:justify)
+      end
+
+      # Load data from a file.
+      #
+      # @return [Array] Any return data from child methods.
+      def load(file = @monster.filename, dir = @monster.work_dir, *_args)
+        path = get_path(file, dir)
+        a = split_canvas(ChunkyPNG::Canvas.from_file(path))
+        h = { rom: @rom, index: @index }
+
+        normal_rgb = a[0].to_rgb_stream + a[2].to_rgb_stream
+        shiny_rgb = a[1].to_rgb_stream + a[3].to_rgb_stream
+
+        @palettes = Palette.create_synced_palettes(
+          normal_rgb,
+          shiny_rgb,
+          h.merge(table: :palette_table),
+          h.merge(table: :shinypal_table)
+        )
+
+        frames = @rom.special_frames.fetch(@index, @rom.frames)
+        front = crop_canvas(a[0], frames.first * 64)
+        back = crop_canvas(a[2], frames.last * 64)
+
+        @sprites = [
+          Sprite.from_canvas(
+            front,
+            @palettes.first,
+            h.merge(table: :front_table)
+          ),
+          Sprite.from_canvas(
+            back,
+            @palettes.first,
+            h.merge(table: :back_table)
+          )
+        ]
+
+        justify
+        children
+      end
+
+      # Save data to a file.
+      #
+      # @return [Array] Any return data from child methods.
+      def save(file = @monster.filename, dir = @monster.work_dir, *_args)
+        a = []
+        @sprites.product(@palettes).each do |x|
+          a << x.first.to_canvas(x.last)
+        end
+
+        path = get_path(file, dir, mkdir: true)
+
+        combine_canvas(a).save(path)
+      end
+
+      private
+
+      # Crops the canvas to the specified height if taller.
+      def crop_canvas(c, h)
+        return c.crop(0, 0, c.width, h) if c.height > h
+        c
+      end
+
+      # Horizontally combine a one-dimensional array of
+      # {http://rdoc.info/gems/chunky_png/1.2.0/ChunkyPNG/Canvas Canvas}
+      # objects into a single, wide canvas.
+      #
+      # @param [Array] a an array of Canvas objects.
+      # @return [Canvas] the combined canvas.
+      def combine_canvas(a)
+        out_c = ChunkyPNG::Canvas.new(a.first.width * a.length, a.first.height)
+        a.each_index { |i| out_c.replace!(a[i], a.first.width * i) }
+        out_c
+      end
+
+      # Vertically combine a one-dimensional array of
+      # {http://rdoc.info/gems/chunky_png/1.2.0/ChunkyPNG/Canvas Canvas}
+      # objects into a single, tall canvas.
+      #
+      # @param [Array] a an array of Canvas objects.
+      # @return [Canvas] the combined canvas.
+      def combine_canvas_vert(a)
+        out_c = ChunkyPNG::Canvas.new(a.first.width, a.first.height * a.length)
+        a.each_index { |i| out_c.replace!(a[i], 0, a.first.height * i) }
+        out_c
+      end
+
+      # Split a {http://rdoc.info/gems/chunky_png/1.2.0/ChunkyPNG/Canvas Canvas}
+      # into an array of canvases horizontally.
+      #
+      # @param [Canvas] c
+      # @param [Integer] w tile width.
+      # @return [Array] an array of Canvas objects.
+      def split_canvas(c, w = 64)
+        out_a = []
+        (c.width / w).times { |i| out_a << c.crop(i * w, 0, w, c.height) }
+        out_a
+      end
+
+      # Concatenate the file name and directory into a full path, optionally
+      # creating the directory if it doesn't exist.
+      #
+      # @param [String] file
+      # @param [String] dir
+      # @param [Hash] h
+      #   @option h [Boolean] :mkdir If +true+, create +dir+ if it doesn't
+      #     exist.
+      # @return [String]
+      def get_path(file, dir, h = {})
+        f, d = file.dup, dir.dup
+        d << '/' unless d.empty? || d.end_with?('/')
+
+        FileUtils.mkpath(d) if h.fetch(:mkdir, false) && !Dir.exist?(d)
+
+        path = d << f
+        path << '.png' unless path.downcase.end_with?('.png')
+      end
+    end
+  end
+end

data/lib/sabrina/plugins/stats.rb

@@ -0,0 +1,257 @@
+module Sabrina
+  module Plugins
+    # @todo Finish this class.
+    # This {Plugin} aids in manipulating the basic stats of any {Monster}.
+    #
+    # @see Plugin
+    class Stats < Plugin
+      # @see Plugin::ENHANCES
+      ENHANCES = Monster
+
+      # @see Plugin::PLUGIN_NAME
+      PLUGIN_NAME = 'Stats'
+
+      # @see Plugin::SHORT_NAME
+      SHORT_NAME = 'stats'
+
+      # @see Plugin::FEATURES
+      FEATURES = Set.new [:reread, :write]
+
+      # Describes the order in which various stats appear in the byte data.
+      # All of these will also be converted into attributes on runtime and
+      # can be modified directly.
+      STRUCTURE = [
+        :hp, :attack, :defense, :speed, :sp_atk, :sp_def, :type_1, :type_2,
+        :catch_rate, :exp_yield, :ev_yield, :item_1, :item_2, :gender,
+        :egg_cycles, :friendship, :level_curve, :egg_group_1, :egg_group_2,
+        :ability_1, :ability_2, :safari_rate, :color_flip
+      ]
+
+      # Code names for level up types.
+      LEVEL_CURVES = [
+        'Medium-Fast', 'Erratic', 'Fluctuating', 'Medium-Slow', 'Fast', 'Slow'
+      ]
+
+      # Code names for egg groups.
+      EGG_GROUPS = [
+        'None', 'Monster', 'Water 1', 'Bug', 'Flying', 'Field', 'Fairy',
+        'Grass', 'Human-Like', 'Water 3', 'Mineral', 'Amorphous', 'Water 2',
+        'Ditto', 'Dragon', 'Undiscovered'
+      ]
+
+      # Where to pull descriptive names from if applicable, these can be arrays
+      # or ROM tables.
+      NAMES = {
+        type_1: :type_table,
+        type_2: :type_table,
+        item_1: :item_table,
+        item_2: :item_table,
+        level_curve: LEVEL_CURVES,
+        egg_group_1: EGG_GROUPS,
+        egg_group_2: EGG_GROUPS,
+        ability_1: :ability_table,
+        ability_2: :ability_table
+      }
+
+      # @!attribute [rw] rom
+      #   The current working ROM file.
+      #   @return [Rom]
+      # @!attribute [rw] index
+      #   The real index of the monster.
+      #   @return [Integer]
+      attr_accessor(:rom, :index, *STRUCTURE)
+
+      # Generates a new Stats object.
+      #
+      # @return [Stats]
+      def initialize(monster)
+        @monster = monster
+        @rom = monster.rom
+        @index = monster.index
+
+        @stream = Bytestream.from_table(
+          @rom,
+          :stats_table,
+          @monster.index,
+          @rom.stats_length
+        )
+
+        parse_stats
+      end
+
+      # Returns the base stats total.
+      #
+      # @return [Integer]
+      def total
+        @hp + @attack + @defense + @speed + @sp_atk + @sp_def
+      end
+
+      # Reloads the data from a ROM, dropping any changes.
+      #
+      # @return [self]
+      def reread
+        parse_stats
+        self
+      end
+
+      # Write data to the ROM.
+      def write
+        stream.write_to_rom
+      end
+
+      # Returns a {Bytestream} object representing the stats, ready to be
+      # written to the ROM.
+      #
+      # @return [Bytestream]
+      def stream
+        Bytestream.from_bytes(
+          unparse_stats,
+          rom: @rom,
+          table: :stats_table,
+          index: @index
+        )
+      end
+
+      # Returns a hash representation of the stats.
+      #
+      # @return [Hash]
+      def to_h
+        h = {}
+
+        STRUCTURE.each do |entry|
+          h[entry] = instance_variable_get('@' << entry.to_s)
+        end
+
+        { @index => { stats: h } }
+      end
+
+      # Returns a pretty hexadecimal representation of the stats byte data.
+      #
+      # @return [String]
+      def to_hex
+        stream.to_hex(true)
+      end
+
+      # Returns a pretty JSON representation of the stats.
+      #
+      # @return [String]
+      def to_json
+        JSON.pretty_generate(to_h)
+      end
+
+      # Returns a blurb containing the base stats total.
+      #
+      # @return [String]
+      def to_s
+        "<Stats (#{total})>"
+      end
+
+      private
+
+      # Reads stats data from the ROM.
+      def parse_stats
+        b = @stream.to_bytes.dup
+
+        STRUCTURE.each do |entry|
+          value =
+            case entry
+            when :ev_yield
+              parse_evs(b.slice!(0, 2))
+            when :item_1, :item_2
+              b.slice!(0, 2).unpack('S').first
+            when :color_flip
+              parse_color_flip(b.slice!(0))
+            else
+              b.slice!(0).unpack('C').first
+            end
+
+          pretty_value = prettify_stat(entry, value)
+          instance_variable_set('@' << entry.to_s, pretty_value)
+        end
+      end
+
+      # Converts stats data to a GBA-compatible byte string.
+      def unparse_stats
+        b = ''
+        STRUCTURE.each do |entry|
+          val = instance_variable_get('@' << entry.to_s)
+          case entry
+          when :ev_yield
+            b << unparse_evs(val)
+          when :item_1, :item_2
+            b << [val.to_i].pack('S')
+          when :color_flip
+            b << unparse_color_flip(val)
+          else
+            b << [val.to_i].pack('C')
+          end
+        end
+
+        b.ljust(28, "\x00")
+      end
+
+      # Attempts to annotate a numeric value with useful information.
+      def prettify_stat(entry, value)
+        return "#{value} (#{gender_info(value)})" if entry == :gender
+
+        return value unless NAMES.key?(entry) && value.is_a?(Numeric)
+
+        zero_is_valid = [:type_1, :type_2, :level_curve]
+        return value if value == 0 && !zero_is_valid.include?(entry)
+
+        return "#{value} (#{NAMES[entry][value]})" if NAMES[entry].is_a?(Array)
+
+        "#{value} (#{ @rom.read_string_from_table(NAMES[entry], value) })"
+      end
+
+      # Displays readable info about the gender distribution defined by the
+      # provided gender value.
+      def gender_info(i)
+        return 'Genderless' if i > 254
+        return 'Always Female' if i == 254
+        return 'Always Male' if i == 0
+        "#{(100.0 * i / 255).round}% Female"
+      end
+
+      # Converts a word (two bytes) into a hash of EV yield data.
+      def parse_evs(b)
+        a = b.unpack('b*').first.scan(/../).map { |x| x.reverse.to_i(2) }
+        h = {}
+
+        a.take(6).each_index do |i|
+          next if a[i] < 1
+          h[STRUCTURE[i]] = a[i]
+        end
+
+        h
+      end
+
+      # Converts a hash of EV yield data into a word (two bytes).
+      def unparse_evs(h)
+        a = []
+
+        STRUCTURE.take(6).each do |stat|
+          ev = h.fetch(stat, 0)
+          a << ev.to_s(2).rjust(2, '0').reverse
+        end
+
+        [a.join.ljust(16, '0')].pack 'b*'
+      end
+
+      # Converts a byte into an array of dex color and flip.
+      def parse_color_flip(b)
+        s = b.unpack('C').first.to_s(16).rjust(2, '0')
+
+        [
+          s[1].to_i,
+          s[0] == '8' ? true : false
+        ]
+      end
+
+      # Converts an array of dex color and flip into a byte.
+      def unparse_color_flip(a)
+        ((a.last ? '8' : '0') << a.first.to_s).hex.chr
+      end
+    end
+  end
+end