북극토끼 2014.07.19 06:31

##----------------------------------------------------------------------------##
## CP's Battle Engine v1.2b
## Created by Neon Black
##
## Only for non-commercial use. See full terms of use and contact info at:
## http://cphouseset.wordpress.com/liscense-and-terms-of-use/
##----------------------------------------------------------------------------##
##
##----------------------------------------------------------------------------##
## Revision Info:
## v1.2a+ in progress
## 1.2b released 1.26.2013 - Fixes vanishing enemy glitch
## v1.2 - 1.14.2013
## Added new actor/enemy tags similar to 2k3 options
## Added a simple sideview mode
## Added in battle party change options
## Changed battle animation queue into an array
## Changed the fix for the "to screen" overlay bug
## Numerous other small changes.
## v1.1 - 11.14.2012
## Added mode 5 to replicate VX/2k styles
## Removed compatibility with Foe Info View and Pop-ups v1.0 and v1.1
## Fixed a bug related to skill and item window sizes
## Slight tweaks and bugfixes
## v1.0a - 10.16.2012
## Single line fix
## v1.0 - 9.11.2012
## Final bugfixes and cleanup
## v0.3 - 9.10.2012
## Numerous bugfixes
## v0.2 - 8.23.2012
## Reorganized script
## v0.1 - 8.30.2012
## Wrote and debugged main script
##----------------------------------------------------------------------------##
##
$imported = {} if $imported.nil? ##
$imported["CP_BATTLEVIEW_2"] = 1.2 ##
##
##----------------------------------------------------------------------------##
## Instructions:
## Place this script in the script editor below "Materials" and above "Main".
## This script modifies the battle system to be more visually pleasing and
## gives it a few different additional features. There are numerous notebox
## tags available to change how several aspects of the battle system work.
##
##------
## Notebox Tags:
## Monster note tags:
##
## attack[x]
## - Sets a monster's normal attack animation to animation "x". This affects
## skills set to "normal attack" animation.
## attack skill[x]
## - Sets the monster's normal attack skill to skill "x". This is the skill
## they will use when they are berserk or confused.
## defend skill[x]
## - Same as above, but with defend. Doesn't really have any effect on
## monsters.
##
## Actor/Class note tags:
## Note that Actor takes priority in all these tags.
## battler[name]
## - Sets the actor's battler graphic to graphic "name". Note that it must be
## a file present in the folder "graphics/battlers". This only has effect
## in mode 4.
## side battler[name]
## - Sets the name of the image to use for battlers in sideview mode. If this
## is not set, the character's left facing graphic is used.
## attack skill[x]
## - Sets the actor's basic attack skill to kill "x". This affects the basic
## attack command as well as any party attack command or other command that
## makes the actor auto attack. Class version of this tag takes priority
## over Actor version.
## defend skill[x]
## - Same as above only with the defend skill. Class version of this tag
## takes priority over Actor version.
## hide mp -or- hide tp
## - Hides the stat reguardless of any other conditions. This stat will not
## appear for the character during battle.
##
## Monster and Actor/Class note tags:
## <flying>
## - Causes the actor or enemy to bob up and down in battle as if they are
## flying or floating.
## <transparent>
## - Causes the actor or enemy to become partially transparent.
## <mirror>
## - Mirrors the actor or enemy's battler sprite.
##
## Skill note tags:
## cast anim[x]
## - Sets the skill's casting animation to animation "x". This plays on the
## user of the skill before it is cast.
##
## Weapon note tags:
## attack skill[x]
## - Sets a characters default attack skill to skill ID "x" while the weapon
## is equipped. This takes priority over Actor and Class tags.
##
##------
## Setting up Actor Command Blocks:
## The commands an actor has in battle can be modified using the notebox. Note
## that you do not need to define this on any actor and actors that do not have
## this in their notebox will use the array at line 292 instead. This will
## allow you to have certain commands on certain characters but not on other
## characters. To do this, set up a section of the notebox in the following
## format:
##
## <commands>
## :attack
## :defend
## :skill
## Name => 10
## :item
## :party
## </commands>
##
## <commands>
## - Designates the start of the actor's commands. Must be used before any
## skills are checked for.
## :attack
## - The basic attack command will go here in the menu.
## :defend
## - The basic defend command will go here in the menu.
## :skill
## - All skill subsets an actor has will be placed here. These are the basic
## skill subsets that house the normal gameplay skills.
## :item
## - The items command will go here in the menu.
## :party
## - Allows the party member to switch out on their turn.
## Name => 10
## - Used to designate a special skill. The format is (I feel) relatively
## simple. The "Name" part is the name of the skill that will display in
## the command window. The number is the ID of the skill. Note that the
## skill conditions must still be met in order for the skill to be used.
##----------------------------------------------------------------------------##
##
module CP # Do not touch ##
module BATTLERS # these lines. ##
##
##----------------------------------------------------------------------------##
## Config:
## The config options are below. You can set these depending on the flavour of
## your game. Each option is explained in a bit more detail above it.
##
##------
# Graphical Config:

# First things first. This is the number of battlers you will have in battle.
# Be careful as this may have undesired effects with certain scripts outside
# of battle.
BATTLERS_MAX = 5
#배틀에 참여하는 멤버 수

# Allows members from the system tab to be added during test battles to
# increase the party size.
ADD_SYSTEM_MEMBERS = false

# This is the number of frames a single frame of battle animation will last.
# Lower numbers produce quicker and smoother animations. 3 or 4 are the best
# values.
ANIM_RATE = 4

# This is the option for determining battle style. There are 4 modes it can be
# set to based on the values you choose.
# Mode 1 = Looks like the default battle engine.
# Mode 2 = Similar but displays faces in the status window.
# Mode 3 = Displays character battlers. See above for note tags to set these.
# Mode 4 = Displays faces outside any window.
# Mode 5 = Simulates RM2K and RMVX styles with slight variations.
BATTLE_STYLE = 4
# 위의 숫자가 1일 경우 일반 배틀 모드
#2일 경우 얼굴 그래픽이 뜨는 배틀
#3일 경우 배틀러 표시 하지만 사용시 별도의 태그 설정이 필요함
#4일 경우 2의 경우와 비슷하지만 더 깔끔함
#5일 경우 rpg2000 vx 스타일 배틀

# This variable holds the battle style. You can change this in game to change
# the battle style.
VARIABLE = 51

# In mode 2, this is the opacity of the status window. In modes 3 and 4, this
# is the opacity of the actor command window.
WINDOW_OPACITY = 100

# If this option is set to true, the help window will always be open during
# actor command selection.
SHOW_HELP_WINDOW = false

# This is the size of the text for name, hp, mp, and tp in modes 2, 3, and 4.
LINE_HEIGHT = 16

# This determines if MP and TP are hidden when the user has no skills that use
# those types of pools. For example, if a user does not have any skills that
# use MP, MP will be hidden until one is obtained.
HIDE_UNUSED_POOLS = false

# Determines if the skill and item windows will have variable sizes based on
# the number available. If true, it will start with 1 row and add more if
# there are more items. In modes 1 and 2 this will try to fill the screen, in
# modes 3 and 4 this will cap at 4 rows before scrolling.
VAR_HEIGHT = false

# This is the y placement offset of the monsters in battle. This will allow
# you to shift all monster groups up or down without having to modify the
# groups themselves.
Y_OFFSET = 0

# This option corrects troop placement when the window is resized. No matter
# the window size, the troop position will be centered in the window based on
# the placement in the editor. Turn this off is using a script like Yanfly
# Core Engine that already does this.
RESIZE_CORRECTION = true

# This is the offset for animations that cover the screen and target the
# players party. This will allow these animations to be shifted down and
# actually cover the actors. This is disabled in sideview battles.
ANIM_OFFSET = 120

# This is the placement of actor battlers in mode 3 from the bottom of the
# screen. Use this to shift them up or down.
Y_PLACEMENT = -12

# This is the zoom of actor battlers. Use this to make them larger or smaller
# than normal battlers. This only affects mode 3 and does not affect sideview
# battlers.
ZOOM = 100

# This is the cast animation for when an item is used. Setting it to nil will
# prevent an animation from being displayed.
ITEM_ANIM = nil

# This hash contains the animations for when different skill types are used.
# Note that the skill note tag above takes priority. To use, use the format
# "x => y," where "x" is the ID of the skill group and "y" is the animation to
# display.
CAST_ANIMS ={
1 => 43,
2 => 81,
}

##------
# Party Config:

# These are the names for the new options that can be added to the party
# command window.
AUTO_NAME = "Auto"
RUSH_NAME = "All-out"
GUARD_NAME = "Defend"
PARTY_NAME = "Members"
SWITCH_NAME = "Switch"

# These are the commands to display in the party menu.
# :fight - Allows the player to select each action.
# :auto - Actors choose commands by auto.
# :rush - All actors attack the first enemy.
# :defend - All actors defend.
# :escape - Allows the player to flee from battle.
COMMANDS =[
:fight,
:auto,
:rush,
:guard,
:party,
:escape,
]

# These are the default abilities each actor in the party has. If an actor has
# an empty list of commands they will get this list instead. The notebox
# version of this takes priority. See the instructions section titled
# "Setting up Actor Command Blocks" for a list of valid commands. Additional
# commands from add-on scripts may be used here as well.
ABILITIES =[
:attack,
:skill,
:defend,
:item,
:party,
]

# This option determines what a character's state must be in order to switch
# them in battle.
# 0 = Members always movable.
# 1 = Members must be alive.
# 2 = Members must be able to act.
# 3 = Members must be able to recieve input.
# 4 = Members may not be inflicted with status at all.
MOVE_MEMBERS = 1

# If this option is enabled, the player can only use the switch command from
# the party command window once per turn.
RESTRICT_USAGE = true

# This sets the change in speed of party members who are switched out on their
# turn. Increasing this number makes the switch occur sooner.
SWITCH_SPEED = 0

# These are lines of text that can display when certain functions are performed
# in battle. You can use the strings <target>, <user>, and <skill> in the line
# and they will be automatically replaced with the name of the user, target, or
# skill.
SWITCH_LOG = "<target> has switched out with <user>."

# This hash contains the help text to be displayed while the cursor is over a
# skill group during battle. Note that each number is the same as the ID of
# the skill type in the data base, 0 is for while "items" is highlighted, and
# -1 is for while "party" is highlighted from the actor command window. You
# can have a second line by adding "\n" to the string."
SKILL_HELP_TEXT ={
-1 => "Switch places with a member on reserve.",
0 => "Uses an item from the party's inventory.",
1 => "Attack with a variety of offensive skills.",
2 => "Cast a variety of offensive and supportive magics.",
}

##------
# Sideview Battle System Config:
# This is the option to determine if sideview is turned on or off by default.
BATTLE_SIDE = false

# This is the switch that holds the sideview battle option. You can turn this
# switch ON to enable sideview and OFF to disable it.
SBS_SWITCH = 52

# These values are the X and Y positions of the actors' feet when the sideview
# system is enabled. Each number represents party position.
SBS_POS ={
1 => [ 462, 180 ],
2 => [ 480, 210 ],
3 => [ 492, 248 ],
4 => [ 500, 288 ],
}

# This option determines if animations are flipped when used by enemies. This
# allows the animations to display properly no matter if the party or troop is
# using the skill.
FLIP_ANIM = true

##------
# Add-on Config:
# These are additional config options for scripts deemed compatible with
# CPBE. These include such things as allowing the said scripts to be enabled
# or disabled by a switch, adding additional options, or extended cross
# support. Each add-on's options are listed below the name and supported
# version of the script.

# CP Battle Pop-ups v1.2+
# While the following switch is ON, battle pop-ups will NOT display.
POP_SWITCH = 51

##----------------------------------------------------------------------------##
##
##
##----------------------------------------------------------------------------##
## The following lines are the actual core code of the script. While you are
## certainly invited to look, modifying it may result in undesirable results.
## Modify at your own risk!
###----------------------------------------------------------------------------

HIDE_V = /hide (hp|mp|tp)/i
NAME = /battler\[(.+)\]/i
SIDE = /side battler\[(.+)\]/i
ATTACK = /attack\[(\d+)\]/i
CAST = /cast anim\[(\d+)\]/i
SCOMM = /:(attack|skill|defend|item)/
NCOMM = /(.*) => (\d+)/
COPEN = /<commands>/i
CCLOSE = /<\/commands>/
ATK_ID = /attack skill\[(\d+)\]/i
DEF_ID = /defend skill\[(\d+)\]/i
TRANS = /<transparent>/i
FLY = /<flying>/i
MIRROR = /<mirror>/i

def self.styles; return [1, 2, 3, 4, 5]; end

def self.style ## Gets the currently active style of the system.
unless styles.include?($game_variables[VARIABLE])
$game_variables[VARIABLE] = BATTLE_STYLE
end
return $game_variables[VARIABLE]
end

def self.sideview
$game_switches[SBS_SWITCH] = BATTLE_SIDE unless @init_side; @init_side = true
return $game_switches[SBS_SWITCH]
end

def self.style1; return style == 1; end
def self.style2; return style == 2; end
def self.style3; return style == 3; end
def self.style4; return style == 4; end
def self.style5; return style == 5; end

def self.classic; return [1, 2, 5].include?(style); end
def self.dated; return [3, 4].include?(style); end
def self.basic; return [1, 5].include?(style); end

def self.faceless; return [1, 3].include?(style); end
def self.face; return [2, 4].include?(style); end

def self.clear_pop
return $game_switches[POP_SWITCH]
end

end
end

module BattleManager
def self.input_start
if @phase != :input
@phase = :input
$game_troop.increase_turn ## Turn increase moved up here to fix the
$game_party.make_actions ## turn counting on foes.
$game_troop.make_actions
clear_actor
end
return !@surprise && $game_party.inputable?
end

def self.turn_start
@phase = :turn
clear_actor ## Removed turn count from here.
make_action_orders
end
end

class Game_Message
alias cp_bv2_add add
def add(text)
cp_bv2_add(text)
return unless CP::BATTLERS.style5 && $game_party.in_battle
@background = 2
end
end

class Game_Action
def targets_for_friends
if item.for_user?
[subject]
elsif item.for_dead_friend?
if item.for_one?
[friends_unit.smooth_dead_target(@target_index)]
else
friends_unit.dead_members
end
elsif item.for_friend?
if item.for_one? ## Added this line to add enemy healing AI.
evaluate_item if @target_index < 0
[friends_unit.smooth_target(@target_index)]
else
friends_unit.alive_members
end
end
end
end

class Game_Battler < Game_BattlerBase
attr_accessor :c_blinking ## Used to add blinking in modes 3 and 4.

alias cp_bv2_gb_init initialize
def initialize
cp_bv2_gb_init
@c_blinking = false
end
end

class Game_Enemy < Game_Battler
def atk_animation_id
if enemy.nattack_id == 0 ## Gets the animation of a foe's skill.
rs = $data_skills[attack_skill_id].animation_id == -1 ? 1 :
$data_skills[attack_skill_id].animation_id
else
rs = enemy.nattack_id
end
return rs
end

def attack_skill_id ## Gets the basic attack and defend skills of a foe.
enemy.sattack_id
end

def guard_skill_id
enemy.sdefend_id
end

def flying?
enemy.motion_flying
end

def transparent?
enemy.motion_trans
end

def mirrored?
enemy.motion_mirror
end
end

class Game_Actor < Game_Battler
attr_accessor :screen_x_pos_bv2
attr_accessor :screen_y_pos_bv2
attr_accessor :side_battler

def animation_mirror ## Mirrors animations displayed on actors.
@animation_mirror = false unless @animation_mirror
if CP::BATTLERS.sideview && CP::BATTLERS::FLIP_ANIM
return !@animation_mirror
else
return @animation_mirror
end
end

alias cp_bv2_setup setup
def setup(actor_id)
cp_bv2_setup(actor_id) ## Creates an actor's battler.
@battler_name = actor.battler_name
@battler_name = self.class.battler_name if @battler_name == ""
@side_battler = actor.side_battler
@side_battler = self.class.side_battler if @side_battler == ""
end

def use_sprite? ## Makes the actor use a sprite in certain modes.
return true if CP::BATTLERS.sideview
return false if CP::BATTLERS.basic
return true if CP::BATTLERS.face
return @battler_name == "" ? false : true
end

def all_commands ## Gets all of an actor's commands with skills.
res = commands.size
return res unless commands.include?(:skill)
res += added_skill_types.size - 1
return res
end

def commands ## Gets the actor's base commands.
return actor.commands unless actor.commands.empty?
return self.class.commands unless self.class.commands.empty?
return CP::BATTLERS::ABILITIES
end

def attack_skill_id ## Gets the actor's base attack skill.
unless weapons.empty? || weapons[0].attack_skill == 0
return weapons[0].attack_skill
end
return actor.sattack_id unless actor.sattack_id == 0
return self.class.sattack_id unless self.class.sattack_id == 0
return 1
end

def guard_skill_id ## Gets the actor's base guard skill.
return actor.sdefend_id unless actor.sdefend_id == 0
return self.class.sdefend_id unless self.class.sdefend_id == 0
return 2
end

def hide_mp? ## Hide MP and TP under certain conditions.
return true if actor.hide_mp?
if CP::BATTLERS::HIDE_UNUSED_POOLS
skills.each do |skill|
if $imported["CP_SKILLCOSTS"]
return false if skill_mp_cost(skill) > 0
return false if skill.all_mp
else
return false if skill.mp_cost > 0
end
end
return true
end
return false
end

def hide_tp?
return true if actor.hide_tp?
if CP::BATTLERS::HIDE_UNUSED_POOLS
skills.each do |skill|
if $imported["CP_SKILLCOSTS"]
return false if skill_tp_cost(skill) > 0
return false if skill.all_tp
else
return false if skill.tp_cost > 0
end
end
return true
end
return false
end

def flying?
actor.motion_flying
end

def transparent?
actor.motion_trans
end

def mirrored?
actor.motion_mirror
end
end

class Game_Party < Game_Unit
def max_battle_members ## The max allowed battle characters.
return CP::BATTLERS::BATTLERS_MAX
end

alias cp_bv2_setup_bt_addition setup_battle_test_members
def setup_battle_test_members ## Adds system members.
cp_bv2_setup_bt_addition
return unless CP::BATTLERS::ADD_SYSTEM_MEMBERS
$data_system.party_members.each {|m| add_actor(m)}
end
end

class Window_BattleLog < Window_Selectable
def max_line_number ## Changes the window for mode 5.
return CP::BATTLERS.style5 ? 4 : 6
end

def back_opacity
return CP::BATTLERS.style5 ? 0 : 64
end
end

class Window_PartyCommand < Window_Command
def visible_line_number ## Mods the size of an party's battle window.
return CP::BATTLERS.dated ? CP::BATTLERS::COMMANDS.size : 4
end

