module Side_view
#--------------------------------------------------------------------------
# œ Using together RTAB@™Automatic recognition
#--------------------------------------------------------------------------
if Scene_Battle.method_defined?("synthe?")
RTAB = true
else
RTAB = false
end
#--------------------------------------------------------------------------
# œ Using together RTAB cam ™Automatic recognition
#--------------------------------------------------------------------------
def camera_correctness
return false if !RTAB
begin
return $scene.drive
rescue
return false
end
end
#--------------------------------------------------------------------------
# œ The maximum number of parties
#--------------------------------------------------------------------------
Party_max = 4
#--------------------------------------------------------------------------
# œ Expansion rate of Battler graphic(actor exclusive use)
#--------------------------------------------------------------------------
CHAR_ZOOM = 1.0
#--------------------------------------------------------------------------
# œ Arrow cursor position correction
#--------------------------------------------------------------------------
ARROW_OX = 0
ARROW_OY = 64
#--------------------------------------------------------------------------
# œ State name treated as flight (Array)
#--------------------------------------------------------------------------
FLY_STATES = ["Flying"]
#--------------------------------------------------------------------------
# œ Positional correction of combat screen party
#--------------------------------------------------------------------------
PARTY_X = 480 # X position of party
PARTY_Y = 200 # Y position of party
FORMATION_X = 32 # actor's interval X
FORMATION_Y = 38 # actor's interval Y
#--------------------------------------------------------------------------
# œ ƒJƒXƒ^ƒ}ƒCƒY'è"
#--------------------------------------------------------------------------
NORMAL = "NORMAL"
WALK_R = "WALK_R"
WALK_L = "WALK_L"
ATTACK = "ATTACK"
ATTACK_R = "ATTACK_R"
ATTACK_L = "ATTACK_L"
MAGIC = "MAGIC"
ITEM = "ITEM"
# ƒAƒjƒ,ÌÝ'è
ANIME = {
# [id,Loop?,speed,weapon visible,pattern freeze,Weapon Right or Left(using RTAB)]
NORMAL => [1,true , 0,false, true ,"" ], # Standby usually
WALK_R => [2,true , 6,false, false,"" ], # move Right
WALK_L => [1,true , 6,false, false,"" ], # move Left
ATTACK_R => [1,false, 6,true , false,"Right"],# attack by Right hand
ATTACK_L => [1,false, 6,true , false,"Left"], # attack by Left hand
MAGIC => [1,false, 6,false, false,"" ], # spell Magic
ITEM => [1,false, 6,false, false,"" ], # using Item
}
# default (Do not change it)
ANIME.default = [1,false,12,false,"",""]
# ƒAƒNƒVƒ‡ƒ"Ý'è,ÌŠÖ˜A•t,¯
ACTION_LIB = {
"Hero Move" => "moving_setup",
"Hero Graphic Change" => "change",
"Throw Animation" => "flying",
"main phase step 3" => "animation1",
"main phase step 4" => "animation2",
"Waiting" => "wait",
"Graphic Reverse" => "reverse",
"Afterimage ON" => "shadow_on",
"Afterimage OFF" => "shadow_off",
"Freeze ON" => "freeze",
"Freeze OFF" => "freeze_lifting",
"Display Animation" => "animation_start",
"Play Sound Effect" => "play_se",
}
ACTION_LIB.default = "finish"
# (Do not change it)
DUAL_WEAPONS_ANIME = [ATTACK]
# Arms display X coordinates
BLZ_X = {
0=>[0,0,0,0], # NO MOTION
1=>[2,2,2,2], # Shake lowering
2=>[15,10,0,0], # Piercing
3=>[2,2,2,2], # Raising
4=>[0,0,3,3], # Bow and gun
5=>[0,0,0,0], # For addition
6=>[0,0,0,0], # For addition
7=>[0,0,0,0], # For addition
8=>[0,0,0,0], # For addition
}
# Arms display Y coordinates
BLZ_Y = {
0=>[0,0,0,0], # NO MOTION
1=>[6,6,6,6], # Shake lowering
2=>[6,6,6,6], # Piercing
3=>[6,6,6,6], # Raising
4=>[8,8,8,8], # Bow and gun
5=>[0,0,0,0], # For addition
6=>[0,0,0,0], # For addition
7=>[0,0,0,0], # For addition
8=>[0,0,0,0], # For addition
}
# Arms display Angle
BLZ_ANGLE = {
0=>[0,0,0,0], # NO MOTION
1=>[75-45*3,75-45*2,75-45*1,75-45*1], # Shake lowering
2=>[45,45,45,45], # Piercing
3=>[100-45*1,100-45*2,100-45*3,00-45*4], # Raising
4=>[45,45,45,45], # Bow and gun
5=>[0,0,0,0], # For addition
6=>[0,0,0,0], # For addition
7=>[0,0,0,0], # For addition
8=>[0,0,0,0], # For addition
}
#--------------------------------------------------------------------------
# œ SHAKE
#--------------------------------------------------------------------------
SHAKE_FILE = "SHAKE" # filename
SHAKE_POWER = 5 # POWER
SHAKE_SPEED = 5 # SPEED
SHAKE_DURATION = 5 # DURATION
#--------------------------------------------------------------------------
# œ UPSIDE_DOWN
#--------------------------------------------------------------------------
UPSIDE_DOWN_FILE = "UPSIDE_DOWN" # filename
#--------------------------------------------------------------------------
# œ REVERSE
#--------------------------------------------------------------------------
REVERSE_FILE = "REVERSE" # filename
#--------------------------------------------------------------------------
# œ ‰ñ"],ÌÝ'è
#--------------------------------------------------------------------------
TURNING_FILE = "ROTATION" # filename
TURNING_DIRECTION = 1 # Directioni1.Anti-clockwise, -1.clockwise)
TURNING_SPEED = 32 # Speed
TURNING_DURATION = 1 # Rotation frequency
#--------------------------------------------------------------------------
# œ ˆÚ"®,ÌÝ'è
#--------------------------------------------------------------------------
MOVE_FILE = "MOVE" # filename
MOVE_RETURN = 1 # Do you return to former position?
MOVE_SPEED = 32 # Speed
MOVE_COORDINATES = [0, -640] # Relative coordinates from former position
#--------------------------------------------------------------------------
# œ Add Animation (using RTAB)
#--------------------------------------------------------------------------
ADD_ANIME_FILE = "Add_ANIME" # filename
ADD_ANIME_ID = 0 # Animation ID
#--------------------------------------------------------------------------
# œ using RTAB (Do not change it)
#--------------------------------------------------------------------------
def convert_battler
return RTAB ? @active_actor : @active_battler
end
#--------------------------------------------------------------------------
# œ using RTAB (Do not change it)
#--------------------------------------------------------------------------
def convert_battler2(*arg)
return RTAB ? arg[0] : @active_battler
end
end
#--------------------------------------------------------------------------
# œ action performer
#--------------------------------------------------------------------------
module BattleActions
# Because the one below is one example to the last
# Please make it originally.
Actions = {
"Normal Attack" => [
"main phase step 3",
"Hero Graphic Change#WALK_L",
"Hero Move#target,32,0,64,0",
"Hero Graphic Change#NORMAL",
"Waiting#5",
"Hero Graphic Change#ATTACK",
"Throw Animation",
"main phase step 4",
"Waiting#5",
"Hero Graphic Change#WALK_L",
"Play Sound Effect#016-Jump02,80,100",
"Hero Move#self,0,0,18,0",
"end"
],
"One step advancement Attack" => [
"main phase step 3",
"Hero Graphic Change#WALK_L",
"Hero Move#self,-32,0,12,0",
"Hero Graphic Change#NORMAL",
"Waiting#5",
"Hero Graphic Change#ATTACK",
"Throw Animation",
"main phase step 4",
"Waiting#5",
"Hero Graphic Change#WALK_L",
"Play Sound Effect#016-Jump02,80,100",
"Hero Move#self,0,0,12,0",
"end"
],
"Enemy Attack" => [
"main phase step 3",
"Hero Graphic Change#WALK_L",
"Hero Move#self,-36,0,12,0",
"Hero Graphic Change#NORMAL",
"Waiting#5",
"Hero Graphic Change#ATTACK",
"Throw Animation",
"main phase step 4",
"Waiting#5",
"Hero Graphic Change#WALK_L",
"Hero Move#self,0,0,12,0",
"end"
],
"Spell Magic" => [
"main phase step 3",
"Hero Graphic Change#WALK_L",
"Hero Move#self,-32,0,4,0",
"Hero Graphic Change#MAGIC",
"Waiting#15",
"Throw Animation",
"main phase step 4",
"Waiting#5",
"Hero Graphic Change#WALK_L",
"Hero Move#self,0,0,4,2",
"end"
],
"Using Item" => [
"Hero Graphic Change#WALK_L",
"Hero Move#self,-32,0,4,0",
"main phase step 3",
"Hero Graphic Change#ITEM",
"Waiting#15",
"Throw Animation",
"main phase step 4",
"Waiting#5",
"Hero Graphic Change#WALK_L",
"Hero Move#self,0,0,4,2",
"end"
],
"Using Skill" => [
"Hero Graphic Change#WALK_L",
"Hero Move#target_near,50,0,48,6",
"Graphic Reverse",
"Freeze ON#ATTACK#3",
"main phase step 3",
"Play Sound Effect#135-Light01,100,100",
"Display Animation#self,42",
"Waiting#15",
"Graphic Reverse",
"Afterimage ON",
"Hero Move#target_far,-50,0,48,0",
"main phase step 4",
"Waiting#5",
"Afterimage OFF",
"Freeze OFF",
"Hero Graphic Change#WALK_L",
"Hero Move#self,0,0,48,1,0",
"end"
],
}
end
module RPG
# Because the one below is one example to the last
# Please make it originally.
class Weapon
#--------------------------------------------------------------------------
# Weapon sctions. Set what weapons are a stand still weapon.
#--------------------------------------------------------------------------
def battle_actions
case @id
when 91, 92, 93, 94, 95, 96, 97, 98, 99, 101, 102, 103, 104, 105, 106, 107,
108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 123,
124, 125, 126, 127, 128, 129, 130, 131, 132, 191, 192, 193, 194, 195,
196, 197, 198, 199, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210,
211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
225 # ID of Ranged Weapon
return BattleActions::Actions["One step advancement Attack"]
end
return BattleActions::Actions["Normal Attack"] # default
end
end
class Skill
#--------------------------------------------------------------------------
# œ action performer
#--------------------------------------------------------------------------
def battle_actions
case @id
when 73,74,75,76,77,78,79,80 # Ranged Skill
return BattleActions::Actions["One step advancement Attack"]
when 82 # Mellee Skill
return BattleActions::Actions["Using Skill"]
when 83 # Magic Skill
return BattleActions::Actions["Spell Magic"]
end
else
if self.magic?
return BattleActions::Actions["Spell Magic"]
else
return BattleActions::Actions["Using Skill"]
end
end
end
class Item
#--------------------------------------------------------------------------
# œ action performer
#--------------------------------------------------------------------------
def battle_actions
return BattleActions::Actions["Using Item"] # default
end
end
end
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# œ action performer
#--------------------------------------------------------------------------
def battle_actions
return BattleActions::Actions["Enemy Attack"] # default
end
end
module RPG
=begin
œ Setting of arms type
The attribute of the name "WeaponType" is made, and it is applied to arms.
The figure is written behind "WeaponType".
@@
Example.@WeaponType1@
=end
class Weapon
#--------------------------------------------------------------------------
# œ WeaponType
#--------------------------------------------------------------------------
def anime
# Elemental
element_name = "WeaponType"
for i in @element_set
if $data_system.elements[i] =~ /#{element_name}([+-]?[0-9]+)?(%)?/
return $1.to_i
end
end
# Weapon ID
# Because the one below is one example to the last
# Please make it originally.
case @id
when 1,2,3,4
return 1 # (WeaponType) Refer from the 115th line to the 150th line.
when 5,6,7,8
return 2 # (WeaponType) Refer from the 115th line to the 150th line.
end
return 1 # defaut
end
end
end
=begin
#--------------------------------------------------------------------------
# œ Include Animation
#--------------------------------------------------------------------------
@ Animation is included from performer to target.
Please make animation from the data base.
[ Animation ID, Speed, Do you shuttle?, Straight line (false) or curve(true)]
=end
module RPG
class Weapon
#--------------------------------------------------------------------------
# œ Include Animation
#--------------------------------------------------------------------------
def flying_anime
# Example
case @id
when 34 # Boomerang
return [10,32,true,true]
when 20 # Arrow
return [40,32,false,false]
end
return [0,0,false,false] # No throw
end
end
class Skill
#--------------------------------------------------------------------------
# œ Include Animation
#--------------------------------------------------------------------------
def flying_anime
# Example
case @id
when 34 # Boomerang
return [10,32,true,true]
when 20 # Arrow
return [40,32,false,false]
end
return [0,0,false,false] # No throw
end
end
class Item
#--------------------------------------------------------------------------
# œ Include Animation
#--------------------------------------------------------------------------
def flying_anime
# Example
case @id
when 34 # Boomerang
return [10,32,true,true]
when 35 # Arrow
return [40,32,false,false]
end
return [0,0,false,false] # No throw
end
end
end
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# œ Throw Animation
#--------------------------------------------------------------------------
def flying_anime
return [0,0,false,false]
end
end
#==============================================================================
# ¡ Game_Battler
#==============================================================================
class Game_Battler
include Side_view
#--------------------------------------------------------------------------
# œ 'ljÁEŒöŠJƒCƒ"ƒXƒ^ƒ"ƒX•Ï"
#--------------------------------------------------------------------------
attr_accessor :height # ‰æ'œ,Ì,,³
attr_accessor :real_x # XÀ•W•â³
attr_accessor :real_y # YÀ•W•â³
attr_accessor :real_zoom # Šg'å--¦
attr_accessor :wait_count # ƒAƒjƒ[ƒVƒ‡ƒ" 'Ò,¿ŽžŠÔ
attr_accessor :wait_count2 # ƒAƒjƒ[ƒVƒ‡ƒ" 'Ò,¿ŽžŠÔ2
attr_accessor :pattern # ƒAƒjƒ[ƒVƒ‡ƒ" ƒJƒEƒ"ƒgiƒLƒƒƒ‰)
attr_accessor :shake # ƒVƒFƒCƒNŠJŽnƒtƒ‰ƒbƒO
attr_accessor :reverse # ¶‰E"½"]ƒtƒ‰ƒbƒO
attr_accessor :shadow # Žc'œƒtƒ‰ƒbƒO
attr_accessor :flash_flag # 'M,«ƒtƒ‰ƒbƒO
attr_reader :ox # XÀ•W•â³
attr_reader :oy # YÀ•W•â³
attr_reader :flying_x # ‰"‹----£ƒAƒjƒXÀ•W
attr_reader :flying_y # ‰"‹----£ƒAƒjƒYÀ•W
attr_reader :flying_anime # ‰"‹----£ƒAƒjƒ
attr_reader :animation1_on # s"®ƒAƒjƒŠJŽnƒtƒ‰ƒbƒO
attr_reader :animation2_on # 'ÎÛƒAƒjƒŠJŽnƒtƒ‰ƒbƒO
#--------------------------------------------------------------------------
# œ ƒfƒtƒHƒ‹ƒg,̃Aƒjƒ[ƒVƒ‡ƒ"'Ò,¿ŽžŠÔ,ðŽæ"¾
#--------------------------------------------------------------------------
def animation_duration=(animation_duration)
@_animation_duration = animation_duration
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹ŠJŽnŽž,̃ZƒbƒgƒAƒbƒv
#--------------------------------------------------------------------------
def start_battle
@height = 0
@real_x = 0
@real_y = 0
@real_zoom = 1.0
@battler_condition = ""
@action = nil
@battle_actions = []
@battler_action = false
@step = 0
@anime_on = false
@wait_count = 0
@wait_count2 = 0
@ox = 0
@oy = 0
@pattern = 0
@pattern_log = true
@pattern_freeze = false
@condition_freeze = false
@active = false
@move_distance = nil
@move_wait = 0
@move_coordinates = [0,0,0,0]
@flying_distance = nil
@flying_wait = 0
@flying_x = 0
@flying_y = 0
@flash_flag = {}
self.flying_clear
end
#--------------------------------------------------------------------------
# œ ˆÚ"®'†"»'è
#--------------------------------------------------------------------------
def moving?
# XÀ•W•â³,Ü,½,ÍAYÀ•W•â³,ª0,Å,È,¯,ê,ÎAˆÚ"®'†
return (@ox != 0 or @oy != 0)
end
#--------------------------------------------------------------------------
# œ ˆÚ"®I--¹"»'è
#--------------------------------------------------------------------------
def move_end?
return (@ox == @move_coordinates[0] and @oy == @move_coordinates[1])
end
#--------------------------------------------------------------------------
# œ ƒAƒNƒVƒ‡ƒ"ŠJŽnÝ'è
#--------------------------------------------------------------------------
def action(flag = true)
@battler_action = flag
@animation1_on = false
@animation2_on = false
@step = "setup"
end
#--------------------------------------------------------------------------
# œ ƒAƒNƒVƒ‡ƒ"'†"»'è
#--------------------------------------------------------------------------
def action?
return @battler_action
end
#--------------------------------------------------------------------------
# œ 'M,«"»'è
#--------------------------------------------------------------------------
def flash?
return @flash_flg
end
#--------------------------------------------------------------------------
# œ í"¬•s"\"»'è
#--------------------------------------------------------------------------
def anime_dead?
if $game_temp.in_battle and !RTAB
if [2,3,4,5].include?($scene.phase4_step)
return @last_dead
end
end
return @last_dead = self.dead?
end
#--------------------------------------------------------------------------
# œ ƒsƒ"ƒ`ó'Ô"»'è
#--------------------------------------------------------------------------
def crisis?
if $game_temp.in_battle and !RTAB
if [2,3,4,5].include?($scene.phase4_step)
return @last_crisis
end
end
return @last_crisis = (self.hp <= self.maxhp / 4 or badstate?)
end
#--------------------------------------------------------------------------
# œ ƒoƒbƒhƒXƒe[ƒg"»'è
#--------------------------------------------------------------------------
def badstate?
for i in @states
unless $data_states[i].nonresistance
return true
end
end
return false
end
#--------------------------------------------------------------------------
# œ "òs
#--------------------------------------------------------------------------
def fly
if @fly != nil
return @fly
end
for id in @states
if FLY_STATES.include?($data_states[id].name)
return 60
end
end
return 0
end
#--------------------------------------------------------------------------
# œ ‰"‹----£ƒAƒjƒ-Ú•WÀ•W,ÌŒvŽZ
#--------------------------------------------------------------------------
def flying_setup
# "ñ"x-Ú,ÍŽÀs,µ,È,¢
return if @flying_distance != nil && !camera_correctness
if RTAB
targets = @target
else
targets = $scene.target_battlers
end
# -Ú"IÀ•W,ðŒvŽZ
@f_target_x = 0
@f_target_y = 0
for t in targets
@f_target_x += t.screen_x
@f_target_y += t.screen_y
end
if targets != []
@f_target_x /= targets.size
@f_target_y /= targets.size
else
@flying_distance = 0
return
end
# ‹----£,ÌŒvŽZ
@flying_distance = (self.screen_x - @f_target_x).abs + (self.screen_y - @f_target_y).abs
@flying_end = false
end
#--------------------------------------------------------------------------
# œ ‰"‹----£ƒAƒjƒ
#--------------------------------------------------------------------------
def flying_animation
# -ß,é
if @step != "flying" or @flying_distance.nil?
return [false,true]
end
# , ,ç,©,¶,ߌvŽZ
self_x = self.screen_x
self_y = self.screen_y
@flying_distance = @flying_distance == 0 ? 1 : @flying_distance
n1 = @flying_wait / @flying_distance.to_f
if @flying_distance - @flying_wait > @flying_distance / 2
n2 = 1.0 + 10.0 * @flying_wait / @flying_distance.to_f
else
n2 = 1.0 + 10.0 * (@flying_distance - @flying_wait) / @flying_distance.to_f
end
if !@flying_anime[4]
# '¼üˆÚ"®
x = (self_x + 1.0 * (@f_target_x - self_x) * n1).to_i
y = (self_y + 1.0 * (@f_target_y - self_y) * n1).to_i
else
# ‹ÈüˆÚ"®
if !@flying_proceed_end
x = (self_x + 1.0 * (@f_target_x - self_x) * n1).to_i
y = (self_y + 1.0 * (@f_target_y - self_y) * n1 - n2**2).to_i
else
x = (self_x + 1.0 * (@f_target_x - self_x) * n1).to_i
y = (self_y + 1.0 * (@f_target_y - self_y) * n1 + n2**2).to_i
end
end
# À•W'ã"ü
@flying_x = x
@flying_y = y
# ƒEƒGƒCƒg
if !@flying_proceed_end
# ŠJŽn
@flying_proceed_start = @flying_wait == 0
@flying_wait += @flying_anime[1]
@flying_wait = [@flying_wait,@flying_distance].min
@flying_proceed_end = @flying_wait == @flying_distance
else
# ŠJŽn
@flying_return_start = @flying_wait == @flying_distance
@flying_wait -= @flying_anime[1]
@flying_wait = [@flying_wait,0].max
@flying_return_end = @flying_wait == 0
end
if @flying_anime[1] == 0
@flying_end = true
elsif !@flying_anime[2]
@flying_end = @flying_proceed_end
else
@flying_end = @flying_return_end
end
# 'l,ð•Ô,·iƒAƒjƒŠJŽn,ƒAƒjƒI--¹)
return [@flying_proceed_start,@flying_end]
end
#--------------------------------------------------------------------------
# œ ‰"‹----£ƒAƒjƒ‰Šú‰»
#--------------------------------------------------------------------------
def flying_clear
@flying_proceed_start = false
@flying_proceed_end = false
@flying_return_start = false
@flying_return_end = false
@flying_end = true
@flying_anime = [0,0,false,false]
end
#--------------------------------------------------------------------------
# œ ˆÚ"®
#--------------------------------------------------------------------------
def move
# ‹----£,ÌŒvŽZ
@move_distance = (@move_coordinates[2] - @move_coordinates[0]).abs +
(@move_coordinates[3] - @move_coordinates[1]).abs
if @move_distance > 0
return if @ox == @move_coordinates[0] and @oy == @move_coordinates[1]
array = @move_coordinates
# ƒWƒƒƒ"ƒv•â³'l,ÌŒvŽZ
n = 100.0 * @move_wait / @move_distance
jump = -@move_action[4] * n * (100 - n) / 100.0
@ox = (array[2] + 1.0 * (array[0] - array[2]) * (@move_distance - @move_wait) / @move_distance.to_f).to_i
@oy = (array[3] + 1.0 * (array[1] - array[3]) * (@move_distance - @move_wait) / @move_distance.to_f + jump).to_i
# ƒEƒGƒCƒg
@move_wait -= @move_action[3]
@move_wait = [@move_wait,0].max
end
end
#--------------------------------------------------------------------------
# œ ˆÚ"®ƒAƒNƒVƒ‡ƒ",ÌŽæ"¾
#--------------------------------------------------------------------------
def get_move_action
string = @action.split(/#/)[1]
string = string.split(/,/)
@move_action = [string[0],string[1].to_i,string[2].to_i,string[3].to_i,string[4].to_i,string[5].to_i]
end
#--------------------------------------------------------------------------
# œ ƒAƒNƒVƒ‡ƒ",ÌŽæ"¾
#--------------------------------------------------------------------------
def get_step
if @action.nil?
@step = "finish"
return
end
return ACTION_LIB[@action.split(/#/)[0]]
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ŽŸ,̃AƒNƒVƒ‡ƒ",Ö)
#--------------------------------------------------------------------------
def update_next
@action = @battle_actions.shift
@step = get_step
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV ("®ìŽæ"¾)
#--------------------------------------------------------------------------
def update_setup
# ƒAƒNƒVƒ‡ƒ",ÌŽæ"¾
self.get_actions
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ˆÚ"®Žæ"¾)
#--------------------------------------------------------------------------
def update_moving_setup
# ˆÚ"®ƒAƒNƒVƒ‡ƒ",ÌŽæ"¾
self.get_move_action
# ˆÚ"®-Ú•W,ÌÝ'è
self.move_setup
@step = "moving"
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ˆÚ"®)
#--------------------------------------------------------------------------
def update_moving
# ˆÚ"®
self.move
self.condition = @battler_condition
# ˆÚ"®Š®--¹,µ,½,玟,̃Xƒeƒbƒv,Ö
if move_end?
update_next
end
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒAƒjƒŽÀs)
#--------------------------------------------------------------------------
def update_action
con = @action.split(/#/)[1]
# ‰EŽèE¶Žè,ð•ª,¯,é
if DUAL_WEAPONS_ANIME.include?(con)
if !@first_weapon and @second_weapon
con = con + "_L"
else
con = con + "_R"
end
end
# ƒAƒjƒ•ÏX
self.condition = con
# ƒ‹[ƒv,©"Û,©
if !ANIME[@battler_condition][1]
self.anime_on
end
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (‰"‹----£ƒAƒjƒ)
#--------------------------------------------------------------------------
def update_flying
# -Ú•W,ÌÝ'è
self.flying_setup
# ‰"‹----£ƒAƒjƒI--¹
if @flying_end or @flying_anime == [0,0,false,false]
self.flying_clear
update_next
end
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒAƒjƒ•ÏX)
#--------------------------------------------------------------------------
def update_change
con = @action.split(/#/)[1]
# ‰EŽèE¶Žè,ð•ª,¯,é
if DUAL_WEAPONS_ANIME.include?(con)
if !@first_weapon and @second_weapon
con = con + "_L"
else
con = con + "_R"
end
end
# ƒAƒjƒ•ÏX
self.condition = con
# ƒ‹[ƒv,©"Û,©
if !ANIME[@battler_condition][1]
self.anime_on
end
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (s"®ƒAƒjƒ)
#--------------------------------------------------------------------------
def update_animation1
@animation1_on = true
# s"®ƒAƒjƒ,ÌŒã,És"®,ðŠJŽn,·,é
if $scene.phase4_step == 3
id = RTAB ? @anime1 : $scene.animation1_id
animation = $data_animations[id]
frame_max = animation != nil ? animation.frame_max : 0
@wait_count2 = frame_max * 2
return
end
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV ('ÎÛƒAƒjƒ)
#--------------------------------------------------------------------------
def update_animation2
@animation2_on = true
# s"®ƒAƒjƒ,ÌŒã,És"®,ðŠJŽn,·,é
if $scene.phase4_step == 4
id = RTAB ? @anime2 : $scene.animation2_id
animation = $data_animations[id]
frame_max = animation != nil ? animation.frame_max : 0
@wait_count2 = frame_max * 2
return
end
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒEƒGƒCƒg)
#--------------------------------------------------------------------------
def update_wait
@wait_count2 = @action.split(/#/)[1].to_i
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (Žc'œ•\Ž¦)
#--------------------------------------------------------------------------
def update_shadow_on
@shadow = true
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (Žc'œÁ‹Ž)
#--------------------------------------------------------------------------
def update_shadow_off
@shadow = false
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (¶‰E"½"])
#--------------------------------------------------------------------------
def update_reverse
@reverse = @reverse ? false : true
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV ('M,«ƒAƒjƒ)
#--------------------------------------------------------------------------
def update_flash
# 'M,«ƒAƒjƒ,ÌŒã,És"®,ðŠJŽn,·,é
if @flash_flag["normal"]
@wait_count = $scene.flash_duration
@flash_flag["normal"] = false
return
end
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (SE,̉‰'t)
#--------------------------------------------------------------------------
def update_play_se
data = @action.split(/#/)[1]
data = data.split(/,/)
# SE ,ð‰‰'t
Audio.se_play("Audio/SE/" + data[0], data[1].to_i, data[2].to_i)
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒAƒNƒ^[ƒAƒjƒŒÅ'è)
#--------------------------------------------------------------------------
def update_freeze
con = @action.split(/#/)[1]
# ‰EŽèE¶Žè,ð•ª,¯,é
if DUAL_WEAPONS_ANIME.include?(con)
if !@first_weapon and @second_weapon
con = con + "_L"
else
con = con + "_R"
end
end
# ƒAƒjƒ•ÏX
self.condition = con
@pattern = @action.split(/#/)[2].to_i
@pattern_freeze = true
@condition_freeze = true
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒAƒNƒ^[ƒAƒjƒŒÅ'è‰ðœ)
#--------------------------------------------------------------------------
def update_freeze_lifting
@pattern_freeze = false
@condition_freeze = false
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒAƒjƒ[ƒVƒ‡ƒ",Ì•\Ž¦)
#--------------------------------------------------------------------------
def update_animation_start
data = @action.split(/#/)[1]
data = data.split(/,/)
target = data[0]
animation_id = data[1].to_i
if RTAB
case target
when "self"
@animation.push([animation_id,true])
when "target"
for tar in @target
tar.animation.push([animation_id, true])
end
end
else
case target
when "self"
@animation_id = animation_id
@animation_hit = true
when "target"
for tar in $scene.target_battlers
tar.animation_id = animation_id
tar.animation_hit = true
end
end
end
update_next
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV ("®ìI--¹)
#--------------------------------------------------------------------------
def update_finish
# "®ìI--¹
@battler_action = false
@step = "setup"
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‰[,Ìó'Ôiƒoƒgƒ‰[ƒOƒ‰ƒtƒBƒbƒN,̃^ƒCƒv)
#--------------------------------------------------------------------------
def condition
return @battler_condition
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‰[,Ìó'Ô •ÏXiƒoƒgƒ‰[ƒOƒ‰ƒtƒBƒbƒN,̃^ƒCƒv)
#--------------------------------------------------------------------------
def condition=(condition)
return if @condition_freeze
if @battler_condition != condition
@wait_count = ANIME[condition][2]
@pattern = 0
end
@battler_condition = condition
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV
#--------------------------------------------------------------------------
def update
# ƒEƒFƒCƒg'†,Ìê‡
if @wait_count == 0
# ƒpƒ^[ƒ"XV
self.char_animation
@wait_count = ANIME[@battler_condition][2]
end
# ƒpƒ^[ƒ"XV
self.char_animation
# ƒEƒFƒCƒg'†,Ìê‡
if @wait_count2 > 0
return
end
# s"®ƒAƒjƒ[ƒVƒ‡ƒ"
if @battler_action
method("update_" + @step).call
return
end
# ƒf[ƒ^‰Šú‰»
@animation1_on = false
@animation2_on = false
@action = nil
@battle_actions = []
@move_wait = 0
@move_distance = nil
@flying_wait = 0
@flying_distance = nil
@flash = false
# 'ÊíE'Ò‹@
return self.condition = NORMAL
end
#--------------------------------------------------------------------------
# œ ƒAƒNƒVƒ‡ƒ",ÌŽæ"¾
#--------------------------------------------------------------------------
def get_actions
skill = $data_skills[self.current_action.skill_id]
item = $data_items[self.current_action.item_id]
kind = self.current_action.kind
# "®ìŽæ"¾
@battle_actions = []
# ƒXƒLƒ‹
if skill != nil && kind == 1
@battle_actions = skill.battle_actions.dup
@flying_anime = skill.flying_anime
# ƒAƒCƒeƒ€
elsif item != nil && kind == 2
@battle_actions = item.battle_actions.dup
@flying_anime = item.flying_anime
# ¶ŽèUŒ,
elsif !@first_weapon and @second_weapon and self.is_a?(Game_Actor)
@battle_actions = self.battle_actions2.dup
@flying_anime = self.flying_anime2
# ‰EŽèUŒ,
elsif self.current_action.basic == 0 and
self.is_a?(Game_Actor) and self.current_action.kind == 0
@battle_actions = self.battle_actions1.dup
@flying_anime = self.flying_anime1
# 'ÊíUŒ,
elsif self.current_action.basic == 0 and self.current_action.kind == 0
@battle_actions = self.battle_actions.dup
@flying_anime = self.flying_anime
else
@battle_actions = ["I--¹"]
@flying_anime = [0,0,false,false]
end
end
#--------------------------------------------------------------------------
# œ ƒ‹[ƒv,µ,È,¢ƒAƒjƒ,̃Zƒbƒg
#--------------------------------------------------------------------------
def anime_on
@pattern = 0
@pattern_log = true
return
end
#--------------------------------------------------------------------------
# œ ƒpƒ^[ƒ"XV
#--------------------------------------------------------------------------
def char_animation
# ƒpƒ^ƒ"ŒÅ'è,Ìê‡,à,Ç,é
return if @pattern_freeze
# ƒ‹[ƒv,µ,È,¢ƒAƒjƒ,Ìê‡ 1234 ,ÅŽ~,Ü,é
if !ANIME[@battler_condition][1] && @pattern == 3
return
end
# ƒAƒjƒ,³,¹,È,¢ê‡ 1 ,ÅŽ~,Ü,é
if ANIME[@battler_condition][4]
@pattern = 0
return
end
@pattern = (@pattern + 1) % 4
end
#--------------------------------------------------------------------------
# œ ƒAƒjƒƒ^ƒCƒv
#--------------------------------------------------------------------------
def anime_type
return ANIME[@battler_condition] != nil ? ANIME[@battler_condition][0] : 0
end
end
#==============================================================================
# ¡ Game_Actor
#==============================================================================
class Game_Actor < Game_Battler
include Side_view
#--------------------------------------------------------------------------
# œ ƒZƒbƒgƒAƒbƒv
#--------------------------------------------------------------------------
alias side_view_setup setup
def setup(actor_id)
side_view_setup(actor_id)
start_battle
end
#--------------------------------------------------------------------------
# œ "ñ"•Ší,ÌIDŽæ"¾@¦ƒGƒ‰[‰ñ"ð--p
#--------------------------------------------------------------------------
def weapon2_id
return @weapon2_id != nil ? @weapon2_id : 0
end
#--------------------------------------------------------------------------
# œ X•ûŒü ƒ|ƒWƒVƒ‡ƒ" Žæ"¾
#--------------------------------------------------------------------------
def position
return $data_classes[@class_id].position
end
#--------------------------------------------------------------------------
# œ Y•ûŒü ƒ|ƒWƒVƒ‡ƒ" Žæ"¾
#--------------------------------------------------------------------------
def position2
return self.index
end
#--------------------------------------------------------------------------
# œ •ŠíƒAƒjƒƒ^ƒCƒv
#--------------------------------------------------------------------------
def weapon_anime_type(type = @battler_condition)
file_name = weapon_anime_type0(type)
visible = weapon_anime_type1(type)
z = weapon_anime_type2(type)
motion = weapon_anime_type3(type)
return [file_name,visible,z,motion]
end
# •ŠíƒAƒCƒRƒ"Žæ"¾
def weapon_anime_type0(type = @battler_condition)
type = ANIME[type][5]
return weapon_anime1 if type == "Right"
return weapon_anime2 if type == "Left"
return nil
end
# •\Ž¦E"ñ•\Ž¦,ÌŽæ"¾
def weapon_anime_type1(type = @battler_condition)
return ANIME[type][3]
end
# ƒoƒgƒ‰[,æ,èã,É•\Ž¦,·,é,©,Ç,¤,©
def weapon_anime_type2(type = @battler_condition)
type = ANIME[type][5]
return true if type == "Left"
return false
end
# •Ší,Ì"®ìNoDŽæ"¾
def weapon_anime_type3(type = @battler_condition)
type = ANIME[type][5]
return extend_weapon_anime1 if type == "Right"
return extend_weapon_anime2 if type == "Left"
return 0
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ-Ê X À•W,ÌŽæ"¾(ƒJƒƒ‰•â³-³,µ)
#--------------------------------------------------------------------------
def true_x
return PARTY_X + position * FORMATION_X + @ox
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ-Ê Y À•W,ÌŽæ"¾(ƒJƒƒ‰•â³-³,µ)
#--------------------------------------------------------------------------
def true_y
# ƒp[ƒeƒB"à,Ì•À,ч,©,ç Y À•W,ðŒvŽZ,µ,Ä•Ô,·
if self.index != nil
y = position2 * FORMATION_Y + PARTY_Y + @oy - @height / 2
return y
else
return 0
end
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ-Ê X À•W,ÌŽæ"¾
#--------------------------------------------------------------------------
def screen_x(true_x = self.true_x)
return 320 + (true_x - 320) * @real_zoom + @real_x
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ-Ê Y À•W,ÌŽæ"¾
#--------------------------------------------------------------------------
def screen_y(true_y = self.true_y)
return true_y * @real_zoom + @real_y
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ-Ê Z À•W,ÌŽæ"¾
#--------------------------------------------------------------------------
def screen_z
return screen_y + 1000
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ-Ê X À•W,ÌŽæ"¾(ˆÚ"®,È,Ç,µ,Ä,¢,È,¢ê‡)
#--------------------------------------------------------------------------
def base_x
return 320 + (true_x - @ox - 320) * @real_zoom + @real_x
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ-Ê Y À•W,ÌŽæ"¾
#--------------------------------------------------------------------------
def base_y
return (true_y - @oy) * @real_zoom + @real_y
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ-Ê Šg'å--¦,ÌŽæ"¾
#--------------------------------------------------------------------------
def zoom
return ($scene.zoom_rate[1] - $scene.zoom_rate[0]) *
(true_x + @fly) / 480 + $scene.zoom_rate[0]
end
#--------------------------------------------------------------------------
# œ UŒ,--pAƒoƒgƒ‹‰æ-Ê X À•W,ÌŽæ"¾
#--------------------------------------------------------------------------
def attack_x(z)
return (320 - true_x) * z * 0.75
end
#--------------------------------------------------------------------------
# œ UŒ,--pAƒoƒgƒ‹‰æ-Ê Y À•W,ÌŽæ"¾
#--------------------------------------------------------------------------
def attack_y(z)
return (160 - (true_y + fly / 4) * z + @height * zoom * z / 2) * 0.75
end
#--------------------------------------------------------------------------
# œ 'M,«'Ò,¿ŽžŠÔ
#--------------------------------------------------------------------------
def flash_duration
return $scene.flash_duration
end
#--------------------------------------------------------------------------
# œ ƒAƒjƒ[ƒVƒ‡ƒ"Žæ"¾
#--------------------------------------------------------------------------
def battle_actions1
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.battle_actions : BattleActions::Actions["'ÊíUŒ,"]
end
#--------------------------------------------------------------------------
# œ ƒAƒjƒ[ƒVƒ‡ƒ"Žæ"¾
#--------------------------------------------------------------------------
def battle_actions2
weapon = $data_weapons[@weapon2_id]
return weapon != nil ? weapon.battle_actions : BattleActions::Actions["'ÊíUŒ,"]
end
#--------------------------------------------------------------------------
# œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ" "®,«•û Žæ"¾
#--------------------------------------------------------------------------
def extend_weapon_anime1
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.anime : 0
end
#--------------------------------------------------------------------------
# œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ" "®,«•û Žæ"¾
#--------------------------------------------------------------------------
def extend_weapon_anime2
weapon = $data_weapons[@weapon2_id]
return weapon != nil ? weapon.anime : 0
end
#--------------------------------------------------------------------------
# œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ"Žæ"¾
#--------------------------------------------------------------------------
def weapon_anime1
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.icon_name : ""
end
#--------------------------------------------------------------------------
# œ •ŠíƒAƒjƒ[ƒVƒ‡ƒ"Žæ"¾
#-----------------------------------------------