Używam skryptu KGC_Overdrive i chciałbym, aby pasek limitu zwiększył się na maxa podczas jednego momentu w bitwie. Oto skrypt:
Spoiler:
Kod:
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/ ◆ OverDrive System - KGC_OverDrive ◆ VX ◆
#_/ ◇ Last Update: 2008/08/28 ◇
#_/ ◆ Original Translation by Touchfuzzy ◆
#_/ ◆ Extended Translation and Updates by Mr. Anonymous ◆
#_/ ◆ KGC Site: ◆
#_/ ◆ http://f44.aaa.livedoor.jp/~ytomy/ ◆
#_/ ◆ Translator's Blog: ◆
#_/ ◆ http://mraprojects.wordpress.com ◆
#_/-----------------------------------------------------------------------------
#_/ This script allows the designer to create skills that are not usable in
#_/ battle until a character gains enough points from specified actions to use
#_/ them. To set up a skill as an "Overdrive" skill (which doesn't appear until
#_/ the Overdrive Gauge is full), go into the database, click the Skills tab,
#_/ locate the skill you desire, and then enter <overdrive> into the "Notes"
#_/ text box. Also, you may desire some skills to increase the Overdrive Gauge
#_/ more than others.
#_/ To do so, enter <OD_gain n%> (where n = a number) into the desired skill's
#_/ "Notes" box. Example: <OD_gain 200%> would increase Overdrive Points
#_/ gained from Attack Gain Rate (80 by default) by 200 percent (x2).
#_/ The formula for this is [attackgainrate * n / 100]
#_/=============================================================================
#_/ ◆ Script Commands ◆
#_/ These commands are used in "Script" function in the third page of event
#_/ commands under "Advanced".
#_/
#_/ Increase OverDrive for an actor:
#_/ * gain_actor_od_gauge(ActorID, Increase)
#_/
#_/ Increase OverDrive for an enemy:
#_/ * gain_enemy_od_gauge(EnemyID, Increase)
#_/
#_/ Modify an actor's drive types:
#_/ * set_actor_drive_type(ActorID, [DriveTypes])
#_/
#_/ Modify an enemy's drive types:
#_/ * set_enemy_drive_type(EnemyID, [DriveTypes])
#_/
#_/ [ Quick Key: ]
#_/ [ ActorID = The ID number of the selected Actor in the database. ]
#_/ [ Setting this to -1 will effect all actors. ]
#_/ [ ]
#_/ [ EnemyID = The ID number of the selected Enemy in the current troop. 0-7 ]
#_/ [ Setting this to -1 will effect all enemies. ]
#_/ [ ]
#_/ [ Increase = The amount of OverDrive points to increase. ]
#_/ [ ]
#_/ [ DriveTypes = The drive types as seen below in the customization block ]
#_/ [ "DEFAULT_ACTOR_DRIVE_TYPE". If this is omitted, it's reset to default. ]
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
module KGC
module OverDrive
# ◆ Maximum Gauge Points ◆
# This affects the amount of OP (Overdrive Points) required to fill the
# Overdrive Gauge. Default: GAUGE_MAX = 1000
GAUGE_MAX = 1200
# ◆ Default OP Gain Rates ◆
# You may specify the amount of OverDrive Points that battlers will be given
# for specific actions performed.
GAIN_RATE = [
100, # 0 Gained per attack.
500, # 1 Gained for taking damage.
# This is per 100% MaxHP of damage taken, so with 500 you would
# have to take 2 times your MaxHP to fill a 1,000 point GAUGE_MAX.
200, # 2 Gained for defeating an enemy.
100, # 3 Gained each time you run away from a fight.
160, # 4 Gained for each round spent while fighting solo in battle, either
# being the only character or being the last one alive.
40, # 5 Gained for taking any action in a round
160, # 6 Gained for each round surviving with 25% or less HP remaining.
180, # 7 Gained for each round for guarding.
] # ← No not remove these lines. Alter to your heart's content, though.
# ◆ Amount of Gauges ◆
# This allows you to specify how many gauges the actor has. These gauges stack
# meaning when that after the first gauge is maxed, OverDrive points are
# allocated to the next gauge. This also means that after using an OverDrive
# skill, OverDrive points are given for that action if applicable.
# As a final note, these gauges are displayed as one whole gauge.
DEFAULT_GAUGE_NUMBER = 1
# ◆ Default Actor OverDrive Increase Options ◆
# Default Overdrive types that affect player-characters. The numbers in the
# brackets [] are chosen from the GAIN_RATE above, to the right of the #.
# It appears these numbers "stack" when setting up an individual character's
# Overdrive parameters.
DEFAULT_ACTOR_DRIVE_TYPE = [0, 1, 6, 7]
# ◆ Default Enemy OverDrive Increase Options ◆
# Default Overdrive types that affect enemies. The numbers in the brackets []
# are chosen from the GAIN_RATE above, to the right of the #.
DEFAULT_ENEMY_DRIVE_TYPE = [0, 1, 4, 5, 6]
# ◆ OverDrive Gauge Colors ◆
# Allows you to change the color of the overdrive gauges.
# The color can also be determined by a red, green, and blue values.
# Example: GAUGE_NORMAL_START_COLOR = Color.new(255, 0, 0) <- This is red.
# This method of color assignment is much like Tint Screen event command.
# Gauge Start Color
GAUGE_NORMAL_START_COLOR = 14
# Gauge End Color
GAUGE_NORMAL_END_COLOR = 6
# Max Gauge Start Color
GAUGE_MAX_START_COLOR = 10
# Max Gauge End Color
GAUGE_MAX_END_COLOR = 2
# ◆ Gauge Y Coordinate ◆
# This allows you to adjust the Y coordinate(depth) of the overdrive gauge.
# Setting to -8 places the OD gauge at the same depth as the HP/MP gauges.
GAUGE_OFFSET_Y = -8
# ◆ Numerical Display of OverDrive Gauge Style ◆
# This function allows you to display a numerical representation of the
# current amount of OverDrive points an actor has.
# 0: No numerical amount is displayed.
# 1: Default - Displays the current amount as a straight number.
# 2: Ratio 1 --> x%
# 3: Ratio 2 --> x.x%
# 4: Ratio 3 --> x.xx%
# 5: Maxing - Amount of times the gauge has maxed since the battle started.
GAUGE_VALUE_STYLE = 2
# ◆ Numerical Display Font Size ◆
# This allows you to change the font size of the numerical display of the
# OverDrive gauge, as defined above.
GAUGE_VALUE_FONT_SIZE = 14
# ◆ Empty OD Gauge Upon Death ◆
# This toggle affects wether the OP Gauge is reset to zero once an actor
# dies. true = Reset to 0. false = Gauge remains persistant.
EMPTY_ON_DEAD = true
# ◆ Hide Actor OD Gauge ◆
# Hide the gauge for individual characters. The number of the character in
# the Actors Database is inserted in the brackets.
# Example: HIDE_GAUGE_ACTOR = [2] would always hide the gauge for the second
# actor in the database. (Simple stuff.)
HIDE_GAUGE_ACTOR = []
# ◆ Hide OD Gauge in Menu ◆
# This toggle allows you to hide the Overdrive gauge from the command menu.
# true = Gauge is hidden.
# false = Gauge remains persistant even in menu.
HIDE_GAUGE_NOT_IN_BATTLE = false
# ◆ Hide OD Gauge When Actor Lacks OD Skills ◆
# This toggle allows you to hide the gauge if a character has no Overdrive
# skills in his/her arsenal.
# true = Gauge is hidden.
# false = Gauge is not hidden.
HIDE_GAUGE_NO_OD_SKILLS = true
# ◆ Prevent Actors Without OD Skills From Gaining OP ◆
# This toggle stops OP from being gained for characters that have no Overdrive
# skills when HIDE_GAUGE_NO_OD_SKILLS = true.
NOT_GAIN_GAUGE_HIDING = true
# ◆ Hide OD Skills When Actor Lacks Max OP ◆
# This toggle allows you to specify wether skills that do not yet meet the
# required OP are visible.
# true = Skills are hidden
# false = skills are not hidden.
HIDE_SKILL_LACK_OF_GAUGE = false
# ◆ Use Image as Gauge Toggle ◆
# If set to true, the old-style system-drawn gauges are replaced by user
# created images. Note that as of now, using this option hides the numerical
# gauge display function. This MAY be fixed by adjusting GAUGE_OFFSET_Y as
# seen above, but hasn't been tested.
USE_IMAGE_GAUGE = true
# ◆ Gauge Image Graphic ◆
# This setting allows you to define the image you want to use as the drive
# gauge bar. The image must be located in the "Graphics\System" folder.
GAUGE_IMAGE = "gauge_od2"
# ◆ Menu Gauge Image Position [x, y] ◆
# Actor names are relative to the coordinates in the menu defined below.
GAUGE_POSITION = [-32, -8]
# ◆ Menu Gauge Image Length ◆
# For a longer or shorter gauge, increase or decrease this number.
GAUGE_LENGTH = 52
# ◆ Battle Gauge Image Position [x, y] ◆
# Actor names are relative to the coordinates during battle defined below.
GAUGE_POSITION_BATTLE = [-32, -8]
# ◆ Battle Gauge Image Length ◆
# For a longer or shorter gauge, increase or decrease this number.
GAUGE_LENGTH_BATTLE = 52
# ◆ OverDrive Max Sound Play ◆
# Sound played on overdrive gauge max. (Filename, Pitch, Volume)
# Sounds are selected from the Audio\SE folder.
ODMAX_SOUND = RPG::SE.new("Limit2", 100, 150)
end
end
#=============================================================================#
# ★ End Customization ★ #
#=============================================================================#
# Numerical Display of OverDrive Gauge
module ValueStyle
NONE = 0 # None
IMMEDIATE = 1 # Immediate
RATE = 2 # Ratio 1
RATE_DETAIL1 = 3 # Ratio 2
RATE_DETAIL2 = 4 # Ratio 3
NUMBER = 5 # Gauge Number
end
#==============================================================================
# □ KGC::SkillCPSystem::Regexp
#==============================================================================
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
# Note Field Tag Strings #
# * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
# Whatever word(s) are after the separator ( | ) in the following lines are
# what are used to determine what is searched for in the "Note" section of a
# skill.
# Regular Expressions Module
module Regexp
# Skill Module
module Skill
# OverDrive tag string
OVER_DRIVE = /<(?:OVER_DRIVE|overdrive)\s*(\d+)?>/i
# OverDrive Gain Rate tag string
OD_GAIN_RATE = /<(?:OD_GAIN_RATE|OD_gain)\s*(\d+)[%％]?>/i
end
end
end
module KGC
module Commands
module_function
#--------------------------------------------------------------------------
# ○ Actor Overdrive Gain Gauge
# actor_id : Actor ID (-1 : Entire Party)
# value : Increase Amount (Subtraction works as well)
#--------------------------------------------------------------------------
def gain_actor_od_gauge(actor_id, value)
if actor_id == -1
# All living party members gauge is operated.
$game_party.existing_members.each { |actor|
actor.overdrive += value
}
else
actor = $game_actors[actor_id]
actor.overdrive += value if actor != nil && actor.exist?
end
end
#--------------------------------------------------------------------------
# ○ Enemy Overdrive Gain Gauge
# enemy_index : Enemy index (-1 : All Enemies)
# value : Increase Amount (Subtraction works as well)
#--------------------------------------------------------------------------
def gain_enemy_od_gauge(enemy_index, value)
if enemy_index == -1
# All living enemies in troop's gauge is operated.
$game_troop.existing_members.each { |enemy|
enemy.overdrive += value
}
else
enemy = $game_troop.members[enemy_index]
enemy.overdrive += value if enemy != nil && enemy.exist?
end
end
#--------------------------------------------------------------------------
# ○ Get Actor OverDrive Gauge
# actor_id : Actor ID (-1 : Entire Party)
# variable_id : Variable ID
#--------------------------------------------------------------------------
def get_actor_od_gauge(actor_id, variable_id = 0)
actor = $game_actors[actor_id]
n = (actor != nil ? actor.overdrive : 0)
if variable_id > 0
$game_variables[variable_id] = n
end
return n
end
#--------------------------------------------------------------------------
# ○ Get Enemy OverDrive Gauge
# enemy_index : EnemyID (-1 : Entire Party)
# variable_id : Variable ID
#--------------------------------------------------------------------------
def get_enemy_od_gauge(enemy_index, variable_id = 0)
enemy = $game_troop.members[enemy_index]
n = (enemy != nil ? enemy.overdrive : 0)
if variable_id > 0
$game_variables[variable_id] = n
end
return n
end
#--------------------------------------------------------------------------
# ○ Set Actor Drive Number
# actor_id : Actor ID (-1 : Entire Party)
# number : Array of number type
#--------------------------------------------------------------------------
def set_actor_od_gauge_number(actor_id, number)
if actor_id == -1
# All living party members members gauge is operated.
$game_party.members.each { |actor|
actor.drive_gauge_number = number
}
else
actor = $game_actors[actor_id]
actor.drive_gauge_number = number if actor != nil
end
end
#--------------------------------------------------------------------------
# ○ Set Enemy Drive Number
# enemy_index : Enemy ID
# number : Array of number type
#--------------------------------------------------------------------------
def set_enemy_od_gauge_number(enemy_index, number)
if enemy_index == -1
# All living enemies in troop's gauge is operated.
$game_troop.members.each { |enemy|
enemy.drive_gauge_number = number
}
else
enemy = $game_troop.members[enemy_index]
enemy.drive_gauge_number = number if enemy != nil
end
end
#--------------------------------------------------------------------------
# ○ Determine Actor Drive Max
# actor_id : ActorID
#--------------------------------------------------------------------------
def actor_od_gauge_max?(actor_id)
actor = $game_actors[actor_id]
return false if actor == nil
return actor.overdrive == actor.max_overdrive
end
#--------------------------------------------------------------------------
# ○ Determine Enemy Drive Max
# enemy_index : Enemy Index
#--------------------------------------------------------------------------
def enemy_od_gauge_max?(enemy_index)
enemy = $game_troop.members[enemy_index]
return false if enemy == nil
return enemy.overdrive == enemy.max_overdrive
end
#--------------------------------------------------------------------------
# ○ Set Actor Drive Type
# actor_id : Actor ID (-1 : Entire Party)
# types : Array of drive type ( When omitted: Initialization. )
#--------------------------------------------------------------------------
def set_actor_drive_type(actor_id, types = nil)
if actor_id == -1
# Set all party members' drive types
$game_party.members.each { |actor|
actor.drive_type = types
}
else
actor = $game_actors[actor_id]
actor.drive_type = types if actor != nil
end
end
#--------------------------------------------------------------------------
# ○ Set Enemy Drive Type
# actor_id : Enemy ID (-1 : All Enemies)
# types : Array of drive type ( When omitted: Initialization. )
#--------------------------------------------------------------------------
def set_enemy_drive_type(enemy_index, types = nil)
if enemy_index == -1
# All enemies' gauge is operated.
$game_troop.members.each { |enemy|
enemy.drive_type = types
}
else
enemy = $game_troop.members[enemy_index]
enemy.drive_type = types if enemy != nil
end
end
end
end
self.note.split(/[\r\n]+/).each { |line|
case line
when KGC::OverDrive::Regexp::Skill::OVER_DRIVE
# Overdrive
@__is_overdrive = true
@__od_cost = $1.to_i if $1 != nil
when KGC::OverDrive::Regexp::Skill::OD_GAIN_RATE
# Gauge increase rate
@__od_gain_rate = $1.to_i
end
}
# Unless OverDrive doesn't consume gauge
unless @__is_overdrive
@__od_cost = 0
end
end
#--------------------------------------------------------------------------
# ○ OverDrive is a skill?
#--------------------------------------------------------------------------
def overdrive?
create_overdrive_cache if @__is_overdrive == nil
return @__is_overdrive
end
#--------------------------------------------------------------------------
# ○ Consumption of drive gauge
#--------------------------------------------------------------------------
def od_cost
create_overdrive_cache if @__od_cost == nil
return @__od_cost
end
#--------------------------------------------------------------------------
# ○ The drive gauge increase rate
#--------------------------------------------------------------------------
def od_gain_rate
create_overdrive_cache if @__od_gain_rate == nil
return @__od_gain_rate
end
end
return skill.od_cost
end
#--------------------------------------------------------------------------
# ● Skill Use Determination
# skill : Skill
#--------------------------------------------------------------------------
alias skill_can_use_KGC_OverDrive? skill_can_use?
def skill_can_use?(skill)
return false unless skill_can_use_KGC_OverDrive?(skill)
return false if calc_od_cost(skill) > overdrive
return true
end
#--------------------------------------------------------------------------
# ● Execute Damage
# user : User of Skill or Item
# Before @hp_damage、@mp_damage、@absorbed is called, they must be set.
#--------------------------------------------------------------------------
alias execute_damage_KGC_OverDrive execute_damage
def execute_damage(user)
execute_damage_KGC_OverDrive(user)
increase_overdrive(user)
end
#--------------------------------------------------------------------------
# ○ Reset OverDrive on Death
#--------------------------------------------------------------------------
def reset_overdrive_on_dead
return unless KGC::OverDrive::EMPTY_ON_DEAD
self.overdrive = 0
end
#--------------------------------------------------------------------------
# ○ Increase Overdrive
# attacker : Attacker
#--------------------------------------------------------------------------
def increase_overdrive(attacker = nil)
return unless attacker.is_a?(Game_Battler) # Unless attacker is a battler
return if self.class == attacker.class # and attacker class is predefined
return if hp_damage == 0 && mp_damage == 0 # and they cannot attack,
# if they can gain overdrive...
if can_gain_overdrive?
# increase the overdrive.
increase_attacker_overdrive(attacker)
increase_defender_overdrive(attacker)
end
# If battler dies, reset overdrive.
reset_overdrive_on_dead if dead?
end
#--------------------------------------------------------------------------
# ○ Increase Attacker's Overdrive
# attacker : Attacker
#--------------------------------------------------------------------------
def increase_attacker_overdrive(attacker)
return unless attacker.drive_attack? # Unless attack has od attack type
od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ATTACK]
if attacker.action.kind == 1
rate = attacker.action.skill.od_gain_rate # obtain rate from od type
od_gain = od_gain * rate / 100
if rate > 0
od_gain = [od_gain, 1].max
elsif rate < 0
od_gain = [od_gain, -1].min
end
end
attacker.overdrive += od_gain
#----------------------------------------------------------------
# Determine OverDrive Max Sound's play state and play when maxed.
# Added by Mr. Anonymous 8/19/08
#----------------------------------------------------------------
# If Attacker's overdrive is greater than GAUGE_MAX...
if attacker.overdrive < KGC::OverDrive::GAUGE_MAX
# set attacker's overdrive max sound played flag to false.
attacker.odmax_sound_played = false
end
# If attacker's overdrive max sound played flag is set to false...
if attacker.odmax_sound_played == false
# and attacker's overdrive is equal to GAUGE_MAX...
if attacker.overdrive == KGC::OverDrive::GAUGE_MAX
# Play overdrive max sound...
odmax_sound.play
# set attacker's overdrive max sound played flag to true.
attacker.odmax_sound_played = true
end
end
#----------------------------------------------------------------
# End max OverDrive determination.
#----------------------------------------------------------------
end
#--------------------------------------------------------------------------
# ○ Increase Attacker's Overdrive
# attacker : Attacker
#--------------------------------------------------------------------------
def increase_defender_overdrive(attacker)
return unless self.drive_damage? # Unless attacker has od damage type
rate = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::DAMAGE]
od_gain = 0
od_gain += hp_damage * rate / maxhp if hp_damage > 0
od_gain += mp_damage * rate / maxmp if mp_damage > 0 && maxmp > 0
if rate > 0
od_gain = [od_gain, 1].max
elsif rate < 0
od_gain = [od_gain, -1].min
end
self.overdrive += od_gain
#----------------------------------------------------------------
# Determine OverDrive Max Sound's play state and play when maxed.
# Added by Mr. Anonymous 8/19/08
#----------------------------------------------------------------
# If defender's overdrive is greater than GAUGE_MAX...
if self.overdrive < KGC::OverDrive::GAUGE_MAX
# set defender's overdrive max sound played flag to false.
self.odmax_sound_played = false
end
# If defender's overdrive max sound played flag is set to false...
if self.odmax_sound_played == false
# and defender's overdrive is equal to GAUGE_MAX...
if self.overdrive == KGC::OverDrive::GAUGE_MAX
# Play overdrive max sound...
odmax_sound.play
# set defender's overdrive max sound played flag to true.
self.odmax_sound_played = true
end
end
#----------------------------------------------------------------
# End max OverDrive determination.
#----------------------------------------------------------------
end
#--------------------------------------------------------------------------
# ● Skill Effects
# user : User
# skill : Skill
#--------------------------------------------------------------------------
alias skill_effect_KGC_OverDrive skill_effect
def skill_effect(user, skill)
skill_effect_KGC_OverDrive(user, skill)
# If imported KGC_ReproduceFunctions & item used has execute skill tag...
if $imported["ReproduceFunctions"] && $game_temp.exec_skill_on_item
return
end
end
end
class Game_Actor < Game_Battler
#--------------------------------------------------------------------------
# ● Setup
# actor_id : ActorID
#--------------------------------------------------------------------------
alias setup_KGC_OverDrive setup
def setup(actor_id)
setup_KGC_OverDrive(actor_id)
@overdrive = 0
@drive_type = nil
end
#--------------------------------------------------------------------------
# ○ Aquire OverDrive Type
#--------------------------------------------------------------------------
def drive_type
unless @drive_type.is_a?(Array)
return KGC::OverDrive::DEFAULT_ACTOR_DRIVE_TYPE
end
return @drive_type
end
#--------------------------------------------------------------------------
# ○ Determine OverDrive Skill Aquired
#--------------------------------------------------------------------------
def overdrive_skill_learned?
result = false
# Temporarily Cancel Battle Flag
last_in_battle = $game_temp.in_battle
$game_temp.in_battle = false
self.skills.each { |skill|
if skill.overdrive?
result = true
break
end
}
$game_temp.in_battle = last_in_battle
return result
end
#--------------------------------------------------------------------------
# ○ Determine Gauge Increase
#--------------------------------------------------------------------------
def can_gain_overdrive?
if KGC::OverDrive::NOT_GAIN_GAUGE_HIDING
# Hide
return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
end
if KGC::OverDrive::HIDE_GAUGE_NO_OD_SKILLS
# No learned
return false unless overdrive_skill_learned?
end
return true
end
#--------------------------------------------------------------------------
# ○ Determine Gauge Display
#--------------------------------------------------------------------------
def od_gauge_visible?
# Hide gauge in Battle
if KGC::OverDrive::HIDE_GAUGE_NOT_IN_BATTLE && !$game_temp.in_battle
return false
end
# Hide Gauge
return false if KGC::OverDrive::HIDE_GAUGE_ACTOR.include?(self.id)
# Gauge amount doesn't increase.
return false unless can_gain_overdrive?
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# ● Object Initialization
# index : Index in enemy group
# enemy_id : EnemyID
#--------------------------------------------------------------------------
alias initialize_KGC_OverDrive initialize
def initialize(index, enemy_id)
initialize_KGC_OverDrive(index, enemy_id)
@overdrive = 0
@drive_type = nil
end
#--------------------------------------------------------------------------
# ○ Aquire OverDrive　Type
#--------------------------------------------------------------------------
def drive_type
unless @drive_type.is_a?(Array)
return KGC::OverDrive::DEFAULT_ENEMY_DRIVE_TYPE
end
return @drive_type
end
end
class Window_Base < Window
#----------------------------------------------------------------------
# Determine Gauge Image Type
# - Added by Mr. Anonymous 8/19/08
# If the user doesn't use gauge images, define system gauge properties.
#----------------------------------------------------------------------
if KGC::OverDrive::USE_IMAGE_GAUGE = false
#--------------------------------------------------------------------------
# ○ OD Gauge Normal Color 1
#--------------------------------------------------------------------------
def od_gauge_normal_color1
color = KGC::OverDrive::GAUGE_NORMAL_START_COLOR
return (color.is_a?(Integer) ? text_color(color) : color)
end
#--------------------------------------------------------------------------
# ○ OD Gauge Normal Color 2
#--------------------------------------------------------------------------
def od_gauge_normal_color2
color = KGC::OverDrive::GAUGE_NORMAL_END_COLOR
return (color.is_a?(Integer) ? text_color(color) : color)
end
#--------------------------------------------------------------------------
# ○ OD Gauge Max Color 1
#--------------------------------------------------------------------------
def od_gauge_max_color1
color = KGC::OverDrive::GAUGE_MAX_START_COLOR
return (color.is_a?(Integer) ? text_color(color) : color)
end
#--------------------------------------------------------------------------
# ○ OD Gauge Max Color 2
#--------------------------------------------------------------------------
def od_gauge_max_color2
color = KGC::OverDrive::GAUGE_MAX_END_COLOR
return (color.is_a?(Integer) ? text_color(color) : color)
end
end # <- if KGC::OverDrive::USE_IMAGE_GAUGE = false
#--------------------------------------------------------------------------
# ● Draw Actor Name
# actor : Actor
# x : Coordinates at X Axis
# y : Coordinates at Y Axis
#--------------------------------------------------------------------------
alias draw_actor_name_KGC_OverDrive draw_actor_name
def draw_actor_name(actor, x, y)
draw_actor_od_gauge(actor, x, y, 108)
draw_actor_name_KGC_OverDrive(actor, x, y)
end
#----------------------------------------------------------------------
# Determine Gauge Image Type
# - Added by Mr. Anonymous 8/19/08
# If the user doesn't use gauge images, draw system gauge.
#----------------------------------------------------------------------
if KGC::OverDrive::USE_IMAGE_GAUGE = false
#--------------------------------------------------------------------------
# ○ Draw Actor OverDrive Gauge
# actor : Actor
# x : Coordinates at X Axis
# y : Coordinates at Y Axis
# width : Width
#--------------------------------------------------------------------------
def draw_actor_od_gauge(actor, x, y, width = 120)
return unless actor.od_gauge_visible?
n = actor.overdrive % KGC::OverDrive::GAUGE_MAX
n = KGC::OverDrive::GAUGE_MAX if actor.overdrive == actor.max_overdrive
gw = width * n / KGC::OverDrive::GAUGE_MAX
gc1 = (gw == width ? od_gauge_max_color1 : od_gauge_normal_color1)
gc2 = (gw == width ? od_gauge_max_color2 : od_gauge_normal_color2)
self.contents.fill_rect(x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y,
width, 6, gauge_back_color)
self.contents.gradient_fill_rect(
x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y, gw, 6, gc1, gc2)
draw_actor_od_gauge_value(actor, x, y, width)
end
#----------------------------------------------------------------------
# Determine Gauge Image Type
# - Added by Mr. Anonymous 8/19/08
# Else, the user IS using gauge images...
#----------------------------------------------------------------------
else
#--------------------------------------------------------------------------
# ○ Draw Actor OverDrive Gauge
# actor : Actor
# x : Coordinates at X Axis
# y : Coordinates at Y Axis
# in_width : Inner Width
#--------------------------------------------------------------------------
def draw_actor_od_gauge(actor, x, y, in_width)
# Exit process if the OD Gauge isn't visible.
return unless actor.od_gauge_visible?
bitmap = self.contents
# Define the gauge image.
gauge = Bitmap.new("Graphics/System/" + KGC::OverDrive::GAUGE_IMAGE)
nx = x # X Coordinate
ny = y # Y Coordinate
nw = in_width # Inner image width
if $game_temp.in_battle # If inside a battle
# Pull customized battle values from the OverDrive module.
nx += KGC::OverDrive::GAUGE_POSITION_BATTLE[0]
ny += KGC::OverDrive::GAUGE_POSITION_BATTLE[1]
nw += KGC::OverDrive::GAUGE_LENGTH_BATTLE
else # when outside of battle
# Pull customized values from the OverDrive module.
nx += KGC::OverDrive::GAUGE_POSITION[0]
ny += KGC::OverDrive::GAUGE_POSITION[1]
nw += KGC::OverDrive::GAUGE_LENGTH
end
gauge_width = calc_od_gauge_width(actor, nw)
full = (gauge_width == nw - 64)
draw_od_gauge_back(bitmap, gauge, nx, ny, nw)
draw_od_gauge_inside(bitmap, gauge, nx, ny, nw, gauge_width, full)
draw_od_gauge_fore(bitmap, gauge, nx, ny, nw)
draw_actor_od_gauge_value(actor, x, y, width)
end
#--------------------------------------------------------------------------
# ○ Draw Gauge Background
# bitmap : Draw Image At...
# image : Gauge Image
# in_width : Internal Width of Gauge
#--------------------------------------------------------------------------
def draw_od_gauge_back(bitmap, image, x, y, in_width)
src_rect = Rect.new(0, 0, 32, 32)
bitmap.blt(x, y, image, src_rect)
src_rect.set(32, 0, 96, 32)
dest_rect = Rect.new(x + 32, y, in_width - 64, 32)
bitmap.stretch_blt(dest_rect, image, src_rect)
src_rect.set(128, 0, 32, 32)
bitmap.blt(x + in_width - 32, y, image, src_rect)
end
#--------------------------------------------------------------------------
# ○ Draw Inner Drive Gauge
# bitmap : Draw Image At...
# image : Gauge Image
# in_width : Internal Width of Gauge
# gauge_width : Gauge External Width
# full : Full Gauge
#--------------------------------------------------------------------------
def draw_od_gauge_inside(bitmap, image, x, y, in_width, gauge_width, full)
src_rect = Rect.new(0, (full ? 64 : 32), 0, 32)
src_rect.width = gauge_width * 96 / (in_width - 64)
dest_rect = Rect.new(x + 32, y, gauge_width, 32)
bitmap.stretch_blt(dest_rect, image, src_rect)
end
#--------------------------------------------------------------------------
# ○ Draw Gauge Foreground
# bitmap : Draw Image At...
# image : Gauge Image
# in_width : Internal Width of Gauge
#--------------------------------------------------------------------------
def draw_od_gauge_fore(bitmap, image, x, y, in_width)
src_rect = Rect.new(160, 0, 32, 32)
bitmap.blt(x, y, image, src_rect)
src_rect.set(192, 0, 96, 32)
dest_rect = Rect.new(x + 32, y, in_width - 64, 32)
bitmap.stretch_blt(dest_rect, image, src_rect)
src_rect.set(288, 0, 32, 32)
bitmap.blt(x + in_width - 32, y, image, src_rect)
end
#--------------------------------------------------------------------------
# ○ Calculate Gauge Width
#--------------------------------------------------------------------------
def calc_od_gauge_width(actor, in_width)
gw = actor.overdrive * (in_width - 64) / KGC::OverDrive::GAUGE_MAX
return [[gw, 0].max, in_width - 64].min
end
#----------------------------------------------------------------------
# End Gauge Image Type Determination
# end ( if KGC::OverDrive::USE_IMAGE_GAUGE )
#----------------------------------------------------------------------
end
#--------------------------------------------------------------------------
# ○ Draw Actor OverDrive Numerical Value
# actor : Actor
# x : Coordinates at X Axis
# y : Coordinates at Y Axis
# width : Width
#--------------------------------------------------------------------------
def draw_actor_od_gauge_value(actor, x, y, width = 120)
text = ""
value = actor.overdrive * 100.0 / KGC::OverDrive::GAUGE_MAX
case KGC::OverDrive::GAUGE_VALUE_STYLE
when KGC::OverDrive::ValueStyle::IMMEDIATE
text = actor.overdrive.to_s
when KGC::OverDrive::ValueStyle::RATE
text = sprintf("%d%%", actor.overdrive * 100 / KGC::OverDrive::GAUGE_MAX)
when KGC::OverDrive::ValueStyle::RATE_DETAIL1
text = sprintf("%0.1f%%", value)
when KGC::OverDrive::ValueStyle::RATE_DETAIL2
text = sprintf("%0.2f%%", value)
when KGC::OverDrive::ValueStyle::NUMBER
text = "#{actor.overdrive / KGC::OverDrive::GAUGE_MAX}"
else
return
end
last_font_size = self.contents.font.size
new_font_size = KGC::OverDrive::GAUGE_VALUE_FONT_SIZE
self.contents.font.size = new_font_size
self.contents.draw_text(
x, y + WLH + KGC::OverDrive::GAUGE_OFFSET_Y - new_font_size / 2,
width, new_font_size, text, 2)
self.contents.font.size = last_font_size
end
end
class Window_Skill < Window_Selectable
#--------------------------------------------------------------------------
# ○ Determine Skill in List
# skill : Skill
#--------------------------------------------------------------------------
unless $@
alias include_KGC_OverDrive? include? if method_defined?(:include?)
end
def include?(skill)
return false if skill == nil
if defined?(include_KGC_OverDrive?)
return false unless include_KGC_OverDrive?(skill)
end
if skill.overdrive?
return (@actor.calc_od_cost(skill) <= @actor.overdrive)
else
return true
end
end
if method_defined?(:include_KGC_OverDrive?)
#--------------------------------------------------------------------------
# ● Refresh
#--------------------------------------------------------------------------
def refresh
@data = []
for skill in @actor.skills
next unless include?(skill)
@data.push(skill)
if skill.id == @actor.last_skill_id
self.index = @data.size - 1
end
end
@item_max = @data.size
create_contents
for i in 0...@item_max
draw_item(i)
end # <-- for i in 0...@item_max
end # <-- refresh
end # <-- if method_defined?(:include_KGC_OverDrive?)
end # <-- class
end # <-- if KGC::OverDrive::HIDE_SKILL_LACK_OF_GAUGE
class Scene_Skill < Scene_Base
#--------------------------------------------------------------------------
# ● Use Skill(The effects of use other than the ally object are applied.)
#--------------------------------------------------------------------------
alias use_skill_nontarget_KGC_OverDrive use_skill_nontarget
def use_skill_nontarget
consume_od_gauge
use_skill_nontarget_KGC_OverDrive
end
#--------------------------------------------------------------------------
# ○ Consume Drive gauge when skill is used
#--------------------------------------------------------------------------
def consume_od_gauge
@actor.overdrive -= @actor.calc_od_cost(@skill)
end
end
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# ● Battle End
# result : Result (0:Victory 1:Escape 2:Defeat)
#--------------------------------------------------------------------------
alias battle_end_KGC_OverDrive battle_end
def battle_end(result)
increase_overdrive_on_battle_end(result)
battle_end_KGC_OverDrive(result)
end
#--------------------------------------------------------------------------
# ○ Increase OverDrive on Battle End
# result : Result (0:Victory 1:Escape 2:Defeat)
#--------------------------------------------------------------------------
def increase_overdrive_on_battle_end(result)
case result
when 0 # Victory
od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::VICTORY]
$game_party.existing_members.each { |actor|
actor.overdrive += od_gain if actor.drive_victory?
}
when 1 # Escape
od_gain = KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ESCAPE]
$game_party.existing_members.each { |actor|
actor.overdrive += od_gain if actor.drive_escape?
}
end
end
#--------------------------------------------------------------------------
# ● Execute Battle Action
#--------------------------------------------------------------------------
alias execute_action_KGC_OverDrive execute_action
def execute_action
increase_overdrive_on_action
execute_action_KGC_OverDrive
end
#--------------------------------------------------------------------------
# ○ Increase Gauge on Action
#--------------------------------------------------------------------------
def increase_overdrive_on_action
battler = @active_battler
od_gain = 0
unit = (battler.actor? ? $game_party : $game_troop)
# Alone
if battler.drive_alone? && unit.existing_members.size == 1
od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ALONE]
end
# Action
if battler.drive_action?
od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::ACTION]
end
# Fatal
if battler.drive_fatal? && battler.hp < battler.maxhp / 4
od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::FATAL]
end
# Guard
if battler.drive_guard? && battler.action.kind == 0 &&
battler.action.basic == 1
od_gain += KGC::OverDrive::GAIN_RATE[KGC::OverDrive::Type::GUARD]
end
battler.overdrive += od_gain
end
#--------------------------------------------------------------------------
# ● Execution of battle action: Skill
#--------------------------------------------------------------------------
alias execute_action_skill_KGC_OverDrive execute_action_skill
def execute_action_skill
execute_action_skill_KGC_OverDrive
consume_od_gauge
end
#--------------------------------------------------------------------------
# ○ Drive gauge consumption when skill is used
#--------------------------------------------------------------------------
def consume_od_gauge
skill = @active_battler.action.skill
@active_battler.overdrive -= @active_battler.calc_od_cost(skill)
end
end
Czy może ktoś mi podać poprawną komendę, która zwiększy overdrive na maxa?
Pomogła: 232 razy Dołączyła: 18 Wrz 2007 Posty: 2424
Wysłany: Nie 12 Lut, 2012 11:21
Kod:
gain_actor_od_gauge(ActorID, Increase)
Cytat:
ActorID = The ID number of the selected Actor in the database.
Setting this to -1 will effect all actors.
Increase = The amount of OverDrive points to increase.
Nie możesz pisać nowych tematów Nie możesz odpowiadać w tematach Nie możesz zmieniać swoich postów Nie możesz usuwać swoich postów Nie możesz głosować w ankietach Nie możesz załączać plików na tym forum Możesz ściągać załączniki na tym forum