def make_command_list ## Creates a list of the commands.
CP::BATTLERS::COMMANDS.each do |com|
case com
when :fight
add_command(Vocab::fight, :fight)
when :auto
add_command(CP::BATTLERS::AUTO_NAME, :auto)
when :rush
add_command(CP::BATTLERS::RUSH_NAME, :rush)
when :guard
add_command(CP::BATTLERS::GUARD_NAME, :block)
when :escape
add_command(Vocab::escape, :escape, BattleManager.can_escape?)
when :party
add_command(CP::BATTLERS::PARTY_NAME, :party, SceneManager.scene.switch? &&
$game_party.all_members.size > $game_party.max_battle_members)
end
end
end
end

class Window_ActorCommand < Window_Command
def visible_line_number ## Gets the size of the actor's battle window.
return 4 if @actor.nil? || CP::BATTLERS.classic
i = @actor.all_commands
h = @help_window ? @help_window.height : 0
return [i, (Graphics.height - (120 + h)) / line_height].min
end

def make_command_list ## Makes the list of commands.
size1 = fitting_height(visible_line_number)
size2 = Graphics.height - 120
self.height = [size1, size2].min unless self.disposed?
return unless @actor
@actor.commands.each do |comm|
if comm.is_a?(Symbol) ## Gets each command by it's symbol.
case comm
when :attack
add_command(Vocab::attack, :attack, @actor.attack_usable?,
@actor.attack_skill_id)
when :skill
@actor.added_skill_types.sort.each do |stype_id|
name = $data_system.skill_types[stype_id]
add_command(name, :skill, true, stype_id)
end
when :defend
add_command(Vocab::guard, :guard, @actor.guard_usable?,
@actor.guard_skill_id)
when :item
add_command(Vocab::item, :item)
when :party
add_command(CP::BATTLERS::SWITCH_NAME, :party,
$game_party.all_members.size > $game_party.max_battle_members)
else
addon_command(comm)
end
elsif comm.is_a?(Array)
can_use = @actor.usable?($data_skills[comm[1]])
add_command(comm[0], :cp_command, can_use, comm[1])
end
end
end

unless method_defined?(:addon_command)
def addon_command(comm)
end
end

def update
super ## Makes the window stay open or closed during modes 3/4.
return if CP::BATTLERS.classic
self.hide if !active
self.show if (active || ![0, 255].include?(openness))
end

def update_help ## Updates the help window if it is turned on.
case current_symbol ## Get the command's help by symbol.
when :attack, :guard, :cp_command
@help_window.set_item($data_skills[current_ext])
when :skill
@help_window.set_text("") unless CP::BATTLERS::SKILL_HELP_TEXT.include?(current_ext)
@help_window.set_text(CP::BATTLERS::SKILL_HELP_TEXT[current_ext])
when :item
@help_window.set_text(CP::BATTLERS::SKILL_HELP_TEXT[0])
@help_window.set_text("") unless CP::BATTLERS::SKILL_HELP_TEXT.include?(0)
when :party
@help_window.set_text(CP::BATTLERS::SKILL_HELP_TEXT[-1])
@help_window.set_text("") unless CP::BATTLERS::SKILL_HELP_TEXT.include?(-1)
else
addon_help_update(current_symbol)
end
end

unless method_defined?(:addon_help_update)
def addon_help_update(sym)
end
end
end

class Window_BattleStatus < Window_Selectable
def window_width ## Creates the party box width by mode.
return CP::BATTLERS.classic ? Graphics.width - 128 : Graphics.width
end

def window_height ## Gets the size of the party box by mode.
return fitting_height(visible_line_number) if CP::BATTLERS.basic
return 96 + standard_padding * 2 ## This is technically the same.
end ## The values that need this are more or less hard coded anyway....

def col_max ## Gets the max columns for other modes.
return CP::BATTLERS.basic ? 1 : $game_party.max_battle_members
end

def spacing ## Spacing. Modded for certain types for a better feel.
return 32 if CP::BATTLERS.basic
return 0 if CP::BATTLERS.style2
return standard_padding * 2
end

def item_height ## Changes the height based on the current mode.
return CP::BATTLERS.basic ? line_height : 96
end

def line_height ## Changes the height of window items based on mode.
return CP::BATTLERS.basic ? 24 : CP::BATTLERS::LINE_HEIGHT
end

alias cp_bv2_old_draw_item draw_item
def draw_item(index) ## Draws different contents based on the mode.
return cp_bv2_old_draw_item(index) if CP::BATTLERS.basic
contents.font.size = line_height
actor = $game_party.battle_members[index]
rect = rect_by_style(index)
draw_bv2_face(actor, rect, index) if CP::BATTLERS.style2
draw_basic_area_bv2(rect, actor)
draw_gauge_area_bv2(rect, actor)
contents.font.size = Font.default_size
end

def draw_bv2_face(actor, rect, nd) ## Modded faces for modes 2/3.
face_name = actor.face_name; face_index = actor.face_index
bitmap = Cache.face(face_name)
bt = Bitmap.new(96, 96)
src = Rect.new(face_index % 4 * 96, face_index / 4 * 96, 96, 96)
bt.blt(0, 0, bitmap, src)
size = Rect.new((96 - rect.width) / 2, 0, rect.width, rect.height)
contents.blt(rect.x, rect.y, bt, size, trans?(nd) ? 255 : translucent_alpha)
end

def trans?(index) ## Determines if the face is transparent or not.
return true if @index == -1
return (index == @index)
end

def rect_by_style(index) ## Gets the item rectangle based on the style.
rect = item_rect(index)
return rect if CP::BATTLERS.faceless
sides = rect.width - 96
if sides > 0
rect.width -= sides
rect.x += sides / 2
end
cw = contents.width / CP::BATTLERS::BATTLERS_MAX
rect.width = [rect.width, cw].min if CP::BATTLERS.style2
return rect
end

def draw_basic_area_bv2(rect, actor) ## Draws the basic HUD items.
bottom = rect.y + rect.height
i_w = contents.text_size(actor.name).width
ncen = (rect.width - i_w) / 2
total_icons = actor.state_icons.size + actor.buff_icons.size
icen = [rect.width - total_icons * 24, rect.width % 24].max
faces = CP::BATTLERS.face
iy = faces ? bottom - line_height * 2 - 24 : rect.y
ny = faces ? rect.y : bottom - line_height * 3
draw_object_back(rect.x, ny, rect.width, ncen)
draw_actor_name(actor, rect.x + ncen, ny, rect.width)
draw_actor_icons(actor, rect.x + icen / 2, iy, rect.width - icen)
end

def draw_object_back(x, y, width, edge)
l_h = line_height - 6 ## The fancy back used by the name on the HUD.
c1 = gauge_back_color
c1.alpha = 0
c2 = gauge_back_color
c2.alpha = 192
temp = Bitmap.new(width, l_h)
temp.gradient_fill_rect(0, 0, edge, l_h, c1, c2)
temp.gradient_fill_rect(0 + width - edge, 0, edge, l_h, c2, c1)
temp.fill_rect(0 + edge, 0, width - edge * 2, l_h, c2)
contents.blt(x, y + 6, temp, temp.rect)
end

def draw_gauge_area_bv2(rect, actor)
if $data_system.opt_display_tp ## Draws either with or without TP.
draw_gauge_area_with_tp_bv2(rect, actor)
else
draw_gauge_area_without_tp_bv2(rect, actor)
end
end

def draw_gauge_area_with_tp_bv2(rect, actor)
return draw_gauge_area_without_tp_bv2(rect, actor, :mp) if actor.hide_tp?
return draw_gauge_area_without_tp_bv2(rect, actor, :tp) if actor.hide_mp?
bottom = rect.y + rect.height ## The with TP drawing.
cen = rect.width / 2
draw_actor_hp(actor, rect.x, bottom - line_height * 2, rect.width)
draw_actor_mp(actor, rect.x, bottom - line_height, cen)
draw_actor_tp(actor, rect.x + cen, bottom - line_height, cen)
end

def draw_gauge_area_without_tp_bv2(rect, actor, val = :mp)
bottom = rect.y + rect.height ## Without TP.
i = CP::BATTLERS.style3 ? 2 : val == :mp && actor.hide_mp? ? 1 :
val == :tp && actor.hide_tp? ? 1 : 2
draw_actor_hp(actor, rect.x, bottom - line_height * i, rect.width)
if val == :mp
return if actor.hide_mp?
draw_actor_mp(actor, rect.x, bottom - line_height, rect.width)
elsif val == :tp
return if actor.hide_tp?
draw_actor_tp(actor, rect.x, bottom - line_height, rect.width)
end
end

def draw_gauge_area_with_tp(rect, actor) ## Modded old methods.
return draw_gauge_area_without_tp(rect, actor, :mp) if actor.hide_tp?
return draw_gauge_area_without_tp(rect, actor, :tp) if actor.hide_mp?
draw_actor_hp(actor, rect.x + 0, rect.y, 72)
draw_actor_mp(actor, rect.x + 82, rect.y, 64)
draw_actor_tp(actor, rect.x + 156, rect.y, 64)
end

def draw_gauge_area_without_tp(rect, actor, val = :mp)
if val == :mp
if actor.hide_mp?
draw_actor_hp(actor, rect.x + 0, rect.y, 220)
else
draw_actor_hp(actor, rect.x + 0, rect.y, 134)
draw_actor_mp(actor, rect.x + 144, rect.y, 76)
end
elsif val == :tp
if actor.hide_tp?
draw_actor_hp(actor, rect.x + 0, rect.y, 220)
else
draw_actor_hp(actor, rect.x + 0, rect.y, 134)
draw_actor_tp(actor, rect.x + 144, rect.y, 76)
end
else
draw_actor_hp(actor, rect.x + 0, rect.y, 220)
end
end

