PROBLEM WITH TRICKSTER'S BAG OF SKILL EFFECTS SCRIPT (PROBLEM WITH DEFENDER)

#--------------------------------------------------------------------------
# * Begin SDK Log
#--------------------------------------------------------------------------
SDK.log("Trickster\'s Bag of Skill Effects", "Trickster", 4.0, "11.11.06")

#--------------------------------------------------------------------------
# * Begin SDK Enable Test
#--------------------------------------------------------------------------
if SDK.state("Trickster\'s Bag of Skill Effects") == true
class Scene_Battle
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :status_window
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
alias skill_effects_main main
def main
$game_party.actors.each {|actor| actor.times_used = Hash.new(0)}
skill_effects_main
end
#--------------------------------------------------------------------------
# * Make Basic Action Results - Nothing
#--------------------------------------------------------------------------
alias skill_make_basic_action_result_nothing make_basic_action_result_nothing
def make_basic_action_result_nothing
skill_make_basic_action_result_nothing
if @active_battler.special_flags.has_key?('countdown')
@help_window.set_text(Skill_Customizations::Charging, 1)
@phase4_step = 2
elsif @active_battler.special_flags.has_key?('recharge')
@help_window.set_text(Skill_Customizations::Recharging, 1)
@phase4_step = 2
end
end
#--------------------------------------------------------------------------
# * Make Skill Action Result (Random Skill Effects)
#--------------------------------------------------------------------------
alias random_make_skill_action_result make_skill_action_result
def make_skill_action_result
skill_id = @active_battler.current_action.skill_id
if $data_skills.effect_set.include?(Skill_Effect_Constants::Random_Range)
range = $data_skills.extra.to_a
range.collect! {|obj| obj.to_a}
range.flatten!
skill = range
@active_battler.current_action.skill_id = skill
@active_battler.current_action.special_skill = true
elsif $data_skills.effect_set.include?(Skill_Effect_Constants::Random_Elem)
element = $data_skills.extra
range =
$data_skills.each do |skill|
next if skill == nil
range << skill.id if skill.element_set.include?(element)
end
skill = range
@active_battler.current_action.skill_id = skill
@active_battler.current_action.special_skill = true
end
random_make_skill_action_result
end
end

class Game_Actor
#--------------------------------------------------------------------------
# * Skill Can Use? (Special Skill Effects)
#--------------------------------------------------------------------------
alias special_skill_can_use? skill_can_use?
def skill_can_use?(skill_id)
if self.current_action.special_skill
return super
else
return special_skill_can_use?(skill_id)
end
end
end

class Game_BattleAction
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :special_skill
#--------------------------------------------------------------------------
# * Clear
#--------------------------------------------------------------------------
alias special_clear clear
def clear
special_clear
@special_skill = false
end
end

class Game_Party
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :items
#--------------------------------------------------------------------------
# * Smooth Target Actor (Unaliased)
#--------------------------------------------------------------------------
def smooth_target_actor(actor_index)
for actor in @actors
if actor.special_flags.has_key?('defender')
index = @actors.index(actor)
return @actors
end
end
actor = @actors
if actor != nil and actor.exist?
return actor if not actor.special_flags.has_key?('hidden')
end
# Loop
for actor in @actors
# If an actor exists
if actor.exist?
return actor if not actor.special_flags.has_key?('hidden')
end
end
return random_target_actor
end
end

class Game_Battler
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :times_used
attr_accessor :special_flags #21-22 special flags
attr_accessor :turns
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
alias skill_effects_init initialize
def initialize
skill_effects_init
@times_used = {}
@special_flags = {}
@skills_used = 0
@turns = 0
end
#--------------------------------------------------------------------------
# * Remove States Battle
#--------------------------------------------------------------------------
alias skill_effects_rsb remove_states_battle
def remove_states_battle
skill_effects_rsb
# Reset Battle Flags and Turns
@special_flags = {}
@skills_used = 0
@turns = 0
end
#--------------------------------------------------------------------------
# * Decide if Command is Inputable
#--------------------------------------------------------------------------
alias recharge_countdown_inputable? inputable?
def inputable?
flag = recharge_countdown_inputable?
flag &= !@special_flags.keys.includes_any?('countdown','recharge')
return flag
end
#--------------------------------------------------------------------------
# * Decide if Action is Possible
#--------------------------------------------------------------------------
alias recharge_countdown_movable? movable?
def movable?
flag = recharge_countdown_movable?
flag &= !@special_flags.keys.includes_any?('countdown','recharge')
return flag
end
#--------------------------------------------------------------------------
# * Make Action Speed
#--------------------------------------------------------------------------
alias skill_make_action_speed make_action_speed
def make_action_speed
skill_make_action_speed
if @current_action.is_a_skill?
if $data_skills.effect_set.include?(First_Act)
@current_action.speed = 1258 #Highest possible speed
elsif $data_skills.effect_set.include?(Last_Act)
@current_action.speed = 10 #Lowest possible speed
elsif $data_skills.effect_set.include?(Rand_Act)
@current_action.speed = rand(1258) #random speed
end
end
end
#--------------------------------------------------------------------------
# * Remove States Auto
#--------------------------------------------------------------------------
alias skill_effects_rsa remove_states_auto
def remove_states_auto
skill_effects_rsa
@special_flags.each_key do |flag|
@special_flags -= 1
if @special_flags <= 0
@special_flags.delete(flag)
if flag == 'shadow_heal'
damage = Integer(self.maxhp * @shadow_removal.to_i / 100.0)
self.hp -= damage
self.damage = damage == 0 ? nil : damage
self.damage_pop = damage == 0 ? false : true
elsif flag == 'countdown'
if @final_skill != nil
@current_action.kind = 1
@current_action.skill_id = @final_skill
@current_action.special_skill = true
@final_skill = nil
end
end
end
end
@turns += 1
end
end

module RPG
class Skill
#--------------------------------------------------------------------------
# * Power - Alias Prevents Stack Errors
#--------------------------------------------------------------------------
if @stack.nil?
alias skill_effect_power power
@stack = true
end
#--------------------------------------------------------------------------
# * Power
#--------------------------------------------------------------------------
def power
n = skill_effect_power
if self.effect_set.include?(Magnitude)
num = rand(20) + 1
power = Skill_Customizations::Magnitudes * n
n = power.to_i
end
return n
end
#--------------------------------------------------------------------------
# * Element Set
#--------------------------------------------------------------------------
def element_set
elements = @element_set.dup
Skill_Effect_Constants.constants.each do |constant|
elements.delete(eval("Skill_Effect_Constants::#{constant}"))
end
return elements
end
#--------------------------------------------------------------------------
# * Effect Set
#--------------------------------------------------------------------------
def effect_set(flag = true)
if flag
return @element_set - self.element_set
else
return @element_set
end
end
end
end
#--------------------------------------------------------------------------
# * End SDK Enable Test
#--------------------------------------------------------------------------
end

#--------------------------------------------------------------------------
# * Begin SDK Enable Test
#--------------------------------------------------------------------------
if SDK.state("Trickster\'s Bag of Skill Effects") == true
module Skill_Effect_Constants
#set these to the element ids set one to 0 to disable it
Desparation = 0
Chance = 0
Gravity = 0
Gravity_Max = 0
Pain_Split = 0
Swap = 0
Inventory = 0
Skills = 0
Gold = 0
Times = 0
Same_Elem = 0
Same_Skill = 0
Weapon = 0
#CLONE = 33 #Disabled Effect
Revive = 0
Defender = 29
Hidden = 0
Turns = 0
Save = 0
Swap2 = 0
Inversion = 0
Rand_Item = 0
Rand_Sts = 0
Present = 0
Enemy_Num = 0
Last_Stand = 0
#GUST_OF_WIND = 46 #Disabled!
#SUMMON = 47 #Disabled!
#SUMMON_DEF = 48 #Disabled!
Yoshi_Cookie = 0
Status2 = 30
Status3 = 0
Roulette = 0
First_Act = 0
Last_Act = 0
Rand_Act = 0
Absorb = 0
Osmosis = 0
Magnitude = 0
Random_Range = 0
Random_Elem = 0
#Random_Item = 61 Disabled!

Countdown = 0
Recharge = 0
Shadow_Heal = 0
Skills_Used = 0
end

module Skill_Customizations
#--------------------------------------------------------------------------
# * Yoshi Cookie Effect syntax enemy_id => item_id
#--------------------------------------------------------------------------
Yoshi_Cookie = {
1 => 4, 2 => 4}
#--------------------------------------------------------------------------
# * Power Magnitudes syntax 0-20 => power multiple
#--------------------------------------------------------------------------
Magnitudes = {
1 => 0.2, 2 => 0.3, 3 => 0.3, 4 => 0.5, 5 => 0.5, 6 => 0.5, 7 => 0.5,
8 => 0.8, 9 => 0.8, 10 => 0.8, 11 => 0.8, 12 => 0.8, 13 => 0.8, 14 => 1,
15 => 1, 16 => 1, 17 => 1, 18 => 2.5, 19 => 2.5, 20 => 5}
#--------------------------------------------------------------------------
# * Charging Help Text
#--------------------------------------------------------------------------
Charging = 'Charging...'
#--------------------------------------------------------------------------
# * Recharging Help Text
#--------------------------------------------------------------------------
Recharging = 'Recharging...'
end

class Game_Battler
include Skill_Effect_Constants
end
#--------------------------------------------------------------------------
# * End SDK Enable Test
#--------------------------------------------------------------------------
end

#--------------------------------------------------------------------------
# * Begin SDK Enable Test
#--------------------------------------------------------------------------
if SDK.state("Trickster\'s Bag of Skill Effects") == true
class Game_Battler
#--------------------------------------------------------------------------
# * Skill Effect
#--------------------------------------------------------------------------
def skill_extra_effect(user, skill)
@damage_hp = skill.power == 0 ? 0 : self.damage
@damage_hp = skill.power < 0 ? -@damage_hp : @damage_hp
@hp_damaging = false
elements = skill.effect_set
gold = user.is_a?(Game_Enemy) ? user.gold : $game_party.gold
multiplier = 0
@skills_used += 1

#Desparation see extra parameters
if elements.include?(Desparation)
damage = skill.extra * user.maxhp / user.hp
damage *= self.element_rate(Desparation) / 100.0
@damage_hp += damage.to_i
end

#Chance Damage see Skill extra parameters
if elements.include?(Chance)
max = skill.extra
min = skill.extra
multiplier = skill.extra
damage = multiplier * (rand(max - min + 1) + min)
damage *= self.element_rate(Chance) / 100.0
@damage_hp += damage.to_i
end

#Hp damaging skill power is the % damage done
if elements.include?(Gravity)
damage = self.hp * (skill.power) / 100
damage *= self.element_rate(Gravity) / 100.0
@damage_hp += damage.to_i
end

#Hp damaging skill using max hp power is % damage
if elements.include?(Gravity_Max)
damage = self.maxhp * (skill.power) / 100
damage *= self.element_rate(Gravity_Max) / 100.0
@damage_hp += damage.to_i
end

#Pain Split
if elements.include?(Pain_Split)
if self.element_rate(Pain_Split) != 0
savehp = self.hp + user.hp
savesp = self.sp + user.sp
savehp /= 2
savesp /= 2
user.hp = savehp
user.sp = savesp
self.hp = savehp
self.sp = savesp
self.damage = "Split"
user.damage = "Split"
else
self.damage = "Miss"
end
end

#Swap
if elements.include?(Swap)
if self.element_rate(Swap) != 0
savehp = self.hp
savesp = self.sp
self.hp = user.hp
self.sp = user.sp
user.hp = savehp
user.sp = savesp
self.damage = "Swapped"
user.damage = "Swapped"
else
self.damage = "Miss"
end
end

#Inventory damage see extra
if elements.include?(Inventory)
damage = $game_party.items.size * skill.extra
damage *= self.element_rate(Inventory) / 100.0
@damage_hp += damage.to_i
end

#num skills damage see extra
if elements.include?(Skills)
damage = user.skills.size * skill.extra
damage *= self.element_rate(Skills) / 100.0
@damage_hp += damage.to_i
end

#gold carrying see extra
if elements.include?(Gold)
x = skill.extra
mul1 = skill.extra+1
mul2 = skill.extra
damage = (gold/(99 * mul1)) * mul2 + rand(3*x+1) + rand(2*x+1) - x
damage = damage.to_i
damage = rand(x) if damage <= 0
damage *= self.element_rate(Gold) / 100.0
@damage_hp += damage.to_i
end

