Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- if true # << Make true to use this script, false to disable.
- #===============================================================================
- #
- # ☆ $D13x - Elemental Control
- # -- Author : Dekita
- # -- Version : 1.4
- # -- Level : Easy / Normal
- # -- Requires : N/A
- # -- Engine : RPG Maker VX Ace.
- #
- #===============================================================================
- # ☆ Import
- #-------------------------------------------------------------------------------
- $D13x={}if$D13x==nil
- $D13x[:Elems_Control]=true
- #===============================================================================
- # ☆ Updates
- #-------------------------------------------------------------------------------
- # D /M /Y
- # 15/o3/2o14 - Fixed small bug with max attack elements,
- # o2/o3/2o14 - Fixed small bug with max attack elements,
- # 31/o5/2o13 - Added More Script Call Help Information.
- # 26/o3/2o13 - Finished,
- # - Fixed Typos,
- # 23/o3/2o13 - Started,
- #
- #===============================================================================
- # ☆ Introduction
- #-------------------------------------------------------------------------------
- # This script is the Elemental Equivalent of my Statistic Control Script.
- # This script 'fixes' elements, ie. differentiates between attack and defence
- # element types.
- # This script also allows Dev's control over elements that would not normally
- # be available, such as various script calls to modify the element value
- # using simple arithmatic (add/subtract/divide/multiply/modulo),
- # As well as actors/classes/enemies/weapons/armors/states/skills notetags.
- #
- # It also adds Max and Min limits for all elements and gives control over these
- # new limitations for both attack and defence.
- #
- # It also provides new ways of handling the elemental damage modification.
- # ie, allows for multiple element damage variances, rather than 1.
- #
- # Note :
- # Elements still work with percentage values, ie 0.01 is 1%, 1.0 is 100%
- #
- #===============================================================================
- # ★☆★☆★☆★☆★☆★☆★☆★ TERMS AND CONDITIONS: ☆★☆★☆★☆★☆★☆★☆★☆★☆
- #===============================================================================
- # 1. You MUST give credit to "Dekita" !!
- # 2. You are NOT allowed to repost this script.(or modified versions)
- # 3. You are NOT allowed to convert this script.
- # 4. You are NOT allowed to use this script for Commercial games.
- # 5. ENJOY!
- #
- # "FINE PRINT"
- # By using this script you hereby agree to the above terms and conditions,
- # if any violation of the above terms occurs "legal action" may be taken.
- # Not understanding the above terms and conditions does NOT mean that
- # they do not apply to you.
- # If you wish to discuss the terms and conditions in further detail you can
- # contact me at http://dekitarpg.wordpress.com/
- #
- #===============================================================================
- # ☆ Instructions
- #-------------------------------------------------------------------------------
- # Place Below " ▼ Materials " and Above " ▼ Main " in your script editor.
- #
- #===============================================================================
- # ☆ Script Calls
- #-------------------------------------------------------------------------------
- # $game_actor[id].add_def_ele(element_id, value)
- # $game_actor[id].sub_def_ele(element_id, value)
- # $game_actor[id].mul_def_ele(element_id, value)
- # $game_actor[id].div_def_ele(element_id, value)
- # $game_actor[id].mod_def_ele(element_id, value)
- #
- # $game_actor[id].add_atk_ele(element_id, value)
- # $game_actor[id].sub_atk_ele(element_id, value)
- # $game_actor[id].mul_atk_ele(element_id, value)
- # $game_actor[id].div_atk_ele(element_id, value)
- # $game_actor[id].mod_atk_ele(element_id, value)
- #
- # id = the actors database id
- # element_id = the elements database id
- # value = the value you with to modify the element with
- #
- # these are the calculatons for each control type
- # add : current stat += value
- # sub : current stat -= value
- # div : current stat /= value
- # mul : current stat *= value
- # mod : current stat %= value
- #
- # These script calls modify the Actor value, other items remain in the same order.
- #
- # BIG NOTE ::
- # By default in Vx Ace the starting element defence is 1.0, this is because the
- # calculation is 1.0 * element defence (eg 1.0) which makes the damage normal
- # (normal = no resist or weakness) this means, if your elemental defence is 2.0
- # you will take 2.0* the damage from elements.
- # This means in order to INCREASE your resistance towards a peticular element
- # you must REDUCE the defencive element.
- # eg.
- # add = more elemental damage intake
- # sub = less elemental damage intake
- #
- # Attack elements work as you would expect.
- # eg.
- # add = more elemental attack value
- # sub = less elemental attack value
- #
- # There is also a third arguement for all the above script calls,
- # it is a boolean arguement to determine if the player should be refreshed.
- # eg.. $game_actors[1].add_atk_ele(3, 0.05, false)
- # this is very helpfull for maintaining FPS when adding LOTS of stats..
- # The default to this arguemet is true.
- # If you don't understand what this mean, just disregard this information :)
- #
- #===============================================================================
- # ☆ Notetags ( default )
- # For use with Weapons / Armors / Enemies / Actors / Classes / States / Skills
- #-------------------------------------------------------------------------------
- # <atk ele: element_id, value>
- # <def ele: element_id, value>
- # <max atk ele: element_id, value>
- # <max def ele: element_id, value>
- #
- # element_id = The Element ID from the database
- # value = the value you wish to change the element by
- #
- #-------------------------------------------------------------------------------
- # For Skills / Items
- #-------------------------------------------------------------------------------
- # <inc atk ele>
- # Use this notetag to change whether this skill includes all elemental damage
- # it will change from the default setting defined at- Atk_Ele_Inc_All_Dmg
- #
- # <no ele mod>
- # Will make the skill / item have no elemental modification when used.
- #
- #===============================================================================
- # ☆ HELP
- #-------------------------------------------------------------------------------
- # Remember :
- # All Elemental Values work with float values, eg. 1.0, 0.5, 0.1, 0.05, 0.01
- # 1.0 = 100%, 0.01 = 1%,
- #
- # Also, element id numbers can be found in the database.
- #
- #===============================================================================
- module Ele_Fixx
- #===============================================================================
- Element={0=>{:atk_ele=>[0,1],:def_ele=>[0,1]}}# << KEEP !!
- Notes={}# << Keep
- #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
- # ☆ Calculation Settings
- #--------------------------------------------------------------------------
- # This is where you set how the script calculates elemental damage
- # Types :
- # 0 = Will take the max element modifier as the damage multiplication
- # This is also the Vx Ace Default Calculation.
- # This will make even the smallest attack elemental modifier count as full
- # elemental attack.
- #
- # 1 = Will calculate only weak and resisted elements, then adds/subtracts
- # Them accordingly and adds them onto the default attack for a total
- # calculation. (positive or negative)
- # RECOMMENDED TYPE.
- #
- # 2 = Will add each elemental modifier together for the damage multiplication
- # This Is An Experimental Calculation ;p
- #
- # 3 = Will take the average modifier for the damage calculation
- # This Is Another Experimental Calculation ;p
- #--------------------------------------------------------------------------
- DMG_Type = 1
- #--------------------------------------------------------------------------
- # Make true if you want all damage to increase based on element atk value
- # - if false, damage will only increase if you use a skill with that element
- #--------------------------------------------------------------------------
- Atk_Ele_Inc_All_Dmg = false
- #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
- # ☆ Limit Settings
- #--------------------------------------------------------------------------
- # This is where you adjust the settings for the base min and max values
- # used for actors / enemies.
- #--------------------------------------------------------------------------
- #Element[id]={ :atk_ele => [ Min , Max ], :def_ele => [ Min , Max ]}
- Element[1] = { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- Element[2] = { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- Element[3] = { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- Element[4] = { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- Element[5] = { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- Element[6] = { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- Element[7] = { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- Element[8] = { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- Element[9] = { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- Element[10]= { :atk_ele => [ -2.0 , 2.0 ], :def_ele => [ -2.0 , 2.0 ]}
- # << Add more rows here if you have more than 10
- # elements in your project :)
- # Follow the same format as above, ie Element[ id ] = [ Min , Max ]
- #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
- # ☆ Notetag Settings
- #--------------------------------------------------------------------------
- # This is where you adjust the settings for the notetags used in all
- # notetaggable items.
- # Only modify these if you understand how to.
- #--------------------------------------------------------------------------
- Notes[:atk_ele] = /<atk ele:(.*),(.*)>/i
- Notes[:def_ele] = /<def ele:(.*),(.*)>/i
- Notes[:max_atk_ele] = /<max atk ele:(.*),(.*)>/i
- Notes[:max_def_ele] = /<max def ele:(.*),(.*)>/i
- Notes[:no_element] = /<no ele mod>/i
- Notes[:atk_ele_dmg] = /<inc atk ele>/i
- end #####################
- # CUSTOMISATION END #
- #####################
- #☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★#
- # #
- # http://dekitarpg.wordpress.com/ #
- # #
- #★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆#
- #===============================================================================#
- # ARE YOU MODIFYING BEYOND THIS POINT? \.\. #
- # YES?\.\. #
- # OMG, REALLY? \| #
- # WELL SLAP MY FACE AND CALL ME A DRAGONITE.\..\.. #
- # I REALLY DIDN'T THINK YOU HAD IT IN YOU.\..\.. #
- #===============================================================================#
- module DataManager
- #===============================================================================
- #---------------------------------------------------------------------------
- # Alias List
- #---------------------------------------------------------------------------
- class << self
- alias :lbd_elef_element :load_database
- end
- #---------------------------------------------------------------------------
- # Load Database (alias)
- #---------------------------------------------------------------------------
- def self.load_database
- lbd_elef_element
- loa_elef_element
- end
- #---------------------------------------------------------------------------
- # Load Unique Elemental Shit
- #---------------------------------------------------------------------------
- def self.loa_elef_element
- classes = [$data_weapons, $data_armors , $data_items , $data_skills ,
- $data_actors , $data_classes, $data_enemies, $data_states ]
- for g in classes
- for o in g
- next if o == nil
- o.load_elemental_control
- end
- end
- end
- end # DataManager
- #===============================================================================
- class RPG::BaseItem
- #===============================================================================
- #---------------------------------------------------------------------------
- # Pi Variables
- #---------------------------------------------------------------------------
- attr_accessor :atk_ele
- attr_accessor :def_ele
- attr_accessor :max_atk_ele
- attr_accessor :max_def_ele
- attr_accessor :include_elem_dmg
- #---------------------------------------------------------------------------
- # Load Elemental Control
- #---------------------------------------------------------------------------
- def load_elemental_control
- @atk_ele = [0] * $data_system.elements.size
- @def_ele = [0] * $data_system.elements.size
- @max_atk_ele = [0] * $data_system.elements.size
- @max_def_ele = [0] * $data_system.elements.size
- @include_elem_dmg = Ele_Fixx::Atk_Ele_Inc_All_Dmg
- check_elefixx_notetags
- end
- #---------------------------------------------------------------------------
- # Parse Notes
- #---------------------------------------------------------------------------
- def check_elefixx_notetags
- self.note.split(/[\r\n]+/).each do |line|
- case line
- when Ele_Fixx::Notes[:atk_ele] then @atk_ele[$1.to_i] = $2.to_f
- when Ele_Fixx::Notes[:def_ele] then @def_ele[$1.to_i] = $2.to_f
- when Ele_Fixx::Notes[:max_atk_ele] then @max_atk_ele[$1.to_i] = $2.to_f
- when Ele_Fixx::Notes[:max_def_ele] then @max_def_ele[$1.to_i] = $2.to_f
- when Ele_Fixx::Notes[:atk_ele_dmg] then @include_elem_dmg = !@include_elem_dmg
- end
- end
- end
- end # << RPG::BaseItem
- #===============================================================================
- class RPG::UsableItem < RPG::BaseItem
- #===============================================================================
- #---------------------------------------------------------------------------
- # Pi Variables
- #---------------------------------------------------------------------------
- attr_accessor :no_ele_mod
- #---------------------------------------------------------------------------
- # Load Elemental Control
- #---------------------------------------------------------------------------
- def load_elemental_control
- super
- @no_ele_mod = false
- check_elefixx_notetags
- end
- #---------------------------------------------------------------------------
- # Parse Notes
- #---------------------------------------------------------------------------
- def check_elefixx_notetags
- super
- self.note.split(/[\r\n]+/).each do |line|
- case line
- when Ele_Fixx::Notes[:no_element]
- @no_ele_mod = true
- end
- end
- end
- end # << RPG::BaseItem
- #===============================================================================
- class Game_BattlerBase
- #===============================================================================
- #--------------------------------------------------------------------------
- # Alias List
- #--------------------------------------------------------------------------
- alias :sd13x_GB_elems :initialize
- #--------------------------------------------------------------------------
- # Initialize Data
- #--------------------------------------------------------------------------
- def initialize(*a,&b)
- clear_def_ele_plus
- clear_atk_ele_plus
- sd13x_GB_elems(*a,&b)
- end
- #--------------------------------------------------------------------------
- # Get Attack Element || Old Method >> features_set(FEATURE_ATK_ELEMENT)
- #--------------------------------------------------------------------------
- def atk_elements
- a = []
- $data_system.elements.size.times do |i|
- e = atk_element_rate(i)
- a << i if e != 0.0
- end
- a
- end
- #--------------------------------------------------------------------------
- # Get Min Value of Defencive Elements
- #--------------------------------------------------------------------------
- def def_ele_min(element_id)
- return Ele_Fixx::Element[element_id][:def_ele][0]
- end
- #--------------------------------------------------------------------------
- # Get Maximum Value of Defencive Elements
- #--------------------------------------------------------------------------
- def def_ele_max(element_id)
- return Ele_Fixx::Element[element_id][:def_ele][1]
- end
- #--------------------------------------------------------------------------
- # Get Base Element Rate
- #--------------------------------------------------------------------------
- def def_ele_base(element_id)
- features_pi(FEATURE_ELEMENT_RATE, element_id)
- end
- #--------------------------------------------------------------------------
- # Get Real Defencive Element Rate
- #--------------------------------------------------------------------------
- def element_rate(element_id)
- val = ( def_ele_base(element_id) + def_ele_plus(element_id) )
- [[val, def_ele_max(element_id)].min, def_ele_min(element_id)].max.to_f
- end
- #--------------------------------------------------------------------------
- # Defencive Elements Plus
- #--------------------------------------------------------------------------
- def def_ele_plus(element_id)
- @def_ele_plus[element_id]
- end
- #--------------------------------------------------------------------------
- # Clear Defencive Elements Plus
- #--------------------------------------------------------------------------
- def clear_def_ele_plus
- @def_ele_plus = [0] * $data_system.elements.size
- end
- #--------------------------------------------------------------------------
- # Add Defencive Elements
- #--------------------------------------------------------------------------
- def add_def_ele(element_id, value, ref = true)
- @def_ele_plus[element_id] += value
- refresh if ref
- end
- #--------------------------------------------------------------------------
- # Sub Defencive Elements
- #--------------------------------------------------------------------------
- def sub_def_ele(element_id, value, ref = true)
- @def_ele_plus[element_id] -= value
- refresh if ref
- end
- #--------------------------------------------------------------------------
- # Div Defencive Elements
- #--------------------------------------------------------------------------
- def div_def_ele(element_id, value, ref = true)
- @def_ele_plus[element_id] /= value
- refresh if ref
- end
- #--------------------------------------------------------------------------
- # Mul Defencive Elements
- #--------------------------------------------------------------------------
- def mul_def_ele(element_id, value, ref = true)
- @def_ele_plus[element_id] *= value
- refresh if ref
- end
- #--------------------------------------------------------------------------
- # Mod Defencive Elements
- #--------------------------------------------------------------------------
- def mod_def_ele(element_id, value, ref = true)
- @def_ele_plus[element_id] %= value
- refresh if ref
- end
- #--------------------------------------------------------------------------
- # Get Min Value of Attack Elements
- #--------------------------------------------------------------------------
- def atk_ele_min(element_id)
- return Ele_Fixx::Element[element_id][:atk_ele][0]
- end
- #--------------------------------------------------------------------------
- # Get Maximum Value of Attack Elements
- #--------------------------------------------------------------------------
- def atk_ele_max(element_id)
- return Ele_Fixx::Element[element_id][:atk_ele][1]
- end
- #--------------------------------------------------------------------------
- # Get Base Attack Element Rate
- #--------------------------------------------------------------------------
- def atk_ele_base(element_id)
- features_sum(FEATURE_ATK_ELEMENT, element_id)
- end
- #--------------------------------------------------------------------------
- # Get Real Attack Elements Rate
- #--------------------------------------------------------------------------
- def atk_element_rate(element_id)
- val = ( atk_ele_base(element_id) + atk_ele_plus(element_id) )
- [[val, atk_ele_max(element_id)].min, atk_ele_min(element_id)].max.to_f
- end
- #--------------------------------------------------------------------------
- # Attack Elements Plus
- #--------------------------------------------------------------------------
- def atk_ele_plus(element_id)
- @atk_ele_plus[element_id]
- end
- #--------------------------------------------------------------------------
- # Clear Attack Elements Plus
- #--------------------------------------------------------------------------
- def clear_atk_ele_plus
- @atk_ele_plus = [0] * $data_system.elements.size
- end
- #--------------------------------------------------------------------------
- # Add Attack Elements
- #--------------------------------------------------------------------------
- def add_atk_ele(element_id, value, ref = true)
- @atk_ele_plus[element_id] += value
- refresh if ref
- end
- #--------------------------------------------------------------------------
- # Sub Attack Elements
- #--------------------------------------------------------------------------
- def sub_atk_ele(element_id, value, ref = true)
- @atk_ele_plus[element_id] -= value
- refresh if ref
- end
- #--------------------------------------------------------------------------
- # Div Attack Elements
- #--------------------------------------------------------------------------
- def div_atk_ele(element_id, value, ref = true)
- @atk_ele_plus[element_id] /= value
- refresh if ref
- end
- #--------------------------------------------------------------------------
- # Mul Attack Elements
- #--------------------------------------------------------------------------
- def mul_atk_ele(element_id, value, ref = true)
- @atk_ele_plus[element_id] *= value
- refresh if ref
- end
- #--------------------------------------------------------------------------
- # Mod Attack Elements
- #--------------------------------------------------------------------------
- def mod_atk_ele(element_id, value, ref = true)
- @atk_ele_plus[element_id] %= value
- refresh if ref
- end
- end # << Game_BattlerBase
- #===============================================================================
- class Game_Battler < Game_BattlerBase
- #===============================================================================
- #--------------------------------------------------------------------------
- # Get Element Modifier for Skill/Item
- #--------------------------------------------------------------------------
- def item_element_rate(user, item)
- all_eles = user.atk_elements.clone << item.damage.element_id
- return 1.0 if all_eles.empty?
- return 1.0 if item.no_ele_mod
- case Ele_Fixx::DMG_Type
- # // Default Type
- when 0 then var = elements_max_rate(user.atk_elements)
- # // $D13x Type
- when 1 then var = sD13x_element_rate(user,item)
- # // Adding Type
- when 2 then var = elements_add_rate(user.atk_elements)
- # // Average Type
- when 3 then var = elements_ave_rate(user.atk_elements)
- end
- if user.is_a?(Game_Actor)
- p "[ #{user.name} ] << attacker | element rate is = #{var}"
- end
- return var
- end
- #--------------------------------------------------------------------------
- # Elements Max Rate (For Reference)
- #--------------------------------------------------------------------------
- # def elements_max_rate(elements)
- # elements.inject([0.0]) {|r, i| r.push(element_rate(i)) }.max
- # end
- #--------------------------------------------------------------------------
- # $D13x Element Rate
- #--------------------------------------------------------------------------
- def sD13x_element_rate(user,item)
- atk_eles = user.atk_elements
- skl_eles = item.damage.element_id
- rate = 1.0
- atk_eles.each do |i|
- erate = element_rate(i)-1.0
- uatkr = 1.0
- if item.include_elem_dmg
- uatkr = user.atk_element_rate(i)
- uatkr = (user.atk_element_rate(i)*2) if skl_eles == i
- else
- uatkr = user.atk_element_rate(i) if skl_eles == i
- end
- rate += uatkr * (1.0+erate) if uatkr >= 0.0
- rate -= uatkr * (1.0-erate) if uatkr < 0.0
- p "#{$data_system.elements[i]} dmg rate is #{rate}" if user.is_a?(Game_Actor)
- end
- rate
- end
- #--------------------------------------------------------------------------
- # Elements Add Rate
- #--------------------------------------------------------------------------
- def elements_add_rate(elements)
- elements.inject(1.0) {|r, i| r += element_rate(i) - (1.0) }
- end
- #--------------------------------------------------------------------------
- # Elements Average Rate
- #--------------------------------------------------------------------------
- def elements_ave_rate(elements)
- data = elements.inject(0.0) {|r, i| r += element_rate(i) }
- (data / (elements.size)).to_f
- end
- end
- #===============================================================================
- class Game_Actor < Game_Battler
- #===============================================================================
- #--------------------------------------------------------------------------
- # Defence Element Max
- #--------------------------------------------------------------------------
- def def_ele_max(element_id)
- base = super
- base += actor.max_def_ele[element_id]
- base += self.class.max_def_ele[element_id]
- base += equips.compact.inject(0) {|r, i| r += i.max_def_ele[element_id] }
- base += states.compact.inject(0) {|r, i| r += i.max_def_ele[element_id] }
- if $D13x[:Skill_Lv]
- base += skills.compact.inject(0) {|r, i| r += (i.max_def_ele[element_id]*
- Skill_Levels::Exp_Set[i.exp_set][@skills_lv[i.id]][2] ).to_f}
- else
- base += skills.compact.inject(0) {|r, i| r += i.max_def_ele[element_id] }
- end
- base
- end
- #--------------------------------------------------------------------------
- # Defence Element Plus
- #--------------------------------------------------------------------------
- def def_ele_plus(element_id)
- base = super
- base += actor.def_ele[element_id]
- base += self.class.def_ele[element_id]
- base += equips.compact.inject(0) {|r, i| r += (i.def_ele[element_id])}
- base += states.compact.inject(0) {|r, i| r += i.def_ele[element_id] }
- if $D13x[:Skill_Lv]
- base += skills.compact.inject(0) {|r, i| r += (i.def_ele[element_id]*
- Skill_Levels::Exp_Set[i.exp_set][@skills_lv[i.id]][2] ).to_f}
- else
- base += skills.compact.inject(0) {|r, i| r += i.def_ele[element_id] }
- end
- base
- end
- #--------------------------------------------------------------------------
- # Attack Element Max
- #--------------------------------------------------------------------------
- def atk_ele_max(element_id)
- base = super
- base += actor.max_atk_ele[element_id]
- base += self.class.max_atk_ele[element_id]
- base += equips.compact.inject(0) {|r, i| r += i.max_atk_ele[element_id] }
- base += states.compact.inject(0) {|r, i| r += i.max_atk_ele[element_id] }
- if $D13x[:Skill_Lv]
- base += skills.compact.inject(0) {|r, i| r += (i.max_atk_ele[element_id]*
- Skill_Levels::Exp_Set[i.exp_set][@skills_lv[i.id]][2] ).to_f}
- else
- base += skills.compact.inject(0) {|r, i| r += i.max_atk_ele[element_id] }
- end
- base
- end
- #--------------------------------------------------------------------------
- # Attack Element Plus
- #--------------------------------------------------------------------------
- def atk_ele_plus(element_id)
- base = super
- base += actor.atk_ele[element_id]
- base += self.class.atk_ele[element_id]
- base += equips.compact.inject(0) {|r, i| r += (i.atk_ele[element_id])}
- base += states.compact.inject(0) {|r, i| r += i.atk_ele[element_id] }
- if $D13x[:Skill_Lv]
- base += skills.compact.inject(0) {|r, i| r += (i.atk_ele[element_id]*
- Skill_Levels::Exp_Set[i.exp_set][@skills_lv[i.id]][2] ).to_f}
- else
- base += skills.compact.inject(0) {|r, i| r += i.atk_ele[element_id] }
- end
- base
- end
- end # << Game_Actor
- #===============================================================================
- class Game_Enemy < Game_Battler
- #===============================================================================
- #--------------------------------------------------------------------------
- # Defence Element Max
- #--------------------------------------------------------------------------
- def def_ele_max(element_id)
- base = super
- base += enemy.max_def_ele[element_id]
- base += states.compact.inject(0) {|r, i| r += i.max_def_ele[element_id] }
- base
- end
- #--------------------------------------------------------------------------
- # Defence Element Plus
- #--------------------------------------------------------------------------
- def def_ele_plus(element_id)
- base = super
- base += enemy.def_ele[element_id]
- base += states.compact.inject(0) {|r, i| r += i.def_ele[element_id] }
- base
- end
- #--------------------------------------------------------------------------
- # Attack Element Max
- #--------------------------------------------------------------------------
- def atk_ele_max(element_id)
- base = super
- base += enemy.max_atk_ele[element_id]
- base += states.compact.inject(0) {|r, i| r += i.max_atk_ele[element_id] }
- base
- end
- #--------------------------------------------------------------------------
- # Attack Element Plus
- #--------------------------------------------------------------------------
- def atk_ele_plus(element_id)
- base = super
- base += enemy.atk_ele[element_id]
- base += states.compact.inject(0) {|r, i| r += i.atk_ele[element_id] }
- base
- end
- end # << Game_Enemy
- #==============================================================================#
- # http://dekitarpg.wordpress.com/ #
- #==============================================================================#
- end
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement