View difference between Paste ID: JfqQVGa2 and 6kb2i6km

-#===================================================
+                            #======================#
-# Alternate MP X System :: By Zetu (RMVXAce)
+                            #  Z-Systems by: Zetu  #
-# v1.01
+#===========================#======================#===========================#
-##==================================================
+#                 *  *  *  Z02 AMPX Ace Version v1.03  *  *  *                 #
-  #  You may need slight scripting knowledge of working with arrays (but  not a whole lot!).
+#=#==========================================================================#=#
-  #-------------------------------------------------------------------------------------------
+  #  You may need slight scripting knowledge of working with arrays (but     #
-  #                      * * Anything in "< >" means replace with the described contents. * *
+  #  not a whole lot!).                                                      #
-  #  REQUIRED PARAMETERS (Any resource without it will cause an error)
+  #--------------------------------------------------------------------------#
-  #    :name, <name of resource>
+  #   * * Anything in "< >" means replace with the described contents. * *   #
-  #    :abbv, <1 or 2 character abbv. of resource>
+  #  REQUIRED PARAMETERS (Any resource without it will cause an error)       #
-  #    :color, <color 1>, <color 2>
+  #    :name, <name of resource>                                             #
-  #        * These color attributes are indexes of the window skin
+  #    :abbv, <1 or 2 character abbv. of resource>                           #
-  #  OPTIONAL PARAMETERS
+  #    :color, <color 1>, <color 2>                                          #
-  #  Resource Regen for each turn:
+  #        * These color attributes are indexes of the window skin           #
-  #    :regen, <type>, <base>
+  #  OPTIONAL PARAMETERS                                                     #
-  #        type can be :mmp, :atk, :def, :spi, :agi, :set
+  #  Resource Regen for each turn:                                           #
-  #        base is number multiplied by type (:set is considered 1)
+  #    :regen, <type>, <base>                                                #
-  #  Resource Regen on Damage
+  #        type can be :mmp, :atk, :def, :spi, :agi, :set                    #
-  #    :regenondamage, <type>, <base>
+  #        base is number multiplied by type (:set is considered 1)          #
-  #        type can be :damage, :mmp, :set, :percentdmg
+  #  Resource Regen on Damage                                                #
-  #        base in number multipled by type (:set is considered 1)
+  #    :regenondamage, <type>, <base>                                        #
-  #        (:percentdmg is ratio of mmp and damage)
+  #        type can be :damage, :mmp, :set, :percentdmg                      #
-  #    :regenelemental, <element_id>, <type>, <base>
+  #        base in number multipled by type (:set is considered 1)           #
-  #        same as :regenondamage, except on elemental damage (of  element_ids)
+  #        (:percentdmg is ratio of mmp and damage)                          #
-  #        (may place more than 1 id)
+  #    :regenelemental, <type>, <element_id(s)>, <base>                      #
-  #  Resource Change Out of Battle:
+  #        same as :regenondamage, except on elemental damage (of            #
-  #    :depleteoob     (Set to 0)
+  #        element_ids) (may place more than 1 id)                           #
-  #    :regenoob       (Set to Max)
+  #  Resource Change Out of Battle:                                          #
-  #  Max Value
+  #    :depleteoob     (Set to 0)                                            #
-  #    :max, <value>
+  #    :regenoob       (Set to Max)                                          #
-  #  Resource Inversion
+  #  Max Value                                                               #
-  #    :invert
+  #    :max, <value>                                                         #
-  #        this allows the resource to Add instead of Subtract for its cost and disallows
+  #  Resource Inversion                                                      #
-  #        skill use if cost will exceed the max resource
+  #    :invert                                                               #
   #        this allows the resource to Add instead of Subtract for its cost  #
   #        and disallows skill use if cost will exceed the max resource.     #
   #==========================================================================#
-  RESOURCES = [
+
 
   RESOURCES = [[
         :regen, :mmp, 0.05,
         :name, "Mana",
         :abbv, "M",
         :color, 23, 22
-        :regenondamage, :percent, 12,
+
         :depleteoob,
         :regenondamage, :percentdmg, 120,
         :max, 100,
         :name, "Rage",
         :abbv, "R",
         :color, 10, 2
       ],[
         :regenoob,
         :regen, :set, 20,
         :max, 100,
         :name, "Energy",
         :abbv, "E",
         :color, 6, 14
       ],[
-        :regenondamage, :percent, -15,
+
         :regen, :set, 30,
         :regenondamage, :percentdmg, -150,
         :max, 100,
         :name, "Focus",
         :abbv, "F",
         :color, 3, 11
       ],[
-        :regenelemental, 9, :percent, 2,
+
-        :regenelemental, 10, 12, :percent, -1,
+
         :regenelemental, 3, :percent, 80,
         :regenelemental, 4, 6, :percent, -120,
         :regen, :set, -30,
         :max, 150,
         :name, "Heat",
-      ]
+
-  # If set to false, use RESBYCLASS's indexes as Actor IDs instead of Class IDs
+
-  BIND_TO_CLASS = true
+      ]]
 
   # Place in Class/Actor note to specify what resource(s) they use.
   # (May use more than one.)