#times the skill has been used in battle
if elements.include?(Times)
time = user.times_used
damage = 1.3 ** time * self.element_rate(Times) / 100.0
damage = 1 if damage == 0
@damage_hp *= damage
@damage_hp = @damage_hp.to_i
user.times_used = Hash.new(0)
user.times_used += time + 1
else
user.times_used = Hash.new(0)
end

#same element increase see extra
if elements.include?(Same_Elem)
multiplier = 0
user.skills.each do |i|
if $data_skills.effect_set(false).include?(skill.extra)
multiplier += 1
end
#give a bonus if all skills have the element
if multiplier == user.skills.size
multiplier *= 1.5
end
end
damage *= (1.3 ** multiplier) * self.element_rate(Same_Elem) / 100.0
damage = 1 if damage == 0
@damage_hp *= damage
@damage_hp = @damage_hp.to_i
end

#known skill increase see extra
if elements.include?(Same_Skill)
multiplier = 0
if user.is_a?(Game_Actor)
$game_party.actors.each do |actor|
if actor.skills.include?(skill.extra)
multiplier += 1
end
if multiplier == $game_party.actors.size
multiplier += 1
end
end
elsif user.is_a?(Game_Enemy)
$game_troop.enemies.each do |enemy|
if enemy.skills.include?(skill.extra)
multiplier += 1
end
if multiplier == $game_troop.enemies.size
multiplier += 1
end
end
end
damage = (1.3 ** multiplier) * self.element_rate(Same_Skill) / 100.0
damage = 1 if damage == 0
@damage_hp *= damage
@damage_hp = @damage_hp.to_i
end

#weapon increase
if elements.include?(Weapon)
if user.is_a?(Game_Actor)
weapon = $data_weapons
damage = weapon.nil? ? 0 : weapon.atk / 2
elsif user.is_a?(Game_Enemy)
damage += user.atk / 2
end
damage *= self.element_rate(Weapon) / 100.0
@damage_hp += damage.to_i
end

#+ revive see extra (buggy?)
if elements.include?(Revive)
$game_party.actors.each do |actor|
if actor.hp0?
states =
(1...$data_states.size).each do |state_id|
states << state_id if $data_states.zero_hp
end
actor.states_minus(states)
actor.hp = skill.extra * actor.maxhp / 100
end
end
end

#Defender see extra
if elements.include?(Defender)
self.special_flags = skill.extra
end

#Hidden see extra
if elements.include?(Hidden)
self.special_flags = skill.extra
end

#turn damage
if elements.include?(Turns)
turns = $game_temp.battle_turn
damage = turns * 1.1 ** turns * self.element_rate(Turns) / 100.0
damage = 1 if damage == 0
@damage_hp *= damage.to_i
end

#save damage
if elements.include?(Save)
damage = 100 ** (1.0/($game_system.save_count+1))
damage *= self.element_rate(Save) / 100.0
damage = 1 if damage == 0
@damage_hp *= damage
@damage_hp = @damage_hp.to_i
end

#skills used damage
if elements.include?(Skills_Used)
damage = 1.1 ** @skills_used * self.element_rate(Skills_Used) / 100.0
damage = 1 if damage == 0
@damage_hp *= damage.to_i
end

#Swap 2
if elements.include?(Swap2)
if self.element_rate(Swap2) != 0
save_hp = self.hp
save_sp = self.sp
self.hp = save_sp
self.sp = save_hp
self.damage = "Swap"
else
self.damage = "Miss"
end
end

#give random item see extra
if elements.include?(Rand_Item)
extra = skill.extra
random = rand(extra - extra + 1) + extra
$game_party.gain_item(random, 1)
self.damage = $data_items.name
end

#random status see extra
if elements.include?(Rand_Sts)
extra = skill.extra
state = rand(extra - extra + 1) + extra
self.add_state(state)
self.damage = $data_states.name
end

#pkmn present see extra
if elements.include?(Present)
if rand(100) > skill.extra
@damage_hp *= -1
end
end

#Enemy # damage
if elements.include?(Enemy_Num)
if user.is_a?(Game_Actor)
num = 0
$game_troop.enemies.each {|enemy| num += 1 if enemy.exist?}
elsif user.is_a?(Game_Enemy)
num = 0
$game_party.actors.each {|actor| num += 1 if !actor.dead?}
end
@damage_hp += num
damage = Integer(1.3 ** num) * (self.element_rate(Enemy_Num) / 100.0)
damage = 1 if damage == 0
@damage_hp *= damage
@damage_hp = @damage_hp.to_i
end

