DatabaseToXml WIP2

#==============================================================================#
# ** ISS - Database To Xml
#==============================================================================#
# ** Date Created  : 09/04/2011
# ** Date Modified : 09/05/2011
# ** Created By    : IceDragon
# ** For Game      : Code JIFZ
# ** ID            : 027
# ** Version       : 1.0
# ** Requires      : ISS000 - Core(2.1 or above)
#==============================================================================#
($imported ||= {})["ISS-DatabaseToXml"] = true
#==============================================================================#
# ** ISS::NoteInject
#==============================================================================#
module ISS
  install_script( 27, :system )
  module DatabaseToXml
    Dir.mkdir( "Database" ) if !FileTest.directory?( "Database" )

    def self.dump_database
      dump_data_object( "ITEM", "Items", "Database/Items" )
      dump_data_object( "SKILL", "Skills", "Database/Skills" )
      dump_data_object( "ARMOR", "Armors", "Database/Armors" )
      dump_data_object( "WEAPON", "Weapons", "Database/Weapons" )
      dump_data_object( "STATE", "States", "Database/States" )
      dump_data_object( "CLASS", "Classes", "Database/Classes" )
    end

    def self.dump_data_object( prename, filename, outputfolder )
      Dir.mkdir( outputfolder ) if !FileTest.directory?( outputfolder )
      (i = load_data( "Data/#{filename}.rvdata" )).each { |o|
         next if o.nil?()
         File.open("#{outputfolder}/#{prename}#{"%03d"%o.id}.xml", "w+") { |f|
           f.puts( o.create_xml )
         }
      }
    end

    def self.array_to_string( array )
      return array.inject("") { |r, i| r + %Q("#{i}") + (array.index(i)==array.size-1 ? "" : ",") }
    end

    def self.learnings_array_to_string( array )
      return array.inject("") { |r, i| r + %Q(\n#{i.create_xml}) }
    end

    def self.rank_table_to_string( table )
      result = ""
      for x in 1...table.xsize
        ans = %Q("#{table[x]}")
        result += %Q(<#{x}=#{ans}/>) + (x==table.xsize-1 ? "" : "\n")
      end
      return result
    end

    def self.sting_each_line( string )
      string.split( /[\r\n]+/ ).each { |line| yield line }
    end

    def self.string_to_bool( string )
      case string
      when true              ; return true
      when false             ; return false
      when /(TRUE|YES|Y|T)/i ; return true
      when /(FALSE|NO|N|F)/i ; return false
      else                   ; return false
      end
    end

    def self.number_string_to_array( string )
      result = []
      case string
      when /("\d+"(?:\s*,\s*"\d+")*)/i
        $1.split(/\d+/).each { |i| result << i }
      when /(\d+(?:\s*,\s*\d+)*)/i
        $1.split(/\d+/).each { |i| result << i }
      end
      return result
    end

  end
end

class RPG::BaseItem

  def create_xml()
    return %Q(
<id="#{@id}"/>
<name="#{@name}"/>
<icon_index="#{@icon_index}"/>
<description="#{@description}"/>

<note>
#{@note}
</note>
)
  end

  def set_from_string( instring )
    @__reading_note_lines = false
    ISS::DatabaseToXml.sting_each_line { |line|
      string_to_property( line )
    }
  end

  def string_to_property( line )
    case line
    when /<id="(\d+)"\/>/i
      @id = $1.to_i
    when /<name="(.*)"\/>/i
      @name = $1
    when /<icon_index="(\d+)"\/>/i
      @icon_index = $1.to_i
    when /<description="(.*)"\/>/i
      @description = $1
    when /<note>/i
      @__reading_note_lines = true
    when /<\/note>/i
      @__reading_note_lines = false
    else
      if @__reading_note_lines
        self.note += line + "\n"
      end
    end
  end

end

class RPG::UsableItem

  def create_xml()
    return super + %Q(
<scope="#{@scope}"/>
<occasion="#{@occasion}"/>
<speed="#{@speed}"/>
<animation_id="#{@animation_id}"/>

<common_event_id="#{@common_event_id}"/>

<base_damage="#{@base_damage}"/>
<variance="#{@variance}"/>
<atk_f="#{@atk_f}"/>
<spi_f="#{@spi_f}"/>

<physical_attack="#{@physical_attack.to_s}"/>
<damage_to_mp="#{@damage_to_mp.to_s}"/>
<absorb_damage="#{@absorb_damage.to_s}"/>
<ignore_defense="#{@ignore_defense.to_s}"/>

<element_set>
#{ISS::DatabaseToXml.array_to_string( @element_set )}
</element_set>

<plus_state_set>
#{ISS::DatabaseToXml.array_to_string( @plus_state_set )}
</plus_state_set>

<minus_state_set>
#{ISS::DatabaseToXml.array_to_string( @minus_state_set )}
</minus_state_set>
)
  end

  def set_from_string( string )
    @__reading_element_set     = false
    @__reading_plus_state_set  = false
    @__reading_minus_state_set = false
    super( string )
  end

  def string_to_property( line )
    super( line )
    case line
    when /<scope="(\d+)"\/>/i
      @scope = $1.to_i
    when /<occasion="(\d+)"\/>/i
      @occasion = $1.to_i
    when /<speed="(\d+)"\/>/i
      @speed = $1.to_i
    when /<animation_id="(\d+)"\/>/i
      @animation_id = $1.to_i
    when /<common_event_id="(\d+)"\/>/i
      @common_event_id = $1.to_i
    when /<base_damage="(\d+)"\/>/i
      @base_damage = $1.to_i
    when /<variance="(\d+)"\/>/i
      @variance = $1.to_i
    when /<atk_f="(\d+)"\/>/i
      @atk_f = $1.to_i
    when /<spi_f="(\d+)"\/>/i
      @spi_f = $1.to_i
    when /<physical_attack="(\w+)"\/>/i
      @physical_attack = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<damage_to_mp="(\w+)"\/>/i
      @damage_to_mp = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<absorb_damage="(\w+)"\/>/i
      @absorb_damage = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<ignore_defense="(\w+)"\/>/i
      @ignore_defense = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<element_set>/i
      @__reading_element_set = true
    when /<\/element_set>/i
      @__reading_element_set = false
    when /<plus_state_set>/i
      @__reading_plus_state_set = true
    when /<\/plus_state_set>/i
      @__reading_plus_state_set = false
    when /<minus_state_set>/i
      @__reading_minus_state_set = true
    when /<\/minus_state_set>/i
      @__reading_minus_state_set = false
    else
      if @__reading_element_set
        @element_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
      if @__reading_plus_state_set
        @plus_state_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
      if @__reading_minus_state_set
        @minus_state_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
    end
  end

end

class RPG::Item

  def create_xml()
    return super + %Q(
<price="#{@price}"/>

<consumable="#{@consumable.to_s}"/>

<hp_recovery_rate="#{@hp_recovery_rate}"/>
<hp_recovery="#{@hp_recovery}"/>

<mp_recovery_rate="#{@mp_recovery_rate}"/>
<mp_recovery="#{@mp_recovery}"/>

<parameter_type="#{@parameter_type}"/>
<parameter_points="#{@parameter_points}"/>
    )
  end

  def string_to_property( line )
    super( line )
    case line
    when /<price="(\d+)"\/>/i
      @price = $1.to_i
    when /<consumable="(\w+)"\/>/i
      @consumable = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<hp_recovery_rate="(\d+)"\/>/i
      @hp_recovery_rate = $1.to_i
    when /<hp_recovery="(\d+)"\/>/i
      @hp_recovery = $1.to_i
    when /<mp_recovery_rate="(\d+)"\/>/i
      @mp_recovery_rate = $1.to_i
    when /<mp_recovery="(\d+)"\/>/i
      @mp_recovery = $1.to_i
    when /<parameter_type="(\d+)"\/>/i
      @parameter_type = $1.to_i
    when /<parameter_points="(\d+)"\/>/i
      @parameter_points = $1.to_i
    end
  end

end

class RPG::Skill

  def create_xml()
    return super + %Q(
<mp_cost="#{@mp_cost}"/>

<hit="#{@hit}"/>

<message1="#{@message1}"/>
<message2="#{@message2}"/>
    )
  end

  def string_to_property( line )
    super( line )
    case line
    when /<mp_cost="(\d+)"\/>/i
      @mp_cost = $1.to_i
    when /<hit="(\d+)"\/>/i
      @hit = $1.to_i
    when /<message1="(.*)"\/>/i
      @message1 = $1
    when /<message2="(.*)"\/>/i
      @message2 = $1
    end
  end

end

class RPG::Armor

  def create_xml()
    return super + %Q(
<kind="#{@kind}"/>
<price="#{@price}"/>

<eva="#{@eva}"/>

<atk="#{@atk}"/>
<def="#{@def}"/>
<spi="#{@spi}"/>
<agi="#{@agi}"/>

<prevent_critical="#{@prevent_critical.to_s}"/>
<half_mp_cost="#{@half_mp_cost.to_s}"/>
<double_exp_gain="#{@double_exp_gain.to_s}"/>
<auto_hp_recover="#{@auto_hp_recover.to_s}"/>

<element_set>
#{ISS::DatabaseToXml.array_to_string( @element_set )}
</element_set>

<state_set>
#{ISS::DatabaseToXml.array_to_string( @state_set )}
</state_set>
    )
  end

  def set_from_string( string )
    @__reading_element_set     = false
    @__reading_state_set = false
    super( string )
  end

  def string_to_property( line )
    super( line )
    case line
    when /<kind="(\d+)"\/>/i
      @kind = $1.to_i
    when /<price="(\d+)"\/>/i
      @price = $1.to_i
    when /<eva="(\d+)"\/>/i
      @eva = $1.to_i
    when /<atk="(\d+)"\/>/i
      @atk = $1.to_i
    when /<def="(\d+)"\/>/i
      @def = $1.to_i
    when /<spi="(\d+)"\/>/i
      @spi = $1.to_i
    when /<agi="(\d+)"\/>/i
      @agi = $1.to_i
    when /<prevent_critical="(\w+)"\/>/i
      @prevent_critical = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<half_mp_cost="(\w+)"\/>/i
      @half_mp_cost = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<double_exp_gain="(\w+)"\/>/i
      @double_exp_gain = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<auto_hp_recover="(\w+)"\/>/i
      @auto_hp_recover = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<element_set>/i
      @__reading_element_set = true
    when /<\/element_set>/i
      @__reading_element_set = false
    when /<state_set>/i
      @__reading_element_set = true
    when /<\/state_set>/i
      @__reading_element_set = false
    else
      if @__reading_element_set
        @element_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
      if @__reading_state_set
        @state_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
    end
  end

end

class RPG::Weapon

  def create_xml()
    return super + %Q(
<animation_id="#{@animation_id}"/>
<price="#{@price}"/>

<hit="#{@hit}"/>

<atk="#{@atk}"/>
<def="#{@def}"/>
<spi="#{@spi}"/>
<agi="#{@agi}"/>

<two_handed="#{@two_handed.to_s}"/>
<fast_attack="#{@fast_attack.to_s}"/>
<dual_attack="#{@dual_attack.to_s}"/>
<critical_bonus="#{@critical_bonus.to_s}"/>

<element_set>
#{ISS::DatabaseToXml.array_to_string( @element_set )}
</element_set>

<state_set>
#{ISS::DatabaseToXml.array_to_string( @state_set )}
</state_set>
    )
  end

  def set_from_string( string )
    @__reading_element_set = false
    @__reading_state_set = false
    super( string )
  end

  def string_to_property( line )
    super( line )
    case line
    when /<animation_id="(\d+)"\/>/i
      @animation_id = $1.to_i
    when /<price="(\d+)"\/>/i
      @price = $1.to_i
    when /<hit="(\d+)"\/>/i
      @hit = $1.to_i
    when /<atk="(\d+)"\/>/i
      @atk = $1.to_i
    when /<def="(\d+)"\/>/i
      @def = $1.to_i
    when /<spi="(\d+)"\/>/i
      @spi = $1.to_i
    when /<agi="(\d+)"\/>/i
      @agi = $1.to_i
    when /<two_handed="(\w+)"\/>/i
      @two_handed = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<fast_attack="(\w+)"\/>/i
      @fast_attack = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<dual_attack="(\w+)"\/>/i
      @dual_attack = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<critical_bonus="(\w+)"\/>/i
      @critical_bonus = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<element_set>/i
      @__reading_element_set = true
    when /<\/element_set>/i
      @__reading_element_set = false
    when /<state_set>/i
      @__reading_element_set = true
    when /<\/state_set>/i
      @__reading_element_set = false
    else
      if @__reading_element_set
        @element_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
      if @__reading_state_set
        @state_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
    end
  end
end

class RPG::State

  def create_xml()
    return %Q(
<id="#{@id}"/>
<name="#{@name}"/>
<icon_index="#{@icon_index}"/>

<restriction="#{@restriction}"/>
<priority="#{@priority}"/>

<atk_rate="#{@atk_rate}"/>
<def_rate="#{@def_rate}"/>
<spi_rate="#{@spi_rate}"/>
<agi_rate="#{@agi_rate}"/>

<nonresistance="#{@nonresistance.to_s}"/>
<offset_by_opposite="#{@offset_by_opposite.to_s}"/>
<slip_damage="#{@slip_damage.to_s}"/>
<reduce_hit_ratio="#{@reduce_hit_ratio.to_s}"/>

<battle_only="#{@battle_only.to_s}"/>
<release_by_damage="#{@release_by_damage.to_s}"/>

<hold_turn="#{@hold_turn}"/>
<auto_release_prob="#{@auto_release_prob}"/>

<message1="#{@message1}"/>
<message2="#{@message2}"/>
<message3="#{@message3}"/>
<message4="#{@message4}"/>

<element_set>
#{ISS::DatabaseToXml.array_to_string( @element_set )}
</element_set>

<state_set>
#{ISS::DatabaseToXml.array_to_string( @state_set )}
</state_set>

<note>
#{@note}
</note>
    )
  end

  def set_from_string( instring )
    @__reading_note_lines = false
    @__reading_element_set = false
    @__reading_state_set   = false
    ISS::DatabaseToXml.sting_each_line { |line|
      string_to_property( line )
    }
  end

  def string_to_property( line )
    case line
    when /<id="(\d+)"\/>/i
      @id = $1.to_i
    when /<name="(.*)"\/>/i
      @name = $1
    when /<icon_index="(\d+)"\/>/i
      @icon_index = $1.to_i
    when /<restriction="(\d+)"\/>/i
      @restriction = $1.to_i
    when /<priority="(\d+)"\/>/i
      @priority = $1.to_i
    when /<atk_rate="(\d+)"\/>/i
      @atk_rate = $1.to_i
    when /<def_rate="(\d+)"\/>/i
      @def_rate = $1.to_i
    when /<spi_rate="(\d+)"\/>/i
      @spi_rate = $1.to_i
    when /<agi_rate="(\d+)"\/>/i
      @agi_rate = $1.to_i
    when /<nonresistance="(\w+)"\/>/i
      @nonresistance = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<offset_by_opposite="(\w+)"\/>/i
      @offset_by_opposite = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<slip_damage="(\w+)"\/>/i
      @slip_damage = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<reduce_hit_ratio="(\w+)"\/>/i
      @reduce_hit_ratio = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<battle_only="(\w+)"\/>/i
      @battle_only = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<release_by_damage="(\w+)"\/>/i
      @release_by_damage = ISS::DatabaseToXml.string_to_bool( $1 )
    when /<hold_turn="(\d+)"\/>/i
      @hold_turn = $1.to_i
    when /<auto_release_prob="(\d+)"\/>/i
      @auto_release_prob = $1.to_i
    when /<message1="(.*)"\/>/i
      @message1 = $1
    when /<message2="(.*)"\/>/i
      @message2 = $1
    when /<message3="(.*)"\/>/i
      @message3 = $1
    when /<message4="(.*)"\/>/i
      @message4 = $1
    when /<note>/i
      @__reading_note_lines = true
    when /<\/note>/i
      @__reading_note_lines = false
    when /<element_set>/i
      @__reading_element_set = true
    when /<\/element_set>/i
      @__reading_element_set = false
    when /<state_set>/i
      @__reading_element_set = true
    when /<\/state_set>/i
      @__reading_element_set = false
    else
      if @__reading_note_lines
        self.note += line + "\n"
      end
      if @__reading_element_set
        @element_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
      if @__reading_state_set
        @state_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
    end
  end

end

class RPG::Class

  def create_xml()
    return %Q(
<id="#{@id}"/>
<name="#{@name}"/>
<position="#{@position}"/>

<weapon_set>
#{ISS::DatabaseToXml.array_to_string( @weapon_set )}
</weapon_set>

<armor_set>
#{ISS::DatabaseToXml.array_to_string( @armor_set )}
</armor_set>

<element_ranks>
#{ISS::DatabaseToXml.rank_table_to_string( @element_ranks )}
</element_ranks>

<state_ranks>
#{ISS::DatabaseToXml.rank_table_to_string( @state_ranks )}
</state_ranks>

<learnings>
#{ISS::DatabaseToXml.learnings_array_to_string( @learnings )}
</learnings>

<skill_name_valid="#{@skill_name_valid.to_s}"/>
<skill_name="#{@skill_name}"/>
    )
  end

  class Learning

    def create_xml()
      return %Q(
<learning>
  <level="#{@level}"/>
  <skill_id="#{@skill_id}"/>
</learning>
      )
    end

  end

  def set_from_string( instring )
    @__reading_note_lines    = false
    @__reading_weapon_set    = false
    @__reading_armor_set     = false
    @__reading_element_ranks = false
    @__reading_state_ranks   = false
    @__reading_learnings     = false
    @__lastlearning = nil
    ISS::DatabaseToXml.sting_each_line { |line|
      string_to_property( line )
    }
  end

  def string_to_property( line )
    case line
    when /<id="(\d+)"\/>/i
      @id = $1.to_i
    when /<name="(.*)"\/>/i
      @name = $1
    when /<position="(\d+)"\/>/i
      @position = $1.to_i
    when /<weapon_set>/i
      @__reading_weapon_set = true
    when /<\/weapon_set>/i
      @__reading_weapon_set = false
    when /<armor_set>/i
      @__reading_armor_set  = true
    when /<\/armor_set>/i
      @__reading_armor_set  = false
    when /<element_ranks>/i
      @__reading_element_ranks = true
    when /<\/element_ranks>/i
      @__reading_element_ranks = false
    when /<state_ranks>/i
      @__reading_state_ranks = true
    when /<\/state_ranks>/i
      @__reading_state_ranks = false
    when /<learnings>/i
      @__reading_learnings  = true
    when /<\/learnings>/i
      @__reading_learnings  = false
    else
      if @__reading_weapon_set
        @weapon_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
      if @__reading_armor_set
        @armor_set += ISS::DatabaseToXml.number_string_to_array( line )
      end
      if @__reading_element_ranks
        case line
        when /<(\d+)="(\d+)"\/>/i
          @element_ranks[$1.to_i] = $2.to_i
        end
      end
      if @__reading_state_ranks
        case line
        when /<(\d+)="(\d+)"\/>/i
          @state_ranks[$1.to_i] = $2.to_i
        end
      end
      if @__reading_learnings
        case line
        when /<learning>/i
          @__lastlearning = Learning.new()
        when /<\/learning>/i
          @learnings << @__lastlearning unless @__lastlearning.nil?()
          @__lastlearning = nil
        when /<level="(\d+)"\/>/i
          next if @__lastlearning.nil?()
          @__lastlearning.level = $1.to_i
        when /<skill_id="(\d+)"\/>/i
          next if @__lastlearning.nil?()
          @__lastlearning.skill_id = $1.to_i
        end
      end
    end
  end

end

ISS::DatabaseToXml.dump_database
#=*==========================================================================*=#
# ** END OF FILE
#=*==========================================================================*=#