def update_cursor ## Determines how to show the cursor by mode.
refresh if CP::BATTLERS.style2
return super if CP::BATTLERS.basic
cursor_rect.empty
end
end

class Window_BattleActor < Window_BattleStatus
def col_max ## Max columns used by the party target window.
return CP::BATTLERS.dated ? item_max : 1
end

def item_max ## Max items. Always the same....
return $game_party.battle_members.size
end

def window_height ## The height based on mode.
return fitting_height(visible_line_number)
end

def visible_line_number ## Used for above method.
return CP::BATTLERS.dated ? 1 : 4
end

def line_height
return 24 ## Used to overwrite the super.
end

def item_width ## Width. Always the same....
return width - (standard_padding * 2)
end

def item_height ## Once again, overwrites super.
return line_height
end

def contents_width ## Same as above.
return (item_width + spacing) * col_max - spacing
end

def draw_item(index) ## Draws a horizontal view of battle status.
actor = $game_party.battle_members[index]
draw_basic_area(basic_area_rect(index), actor)
draw_gauge_area(gauge_area_rect(index), actor)
end

def skill_viewport=(skill_viewport)
@skill_viewport = skill_viewport
end

alias cp_bv2_show_old show
def show ## Shows the box and selects the first item.
@skill_viewport.rect.width = Graphics.width - width if @skill_viewport
return cp_bv2_show_old if CP::BATTLERS.classic
select(0)
super
end

alias cp_bv2_hide_old hide
def hide ## Hides the window and stops all blinking.
cp_bv2_hide_old
@skill_viewport.rect.width = Graphics.width if @skill_viewport
$game_party.battle_members.each {|m| m.c_blinking = false}
end

def process_cursor_move ## Prevents left/right wrapping.
return unless cursor_movable?
last_index = @index
cursor_down (Input.trigger?(:DOWN)) if Input.repeat?(:DOWN)
cursor_up (Input.trigger?(:UP)) if Input.repeat?(:UP)
cursor_right(false) if Input.repeat?(:RIGHT)
cursor_left (false) if Input.repeat?(:LEFT)
cursor_pagedown if !handle?(:pagedown) && Input.trigger?(:R)
cursor_pageup if !handle?(:pageup) && Input.trigger?(:L)
Sound.play_cursor if @index != last_index
end

def current_item_enabled? ## Gets which members are properly allowed.
return true if @dead_members
case CP::BATTLERS::MOVE_MEMBERS
when 1
return $game_party.battle_members[@index].alive?
when 2
return $game_party.battle_members[@index].movable?
when 3
return $game_party.battle_members[@index].inputable?
when 4
return $game_party.battle_members[@index].normal?
else
return true
end
return false
end

def ensure_cursor_visible ## Ensures the proper actor is displayed.
return super if CP::BATTLERS.classic
self.ox = @index * (item_width + spacing)
end

def update_cursor ## Modded to make actors blink.
return super if CP::BATTLERS.basic
$game_party.battle_members.each {|m| m.c_blinking = @cursor_all}
if @cursor_all
cursor_rect.set(0, 0, contents.width, row_max * item_height)
self.top_row = 0
elsif @index < 0
cursor_rect.empty
else
ensure_cursor_visible
cursor_rect.set(item_rect(@index))
mem = $game_party.battle_members[@index]
mem.c_blinking = true unless mem.nil?
end
end

def activate(dead = true) ## Determines if dead members may be selected.
super()
@dead_members = dead
end
end

class Winodw_ExtraMembers < Window_BattleActor
def item_max ## Max items. Always the same....
return extra_members.size
end

def extra_members ## Members not currently in the party.
return $game_party.all_members - $game_party.battle_members
end

def draw_item(index) ## Draws a horizontal view of battle status.
actor = extra_members[index]
draw_basic_area(basic_area_rect(index), actor)
draw_gauge_area(gauge_area_rect(index), actor)
end

def actor_window=(actor_window)
@actor_window = actor_window
end

def current_item_enabled?
return true if @dead_members
return false if last_for_dead
return false if already_switch_in
case CP::BATTLERS::MOVE_MEMBERS
when 1
return extra_members[@index].alive?
when 2
return extra_members[@index].movable?
when 3
return extra_members[@index].inputable?
when 4
return extra_members[@index].normal?
else
return true
end
return false
end

def last_for_dead ## Prevents filling the party with dead members.
return false unless @actor_window
return false if $game_party.alive_members.size > 1
return false unless $game_party.battle_members[@actor_window.index].alive?
return false if extra_members[@index].alive?
return true
end

def already_switch_in ## Prevents a member from being switched in twice.
$game_party.battle_members.each do |mem|
mem.actions.each do |act|
next if act.item.nil? || act.item.swap_party.nil?
id = act.item.swap_party
return true if id == $game_party.all_members.index(extra_members[@index])
end
end
return false
end

def update_cursor
if @cursor_all
cursor_rect.set(0, 0, contents.width, row_max * item_height)
self.top_row = 0
elsif @index < 0
cursor_rect.empty
else
ensure_cursor_visible
cursor_rect.set(item_rect(@index))
end
end

def activate(dead = true)
super()
@dead_members = dead
end
end

class Window_BattleEnemy < Window_Selectable
def col_max ## Mods it's own size based on style.
return 2 if CP::BATTLERS.classic
return 3
end

alias cp_bv2_wind_width window_width
def window_width ## Mods it's width based on style.
return cp_bv2_wind_width if CP::BATTLERS.classic
return Graphics.width
end

def update_cursor ## Causes enemies to blink.
$game_troop.alive_members.each {|m| m.c_blinking = @cursor_all}
if @cursor_all
cursor_rect.set(0, 0, contents.width, row_max * item_height)
self.top_row = 0
elsif @index < 0
$game_troop.alive_members.each {|m| m.c_blinking = false}
cursor_rect.empty
else
mem = $game_troop.alive_members[@index]
mem.c_blinking = true unless mem.nil?
ensure_cursor_visible
cursor_rect.set(item_rect(@index))
end ## Added method for old script.
if !active
$game_troop.alive_members.each {|m| m.c_blinking = false}
end
end

def skill_viewport=(skill_viewport)
@skill_viewport = skill_viewport
end

alias cp_bv2_show_old show
def show ## Changes the info viewport by style. Ignored with CP Battleview.
@skill_viewport.rect.width = Graphics.width - width if @skill_viewport
return cp_bv2_show_old if CP::BATTLERS.classic
if @info_viewport
tot = [(item_max / col_max + (item_max % col_max > 0 ? 1 : 0)), 1].max
self.height = fitting_height(tot)
create_contents
refresh
self.x = 0
self.y = Graphics.height - height
hr = @info_viewport.rect.height - height
@info_viewport.rect.height = hr
select(0)
end
super
end

alias cp_bv2_hide hide
def hide ## Reverts the info viewport to normal.
cp_bv2_hide
@skill_viewport.rect.width = Graphics.width if @skill_viewport
if @info_viewport
@info_viewport.rect.height = Graphics.height - @info_viewport.rect.y
end
$game_troop.alive_members.each {|m| m.c_blinking = false}
end
end

class Window_BattleSkill < Window_SkillList
def top_lines ## Gets the max number of lines.
return CP::BATTLERS.classic ? 99 : 4
end

def modded_height ## Changes the window's height.
if CP::BATTLERS::VAR_HEIGHT
lines = [(item_max / col_max + (item_max % col_max > 0 ? 1 : 0)), 1].max
else
lines = top_lines
end ## Will find the best fit based on the number of items.
set = (line_height * [top_lines, lines].min) + (standard_padding * 2)
return [set, @info_viewport.rect.y - y].min
end

def info_viewport=(window)
@info_viewport = window
end

alias cp_bv2_show show
def show ## Update the height when the window is shown.
self.height = modded_height unless CP::BATTLERS.style5
self.height = fitting_height(4) if CP::BATTLERS.style5
@info_viewport.visible = false if CP::BATTLERS.style5
refresh
cp_bv2_show
end

def hide ## Modded to prevent the help window from vanishing.
@help_window.hide unless CP::BATTLERS::SHOW_HELP_WINDOW
@info_viewport.visible = true if CP::BATTLERS.style5
super
end
end

class Window_BattleItem < Window_ItemList
def top_lines ## Same as the class above.
return CP::BATTLERS.classic ? 99 : 4
end

def modded_height
if CP::BATTLERS::VAR_HEIGHT
lines = [(item_max / col_max + (item_max % col_max > 0 ? 1 : 0)), 1].max
else
lines = top_lines
end
set = (line_height * [top_lines, lines].min) + (standard_padding * 2)
return [set, @info_viewport.rect.y - y].min
end

def info_viewport=(window)
@info_viewport = window
end

alias cp_bv2_show show
def show ## Update the height when the window is shown.
self.height = modded_height unless CP::BATTLERS.style5
self.height = fitting_height(4) if CP::BATTLERS.style5
@info_viewport.visible = false if CP::BATTLERS.style5
refresh
cp_bv2_show
end

def hide ## Modded to prevent the help window from vanishing.
@help_window.hide unless CP::BATTLERS::SHOW_HELP_WINDOW
@info_viewport.visible = true if CP::BATTLERS.style5
super
end
end