#last one standing
if elements.include?(Last_Stand)
if user.is_a?(Game_Actor)
num = $game_party.actors.size
hptotal = 0
$game_party.actors.each do |actor|
num -= 1 if actor.dead?
hptotal += actor.maxhp
end
elsif user.is_a?(Game_Enemy)
num = $game_troop.enemies.size
hptotal = 0
$game_troop.enemies.each do |enemy|
num -= 1 if enemy.dead?
hptotal += enemy.maxhp
end
end
rate = skill.extra.to_f
damage = hptotal / (rate * num) * self.element_rate(Last_Stand) / 100
@damage_hp += damage.to_i
end

#Status effect damage 3
if elements.include?(Status3)
num = user.states.size
@damage_hp += num
damage = Integer(1.1625 ** num) * self.element_rate(Status3) / 100.0
damage = 1 if damage == 0
@damage_hp *= damage
end

#Roulette
if elements.include?(Roulette)
array =
$game_party.actors.each {|actor| array << actor}
$game_troop.enemies.each {|enemy| array << enemy}
random = rand(array.size) + 1
damage = array.maxhp - array.hp
damage *= self.element_rate(Roulette) / 100.0
@damage_hp += damage.to_i
end

#Yoshi cookie see method get_item
if elements.include?(Yoshi_Cookie)
item = Skill_Customizations::Yoshi_Cookie
if item != nil
@damage_hp = self.hp
$game_party.gain_item(item,1)
else
@damage_hp = 0
end
end

#inversion
if elements.include?(Inversion)
if @damage_hp != (skill.power == 0 ? 0 : self.damage)
n = @damage_hp
else
n = self.damage
end
n = 0.5 if n == 0
n = 100.0 / n
damage = Integer(n + rand(n))
damage *= self.element_rate(Inversion) / 100.0
@damage_hp = damage.to_i
end

#Status effect damage 2 see extra
if elements.include?(Status2)
if self.states.include?(skill.extra)
damage = rand(@damage_hp / 2 + 1) * self.element_rate(Status2) / 100.0
@damage_hp += damage.to_i
else
@damage_hp = 0
self.damage = 0
end
end

#Osmosis
if elements.include?(Osmosis)
self.damage = @damage_hp
last_hp = self.hp
if skill.extra == 0 and self.damage.abs > 0
random = rand(self.damage) + 1
user.sp += random
user.damage = -random
else
user.sp += self.damage * skill.extra / 100
user.damage = -self.damage * skill.extra / 100
end
@damage_hp = 0
end

#Countdown
if elements.include?(Countdown)
extra = skill.extra
@special_flags = extra
@final_skill = extra
self.damage = ''
end

#Recharge
if elements.include?(Recharge)
user.special_flags = skill.extra
end

#Shadow Heal
if elements.include?(Shadow_Heal)
extra = skill.extra
damage = (self.maxhp * extra.to_i / 100.0).to_i
self.hp += damage
self.damage = -damage
@special_flags = extra
@shadow_removal = extra
end

#damage routine
if @damage_hp.is_a?(Numeric)
@damage_hp = (skill.power < 0 && @damage_hp > 0) ? -@damage_hp : @damage_hp
end
if @damage_hp != 0 and @damage_hp != nil
self.damage = @damage_hp
last_hp = self.hp
self.hp -= @damage_hp if @damage_hp.is_a?(Numeric)
else
last_hp = self.hp
self.hp -= self.damage if self.damage.is_a?(Numeric)
end
if @damage_hp != 0 and @damage_hp != nil or self.damage != "Miss"
@hp_damaging = true
end
#absorb see Extra parameters
if elements.include?(Absorb)
if skill.extra == 0 and self.damage.abs > 0
random = rand(self.damage) + 1
user.hp += random
user.damage = -random
else
user.hp += self.damage * skill.extra / 100
user.damage = -self.damage * skill.extra / 100
end
end
return last_hp
end
end
#--------------------------------------------------------------------------
# * End SDK Enable Test
#--------------------------------------------------------------------------
end