求转换此VX战斗界面脚本为VA版 - Project1

#==============================================================================
#
# ▼ Yanfly Engine Ace - Ace Battle Engine v1.18
# -- Last Updated: 2012.01.24
# -- Level: Normal, Hard
# -- Requires: n/a
#
#==============================================================================
$imported = {} if $imported.nil?
$imported["YEA-BattleEngine"] = true
#==============================================================================
# ▼ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.01.24 - Compatibility Update: Enemy Levels
# 2012.01.18 - Bug Fixed: Help Window clears text upon selecting nil items.
# 2012.01.11 - Added <one animation> tag for multi-hit skills to play an
# animation only once.
# - Reduced lag from battle system constantly recreating bitmaps.
# 2012.01.10 - Compatibility Update: Battle System FTB
# 2012.01.09 - Anticrash methods implemented.
# - Damage Popups are now separate for damage formulas and recovery.
# 2012.01.05 - Bug fixed: Game no longer crashes with escape skills/items.
# 2012.01.02 - Compatibility Update: Target Manager
# - Added Option: AUTO_FAST
# - Random hits now show animations individually.
# 2011.12.30 - Compatibility Update: Enemy Levels
# - Added Option to center the actors in the HUD.
# 2011.12.27 - Bug fixed: TP Damage skills and items no longer crash game.
# - Default battle system bug fixes are now included from YEA's Ace
# Core Engine.
# - Groundwork is also made to support future battle system types.
# - Multi-hit actions no longer linger when a target dies during the
# middle of one of the hits.
# - Compatibility Update: Lunatic Objects v1.02
# 2011.12.26 - Bug fixed: Multi-hit popups occured even after an enemy's dead.
# 2011.12.22 - Bug fixed: Elemental Resistance popup didn't show.
# 2011.12.20 - Bug fixed: Death state popups against immortal states.
# - Bug fixed: During State popup fix.
# - Added HIDE_POPUP_SWITCH.
# 2011.12.17 - Compatibiilty Update: Cast Animations
# 2011.12.15 - Compatibility Update: Battle Command List
# 2011.12.14 - Compatibility Update: Lunatic Objects
# 2011.12.13 - Compatibility Update: Command Party
# 2011.12.12 - Bug fixed: Turn stalling if no inputable members.
# 2011.12.10 - Compatibility update for Automatic Party HUD.
# - Popup graphical bug fixed.
# - Bug fixed: Didn't wait for boss dead animations.
# - Bug fixed: Surprise attacks that froze the game.
# - Bug fixed: Popups didn't show for straight recovery effects.
# 2011.12.08 - Finished Script.
# 2011.12.04 - Started Script.
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# Ace Battle Engine works as a foundation for future battle engine add-ons. It
# allows for easier management of the battle engine without adding too many
# features, allowing users to customize what they want as they see fit. While
# the Ace Battle Engine isn't an entirely new engine, it gives users control
# that RPG Maker VX Ace didn't originally give them.
#
# Furthermore, this script provides some new features. They are as follows:
#
# -----------------------------------------------------------------------------
# Animation Fixes
# -----------------------------------------------------------------------------
# Though the Yanfly Engine Ace - Ace Core Engine script contains these fixes,
# these fixes are included in this script as well to ensure it's working for
# the battle script in the event someone chooses not to work with the Ace Core
# Engine script. The animation fixes prevent excessive animation overlaying
# (and making the screen look really ugly) and prevents animation clashing
# between two dual wielding normal attack animations.
#
# -----------------------------------------------------------------------------
# Enemy Animations
# -----------------------------------------------------------------------------
# Enemies now show battle animations when they deliver attacks and skills
# against the player's party. Before in RPG Maker VX Ace, it was nothing more
# than just sound effects and the screen shaking. Now, animations play where
# the status window is and relative to the position of each party member.
#
# -----------------------------------------------------------------------------
# Left/Right Command Selection
# -----------------------------------------------------------------------------
# While choosing actions, the player can press Left or Right to move freely
# between (alive) actors to change their skills. Players no longer have to
# cancel all the way back to change one person's skill and reselect everything.
# On that note, there is now the option that when a battle starts or at the
# end of a turn, players will start immediately at command selection rather
# than needing to select "Fight" in the Party Command Window.
#
# -----------------------------------------------------------------------------
# Popups
# -----------------------------------------------------------------------------
# Dealing damage, inflicting states, adding buffs, landing critical hits,
# striking weaknesses, missing attacks, you name it, there's probably a popup
# for it. Popups deliver information to the player in a quick or orderly
# fashion without requiring the player to read lines of text.
#
# -----------------------------------------------------------------------------
# Targeting Window
# -----------------------------------------------------------------------------
# When targeting enemies, the window is no longer displayed. Instead, the
# targeted enemies are highlighted and their names are shown at the top of the
# screen in a help window. Another thing that's changed is when skills that
# target multiple targets are selected, there is a confirmation step that the
# player must take before continuing. In this confirmation step, all of the
# multiple targets are selected and in the help window would display the scope
# of the skill (such as "All Foes" or "Random Foes"). RPG Maker VX Ace skipped
# this step by default.
#
# -----------------------------------------------------------------------------
# Toggling On and Off Special Effects and Text
# -----------------------------------------------------------------------------
# Not everybody likes having the screen shake or the enemies blink when they
# take damage. These effects can now be toggled on and off. Certain text can
# also be toggled on and off from appearing. A lot of the displayed text has
# been rendered redundant through the use of popups.
#
# -----------------------------------------------------------------------------
# Visual Battle Status Window
# -----------------------------------------------------------------------------
# Rather than just having rows of names with HP and MP bars next to them, the
# Battle Status Window now displays actors' faces and their gauges aligned at
# the bottom. More status effects can be shown in addition to showing more
# members on screen at once. The Battle Status Window is also optimized to
# refresh less (thus, removing potential lag from the system).
#
# -----------------------------------------------------------------------------
# Window Position Changes
# -----------------------------------------------------------------------------
# Windows such as the Skill Window and Item Window have been rearranged to
# always provide the player a clear view of the battlefield rather than opening
# up and covering everything. As such, the window positions are placed at the
# bottom of the screen and are repositioned.
#
#==============================================================================
# ▼ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials/素材 but above ▼ Main. Remember to save.
#
# -----------------------------------------------------------------------------
# Skill Notetags - These notetags go in the skills notebox in the database.
# -----------------------------------------------------------------------------
# <one animation>
# Causes the action to display the action animation only once, even if it's a
# multi-hit action. This is used primarily for non-all scope targeting.
#
# -----------------------------------------------------------------------------
# Item Notetags - These notetags go in the items notebox in the database.
# -----------------------------------------------------------------------------
# <one animation>
# Causes the action to display the action animation only once, even if it's a
# multi-hit action. This is used primarily for non-all scope targeting.
#
# -----------------------------------------------------------------------------
# Enemy Notetags - These notetags go in the enemy notebox in the database.
# -----------------------------------------------------------------------------
# <atk ani 1: x>
# <atk ani 2: x>
# Changes the normal attack animation of the particular enemy to animation x.
# Attack animation 1 is the first one that plays. If there's a second animation
# then the second one will play after in mirrored form.
#
# -----------------------------------------------------------------------------
# State Notetags - These notetags go in the state notebox in the database.
# -----------------------------------------------------------------------------
# <popup add: string>
# <popup rem: string>
# <popup dur: string>
# Status effects now create popups whenever they're inflicted. However, if you
# don't like that a certain status effect uses a particular colour setting,
# change "string" to one of the rulesets below to cause that popup to use a
# different ruleset.
#
# <popup hide add>
# <popup hide rem>
# <popup hide dur>
# Not everybody wants status effects to show popups when inflicted. When this
# is the case, insert the respective tag to hide popups from appearing when the
# state is added, removed, or during the stand-by phases.
#
# -----------------------------------------------------------------------------
# Debug Tools - These tools only work during Test Play.
# -----------------------------------------------------------------------------
# - F5 Key -
# Recovers all actors. Restores their HP and MP to max. Does not affect TP.
# All states and buffs are removed whether they are positive or negative.
#
# - F6 Key -
# Sets all actors to have 1 HP, 0 MP, and 0 TP. States are unaffected.
#
# - F7 Key -
# Sets all actors to have max TP. Everything else is unaffected.
#
# - F8 Key -
# Kills all enemies in battle. Ends the battle quickly.
#
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
#==============================================================================
module YEA
module BATTLE
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - General Battle Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# These settings are adjusted for the overall battle system. These are
# various miscellaneous options to adjust. Each of the settings below will
# explain what they do. Change default enemy battle animations here, too.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
BLINK_EFFECTS = false # Blink sprite when damaged?
FLASH_WHITE_EFFECT = true # Flash enemy white when it starts an attack.
SCREEN_SHAKE = false # Shake screen in battle?
SKIP_PARTY_COMMAND = true # Skips the Fight/Escape menu.
AUTO_FAST = true # Causes message windows to not wait.
ENEMY_ATK_ANI = 36 # Sets default attack animation for enemies.
# If this switch is ON, popups will be hidden. If OFF, the popups will be
# shown. If you do not wish to use this switch, set it to 0.
HIDE_POPUP_SWITCH = 0
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Battle Status Window -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# This sets the default battle system your game will use. If your game
# doesn't have any other battle systems installed, it will use :dtb.
#
# Battle System Requirement
# :dtb - Default Turn Battle. Default system.
# :ftb - YEA Battle System Add-On: Free Turn Battle
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
DEFAULT_BATTLE_SYSTEM = :dtb # Default battle system set.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Battle Status Window -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# Here, you can adjust the settings for the battle status window. The
# battle status window, by default, will show the actor's face, HP, MP, TP
# (if viable), and any inflicted status effects.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
BATTLESTATUS_NAME_FONT_SIZE = 20 # Font size used for name.
BATTLESTATUS_TEXT_FONT_SIZE = 16 # Font size used for HP, MP, TP.
BATTLESTATUS_NO_ACTION_ICON = 185 # No action icon.
BATTLESTATUS_HPGAUGE_Y_PLUS = 11 # Y Location buffer used for HP gauge.
BATTLESTATUS_CENTER_FACES = false # Center faces for the Battle Status.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Help Window Text -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# When selecting a target to attack, this is the text that will be shown
# in place of a target's name for special cases. These special cases are
# for selections that were originally non-targetable battle scopes.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
HELP_TEXT_ALL_FOES = "All Foes"
HELP_TEXT_ONE_RANDOM_FOE = "One Random Foe"
HELP_TEXT_MANY_RANDOM_FOE = "%d Random Foes"
HELP_TEXT_ALL_ALLIES = "All Allies"
HELP_TEXT_ALL_DEAD_ALLIES = "All Dead Allies"
HELP_TEXT_ONE_RANDOM_ALLY = "One Random Ally"
HELP_TEXT_RANDOM_ALLIES = "%d Random Allies"
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Popup Settings -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# These settings will adjust the popups that appear in battle. Popups
# deliver information to your player as battlers deal damage, inflict
# status effects, and more.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
ENABLE_POPUPS = true # Set this to false if you wish to disable them.
FLASH_CRITICAL = true # Sets critical hits to flash.
# This hash adjusts the popup settings that will govern how popups appear.
# Adjust them accordingly.
POPUP_SETTINGS ={
:offset => -24, # Height offset of a popup.
:fade => 12, # Fade rate for each popup.
:full => 60, # Frames before a popup fades.
:hp_dmg => "-%s ", # SprintF for HP damage.
:hp_heal => "+%s ", # SprintF for HP healing.
:mp_dmg => "-%s MP", # SprintF for MP damage.
:mp_heal => "+%s MP", # SprintF for MP healing.
:tp_dmg => "-%s TP", # SprintF for MP damage.
:tp_heal => "+%s TP", # SprintF for MP healing.
:drained => "DRAIN", # Text display for draining HP/MP.
:critical => "CRITICAL!", # Text display for critical hit.
:missed => "MISS", # Text display for missed attack.
:evaded => "EVADE!", # Text display for evaded attack.
:nulled => "NULL", # Text display for nulled attack.
:failed => "FAILED", # Text display for a failed attack.
:add_state => "+%s", # SprintF for added states.
:rem_state => "-%s", # SprintF for removed states.
:dur_state => "%s", # SprintF for during states.
:ele_rates => true, # This will display elemental affinities.
:ele_wait => 20, # This is how many frames will wait.
:weakpoint => "WEAKPOINT", # Appears if foe is weak to element.
:resistant => "RESIST", # Appears if foe is resistant to element.
:immune => "IMMUNE", # Appears if foe is immune to element.
:absorbed => "ABSORB", # Appears if foe can absorb the element.
:add_buff => "%s＋", # Appears when a positive buff is applied.
:add_debuff => "%s－", # Appears when a negative buff is applied.
} # Do not remove this.
# This is the default font used for the popups. Adjust them accordingly
# or even add new ones.
DEFAULT = ["VL Gothic", "Verdana", "Arial", "Courier"]
# The following are the various rules that govern the individual popup
# types that will appear. Adjust them accordingly. Here is a list of what
# each category does.
# Zoom1 The zoom the popup starts at. Values over 2.0 may cause lag.
# Zoom2 The zoom the popup goes to. Values over 2.0 may cause lag.
# Sz The font size used for the popup text.
# Bold Applying bold for the popup text.
# Italic Applying italic for the popup text.
# Red The red value of the popup text.
# Grn The green value of the popup text.
# Blu The blue value of the popup text.
# Font The font used for the popup text.
POPUP_RULES ={
# Type => [ Zoom1, Zoom2, Sz, Bold, Italic, Red, Grn, Blu, Font]
"DEFAULT" => [ 2.0, 1.0, 24, true, false, 255, 255, 255, DEFAULT],
"CRITICAL" => [ 2.0, 1.0, 24, true, false, 255, 80, 80, DEFAULT],
"HP_DMG" => [ 2.0, 1.0, 36, true, false, 255, 255, 255, DEFAULT],
"HP_HEAL" => [ 2.0, 1.0, 36, true, false, 130, 250, 130, DEFAULT],
"MP_DMG" => [ 2.0, 1.0, 36, true, false, 220, 180, 255, DEFAULT],
"MP_HEAL" => [ 2.0, 1.0, 36, true, false, 160, 230, 255, DEFAULT],
"TP_DMG" => [ 2.0, 1.0, 36, true, false, 242, 108, 78, DEFAULT],
"TP_HEAL" => [ 2.0, 1.0, 36, true, false, 251, 175, 92, DEFAULT],
"ADDSTATE" => [ 2.0, 1.0, 24, true, false, 240, 100, 100, DEFAULT],
"REMSTATE" => [ 2.0, 1.0, 24, true, false, 125, 170, 225, DEFAULT],
"DURSTATE" => [ 2.0, 1.0, 24, true, false, 255, 240, 150, DEFAULT],
"DRAIN" => [ 2.0, 1.0, 36, true, false, 250, 190, 255, DEFAULT],
"POSITIVE" => [ 2.0, 1.0, 24, true, false, 110, 210, 245, DEFAULT],
"NEGATIVE" => [ 2.0, 1.0, 24, true, false, 245, 155, 195, DEFAULT],
"WEAK_ELE" => [ 0.5, 1.0, 24, true, false, 240, 110, 80, DEFAULT],
"IMMU_ELE" => [ 0.5, 1.0, 24, true, false, 185, 235, 255, DEFAULT],
"REST_ELE" => [ 0.5, 1.0, 24, true, false, 145, 230, 180, DEFAULT],
"ABSB_ELE" => [ 0.5, 1.0, 24, true, false, 250, 190, 255, DEFAULT],
"BUFF" => [ 2.0, 1.0, 24, true, false, 255, 240, 100, DEFAULT],
"DEBUFF" => [ 2.0, 1.0, 24, true, false, 160, 130, 200, DEFAULT],
} # Do not remove this.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Streamlined Messages -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# Want to remove some of those annoying messages that appear all the time?
# Now you can! Select which messages you want to enable or disable. Some of
# these messages will be rendered useless due to popups.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
MSG_ENEMY_APPEARS = false # Message when enemy appears start of battle.
MSG_CURRENT_STATE = false # Show which states has affected battler.
MSG_CURRENT_ACTION = true # Show the current action of the battler.
MSG_COUNTERATTACK = true # Show the message for a counterattack.
MSG_REFLECT_MAGIC = true # Show message for reflecting magic attacks.
MSG_SUBSTITUTE_HIT = true # Show message for ally taking another's hit.
MSG_FAILURE_HIT = false # Show effect failed against target.
MSG_CRITICAL_HIT = false # Show attack was a critical hit.
MSG_HIT_MISSED = false # Show attack missed the target.
MSG_EVASION = false # Show attack was evaded by the target.
MSG_HP_DAMAGE = false # Show HP damage to target.
MSG_MP_DAMAGE = false # Show MP damage to target.
MSG_TP_DAMAGE = false # Show TP damage to target.
MSG_ADDED_STATES = false # Show target's added states.
MSG_REMOVED_STATES = false # Show target's removed states.
MSG_CHANGED_BUFFS = false # Show target's changed buffs.
end # BATTLE
end # YEA
#==============================================================================
# ▼ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================
module YEA
module REGEXP
module ENEMY
ATK_ANI1 = /<(?:ATK_ANI_1|atk ani 1):[ ]*(\d+)>/i
ATK_ANI2 = /<(?:ATK_ANI_2|atk ani 2):[ ]*(\d+)>/i
end # ENEMY
module USABLEITEM
ONE_ANIMATION = /<(?:ONE_ANIMATION|one animation)>/i
end # USABLEITEM
module STATE
POPUP_ADD = /<(?:POPUP_ADD_RULE|popup add rule|popup add):[ ](.*)>/i
POPUP_REM = /<(?:POPUP_REM_RULE|popup rem rule|popup rem):[ ](.*)>/i
POPUP_DUR = /<(?:POPUP_DUR_RULE|popup dur rule|popup dur):[ ](.*)>/i
HIDE_ADD = /<(?:POPUP_HIDE_ADD|popup hide add|hide add)>/i
HIDE_REM = /<(?:POPUP_HIDE_REM|popup hide rem|hide rem)>/i
HIDE_DUR = /<(?:POPUP_HIDE_DUR|popup hide dur|hide dur)>/i
end # STATE
end # REGEXP
end # YEA
#==============================================================================
# ■ Switch
#==============================================================================
module Switch
#--------------------------------------------------------------------------
# self.hide_popups
#--------------------------------------------------------------------------
def self.hide_popups
return false if YEA::BATTLE::HIDE_POPUP_SWITCH <= 0
return $game_switches[YEA::BATTLE::HIDE_POPUP_SWITCH]
end
end # Switch
#==============================================================================
# ■ Colour
#==============================================================================
module Colour
#--------------------------------------------------------------------------
# self.text_colour
#--------------------------------------------------------------------------
def self.text_colour(index)
windowskin = Cache.system("Window")
x = 64 + (index % 8) * 8
y = 96 + (index / 8) * 8
return windowskin.get_pixel(x, y)
end
end # Colour
#==============================================================================
# ■ Icon
#==============================================================================
module Icon
#--------------------------------------------------------------------------
# self.no_action
#--------------------------------------------------------------------------
def self.no_action; return YEA::BATTLE::BATTLESTATUS_NO_ACTION_ICON; end
end # Icon
#==============================================================================
# ■ Numeric
#==============================================================================
class Numeric
#--------------------------------------------------------------------------
# new method: group_digits
#--------------------------------------------------------------------------
unless $imported["YEA-CoreEngine"]
def group; return self.to_s; end
end # $imported["YEA-CoreEngine"]
end # Numeric
#==============================================================================
# ■ DataManager
#==============================================================================
module DataManager
#--------------------------------------------------------------------------
# alias method: load_database
#--------------------------------------------------------------------------
class <<self; alias load_database_abe load_database; end
def self.load_database
load_database_abe
load_notetags_abe
end
#--------------------------------------------------------------------------
# new method: load_notetags_abe
#--------------------------------------------------------------------------
def self.load_notetags_abe
groups = [$data_enemies, $data_states, $data_skills, $data_items]
for group in groups
for obj in group
next if obj.nil?
obj.load_notetags_abe
end
end
end
end # DataManager
#==============================================================================
# ■ RPG::UsableItem
#==============================================================================
class RPG::UsableItem < RPG::BaseItem
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :one_animation
#--------------------------------------------------------------------------
# common cache: load_notetags_abe
#--------------------------------------------------------------------------
def load_notetags_abe
@one_animation = false
#---
self.note.split(/[\r\n]+/).each { |line|
case line
#---
when YEA::REGEXP::USABLEITEM::ONE_ANIMATION
@one_animation = true
end
} # self.note.split
#---
end
end # RPG::UsableItem
#==============================================================================
# ■ RPG::Enemy
#==============================================================================
class RPG::Enemy < RPG::BaseItem
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :atk_animation_id1
attr_accessor :atk_animation_id2
#--------------------------------------------------------------------------
# common cache: load_notetags_abe
#--------------------------------------------------------------------------
def load_notetags_abe
@atk_animation_id1 = YEA::BATTLE::ENEMY_ATK_ANI
@atk_animation_id2 = 0
#---
self.note.split(/[\r\n]+/).each { |line|
case line
#---
when YEA::REGEXP::ENEMY::ATK_ANI1
@atk_animation_id1 = $1.to_i
when YEA::REGEXP::ENEMY::ATK_ANI2
@atk_animation_id2 = $1.to_i
end
} # self.note.split
#---
end
end # RPG::Enemy
#==============================================================================
# ■ RPG::Enemy
#==============================================================================
class RPG::State < RPG::BaseItem
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :popup_rules
#--------------------------------------------------------------------------
# common cache: load_notetags_abe
#--------------------------------------------------------------------------
def load_notetags_abe
@popup_rules = {
:add_state => "ADDSTATE",
:rem_state => "REMSTATE",
:dur_state => nil
} # Do not remove this.
#---
self.note.split(/[\r\n]+/).each { |line|
case line
#---
when YEA::REGEXP::STATE::POPUP_ADD
@popup_rules[:add_state] = $1.upcase.to_s
when YEA::REGEXP::STATE::POPUP_REM
@popup_rules[:rem_state] = $1.upcase.to_s
when YEA::REGEXP::STATE::POPUP_DUR
@popup_rules[:dur_state] = $1.upcase.to_s
when YEA::REGEXP::STATE::HIDE_ADD
@popup_rules[:add_state] = nil
when YEA::REGEXP::STATE::HIDE_REM
@popup_rules[:rem_state] = nil
when YEA::REGEXP::STATE::HIDE_DUR
@popup_rules[:dur_state] = nil
end
} # self.note.split
#---
end
end # RPG::State
#==============================================================================
# ■ BattleManager
#==============================================================================
module BattleManager
#--------------------------------------------------------------------------
# overwrite method: self.battle_start
#--------------------------------------------------------------------------
def self.battle_start
$game_system.battle_count += 1
$game_party.on_battle_start
$game_troop.on_battle_start
return unless YEA::BATTLE::MSG_ENEMY_APPEARS
$game_troop.enemy_names.each do |name|
$game_message.add(sprintf(Vocab::Emerge, name))
end
if @preemptive
$game_message.add(sprintf(Vocab::Preemptive, $game_party.name))
elsif @surprise
$game_message.add(sprintf(Vocab::Surprise, $game_party.name))
end
wait_for_message
end
#--------------------------------------------------------------------------
# overwrite method: make_action_orders
#--------------------------------------------------------------------------
def self.make_action_orders
make_dtb_action_orders if btype?(:dtb)
end
#--------------------------------------------------------------------------
# new method: make_dtb_action_orders
#--------------------------------------------------------------------------
def self.make_dtb_action_orders
@action_battlers = []
@action_battlers += $game_party.members unless @surprise
@action_battlers += $game_troop.members unless @preemptive
@action_battlers.each {|battler| battler.make_speed }
@action_battlers.sort! {|a,b| b.speed - a.speed }
end
#--------------------------------------------------------------------------
# overwrite method: turn_start
#--------------------------------------------------------------------------
def self.turn_start
@phase = :turn
clear_actor
$game_troop.increase_turn
@performed_battlers = []
make_action_orders
end
#--------------------------------------------------------------------------
# overwrite method: next_subject
#--------------------------------------------------------------------------
def self.next_subject
@performed_battlers = [] if @performed_battlers.nil?
loop do
@action_battlers -= @performed_battlers
battler = @action_battlers.shift
return nil unless battler
next unless battler.index && battler.alive?
@performed_battlers.push(battler)
return battler
end
end
#--------------------------------------------------------------------------
# overwrite method: force_action
#--------------------------------------------------------------------------
def self.force_action(battler)
@action_forced = [] if @action_forced == nil
@action_forced.push(battler)
return unless Switch.forced_action_remove
@action_battlers.delete(battler)
end
#--------------------------------------------------------------------------
# overwrite method: action_forced?
#--------------------------------------------------------------------------
def self.action_forced?
@action_forced != nil
end
#--------------------------------------------------------------------------
# overwrite method: action_forced_battler
#--------------------------------------------------------------------------
def self.action_forced_battler
@action_forced.shift
end
#--------------------------------------------------------------------------
# overwrite method: clear_action_force
#--------------------------------------------------------------------------
def self.clear_action_force
@action_forced = nil if @action_forced.empty?
end
#--------------------------------------------------------------------------
# new method: self.init_battle_type
#--------------------------------------------------------------------------
def self.init_battle_type
set_btype($game_system.battle_system)
end
#--------------------------------------------------------------------------
# new method: self.set_btype
#--------------------------------------------------------------------------
def self.set_btype(btype = :dtb)
@battle_type = btype
end
#--------------------------------------------------------------------------
# new method: self.btype?
#--------------------------------------------------------------------------
def self.btype?(btype)
return @battle_type == btype
end
end # BattleManager
#==============================================================================
# ■ Game_System
#==============================================================================
class Game_System
#--------------------------------------------------------------------------
# new method: battle_system
#--------------------------------------------------------------------------
def battle_system
if @battle_system.nil?
return battle_system_corrected(YEA::BATTLE::DEFAULT_BATTLE_SYSTEM)
else
return battle_system_corrected(@battle_system)
end
end
#--------------------------------------------------------------------------
# new method: set_battle_system
#--------------------------------------------------------------------------
def set_battle_system(type)
case type
when :dtb; @battle_system = :dtb
when :ftb; @battle_system = $imported["YEA-BattleSystem-FTB"] ? :ftb : :dtb
else; @battle_system = :dtb
end
end
#--------------------------------------------------------------------------
# new method: battle_system_corrected
#--------------------------------------------------------------------------
def battle_system_corrected(type)
case type
when :dtb; return :dtb
when :ftb; return $imported["YEA-BattleSystem-FTB"] ? :ftb : :dtb
else; return :dtb
end
end
end # Game_System
#==============================================================================
# ■ Sprite_Base
#==============================================================================
class Sprite_Base < Sprite
#--------------------------------------------------------------------------
# new method: start_pseudo_animation
#--------------------------------------------------------------------------
unless $imported["YEA-CoreEngine"]
def start_pseudo_animation(animation, mirror = false)
dispose_animation
@animation = animation
return if @animation.nil?
@ani_mirror = mirror
set_animation_rate
@ani_duration = @animation.frame_max * @ani_rate + 1
@ani_sprites = []
end
end # $imported["YEA-CoreEngine"]
end # Sprite_Base
#==============================================================================
# ■ Sprite_Battler
#==============================================================================
class Sprite_Battler < Sprite_Base
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :effect_type
attr_accessor :battler_visible
attr_accessor :popups
#--------------------------------------------------------------------------
# alias method: initialize
#--------------------------------------------------------------------------
alias sprite_battler_initialize_abe initialize
def initialize(viewport, battler = nil)
sprite_battler_initialize_abe(viewport, battler)
@popups = []
@popup_flags = []
end
#--------------------------------------------------------------------------
# alias method: update_bitmap
#--------------------------------------------------------------------------
alias sprite_battler_update_bitmap_abe update_bitmap
def update_bitmap
return if @battler.actor? && @battler.battler_name == ""
sprite_battler_update_bitmap_abe
end
#--------------------------------------------------------------------------
# alias method: setup_new_animation
#--------------------------------------------------------------------------
unless $imported["YEA-CoreEngine"]
alias sprite_battler_setup_new_animation_abe setup_new_animation
def setup_new_animation
sprite_battler_setup_new_animation_abe
return if @battler.pseudo_ani_id <= 0
animation = $data_animations[@battler.pseudo_ani_id]
mirror = @battler.animation_mirror
start_pseudo_animation(animation, mirror)
@battler.pseudo_ani_id = 0
end
end # $imported["YEA-CoreEngine"]
#--------------------------------------------------------------------------
# alias method: setup_new_effect
#--------------------------------------------------------------------------
alias sprite_battler_setup_new_effect_abe setup_new_effect
def setup_new_effect
sprite_battler_setup_new_effect_abe
setup_popups
end
#--------------------------------------------------------------------------
# new method: setup_popups
#--------------------------------------------------------------------------
def setup_popups
return unless @battler.use_sprite?
@battler.popups = [] if @battler.popups.nil?
return if @battler.popups == []
array = @battler.popups.shift
create_new_popup(array[0], array[1], array[2])
end
#--------------------------------------------------------------------------
# new method: create_new_popup
#--------------------------------------------------------------------------
def create_new_popup(value, rules, flags)
return if @battler == nil
return if flags & @popup_flags != []
array = YEA::BATTLE::POPUP_RULES[rules]
for popup in @popups
popup.y -= 24
end
return unless SceneManager.scene.is_a?(Scene_Battle)
return if SceneManager.scene.spriteset.nil?
view = SceneManager.scene.spriteset.viewportPopups
new_popup = Sprite_Popup.new(view, @battler, value, rules, flags)
@popups.push(new_popup)
@popup_flags.push("weakness") if flags.include?("weakness")
@popup_flags.push("resistant") if flags.include?("resistant")
@popup_flags.push("immune") if flags.include?("immune")
@popup_flags.push("absorbed") if flags.include?("absorbed")
end
#--------------------------------------------------------------------------
# alias method: update_effect
#--------------------------------------------------------------------------
alias sprite_battler_update_effect_abe update_effect
def update_effect
sprite_battler_update_effect_abe
update_popups
end
#--------------------------------------------------------------------------
# new method: update_popups
#--------------------------------------------------------------------------
def update_popups
for popup in @popups
popup.update
next unless popup.opacity <= 0
popup.bitmap.dispose
popup.dispose
@popups.delete(popup)
popup = nil
end
@popup_flags = [] if @popups == [] && @popup_flags != []
return unless SceneManager.scene_is?(Scene_Battle)
if @current_active_battler != SceneManager.scene.subject
@current_active_battler = SceneManager.scene.subject
@popup_flags = []
end
end
end # Sprite_Battler
#==============================================================================
# ■ Sprite_Popup
#==============================================================================
class Sprite_Popup < Sprite_Base
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :flags
#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(viewport, battler, value, rules, flags)
super(viewport)
@value = value
@rules = rules
@rules = "DEFAULT" unless YEA::BATTLE::POPUP_RULES.include?(@rules)
@fade = YEA::BATTLE::POPUP_SETTINGS[:fade]
@full = YEA::BATTLE::POPUP_SETTINGS[:full]
@flags = flags
@battler = battler
create_popup_bitmap
end
#--------------------------------------------------------------------------
# create_popup_bitmap
#--------------------------------------------------------------------------
def create_popup_bitmap
rules_array = YEA::BATTLE::POPUP_RULES[@rules]
bw = Graphics.width
bw += 48 if @flags.include?("state")
bh = Font.default_size * 3
bitmap = Bitmap.new(bw, bh)
bitmap.font.name = rules_array[8]
size = @flags.include?("critical") ? rules_array[2] * 1.2 : rules_array[2]
bitmap.font.size = size
bitmap.font.bold = rules_array[3]
bitmap.font.italic = rules_array[4]
if flags.include?("critical")
crit = YEA::BATTLE::POPUP_RULES["CRITICAL"]
bitmap.font.out_color.set(crit[5], crit[6], crit[7], 255)
else
bitmap.font.out_color.set(0, 0, 0, 255)
end
dx = 0; dy = 0; dw = 0
dx += 24 if @flags.include?("state")
dw += 24 if @flags.include?("state")
if @flags.include?("state") || @flags.include?("buff")
c_width = bitmap.text_size(@value).width
icon_bitmap = $game_temp.iconset
icon_index = flag_state_icon
rect = Rect.new(icon_index % 16 * 24, icon_index / 16 * 24, 24, 24)
bitmap.blt(dx+(bw-c_width)/2-36, (bh - 24)/2, icon_bitmap, rect, 255)
end
bitmap.font.color.set(rules_array[5], rules_array[6], rules_array[7])
bitmap.draw_text(dx, dy, bw-dw, bh, @value, 1)
self.bitmap = bitmap
self.x = @battler.screen_x
self.x += rand(4) - rand(4) if @battler.sprite.popups.size >= 1
self.x -= SceneManager.scene.spriteset.viewport1.ox
self.y = @battler.screen_y - @battler.sprite.oy/2
self.y -= @battler.sprite.oy/2 if @battler.actor?
self.y -= SceneManager.scene.spriteset.viewport1.oy
self.ox = bw/2; self.oy = bh/2
self.zoom_x = self.zoom_y = rules_array[0]
if @flags.include?("no zoom")
self.zoom_x = self.zoom_y = rules_array[1]
end
@target_zoom = rules_array[1]
@zoom_direction = (self.zoom_x > @target_zoom) ? "down" : "up"
self.z = 500
end
#--------------------------------------------------------------------------
# update
#--------------------------------------------------------------------------
def update
super
#---
if @flags.include?("critical") && YEA::BATTLE::FLASH_CRITICAL
@hue_duration = 2 if @hue_duration == nil || @hue_duration == 0
@hue_duration -= 1
self.bitmap.hue_change(15) if @hue_duration <= 0
end
#---
if @zoom_direction == "up"
self.zoom_x = [self.zoom_x + 0.075, @target_zoom].min
self.zoom_y = [self.zoom_y + 0.075, @target_zoom].min
else
self.zoom_x = [self.zoom_x - 0.075, @target_zoom].max
self.zoom_y = [self.zoom_y - 0.075, @target_zoom].max
end
#---
@full -= 1
return if @full > 0
self.y -= 1
self.opacity -= @fade
end
#--------------------------------------------------------------------------
# flag_state_icon
#--------------------------------------------------------------------------
def flag_state_icon
for item in @flags; return item if item.is_a?(Integer); end
return 0
end
end # Sprite_Popup
#==============================================================================
# ■ Spriteset_Battle
#==============================================================================
class Spriteset_Battle
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :actor_sprites
attr_accessor :enemy_sprites
attr_accessor :viewport1
attr_accessor :viewportPopups
#--------------------------------------------------------------------------
# alias method: create_viewports
#--------------------------------------------------------------------------
alias spriteset_battle_create_viewports_abe create_viewports
def create_viewports
spriteset_battle_create_viewports_abe
@viewportPopups = Viewport.new
@viewportPopups.z = 200
end
#--------------------------------------------------------------------------
# alias method: dispose_viewports
#--------------------------------------------------------------------------
alias spriteset_battle_dispose_viewports_abe dispose_viewports
def dispose_viewports
spriteset_battle_dispose_viewports_abe
@viewportPopups.dispose
end
#--------------------------------------------------------------------------
# alias method: update_viewports
#--------------------------------------------------------------------------
alias spriteset_battle_update_viewports_abe update_viewports
def update_viewports
spriteset_battle_update_viewports_abe
@viewportPopups.update
end
end # Spriteset_Battle
#==============================================================================
# ■ Game_Temp
#==============================================================================
class Game_Temp
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :battle_aid
attr_accessor :evaluating
attr_accessor :iconset
#--------------------------------------------------------------------------
# alias method: initialize
#--------------------------------------------------------------------------
alias game_temp_initialize_abe initialize
def initialize
game_temp_initialize_abe
@iconset = Cache.system("Iconset")
end
end # Game_Temp
#==============================================================================
# ■ Game_Action
#==============================================================================
class Game_Action
#--------------------------------------------------------------------------
# overwrite method: speed
#--------------------------------------------------------------------------
def speed
speed = subject.agi
speed += item.speed if item
speed += subject.atk_speed if attack?
return speed
end
#--------------------------------------------------------------------------
# alias method: evaluate_item_with_target
#--------------------------------------------------------------------------
alias evaluate_item_with_target_abe evaluate_item_with_target
def evaluate_item_with_target(target)
$game_temp.evaluating = true
result = evaluate_item_with_target_abe(target)
$game_temp.evaluating = false
return result
end
end # Game_Action
#==============================================================================
# ■ Game_ActionResult
#==============================================================================
class Game_ActionResult
#--------------------------------------------------------------------------
# alias method: clear
#--------------------------------------------------------------------------
alias game_actionresult_clear_abe clear
def clear
game_actionresult_clear_abe
clear_stored_damage
end
#--------------------------------------------------------------------------
# new method: clear_stored_damage
#--------------------------------------------------------------------------
def clear_stored_damage
@stored_hp_damage = 0
@stored_mp_damage = 0
@stored_tp_damage = 0
@stored_hp_drain = 0
@stored_mp_drain = 0
end
#--------------------------------------------------------------------------
# new method: store_damage
#--------------------------------------------------------------------------
def store_damage
@stored_hp_damage += @hp_damage
@stored_mp_damage += @mp_damage
@stored_tp_damage += @tp_damage
@stored_hp_drain += @hp_drain
@stored_mp_drain += @mp_drain
end
#--------------------------------------------------------------------------
# new method: restore_damage
#--------------------------------------------------------------------------
def restore_damage
@hp_damage = @stored_hp_damage
@mp_damage = @stored_mp_damage
@tp_damage = @stored_tp_damage
@hp_drain = @stored_hp_drain
@mp_drain = @stored_mp_drain
end
end # Game_ActionResult
#==============================================================================
# ■ Game_BattlerBase
#==============================================================================
class Game_BattlerBase
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :popups
#--------------------------------------------------------------------------
# new method: create_popup
#--------------------------------------------------------------------------
def create_popup(value, rules = "DEFAULT", flags = [])
return unless SceneManager.scene_is?(Scene_Battle)
return unless YEA::BATTLE::ENABLE_POPUPS
return if Switch.hide_popups
@popups = [] if @popups.nil?
@popups.push([value, rules, flags])
end
#--------------------------------------------------------------------------
# new method: make_damage_popups
#--------------------------------------------------------------------------
def make_damage_popups(user)
if @result.hp_drain != 0
text = YEA::BATTLE::POPUP_SETTINGS[:drained]
rules = "DRAIN"
user.create_popup(text, rules)
setting = :hp_dmg if @result.hp_drain < 0
setting = :hp_heal if @result.hp_drain > 0
rules = "HP_DMG" if @result.hp_drain < 0
rules = "HP_HEAL" if @result.hp_drain > 0
value = @result.hp_drain.abs
text = sprintf(YEA::BATTLE::POPUP_SETTINGS[setting], value.group)
user.create_popup(text, rules)
end
if @result.mp_drain != 0
text = YEA::BATTLE::POPUP_SETTINGS[:drained]
rules = "DRAIN"
user.create_popup(text, rules)
setting = :mp_dmg if @result.mp_drain < 0
setting = :mp_heal if @result.mp_drain > 0
rules = "HP_DMG" if @result.mp_drain < 0
rules = "HP_HEAL" if @result.mp_drain > 0
value = @result.mp_drain.abs
text = sprintf(YEA::BATTLE::POPUP_SETTINGS[setting], value.group)
user.create_popup(text, rules)
end
#---
flags = []
flags.push("critical") if @result.critical
if @result.hp_damage != 0
setting = :hp_dmg if @result.hp_damage > 0
setting = :hp_heal if @result.hp_damage < 0
rules = "HP_DMG" if @result.hp_damage > 0
rules = "HP_HEAL" if @result.hp_damage < 0
value = @result.hp_damage.abs
text = sprintf(YEA::BATTLE::POPUP_SETTINGS[setting], value.group)
create_popup(text, rules, flags)
end
if @result.mp_damage != 0
setting = :mp_dmg if @result.mp_damage > 0
setting = :mp_heal if @result.mp_damage < 0
rules = "MP_DMG" if @result.mp_damage > 0
rules = "MP_HEAL" if @result.mp_damage < 0
value = @result.mp_damage.abs
text = sprintf(YEA::BATTLE::POPUP_SETTINGS[setting], value.group)
create_popup(text, rules, flags)
end
if @result.tp_damage != 0
setting = :tp_dmg if @result.tp_damage > 0
setting = :tp_heal if @result.tp_damage < 0
rules = "TP_DMG" if @result.tp_damage > 0
rules = "TP_HEAL" if @result.tp_damage < 0
value = @result.tp_damage.abs
text = sprintf(YEA::BATTLE::POPUP_SETTINGS[setting], value.group)
create_popup(text, rules)
end
@result.store_damage
@result.clear_damage_values
end
#--------------------------------------------------------------------------
# alias method: erase_state
#--------------------------------------------------------------------------
alias game_battlerbase_erase_state_abe erase_state
def erase_state(state_id)
make_state_popup(state_id, :rem_state) if @states.include?(state_id)
game_battlerbase_erase_state_abe(state_id)
end
#--------------------------------------------------------------------------
# new method: make_during_state_popup
#--------------------------------------------------------------------------
def make_during_state_popup
state_id = most_important_state_id
return if state_id == 0
make_state_popup(state_id, :dur_state)
end
#--------------------------------------------------------------------------
# new method: most_important_state_id
#--------------------------------------------------------------------------
def most_important_state_id
states.each {|state| return state.id unless state.message3.empty? }
return 0
end
#--------------------------------------------------------------------------
# new method: make_state_popup
#--------------------------------------------------------------------------
def make_state_popup(state_id, type)
state = $data_states[state_id]
return if state.icon_index == 0
rules = state.popup_rules[type]
return if rules.nil?
text = sprintf(YEA::BATTLE::POPUP_SETTINGS[type], state.name)
flags = ["state", state.icon_index]
create_popup(text, rules, flags)
end
#--------------------------------------------------------------------------
# new method: make_miss_popups
#--------------------------------------------------------------------------
def make_miss_popups(user, item)
return if dead?
if @result.missed
text = YEA::BATTLE::POPUP_SETTINGS[:missed]
rules = "DEFAULT"
create_popup(text, rules)
end
if @result.evaded
text = YEA::BATTLE::POPUP_SETTINGS[:evaded]
rules = "DEFAULT"
create_popup(text, rules)
end
if @result.hit? && [email protected]
text = YEA::BATTLE::POPUP_SETTINGS[:failed]
rules = "DEFAULT"
create_popup(text, rules)
end
if @result.hit? && item.damage.to_hp?
if @result.hp_damage == 0 && @result.hp_damage == 0
text = YEA::BATTLE::POPUP_SETTINGS[:nulled]
rules = "DEFAULT"
create_popup(text, rules)
end
end
end
#--------------------------------------------------------------------------
# new method: make_rate_popup
#--------------------------------------------------------------------------
def make_rate_popup(rate)
return if rate == 1.0
flags = []
if rate > 1.0
text = YEA::BATTLE::POPUP_SETTINGS[:weakpoint]
rules = "WEAK_ELE"
flags.push("weakness")
elsif rate == 0.0
text = YEA::BATTLE::POPUP_SETTINGS[:immune]
rules = "IMMU_ELE"
flags.push("immune")
elsif rate < 0.0
text = YEA::BATTLE::POPUP_SETTINGS[:absorbed]
rules = "ABSB_ELE"
flags.push("absorbed")
else
text = YEA::BATTLE::POPUP_SETTINGS[:resistant]
rules = "REST_ELE"
flags.push("resistant")
end
create_popup(text, rules, flags)
end
#--------------------------------------------------------------------------
# new method: make_buff_popup
#--------------------------------------------------------------------------
def make_buff_popup(param_id, positive = true)
return unless alive?
name = Vocab::param(param_id)
if positive
text = sprintf(YEA::BATTLE::POPUP_SETTINGS[:add_buff], name)
rules = "BUFF"
buff_level = 1
else
text = sprintf(YEA::BATTLE::POPUP_SETTINGS[:add_debuff], name)
rules = "DEBUFF"
buff_level = -1
end
icon = buff_icon_index(buff_level, param_id)
flags = ["buff", icon]
create_popup(text, rules, flags)
end
end # Game_BattlerBase
#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :pseudo_ani_id
#--------------------------------------------------------------------------
# alias method: on_battle_end
#--------------------------------------------------------------------------
alias game_battler_on_battle_end_abe on_battle_end
def on_battle_end
game_battler_on_battle_end_abe
@popups = []
end
#--------------------------------------------------------------------------
# alias method: clear_sprite_effects
#--------------------------------------------------------------------------
alias game_battler_clear_sprite_effects_abe clear_sprite_effects
def clear_sprite_effects
game_battler_clear_sprite_effects_abe
@pseudo_ani_id = 0
end
#--------------------------------------------------------------------------
# alias method: item_apply
#--------------------------------------------------------------------------
alias game_battler_item_apply_abe item_apply
def item_apply(user, item)
game_battler_item_apply_abe(user, item)
make_miss_popups(user, item)
end
#--------------------------------------------------------------------------
# alias method: make_damage_value
#--------------------------------------------------------------------------
alias game_battler_make_damage_value_abe make_damage_value
def make_damage_value(user, item)
game_battler_make_damage_value_abe(user, item)
rate = item_element_rate(user, item)
make_rate_popup(rate) unless $game_temp.evaluating
end
#--------------------------------------------------------------------------
# alias method: execute_damage
#--------------------------------------------------------------------------
alias game_battler_execute_damage_abe execute_damage
def execute_damage(user)
game_battler_execute_damage_abe(user)
make_damage_popups(user)
end
#--------------------------------------------------------------------------
# alias method: item_effect_recover_hp
#--------------------------------------------------------------------------
alias game_battler_item_effect_recover_hp_abe item_effect_recover_hp
def item_effect_recover_hp(user, item, effect)
game_battler_item_effect_recover_hp_abe(user, item, effect)
make_damage_popups(user)
end
#--------------------------------------------------------------------------
# alias method: item_effect_recover_mp
#--------------------------------------------------------------------------
alias game_battler_item_effect_recover_mp_abe item_effect_recover_mp
def item_effect_recover_mp(user, item, effect)
game_battler_item_effect_recover_mp_abe(user, item, effect)
make_damage_popups(user)
end
#--------------------------------------------------------------------------
# alias method: item_effect_gain_tp
#--------------------------------------------------------------------------
alias game_battler_item_effect_gain_tp_abe item_effect_gain_tp
def item_effect_gain_tp(user, item, effect)
game_battler_item_effect_gain_tp_abe(user, item, effect)
make_damage_popups(user)
end
#--------------------------------------------------------------------------
# alias method: item_user_effect
#--------------------------------------------------------------------------
alias game_battler_item_user_effect_abe item_user_effect
def item_user_effect(user, item)
game_battler_item_user_effect_abe(user, item)
@result.restore_damage
end
#--------------------------------------------------------------------------
# alias method: add_new_state
#--------------------------------------------------------------------------
alias game_battler_add_new_state_abe add_new_state
def add_new_state(state_id)
game_battler_add_new_state_abe(state_id)
make_state_popup(state_id, :add_state) if @states.include?(state_id)
end
#--------------------------------------------------------------------------
# alias method: add_buff
#--------------------------------------------------------------------------
alias game_battler_add_buff_abe add_buff
def add_buff(param_id, turns)
make_buff_popup(param_id, true)
game_battler_add_buff_abe(param_id, turns)
end
#--------------------------------------------------------------------------
# alias method: add_debuff
#--------------------------------------------------------------------------
alias game_battler_add_debuff_abe add_debuff
def add_debuff(param_id, turns)
make_buff_popup(param_id, false)
game_battler_add_debuff_abe(param_id, turns)
end
#--------------------------------------------------------------------------
# alias method: regenerate_all
#--------------------------------------------------------------------------
alias game_battler_regenerate_all_abe regenerate_all
def regenerate_all
game_battler_regenerate_all_abe
return unless alive?
make_damage_popups(self)
end
#--------------------------------------------------------------------------
# new method: can_collapse?
#--------------------------------------------------------------------------
def can_collapse?
return false unless dead?
unless actor?
return false unless sprite.battler_visible
array = [:collapse, :boss_collapse, :instant_collapse]
return false if array.include?(sprite.effect_type)
end
return true
end
#--------------------------------------------------------------------------
# new method: draw_mp?
#--------------------------------------------------------------------------
def draw_mp?; return true; end
#--------------------------------------------------------------------------
# new method: draw_tp?
#--------------------------------------------------------------------------
def draw_tp?
return $data_system.opt_display_tp
end
end # Game_Battler
#==============================================================================
# ■ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
#def battler_name
#return "Slime"
#end
#def battler_hue
#return 0
#end
#--------------------------------------------------------------------------
# overwrite method: perform_damage_effect
#--------------------------------------------------------------------------
def perform_damage_effect
$game_troop.screen.start_shake(5, 5, 10) if YEA::BATTLE::SCREEN_SHAKE
@sprite_effect_type = :blink if YEA::BATTLE::BLINK_EFFECTS
Sound.play_actor_damage
end
#--------------------------------------------------------------------------
# overwrite method: use_sprite?
#--------------------------------------------------------------------------
def use_sprite?; return true; end
#--------------------------------------------------------------------------
# new method: screen_x
#--------------------------------------------------------------------------
def screen_x
return 0 unless SceneManager.scene_is?(Scene_Battle)
status_window = SceneManager.scene.status_window
return 0 if status_window.nil?
item_rect_width = (status_window.width-24) / $game_party.max_battle_members
ext = SceneManager.scene.info_viewport.ox
rect = SceneManager.scene.status_window.item_rect(self.index)
constant = 128 + 12
return constant + rect.x + item_rect_width / 2 - ext
end
#--------------------------------------------------------------------------
# new method: screen_y
#--------------------------------------------------------------------------
def screen_y
return Graphics.height - 120 unless SceneManager.scene_is?(Scene_Battle)
return Graphics.height - 120 if SceneManager.scene.status_window.nil?
return Graphics.height - (SceneManager.scene.status_window.height * 7/8)
end
#--------------------------------------------------------------------------
# new method: screen_z
#--------------------------------------------------------------------------
def screen_z; return 100; end
#--------------------------------------------------------------------------
# new method: sprite
#--------------------------------------------------------------------------
def sprite
index = $game_party.battle_members.index(self)
return SceneManager.scene.spriteset.actor_sprites[index]
end
#--------------------------------------------------------------------------
# new method: draw_mp?
#--------------------------------------------------------------------------
def draw_mp?
return true unless draw_tp?
for skill in skills
next unless added_skill_types.include?(skill.stype_id)
return true if skill.mp_cost > 0
end
return false
end
#--------------------------------------------------------------------------
# new method: draw_tp?
#--------------------------------------------------------------------------
def draw_tp?
return false unless $data_system.opt_display_tp
for skill in skills
next unless added_skill_types.include?(skill.stype_id)
return true if skill.tp_cost > 0
end
return false
end
end # Game_Actor
#==============================================================================
# ■ Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# overwrite method: perform_damage_effect
#--------------------------------------------------------------------------
def perform_damage_effect
@sprite_effect_type = :blink if YEA::BATTLE::BLINK_EFFECTS
Sound.play_enemy_damage
end
#--------------------------------------------------------------------------
# new methods: attack_animation_id
#--------------------------------------------------------------------------
def atk_animation_id1; return enemy.atk_animation_id1; end
def atk_animation_id2; return enemy.atk_animation_id2; end
#--------------------------------------------------------------------------
# new method: sprite
#--------------------------------------------------------------------------
def sprite
return SceneManager.scene.spriteset.enemy_sprites.reverse[self.index]
end
end # Game_Enemy
#==============================================================================
# ■ Game_Unit
#==============================================================================
class Game_Unit
#--------------------------------------------------------------------------
# alias method: make_actions
#--------------------------------------------------------------------------
alias game_unit_make_actions_abe make_actions
def make_actions
game_unit_make_actions_abe
refresh_autobattler_status_window
end
#--------------------------------------------------------------------------
# new method: refresh_autobattler_status_window
#--------------------------------------------------------------------------
def refresh_autobattler_status_window
return unless SceneManager.scene_is?(Scene_Battle)
return unless self.is_a?(Game_Party)
SceneManager.scene.refresh_autobattler_status_window
end
end # Game_Unit
#==============================================================================
# ■ Window_PartyCommand
#==============================================================================
class Window_PartyCommand < Window_Command
#--------------------------------------------------------------------------
# overwrite method: process_handling
#--------------------------------------------------------------------------
def process_handling
return unless open? && active
return process_dir6 if Input.repeat?(:RIGHT)
return super
end
#--------------------------------------------------------------------------
# new method: process_dir6
#--------------------------------------------------------------------------
def process_dir6
Sound.play_cursor
Input.update
deactivate
call_handler(:dir6)
end
end # Window_PartyCommand
#==============================================================================
# ■ Window_ActorCommand
#==============================================================================
class Window_ActorCommand < Window_Command
#--------------------------------------------------------------------------
# overwrite method: process_handling
#--------------------------------------------------------------------------
def process_handling
return unless open? && active
return process_dir4 if Input.repeat?(:LEFT)
return process_dir6 if Input.repeat?(:RIGHT)
return super
end
#--------------------------------------------------------------------------
# new method: process_dir4
#--------------------------------------------------------------------------
def process_dir4
Sound.play_cursor
Input.update
deactivate
call_handler(:cancel)
end
#--------------------------------------------------------------------------
# new method: process_dir6
#--------------------------------------------------------------------------
def process_dir6
Sound.play_cursor
Input.update
deactivate
call_handler(:dir6)
end
end # Window_ActorCommand
#==============================================================================
# ■ Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Selectable
#--------------------------------------------------------------------------
# overwrite method: initialize
#--------------------------------------------------------------------------
def initialize
super(0, 0, window_width, window_height)
self.openness = 0
@party = $game_party.battle_members.clone
end
#--------------------------------------------------------------------------
# overwrite method: col_max
#--------------------------------------------------------------------------
def col_max; return $game_party.max_battle_members; end
#--------------------------------------------------------------------------
# new method: battle_members
#--------------------------------------------------------------------------
def battle_members; return $game_party.battle_members; end
#--------------------------------------------------------------------------
# new method: actor
#--------------------------------------------------------------------------
def actor; return battle_members[@index]; end
#--------------------------------------------------------------------------
# overwrite method: update
#--------------------------------------------------------------------------
def update
super
return if @party == $game_party.battle_members
@party = $game_party.battle_members.clone
refresh
end
#--------------------------------------------------------------------------
# overwrite method: draw_item
#--------------------------------------------------------------------------
def draw_item(index)
return if index.nil?
clear_item(index)
actor = battle_members[index]
rect = item_rect(index)
return if actor.nil?
draw_actor_face(actor, rect.x+2, rect.y+2, actor.alive?)
draw_actor_name(actor, rect.x, rect.y, rect.width-8)
draw_actor_action(actor, rect.x, rect.y)
draw_actor_icons(actor, rect.x, line_height*1, rect.width)
gx = YEA::BATTLE::BATTLESTATUS_HPGAUGE_Y_PLUS
contents.font.size = YEA::BATTLE::BATTLESTATUS_TEXT_FONT_SIZE
draw_actor_hp(actor, rect.x+2, line_height*2+gx, rect.width-4)
if draw_tp?(actor) && draw_mp?(actor)
dw = rect.width/2-2
dw += 1 if $imported["YEA-CoreEngine"] && YEA::CORE::GAUGE_OUTLINE
draw_actor_tp(actor, rect.x+2, line_height*3, dw)
dw = rect.width - rect.width/2 - 2
draw_actor_mp(actor, rect.x+rect.width/2, line_height*3, dw)
elsif draw_tp?(actor) && !draw_mp?(actor)
draw_actor_tp(actor, rect.x+2, line_height*3, rect.width-4)
else
draw_actor_mp(actor, rect.x+2, line_height*3, rect.width-4)
end
end
#--------------------------------------------------------------------------
# overwrite method: item_rect
#--------------------------------------------------------------------------
def item_rect(index)
rect = Rect.new
rect.width = contents.width / $game_party.max_battle_members
rect.height = contents.height
rect.x = index * rect.width
if YEA::BATTLE::BATTLESTATUS_CENTER_FACES
rect.x += (contents.width - $game_party.members.size * rect.width) / 2
end
rect.y = 0
return rect
end
#--------------------------------------------------------------------------
# overwrite method: draw_face
#--------------------------------------------------------------------------
def draw_face(face_name, face_index, dx, dy, enabled = true)
bitmap = Cache.face(face_name)
fx = [(96 - item_rect(0).width + 1) / 2, 0].max
fy = face_index / 4 * 96 + 2
fw = [item_rect(0).width - 4, 92].min
rect = Rect.new(fx, fy, fw, 92)
rect = Rect.new(face_index % 4 * 96 + fx, fy, fw, 92)
contents.blt(dx, dy, bitmap, rect, enabled ? 255 : translucent_alpha)
bitmap.dispose
end
#--------------------------------------------------------------------------
# overwrite method: draw_actor_name
#--------------------------------------------------------------------------
def draw_actor_name(actor, dx, dy, dw = 112)
reset_font_settings
contents.font.size = YEA::BATTLE::BATTLESTATUS_NAME_FONT_SIZE
change_color(hp_color(actor))
draw_text(dx+24, dy, dw-24, line_height, actor.name)
end
#--------------------------------------------------------------------------
# new method: draw_actor_action
#--------------------------------------------------------------------------
def draw_actor_action(actor, dx, dy)
draw_icon(action_icon(actor), dx, dy)
end
#--------------------------------------------------------------------------
# new method: action_icon
#--------------------------------------------------------------------------
def action_icon(actor)
return Icon.no_action if actor.current_action.nil?
return Icon.no_action if actor.current_action.item.nil?
return actor.current_action.item.icon_index
end
#--------------------------------------------------------------------------
# new method: draw_tp?
#--------------------------------------------------------------------------
def draw_tp?(actor)
return actor.draw_tp?
end
#--------------------------------------------------------------------------
# new method: draw_mp?
#--------------------------------------------------------------------------
def draw_mp?(actor)
return actor.draw_mp?
end
#--------------------------------------------------------------------------
# overwrite method: draw_current_and_max_values
#--------------------------------------------------------------------------
def draw_current_and_max_values(dx, dy, dw, current, max, color1, color2)
change_color(color1)
draw_text(dx, dy, dw, line_height, current.group, 2)
end
#--------------------------------------------------------------------------
# overwrite method: draw_actor_hp
#--------------------------------------------------------------------------
def draw_actor_hp(actor, dx, dy, width = 124)
draw_gauge(dx, dy, width, actor.hp_rate, hp_gauge_color1, hp_gauge_color2)
change_color(system_color)
cy = (Font.default_size - contents.font.size) / 2 + 1
draw_text(dx+2, dy+cy, 30, line_height, Vocab::hp_a)
draw_current_and_max_values(dx, dy+cy, width, actor.hp, actor.mhp,
hp_color(actor), normal_color)
end
#--------------------------------------------------------------------------
# overwrite method: draw_actor_mp
#--------------------------------------------------------------------------
def draw_actor_mp(actor, dx, dy, width = 124)
draw_gauge(dx, dy, width, actor.mp_rate, mp_gauge_color1, mp_gauge_color2)
change_color(system_color)
cy = (Font.default_size - contents.font.size) / 2 + 1
draw_text(dx+2, dy+cy, 30, line_height, Vocab::mp_a)
draw_current_and_max_values(dx, dy+cy, width, actor.mp, actor.mmp,
mp_color(actor), normal_color)
end
#--------------------------------------------------------------------------
# overwrite method: draw_actor_tp
#--------------------------------------------------------------------------
def draw_actor_tp(actor, dx, dy, width = 124)
draw_gauge(dx, dy, width, actor.tp_rate, tp_gauge_color1, tp_gauge_color2)
change_color(system_color)
cy = (Font.default_size - contents.font.size) / 2 + 1
draw_text(dx+2, dy+cy, 30, line_height, Vocab::tp_a)
change_color(tp_color(actor))
draw_text(dx + width - 42, dy+cy, 42, line_height, actor.tp.to_i, 2)
end
end # Window_BattleStatus
#==============================================================================
# ■ Window_BattleActor
#==============================================================================
class Window_BattleActor < Window_BattleStatus
#--------------------------------------------------------------------------
# overwrite method: show
#--------------------------------------------------------------------------
def show
create_flags
super
end
#--------------------------------------------------------------------------
# new method: create_flags
#--------------------------------------------------------------------------
def create_flags
set_select_flag(:any)
select(0)
return if $game_temp.battle_aid.nil?
if $game_temp.battle_aid.need_selection?
select(0)
set_select_flag(:dead) if $game_temp.battle_aid.for_dead_friend?
elsif $game_temp.battle_aid.for_user?
battler = BattleManager.actor
id = battler.nil? ? 0 : $game_party.battle_members.index(battler)
select(id)
set_select_flag(:user)
elsif $game_temp.battle_aid.for_all?
select(0)
set_select_flag(:all)
set_select_flag(:all_dead) if $game_temp.battle_aid.for_dead_friend?
elsif $game_temp.battle_aid.for_random?
select(0)
set_select_flag(:random) if $game_temp.battle_aid.for_random?
end
end
#--------------------------------------------------------------------------
# new method: set_flag
#--------------------------------------------------------------------------
def set_select_flag(flag)
@select_flag = flag
case @select_flag
when :all, :all_dead, :random
@cursor_all = true
else
@cursor_all = false
end
end
#--------------------------------------------------------------------------
# overwrite method: update_cursor
#--------------------------------------------------------------------------
def update_cursor
if @cursor_all
cursor_rect.set(0, 0, contents.width, contents.height)
self.top_row = 0
elsif @index < 0
cursor_rect.empty
else
ensure_cursor_visible
cursor_rect.set(item_rect(@index))
end
end
#--------------------------------------------------------------------------
# overwrite method: cursor_movable?
#--------------------------------------------------------------------------
def cursor_movable?
return false if @select_flag == :user
return super
end
#--------------------------------------------------------------------------
# overwrite method: current_item_enabled?
#--------------------------------------------------------------------------
def current_item_enabled?
return true if $game_temp.battle_aid.nil?
if $game_temp.battle_aid.need_selection?
member = $game_party.battle_members[@index]
return member.dead? if $game_temp.battle_aid.for_dead_friend?
elsif $game_temp.battle_aid.for_dead_friend?
for member in $game_party.battle_members
return true if member.dead?
end
return false
end
return true
end
end # Window_BattleActor
#==============================================================================
# ■ Window_BattleStatusAid
#==============================================================================
class Window_BattleStatusAid < Window_BattleStatus
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :status_window
#--------------------------------------------------------------------------
# overwrite method: initialize
#--------------------------------------------------------------------------
def initialize
super
self.visible = false
self.openness = 255
end
#--------------------------------------------------------------------------
# overwrite method: window_width
#--------------------------------------------------------------------------
def window_width; return 128; end
#--------------------------------------------------------------------------
# overwrite method: show
#--------------------------------------------------------------------------
def show
super
refresh
end
#--------------------------------------------------------------------------
# overwrite method: refresh
#--------------------------------------------------------------------------
def refresh
contents.clear
return if @status_window.nil?
draw_item(@status_window.index)
end
#--------------------------------------------------------------------------
# overwrite method: item_rect
#--------------------------------------------------------------------------
def item_rect(index)
return Rect.new(0, 0, contents.width, contents.height)
end
end # Window_BattleStatusAid
#==============================================================================
# ■ Window_BattleEnemy
#==============================================================================
class Window_BattleEnemy < Window_Selectable
#--------------------------------------------------------------------------
# overwrite method: initialize
#--------------------------------------------------------------------------
def initialize(info_viewport)
super(0, Graphics.height, window_width, fitting_height(1))
refresh
self.visible = false
@info_viewport = info_viewport
end
#--------------------------------------------------------------------------
# overwrite method: col_max
#--------------------------------------------------------------------------
def col_max; return item_max; end
#--------------------------------------------------------------------------
# overwrite method: show
#--------------------------------------------------------------------------
def show
create_flags
super
end
#--------------------------------------------------------------------------
# new method: create_flags
#--------------------------------------------------------------------------
def create_flags
set_select_flag(:any)
select(0)
return if $game_temp.battle_aid.nil?
if $game_temp.battle_aid.need_selection?
select(0)
elsif $game_temp.battle_aid.for_all?
select(0)
set_select_flag(:all)
elsif $game_temp.battle_aid.for_random?
select(0)
set_select_flag(:random)
end
end
#--------------------------------------------------------------------------
# new method: set_flag
#--------------------------------------------------------------------------
def set_select_flag(flag)
@select_flag = flag
case @select_flag
when :all, :random
@cursor_all = true
else
@cursor_all = false
end
end
#--------------------------------------------------------------------------
# new method: select_all?
#--------------------------------------------------------------------------
def select_all?
return true if @select_flag == :all
return true if @select_flag == :random
return false
end
#--------------------------------------------------------------------------
# overwrite method: update_cursor
#--------------------------------------------------------------------------
def update_cursor
if @cursor_all
cursor_rect.set(0, 0, contents.width, contents.height)
self.top_row = 0
elsif @index < 0
cursor_rect.empty
else
ensure_cursor_visible
cursor_rect.set(item_rect(@index))
end
end
#--------------------------------------------------------------------------
# overwrite method: cursor_movable?
#--------------------------------------------------------------------------
def cursor_movable?
return false if @select_flag == :user
return super
end
#--------------------------------------------------------------------------
# overwrite method: current_item_enabled?
#--------------------------------------------------------------------------
def current_item_enabled?
return true if $game_temp.battle_aid.nil?
if $game_temp.battle_aid.need_selection?
member = $game_party.battle_members[@index]
return member.dead? if $game_temp.battle_aid.for_dead_friend?
elsif $game_temp.battle_aid.for_dead_friend?
for member in $game_party.battle_members
return true if member.dead?
end
return false
end
return true
end
#--------------------------------------------------------------------------
# overwrite method: enemy
#--------------------------------------------------------------------------
def enemy; @data[index]; end
#--------------------------------------------------------------------------
# overwrite method: refresh
#--------------------------------------------------------------------------
def refresh
make_item_list
create_contents
draw_all_items
end
#--------------------------------------------------------------------------
# overwrite method: make_item_list
#--------------------------------------------------------------------------
def make_item_list
@data = $game_troop.alive_members
@data.sort! { |a,b| a.screen_x <=> b.screen_x }
end
#--------------------------------------------------------------------------
# overwrite method: draw_item
#--------------------------------------------------------------------------
def draw_item(index); return; end
#--------------------------------------------------------------------------
# overwrite method: update
#--------------------------------------------------------------------------
def update
super
return unless active
enemy.sprite_effect_type = :whiten
return unless select_all?
for enemy in $game_troop.alive_members
enemy.sprite_effect_type = :whiten
end
end
end # Window_BattleEnemy
#==============================================================================
# ■ Window_BattleHelp
#==============================================================================
class Window_BattleHelp < Window_Help
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :actor_window
attr_accessor :enemy_window
#--------------------------------------------------------------------------
# update
#--------------------------------------------------------------------------
def update
super
if !self.visible and @text != ""
@text = ""
return refresh
end
update_battler_name
end
#--------------------------------------------------------------------------
# update_battler_name
#--------------------------------------------------------------------------
def update_battler_name
return unless @actor_window.active || @enemy_window.active
if @actor_window.active
battler = $game_party.battle_members[@actor_window.index]
elsif @enemy_window.active
battler = @enemy_window.enemy
end
if special_display?
refresh_special_case(battler)
else
refresh_battler_name(battler) if battler_name(battler) != @text
end
end
#--------------------------------------------------------------------------
# battler_name
#--------------------------------------------------------------------------
def battler_name(battler)
text = battler.name.clone
return text
end
#--------------------------------------------------------------------------
# refresh_battler_name
#--------------------------------------------------------------------------
def refresh_battler_name(battler)
contents.clear
reset_font_settings
change_color(normal_color)
@text = battler_name(battler)
icons = battler.state_icons + battler.buff_icons
dy = icons.size <= 0 ? line_height / 2 : 0
draw_text(0, dy, contents.width, line_height, @text, 1)
dx = (contents.width - (icons.size * 24)) / 2
draw_actor_icons(battler, dx, line_height, contents.width)
end
#--------------------------------------------------------------------------
# special_display?
#--------------------------------------------------------------------------
def special_display?
return false if $game_temp.battle_aid.nil?
return false if $game_temp.battle_aid.for_user?
return !$game_temp.battle_aid.need_selection?
end
#--------------------------------------------------------------------------
# refresh_special_case
#--------------------------------------------------------------------------
def refresh_special_case(battler)
if $game_temp.battle_aid.for_opponent?
if $game_temp.battle_aid.for_all?
text = YEA::BATTLE::HELP_TEXT_ALL_FOES
else
case $game_temp.battle_aid.number_of_targets
when 1
text = YEA::BATTLE::HELP_TEXT_ONE_RANDOM_FOE
else
number = $game_temp.battle_aid.number_of_targets
text = sprintf(YEA::BATTLE::HELP_TEXT_MANY_RANDOM_FOE, number)
end
end
else # $game_temp.battle_aid.for_friend?
if $game_temp.battle_aid.for_dead_friend?
text = YEA::BATTLE::HELP_TEXT_ALL_DEAD_ALLIES
elsif $game_temp.battle_aid.for_random?
case $game_temp.battle_aid.number_of_targets
when 1
text = YEA::BATTLE::HELP_TEXT_ONE_RANDOM_ALLY
else
number = $game_temp.battle_aid.number_of_targets
text = sprintf(YEA::BATTLE::HELP_TEXT_RANDOM_ALLIES, number)
end
else
text = YEA::BATTLE::HELP_TEXT_ALL_ALLIES
end
end
return if text == @text
@text = text
contents.clear
reset_font_settings
draw_text(0, 0, contents.width, line_height*2, @text, 1)
end
end # Window_BattleHelp
#==============================================================================
# ■ Window_BattleLog
#==============================================================================
class Window_BattleLog < Window_Selectable
#--------------------------------------------------------------------------
# alias method: display_current_state
#--------------------------------------------------------------------------
alias window_battlelog_display_current_state_abe display_current_state
def display_current_state(subject)
subject.make_during_state_popup
return unless YEA::BATTLE::MSG_CURRENT_STATE
window_battlelog_display_current_state_abe(subject)
end
#--------------------------------------------------------------------------
# alias method: display_use_item
#--------------------------------------------------------------------------
alias window_battlelog_display_use_item_abe display_use_item
def display_use_item(subject, item)
return unless YEA::BATTLE::MSG_CURRENT_ACTION
window_battlelog_display_use_item_abe(subject, item)
end
#--------------------------------------------------------------------------
# alias method: display_counter
#--------------------------------------------------------------------------
alias window_battlelog_display_counter_abe display_counter
def display_counter(target, item)
if YEA::BATTLE::MSG_COUNTERATTACK
window_battlelog_display_counter_abe(target, item)
else
Sound.play_evasion
end
end
#--------------------------------------------------------------------------
# alias method: display_reflection
#--------------------------------------------------------------------------
alias window_battlelog_display_reflection_abe display_reflection
def display_reflection(target, item)
if YEA::BATTLE::MSG_REFLECT_MAGIC
window_battlelog_display_reflection_abe(target, item)
else
Sound.play_reflection
end
end
#--------------------------------------------------------------------------
# alias method: display_substitute
#--------------------------------------------------------------------------
alias window_battlelog_display_substitute_abe display_substitute
def display_substitute(substitute, target)
return unless YEA::BATTLE::MSG_SUBSTITUTE_HIT
window_battlelog_display_substitute_abe(substitute, target)
end
#--------------------------------------------------------------------------
# alias method: display_failure
#--------------------------------------------------------------------------
alias window_battlelog_display_failure_abe display_failure
def display_failure(target, item)
return unless YEA::BATTLE::MSG_FAILURE_HIT
window_battlelog_display_failure_abe(target, item)
end
#--------------------------------------------------------------------------
# alias method: display_critical
#--------------------------------------------------------------------------
alias window_battlelog_display_critical_abe display_critical
def display_critical(target, item)
return unless YEA::BATTLE::MSG_CRITICAL_HIT
window_battlelog_display_critical_abe(target, item)
end
#--------------------------------------------------------------------------
# alias method: display_miss
#--------------------------------------------------------------------------
alias window_battlelog_display_miss_abe display_miss
def display_miss(target, item)
return unless YEA::BATTLE::MSG_HIT_MISSED
window_battlelog_display_miss_abe(target, item)
end
#--------------------------------------------------------------------------
# alias method: display_evasion
#--------------------------------------------------------------------------
alias window_battlelog_display_evasion_abe display_evasion
def display_evasion(target, item)
if YEA::BATTLE::MSG_EVASION
window_battlelog_display_evasion_abe(target, item)
else
if !item || item.physical?
Sound.play_evasion
else
Sound.play_magic_evasion
end
end
end
#--------------------------------------------------------------------------
# overwrite method: display_hp_damage
#--------------------------------------------------------------------------
def display_hp_damage(target, item)
return if target.result.hp_damage == 0 && item && !item.damage.to_hp?
if target.result.hp_damage > 0 && target.result.hp_drain == 0
target.perform_damage_effect
end
Sound.play_recovery if target.result.hp_damage < 0
return unless YEA::BATTLE::MSG_HP_DAMAGE
add_text(target.result.hp_damage_text)
wait
end
#--------------------------------------------------------------------------
# overwrite method: display_mp_damage
#--------------------------------------------------------------------------
def display_mp_damage(target, item)
return if target.dead? || target.result.mp_damage == 0
Sound.play_recovery if target.result.mp_damage < 0
return unless YEA::BATTLE::MSG_MP_DAMAGE
add_text(target.result.mp_damage_text)
wait
end
#--------------------------------------------------------------------------
# overwrite method: display_tp_damage
#--------------------------------------------------------------------------
def display_tp_damage(target, item)
return if target.dead? || target.result.tp_damage == 0
Sound.play_recovery if target.result.tp_damage < 0
return unless YEA::BATTLE::MSG_TP_DAMAGE
add_text(target.result.tp_damage_text)
wait
end
#--------------------------------------------------------------------------
# alias method: display_added_states
#--------------------------------------------------------------------------
alias window_battlelog_display_added_states_abe display_added_states
def display_added_states(target)
return unless YEA::BATTLE::MSG_ADDED_STATES
window_battlelog_display_added_states_abe(target)
end
#--------------------------------------------------------------------------
# alias method: display_removed_states
#--------------------------------------------------------------------------
alias window_battlelog_display_removed_states_abe display_removed_states
def display_removed_states(target)
return unless YEA::BATTLE::MSG_REMOVED_STATES
window_battlelog_display_removed_states_abe(target)
end
#--------------------------------------------------------------------------
# alias method: display_changed_buffs
#--------------------------------------------------------------------------
alias window_battlelog_display_changed_buffs_abe display_changed_buffs
def display_changed_buffs(target)
return unless YEA::BATTLE::MSG_CHANGED_BUFFS
window_battlelog_display_changed_buffs_abe(target)
end
end # Window_BattleLog
#==============================================================================
# ■ Window_SkillList
#==============================================================================
class Window_SkillList < Window_Selectable
#--------------------------------------------------------------------------
# overwrite method: spacing
#--------------------------------------------------------------------------
def spacing
return 8 if $game_party.in_battle
return super
end
end # Window_SkillList
#==============================================================================
# ■ Window_ItemList
#==============================================================================
class Window_ItemList < Window_Selectable
#--------------------------------------------------------------------------
# overwrite method: spacing
#--------------------------------------------------------------------------
def spacing
return 8 if $game_party.in_battle
return super
end
end # Window_ItemList
#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :enemy_window
attr_accessor :info_viewport
attr_accessor :spriteset
attr_accessor :status_window
attr_accessor :status_aid_window
attr_accessor :subject
#--------------------------------------------------------------------------
# alias method: create_spriteset
#--------------------------------------------------------------------------
alias scene_battle_create_spriteset_abe create_spriteset
def create_spriteset
BattleManager.init_battle_type
scene_battle_create_spriteset_abe
end
#--------------------------------------------------------------------------
# alias method: update_basic
#--------------------------------------------------------------------------
alias scene_battle_update_basic_abe update_basic
def update_basic
scene_battle_update_basic_abe
update_debug
end
#--------------------------------------------------------------------------
# new method: update_debug
#--------------------------------------------------------------------------
def update_debug
return unless $TEST || $BTEST
debug_heal_party if Input.trigger?(:F5)
debug_damage_party if Input.trigger?(:F6)
debug_fill_tp if Input.trigger?(:F7)
debug_kill_all if Input.trigger?(:F8)
end
#--------------------------------------------------------------------------
# new method: debug_heal_party
#--------------------------------------------------------------------------
def debug_heal_party
Sound.play_recovery
for member in $game_party.battle_members
member.recover_all
end
@status_window.refresh
end
#--------------------------------------------------------------------------
# new method: debug_damage_party
#--------------------------------------------------------------------------
def debug_damage_party
Sound.play_actor_damage
for member in $game_party.alive_members
member.hp = 1
member.mp = 0
member.tp = 0
end
@status_window.refresh
end
#--------------------------------------------------------------------------
# new method: debug_fill_tp
#--------------------------------------------------------------------------
def debug_fill_tp
Sound.play_recovery
for member in $game_party.alive_members
member.tp = member.max_tp
end
@status_window.refresh
end
#--------------------------------------------------------------------------
# new method: debug_kill_all
#--------------------------------------------------------------------------
def debug_kill_all
for enemy in $game_troop.alive_members
enemy.hp = 0
enemy.perform_collapse_effect
end
BattleManager.judge_win_loss
@log_window.wait
@log_window.wait_for_effect
end
#--------------------------------------------------------------------------
# alias method: create_all_windows
#--------------------------------------------------------------------------
alias scene_battle_create_all_windows_abe create_all_windows
def create_all_windows
scene_battle_create_all_windows_abe
create_battle_status_aid_window
set_help_window
end
#--------------------------------------------------------------------------
# alias method: create_info_viewport
#--------------------------------------------------------------------------
alias scene_battle_create_info_viewport_abe create_info_viewport
def create_info_viewport
scene_battle_create_info_viewport_abe
@status_window.refresh
end
#--------------------------------------------------------------------------
# new method: create_battle_status_aid_window
#--------------------------------------------------------------------------
def create_battle_status_aid_window
@status_aid_window = Window_BattleStatusAid.new
@status_aid_window.status_window = @status_window
@status_aid_window.x = Graphics.width - @status_aid_window.width
@status_aid_window.y = Graphics.height - @status_aid_window.height
end
#--------------------------------------------------------------------------
# overwrite method: create_help_window
#--------------------------------------------------------------------------
def create_help_window
@help_window = Window_BattleHelp.new
@help_window.hide
end
#--------------------------------------------------------------------------
# new method: set_help_window
#--------------------------------------------------------------------------
def set_help_window
@help_window.actor_window = @actor_window
@help_window.enemy_window = @enemy_window
end
#--------------------------------------------------------------------------
# alias method: create_party_command_window
#--------------------------------------------------------------------------
alias scene_battle_create_party_command_window_abe create_party_command_window
def create_party_command_window
scene_battle_create_party_command_window_abe
@party_command_window.set_handler(:dir6, method(:command_fight))
end
#--------------------------------------------------------------------------
# alias method: create_actor_command_window
#--------------------------------------------------------------------------
alias scene_battle_create_actor_command_window_abe create_actor_command_window
def create_actor_command_window
scene_battle_create_actor_command_window_abe
@actor_command_window.set_handler(:dir4, method(:prior_command))
@actor_command_window.set_handler(:dir6, method(:next_command))
end
#--------------------------------------------------------------------------
# alias method: create_skill_window
#--------------------------------------------------------------------------
alias scene_battle_create_skill_window_abe create_skill_window
def create_skill_window
scene_battle_create_skill_window_abe
@skill_window.height = @info_viewport.rect.height
@skill_window.width = Graphics.width - @actor_command_window.width
@skill_window.y = Graphics.height - @skill_window.height
end
#--------------------------------------------------------------------------
# alias method: create_item_window
#--------------------------------------------------------------------------
alias scene_battle_create_item_window_abe create_item_window
def create_item_window
scene_battle_create_item_window_abe
@item_window.height = @skill_window.height
@item_window.width = @skill_window.width
@item_window.y = Graphics.height - @item_window.height
end
#--------------------------------------------------------------------------
# alias method: show_fast?
#--------------------------------------------------------------------------
alias scene_battle_show_fast_abe show_fast?
def show_fast?
return true if YEA::BATTLE::AUTO_FAST
return scene_battle_show_fast_abe
end
#--------------------------------------------------------------------------
# alias method: next_command
#--------------------------------------------------------------------------
alias scene_battle_next_command_abe next_command
def next_command
@status_window.show
redraw_current_status
@actor_command_window.show
@status_aid_window.hide
scene_battle_next_command_abe
end
#--------------------------------------------------------------------------
# alias method: prior_command
#--------------------------------------------------------------------------
alias scene_battle_prior_command_abe prior_command
def prior_command
redraw_current_status
scene_battle_prior_command_abe
end
#--------------------------------------------------------------------------
# new method: redraw_current_status
#--------------------------------------------------------------------------
def redraw_current_status
return if @status_window.index < 0
@status_window.draw_item(@status_window.index)
end
#--------------------------------------------------------------------------
# alias method: command_attack
#--------------------------------------------------------------------------
alias scene_battle_command_attack_abe command_attack
def command_attack
$game_temp.battle_aid = $data_skills[BattleManager.actor.attack_skill_id]
scene_battle_command_attack_abe
end
#--------------------------------------------------------------------------
# alias method: command_skill
#--------------------------------------------------------------------------
alias scene_battle_command_skill_abe command_skill
def command_skill
scene_battle_command_skill_abe
@status_window.hide
@actor_command_window.hide
@status_aid_window.show
end
#--------------------------------------------------------------------------
# alias method: command_item
#--------------------------------------------------------------------------
alias scene_battle_command_item_abe command_item
def command_item
scene_battle_command_item_abe
@status_window.hide
@actor_command_window.hide
@status_aid_window.show
end
#--------------------------------------------------------------------------
# overwrite method: on_skill_ok
#--------------------------------------------------------------------------
def on_skill_ok
@skill = @skill_window.item
$game_temp.battle_aid = @skill
BattleManager.actor.input.set_skill(@skill.id)
BattleManager.actor.last_skill.object = @skill
if @skill.for_opponent?
select_enemy_selection
elsif @skill.for_friend?
select_actor_selection
else
@skill_window.hide
next_command
$game_temp.battle_aid = nil
end
end
#--------------------------------------------------------------------------
# alias method: on_skill_cancel
#--------------------------------------------------------------------------
alias scene_battle_on_skill_cancel_abe on_skill_cancel
def on_skill_cancel
scene_battle_on_skill_cancel_abe
@status_window.show
@actor_command_window.show
@status_aid_window.hide
end
#--------------------------------------------------------------------------
# overwrite method: on_item_ok
#--------------------------------------------------------------------------
def on_item_ok
@item = @item_window.item
$game_temp.battle_aid = @item
BattleManager.actor.input.set_item(@item.id)
if @item.for_opponent?
select_enemy_selection
elsif @item.for_friend?
select_actor_selection
else
@item_window.hide
next_command
$game_temp.battle_aid = nil
end
$game_party.last_item.object = @item
end
#--------------------------------------------------------------------------
# alias method: on_item_cancel
#--------------------------------------------------------------------------
alias scene_battle_on_item_cancel_abe on_item_cancel
def on_item_cancel
scene_battle_on_item_cancel_abe
@status_window.show
@actor_command_window.show
@status_aid_window.hide
end
#--------------------------------------------------------------------------
# alias method: select_actor_selection
#--------------------------------------------------------------------------
alias scene_battle_select_actor_selection_abe select_actor_selection
def select_actor_selection
@status_aid_window.refresh
scene_battle_select_actor_selection_abe
@status_window.hide
@skill_window.hide
@item_window.hide
@help_window.show
end
#--------------------------------------------------------------------------
# alias method: on_actor_ok
#--------------------------------------------------------------------------
alias scene_battle_on_actor_ok_abe on_actor_ok
def on_actor_ok
$game_temp.battle_aid = nil
scene_battle_on_actor_ok_abe
@status_window.show
if $imported["YEA-BattleCommandList"] && !@confirm_command_window.nil?
@actor_command_window.visible = !@confirm_command_window.visible
else
@actor_command_window.show
end
@status_aid_window.hide
end
#--------------------------------------------------------------------------
# alias method: on_actor_cancel
#--------------------------------------------------------------------------
alias scene_battle_on_actor_cancel_abe on_actor_cancel
def on_actor_cancel
BattleManager.actor.input.clear
@status_aid_window.refresh
$game_temp.battle_aid = nil
scene_battle_on_actor_cancel_abe
case @actor_command_window.current_symbol
when :skill
@skill_window.show
when :item
@item_window.show
end
end
#--------------------------------------------------------------------------
# alias method: select_enemy_selection
#--------------------------------------------------------------------------
alias scene_battle_select_enemy_selection_abe select_enemy_selection
def select_enemy_selection
@status_aid_window.refresh
scene_battle_select_enemy_selection_abe
@help_window.show
end
#--------------------------------------------------------------------------
# alias method: on_enemy_ok
#--------------------------------------------------------------------------
alias scene_battle_on_enemy_ok_abe on_enemy_ok
def on_enemy_ok
$game_temp.battle_aid = nil
scene_battle_on_enemy_ok_abe
end
#--------------------------------------------------------------------------
# alias method: on_enemy_cancel
#--------------------------------------------------------------------------
alias scene_battle_on_enemy_cancel_abe on_enemy_cancel
def on_enemy_cancel
BattleManager.actor.input.clear
@status_aid_window.refresh
$game_temp.battle_aid = nil
scene_battle_on_enemy_cancel_abe
if @skill_window.visible || @item_window.visible
@help_window.show
else
@help_window.hide
end
end
#--------------------------------------------------------------------------
# alias method: battle_start
#--------------------------------------------------------------------------
alias scene_battle_battle_start_abe battle_start
def battle_start
scene_battle_battle_start_abe
return unless YEA::BATTLE::SKIP_PARTY_COMMAND
@party_command_window.deactivate
if BattleManager.input_start
command_fight
else
turn_start
end
end
#--------------------------------------------------------------------------
# overwrite method: turn_end
#--------------------------------------------------------------------------
def turn_end
all_battle_members.each do |battler|
battler.on_turn_end
status_redraw_target(battler)
@log_window.display_auto_affected_status(battler)
@log_window.wait_and_clear
end
update_party_cooldowns if $imported["YEA-CommandParty"]
BattleManager.turn_end
process_event
start_party_command_selection
return unless YEA::BATTLE::SKIP_PARTY_COMMAND
if BattleManager.input_start
@party_command_window.deactivate
command_fight
else
@party_command_window.deactivate
turn_start
end
end
#--------------------------------------------------------------------------
# overwrite method: execute_action
#--------------------------------------------------------------------------
def execute_action
@subject.sprite_effect_type = :whiten if YEA::BATTLE::FLASH_WHITE_EFFECT
use_item
@log_window.wait_and_clear
end
#--------------------------------------------------------------------------
# overwrite method: apply_item_effects
#--------------------------------------------------------------------------
def apply_item_effects(target, item)
if $imported["YEA-LunaticObjects"]
lunatic_object_effect(:prepare, item, @subject, target)
end
target.item_apply(@subject, item)
status_redraw_target(@subject)
status_redraw_target(target) unless target == @subject
@log_window.display_action_results(target, item)
if $imported["YEA-LunaticObjects"]
lunatic_object_effect(:during, item, @subject, target)
end
perform_collapse_check(target)
end
#--------------------------------------------------------------------------
# overwite method: invoke_counter_attack
#--------------------------------------------------------------------------
def invoke_counter_attack(target, item)
@log_window.display_counter(target, item)
attack_skill = $data_skills[target.attack_skill_id]
@subject.item_apply(target, attack_skill)
status_redraw_target(@subject)
status_redraw_target(target) unless target == @subject
@log_window.display_action_results(@subject, attack_skill)
perform_collapse_check(target)
perform_collapse_check(@subject)
end
#--------------------------------------------------------------------------
# new method: perform_collapse_check
#--------------------------------------------------------------------------
def perform_collapse_check(target)
return if YEA::BATTLE::MSG_ADDED_STATES
target.perform_collapse_effect if target.can_collapse?
@log_window.wait
@log_window.wait_for_effect
end
#--------------------------------------------------------------------------
# overwrite method: show_attack_animation
#--------------------------------------------------------------------------
def show_attack_animation(targets)
show_normal_animation(targets, @subject.atk_animation_id1, false)
wait_for_animation
show_normal_animation(targets, @subject.atk_animation_id2, true)
end
#--------------------------------------------------------------------------
# overwrite method: show_normal_animation
#--------------------------------------------------------------------------
def show_normal_animation(targets, animation_id, mirror = false)
animation = $data_animations[animation_id]
return if animation.nil?
ani_check = false
targets.each do |target|
if ani_check && target.animation_id <= 0
target.pseudo_ani_id = animation_id
else
target.animation_id = animation_id
end
target.animation_mirror = mirror
ani_check = true if animation.to_screen?
end
end
#--------------------------------------------------------------------------
# overwrite method: process_action_end
#--------------------------------------------------------------------------
def process_action_end
@subject.on_action_end
status_redraw_target(@subject)
@log_window.display_auto_affected_status(@subject)
@log_window.wait_and_clear
@log_window.display_current_state(@subject)
@log_window.wait_and_clear
BattleManager.judge_win_loss
end
#--------------------------------------------------------------------------
# overwrite method: use_item
#--------------------------------------------------------------------------
def use_item
item = @subject.current_action.item
@log_window.display_use_item(@subject, item)
@subject.use_item(item)
status_redraw_target(@subject)
if $imported["YEA-LunaticObjects"]
lunatic_object_effect(:before, item, @subject, @subject)
end
process_casting_animation if $imported["YEA-CastAnimations"]
targets = @subject.current_action.make_targets.compact rescue []
show_animation(targets, item.animation_id) if show_all_animation?(item)
targets.each {|target|
if $imported["YEA-TargetManager"]
target = alive_random_target(target, item) if item.for_random?
end
item.repeats.times { invoke_item(target, item) } }
if $imported["YEA-LunaticObjects"]
lunatic_object_effect(:after, item, @subject, @subject)
end
end
#--------------------------------------------------------------------------
# alias method: invoke_item
#--------------------------------------------------------------------------
alias scene_battle_invoke_item_abe invoke_item
def invoke_item(target, item)
show_animation([target], item.animation_id) if separate_ani?(target, item)
if target.dead? != item.for_dead_friend?
@subject.last_target_index = target.index
return
end
scene_battle_invoke_item_abe(target, item)
end
#--------------------------------------------------------------------------
# new method: show_all_animation?
#--------------------------------------------------------------------------
def show_all_animation?(item)
return true if item.one_animation
return false if $data_animations[item.animation_id].nil?
return false unless $data_animations[item.animation_id].to_screen?
return true
end
#--------------------------------------------------------------------------
# new method: separate_ani?
#--------------------------------------------------------------------------
def separate_ani?(target, item)
return false if item.one_animation
return false if $data_animations[item.animation_id].nil?
return false if $data_animations[item.animation_id].to_screen?
return target.dead? == item.for_dead_friend?
end
#--------------------------------------------------------------------------
# new method: status_redraw_target
#--------------------------------------------------------------------------
def status_redraw_target(target)
return unless target.actor?
@status_window.draw_item($game_party.battle_members.index(target))
end
#--------------------------------------------------------------------------
# alias method: start_party_command_selection
#--------------------------------------------------------------------------
alias start_party_command_selection_abe start_party_command_selection
def start_party_command_selection
@status_window.refresh unless scene_changing?
start_party_command_selection_abe
end
#--------------------------------------------------------------------------
# overwrite method: refresh_status
#--------------------------------------------------------------------------
def refresh_status; return; end
#--------------------------------------------------------------------------
# new method: refresh_autobattler_status_window
#--------------------------------------------------------------------------
def refresh_autobattler_status_window
for member in $game_party.battle_members
next unless member.auto_battle?
@status_window.draw_item(member.index)
end
end
#--------------------------------------------------------------------------
# new method: hide_extra_gauges
#--------------------------------------------------------------------------
def hide_extra_gauges
# Made for compatibility
end
#--------------------------------------------------------------------------
# new method: show_extra_gauges
#--------------------------------------------------------------------------
def show_extra_gauges
# Made for compatibility
end
end # Scene_Battle
#==============================================================================
#
# ▼ YSA Battle System: Classical ATB
# -- Last Updated: 2012.01.20
# -- Level: Easy, Normal
# -- Requires: YEA - Ace Battle Engine v1.15+.
#
#==============================================================================
$imported = {} if $imported.nil?
$imported["YSA-CATB"] = true
#==============================================================================
# ▼ Updates
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# 2012.01.20 - Compatible with: Lunatic CATB Rate.
# - Fix a bug with first strike.
# 2012.01.19 - Fix a small bug with Action's Icon Updating.
# - Fix a critical bug with target selecting.
# - Fix a bug with states updating.
# - Fix a small bug with actor's status when choosing skill/item.
# - Fix a critical bug with auto battle.
# 2012.01.16 - Fix ATB speed changes when a battler's agi changes.
# - Add casting time.
# 2012.01.16 - Add a function for preemptive strike and surprised.
# - Fix a small bug with make action.
# 2012.01.13 - Bugfix for ATB Type Wait.
# - Upgrade a little ATB gauge.
# - Upgrade turn count.
# - Compatible with: Lunatic CATB Start.
# 2012.01.12 - Started Script and Finished.
#
#==============================================================================
# ▼ Introduction
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script will add a battle type into YEA Battle Engine Ace.
# Battle Type: Classical ATB.
#
#==============================================================================
# ▼ Instructions
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials/素材 but above ▼ Main. Remember to save.
#
# First, set the default battle system for your game to be :catb by either going
# to the Ace Battle Engine script and setting DEFAULT_BATTLE_SYSTEM as :catb or
# by using the following script call:
#
# $game_system:set_battle_system(:catb)
#
# Second, you can set the default wait for your game by either setting DEFAULT_WAIT
# or using the following script call:
#
# $game_system:set_catb_wait_type(wait_type)
#
# Which there are 4 types:
# - :full : ATB always run, except when animation run
# - :quarter : ATB pause when select skill/item/target
# - :semi : ATB pause when select target
# - :wait : ATB pause when choose action for actor
#
# Third, you can set the default turn counting for your game by either setting
# DEFAULT_TURN or using the following script call:
#
# $game_system:set_catb_turn_type(turn_type)
#
# Which there are 2 types:
# - :tick : Count as a turn after X frame
# - :action : Count as a turn after X actions
#
# -----------------------------------------------------------------------------
# Skill/Item Notetags - These notetags go in the skill/item notebox in the database.
# -----------------------------------------------------------------------------
# <charge rate: x%>
# Enable casting time (skill charge) for Skill or Item. Skill/Item will be charged
# at normal ATB filled speed * x%, which means it will be charged at x% rate.
#
#==============================================================================
# ▼ Compatibility
# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# This script is made strictly for RPG Maker VX Ace. It is highly unlikely that
# it will run with RPG Maker VX without adjusting.
#
# This script requires Yanfly Engine Ace - Ace Battle Engine v1.15+ and the
# script must be placed under Ace Battle Engine in the script listing.
#
#==============================================================================
#==============================================================================
# ▼ Configuration
#==============================================================================
module YSA
module CATB
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - General Configuration -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
DEFAULT_FILL_TIME = 120 # Frames
DEFAULT_WAIT = :wait # :full, :semi, :quarter, :wait
FILL_TIME_VARIABLE = 15 # Change DEFAULT_FILL_TIME by variable.
PAUSE_WHEN_ACTIVE_PARTY_COMMAND = true
PREEMTIVE_ATB_ACTOR = 70
PREEMTIVE_ATB_ENEMY = 0
SURPRISE_ATB_ACTOR = 0
SURPRISE_ATB_ENEMY = 70
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Turn Configuration -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
DEFAULT_TURN = :action # :tick, :action
TICK_COUNT = 150 # Turn after TICK_COUNT
TICK_COUNT_VARIABLE = 16 # Change TICK_COUNT by variable.
AFTER_ACTION = 1 # Turn after AFTER_ACTION actions.
AFTER_ACTION_VARIABLE = 17 # Change AFTER_ACTION by variable.
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Actor ATB Gauges -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
GAUGE_COLOR1 = 32
GAUGE_COLOR2 = 31
CHARGE_COLOR1 = 18
CHARGE_COLOR2 = 10
ATB_GAUGE_Y_PLUS = 12
ATB_PHRASE = "ATB"
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# - Enemy ATB Gauges -
#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
SHOW_ENEMY_ATB_GAUGE = true # Display Enemy HP Gauge?
ENEMY_GAUGE_WIDTH = 128 # How wide the enemy gauges are.
ENEMY_GAUGE_HEIGHT = 12 # How tall the enemy gauges are.
ENEMY_ATB_GAUGE_COLOUR1 = 1 # Colour 1 for ATB.
ENEMY_ATB_GAUGE_COLOUR2 = 4 # Colour 2 for ATB.
ENEMY_BACKGAUGE_COLOUR = 19 # Gauge Back colour.
end
end
#==============================================================================
# ▼ Editting anything past this point may potentially result in causing
# computer damage, incontinence, explosion of user's head, coma, death, and/or
# halitosis so edit at your own risk.
#==============================================================================
module YSA
module REGEXP
module USABLEITEM
CHARGE_RATE = /<(?:CHARGE_RATE|charge rate):[ ](\d+)?([%％])>/i
end # USABLEITEM
end # REGEXP
end # YSA
#==============================================================================
# ■ DataManager
#==============================================================================
module DataManager
#--------------------------------------------------------------------------
# alias method: load_database
#--------------------------------------------------------------------------
class <<self; alias load_database_catb load_database; end
def self.load_database
load_database_catb
load_notetags_catb
end
#--------------------------------------------------------------------------
# new method: load_notetags_catb
#--------------------------------------------------------------------------
def self.load_notetags_catb
groups = [$data_skills, $data_items]
for group in groups
for obj in group
next if obj.nil?
obj.load_notetags_catb
end
end
end
end # DataManager
#==============================================================================
# ■ RPG::UsableItem
#==============================================================================
class RPG::UsableItem < RPG::BaseItem
#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :charge_rate
attr_accessor :charge_on
#--------------------------------------------------------------------------
# common cache: load_notetags_catb
#--------------------------------------------------------------------------
def load_notetags_catb
@charge_rate = 100
@charge_on = false
#---
self.note.split(/[\r\n]+/).each { |line|
case line
#---
when YSA::REGEXP::USABLEITEM::CHARGE_RATE
@charge_on = true
@charge_rate = $1.to_i
#---
end
} # self.note.split
#---
@charge_rate = 100 if @charge_rate <= 0
end
end # RPG::UsableItem
#==============================================================================
# ■ BattleManager
#==============================================================================
module BattleManager
#--------------------------------------------------------------------------
# alias method:
# - make_action_orders
# - prior_command
# - next_command
# - in_turn?
# - battle_start
#--------------------------------------------------------------------------
class <<self
alias catb_make_action_orders make_action_orders
alias catb_prior_command prior_command
alias catb_next_command next_command
alias catb_in_turn? in_turn?
alias catb_battle_start battle_start
end
#--------------------------------------------------------------------------
# battle_start
#--------------------------------------------------------------------------
def self.battle_start
catb_battle_start
if btype?(:catb)
@average_agi = 0
make_catb_action_orders
battler_hash = $game_party.members + $game_troop.members
battler_hash.each { |a|
if @preemptive
a.make_first_catb_value(1)
elsif @surprise
a.make_first_catb_value(2)
else
a.make_first_catb_value(0)
end
@average_agi += a.agi
}
@average_agi /= battler_hash.size
end
end
#--------------------------------------------------------------------------
# next_command
#--------------------------------------------------------------------------
def self.next_command
return false if btype?(:catb)
catb_next_command
end
#--------------------------------------------------------------------------
# alias method: in_turn?
#--------------------------------------------------------------------------
def self.in_turn?
return true if btype?(:catb)
return catb_in_turn?
end
#--------------------------------------------------------------------------
# new method: make_catb_action_orders
#--------------------------------------------------------------------------
class <<self
def make_catb_action_orders
@action_actors = []
@action_enemies = []
@action_battlers = []
end
end
#--------------------------------------------------------------------------
# new method: average_agi
#--------------------------------------------------------------------------
class <<self
def average_agi
return @average_agi
end
end
#--------------------------------------------------------------------------
# new method: set_actor
#--------------------------------------------------------------------------
class <<self
def set_actor(actor_index)
@actor_index = actor_index
end
end
#--------------------------------------------------------------------------
# prior_command
#--------------------------------------------------------------------------
def self.prior_command
return false if btype?(:catb)
catb_prior_command
end
#--------------------------------------------------------------------------
# new method: make_catb_action
#--------------------------------------------------------------------------
class <<self
def make_catb_action(battler)
make_catb_action_orders if !@action_battlers || !@action_actors || !@action_enemies
return false if @action_battlers.include?(battler)
@action_battlers.push(battler)
@action_actors.push(battler) if battler.actor?
@action_enemies.push(battler) if battler.enemy?
return true
end
end
#--------------------------------------------------------------------------
# new method: delete_catb_action
#--------------------------------------------------------------------------
class <<self
def delete_catb_action(battler)
return false if !battler
@action_battlers.delete(battler)
@action_battlers = @action_battlers.compact
@action_actors.delete(battler) if battler.actor?
@action_actors = @action_actors.compact
@action_enemies.delete(battler) if battler.enemy?
@action_enemies = @action_enemies.compact
return true
end
end
#--------------------------------------------------------------------------
# new method: action_list
#--------------------------------------------------------------------------
class <<self
def action_list(type = :all)
return @action_battlers if type == :all
return @action_actors if type == :actor
return @action_enemies if type = :enemy
end
end
end # BattleManager
#==============================================================================
# ■ Game_System
#==============================================================================
class Game_System
#--------------------------------------------------------------------------
# alias method: set_battle_system
#--------------------------------------------------------------------------
alias qatb_set_battle_system set_battle_system
def set_battle_system(type)
case type
when :catb; @battle_system = :catb
else; qatb_set_battle_system(type)
end
end
#--------------------------------------------------------------------------
# alias method: battle_system_corrected
#--------------------------------------------------------------------------
alias qatb_battle_system_corrected battle_system_corrected
def battle_system_corrected(type)
case type
when :catb; return :catb
else; return qatb_battle_system_corrected(type)
end
end
#--------------------------------------------------------------------------
# new method: catb_fill_time
#--------------------------------------------------------------------------
def catb_fill_time
return $game_variables[YSA::CATB::FILL_TIME_VARIABLE] > 0 ? $game_variables[YSA::CATB::FILL_TIME_VARIABLE] : YSA::CATB::DEFAULT_FILL_TIME
end
#--------------------------------------------------------------------------
# new method: catb_tick_count
#--------------------------------------------------------------------------
def catb_tick_count
return $game_variables[YSA::CATB::TICK_COUNT_VARIABLE] > 0 ? $game_variables[YSA::CATB::TICK_COUNT_VARIABLE] : YSA::CATB::TICK_COUNT
end
#--------------------------------------------------------------------------
# new method: catb_after_action
#--------------------------------------------------------------------------
def catb_after_action
return $game_variables[YSA::CATB::AFTER_ACTION_VARIABLE] > 0 ? $game_variables[YSA::CATB::AFTER_ACTION_VARIABLE] : YSA::CATB::AFTER_ACTION
end
#--------------------------------------------------------------------------
# new method: catb_turn_type
#--------------------------------------------------------------------------
def catb_turn_type
return @catb_turn_type ? @catb_turn_type : YSA::CATB::DEFAULT_TURN
end
#--------------------------------------------------------------------------
# new method: catb_wait_type
#--------------------------------------------------------------------------
def catb_wait_type
return @catb_wait_type ? @catb_wait_type : YSA::CATB::DEFAULT_WAIT
end
#--------------------------------------------------------------------------
# new method: set_catb_wait_type
#--------------------------------------------------------------------------
def set_catb_wait_type(type = :full)
@catb_wait_type = type
end
#--------------------------------------------------------------------------
# new method: set_catb_turn_type
#--------------------------------------------------------------------------
def set_catb_turn_type(type = :tick)
@catb_turn_type = type
end
end # Game_System
#==============================================================================
# ■ Game_Battler
#==============================================================================
class Game_Battler < Game_BattlerBase
MAX_CATB_VALUE = 100000.0
#--------------------------------------------------------------------------
# alias method: initialize
#--------------------------------------------------------------------------
alias catb_initialize initialize
def initialize
catb_initialize
@catb_value = 0
@ct_catb_value = 0
end
#--------------------------------------------------------------------------
# new method: base_gain_catb
#--------------------------------------------------------------------------
def base_gain_catb
return MAX_CATB_VALUE / $game_system.catb_fill_time
end
#--------------------------------------------------------------------------
# new method: real_gain_catb
#--------------------------------------------------------------------------
def real_gain_catb
value = (self.agi.to_f / BattleManager.average_agi) * base_gain_catb
return value
end
#--------------------------------------------------------------------------
# new method: make_catb_update
#--------------------------------------------------------------------------
def make_catb_update
return if @catb_value >= MAX_CATB_VALUE
return if not normal?
value = $imported["YSA-LunaticCATBRate"] ? lunatic_catb_rate_formula : real_gain_catb
@catb_value += [value, MAX_CATB_VALUE - @catb_value].min
end
#--------------------------------------------------------------------------
# new method: make_catb_action
#--------------------------------------------------------------------------
def make_catb_action
return unless @catb_value >= MAX_CATB_VALUE
return clear_catb if not normal?
return BattleManager.make_catb_action(self)
end
#--------------------------------------------------------------------------
# new method: make_ct_catb_update
#--------------------------------------------------------------------------
def make_ct_catb_update
return if @catb_value < MAX_CATB_VALUE
return if @ct_catb_value >= MAX_CATB_VALUE
return if !self.current_action
return if !self.current_action.item
return if self.actor? && !self.current_action.confirm
clear_catb if not normal?
@ct_catb_value = MAX_CATB_VALUE if !self.current_action.item.charge_on
value = $imported["YSA-LunaticCATBRate"] ? lunatic_catb_rate_formula : real_gain_catb
@ct_catb_value += [value * self.current_action.item.charge_rate / 100, MAX_CATB_VALUE - @ct_catb_value].min
end
#--------------------------------------------------------------------------
# new method: charge_skill_done?
#--------------------------------------------------------------------------
def charge_skill_done?
return @catb_value >= MAX_CATB_VALUE && @ct_catb_value >= MAX_CATB_VALUE
end
#--------------------------------------------------------------------------
# new method: clear_catb
#--------------------------------------------------------------------------
def clear_catb
make_actions
@catb_value = 0
@ct_catb_value = 0
BattleManager.clear_actor if self.actor? && BattleManager.actor == self
BattleManager.delete_catb_action(self)
end
#--------------------------------------------------------------------------
# new method: make_first_catb_value
#--------------------------------------------------------------------------
def make_first_catb_value(pre = 0)
make_actions
@catb_value = 0
@catb_value = YSA::CATB::PREEMTIVE_ATB_ACTOR if self.actor? && pre == 1
@catb_value = YSA::CATB::PREEMTIVE_ATB_ENEMY if self.enemy? && pre == 1
@catb_value = YSA::CATB::SURPRISE_ATB_ACTOR if self.actor? && pre == 2
@catb_value = YSA::CATB::SURPRISE_ATB_ENEMY if self.enemy? && pre == 2
lunatic_catb_start_formula(pre) if $imported["YSA-LunaticCATBStart"]
end
#--------------------------------------------------------------------------
# new method: catb_filled_rate
#--------------------------------------------------------------------------
def catb_filled_rate
return @catb_value / MAX_CATB_VALUE
end
#--------------------------------------------------------------------------
# new method: catb_ct_filled_rate
#--------------------------------------------------------------------------
def catb_ct_filled_rate
return @catb_value < MAX_CATB_VALUE ? 0 : @ct_catb_value / MAX_CATB_VALUE
end
end # Game_Battler
#==============================================================================
# ■ Game_Action
#==============================================================================
class Game_Action
#--------------------------------------------------------------------------
# alias method: clear
#--------------------------------------------------------------------------
alias catb_clear clear
def clear
catb_clear
@confirm = false
end
#--------------------------------------------------------------------------
# new method: confirm=
#--------------------------------------------------------------------------
def confirm=(con)
@confirm = con
end
#--------------------------------------------------------------------------
# new method: confirm
#--------------------------------------------------------------------------
def confirm
return @subject.auto_battle? ? true : @confirm
end
end # Game_Action
#==============================================================================
# ■ Window_Base
#==============================================================================
class Window_Base < Window
#--------------------------------------------------------------------------
# catb_gauge_color
#--------------------------------------------------------------------------
def catb_color1; text_color(YSA::CATB::GAUGE_COLOR1); end;
def catb_color2; text_color(YSA::CATB::GAUGE_COLOR2); end;
def charge_color1; text_color(YSA::CATB::CHARGE_COLOR1); end;
def charge_color2; text_color(YSA::CATB::CHARGE_COLOR2); end;
end # Window_Base
#==============================================================================
# ■ Window_BattleStatus
#==============================================================================
class Window_BattleStatus < Window_Selectable
#--------------------------------------------------------------------------
# alias method: draw_item
#--------------------------------------------------------------------------
alias catb_draw_item draw_item
def draw_item(index)
catb_draw_item(index)
actor = battle_members[index]
rect = item_rect(index)
gx = YEA::BATTLE::BATTLESTATUS_HPGAUGE_Y_PLUS + YSA::CATB::ATB_GAUGE_Y_PLUS
return unless BattleManager.btype?(:catb)
draw_actor_catb(actor, rect.x+2, line_height*1+gx, rect.width-4)
end
#--------------------------------------------------------------------------
# new method: draw_actor_catb
#--------------------------------------------------------------------------
def draw_actor_catb(actor, dx, dy, width = 124)
draw_gauge(dx, dy, width, actor.catb_filled_rate, catb_color1, catb_color2)
if actor.catb_ct_filled_rate > 0
draw_gauge(dx, dy, width, actor.catb_ct_filled_rate, charge_color1, charge_color2)
end
change_color(system_color)
cy = (Font.default_size - contents.font.size) / 2 + 1
draw_text(dx+2, dy+cy, 30, line_height, YSA::CATB::ATB_PHRASE)
end
#--------------------------------------------------------------------------
# new method: draw_item_actor_catb
#--------------------------------------------------------------------------
def draw_item_actor_catb(index)
return if index.nil?
actor = battle_members[index]
rect = item_rect(index)
return if actor.nil?
gx = YEA::BATTLE::BATTLESTATUS_HPGAUGE_Y_PLUS + YSA::CATB::ATB_GAUGE_Y_PLUS
draw_actor_catb(actor, rect.x+2, line_height*1+gx, rect.width-4)
end
#--------------------------------------------------------------------------
# new method: refresh_catb
#--------------------------------------------------------------------------
def refresh_catb
return unless BattleManager.btype?(:catb)
item_max.times {|i| draw_item_actor_catb(i) }
end
end # Window_BattleStatus
#==============================================================================
# ■ Sprite_Battler
#==============================================================================
class Sprite_Battler < Sprite_Base
#--------------------------------------------------------------------------
# alias method: initialize
#--------------------------------------------------------------------------
alias sprite_battler_initialize_catb initialize
def initialize(viewport, battler = nil)
sprite_battler_initialize_catb(viewport, battler)
create_enemy_gauges_catb
end
#--------------------------------------------------------------------------
# alias method: dispose
#--------------------------------------------------------------------------
alias sprite_battler_dispose_catb dispose
def dispose
sprite_battler_dispose_catb
dispose_enemy_gauges_catb
end
#--------------------------------------------------------------------------
# alias method: update
#--------------------------------------------------------------------------
alias sprite_battler_update_catb update
def update
sprite_battler_update_catb
update_enemy_gauges_catb
end
#--------------------------------------------------------------------------
# new method: create_enemy_gauges_catb
#--------------------------------------------------------------------------
def create_enemy_gauges_catb
return if @battler.nil?
return if @battler.actor?
return unless BattleManager.btype?(:catb)
@catb_back_gauge_viewport = Enemy_CATB_Gauge_Viewport.new(@battler, self, :back)
@catb_gauge_viewport = Enemy_CATB_Gauge_Viewport.new(@battler, self, :catb)
@catb_ct_gauge_viewport = Enemy_CATB_Gauge_Viewport.new(@battler, self, :catbct)
end
#--------------------------------------------------------------------------
# new method: dispose_enemy_gauges_catb
#--------------------------------------------------------------------------
def dispose_enemy_gauges_catb
return unless BattleManager.btype?(:catb)
@catb_back_gauge_viewport.dispose unless @catb_back_gauge_viewport.nil?
@catb_gauge_viewport.dispose unless @catb_gauge_viewport.nil?
@catb_ct_gauge_viewport.dispose unless @catb_ct_gauge_viewport.nil?
end
#--------------------------------------------------------------------------
# new method: update_enemy_gauges_catb
#--------------------------------------------------------------------------
def update_enemy_gauges_catb
return unless BattleManager.btype?(:catb)
@catb_back_gauge_viewport.update unless @catb_back_gauge_viewport.nil?
@catb_gauge_viewport.update unless @catb_gauge_viewport.nil?
@catb_ct_gauge_viewport.update unless @catb_ct_gauge_viewport.nil?
end
end # Sprite_Battler
#==============================================================================
# ■ Enemy_CATB_Gauge_Viewport
#==============================================================================
class Enemy_CATB_Gauge_Viewport < Viewport
#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(battler, sprite, type)
@battler = battler
@base_sprite = sprite
@type = type
dw = YSA::CATB::ENEMY_GAUGE_WIDTH
dw += 2 if @type == :back
@start_width = dw
dh = YSA::CATB::ENEMY_GAUGE_HEIGHT
dh += 2 if @type == :back
rect = Rect.new(0, 0, dw, dh)
super(rect)
self.z = 125
create_gauge_sprites
self.visible = false
update_position
end
#--------------------------------------------------------------------------
# dispose
#--------------------------------------------------------------------------
def dispose
@sprite.bitmap.dispose unless @sprite.bitmap.nil?
@sprite.dispose
super
end
#--------------------------------------------------------------------------
# update
#--------------------------------------------------------------------------
def update
super
self.visible = @battler.dead? ? false : YSA::CATB::SHOW_ENEMY_ATB_GAUGE
update_position
update_gauge
end
#--------------------------------------------------------------------------
# create_gauge_sprites
#--------------------------------------------------------------------------
def create_gauge_sprites
@sprite = Plane.new(self)
dw = self.rect.width * 2
@sprite.bitmap = Bitmap.new(dw, self.rect.height)
case @type
when :back
colour1 = Colour.text_colour(YSA::CATB::ENEMY_BACKGAUGE_COLOUR)
colour2 = Colour.text_colour(YSA::CATB::ENEMY_BACKGAUGE_COLOUR)
when :catb
colour1 = Colour.text_colour(YSA::CATB::ENEMY_ATB_GAUGE_COLOUR1)
colour2 = Colour.text_colour(YSA::CATB::ENEMY_ATB_GAUGE_COLOUR2)
when :catbct
colour1 = Colour.text_colour(YSA::CATB::CHARGE_COLOR1)
colour2 = Colour.text_colour(YSA::CATB::CHARGE_COLOR2)
end
dx = 0
dy = 0
dw = self.rect.width
dh = self.rect.height
self.rect.width = target_gauge_width unless @type == :back
@gauge_width = target_gauge_width
@sprite.bitmap.gradient_fill_rect(dx, dy, dw, dh, colour1, colour2)
@sprite.bitmap.gradient_fill_rect(dw, dy, dw, dh, colour2, colour1)
end
#--------------------------------------------------------------------------
# update_position
#--------------------------------------------------------------------------
def update_position
dx = @battler.screen_x - @start_width / 2
self.rect.x = dx
dh = self.rect.height + 1
dh += 2 unless @type == :back
dy = [@battler.screen_y, Graphics.height - dh - 120].min
dy += 1 unless @type == :back
dy -= YEA::BATTLE::ENEMY_GAUGE_HEIGHT if $imported["YEA-EnemyHPBars"]
self.rect.y = dy
end
#--------------------------------------------------------------------------
# update_gauge
#--------------------------------------------------------------------------
def update_gauge
return if @gauge_width == target_gauge_width
@gauge_width = target_gauge_width if @type == :catb
@gauge_width = target_gauge_width_ct if @type == :catbct
return if @type == :back
self.rect.width = @gauge_width
end
#--------------------------------------------------------------------------
# target_gauge_width
#--------------------------------------------------------------------------
def target_gauge_width
return @battler.catb_filled_rate * @start_width
end
#--------------------------------------------------------------------------
# target_gauge_width_ct
#--------------------------------------------------------------------------
def target_gauge_width_ct
return @battler.catb_ct_filled_rate * @start_width
end
end # Enemy_CATB_Gauge_Viewport
#==============================================================================
# ■ Window_BattleEnemy
#==============================================================================
class Window_BattleEnemy < Window_Selectable
#--------------------------------------------------------------------------
# alias method: col_max
#--------------------------------------------------------------------------
alias catb_col_max col_max
def col_max; return catb_col_max == 0 ? 1 : catb_col_max; end
end # Window_BattleEnemy
#==============================================================================
# ■ Scene_Battle
#==============================================================================
class Scene_Battle < Scene_Base
#--------------------------------------------------------------------------
# alias method: process_action
#--------------------------------------------------------------------------
alias catb_process_action process_action
def process_action
process_catb
perform_catb_action(@subject, true) if BattleManager.action_forced?
catb_process_action unless BattleManager.btype?(:catb)
end
#--------------------------------------------------------------------------
# new method: catb_pause?
#--------------------------------------------------------------------------
def catb_pause?
return YSA::CATB::PAUSE_WHEN_ACTIVE_PARTY_COMMAND if @party_command_window.active
return false if $game_system.catb_wait_type == :full
return true if $game_system.catb_wait_type == :wait && (@actor_command_window.active || @skill_window.active || @item_window.active || @actor_window.active || @enemy_window.active)
return true if $game_system.catb_wait_type == :quarter && (@skill_window.active || @item_window.active || @actor_window.active || @enemy_window.active)
return true if $game_system.catb_wait_type == :semi && (@actor_window.active || @enemy_window.active)
end
#--------------------------------------------------------------------------
# new method: process_catb
#--------------------------------------------------------------------------
def process_catb
return unless SceneManager.scene_is?(Scene_Battle)
return if scene_changing?
return unless BattleManager.btype?(:catb)
return if catb_pause?
battler_hash = $game_party.members + $game_troop.members
battler_hash.each { |a|
a.make_catb_update
a.make_catb_action
a.make_ct_catb_update
}
#--- Update Tick Turn
if $game_system.catb_turn_type == :tick
@tick_clock = 0 if !@tick_clock
@tick_clock += 1
if @tick_clock >= $game_system.catb_tick_count
@tick_clock = 0
all_battle_members.each { |battler|
battler.on_turn_end
}
@status_window.refresh
$game_troop.increase_turn
end
end
#--- Fix make action
BattleManager.action_list(:actor).each { |battler|
battler.make_actions if (battler.actor? && !battler.input)
}
#---
@status_window.refresh_catb
#--- Setup Actor
@f_actor_index = 0 if !@f_actor_index || @f_actor_index < 0 || @f_actor_index + 1 > BattleManager.action_list(:actor).size
f_actor = BattleManager.action_list(:actor)[@f_actor_index]
@f_actor_index += 1 if (@f_actor_index + 1) < BattleManager.action_list(:actor).size && f_actor && f_actor.input && f_actor.input.item && f_actor.input.confirm
f_actor = BattleManager.action_list(:actor)[@f_actor_index]
if f_actor && f_actor.input && !f_actor.input.item && (!BattleManager.actor || @status_window.index != BattleManager.actor.index)
BattleManager.set_actor(f_actor.index)
@status_window.select(BattleManager.actor.index)
@actor_command_window.setup(BattleManager.actor)
end
BattleManager.action_list.each { |battler|
battler.make_actions if battler.enemy?
perform_catb_action(battler) if !@subject
}
end
#--------------------------------------------------------------------------
# new method: perform_catb_action
#--------------------------------------------------------------------------
def perform_catb_action(subject, forced = false)
return if subject && !subject.charge_skill_done?
return if subject && subject.actor? && !forced && !subject.input
return if subject && subject.actor? && !forced && !subject.input.item
return if subject && subject.actor? && !forced && !subject.input.confirm
@subject = subject if subject
return if !@subject
if @subject.current_action
@subject.current_action.prepare
execute_action
process_event
@status_aid_window.refresh if @status_aid_window.visible
if $game_system.catb_turn_type == :action
@tick_action = 0 if !@tick_action
@tick_action += 1
if @tick_action >= $game_system.catb_after_action
@tick_action = 0
all_battle_members.each { |battler|
battler.on_turn_end
}
@status_window.refresh
$game_troop.increase_turn
end
end
@subject.on_action_end
end
return if BattleManager.judge_win_loss
@subject.clear_catb
@status_window.draw_item(@subject.index) if @subject.actor?
@subject = nil
end
#--------------------------------------------------------------------------
# alias method: create_actor_command_window
#--------------------------------------------------------------------------
alias catb_create_actor_command_window create_actor_command_window
def create_actor_command_window
catb_create_actor_command_window
if BattleManager.btype?(:catb)
@actor_command_window.set_handler(:dir4, method(:prior_f_actor))
@actor_command_window.set_handler(:dir6, method(:next_f_actor))
end
end
#--------------------------------------------------------------------------
# new method: prior_f_actor
#--------------------------------------------------------------------------
def prior_f_actor
if @f_actor_index && BattleManager.action_list(:actor).size > 0
@f_actor_index -= 1
@f_actor_index = 0 if @f_actor_index < 0
f_actor = BattleManager.action_list(:actor)[@f_actor_index]
if f_actor
BattleManager.set_actor(f_actor.index)
@status_window.select(BattleManager.actor.index)
@actor_command_window.setup(BattleManager.actor)
end
end
end
#--------------------------------------------------------------------------
# new method: next_f_actor
#--------------------------------------------------------------------------
def next_f_actor
if @f_actor_index && BattleManager.action_list(:actor).size > 0
@f_actor_index += 1
@f_actor_index = 0 if (@f_actor_index + 1) > BattleManager.action_list(:actor).size
f_actor = BattleManager.action_list(:actor)[@f_actor_index]
if f_actor
BattleManager.set_actor(f_actor.index)
@status_window.select(BattleManager.actor.index)
@actor_command_window.setup(BattleManager.actor)
end
end
end
#--------------------------------------------------------------------------
# alias method: turn_start
#--------------------------------------------------------------------------
alias catb_turn_start turn_start
def turn_start
if BattleManager.btype?(:catb)
@party_command_window.close
@actor_command_window.close
@status_window.unselect
@log_window.wait
@log_window.clear
else
catb_turn_start
end
end
#--------------------------------------------------------------------------
# alias method: command_guard
#--------------------------------------------------------------------------
alias catb_command_guard command_guard
def command_guard
BattleManager.actor.input.confirm = true
catb_command_guard
@status_window.draw_item(BattleManager.actor.index)
end
#--------------------------------------------------------------------------
# alias method: command_attack
#--------------------------------------------------------------------------
alias catb_command_attack command_attack
def command_attack
catb_command_attack
@status_window.draw_item(BattleManager.actor.index)
end
#--------------------------------------------------------------------------
# alias method: on_enemy_ok
#--------------------------------------------------------------------------
alias catb_on_enemy_ok on_enemy_ok
def on_enemy_ok
BattleManager.actor.input.confirm = true
catb_on_enemy_ok
end
#--------------------------------------------------------------------------
# alias method: on_enemy_cancel
#--------------------------------------------------------------------------
alias catb_on_enemy_cancel on_enemy_cancel
def on_enemy_cancel
BattleManager.actor.input.confirm = false
catb_on_enemy_cancel
@status_window.draw_item(BattleManager.actor.index)
end
#--------------------------------------------------------------------------
# alias method: on_actor_ok
#--------------------------------------------------------------------------
alias catb_on_actor_ok on_actor_ok
def on_actor_ok
BattleManager.actor.input.confirm = true
catb_on_actor_ok
end
#--------------------------------------------------------------------------
# alias method: on_actor_cancel
#--------------------------------------------------------------------------
alias catb_on_actor_cancel on_actor_cancel
def on_actor_cancel
BattleManager.actor.input.confirm = false
catb_on_actor_cancel
@status_window.draw_item(BattleManager.actor.index)
end
#--------------------------------------------------------------------------
# alias method: on_skill_ok
#--------------------------------------------------------------------------
alias catb_on_skill_ok on_skill_ok
def on_skill_ok
catb_on_skill_ok
@status_window.draw_item(BattleManager.actor.index)
end
#--------------------------------------------------------------------------
# alias method: on_item_ok
#--------------------------------------------------------------------------
alias catb_on_item_ok on_item_ok
def on_item_ok
catb_on_item_ok
@status_window.draw_item(BattleManager.actor.index)
end
#--------------------------------------------------------------------------
# alias method: update_info_viewport
#--------------------------------------------------------------------------
alias catb_update_info_viewport update_info_viewport
def update_info_viewport
catb_update_info_viewport
if BattleManager.btype?(:catb)
move_info_viewport(128) if @actor_command_window.active || @actor_window.active || @enemy_window.active || (($game_troop.all_dead? || $game_party.all_dead?)&& @bug_fix1)
move_info_viewport(0) if @party_command_window.active
end
end
#--------------------------------------------------------------------------
# rewrite method: perform_collapse_check
#--------------------------------------------------------------------------
def perform_collapse_check(target)
return if YEA::BATTLE::MSG_ADDED_STATES
if $game_troop.all_dead? || $game_party.all_dead?
if @actor_window.active || @enemy_window.active
@bug_fix1 = true
@help_window.hide
@actor_window.hide.deactivate
@enemy_window.hide.deactivate
end
end
target.perform_collapse_effect if target.can_collapse?
@log_window.wait
end
end # Scene_Battle
module YEA
module BATTLE
DEFAULT_BATTLE_SYSTEM = :catb
end
end
#==============================================================================
#
# ▼ End of File
#
#==============================================================================

复制代码