class Scene_Battle < Scene_Base ## The blood and guts of the script!!
alias cp_bv2_create_info_viewport create_info_viewport
def create_info_viewport ## Lots of changes here.
cp_bv2_create_info_viewport ## Changes some aspects of certain windows.
opac = CP::BATTLERS::WINDOW_OPACITY
@status_window.back_opacity = opac if CP::BATTLERS.style2
@status_window.opacity = 0 if CP::BATTLERS.dated
@spriteset.info(@info_viewport, @status_window) if CP::BATTLERS.style4
return unless CP::BATTLERS.style2
$game_party.members.each_with_index do |mem, i|
edge = 64 + @status_window.standard_padding
rec = @status_window.width - (@status_window.standard_padding * 2)
rec /= $game_party.max_battle_members
l_offset = @status_window.height - @status_window.standard_padding
mem.screen_x_pos_bv2 = edge + rec * i + rec / 2
mem.screen_y_pos_bv2 = Graphics.height - l_offset
end
end

alias cp_bv2_party_window create_party_command_window
def create_party_command_window
cp_bv2_party_window ## Adds commands to the party window.
@party_command_window.viewport = nil unless CP::BATTLERS.classic
@party_command_window.set_handler(:auto, method(:command_auto))
@party_command_window.set_handler(:rush, method(:command_rush))
@party_command_window.set_handler(:block, method(:command_block))
@party_command_window.set_handler(:party, method(:command_party))
end

alias cp_bv2_clog_window create_log_window
def create_log_window
cp_bv2_clog_window
return unless CP::BATTLERS.style5
@log_window.y = Graphics.height - @log_window.height
@log_window2 = Window_Base.new(0, @log_window.y, @log_window.width,
@log_window.height)
@log_window2.openness = 255
end

alias cp_bv2_create_item_window create_item_window
def create_item_window
cp_bv2_create_item_window
@skill_viewport = Viewport.new
return unless CP::BATTLERS.style5
@item_window.y = 0
@skill_window.y = 0
@item_window.info_viewport = @info_viewport
@skill_window.info_viewport = @info_viewport
@skill_viewport.rect.y = @info_viewport.rect.y
@skill_viewport.rect.height = @item_window.height
@skill_viewport.z = 100
@item_window.viewport = @skill_viewport
@skill_window.viewport = @skill_viewport
end

alias cp_bv2_actor_window create_actor_command_window
def create_actor_command_window
cp_bv2_actor_window ## Adds a new command to the actor window.
@actor_command_window.set_handler(:cp_command, method(:command_new_comms))
@actor_command_window.set_handler(:party, method(:command_switch))
return if CP::BATTLERS.classic
@actor_command_window.viewport = nil ## May change window opacity.
@actor_command_window.back_opacity = CP::BATTLERS::WINDOW_OPACITY
end

alias cp_bv2_help_window create_help_window
def create_help_window
cp_bv2_help_window
return unless CP::BATTLERS::SHOW_HELP_WINDOW
@help_window.visible = true ## Prevents removal of the help window.
@help_window.openness = 0
@actor_command_window.help_window = @help_window
end

alias cp_bv2_create_enemy_window create_enemy_window
def create_enemy_window
cp_bv2_create_enemy_window
@enemy_window.skill_viewport = @skill_viewport
@actor_window.skill_viewport = @skill_viewport
end

alias cp_bv2_create_actor_window create_actor_window
def create_actor_window
cp_bv2_create_actor_window
@extras_window = Winodw_ExtraMembers.new(@info_viewport)
@extras_window.actor_window = @actor_window
@extras_window.set_handler(:ok, method(:on_extras_ok))
@extras_window.set_handler(:cancel, method(:on_extras_cancel))
end

def command_attack ## Makes the basic attack command like other commands.
skill = $data_skills[BattleManager.actor.attack_skill_id]
command_new_comms(skill)
end

def command_guard ## Same as attack command but with defend.
skill = $data_skills[BattleManager.actor.guard_skill_id]
command_new_comms(skill)
end

def command_party
@party_command_window.hide unless CP::BATTLERS.classic
select_actor_selection
@actor_window.activate(false)
end

def command_switch
unless CP::BATTLERS.classic
@actor_command_window.hide
ypos = 0
ypos = @help_window.y + @help_window.height if @help_window.visible &&
@help_window.open?
@extras_window.y = ypos
end
BattleManager.actor.input.set_swap_party(0)
@extras_window.refresh
@actor_window.select($game_party.battle_members.index(BattleManager.actor))
@extras_window.show.activate(false)
end

def command_new_comms(skl = nil) ## Pushes the selected command.
skill = skl ? skl : $data_skills[@actor_command_window.current_ext]
BattleManager.actor.input.set_skill(skill.id)
if !skill.need_selection? ## Determines selection type.
next_command
elsif skill.for_opponent?
select_enemy_selection
else
select_actor_selection
end
end

alias cp_bv2_select_actor select_actor_selection
def select_actor_selection
cp_bv2_select_actor
return if CP::BATTLERS.classic
ypos = 0 ## Determines where to put the status window.
ypos = @help_window.y + @help_window.height if @help_window.visible &&
@help_window.open?
ypos = @skill_window.y + @skill_window.height if @skill_window.visible
ypos = @item_window.y + @item_window.height if @item_window.visible
@actor_window.y = ypos
end

alias cp_bv2_on_a_ok on_actor_ok
def on_actor_ok
if @party_command_window.current_symbol == :party
if CP::BATTLERS.classic
@actor_window.hide
else
ypos = 0
ypos = @actor_window.y + @actor_window.height if @actor_window.visible
@extras_window.y = ypos
end
@extras_window.refresh
@extras_window.show.activate(false)
else
cp_bv2_on_a_ok
end
end

alias cp_bv2_on_e_cancel on_enemy_cancel
def on_enemy_cancel
cp_bv2_on_e_cancel ## Allows the cursor to return to it's index normally.
case @actor_command_window.current_symbol
when :cp_command, :attack, :guard
@actor_command_window.activate
end
end

alias cp_bv2_on_a_cancel on_actor_cancel
def on_actor_cancel
cp_bv2_on_a_cancel ## Same as above.
if @party_command_window.current_symbol == :party
@party_command_window.show.activate
else
case @actor_command_window.current_symbol
when :cp_command, :attack, :guard
@actor_command_window.activate
end
end
end

def on_extras_ok
if @party_command_window.current_symbol == :party
i = @actor_window.index
n = @actor_window.item_max + @extras_window.index
$game_party.swap_order(i, n)
$game_party.make_actions
@status_window.refresh
@extras_window.hide
@actor_window.hide
@spriteset.dispose_actors
@spriteset.create_actors
@party_command_window.show.activate
@already_party = CP::BATTLERS::RESTRICT_USAGE
@party_command_window.refresh
else
n = @actor_window.item_max + @extras_window.index
BattleManager.actor.input.set_swap_party(n)
@extras_window.hide
next_command
end
end

def on_extras_cancel
@extras_window.hide
if @party_command_window.current_symbol == :party
i = @actor_window.index
select_actor_selection
@actor_window.select(i)
else
@actor_command_window.show.activate
end
end

alias cp_bv2_status_create create_actor_window
def create_actor_window
cp_bv2_status_create ## Mods the status window viewport OX by style.
@info_viewport.ox = 128 unless CP::BATTLERS.classic
end

def show_attack_animation(targets, user = @subject)
if user.actor? ## Fixes how animations are shown by battler.
show_normal_animation(targets, user.atk_animation_id1, false)
show_normal_animation(targets, user.atk_animation_id2, true)
else
show_normal_animation(targets, user.atk_animation_id, false)
end
end

def command_auto ## Creates auto commands on actor selection.
while BattleManager.next_command
BattleManager.actor.make_auto_battle_actions
end
turn_start
end

def command_rush ## Makes all party members auto attack.
while BattleManager.next_command
BattleManager.actor.input.set_attack
BattleManager.actor.input.target_index = 0
next if BattleManager.actor.input.item.for_opponent?
BattleManager.actor.input.evaluate_item
end
turn_start
end

def command_block ## Makes all party members block.
while BattleManager.next_command
BattleManager.actor.input.set_guard
end
turn_start
end

alias cp_bv2_turn_start turn_start
def turn_start ## Motion of several modified windows.
@help_window.close if CP::BATTLERS::SHOW_HELP_WINDOW
if CP::BATTLERS.style5
@status_window.openness = 0
@actor_command_window.openness = 0
@party_command_window.openness = 0
@log_window2.openness = 255
$game_message.background = 2
end
return cp_bv2_turn_start if CP::BATTLERS.classic
@actor_command_window.openness = 0 if !@actor_command_window.visible
cp_bv2_turn_start
end

def start_actor_command_selection
@status_window.select(BattleManager.actor.index)
@party_command_window.close unless CP::BATTLERS.style5
@actor_command_window.setup(BattleManager.actor)
@help_window.open if CP::BATTLERS::SHOW_HELP_WINDOW
return if CP::BATTLERS.classic
th = @status_window.height + @actor_command_window.height
@actor_command_window.y = Graphics.height - th
slo = Graphics.width / $game_party.max_battle_members
pos = (slo * BattleManager.actor.index) + slo / 2
@actor_command_window.x = pos - @actor_command_window.width / 2
@actor_command_window.x = 0 if @actor_command_window.x < 0
grmw = Graphics.width - @actor_command_window.width
@actor_command_window.x = grmw if @actor_command_window.x > grmw
end

