북극토끼 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	12393
RMVXA	[rpg maker vx ace] 메뉴에 아이템 세이브 게임종료 3	듀우우퐁	2014.07.13	1567
RMVXA	소지 아이템 초기화 2	GloomyDay	2014.07.13	633
RMVX	차지 기능?? 2	옵티머스	2014.07.13	645
RMVXA	전투문제... 1	슈퍼울트라그레이트딜리셔스	2014.07.13	529
기타	rpg형식게임 1	만원만s	2014.07.14	897
RMVXA	맵칩관련 질문입니다 1	월광공작	2014.07.14	913
RMVXA	스킬사용시 나는 소리가 랜덤으로 나오게 하는법	프라임헌터즈	2014.07.14	680
RMVXA	vx ace lite 버전은 어떤 기능이 제한되어 있는 건가요? (+한글패치 질문) 1	듀시아드	2014.07.14	853
RMVX	RPGVX 이름 띄우기 스크립트	겜제작광	2014.07.15	896
RMVXA	맵칩을 찾고있는대요 1	월광공작	2014.07.16	702
RMVXA	이미지 항상띄우고 거기에 옷입히기 같은 기능을 할 수 있는지.. 2	카슈엔1	2014.07.17	1204
RMVX	주인공이 1명인 게임인데 액터 고르는 메뉴스테이터스 안 나오도록 4	gyro2du	2014.07.18	936
RMVXA	겉의 서계처럼 억지로 끄면 뭐가 뜨도록 하는법	조각조각	2014.07.18	708
RMVXA	전투시 최대 전투 인원 수를 5명이상 늘리기 3	4차원소녀	2014.07.18	772
툴선택	윈도우(대사 나오는곳)위로 캐릭터(픽쳐)나오게 하기 3	옥세(Okse)	2014.07.19	1061
	RPG VX 판 메뉴창(ESC or x 키 누를시 나오는 메뉴시스템)을 전체 한글화 시키고싶은데요 4	유변세변능력자ek	2014.07.19	1120
기타	RPG VX 페이스 칩이 안되요 4	ddanggree	2014.07.19	941
기타	rpg vx 인데 오프닝을 만들고 나서 투명을 풀어도 투명상태가 안풀려요 5	ddanggree	2014.07.20	988
RMVXA	전투중 스킬사용시 애니메이션 끊김현상	FairyLover	2014.07.20	639
RMVX	저장 제한 1	파프리카	2014.07.20	556

쓰기