Skills : Drain/Osmosis - Printable Version+- Save-Point (https://www.save-point.org)
+-- Forum: Material Development (https://www.save-point.org/forum-8.html)
+--- Forum: Scripts Database (https://www.save-point.org/forum-39.html)
+---- Forum: RPGMaker XP (RGSS) Engine (https://www.save-point.org/forum-116.html)
+---- Thread:
Skills : Drain/Osmosis (/thread-2307.html)Skills : Drain/Osmosis - Kain Nobel - 04-19-2009
Kain Nobel
Version: 1.0
Version: 1.0
Introduction
This script is deticated to handling skills that absorb HP and SP. With this, you can set the custom font and display strings of HP/SP absorb damage and specify each skills direct, percent and allowed variance to absorb.
Features
- Set Skills that can drain HP/SP
- You can set the direct HP/SP drawn from each skill's damage
- You can set the percent HP/SP drawn from each skill's damage
- You can set a variance on HP/SP drawn from each skill's damage
- Set the font/color and string display of absored HP/SP
- Set the returning animation of absorbtion
- Automatically applies Drain HP element tag to skills that drain HP.
- Automatically applies Drain SP element tag to skills that drain SP.
- Settings are all commented and easy for non-scripters to understand.
Code:
#===============================================================================
# ** Skills : Drain/Osmosis
#===============================================================================
#-------------------------------------------------------------------------------
# * SDK Log
#-------------------------------------------------------------------------------
SDK.log('Skills.Drain/Osmosis', 'Kain Nobel ©', 2.0, '04.01.2009')
SDK.check_requirements(2.4, [1, 2])
#-------------------------------------------------------------------------------
# * SDK Enabled Test : Begin
#-------------------------------------------------------------------------------
if SDK.enabled?('Skills.Drain/Osmosis')
#===============================================================================
# ** RPG::Skill
#===============================================================================
class RPG::Skill
#=============================================================================
# ** RPG::Skill::Drain
#=============================================================================
module Drain
#---------------------------------------------------------------------------
# * HP Drain Element Tag ID (set inside Database/System tab).
#---------------------------------------------------------------------------
HP_Element_Tag = nil
#---------------------------------------------------------------------------
# * SP Drain Element Tag ID (set inside Database/System tab).
#---------------------------------------------------------------------------
SP_Element_Tag = nil
#---------------------------------------------------------------------------
# * Font Name for Drain Damage String.
#---------------------------------------------------------------------------
DamageFontName = "Arial Black"
#---------------------------------------------------------------------------
# * Font Size for Drain Damage String.
#---------------------------------------------------------------------------
DamageFontSize = 28
#---------------------------------------------------------------------------
# * Damage font for drain damage is bolded?
#---------------------------------------------------------------------------
DamageFontBold = false
#---------------------------------------------------------------------------
# * Damage font for drain damage is italicized?
#---------------------------------------------------------------------------
DamageFontItal = false
#---------------------------------------------------------------------------
# * Color for text outline displaying HP drain value.
#---------------------------------------------------------------------------
HP_ColorBack = Color.new(0, 160, 0)
#---------------------------------------------------------------------------
# * Color for main text color displaying HP drain value.
#---------------------------------------------------------------------------
HP_ColorMain = Color.new(0, 255, 0)
#---------------------------------------------------------------------------
# * Color for text outline displaying SP drain value.
#---------------------------------------------------------------------------
SP_ColorBack = Color.new(160, 0, 160)
#---------------------------------------------------------------------------
# * Color for main text color displaying SP drain value.
#---------------------------------------------------------------------------
SP_ColorMain = Color.new(255, 0, 255)
#---------------------------------------------------------------------------
# * Reformat the Damage String for draining HP (ie "HP +[x]") [x] = value
#---------------------------------------------------------------------------
HP_DamageFormat = "HP +[x]"
#---------------------------------------------------------------------------
# * Reformat the Damage String for draining SP (ie "HP +[x]") [x] = value
#---------------------------------------------------------------------------
SP_DamageFormat = "SP +[x]"
#---------------------------------------------------------------------------
# * Animation played to the reciever of drained HP/SP. (skill_id => n)
#---------------------------------------------------------------------------
Animation = {7 => 15}
#---------------------------------------------------------------------------
# * The percent to drain from damage inflicted on HP. (skill_id => n)
#---------------------------------------------------------------------------
HP_Percent = {1 => 100, 6 => 100, 7 => 100, 9 => 100}
#---------------------------------------------------------------------------
# * A direct value to drain from damage inflicted on HP. (skill_id => n)
#---------------------------------------------------------------------------
HP_Direct = {}
#---------------------------------------------------------------------------
# * Allowed variance to +/- from sub total HP drained. (skill_id => n)
#---------------------------------------------------------------------------
HP_Variance = {}
#---------------------------------------------------------------------------
# * The percent to drain from damage inflicted on SP. (skill_id => n)
#---------------------------------------------------------------------------
SP_Percent = {}
#---------------------------------------------------------------------------
# * A direct value to drain from damage inflicted on SP. (skill_id => n)
#---------------------------------------------------------------------------
SP_Direct = {}
#---------------------------------------------------------------------------
# * Allowed variance to +/- from sub total SP drained. (skill_id => n)
#---------------------------------------------------------------------------
SP_Variance = {}
#---------------------------------------------------------------------------
# * Critical Flag to be set when draining (this is an scripter thing...)
#---------------------------------------------------------------------------
Critical_Flag = "Drain/Osmosis"
#---------------------------------------------------------------------------
# * Default Settings (You might not want to modify these...)
#---------------------------------------------------------------------------
Animation.default = 0
HP_Percent.default = 0
HP_Direct.default = 0
HP_Variance.default = 0
SP_Percent.default = 0
SP_Direct.default = 0
SP_Variance.default = 0
end
#-----------------------------------------------------------------------------
# * Alias Listings
#-----------------------------------------------------------------------------
alias_method :drainskill_rpgskill_initialize, :initialize
#-----------------------------------------------------------------------------
# * Object Initialization
#-----------------------------------------------------------------------------
def initialize
drainskill_rpgskill_initialize
if self.drain_hp? && !@element_set.include?(Drain::HP_Element_Tag)
unless Drain::HP_Element_Tag.nil?
@element_set << Drain::HP_Element_Tag
end
end
if self.drain_sp? && !@element_set.include?(Drain::SP_Element_Tag)
unless Drain::SP_Element_Tag.nil?
@element_set << Drain::SP_Element_Tag
end
end
end
#-----------------------------------------------------------------------------
# * Drain Animation
#-----------------------------------------------------------------------------
def drain_animation
return Drain::Animation[@id]
end
#-----------------------------------------------------------------------------
# * HP Drain Percent
#-----------------------------------------------------------------------------
def hp_drain_percent
return Drain::HP_Percent[@id]
end
#-----------------------------------------------------------------------------
# * HP Drain Direct
#-----------------------------------------------------------------------------
def hp_drain_direct
return Drain::HP_Direct[@id]
end
#-----------------------------------------------------------------------------
# * HP Drain Variance
#-----------------------------------------------------------------------------
def hp_drain_variance
return Drain::HP_Variance[@id]
end
#-----------------------------------------------------------------------------
# * SP Drain Percent
#-----------------------------------------------------------------------------
def sp_drain_percent
return Drain::SP_Percent[@id]
end
#-----------------------------------------------------------------------------
# * SP Drain Direct
#-----------------------------------------------------------------------------
def sp_drain_direct
return Drain::SP_Direct[@id]
end
#-----------------------------------------------------------------------------
# * SP Drain Variance
#-----------------------------------------------------------------------------
def sp_drain_variance
return Drain::SP_Variance[@id]
end
#-----------------------------------------------------------------------------
# * HP Drain
#-----------------------------------------------------------------------------
def hp_drain(value)
unless hp_drain_percent.zero?
value *= hp_drain_percent / 100.0
end
value += hp_drain_direct
value += rand(2).zero? ? -hp_drain_variance : hp_drain_variance
return Integer(value)
end
#-----------------------------------------------------------------------------
# * SP Drain
#-----------------------------------------------------------------------------
def sp_drain(value)
unless sp_drain_percent.zero?
value *= sp_drain_percent / 100.0
end
value += sp_drain_direct
value += rand(2).zero? ? -sp_drain_variance : sp_drain_variance
return Integer(value)
end
#-----------------------------------------------------------------------------
# * Drain?
#-----------------------------------------------------------------------------
def drain?
return (hp_drain? || sp_drain?)
end
#-----------------------------------------------------------------------------
# * HP Drain?
#-----------------------------------------------------------------------------
def hp_drain?
return (!hp_drain_percent.zero? || !hp_drain_direct.zero?)
end
#-----------------------------------------------------------------------------
# * SP Drain?
#-----------------------------------------------------------------------------
def sp_drain?
return (!sp_drain_percent.zero? || !sp_drain_direct.zero?)
end
end
#===============================================================================
# ** Game_BattleAction
#===============================================================================
class Game_BattleAction
#-----------------------------------------------------------------------------
# * Public Instance Variables
#-----------------------------------------------------------------------------
attr_accessor :drain_hp
attr_accessor :drain_sp
#-----------------------------------------------------------------------------
# * Alias Listings
#-----------------------------------------------------------------------------
alias_method :drainskill_gmbtlact_clear, :clear
#-----------------------------------------------------------------------------
# * Clear
#-----------------------------------------------------------------------------
def clear
drainskill_gmbtlact_clear
@drain_hp = 0
@drain_sp = 0
end
end
#===============================================================================
# ** Game_Battler
#===============================================================================
class Game_Battler
#-----------------------------------------------------------------------------
# * Public Instance Variables
#-----------------------------------------------------------------------------
attr_accessor :drain_animation
#-----------------------------------------------------------------------------
# * Alias Listings
#-----------------------------------------------------------------------------
alias_method :drainskill_gmbtlr_skilleffect, :skill_effect
#-----------------------------------------------------------------------------
# * Skill Effect
#-----------------------------------------------------------------------------
def skill_effect(user, skill)
unless skill.drain?
return drainskill_gmbtlr_skilleffect(user, skill)
end
old_hp, old_sp = self.hp, self.sp
effective = drainskill_gmbtlr_skilleffect(user, skill)
last_damage = self.damage
self.damage = 0
hit, hit_result = skill_effect_first_hit_result(user, skill)
effective = skill_effect_effective_correction(effective, hit)
if hit_result
power = skill_effect_power(user, skill)
rate = skill_effect_rate(user, skill)
skill_effect_base_damage(power, rate)
skill_effect_element_correction(skill)
if self.damage > 0
skill_effect_guard_correction
end
skill_effect_disperation(skill)
hit, hit_result = skill_effect_second_hit_result(user, skill)
effective = skill_effect_effective_correction(effective, hit)
end
if hit_result
effective = true if skill_effect_physical_hit_result(skill)
last_sp = self.sp
self.sp -= self.damage
effective = self.sp != last_sp
@state_changed = false
effective |= states_plus(skill.plus_state_set)
effective |= states_minus(skill.minus_state_set)
skill_effect_power0(skill)
else
skill_effect_miss
end
skill_effect_damagefix
hp_drain = skill.hp_drain(old_hp - self.hp)
sp_drain = skill.sp_drain(old_sp - self.sp)
user.hp += [hp_drain, 0].max
user.sp += [sp_drain, 0].max
self.damage = last_damage
user.critical = RPG::Skill::Drain::Critical_Flag
user.current_action.drain_hp ||= 0
user.current_action.drain_sp ||= 0
user.current_action.drain_hp += hp_drain
user.current_action.drain_sp += sp_drain
user.damage = Array.new
user.damage << [user.current_action.drain_hp, 0].max
user.damage << [user.current_action.drain_sp, 0].max
unless skill.drain_animation.zero? || skill.drain_animation.nil?
user.drain_animation = skill.drain_animation
end
return effective
end
end
#===============================================================================
# ** Scene_Battle
#===============================================================================
class Scene_Battle < SDK::Scene_Base
#-----------------------------------------------------------------------------
# * Alias Listings
#-----------------------------------------------------------------------------
alias_method :drainskill_scnbtl_updatep4s6, :update_phase4_step6
#-----------------------------------------------------------------------------
# * Update Phase 4 : Step 6
#-----------------------------------------------------------------------------
def update_phase4_step6
draining_battlers.each do |battler|
battler.damage_pop = true
unless battler.drain_animation == 0 || battler.drain_animation.nil?
battler.animation_id = battler.drain_animation
battler.animation_hit = true
battler.drain_animation = nil
end
end
drainskill_scnbtl_updatep4s6
end
#-----------------------------------------------------------------------------
# * Draining Battlers
#-----------------------------------------------------------------------------
def draining_battlers
battlers = Array.new
$game_party.actors.each do |actor|
if actor.current_action.drain_hp || actor.current_action.drain_sp
battlers << actor
end
end
$game_troop.enemies.each do |enemy|
if enemy.current_action.drain_hp || enemy.current_action.drain_sp
battlers << enemy
end
end
battlers.each {|battler|
battler.current_action.drain_hp = nil
battler.current_action.drain_sp = nil
}
return battlers
end
end
#===============================================================================
# ** RPG::Sprite
#===============================================================================
class RPG::Sprite < ::Sprite
#-----------------------------------------------------------------------------
# * Alias Listings
#-----------------------------------------------------------------------------
alias_method :drainskill_RPGsprite_damage, :damage
#-----------------------------------------------------------------------------
# * Damage
#-----------------------------------------------------------------------------
def damage(value, critical)
unless value.is_a?(Array) && critical == RPG::Skill::Drain::Critical_Flag
drainskill_RPGsprite_damage(value, critical)
return
end
dispose_damage
hp_drain = RPG::Skill::Drain::HP_DamageFormat.dup
hp_drain.gsub!("[x]", "#{value[0]}")
hp_drain.gsub!("+", "-") if value[0] < 0
sp_drain = RPG::Skill::Drain::SP_DamageFormat.dup
sp_drain.gsub!("[x]", "#{value[1]}")
sp_drain.gsub!("+", "-") if value[1] < 0
bitmap = Bitmap.new(160, 8 + (RPG::Skill::Drain::DamageFontSize * 2))
bitmap.font.name = RPG::Skill::Drain::DamageFontName
bitmap.font.size = RPG::Skill::Drain::DamageFontSize
bitmap.font.bold = RPG::Skill::Drain::DamageFontBold
bitmap.font.italic = RPG::Skill::Drain::DamageFontItal
bitmap.font.color = RPG::Skill::Drain::HP_ColorBack
bitmap.draw_text(-1, 12-1, 160, 40, hp_drain, 1)
bitmap.draw_text(+1, 12-1, 160, 40, hp_drain, 1)
bitmap.draw_text(-1, 12+1, 160, 40, hp_drain, 1)
bitmap.draw_text(+1, 12+1, 160, 40, hp_drain, 1)
bitmap.font.color = RPG::Skill::Drain::HP_ColorMain
bitmap.draw_text(0, 12, 160, 40, hp_drain, 1)
bitmap.font.color = RPG::Skill::Drain::SP_ColorBack
y = bitmap.font.size + 2
bitmap.draw_text(-1, y-1, 160, 40, sp_drain, 1)
bitmap.draw_text(+1, y-1, 160, 40, sp_drain, 1)
bitmap.draw_text(-1, y+1, 160, 40, sp_drain, 1)
bitmap.draw_text(+1, y+1, 160, 40, sp_drain, 1)
bitmap.font.color = RPG::Skill::Drain::SP_ColorMain
bitmap.draw_text(0, y, 160, 40, sp_drain, 1)
@_damage_sprite = ::Sprite.new(self.viewport)
@_damage_sprite.bitmap = bitmap
@_damage_sprite.ox = 80
@_damage_sprite.oy = 20
@_damage_sprite.x = self.x
@_damage_sprite.y = self.y - self.oy / 2
@_damage_sprite.z = 3000
@_damage_duration = 40
end
end
#-------------------------------------------------------------------------------
# * SDK Enabled Test : End
#-------------------------------------------------------------------------------
endInstructions
Place below SDK, above main. Please read the instructions on the settings in the script, they are all commented and easy to understand. If you have any further questions please don't be shy to ask.
FAQ
I'll add later if need be...
Compatibility
Requires SDK 2.4 individual part labled "GAME_BATTLER#SKILL_EFFECT"
Scripts that remodel the damage display, it might not work on the return effect of HP/SP. If so, please contact me and I'll tinker with a patch if I have time.
Author's Notes
I'm going to remodel this script to work with weapons, armors and items later on, so please await the newer version(s).
Terms and Conditions
Free to use in non-commercial games, please ask permission before using commercially. At the very least, at least credit me if you use this.
Enjoy :D
Skills : Drain/Osmosis - DerVVulfman - 04-19-2009
Draining Health and Magic... nice. :)
Never that keen on the whole SDK 'requirements' as it forces you to use the SDK, but it appears solid enough. From the looks of it, you took lessons from Trickster. ;)
Skills : Drain/Osmosis - Kain Nobel - 05-18-2009
Yes, I learned from the best, Trickster is amongst one of many I've learned ALOT from. I'll try and post a non-SDK version of this later in the week, shouldn't be too hard (basically working backwards from Game_Battler.skill_effect coding being broke up.)