def start_party_command_selection
@help_window.close if CP::BATTLERS::SHOW_HELP_WINDOW
unless scene_changing?
if CP::BATTLERS.style5
@info_viewport.ox = 0 if @info_viewport.ox == 64
@actor_command_window.openness = 255
@party_command_window.openness = 255
@status_window.openness = 255
@log_window2.openness = 0
end
refresh_status
@status_window.unselect
@status_window.open
if BattleManager.input_start
@actor_command_window.close unless CP::BATTLERS.style5
@party_command_window.setup
else
@party_command_window.deactivate
turn_start
end
end
end

alias cp_bv2_up_info_view update_info_viewport
def update_info_viewport ## Ignores viewport movement in some styles.
return cp_bv2_up_info_view unless CP::BATTLERS.dated
end

def process_action
return if scene_changing?
if !@subject || !@subject.current_action
@subject = BattleManager.next_subject
end
return turn_end unless @subject
if @subject.current_action
@subject.current_action.prepare
if @subject.current_action.valid?
@status_window.open unless CP::BATTLERS.style5 ## Only added this.
execute_action
end
@subject.remove_current_action
end
process_action_end unless @subject.current_action
end

def execute_action ## Creates the casting animations.
if @subject.current_action.item.swap_party.nil?
@log_window.display_use_item(@subject, @subject.current_action.item)
item = @subject.current_action.item
sid = nil
sid = :item if item.is_a?(RPG::Item)
sid = item.stype_id if item.is_a?(RPG::Skill)
cst = item.is_a?(RPG::UsableItem) ? item.cast_anim : 0
perform_casting_use(sid, cst)
end
@log_window.clear
use_item
@log_window.wait_and_clear
end

def perform_casting_use(type = nil, cast = 0)
if type.nil? ## Finds and performs the proper casting animations.
@subject.sprite_effect_type = :whiten
abs_wait_short
elsif cast > 0
@subject.animation_id = cast
wait_for_animation
elsif type == :item && !CP::BATTLERS::ITEM_ANIM.nil?
@subject.animation_id = CP::BATTLERS::ITEM_ANIM
wait_for_animation
elsif type.is_a?(Integer) && CP::BATTLERS::CAST_ANIMS.include?(type)
@subject.animation_id = CP::BATTLERS::CAST_ANIMS[type]
wait_for_animation
else
@subject.sprite_effect_type = :whiten
abs_wait_short
end
end

def invoke_counter_attack(target, item) ## Modified counter.
@log_window.display_counter(target, item)
attack_skill = $data_skills[target.attack_skill_id]
if attack_skill.for_opponent? ## Gets the attack's target.
tgs = [@subject] * [attack_skill.number_of_targets, 1].max
else
tgs = [target] * [attack_skill.number_of_targets, 1].max
end
if attack_skill.animation_id < 0 ## Shows the attack anim.
show_attack_animation(tgs, target)
else
show_normal_animation(tgs, attack_skill.animation_id)
end ## Performs the counter attack.
tgs.each {|t| attack_skill.repeats.times {do_counter(target, attack_skill)}}
end

alias cp_basic_check_substitute check_substitute
def check_substitute(target, item) ## Prevents covering friendly attacks.
return false if @subject.enemy? and target.enemy?
return cp_basic_check_substitute(target, item)
end

def do_counter(user, item) ## Modified counter to properly use party skills.
target = item.for_opponent? ? @subject : user
target.item_apply(user, item)
refresh_status
@log_window.display_action_results(target, item)
end

alias cp_bv2_turn_end turn_end
def turn_end ## Process party switch cooldown.
@already_party = false
temp = []
$data_skills.each do |a|
next if a.nil?
next if a.swap_party.nil?
temp.push(a)
end
$data_skills -= temp
cp_bv2_turn_end
end

def switch? ## Check if the party has already been switched.
@already_party = false if @already_party.nil?
return !@already_party
end

alias cp_bv2_use_item use_item
def use_item ## Process an actor set switch.
item = @subject.current_action.item
if !item.swap_party.nil? && item.swap_party > 0
user_swap_party
else
cp_bv2_use_item
end
end

unless method_defined?(:user_swap_party)
def user_swap_party ## Perform the basic switch.
item = @subject.current_action.item
text = CP::BATTLERS::SWITCH_LOG.gsub(/<user>/i, @subject.name)
text.gsub!(/<target>/i, $game_party.all_members[item.swap_party].name)
text.gsub!(/<skill>/i, CP::BATTLERS::SWITCH_NAME)
@log_window.add_text(text)
i = $game_party.all_members.index(@subject)
n = item.swap_party
$game_party.swap_order(i, n)
@status_window.refresh
@spriteset.dispose_actors
@spriteset.create_actors
end
end
end

class Game_Action ## Adds a switch skill and who to switch with.
def set_swap_party(id = 0)
if id > 0
$data_skills.push(RPG::Skill.new)
$data_skills[-1].swap_party = id
$data_skills[-1].speed += CP::BATTLERS::SWITCH_SPEED
$data_skills[-1].id = $data_skills.size - 1
@item.object = $data_skills[-1]
else
@item.object = $data_skills[1]
end
self
end
end

class Animation_Class
attr_accessor :animation
attr_accessor :ani_duration
attr_accessor :ani_mirror
attr_accessor :ani_rate
attr_accessor :ani_bitmap1
attr_accessor :ani_bitmap2
attr_accessor :ani_sprites
attr_accessor :ani_duplicated
attr_accessor :ani_ox
attr_accessor :ani_oy
end

class Sprite_Base < Sprite
@@ani_checker_frame = 0

alias cp_bv2_spb_init initialize
def initialize(*args)
@ani_array = [] ## Adds an animation array.
cp_bv2_spb_init(*args)
end

def dispose
super ## Dispose each element of the array.
@ani_array.each {|ani| dispose_animation(ani)}
end

def update
super ## FIX THE LEGACY BUG!
update_animation
@@ani_checker.clear unless @@ani_checker_frame == Graphics.frame_count
@@ani_spr_checker.clear unless @@ani_checker_frame == Graphics.frame_count
@@ani_checker_frame = Graphics.frame_count
end

def animation? ## Checks if the animation array is empty.
!@ani_array.empty?
end

def start_animation(animation, mirror = false)
if animation ## Adds a new animation to the array.
@ani_array.push(Animation_Class.new)
ani = @ani_array[-1]
ani.animation = animation
ani.ani_mirror = mirror
set_animation_rate(-1)
ani.ani_duration = ani.animation.frame_max * ani.ani_rate + 1
load_animation_bitmap(ani)
make_animation_sprites(ani)
set_animation_origin(ani)
end
end

def set_animation_rate(i = -1) ## Sets the rate to make anims flow better.
@ani_array[i].ani_rate = CP::BATTLERS::ANIM_RATE
end

def load_animation_bitmap(ani = nil)
return unless ani ## Loads an animation into the array.
animation1_name = ani.animation.animation1_name
animation1_hue = ani.animation.animation1_hue
animation2_name = ani.animation.animation2_name
animation2_hue = ani.animation.animation2_hue
ani.ani_bitmap1 = Cache.animation(animation1_name, animation1_hue)
ani.ani_bitmap2 = Cache.animation(animation2_name, animation2_hue)
if @@_reference_count.include?(ani.ani_bitmap1)
@@_reference_count[ani.ani_bitmap1] += 1
else
@@_reference_count[ani.ani_bitmap1] = 1
end
if @@_reference_count.include?(ani.ani_bitmap2)
@@_reference_count[ani.ani_bitmap2] += 1
else
@@_reference_count[ani.ani_bitmap2] = 1
end
Graphics.frame_reset
end

def make_animation_sprites(ani = nil)
return unless ani ## Makes the sprites for the array.
ani.ani_sprites = []
if @use_sprite && !@@ani_spr_checker.include?(ani.animation)
16.times do
sprite = ::Sprite.new(viewport)
sprite.visible = false
ani.ani_sprites.push(sprite)
end
if ani.animation.position == 3
@@ani_spr_checker.push(ani.animation)
end
end
ani.ani_duplicated = @@ani_checker.include?(ani.animation)
if !ani.ani_duplicated && ani.animation.position == 3
@@ani_checker.push(ani.animation)
end
end

def set_animation_origin(ani = nil)
return unless ani ## Sets the origin... for the array.
if ani.animation.position == 3
if viewport == nil
ani.ani_ox = Graphics.width / 2
ani.ani_oy = Graphics.height / 2
else
ani.ani_ox = viewport.rect.width / 2
ani.ani_oy = viewport.rect.height / 2
end
else
ani.ani_ox = x - ox + width / 2
ani.ani_oy = y - oy + height / 2
if ani.animation.position == 0
ani.ani_oy -= height / 2
elsif ani.animation.position == 2
ani.ani_oy += height / 2
end
end
end

def dispose_animation(ani = nil)
return unless ani ## Need I say it?
if ani.ani_bitmap1
@@_reference_count[ani.ani_bitmap1] -= 1
if @@_reference_count[ani.ani_bitmap1] == 0
@@_reference_count.delete(ani.ani_bitmap1)
ani.ani_bitmap1.dispose
end
end
if ani.ani_bitmap2
@@_reference_count[ani.ani_bitmap2] -= 1
if @@_reference_count[ani.ani_bitmap2] == 0
@@_reference_count.delete(ani.ani_bitmap2)
ani.ani_bitmap2.dispose
end
end
if ani.ani_sprites
ani.ani_sprites.each {|sprite| sprite.dispose }
end ## Deletes the position in the array.
@ani_array.delete_at(@ani_array.index(ani))
end