-  REGEXP_RESOURCES = /<ampx[: ]+(.*)>/i
+  REGEXP_RESOURCES = /<ampx[:]*\s*(.*)>/i
 
   # Place in Skill note to specify mana cost.  First regexp will default
   # in value in database (MP Cost)
-  REGEXP_NOVALUE = /<ampx[: ]+(.+)>/i
+  REGEXP_NOVALUE = /<ampxcost[:]*\s*(.+)>/i
-  REGEXP_WVALUE  = /<ampx[: ]+(.+) +(\d+)>/i
+  REGEXP_WVALUE  = /<ampxcost[:]*\s*(.+) +(\d+)>/i
 
   # If skill does MP damage/healing, use this to tell what resource.
   REGEXP_AMPX = /<ampxvalue[:]*\s*(.+)>/i
 
   # Default value if not in RESBYCLASS hash.
   DEF_RES = "Mana"
 #========#======================#====#================================#========#
 #--------#                      #----# DO NOT EDIT PAST THIS POINT!!! #--------#
 #--------# End of Customization #----# Editing will cause death by    #--------#
 #--------#                      #----# brain asplosions.              #--------#
 #========#======================#====#================================#========#
 end
 ($imported||={})[:z02]=true
 class Window_Base < Window
   #--------------------------------------------------------------------------
   # * New method: draw_actor_ampx
   #--------------------------------------------------------------------------
-	if actor.resources.nil?
+
-		actor.setup(actor.id)
+
-	end
+
     draw_text(x, y, 30, line_height, resource.abbv)
     draw_current_and_max_values(x, y, width, resource.value, resource.max,#~
     mp_color(resource.actor), normal_color)
   end
   #--------------------------------------------------------------------------
   # * Overwrite method: draw_actor_mp
   #--------------------------------------------------------------------------
   def draw_actor_mp(actor, x, y, width=124)
 	  if actor.resources.nil?
 	  	actor.setup(actor.id)
 	  end
     width /= actor.resources.size
     offset = width
     if actor.resources.size != 1
       offset += 2
       width -= 1
     end
     for i in 0...actor.resources.size
-  attr_accessor :max
+
     end
   end
 
 end
 
 class Game_Resources
   attr_reader :name, :abbv, :color1, :color2, :value, :regenelemental,
       :regentype, :regenbase, :regenodtype, :regenodbase, :tags, :regenouttype,
       :regenoutbase, :actor, :index
   attr_writer :max
 
-    @max = @actor.mmp
+
-    @value = @max
+
     @index = get_resource_index(type)
     scan_object_variables(@index)
   end
 
   def scan_object_variables(index)
     i = 0
     array=Z02::RESOURCES[index]
     @tags = []
     @value = max
     @maxdefault = true
     @regenelemental = {}
     while (i < array.size)
       case array[i]
       when :name; @name = array[i+1]; i+=1
       when :abbv; @abbv = array[i+1]; i+=1
       when :color; @color1 = array[i+1]; @color2 = array[i+2]; i+=2
       when :regen; @regentype = array[i+1]; @regenbase = array[i+2]; i+=2
       when :regenonoutdmg
         @regenouttype = array[i+1]
         @regenoutbase = array[i+2]
         i+=2
       when :regenondamage
         @regenodtype = array[i+1]
         @regenodbase = array[i+2]
-          @regenelemental[n]= array[i], array[i+1]
+
       when :regenelemental
         i+=1
         id = []
         while (array[i].is_a?(Integer))
           id.push(array[i])
           i+=1
         end
         for n in id
           @regenelemental[n]= [array[i], array[i+1]]
         end
         i+=1
       when :max
         @max = array[i+1]
         i+=1
         @value = [@max, @value].min
         @maxdefault = false
       when :depleteoob; @tags.push(:depleteoob); @value = 0
       when :regenoob; @tags.push(:regenoob)
       when :invert; @tags.push(:invert)
       end
       i+=1
     end
   end
 
   def max
     @max.nil? ? @actor.mmp : @max
   end
 
-      self.value=self.max
+
     for i in 0...Z02::RESOURCES.size
       index = Z02::RESOURCES[i].index(:name)+1
       if Z02::RESOURCES[i][index].upcase==name.upcase
         return i
