Added class Data::Ability and made all code use symbols for abilities instead of numbers. Also added class Data::Item but it's unused.

Data/Scripts/011_Data/002_Misc_Data.rb

@@ -190,9 +190,9 @@ module SpeciesData
   def self.optionalValues(compilingForms = false)
     ret = {
       "Type2"               => [TYPE2,              "e", :PBTypes],
-      "Abilities"           => [ABILITIES,          "eE", :PBAbilities, :PBAbilities],
-      "HiddenAbility"       => [HIDDEN_ABILITY,     "eEEE", :PBAbilities, :PBAbilities,
-                                                            :PBAbilities, :PBAbilities],
+      "Abilities"           => [ABILITIES,          "eE", :Ability, :Ability],
+      "HiddenAbility"       => [HIDDEN_ABILITY,     "eEEE", :Ability, :Ability,
+                                                            :Ability, :Ability],
       "Habitat"             => [HABITAT,            "e", :PBHabitats],
       "WildItemCommon"      => [WILD_ITEM_COMMON,   "e", :PBItems],
       "WildItemUncommon"    => [WILD_ITEM_UNCOMMON, "e", :PBItems],

Data/Scripts/011_Data/014_Item_Data.rb

@@ -0,0 +1,158 @@
+class Data
+
+  class Item
+    attr_reader :id
+    attr_reader :id_number
+    attr_reader :real_name
+    attr_reader :real_name_plural
+    attr_reader :pocket
+    attr_reader :price
+    attr_reader :real_description
+    attr_reader :field_use
+    attr_reader :battle_use
+    attr_reader :type
+    attr_reader :move
+
+    DATA = {}
+
+    def initialize(hash)
+      validate hash => Hash, hash[:id] => Symbol
+      @id               = hash[:id]
+      @id_number        = hash[:id_number]   || -1
+      @real_name        = hash[:name]        || "Unnamed"
+      @real_name_plural = hash[:name_plural] || "Unnamed"
+      @pocket           = hash[:pocket]      || 1
+      @price            = hash[:price]       || 0
+      @real_description = hash[:description] || "???"
+      @field_use        = hash[:field_use]   || 0
+      @battle_use       = hash[:battle_use]  || 0
+      @type             = hash[:type]        || 0
+      @move             = hash[:move]
+    end
+
+    # @return [String] the translated name of this item
+    def name
+      return pbGetMessage(MessageTypes::Items, @id_number)
+    end
+
+    # @return [String] the translated plural version of the name of this item
+    def name_plural
+      return pbGetMessage(MessageTypes::ItemPlurals, @id_number)
+    end
+
+    # @return [String] the translated description of this item
+    def description
+      return pbGetMessage(MessageTypes::ItemDescriptions, @id_number)
+    end
+
+    # @param other [Symbol, Item, Integer]
+    # @return [Boolean] whether other is the same as this item
+    def ==(other)
+      return false if other.nil?
+      validate other => [Symbol, Item, Integer]
+      if other.is_a?(Symbol)
+        return @id == other
+      elsif other.is_a?(Item)
+        return @id == other.id
+      elsif other.is_a?(Integer)
+        return @id_number == other
+      end
+      return false
+    end
+
+    # @param item_id [Symbol, Item, Integer]
+    # @return [Boolean] whether the given item_id is defined as an Item
+    def self.exists?(item_id)
+      return false if item_id.nil?
+      validate item_id => [Symbol, Item, Integer]
+      item_id = item_id.id if item_id.is_a?(Item)
+      return !DATA[item_id].nil?
+    end
+
+    # @param item_id [Symbol, Item, Integer]
+    # @return [Item]
+    def self.get(item_id)
+      validate item_id => [Symbol, Item, Integer]
+      return item_id if item_id.is_a?(Item)
+#      if item_id.is_a?(Integer)
+#        p "Please switch to symbols, thanks."
+#      end
+      raise "Unknown item ID #{item_id}." unless DATA.has_key?(item_id)
+      return DATA[item_id]
+    end
+
+    def self.try_get(item_id)
+      return nil if item_id.nil?
+      validate item_id => [Symbol, Item, Integer]
+      return item_id if item_id.is_a?(Item)
+#      if item_id.is_a?(Integer)
+#        p "Please switch to symbols, thanks."
+#      end
+      return (DATA.has_key?(item_id)) ? DATA[item_id] : nil
+    end
+
+    def self.each
+      DATA.keys.sort.each do |key|
+        yield DATA[key] if key.is_a?(Symbol)
+      end
+    end
+
+    def self.load
+      const_set(:DATA, load_data("Data/items.dat"))
+    end
+
+    def self.save
+      save_data(DATA, "Data/items.dat")
+    end
+  end
+
+end
+
+
+
+module Compiler
+  module_function
+
+  def compile_items
+    item_names        = []
+    item_names_plural = []
+    item_descriptions = []
+    # Read each line of items.txt at a time and compile it into an item
+    pbCompilerEachCommentedLine("PBS/items.txt") { |line, line_no|
+      line = pbGetCsvRecord(line, line_no, [0, "vnssuusuuUN"])
+      item_number = line[0]
+      item_symbol = line[1].to_sym
+      if Data::Item::DATA[item_number]
+        raise _INTL("Item ID number '{1}' is used twice.\r\n{2}", item_number, FileLineData.linereport)
+      elsif Data::Item::DATA[item_symbol]
+        raise _INTL("Item ID '{1}' is used twice.\r\n{2}", item_symbol, FileLineData.linereport)
+      end
+      # Construct item hash
+      item_hash = {
+        :id_number   => item_number,
+        :id          => item_symbol,
+        :name        => line[2],
+        :name_plural => line[3],
+        :pocket      => line[4],
+        :price       => line[5],
+        :description => line[6],
+        :field_use   => line[7],
+        :battle_use  => line[8],
+        :type        => line[9]
+      }
+      item_hash[:move] = parseMove(line[10]) if !nil_or_empty?(line[10])
+      # Add item's data to records
+      Data::Item::DATA[item_number] = Data::Item::DATA[item_symbol] = Data::Item.new(item_hash)
+      item_names[item_number]        = item_hash[:name]
+      item_names_plural[item_number] = item_hash[:name_plural]
+      item_descriptions[item_number] = item_hash[:description]
+    }
+    # Save all data
+    Data::Item.save
+    MessageTypes.setMessages(MessageTypes::Items, item_names)
+    MessageTypes.setMessages(MessageTypes::ItemPlurals, item_names_plural)
+    MessageTypes.setMessages(MessageTypes::ItemDescriptions, item_descriptions)
+
+    Graphics.update
+  end
+end

Data/Scripts/011_Data/015_Ability_Data.rb

@@ -0,0 +1,90 @@
+class Data
+
+  class Ability
+    attr_reader :id
+    attr_reader :id_number
+    attr_reader :real_name
+    attr_reader :real_description
+
+    DATA = {}
+
+    def initialize(hash)
+      validate hash => Hash, hash[:id] => Symbol
+      @id               = hash[:id]
+      @id_number        = hash[:id_number]   || -1
+      @real_name        = hash[:name]        || "Unnamed"
+      @real_description = hash[:description] || "???"
+    end
+
+    # @return [String] the translated name of this ability
+    def name
+      return pbGetMessage(MessageTypes::Abilities, @id_number)
+    end
+
+    # @return [String] the translated description of this ability
+    def description
+      return pbGetMessage(MessageTypes::AbilityDescs, @id_number)
+    end
+
+    # @param other [Symbol, Ability, Integer]
+    # @return [Boolean] whether other is the same as this ability
+    def ==(other)
+      return false if other.nil?
+      validate other => [Symbol, Ability, Integer]
+      if other.is_a?(Symbol)
+        return @id == other
+      elsif other.is_a?(Ability)
+        return @id == other.id
+      elsif other.is_a?(Integer)
+        return @id_number == other
+      end
+      return false
+    end
+
+    # @param ability_id [Symbol, Ability, Integer]
+    # @return [Boolean] whether the given ability_id is defined as an Ability
+    def self.exists?(ability_id)
+      return false if ability_id.nil?
+      validate ability_id => [Symbol, Ability, Integer]
+      ability_id = ability_id.id if ability_id.is_a?(Ability)
+      return !DATA[ability_id].nil?
+    end
+
+    # @param ability_id [Symbol, Ability, Integer]
+    # @return [Ability]
+    def self.get(ability_id)
+      validate ability_id => [Symbol, Ability, Integer]
+      return ability_id if ability_id.is_a?(Ability)
+#      if ability_id.is_a?(Integer)
+#        p "Please switch to symbols, thanks."
+#      end
+      raise "Unknown ability ID #{ability_id}." unless DATA.has_key?(ability_id)
+      return DATA[ability_id]
+    end
+
+    def self.try_get(ability_id)
+      return nil if ability_id.nil?
+      validate ability_id => [Symbol, Ability, Integer]
+      return ability_id if ability_id.is_a?(Ability)
+#      if ability_id.is_a?(Integer)
+#        p "Please switch to symbols, thanks."
+#      end
+      return (DATA.has_key?(ability_id)) ? DATA[ability_id] : nil
+    end
+
+    def self.each
+      DATA.keys.sort.each do |key|
+        yield DATA[key] if key.is_a?(Symbol)
+      end
+    end
+
+    def self.load
+      const_set(:DATA, load_data("Data/abilities.dat"))
+    end
+
+    def self.save
+      save_data(DATA, "Data/abilities.dat")
+    end
+  end
+
+end