def update_animation ## Updates each animation in the array.
return unless animation?
@ani_array.each do |ani|
ani.ani_duration -= 1
if ani.ani_duration % ani.ani_rate == 0
if ani.ani_duration > 0
frame_index = ani.animation.frame_max
frame_index -= (ani.ani_duration + ani.ani_rate - 1) / ani.ani_rate
animation_set_sprites(ani.animation.frames[frame_index], ani)
ani.animation.timings.each do |timing|
animation_process_timing(timing, ani) if timing.frame == frame_index
end
else
end_animation(ani)
end
end
end
end

def end_animation(ani = nil)
dispose_animation(ani) ## I think I took something out of this.
end

def animation_set_sprites(frame, ani = nil)
return unless ani
cell_data = frame.cell_data
ani.ani_sprites.each_with_index do |sprite, i|
next unless sprite
pattern = cell_data[i, 0]
if !pattern || pattern < 0
sprite.visible = false
next
end
sprite.bitmap = pattern < 100 ? ani.ani_bitmap1 : ani.ani_bitmap2
sprite.visible = true
sprite.src_rect.set(pattern % 5 * 192,
pattern % 100 / 5 * 192, 192, 192)
if ani.ani_mirror
sprite.x = ani.ani_ox - cell_data[i, 1]
sprite.y = ani.ani_oy + cell_data[i, 2]
sprite.angle = (360 - cell_data[i, 4])
sprite.mirror = (cell_data[i, 5] == 0)
else
sprite.x = ani.ani_ox + cell_data[i, 1]
sprite.y = ani.ani_oy + cell_data[i, 2]
sprite.angle = cell_data[i, 4]
sprite.mirror = (cell_data[i, 5] == 1)
end ## Adjust the animation position.
ofs = CP::BATTLERS.sideview ? 0 : CP::BATTLERS::ANIM_OFFSET
sprite.y += ofs if ani.animation.to_screen? && @battler && @battler.actor?
sprite.z = self.z + 300 + i
sprite.ox = 96
sprite.oy = 96
sprite.zoom_x = cell_data[i, 3] / 100.0
sprite.zoom_y = cell_data[i, 3] / 100.0
sprite.opacity = cell_data[i, 6] ## Ignore transparency.
sprite.blend_type = cell_data[i, 7]
end
end

def animation_process_timing(timing, ani = nil)
return unless ani ## Made once again for the array.
timing.se.play unless ani.ani_duplicated
case timing.flash_scope
when 1
self.flash(timing.flash_color, timing.flash_duration * ani.ani_rate)
when 2
if viewport && !ani.ani_duplicated
viewport.flash(timing.flash_color, timing.flash_duration * ani.ani_rate)
end
when 3
self.flash(nil, timing.flash_duration * ani.ani_rate)
end
end
end

class Sprite_Character < Sprite_Base
def end_animation(*args)
super(*args) ## Ensures sprites work.
@character.animation_id = 0
end

def move_animation(dx, dy)
@ani_array.each do |ani|
if ani.animation && ani.animation.position != 3
ani.ani_ox += dx
ani.ani_oy += dy
ani.ani_sprites.each do |sprite|
sprite.x += dx
sprite.y += dy
end
end
end
end
end

class Sprite_Battler < Sprite_Base
attr_accessor :viewport4

def opacity=(i)
n = @battler.transparent? ? i * 0.62 : i
super(n)
end

alias cp_bv2_init_vis init_visibility
def init_visibility
self.opacity = 255
cp_bv2_init_vis
end

def flying_offset
return self.oy unless @battler.flying?
frames = 480
@flying_add = 2.0 + rand if @flying_add.nil?
@flying_frame = rand(frames).to_f if @flying_frame.nil?
@flying_frame += @flying_add
ra = ((@flying_frame % frames).to_f / frames) * 360
offset = 6 * Math.sin(ra * Math::PI / 180)
return (self.height - 3) + offset
end

alias cp_bv2_sb_init initialize
def initialize(viewport, battler = nil, use = true)
@used_sprite = use
if !use
return super() if CP::BATTLERS.basic
return super() if battler.battler_name == "" && !CP::BATTLERS.face
end
cp_bv2_sb_init(viewport, battler)
update
end

alias cp_bv2_sb_update update
def update ## Updates the blinking effect in modes 3/4.
if $imported["CP_BATTLEVIEW"] && $imported["CP_BATTLEVIEW"] >= 1.2
@battler.popup.clear if CP::BATTLERS.clear_pop
end
#return cp_bv2_sb_update if CP::BATTLERS.sideview
@c_blinking = 0 if @c_blinking.nil?
@c_blinking += 1; @c_blinking %= 80
cp_bv2_sb_update
end

alias cp_bv2_update_bitmap update_bitmap
def update_bitmap ## Modified update to get faces and battlers.
if @used_sprite && CP::BATTLERS.sideview && @battler.actor?
update_sideview_bitmap
elsif @battler.enemy? || CP::BATTLERS.faceless
self.mirror = @battler.mirrored?
cp_bv2_update_bitmap
elsif CP::BATTLERS.style4
if @battler.face_name != @old_face_name ||
@battler.face_index != @old_face_index
temp = Cache.face(@battler.face_name)
face_index = @battler.face_index
rect = Rect.new(face_index % 4 * 96, face_index / 4 * 96, 96, 96)
new_bitmap = Bitmap.new(96, 96)
new_bitmap.blt(0, 0, temp, rect)
self.bitmap = new_bitmap
@old_face_name = @battler.face_name
@old_face_index = @battler.face_index
init_visibility
self.opacity = 1000
end
end
end

unless method_defined?(:update_sideview_bitmap)
def update_sideview_bitmap ## Creates a sideview battler.
unless @battler.side_battler.empty?
new_bitmap = Cache.battler(@battler.side_battler, @battler.battler_hue)
self.mirror = @battler.mirrored?
if bitmap != new_bitmap
self.bitmap = new_bitmap
init_visibility
end
else
if @battler.character_name != @old_char_name ||
@battler.character_index != @old_char_index
temp = Cache.character(@battler.character_name)
sign = @battler.character_name[/^[\!\$]./]
if sign && sign.include?('$')
cw = temp.width / 3
ch = temp.height / 4
else
cw = temp.width / 12
ch = temp.height / 8
end
n = @battler.character_index
src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch + ch, cw, ch)
new_bitmap = Bitmap.new(cw, ch)
new_bitmap.blt(0, 0, temp, src_rect)
self.bitmap = new_bitmap
@old_char_name = @battler.character_name
@old_char_index = @battler.character_index
init_visibility
end
end
end
end

alias cp_bv2_update_position update_position
def update_position ## Updates position on modes 2-4.
self.oy = flying_offset
if @battler.enemy?
cp_bv2_update_position
self.y += CP::BATTLERS::Y_OFFSET unless CP::BATTLERS.sideview
return unless CP::BATTLERS::RESIZE_CORRECTION
self.y += Graphics.height - 416
self.x += (Graphics.width - 544) / 2
else
return sideview_pos if CP::BATTLERS.sideview && @used_sprite
return move_style_2 if CP::BATTLERS.style2
i = $game_party.battle_members.index(@battler)
l = Graphics.width / $game_party.max_battle_members
self.x = l * i + l / 2
self.y = Graphics.height - 12
self.z = 100
return if CP::BATTLERS.face
zoom = CP::BATTLERS::ZOOM.to_f / 100
self.y = Graphics.height + CP::BATTLERS::Y_PLACEMENT
self.zoom_x = zoom
self.zoom_y = zoom
end
end

unless method_defined?(:sideview_pos)
def sideview_pos
i = $game_party.battle_members.index(@battler)
return unless i
i += 1
if CP::BATTLERS::SBS_POS.include?(i)
self.x = CP::BATTLERS::SBS_POS[i][0]
self.y = CP::BATTLERS::SBS_POS[i][1]
self.z = 100
end
end
end

def move_style_2 ## Places blank battlers during mode 2.
return if @battler.screen_x_pos_bv2.nil?
return if @battler.screen_y_pos_bv2.nil?
self.x = @battler.screen_x_pos_bv2
self.y = @battler.screen_y_pos_bv2
self.z = 100
end

unless $imported["CP_VIEWED"]
alias cp_bv2_update_effect update_effect
def update_effect ## Updates the blinking effect.
cp_bv2_update_effect
return if CP::BATTLERS.sideview
return unless @effect_type.nil?
if @battler.c_blinking
update_blinking_effect
else
remove_blinking_effect
end
end
end

def update_blinking_effect ## Actually does what I said above.
return if CP::BATTLERS.sideview && @used_sprite
i = @c_blinking > 40 ? 80 - @c_blinking : @c_blinking
create_backlit if @backlit_s.nil?
@backlit_s.opacity = i * 2 + 155
if @battler_visible
self.color.set(160, 200, 255, 0)
self.color.set(255, 120, 120, 0) if @battler.enemy?
self.color.alpha = i * 2
end
end

def remove_blinking_effect ## Stops the blinking effect.
remove_backlit if @backlit_s
self.color.set(255, 255, 255, 0)
end

def create_backlit ## Creates the backlit sprite.
@backlit_s = ::Sprite.new(viewport)
return unless CP::BATTLERS.dated
return unless width > 0 && height > 0
@backlit_s.x = x
@backlit_s.y = y - 10
@backlit_s.z = z
@backlit_s.ox = ox
@backlit_s.oy = oy
@backlit_s.zoom_x = zoom_x
@backlit_s.zoom_y = zoom_y
@backlit_s.opacity = opacity
@backlit_s.bitmap = Bitmap.new(width, height)
@backlit_s.bitmap.blt(0, 0, bitmap, src_rect)
@backlit_s.color.set(255, 255, 200, 255)
@backlit_s.color.set(255, 160, 160, 255) if @battler.enemy?
end