-    @value = [[new_value, 0].max, @max].min
+
     end
   end
 
   def reinitialize
     if @tags.include?(:depleteoob)
       self.value=0
     elsif @tags.include?(:regenoob)
       self.value=max
     end
   end
 
   def value=(new_value)
     @value = [[new_value, 0].max, max].min
   end
 
   def rate
     max > 0 ? value.to_f / max : 0
   end
 
   def regen
-  def regendmg(value)
+
     return if @regentype.nil?
     tvalue = @regenbase
     case @regentype
-    when :damage
+
-      value *= tvalue
+
-    when :maxmp
+
-      tvalue *= max
+
-    when :percentdmg
+
-      tvalue *= value.to_f/max
+
     self.value += tvalue.to_i
   end
 
   def regenoffdmg(amt)
-  def regenoffdmg(value)
+
     return if amt < 1
     tvalue = regenoutbase
     case regenouttype
-    when :damage
+    when :damage;     tvalue *= amt
-      value *= tvalue
+    when :maxmp;      tvalue *= max
-    when :maxmp
+    when :percentdmg; tvalue *= amt.to_f/@actor.mhp
-      tvalue *= max
+
-    when :percentdmg
+
-      tvalue *= value.to_f/max
+
 
   def regendmg(amt, element_id=0)
     regendmgreg(amt)
     regendmgele(amt, element_id)
   end
 
-      return (self.value+amount)<=self.max
+  def regendmgreg(amt)
     return if regenodtype.nil?
-      return (self.value)>=amount
+    return if amt < 1
     tvalue = regenodbase
     case regenodtype
     when :damage;     tvalue *= amt
-  def pay(amount)
+    when :maxmp;      tvalue *= max
     when :percentdmg; tvalue *= amt.to_f/@actor.mhp
-      self.value += amount
+
     self.value += tvalue.to_i
-      self.value -= amount
+
 
   def regendmgele(amt, element_id)
     return if regenelemental.nil?
     return if regenelemental[element_id].nil?
     return if amt < 1
     tvalue = regenelemental[element_id][1]
     case regenelemental[element_id][0]
     when :damage;     tvalue *= amt
     when :maxmp;      tvalue *= max
-  print "Creating Resources for #{self.name}!\n"
+    when :percentdmg; tvalue *= amt.to_f/@actor.mhp
     end
     self.value += tvalue.to_i
   end
 
   def pay?(amount)
     if @tags.include?(:invert)
       return (@value+amount)<=@max
     else
-  alias z02ote on_turn_end unless $@
+      return (@value)>=amount
     end
   end
-    for resource in self.resources
+
   def pay(amt)
     if @tags.include?(:invert)
       @value += amt
     else
-  alias z02od on_damage
+      @value -= amt
-  def on_damage(value)
+
-    z02od(value)
+
-    for resource in self.resources
+
-      resource.regendmg(value)
+
 
 class Game_Battler < Game_BattlerBase
   attr_reader :resources
   #--------------------------------------------------------------------------
   # * New method: create_resources
   #--------------------------------------------------------------------------
   def create_resources
     @resources = []
     create_actor_spec_resources
     @resources.push(Game_Resources.new(Z02::DEF_RES, self)) if @resources.size==0
   end
   #--------------------------------------------------------------------------
   # * New method: create_actor_spec_resources
   #--------------------------------------------------------------------------
   def create_actor_spec_resources
   end
   #--------------------------------------------------------------------------
   # * Alias method: on_turn_end
   #--------------------------------------------------------------------------
   alias :z02ote :on_turn_end
   def on_turn_end
     z02ote
     for resource in @resources
       resource.regen
     end
   end
   #--------------------------------------------------------------------------
   # * New method: resourcebyid
   #--------------------------------------------------------------------------
   def resourcebyid(id)
     for resource in @resources
       return resource if resource.index==id
     end
     return nil
   end
-  alias z02psc pay_skill_cost unless $@
+  #--------------------------------------------------------------------------
   # * New method: skill_ampx_costs
   #--------------------------------------------------------------------------
   def skill_ampx_costs(skill)
     values = []
     skill.note.scan(Z02::REGEXP_NOVALUE){
       next if (index=self.resources[0].get_resource_index($1)).nil?
       values[index] = skill.mp_cost}
     skill.note.scan(Z02::REGEXP_WVALUE){
       next if (index=self.resources[0].get_resource_index($1)).nil?
       values[index] = $2.to_i}
     if values.size==0
       index = self.resources[0].index
       values[index]=skill.mp_cost
     end
-  alias z02init initialize unless $@
+
   end
   #--------------------------------------------------------------------------
   # * Overwrite method: skill_cost_payable?
   #--------------------------------------------------------------------------
   def skill_cost_payable?(skill)
     values = skill_ampx_costs(skill)
     for i in 0...values.size
       next if values[i].nil?
       return false if (resource = resourcebyid(i)).nil?
