My script goes here# Changes to the bitmap class to add a function which can draw gradient bars
class Bitmap
# Draw a rectangle with a gradient color shift from color1 to color2
# Goes from left to right, or top to bottom if vertical is set
def draw_gradient_rect(x, y, width, height, color1, color2, vertical=false)
# Determine what will limit the draw
limit = vertical ? height: width
for i in 0..limit
# Calculate the color1 multiplier for its color
mul = (limit - i).to_f / limit
# Calculate the new color for this part of the gradient
color = Color.new(
mul * (color1.red - color2.red) + color2.red,
mul * (color1.green - color2.green) + color2.green,
mul * (color1.blue - color2.blue) + color2.blue
)
# Draw the portion of the rectangle with the new color
if vertical
self.fill_rect(x, y+i, width,1, color)
else
self.fill_rect(x+i, y, 1, height, color)
end
end
end
end
#---------------------
# Changes to the Window_Base class where Draw_Actor_HP/SP reside
class Window_Base < Window
# --------
# Change the Draw_Actor_HP function so a gradient bar appears to show how
# much HP the actor has left
alias draw_actor_hp_healthgauges draw_actor_hp unless $@
def draw_actor_hp(actor, x, y, width = 144)
# First create the health gauge!
# Define colors for the gauges and the empty part of the gauge
# Color1 is the left of the gauge, Color2 is the right
health_gauge_color_1 = Color.new(228, 164, 32)
health_gauge_color_2 = Color.new(255, 128, 64)
black_color = Color.new(0, 0, 0)
# Define the dimensions of the gauge in pixels
height = 12
x_offset = 0
y_offset = 20
# If the actor has HP left...
if actor.hp > 0
# Draw the full gauge first
self.contents.draw_gradient_rect(
x + x_offset,
y + y_offset,
width,
height,
health_gauge_color_1,
health_gauge_color_2
)
# If HP isn't maxed out, we'll have to draw the empty part of the gauge
if actor.hp < actor.maxhp
# Calculate how long the empty part of thegauge is (it will be at least one pixel wide and it won't be as long as the health gauge)
empty_width = [[(width * (1 - actor.hp.to_f / actor.maxhp)).to_i, 1].max, width - 1].min
# Now draw the empty part of the bar using this width
self.contents.fill_rect(
width - empty_width + x + x_offset + 1,
y+y_offset,
empty_width,
height,
black_color
)
end
else
# The actor has no HP, just show a big black bar
self.contents.fill_rect(x+x_offset, y+y_offset, width, height, black_color)
end
# Now draw the HP value by calling the original method
draw_actor_hp_healthgauges(actor, x, y, width)
end
# ------------
# Change the Draw_Actor_SP function so it draws a gradient bar to show the
# amount of SP the actor has left
alias draw_actor_sp_healthgauges draw_actor_sp unless $@
def draw_actor_sp(actor, x, y, width = 144)
# First create the SP gauge!
# Define colors for the gauges and the empty part of the gauge
# Color1 is the left of the gauge, Color2 is the right
sp_gauge_color_1 = Color.new(132, 32, 128)
sp_gauge_color_2 = Color.new(64, 64, 255)
black_color = Color.new(0, 0, 0)
# Define the dimensions of the gauge in pixels
height = 12
x_offset = 0
y_offset = 20
# If the actor has SP left...
if actor.sp > 0
# Draw the full gauge first
self.contents.draw_gradient_rect(
x + x_offset,
y + y_offset,
width,
height,
sp_gauge_color_1,
sp_gauge_color_2
)
# If SP isn't maxed out, we'll have to draw the empty part of the gauge
if actor.sp < actor.maxsp
# Calculate how long the empty part of thegauge is (it will be at least one pixel wide and it won't be as long as the health gauge)
empty_width = [[(width * (1 - actor.sp.to_f / actor.maxsp)).to_i, 1].max, width - 1].min
# Now draw the empty part of the bar using this width
self.contents.fill_rect(
width - empty_width + x + x_offset + 1,
y+y_offset,
empty_width,
height,
black_color
)
end
else
# Just draw a big black empty bar
self.contents.fill_rect(x+x_offset, y+y_offset, width, height, black_color)
end
# Now draw the SP value by calling the original method
draw_actor_sp_healthgauges(actor, x, y, width)
end
end#==============================================================================
# ** Animated Battlers - Enhanced ver. 10.5 (01-20-2007)
#
#------------------------------------------------------------------------------
# * (2) Sprite System: The Sprite Battler Class
#==============================================================================
#==============================================================================
# ** Sprite_Battler
#------------------------------------------------------------------------------
# This sprite is used to display the battler.It observes the Game_Character
# class and automatically changes sprite conditions.
#==============================================================================
class Sprite_Battler < RPG::Sprite
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :battler_offset # Degree of action forcing
attr_accessor :skill_used # Degree of action forcing
attr_accessor :item_used # Degree of action forcing
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
alias mnk_init initialize
def initialize(viewport, battler = nil)
# --Initialize poses
@frame, @pose, @last_time, @last_move_time = 0, 0, 0, 0
# --Initialize Battler placement and pose types
@battler_offset, @skill_used, @item_used = 0, 0, 0
# --Initialize Boolean values
@statusd = false
@dying = true
@s_pose = false
$game_system.victory = false
$game_system.defeat = false
@winning = true
# ORIGINAL Initialize call
mnk_init(viewport, battler)
# EVENT VALUE CALLS
# --Obtain the Sideview switch
$game_system.sv_angle = $sideview_mirror
$game_system.sv_angle = 0 if $sideview_mirror == nil
# -- Obtain the max party size
$game_system.max_member = $formation_max_member
$game_system.max_member = 4 if $formation_max_member == nil
# --Obtain the highest position for the formation
$game_system.form_top = $formation_max_height
$game_system.form_top = 220 if $formation_max_height == nil
# --Obtain the formation's width
$game_system.form_wd = $formation_max_width
$game_system.form_wd = 128 if $formation_max_width == nil
# --Obtain the height of the Battlestatus Window
$game_system.bstat_ht = $battlestatus_height
$game_system.bstat_ht = 160 if $battlestatus_height == nil
end
#--------------------------------------------------------------------------
# * Update
#--------------------------------------------------------------------------
alias mnk_update update
def update
# Only perform sprite edit for valid battlers
return unless @battler
if @battler.battler_name != @battler_name
@started = false
end
# Regular Update
mnk_update
# Set Translucency
if @battler.is_a?(Game_Enemy)
battler_translucency(@battler, MNK_TRANSLUCENT_ENEMY)
else
battler_translucency(@battler, MNK_TRANSLUCENT_ACTOR)
end
# Reset hash for Advanced Pose/Frames
pose_temp = {}
# Start Routine (Performed at startup for each battler)
unless @started
# Set the pose based on battler's state
@pose = state
# Turn off Casting pose
@battler.casted = false
@battler.casting = false
# Configure Enemy Spritesheet
if @battler.is_a?(Game_Enemy)
# Use spritesheet unless specified
unless DEFAULT_ENEMY or DEFAULT_ENEMY_ID.include?(@battler.id)
@width = @width / cell_divider(MNK_FRAMES_ENEMY, MNK_FRAMES)
@height = @height / cell_divider(MNK_POSES_ENEMY, MNK_POSES)
end
# Or Configure Actor Spritesheet
else
# Use spritesheet unless specified
unless DEFAULT_ACTOR or DEFAULT_ACTOR_ID.include?(@battler.id)
@width = @width / cell_divider(MNK_FRAMES_ACTOR, MNK_FRAMES)
@height = @height / cell_divider(MNK_POSES_ACTOR, MNK_POSES)
end
end
# Distance the battlers
@battler_offset = @width * 0.75
# Obtain battler position (simulating 3-Dness)
@display_x = @battler.screen_x
@display_y = @battler.screen_y
@display_z = @battler.screen_z
@destination_x = @display_x
@destination_y = @display_y
@destination_z = @display_z
# Opacity fadein feature
self.opacity = 0 if MNK_FADE_IN
# Make invisible if dead at battle start
self.visible = false if @battler.dead?
# Set the started flag
@started = true
# End of Start Routine (for each battler)
end
# Again, ensure a pose is set
@pose = state if @pose == nil
# Obtain animation cell/frame from Enemy
if @battler.is_a?(Game_Enemy)
# Use spritesheet cell unless specified
unless DEFAULT_ENEMY or DEFAULT_ENEMY_ID.include?(@battler.id)
cell_obtain
else
self.src_rect.set(0, 0, @width, @height)
end
# Or get it from an actor
else
# Use spritesheet cell unless specified
unless DEFAULT_ACTOR or DEFAULT_ACTOR_ID.include?(@battler.id)
cell_obtain
else
self.src_rect.set(0, 0, @width, @height)
end
end
# Position Sprite
self.x = @display_x
self.y = @display_y
self.z = @display_z
self.ox = @width / 2
self.oy = @height
# Party Turned Around
# $game_temp.advantage_set == 6
# Adjust sprite direction if facing the other way...
if $game_system.sv_angle == 1
if @battler.is_a?(Game_Actor)
mirror_pose_unless(6)
else
if MNK_MIRROR_ENEMIES
mirror_pose_if(5)
else
mirror_pose_unless(5)
end
end
else
if @battler.is_a?(Game_Actor)
mirror_pose_if(6)
else
if MNK_MIRROR_ENEMIES
mirror_pose_unless(5)
else
mirror_pose_if(5)
end
end
end
# Setup Frames per Pose
poseframe = MNK_FRAMES_STANDARD
if @battler.is_a?(Game_Actor)
poseframe = cell_divider(MNK_FRAMES_ACTOR, MNK_FRAMES_STANDARD) if cell_divider(MNK_FRAMES_ACTOR, MNK_FRAMES_STANDARD) != nil
else
poseframe = cell_divider(MNK_FRAMES_ENEMY, MNK_FRAMES_STANDARD) if cell_divider(MNK_FRAMES_ENEMY, MNK_FRAMES_STANDARD) != nil
end
pose_chk = 0
pose_chk = @pose+1 if @pose != nil
poseframe = MNK_FRAMES_PER_POSE[pose_chk] if MNK_FRAMES_PER_POSE.include?(pose_chk)
# Set Advanced Poses for Actors
if @battler.is_a?(Game_Actor)
pose_temp = MNK_POSES_FR_ACTOR[@battler.id] if MNK_POSES_FR_ACTOR.include?(@battler.id)
poseframe = pose_temp[pose_chk] if pose_temp.include?(pose_chk)
end
# Set Advanced Poses for Enemies
if @battler.is_a?(Game_Enemy)
pose_temp = MNK_POSES_FR_ENEMY[@battler.id] if MNK_POSES_FR_ENEMY.include?(@battler.id)
poseframe = pose_temp[pose_chk] if pose_temp.include?(pose_chk)
end
# Make visible if returned to life
unless @battler.dead?
self.visible = true if @pose == pose_obtain(MNK_POSE1, MNK_APOSE1, MNK_EPOSE1)
@freeze = false unless $game_system.victory
end
# Setup Animation
time = Graphics.frame_count / (Graphics.frame_rate / MNK_SPEED)
if @last_time < time
@frame = (@frame + 1) % poseframe
if @frame == 0
if @freeze
@frame = poseframe - 1
return
end
@pose = state
end
end
@last_time = time
# Setup Dying Animation
if @battler.dead?
if @dying == true
@pose = state
@dying = false
end
# Otherwise, all non-dead actions...
else
# Setup/Ready for Battle (Let's get ready to RUMBLE!)
if @s_pose == false
tmp_pose = pose_obtain(MNK_POSES_SETUP, MNK_POSES_SETUP_A, MNK_POSES_SETUP_E)
if tmp_pose != nil
@pose = tmp_pose
@s_pose = true
end
end
# If Victory pose (Who's your daddy?)
if @battler.is_a?(Game_Actor)
if $game_system.victory == true
if @winning == true
@pose = state
@winning = false
end
end
end
end
# Move It
move if moving
end
#--------------------------------------------------------------------------
# * Current State
#--------------------------------------------------------------------------
def state
# Reset Statusd Flag
@statusd = false
# Set Translucency if not dead
unless @battler.dead?
if @battler.is_a?(Game_Actor)
battler_translucency(@battler, MNK_TRANSLUCENT_ACTOR)
else
battler_translucency(@battler, MNK_TRANSLUCENT_ENEMY)
end
end
# Damage State
if [nil,{}].include?(@battler.damage)
# Battler Fine
state = pose_obtain(MNK_POSE1, MNK_APOSE1, MNK_EPOSE1)
# Battler Wounded
temp_woozy = MNK_LOW_HP_PERCENTAGE
if @battler.is_a?(Game_Actor)
temp_woozy = MNK_LOW_HP_ACTOR[@battler.id] if MNK_LOW_HP_ACTOR[@battler.id] != nil
end
if @battler.is_a?(Game_Enemy)
temp_woozy = MNK_LOW_HP_ENEMY[@battler.id] if MNK_LOW_HP_ENEMY[@battler.id] != nil
end
# If Set to Flat Rate
if MNK_LOW_HP_FLAT
if @battler.hp < temp_woozy
state = pose_obtain(MNK_POSE3, MNK_APOSE3, MNK_EPOSE3)
@statusd = true
end
# Otherwise, use percentage of battler's health
else
if @battler.hp < @battler.maxhp * temp_woozy
state = pose_obtain(MNK_POSE3, MNK_APOSE3, MNK_EPOSE3)
@statusd = true
end
end
# Battler Status-Effect
for i in @battler.states
tmp_pose2 = pose_array_obtain(MNK_POSES_STATUS, MNK_POSES_STAT_A, MNK_POSES_STAT_E, i)
state = tmp_pose2 if tmp_pose2 != nil
@statusd = true if tmp_pose2 != nil
end
# If Battler Dead
if @battler.dead?
# If using default battlers or default collapse
if (DEFAULT_COLLAPSE_ACTOR and @battler.is_a?(Game_Actor)) or
(DEFAULT_COLLAPSE_ENEMY and @battler.is_a?(Game_Enemy)) or
(DEFAULT_ACTOR and @battler.is_a?(Game_Actor)) or
(DEFAULT_ENEMY and @battler.is_a?(Game_Enemy)) or
(DEFAULT_ENEMY_ID.include?(@battler.id) and @battler.is_a?(Game_Enemy)) or
(DEFAULT_ACTOR_ID.include?(@battler.id) and @battler.is_a?(Game_Actor))
# Do absolutely nothing :)
else
# Dying Animation pose
if @dying == true
tmp_pose = pose_obtain(MNK_POSES_DYING, MNK_POSES_DYING_a, MNK_POSES_DYING_E)
if tmp_pose != nil
state = tmp_pose
else
state = dying_pose
end
else
state = dying_pose
end
# Fix Opacity
if @battler.is_a?(Game_Enemy)
if MNK_TRANSLUCENT_ENEMY.include?(@battler.id)
set_translucency(@battler, MNK_TRANSLUCENCY)
else
set_translucency(@battler, 255)
end
else
if MNK_TRANSLUCENT_ACTOR.include?(@battler.id)
set_translucency(@battler, MNK_TRANSLUCENCY)
else
set_translucency(@battler, 255)
end
end
end
end
end
# Casting State
if @battler.casted
state = casting_pose if $game_system.mnk_det_para_spell and @battler.spelling?
state = casting_pose if $game_system.mnk_det_sd_casting and @battler.sd_casting
state = casting_pose if $game_system.mnk_det_rtab_systm and @battler.rtp != 0
end
# Victory State
if @battler.is_a?(Game_Actor)
if $game_system.victory
if not @battler.dead?
if @winning == true
# A Pre-Winning Pose display
if MNK_POSES_WINNING != nil
tmp_pose = pose_obtain(MNK_POSES_WINNING, MNK_POSES_WINNING_A, MNK_POSES_WINNING_E)
state = tmp_pose if tmp_pose != nil
end
else
# Final Pose
state = victory_pose
end
else
# Final Pose
state = victory_pose
end
end
# Perform check for Enemies
else
if $game_system.defeat
if not @battler.dead?
if @winning == true
if MNK_POSES_WINNING != nil
tmp_pose = pose_obtain(MNK_POSES_WINNING, MNK_POSES_WINNING_A, MNK_POSES_WINNING_E)
state = tmp_pose if tmp_pose != nil
end
else
# Final Pose
state = victory_pose
end
else
# Final Pose
state = victory_pose
end
end
end
# Guarding State (not if dead OR in victory)
if not @battler.dead?
if not $game_system.victory
if @statusd == false
state = pose_obtain(MNK_POSE4, MNK_APOSE4, MNK_EPOSE4) if @battler.guarding?
end
end
end
# Moving State
if moving
# Adjust sprite direction if facing the other way...
if $game_system.sv_angle == 1
# If enemy battler moving
if @battler.is_a?(Game_Enemy)
# Battler Moving Left
state = pose_obtain(MNK_POSE5, MNK_APOSE5, MNK_EPOSE5) if moving.eql?(0)
# Battler Moving Right
state = pose_obtain(MNK_POSE6, MNK_APOSE6, MNK_EPOSE6) if moving.eql?(1)
# Else actor battler moving
else
# Battler Moving Left
state = pose_obtain(MNK_POSE6, MNK_APOSE6, MNK_EPOSE6) if moving.eql?(0)
# Battler Moving Right
state = pose_obtain(MNK_POSE5, MNK_APOSE5, MNK_EPOSE5) if moving.eql?(1)
end
else
# If enemy battler moving
if @battler.is_a?(Game_Enemy)
# Battler Moving Left
state = pose_obtain(MNK_POSE6, MNK_APOSE6, MNK_EPOSE6) if moving.eql?(0)
# Battler Moving Right
state = pose_obtain(MNK_POSE5, MNK_APOSE5, MNK_EPOSE5) if moving.eql?(1)
# Else actor battler moving
else
# Battler Moving Left
state = pose_obtain(MNK_POSE5, MNK_APOSE5, MNK_EPOSE5) if moving.eql?(0)
# Battler Moving Right
state = pose_obtain(MNK_POSE6, MNK_APOSE6, MNK_EPOSE6) if moving.eql?(1)
end
end
end
# Return State
return state
end
#--------------------------------------------------------------------------
# * Move
#--------------------------------------------------------------------------
def move
time = Graphics.frame_count / (Graphics.frame_rate.to_f / (MNK_SPEED * 5))
if @last_move_time < time
# Pause for Animation
return if @pose != state
# The standard 'full' opacity
opa = 255
if @battler.is_a?(Game_Enemy) and MNK_TRANSLUCENT_ENEMY.include?(@battler.id)
opa = MNK_TRANSLUCENCY
end
if @battler.is_a?(Game_Actor) and MNK_TRANSLUCENT_ACTOR.include?(@battler.id)
opa = MNK_TRANSLUCENCY
end
# Phasing
self.opacity = phasing(opa) if MNK_PHASING
if @battler.is_a?(Game_Actor)
self.opacity = phasing(opa) if MNK_PHASING_ACTOR.include?(@battler.id)
else
self.opacity = phasing(opa) if MNK_PHASING_ENEMY.include?(@battler.id)
end
# Calculate Difference
difference_x = (@display_x - @destination_x).abs
difference_y = (@display_y - @destination_y).abs
difference_z = (@display_z - @destination_z).abs
# Done? Reset, Stop
if [difference_x, difference_y].max.between?(0, 8)
@display_x = @destination_x
@display_y = @destination_y
@display_z = @destination_z
@pose = state
return
end
# Calculate Movement Increments
increment_x = increment_y = 1
if difference_x < difference_y
increment_x = 1.0 / (difference_y.to_f / difference_x)
elsif difference_y < difference_x
increment_y = 1.0 / (difference_x.to_f / difference_y)
end
increment_z = increment_y
# Calculate Movement Speed
if MNK_CALC_SPEED
total = 0; $game_party.actors.each{ |actor| total += actor.agi }
speed = @battler.agi.to_f / (total / $game_party.actors.size)
increment_x *= speed
increment_y *= speed
increment_z *= speed
end
# Multiply and Move
multiplier_x = MNK_RUSH_SPEED * (@destination_x - @display_x > 0 ? 8 : -8)
multiplier_y = MNK_RUSH_SPEED * (@destination_y - @display_y > 0 ? 8 : -8)
multiplier_z = MNK_RUSH_SPEED * (@destination_z - @display_z > 0 ? 8 : -8)
@display_x += (increment_x * multiplier_x).to_i
@display_y += (increment_y * multiplier_y).to_i
@display_z += (increment_z * multiplier_z).to_i
end
@last_move_time = time
end
#--------------------------------------------------------------------------
# * Set Movement
#--------------------------------------------------------------------------
def setmove(destination_x, destination_y, destination_z)
unless (@battler.is_a?(Game_Enemy) and MNK_STATIONARY_ENEMIES) or
(@battler.is_a?(Game_Actor) and MNK_STATIONARY_ACTORS)
unless MNK_STATIONARY_WEAPONS.include?(@battler.weapon_id) or
MNK_STATIONARY_SKILLS.include?(@skill_used) or
MNK_STATIONARY_ITEMS.include?(@item_used)
@original_x = @display_x
@original_y = @display_y
@original_z = @display_z
@destination_x = destination_x
@destination_y = destination_y
@destination_z = destination_z
end
end
end
#--------------------------------------------------------------------------
# * Movement Check
#--------------------------------------------------------------------------
def moving
if (@display_x != @destination_x and @display_y != @destination_y and !@battler.dead?)
return (@display_x > @destination_x ? 0 : 1)
end
end
#--------------------------------------------------------------------------
# * Set Pose
#--------------------------------------------------------------------------
def pose=(pose)
@pose = pose
@frame = 0
end
#--------------------------------------------------------------------------
# * Freeze
#--------------------------------------------------------------------------
def freeze
@freeze = true
end
#--------------------------------------------------------------------------
# * Fallen Pose
#--------------------------------------------------------------------------
if @derv_anim_bat_stack.nil?
@derv_anim_bat_stack = true
alias mnk_collapse collapse
def collapse
if @battler.is_a?(Game_Actor)
mnk_collapse if DEFAULT_ACTOR
mnk_collapse if DEFAULT_COLLAPSE_ACTOR
if DEFAULT_ACTOR_ID != nil
mnk_collapse if DEFAULT_ACTOR_ID.include?(@battler.id)
end
else
mnk_collapse if DEFAULT_ENEMY
mnk_collapse if DEFAULT_COLLAPSE_ENEMY
if DEFAULT_ENEMY_ID != nil
mnk_collapse if DEFAULT_ENEMY_ID.include?(@battler.id)
end
end
end
end
#--------------------------------------------------------------------------
# * Phasing / Vanishing
#--------------------------------------------------------------------------
def phasing(opa)
d1 = (@display_x - @original_x).abs
d2 = (@display_y - @original_y).abs
d3 = (@display_x - @destination_x).abs
d4 = (@display_y - @destination_y).abs
return [opa - ([d1 + d2, d3 + d4].min * 1.75).to_i, 0].max
end
#--------------------------------------------------------------------------
# * Mirror Pose If...
#--------------------------------------------------------------------------
def mirror_pose_if(adv_value)
if $game_temp.advantage_set == adv_value
self.mirror = true
else
self.mirror = false
end
end
#--------------------------------------------------------------------------
# * Mirror Pose Unless...
#--------------------------------------------------------------------------
def mirror_pose_unless(adv_value)
unless $game_temp.advantage_set == adv_value
self.mirror = true
else
self.mirror = false
end
end
#--------------------------------------------------------------------------
# * Casting Pose
#--------------------------------------------------------------------------
def casting_pose
tmp_pose = pose_obtain(MNK_POSES_CASTPREP, MNK_POSES_CASTPREP_A, MNK_POSES_CASTPREP_E)
tmp_pose2 = pose_array_obtain(MNK_POSES_CASTED, MNK_POSES_CASTED_A, MNK_POSES_CASTED_E, @battler.skill_casted)
tmp_pose = tmp_pose2 if tmp_pose2 != nil
state = tmp_pose if tmp_pose != nil
return state
end
#--------------------------------------------------------------------------
# * Final Victory Pose
#--------------------------------------------------------------------------
def victory_pose
tmp_pose = MNK_POSE10-1
tmp_pose = MNK_APOSE10[@battler.id]-1 if MNK_APOSE10[@battler.id] != nil
if not MNK_LOOPS_WINNING.include?(@battler.id)
@freeze = true
end
return tmp_pose
end
#--------------------------------------------------------------------------
# * Final Victory Pose
#--------------------------------------------------------------------------
def dying_pose
state = pose_obtain(MNK_POSE11, MNK_APOSE11, MNK_EPOSE11)
if @battler.is_a?(Game_Actor)
@freeze = true if not MNK_LOOPS_DEFEATED_ACTOR.include?(@battler.id)
else
@freeze = true if not MNK_LOOPS_DEFEATED_ENEMY.include?(@battler.id)
end
return state
end
#--------------------------------------------------------------------------
# * Battler Translucency
# battler : actor or enemy battler
# battler_trans : translucency array for battler
#--------------------------------------------------------------------------
def battler_translucency(battler, battler_trans)
tcheck = {}
tcheck = battler_trans
set_translucency(battler, MNK_TRANSLUCENCY) if tcheck.include?(battler.id)
end
#--------------------------------------------------------------------------
# * Set Translucency
# battler : actor or enemy battler
# trans_level : translucency level
#--------------------------------------------------------------------------
def set_translucency(battler, trans_level)
if battler.hidden
self.opacity = 0
else
self.opacity = MNK_TRANSLUCENCY
end
end
#--------------------------------------------------------------------------
# * Cell Divider
# divider_check : array to divide cells by custom actor or enemy
# divider_standard : standard number to divide by
#--------------------------------------------------------------------------
def cell_divider(divider_check, divider_standard)
dcheck = {}
divided_cell = divider_standard
dcheck = divider_check
if dcheck != nil
if dcheck.include?(@battler.id)
divided_cell = dcheck[@battler.id] if dcheck[@battler.id] != nil
end
end
return divided_cell
end
#--------------------------------------------------------------------------
# * Obtain Individual Cell
#--------------------------------------------------------------------------
def cell_obtain
# Only permit for valid poses & frames
if @pose != nil
if @frame != nil
self.src_rect.set(@width * @frame, @height * @pose, @width, @height)
end
end
end
#--------------------------------------------------------------------------
# * Obtain Pose
# pose_base : default pose to return
# pose_actor : list of poses for actors
# pose_enemy : list of poses for enemies
#--------------------------------------------------------------------------
def pose_obtain(pose_base, pose_actor, pose_enemy)
# create Arrays
pos_a = {}
pos_e = {}
# fill created Arrays & Set pose
pos_a = pose_actor
pos_e = pose_enemy
pose_now = pose_base
# Obtain pose if not a standard pose
if @battler.is_a?(Game_Actor)
pose_now = pos_a[@battler.id] if pos_a[@battler.id] != nil
else
pose_now = pos_e[@battler.id] if pos_e[@battler.id] != nil
end
# Return the final pose (minus 1 for neceties)
pose_now -= 1 if pose_now != nil
return pose_now
end
#--------------------------------------------------------------------------
# * Obtain Pose from hashes
# hash_base : hash with default poses
# hash_actor : advanced list of poses for actors
# hash_enemy : advanced list of poses for enemies
# condition : value determining where to get the final pose
#--------------------------------------------------------------------------
def pose_array_obtain(hash_base, hash_actor, hash_enemy, condition)
# create Arrays
hash_b = {}
hash_a = {}
hash_e = {}
pose_temp = {}
# fill created Arrays & Set pose
hash_b = hash_base
hash_a = hash_actor
hash_e = hash_enemy
# Setup the temp Array
if @battler.is_a?(Game_Actor)
pose_temp = hash_a[@battler.id] if hash_a.include?(@battler.id)
else
pose_temp = hash_e[@battler.id] if hash_e.include?(@battler.id)
end
# Obtain the base pose based on condition (or nil)
pose_now = hash_b[condition] if hash_b.include?(condition)
# Obtain the optional actor/enemy pose based on condition (unless nil)
pose_now = pose_temp[condition] if pose_temp.include?(condition)
# Return the final pose (minus 1 for neceties)
pose_now -= 1 if pose_now != nil
return pose_now
end
end#==============================================================================
# ** Animated Battlers - Enhanced ver. 10.5 (01-20-2007)
#
#------------------------------------------------------------------------------
# * (3) Battle System: The Scene Battle class
#==============================================================================
#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
# This class performs battle screen processing.
#==============================================================================
class Scene_Battle
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
alias mnkmain main
def main
# Initialize wait count
@delay_count = 0
# Obtain the formation style
# Only once per battle start
$game_system.formation = $formation_style
$game_system.formation = 0 if $formation_style == nil
# if Formation is random
if $game_system.formation == 8 then
$game_system.formation = rand(8).to_i
end
# Perform the original call
mnkmain
end
#--------------------------------------------------------------------------
# * Frame Update (main phase)
#--------------------------------------------------------------------------
alias mnk_anim_sp3 start_phase3
def start_phase3
# Remove flag after set number of turns
if $game_temp.battle_turn >= MNK_ADV_OFF_TURN
# Turn sideview advantage mirror flag off
$game_temp.advantage_set = 0
end
# Perform the original call
mnk_anim_sp3
end
#--------------------------------------------------------------------------
# * Frame Update (main phase step 1 : action preparation)
#--------------------------------------------------------------------------
alias mkf_up4s1 update_phase4_step1
def update_phase4_step1(battler = @active_battler)
if $game_system.mnk_det_rtab_systm == true
mkf_up4s1(battler)
else
mkf_up4s1
end
if battler != nil
if $game_system.mnk_det_sd_casting == true
if battler.sd_casting
battler.casted = true
end
end
end
end
#--------------------------------------------------------------------------
# * End Skill Selection
#--------------------------------------------------------------------------
alias mkf_endss end_skill_select
def end_skill_select
mkf_endss
if $game_system.mnk_det_rtab_systm
@active_actor.skill_casted = @skill.id
else
@active_battler.skill_casted = @skill.id
end
end
#--------------------------------------------------------------------------
# * Make Skill Action Results (alias used to determine skill used)
#--------------------------------------------------------------------------
alias make_skill_action_result_anim make_skill_action_result
def make_skill_action_result(battler = @active_battler, plus_id = 0)
@rtab = !@target_battlers
if $game_system.mnk_det_rtab_attck
make_skill_action_result_anim(battler, plus_id)
else
@rtab ? make_skill_action_result_anim(battler) : make_skill_action_result_anim
end
@skill_used = @skill.id
battler.strike_skill = @skill.id
if $game_system.mnk_det_para_spell == true
#if battler.spelling?
battler.casted = true
#end
end
for target in (@rtab ? battler.target : @target_battlers)
target.struck_skill = @skill.id
end
end
#--------------------------------------------------------------------------
# * Make Item Action Results (alias used to determine item used)
#--------------------------------------------------------------------------
alias make_item_action_result_anim make_item_action_result
def make_item_action_result(battler = @active_battler)
@rtab = !@target_battlers
@rtab ? make_item_action_result_anim(battler) : make_item_action_result_anim
@item_used = @item.id
@item_usage = @item.scope
battler.strike_item = @item.id
for target in (@rtab ? battler.target : @target_battlers)
target.struck_item = @item.id
end
end
#--------------------------------------------------------------------------
# * Frame Update (main phase step 1 : action preparation) (Casting Routine)
#--------------------------------------------------------------------------
alias update_phase4_step1_anim update_phase4_step1
def update_phase4_step1(battler = @active_battler)
@rtab = !@target_battlers
if $game_system.mnk_det_rtab_systm == true
update_phase4_step1_anim(battler)
if battler.current_action.kind == 1 and
(not battler.current_action.forcing or @force != 2)
if battler.rtp != 0
battler.casted = true
end
end
else
update_phase4_step1_anim
end
end
#--------------------------------------------------------------------------
# * Action Animation, Movement
#--------------------------------------------------------------------------
alias mnk_update_phase4_step3 update_phase4_step3
def update_phase4_step3(battler = @active_battler)
@rtab = !@target_battlers
target = (@rtab ? battler.target : @target_battlers)[0]
# Battle Delay System
if MNK_AT_DELAY
# Fomar's Action Cost Detection
if $game_system.mnk_det_acb_detect
for actor in $game_party.actors
actor.vitality= 0
end
for enemy in $game_troop.enemies
enemy.vitality= 0
end
end
# Trickster's AT Detection
if $game_system.mnk_det_abs_detect
for actor in $game_party.actors
actor.at_bonus= [0,0]
end
for enemy in $game_troop.enemies
enemy.at_bonus= [0,0]
end
end
# Cogwheel RTAB Detection
if $game_system.mnk_det_rtab_systm
@rtab_wait_flag = true
end
end
# If enemy is a default battler
if battler.is_a?(Game_Enemy)
if DEFAULT_ENEMY
if @rtab then battler.white_flash = true end
if @rtab then battler.wait = 10 end
end
if DEFAULT_ENEMY_ID != nil
if DEFAULT_ENEMY_ID.include?(battler.id)
if @rtab then battler.white_flash = true end
if @rtab then battler.wait = 10 end
end
end
end
# If actor is a default battler
if battler.is_a?(Game_Actor)
if DEFAULT_ACTOR
if @rtab then battler.white_flash = true end
if @rtab then battler.wait = 10 end
end
if DEFAULT_ACTOR_ID != nil
if DEFAULT_ACTOR_ID.include?(battler.id)
if @rtab then battler.white_flash = true end
if @rtab then battler.wait = 10 end
end
end
end
# Reset the 'Do Nothing' flag
dn_flag = false
# Set values and poses based on Action
case battler.current_action.kind
when 0 # Attack
# if Do Nothing, just return
if battler.current_action.basic == 3
dn_flag = true
end
if dn_flag != true
rush_type = MNK_STEP_ATTACK
full_moving = true ; if rush_type; full_moving = false; end
if MNK_MOVE2CENTER_ATK.include?(battler.weapon_id); center_move=true ; end
if MNK_STATIONARY_ENEMY_IDS.include?(battler.id) and battler.is_a?(Game_Enemy)
full_moving = false
center_move = false
rush_type = false
end
base_pose = pose_obtain(battler, MNK_POSE7, MNK_APOSE7, MNK_EPOSE7)
base_pose2 = pose_array_obtain(battler, MNK_POSES_WEAPONS, MNK_POSES_WEAPS_A, MNK_POSES_WEAPS_E, battler.weapon_id)
base_pose = base_pose2 if base_pose2 != nil
if battler.current_action.basic == 2
# If escaping, disable all movement
full_moving = false
center_move = false
rush_type = false
# Set the graphics
temp_pose = pose_obtain(battler, MNK_POSES_ESCAPE, MNK_POSES_ESCAPE_A, MNK_POSES_ESCAPE_E)
base_pose = temp_pose if temp_pose != nil
end
end
when 1 # Skill
rush_type = MNK_STEP_SKILL
if MNK_MOVING_SKILL.include?(@skill_used) ; full_moving = true ; end
if MNK_MOVE2CENTER_SKILL.include?(@skill_used) ; center_move = true ; end
base_pose = pose_obtain(battler, MNK_POSE9, MNK_APOSE9, MNK_EPOSE9)
base_pose2 = pose_array_obtain(battler, MNK_POSES_SKILLS, MNK_POSES_SKILLS_A, MNK_POSES_SKILLS_E, @skill_used)
base_pose = base_pose2 if base_pose2 != nil
when 2 # Item
rush_type = MNK_STEP_ITEM
if MNK_MOVING_ITEM.include?(@item_used) or @item_scope == 1..2 ; full_moving = true ; end
if MNK_MOVE2CENTER_ITEM.include?(@item_used); center_move = true; end
base_pose = pose_obtain(battler, MNK_POSE8, MNK_APOSE8, MNK_EPOSE8)
base_pose2 = pose_array_obtain(battler, MNK_POSES_ITEMS, MNK_POSES_ITEMS_A, MNK_POSES_ITEMS_E, @item_used)
base_pose = base_pose2 if base_pose2 != nil
end
# Only perform action if 'Do Nothing' flag is off, ie... doing something...
if dn_flag != true
# Control Movement and use current pose
@moved = {} unless @moved
return if @spriteset.battler(battler).moving
if not (@moved[battler] or battler.guarding?)
offset = offset_value(target, battler)
if rush_type # Steps forward
@spriteset.battler(battler).setmove(battler.screen_x - offset, battler.screen_y + 1, battler.screen_z)
end
if full_moving # Runs to target
@spriteset.battler(battler).setmove(target.screen_x + offset, target.screen_y - 1, target.screen_z + 10)
end
if center_move # Runs to center
@spriteset.battler(battler).setmove(320+(offset/4), battler.screen_y-1, battler.screen_z)
end
@moved[battler] = true
return
@spriteset.battler(battler).pose = base_pose
elsif not battler.guarding?
@spriteset.battler(battler).pose = base_pose
@spriteset.battler(battler).setmove(battler.screen_x, battler.screen_y, battler.screen_z)
end
# Finish Up Skill and Item Use
case battler.current_action.kind
when 1
# Flag system that skill was used
battler.casted = false
battler.casting = false
@spriteset.battler(battler).skill_used = 0
when 2
# Flag system that item was used
@spriteset.battler(battler).item_used = 0
end
# Battle_Charge value for BattleCry script
$battle_charge = true
end
# Battle Delay System
if MNK_AT_DELAY
# Fomar's Action Cost Detection
if $game_system.mnk_det_acb_detect
for actor in $game_party.actors
actor.vitality = 1
end
for enemy in $game_troop.enemies
enemy.vitality = 1
end
end
# Trickster's AT Detection
if $game_system.mnk_det_abs_detect
for actor in $game_party.actors
actor.at_bonus = [1,0]
end
for enemy in $game_troop.enemies
enemy.at_bonus = [1,0]
end
end
# Cogwheel RTAB Detection
if $game_system.mnk_det_rtab_systm
@rtab_wait_flag = false
end
end
# Prevent 'removed battler' moved state
unless @moved == nil
@moved[battler] = true
end
# Start attack, do not move from spot
battler.attacking = true
# Perform the original call
@rtab ? mnk_update_phase4_step3(battler) : mnk_update_phase4_step3
end
#--------------------------------------------------------------------------
# * Offset Calculation
#--------------------------------------------------------------------------
def offset_value(target, battler = @active_battler)
offst = @spriteset.battler(battler).battler_offset
offst += MNK_OFFSET
# Oversized or special Battler offsets
if target.is_a?(Game_Enemy) && battler.is_a?(Game_Actor)
unless MNK_OFFSET_ACTOR == nil
offst += MNK_OFFSET_ACTOR[battler.id] if MNK_OFFSET_ACTOR.include?(battler.id)
end
unless MNK_OFFSET_ENEMY == nil
offst += MNK_OFFSET_ENEMY[target.id] if MNK_OFFSET_ENEMY.include?(target.id)
end
end
if target.is_a?(Game_Actor) && battler.is_a?(Game_Enemy)
unless MNK_OFFSET_ENEMY == nil
offst += MNK_OFFSET_ENEMY[battler.id] if MNK_OFFSET_ENEMY.include?(battler.id)
end
unless MNK_OFFSET_ACTOR == nil
offst += MNK_OFFSET_ACTOR[target.id] if MNK_OFFSET_ACTOR.include?(target.id)
end
end
# Offset calc dependant on sideview
if $game_system.sv_angle == 1
offset = (battler.is_a?(Game_Actor) ? -(offst) : offst)
else
offset = (battler.is_a?(Game_Actor) ? offst : -(offst))
end
return offset
end
#--------------------------------------------------------------------------
# * Hit Animation
#--------------------------------------------------------------------------
alias mnk_update_phase4_step4 update_phase4_step4
def update_phase4_step4(battler = @active_battler)
# Cycle through the targets
for target in (@rtab ? battler.target : @target_battlers)
damage = (@rtab ? target.damage[battler] : target.damage)
critical = (@rtab ? target.critical[battler] : target.critical)
if damage.is_a?(Numeric) and damage > 0
base_pose = pose_obtain(target, MNK_POSE2, MNK_APOSE2, MNK_EPOSE2)
weapon_used = battler.weapon_id
weapon_used = 0 if weapon_used == nil
base_pose2 = pose_array_obtain(target, MNK_STRUCK_WEAPS, MNK_STRUCK_WEAPS_A, MNK_STRUCK_WEAPS_E, weapon_used)
base_pose = base_pose2 if base_pose2 != nil
if battler.strike_skill != 0
if battler.strike_skill == target.struck_skill
base_pose2 = pose_array_obtain(target, MNK_STRUCK_SKILLS, MNK_STRUCK_SKILLS_A, MNK_STRUCK_SKILLS_E, target.struck_skill)
base_pose = base_pose2 if base_pose2 != nil
end
end
if battler.strike_item != 0
if battler.strike_item == target.struck_item
base_pose2 = pose_array_obtain(target, MNK_STRUCK_ITEMS, MNK_STRUCK_ITEMS_A, MNK_STRUCK_ITEMS_E, target.struck_item)
base_pose = base_pose2 if base_pose2 != nil
end
end
@spriteset.battler(target).pose = base_pose
if critical == true
temp_pose = pose_obtain(target, MNK_POSES_CRITICAL, MNK_POSES_CRIT_A, MNK_POSES_CRIT_E)
weapon_used = battler.weapon_id
weapon_used = 0 if weapon_used == nil
base_pose2 = pose_array_obtain(target, MNK_CRIT_WEAPS, MNK_CRIT_WEAPS_A, MNK_CRIT_WEAPS_E, weapon_used)
base_pose = base_pose2 if base_pose2 != nil
if @skill_used != 0
if @skill_used == target.struck_skill
base_pose2 = pose_array_obtain(target, MNK_CRIT_SKILLS, MNK_CRIT_SKILLS_A, MNK_CRIT_SKILLS_E, target.struck_skill)
base_pose = base_pose2 if base_pose2 != nil
end
end
if @item_used != 0
if @item_used == target.struck_item
base_pose2 = pose_array_obtain(target, MNK_CRIT_ITEMS, MNK_CRIT_ITEMS_A, MNK_CRIT_ITEMS_E, target.struck_item)
base_pose = base_pose2 if base_pose2 != nil
end
end
@spriteset.battler(target).pose = temp_pose if temp_pose != nil
end
end
end
# Reset/zero out the battler's skill & item
battler.strike_skill = 0
battler.strike_item = 0
# Perform the original call
@rtab ? mnk_update_phase4_step4(battler) : mnk_update_phase4_step4
# Finish attack n battle animation, free to move
battler.attacking = false
end
#--------------------------------------------------------------------------
# * Victory Animation
#--------------------------------------------------------------------------
alias mnk_start_phase5 start_phase5
def start_phase5
for actor in $game_party.actors
return if @spriteset.battler(actor).moving
end
# See if an actor remains alive
for actor in $game_party.actors
unless actor.dead?
$game_system.victory = true
end
end
# See if an enemy remains alive
for enemy in $game_troop.enemies.reverse
unless enemy.dead?
$game_system.defeat = true
end
end
# Perform the original call
mnk_start_phase5
end
#--------------------------------------------------------------------------
# * Change Arrow Viewport
#--------------------------------------------------------------------------
alias mnk_start_enemy_select start_enemy_select
def start_enemy_select
# Perform the original call
mnk_start_enemy_select
# Arrow manipulation
@enemy_arrow.dispose
@enemy_arrow = Arrow_Enemy.new(@spriteset.viewport2)
@enemy_arrow.help_window = @help_window
end
#--------------------------------------------------------------------------
# * Obtain Pose (Scene Battle version)
# battler : battler performing attack
# pose_base : default pose to return
# pose_actor : list of poses for actors
# pose_enemy : list of poses for enemies
#--------------------------------------------------------------------------
def pose_obtain(battler, pose_base, pose_actor, pose_enemy)
# create Arrays
pos_a = {}
pos_e = {}
# fill created Arrays & Set pose
pos_a = pose_actor
pos_e = pose_enemy
pose_now = pose_base
# Obtain pose if not a standard pose
if battler.is_a?(Game_Actor)
pose_now = pos_a[battler.id] if pos_a[battler.id] != nil
else
pose_now = pos_e[battler.id] if pos_e[battler.id] != nil
end
# Return the final pose (minus 1 for niceties)
pose_now -= 1 if pose_now != nil
return pose_now
end
#--------------------------------------------------------------------------
# * Obtain Pose from hashes (Scene Battle version)
# battler : battler performing attack
# hash_base : hash with default poses
# hash_actor : advanced list of poses for actors
# hash_enemy : advanced list of poses for enemies
# condition : value determining where to get the final pose
#--------------------------------------------------------------------------
def pose_array_obtain(battler, hash_base, hash_actor, hash_enemy, condition)
# create Arrays
# create Arrays
hash_b = {}
hash_a = {}
hash_e = {}
pose_temp = {}
# fill created Arrays & Set pose
hash_b = hash_base
hash_a = hash_actor
hash_e = hash_enemy
# Setup the temp Array
if battler.is_a?(Game_Actor)
pose_temp = hash_a[battler.id] if hash_a.include?(battler.id)
else
pose_temp = hash_e[battler.id] if hash_e.include?(battler.id)
end
# Obtain the base pose based on condition (or nil)
pose_now = hash_b[condition] if hash_b.include?(condition)
# Obtain the optional actor/enemy pose based on condition (unless nil)
pose_now = pose_temp[condition] if pose_temp.include?(condition)
# Return the final pose (minus 1 for niceties)
pose_now -= 1 if pose_now != nil
return pose_now
end
end#==============================================================================
# ** Animated Battlers - Enhanced ver. 10.5 (01-20-2007)
#
#------------------------------------------------------------------------------
# * (4) Miscellaneous: Formations, Viewport and various Detection routines.
#==============================================================================
#============================================================================
# ** Game_Temp
#------------------------------------------------------------------------------
# This class handles temporary data that is not included with save data.
# Refer to "$game_temp" for the instance of this class.
#==============================================================================
class Game_Temp
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :advantage_set # holds value for sideview systems
end
#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
# This class handles data surrounding the system. Backround music, etc.
# is managed here as well. Refer to "$game_system" for the instance of
# this class.
#==============================================================================
class Game_System
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
# Auto-Detection Values
attr_accessor :mnk_det_abs_detect # Trickster's ATB System Detection
attr_accessor :mnk_det_acb_detect # Action Cost Battlesystem Detection
attr_accessor :mnk_det_claihms_ts # Claihm's Tactical Skills Detection
attr_accessor :mnk_det_para_spell # ParaDog Detection
attr_accessor :mnk_det_rtab_attck # Connected Attacking Detection
attr_accessor :mnk_det_rtab_systm # RTAB Detection
attr_accessor :mnk_det_sd_casting # DBS Skill Delay Detection
# Inter-Class variables
attr_accessor :max_member # max members
attr_accessor :sv_angle # sideview system angle
attr_accessor :formation # formation
attr_accessor :form_top # formation top
attr_accessor :form_wd # formation height
attr_accessor :bstat_ht # battlestatus height
attr_accessor :victory # victory boolean
attr_accessor :defeat # defeat boolean
# Additional values for the $global's save/load feature
attr_accessor :mnk_sm # sideview mirror
attr_accessor :mnk_fmm # formation max members
attr_accessor :mnk_fmh # formation max height
attr_accessor :mnk_fmw # formation max width
attr_accessor :mnk_bh # battlestatus height
attr_accessor :mnk_fs # formation style
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
alias mnk_init initialize
def initialize
# Perform the original call
mnk_init
# Create the savable values
@mnk_sm = 0
@mnk_fmm = 4
@mnk_fmh = 220
@mnk_fmw = 128
@mnk_bh = 160
@mnk_fs = 0
end
end
#===================================================\==========================
# ** Scene_Save
#------------------------------------------------------------------------------
# This class performs save screen processing.
#==============================================================================
class Scene_Save < Scene_File
#--------------------------------------------------------------------------
# * Write Save Data
# file : write file object (opened)
#--------------------------------------------------------------------------
alias mnk_wsd write_save_data
def write_save_data(file)
# Store the globals
$game_system.mnk_sm = $sideview_mirror
$game_system.mnk_fmm = $formation_max_member
$game_system.mnk_fmh = $formation_max_height
$game_system.mnk_fmw = $formation_max_width
$game_system.mnk_bh = $battlestatus_height
$game_system.mnk_fs = $formation_style
# Perform the original call
mnk_wsd(file)
end
end
#==============================================================================
# ** Scene_Load
#------------------------------------------------------------------------------
# This class performs load screen processing.
#==============================================================================
class Scene_Load < Scene_File
#--------------------------------------------------------------------------
# * Read Save Data
# file : file object for reading (opened)
#--------------------------------------------------------------------------
alias mnk_rsd read_save_data
def read_save_data(file)
#Perform the original call
mnk_rsd(file)
# ReStore the globals
$sideview_mirror = $game_system.mnk_sm
$formation_max_member = $game_system.mnk_fmm
$formation_max_height = $game_system.mnk_fmh
$formation_max_width = $game_system.mnk_fmw
$battlestatus_height = $game_system.mnk_bh
$formation_style = $game_system.mnk_fs
end
end
#==============================================================================
# ** Game_Battler
#------------------------------------------------------------------------------
# This class deals with battlers. It's used as a superclass for the Game_Actor
# and Game_Enemy classes.
#==============================================================================
class Game_Battler
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_accessor :attacking # if attacking
attr_accessor :casted # if spell is casted
attr_accessor :casting # if currently casting
attr_accessor :skill_casted # ID of skill used
attr_accessor :strike_skill
attr_accessor :strike_item
attr_accessor :struck_weapon
attr_accessor :struck_skill
attr_accessor :struck_item
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
alias mnk_init initialize
def initialize
@attacking = false
@casted = false
@casting = false
@skill_casted = 0
@strike_skill = 0
@strike_item = 0
@struck_weapon = 0
@struck_skill = 0
@struck_item = 0
mnk_init
# ParaDog's Spell Delay Detection
if defined?(spelling?)
$game_system.mnk_det_para_spell = true
end
# DBS Spell Delay Detection
if @sd_casting != nil
$game_system.mnk_det_sd_casting = true
end
# Fomar's Action Cost Detection
if @vitality != nil
$game_system.mnk_det_acb_detect = true
end
# Trickster's AT Detection
if @at_bonus != nil
$game_system.mnk_det_abs_detect = true
end
end
end
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
# This class handles the actor. It's used within the Game_Actors class
# ($game_actors) and refers to the Game_Party class ($game_party).
#==============================================================================
class Game_Actor
alias mnk_ini initialize
def initialize(actor_id)
mnk_ini(actor_id)
if defined?(change_weapon)
$game_system.mnk_det_rtab_attck = true
end
end
#--------------------------------------------------------------------------
# * Actor X Coordinate
#--------------------------------------------------------------------------
def screen_x
# Determine minimum horizontal space between battlers
x_spacer = $game_system.form_wd / $game_system.max_member
if self.index != nil
case $game_system.formation
when 0 # DIAGONAL PATTERN 1
if $game_system.sv_angle == 1
return self.index * -x_spacer + (($game_system.max_member+1)*x_spacer) #202
else
return self.index * x_spacer + (640-(($game_system.max_member+1)*x_spacer))#450
end
when 1 # DIAGONAL PATTERN 2
if $game_system.sv_angle == 1
return self.index * x_spacer + x_spacer #64
else
return self.index * -x_spacer + (640-x_spacer*2) #576
end
when 2 # 2-ROW SLANT
if $game_system.sv_angle == 1
if self.index < ($game_system.max_member/2)
return self.index + (($game_system.max_member+1)*x_spacer) + (x_spacer * self.index)
else
return self.index + (x_spacer * self.index) - x_spacer * 0.5
end
else
if self.index < ($game_system.max_member/2)
return self.index + (640-(($game_system.max_member+1)* x_spacer)) + (-x_spacer * self.index)
else
return self.index + (640-((x_spacer*0.5)-x_spacer)) + (-x_spacer * self.index)
end
end
when 3 # 2 ROW - SLANT
if $game_system.sv_angle == 1
if self.index < ($game_system.max_member/2)
return self.index + (x_spacer/2)+(($game_system.max_member+1)* x_spacer) + (-x_spacer * self.index)
else
return self.index + (($game_system.max_member+1)* x_spacer) + (-x_spacer * self.index)
end
else
if self.index < ($game_system.max_member/2)
return self.index + 442 + (x_spacer * self.index)
else
return self.index + 430 + (x_spacer * self.index)
end
end
when 4 # Column Pattern 1
if $game_system.sv_angle == 1
if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )
return self.index + ($game_system.max_member*(x_spacer*1.5)) + (-(x_spacer*1.5) * (self.index-1))
else
return self.index + ($game_system.max_member*(x_spacer*1.5)) + (-(x_spacer*1.5) * self.index)
end
else
if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )
return self.index + 640-($game_system.max_member*(x_spacer*1.5)) + ((x_spacer*1.5) * (self.index-1))
else
return self.index + 640-($game_system.max_member*(x_spacer*1.5)) + ((x_spacer*1.5) * self.index)
end
end
when 5 # Column Pattern 2
if $game_system.sv_angle == 1
if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )
return self.index + ($game_system.max_member*(x_spacer*1.5)) + (-(x_spacer*1.5) * (self.index-1))
else
return self.index + ($game_system.max_member*(x_spacer*1.5)) + (-(x_spacer*1.5) * self.index)
end
else
if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )
return self.index + 640-($game_system.max_member*(x_spacer*1.5)) + ((x_spacer*1.5) * (self.index-1))
else
return self.index + 640-($game_system.max_member*(x_spacer*1.5)) + ((x_spacer*1.5) * self.index)
end
end
when 6 # Wave Formation 1
if $game_system.sv_angle == 1
if self.index < ($game_system.max_member/2)
return 170
else
return 90
end
else
if self.index < ($game_system.max_member/2)
return 470
else
return 550
end
end
else # Wave Formation 2
if $game_system.sv_angle == 1
if self.index < ($game_system.max_member/2)
return 170
else
return 90
end
else
if self.index < ($game_system.max_member/2)
return 470
else
return 550
end
end
end
else
return 0
end
end
#--------------------------------------------------------------------------
# * Actor Y Coordinate
#--------------------------------------------------------------------------
def screen_y
# Determine minimum vertical space between battlers
y_spacer = (480 - $game_system.bstat_ht - $game_system.form_top) / $game_system.max_member
if self.index != nil
case $game_system.formation
# DIAGONAL PATTERNS ( 1 & 2 )
when 0, 1
return self.index * (y_spacer * 1.25) + $game_system.form_top
# TWO-ROW SLANTS ( 1 & 2 )
when 2, 3
if self.index < ($game_system.max_member / 2)
return $game_system.form_top + ((y_spacer * 2.5) * self.index)
else
return ($game_system.form_top - (y_spacer*($game_system.max_member + 1))) + ((y_spacer*2.5) * self.index) #was 60
end
# COLUMN PATTERNS (1 & 2)
when 4
if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )
return $game_system.form_top + ($game_system.bstat_ht / 2)
else
return $game_system.form_top + ($game_system.bstat_ht / 6)
end
when 5
if ((self.index + 1) / 2) >= (((self.index + 1).to_f) / 2 )
return $game_system.form_top + ($game_system.bstat_ht / 6)
else
return $game_system.form_top + ($game_system.bstat_ht / 2)
end
# BOX PATTERN (1 & 2)
when 6
if self.index < ($game_system.max_member / 2)
return $game_system.form_top + (y_spacer * 2.5 * self.index)
else
return $game_system.form_top + (y_spacer * 2.5 * ((self.index) - ($game_system.max_member / 2)))
end
else
if self.index < ($game_system.max_member / 2)
return $game_system.form_top + (y_spacer * 2.5 * (($game_system.max_member / 2) - 1))+ (y_spacer * 2.5 * -self.index)
else
return $game_system.form_top + (y_spacer * 2.5 * (($game_system.max_member / 2) - 1)) + (y_spacer * 2.5 * -((self.index) - ($game_system.max_member / 2)))
end
end
end
end
#--------------------------------------------------------------------------
# * Actor Z Coordinate
#--------------------------------------------------------------------------
def screen_z
return screen_y
end
end
#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
# This class handles enemies. It's used within the Game_Troop class
# ($game_troop).
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# * Get Battle Screen X-Coordinate
#--------------------------------------------------------------------------
def screen_x
if self.index != nil
if $game_system.sv_angle == 1
return 640 - $data_troops[@troop_id].members[@member_index].x
else
return $data_troops[@troop_id].members[@member_index].x
end
end
end
#--------------------------------------------------------------------------
# * Actor Z Coordinate
#--------------------------------------------------------------------------
def screen_z
return screen_y
end
end
#==============================================================================
# ** Game_Party
#------------------------------------------------------------------------------
# This class handles the party. It includes information on amount of gold
# and items. Refer to "$game_party" for the instance of this class.
#==============================================================================
class Game_Party
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :party_size
end
#==============================================================================
# ** Spriteset_Battle
#------------------------------------------------------------------------------
# This class brings together battle screen sprites. It's used within
# the Scene_Battle class.
#==============================================================================
class Spriteset_Battle
#--------------------------------------------------------------------------
# * Change Enemy Viewport
#--------------------------------------------------------------------------
alias mnk_initialize initialize
def initialize
mnk_initialize
# Determine if RTAB system in use
if @real_zoom != nil
$game_system.mnk_det_rtab_systm = true
end
@enemy_sprites = []
for enemy in $game_troop.enemies.reverse
@enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
end
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
alias mnk_update update
def update
# Set current number of battlers
mnkps = 4
mnkps = $game_party.party_size if $game_party.party_size != nil
# Added routine to load battlers during combat
unless @mnk_battlers_reloaded
@actor_sprites = []
for i in 0...mnkps
@actor_sprites.push(Sprite_Battler.new(@viewport1))
end
@mnk_battlers_reloaded = true
end
# Perform the original call
mnk_update
# 'Re-'Update actor sprite contents (corresponds with actor switching)
for i in 0...mnkps
@actor_sprites[i].battler = $game_party.actors[i]
end
end
#--------------------------------------------------------------------------
# * Find Sprite From Battler Handle
#--------------------------------------------------------------------------
def battler(handle)
for sprite in @actor_sprites + @enemy_sprites
return sprite if sprite.battler == handle
end
end
end
#==============================================================================
# ** Arrow_Base
#------------------------------------------------------------------------------
# This sprite is used as an arrow cursor for the battle screen. This class
# is used as a superclass for the Arrow_Enemy and Arrow_Actor classes.
#==============================================================================
class Arrow_Base < Sprite
#--------------------------------------------------------------------------
# * Reposition Arrows
#--------------------------------------------------------------------------
alias mnk_initialize initialize
def initialize(viewport)
mnk_initialize(viewport)
self.ox = MNK_ARROW_X
self.oy = MNK_ARROW_Y
end
end