def remove_backlit ## Removes above sprite.
@backlit_s.dispose
@backlit_s = nil
end
end

class Spriteset_Battle
alias cp_new_viewports create_viewports
def create_viewports
cp_new_viewports ## Adds a new actor viewport.
@viewport4 = Viewport.new
@viewport4.z = 25
@viewport4.visible = false if CP::BATTLERS.style4
end

alias cp_update_viewports_bv2 update_viewports
def update_viewports ## Updates the new viewport.
cp_update_viewports_bv2
@viewport4.tone.set($game_troop.screen.tone)
@viewport4.ox = $game_troop.screen.shake if CP::BATTLERS.style3
@viewport4.update
update_info_viewport if @info_viewport
end

def update_info_viewport ## Changes the actor viewport during mode 3.
@viewport4.rect.width = @info_viewport.rect.width
@viewport4.rect.height = @info_viewport.rect.y + @info_viewport.rect.height
@viewport4.visible = @window_status.open?
end

alias cp_dispose_viewports_bv2 dispose_viewports
def dispose_viewports ## Disposes the viewport.
cp_dispose_viewports_bv2
@viewport4.dispose
end

def create_enemies ## Tells enemy sprites where viewport 4 is.
@enemy_sprites = $game_troop.members.reverse.collect do |enemy|
Sprite_Battler.new(@viewport1, enemy)
end
@enemy_sprites.each {|sprite| sprite.viewport4 = @viewport4}
end

def create_actors ## Creates the actor sprites.
@extra_sprites = []
@actor_sprites = $game_party.battle_members.collect do |actor|
create_viewed_battler(actor)
end
@actor_sprites.each {|sprite| sprite.viewport4 = @viewport4}
end

def create_viewed_battler(actor)
basic_sprite = Sprite_Battler.new(@viewport4, actor, !CP::BATTLERS.sideview)
return basic_sprite unless CP::BATTLERS.sideview
if $imported["CP_VIEWED"] ## Bookmarked.
side_sprite = cp_viewed_battler_create ## Used for the later sideview mod.
else
side_sprite = Sprite_Battler.new(@viewport1, actor)
end
@extra_sprites.push(basic_sprite) if @extra_sprites
return side_sprite
end

alias cp_bv2_dispose_act dispose_actors
def dispose_actors
cp_bv2_dispose_act
@extra_sprites.each {|sprite| sprite.dispose }
end

def info(viewport, status) ## Gets the battle viewports.
@info_viewport = viewport
@window_status = status
end
end

class RPG::BaseItem
def battler_name
set_b_name if @battler_name.nil?
return @battler_name
end

def side_battler
set_b_name if @side_battler.nil?
return @side_battler
end

def hide_hp?
set_b_name if @hide_hp.nil?
return @hide_hp
end

def hide_mp?
set_b_name if @hide_mp.nil?
return @hide_mp
end

def hide_tp?
set_b_name if @hide_tp.nil?
return @hide_tp
end

def sattack_id
set_b_name if @sattack_id.nil?
return @sattack_id
end

def sdefend_id
set_b_name if @sdefend_id.nil?
return @sdefend_id
end

def commands
create_comms if @commands.nil?
return @commands
end

def motion_flying
set_b_name if @motion_flying.nil?
return @motion_flying
end

def motion_trans
set_b_name if @motion_trans.nil?
return @motion_trans
end

def motion_mirror
set_b_name if @motion_mirror.nil?
return @motion_mirror
end

def set_b_name
@battler_name = "" unless @battler_name
@side_battler = ""
@hide_hp = false; @hide_mp = false; @hide_tp = false
@sattack_id = 0
@sdefend_id = 0
@motion_flying = false; @motion_trans = false; @motion_mirror = false
note.split(/[\r\n]+/).each do |line|
case line
when CP::BATTLERS::SIDE
@side_battler = $1.to_s
when CP::BATTLERS::NAME
@battler_name = $1.to_s
when CP::BATTLERS::HIDE_V
case $1.to_sym.downcase
when :hp
@hide_hp = true
when :mp
@hide_mp = true
when :tp
@hide_tp = true
end
when CP::BATTLERS::ATK_ID
@sattack_id = $1.to_i
when CP::BATTLERS::DEF_ID
@sdefend_id = $1.to_i
when CP::BATTLERS::TRANS
@motion_trans = true
when CP::BATTLERS::FLY
@motion_flying = true
when CP::BATTLERS::MIRROR
@motion_mirror = true
end
end
end

def create_comms
@commands = []
in_comm = false
note.split(/[\r\n]+/).each do |line|
case line
when CP::BATTLERS::COPEN
in_comm = true
when CP::BATTLERS::CCLOSE
in_comm = false
break
when CP::BATTLERS::SCOMM
next unless in_comm
@commands.push($1.to_sym)
when CP::BATTLERS::NCOMM
next unless in_comm
@commands.push([$1.to_s, $2.to_i])
end
end
end
end

class RPG::Enemy < RPG::BaseItem
def nattack_id
set_a_id if @nattack_id.nil?
return @nattack_id
end

def sattack_id
set_a_id if @sattack_id.nil?
return @sattack_id
end

def sdefend_id
set_a_id if @sdefend_id.nil?
return @sdefend_id
end

def set_a_id
@nattack_id = 0
@sattack_id = 1
@sdefend_id = 2
note.split(/[\r\n]+/).each do |line|
case line
when CP::BATTLERS::ATTACK
@nattack_id = $1.to_i
when CP::BATTLERS::ATK_ID
@sattack_id = $1.to_i
when CP::BATTLERS::DEF_ID
@sdefend_id = $1.to_i
end
end
end
end

class RPG::UsableItem < RPG::BaseItem
attr_accessor :swap_party

def cast_anim
set_cast_anim if @cast_anim.nil?
return @cast_anim
end

def set_cast_anim
@cast_anim = 0
note.split(/[\r\n]+/).each do |line|
case line
when CP::BATTLERS::CAST
@cast_anim = $1.to_i
end
end
end
end

class RPG::Weapon < RPG::EquipItem
def attack_skill
set_weapon_attack_skill if @attack_skill.nil?
return @attack_skill
end

def set_weapon_attack_skill
@attack_skill = 0
note.split(/[\r\n]+/).each do |line|
case line
when CP::BATTLERS::ATK_ID
@attack_skill = $1.to_i
end
end
end
end

###--------------------------------------------------------------------------###
# End of script. #
###--------------------------------------------------------------------------###

댓글
북극토끼 2014.07.19 06:33

이 스크립트를 사용하신다면 크래딧에 Neon Black님을 넣어주셔야 합니다. 다른 전투 스크립트와 호환되지 않을 가능성이 큽니다.

댓글
4차원소녀 2014.07.19 07:12

그렇군요 :0
답변 감사합니다!

댓글

Category

List of Articles
종류	분류	제목	글쓴이	날짜	조회 수
	공지	묻고 답하기 가이드	습작	2014.06.14	12392
	RMVXA	전투에서 데미지를 줄 수 없다는데... 3	Tape	2012.08.01	1378
액션 전투	RMMV	전투에서 데미지를 입었을 때에 TP획득 을 없애고 싶습니다. 2	게임제작초보자	2021.04.13	105
	RMVXA	전투에서 공격할 수 없다는데... 4	Tape	2012.08.02	1413
	RMVXA	전투에서 게이지바에 있는 숫자만 지우고싶습니다. 1	쇼몬아레하	2012.08.18	1642
	RMVXA	전투에서 1턴에 행동을 여러번 하도록 만들려는데 어떻게 해야되나요? 2	Fortissimo	2017.08.06	105
	RMVXA	전투에서 1번액터의 HP만 표시하는법	기폭	2016.01.28	112
	RMVXA	전투에 참여하지 않는 5번째도 경험치을 함계 얻고 싶은데 어떻게 해야될까요? 2	chaeringus	2013.06.18	705
	RMMV	전투에 참가하지 않는 플레이어를 만들고 싶습니다.	padarkbot	2017.01.14	122
스크립트 사용	RMXP	전투에 들어가도 맵브금이 그대로 흘러가는 스크립트 없을까요?	꼬맹E	2020.05.03	81
	RMVXA	전투에 관한 스크립트를 찾습니다...	sakuragi	2016.02.18	107
	RMVX	전투없이 대화로 몬스터를 등록할 때 생기는 오류 7	알렌솜니움	2014.02.18	636
	RMVX	전투씬 설정 1	krmojo	2018.01.10	132
	RMVXA	전투실행할때 전투 안에 그림 못 넣나요?	아이어리이	2013.09.14	1261
	RMVXA	전투신에서 에러가 납니다. 2	WOLLEYSGB	2017.08.17	171
	RMVXA	전투시에도 1초마다 변수 상승시키는 방법이 뭔가요? 2	wkdrn33	2014.07.11	655
	RMMV	전투시에 커먼 이벤트의 IF절이 작동하지 않습니다 2	스네이쿠	2015.11.23	197
	RMVXA	전투시스템을 변경하는 스크립트를 적용하면 오류가 납니다... 1	Bronya	2015.10.15	254
	RMVXA	전투시스템 관련하여 질문입니다 ㅠㅠ 4	천지설화	2016.09.20	159
	RMVX	전투시스템 관련 질문이 있어요;;; 2	니노미야	2010.09.09	2708
	RMVXA	전투시 특정 캐릭터만 공격을 못하게 하고 싶습니다. 3	qjsu	2013.09.27	936

쓰기