-  alias z02setup setup unless $@
+
     end
     return true
   end
   #--------------------------------------------------------------------------
   # * Alias method: pay_skill_cost
   #--------------------------------------------------------------------------
-    (Z02::BIND_TO_CLASS ? self.class : self).note.scan(Z02::REGEXP_RESOURCES){
+  alias :z02psc :pay_skill_cost
   def pay_skill_cost(skill)
     z02psc(skill)
     values = skill_ampx_costs(skill)
     for i in 0...values.size
       next if values[i].nil?
       return false if (resource = resourcebyid(i)).nil?
       resource.pay(values[i])
     end
   end
   #--------------------------------------------------------------------------
   # * Alias method: item_apply
-	  next if actor.resources.nil?
+  #--------------------------------------------------------------------------
   alias :z02ia :item_apply
   def item_apply(user, item)
     z02ia(user, item)
     if @result.hit?
       unless item.damage.none?
         ampx_ondamage(user, item.damage.element_id)
         resource = resource(item)
         unless resource.nil?
           resource.value -= @result.mp_damage
           ####user.mp += @result.mp_drain#### NEED TO ADD DRAIN
-  alias z02dsc draw_skill_cost unless $@
+
       end
     end
   end
 
   def ampx_ondamage(user, element_id)
     return if @result.hp_damage==0
     for resource in @resources
       resource.regendmg(@result.hp_damage, element_id)
-        change_color(text_color(resource.color1), @actor.skill_cost_payable?(skill))
+
     for resource in user.resources
       resource.regenoffdmg(@result.hp_damage)
     end
   end
 
   def resource(item)
     name = item.resourcename
-
+
       return resource if resource.name.upcase==name.upcase
     end
     return nil
   end
 
 end
 
 class Game_Enemy < Game_Battler
   #--------------------------------------------------------------------------
   # * Alias method: initialize
   #--------------------------------------------------------------------------
   alias :z02init :initialize
   def initialize(index, enemy_id)
     z02init(index, enemy_id)
     create_resources
   end
 
 end
 
 class Game_Actor < Game_Battler
   #--------------------------------------------------------------------------
   # * Alias method: setup
   #--------------------------------------------------------------------------
   alias :z02setup :setup
   def setup(actor_id)
     z02setup(actor_id)
     create_resources
   end
   #--------------------------------------------------------------------------
   # * New method: create_actor_spec_resources
   #--------------------------------------------------------------------------
   def create_actor_spec_resources
     self.class.note.scan(Z02::REGEXP_RESOURCES){
     @resources.push(Game_Resources.new($1, self))}
   end
 
 end
 
 module SceneManager
   #--------------------------------------------------------------------------
   # * Alias method: call
   #--------------------------------------------------------------------------
   class <<self; alias_method :z02call, :call; end
   def self.call(scene_class)
     self.z02call(scene_class)
     for actor in $game_party.members
 	    next if actor.resources.nil?
       for resource in actor.resources
         resource.reinitialize
       end
     end
   end
 
 end
 
 class Window_SkillList < Window_Selectable
   #--------------------------------------------------------------------------
   # * Alias method: draw_skill_cost
   #--------------------------------------------------------------------------
   alias :z02dsc :draw_skill_cost
   def draw_skill_cost(rect, skill)
     if @actor.skill_tp_cost(skill) > 0
       z02dsc(rect, skill)
     elsif @actor.skill_mp_cost(skill) > 0
       values = @actor.skill_ampx_costs(skill)
       values.size.downto(0) { |i|
         next if values[i].nil?
         next if (resource = @actor.resourcebyid(i)).nil?
         change_color(text_color(resource.color1),
           @actor.skill_cost_payable?(skill))
         draw_text(rect, values[i], 2)
         rect.width -= 32
       }
     end
   end
 
 end
 
 class RPG::UsableItem < RPG::BaseItem
 
   def resourcename
     self.note.scan(Z02::REGEXP_AMPX){
       return $1}
     return Z02::DEF_RES
   end
 
 end
 
 class Game_ActionResult
 
   def ampx_damage_text(name)
     if @mp_drain > 0
       fmt = @battler.actor? ? Vocab::ActorDrain : Vocab::EnemyDrain
       sprintf(fmt, @battler.name, name, @mp_drain)
     elsif @mp_damage > 0
       fmt = @battler.actor? ? Vocab::ActorLoss : Vocab::EnemyLoss
       sprintf(fmt, @battler.name, name, @mp_damage)
     elsif @mp_damage < 0
       fmt = @battler.actor? ? Vocab::ActorRecovery : Vocab::EnemyRecovery
       sprintf(fmt, @battler.name, name, -@mp_damage)
     else
       ""
     end
   end
 
 end