Sideview-Kampfsystem (Laufgrafik-Version)
RPG Maker XP (RGSS)Seitenansicht-Kampfsystem für den RPG Maker XP, das die normalen Laufgrafiken der Helden verwendet (Simple English Version, Ver. alpha 2007).
Im Forum war das Script auf zwei Beiträge verteilt – hier steht es am Stück.
#--------------------------------------------------------------------------
# ™Sideview battle simple English version
#
# (C) copyright by http://rye.jp/ Date 2007/01/12 Ver alpha
#--------------------------------------------------------------------------
# Side view battle script walking graphic version Special Thanks by blz
#--------------------------------------------------------------------------
#--------------------------------------------------------------------------
# Standard of graphic file
#--------------------------------------------------------------------------
# battler graphics
#
# @Walking graphic is used as it is.
# @
# weapon graphics
#
# @The icon graphic of arms is used as it is.
#
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 = 40 # 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",
"Hero Graphic Change#WALK_L",
"Play Sound Effect#016-Jump02,80,100",
"Hero Move#self,0,0,18,4",
"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",
"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",
"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",
"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",
"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",
"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 21 # Bronze Gun
return BattleActions::Actions["One step advancement Attack"]
end
return BattleActions::Actions["Normal Attack"] # default
end
end
class Skill
#--------------------------------------------------------------------------
# œ action performer
#--------------------------------------------------------------------------
def battle_actions
if self.magic?
return BattleActions::Actions["Spell Magic"] # default
else
return BattleActions::Actions["Using Skill"] # default
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
#--------------------------------------------------------------------------
# œ Throw Animation
#--------------------------------------------------------------------------
@ Animation is thrown out from performar 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
#--------------------------------------------------------------------------
# œ Throw Animation
#--------------------------------------------------------------------------
def flying_anime
# Example
#case @id
#when 34 # Boomerang
# return [10,32,true,true]
#when 17,18,19,20 # Arrow
# return [40,32,false,false]
#end
return [0,0,false,false] # No throw
end
end
class Skill
#--------------------------------------------------------------------------
# œ Throw Animation
#--------------------------------------------------------------------------
def flying_anime
# Example
#case @id
#when 34 # Boomerang
# return [10,32,true,true]
#when 17,18,19,20 # Arrow
# return [40,32,false,false]
#end
return [0,0,false,false] # No throw
end
end
class Item
#--------------------------------------------------------------------------
# œ Throw Animation
#--------------------------------------------------------------------------
def flying_anime
# Example
#case @id
#when 34 # Boomerang
# return [10,32,true,true]
#when 17,18,19,20 # 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
# Example
#case @id
#when 34 # Boomerang
# return [10,32,true,true]
#when 17,18,19,20 # Arrow
# return [40,32,false,false]
#end
return [0,0,false,false] # No throw
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 (ƒ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ƒ‡ƒ“Žæ“¾
#--------------------------------------------------------------------------
def weapon_anime2
weapon = $data_weapons[@weapon2_id]
return weapon != nil ? weapon.icon_name : ""
end
#--------------------------------------------------------------------------
# œ ‰“‹——£ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
#--------------------------------------------------------------------------
def flying_anime1
weapon = $data_weapons[@weapon_id]
return weapon != nil ? weapon.flying_anime : [0,0,false,false]
end
#--------------------------------------------------------------------------
# œ ‰“‹——£ƒAƒjƒ[ƒVƒ‡ƒ“Žæ“¾
#--------------------------------------------------------------------------
def flying_anime2
weapon = $data_weapons[@weapon2_id]
return weapon != nil ? weapon.flying_anime : [0,0,false,false]
end
#--------------------------------------------------------------------------
# œ ˆÚ“®–Ú•WÀ•W‚ÌŒvŽZ
#--------------------------------------------------------------------------
def move_setup
if RTAB
targets = @target
else
targets = $scene.target_battlers
end
case @move_action[0]
when "self" # Ž©•ª
@target_x = self.base_x
@target_y = self.base_y
when "target_near" # ˆê”Ô‹ß‚‚̃^[ƒQƒbƒg
targets.sort!{|a,b| a.screen_x<=>b.screen_x }
targets.reverse!
if targets != []
@target_x = targets[0].screen_x
@target_y = targets[0].screen_y
else
@target_x = self.base_x
@target_y = self.base_y
end
when "target_far" # ˆê”Ô‰“‚‚̃^[ƒQƒbƒg
targets.sort!{|a,b| a.screen_x<=>b.screen_x }
if targets != []
@target_x = targets[0].screen_x
@target_y = targets[0].screen_y
else
@target_x = self.base_x
@target_y = self.base_y
end
when "target" # ƒ^[ƒQƒbƒg’†‰›
@target_x = 0
@target_y = 0
for t in targets
@target_x += t.screen_x
@target_y += t.screen_y
end
if targets != []
@target_x /= targets.size
@target_y /= targets.size
end
when "troop" # "ƒgƒ‹[ƒv’†‰›"
@target_x = 0
@target_y = 0
for t in $game_troop.enemies
@target_x += t.screen_x
@target_y += t.screen_y
end
if $game_troop.enemies != []
@target_x /= $game_troop.enemies.size
@target_y /= $game_troop.enemies.size
end
when "party" # "ƒp[ƒeƒB’†‰›"
@target_x = 0
@target_y = 0
for t in $game_party.actors
@target_x += t.screen_x
@target_y += t.screen_y
end
if $game_party.actors != []
@target_x /= $game_party.actors.size
@target_y /= $game_party.actors.size
end
when "screen" # "‰æ–Ê"
@target_x = self.base_x
@target_y = self.base_y
end
# •â³
@target_x += @move_action[1] - self.base_x
@target_y += @move_action[2] - self.base_y
# ˆÚ“®–Ú•W‚ÌÀ•W‚ðƒZƒbƒg
@move_coordinates = [@target_x.to_i,@target_y.to_i,@move_coordinates[0],@move_coordinates[1]]
# ‹——£‚ÌŒvŽZ(ƒEƒGƒCƒg‚ÌÝ’è)
@move_wait = (@move_coordinates[2] - @move_coordinates[0]).abs +
(@move_coordinates[3] - @move_coordinates[1]).abs
end
end
#==============================================================================
# ¡ Game_Enemy
#==============================================================================
class Game_Enemy < Game_Battler
#--------------------------------------------------------------------------
# œ ƒZƒbƒgƒAƒbƒv
#--------------------------------------------------------------------------
alias side_view_initialize initialize
def initialize(troop_id, member_index)
side_view_initialize(troop_id, member_index)
start_battle
end
def character_name
return battler_name
end
def character_hue
return battler_hue
end
def reverse
return !@reverse
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
#--------------------------------------------------------------------------
# œ ˆÚ“®–Ú•WÀ•W‚ÌŒvŽZ
#--------------------------------------------------------------------------
def move_setup
if RTAB
targets = @target
else
targets = $scene.target_battlers
end
case @move_action[0]
when "self" # Ž©•ª
@target_x = self.base_x
@target_y = self.base_y
when "target_near" # ˆê”Ô‹ß‚‚̃^[ƒQƒbƒg
targets.sort!{|a,b| a.screen_x<=>b.screen_x }
if targets != []
@target_x = targets[0].screen_x
@target_y = targets[0].screen_y
else
@target_x = self.base_x
@target_y = self.base_y
end
when "target_far" # ˆê”Ô‰“‚‚̃^[ƒQƒbƒg
targets.sort!{|a,b| a.screen_x<=>b.screen_x }
targets.reverse!
if targets != []
@target_x = targets[0].screen_x
@target_y = targets[0].screen_y
else
@target_x = self.base_x
@target_y = self.base_y
end
when "target" # ƒ^[ƒQƒbƒg’†‰›
@target_x = 0
@target_y = 0
for t in targets
@target_x += t.screen_x
@target_y += t.screen_y
end
if targets != []
@target_x /= targets.size
@target_y /= targets.size
end
when "party" # "ƒgƒ‹[ƒv’†‰›"
@target_x = 0
@target_y = 0
for t in $game_troop.enemies
@target_x += t.screen_x
@target_y += t.screen_y
end
if $game_troop.enemies != []
@target_x /= $game_troop.enemies.size
@target_y /= $game_troop.enemies.size
end
when "troop" # "ƒp[ƒeƒB’†‰›"
@target_x = 0
@target_y = 0
for t in $game_party.actors
@target_x += t.screen_x
@target_y += t.screen_y
end
if $game_party.actors != []
@target_x /= $game_party.actors.size
@target_y /= $game_party.actors.size
end
when "screen" # "‰æ–Ê"
@target_x = self.base_x
@target_y = self.base_y
end
# •â³
@target_x -= @move_action[1] + self.base_x
@target_y -= @move_action[2] + self.base_y
# ˆÚ“®–Ú•W‚ÌÀ•W‚ðƒZƒbƒg
@move_coordinates = [@target_x.to_i,@target_y.to_i,@move_coordinates[0],@move_coordinates[1]]
# ‹——£‚ÌŒvŽZ(ƒEƒGƒCƒg‚ÌÝ’è)
@move_wait = (@move_coordinates[2] - @move_coordinates[0]).abs +
(@move_coordinates[3] - @move_coordinates[1]).abs
end
if RTAB
alias original_x true_x
alias original_y true_y
else
alias original_x screen_x
alias original_y screen_y
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
#--------------------------------------------------------------------------
def true_x
return original_x + @ox
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾(ƒJƒƒ‰•â³–³‚µ)
#--------------------------------------------------------------------------
def true_y
return original_y - @height / 2 + @oy
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ–Ê X À•W‚̎擾
#--------------------------------------------------------------------------
def screen_x(true_x = self.true_x)
return true_x * @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ƒ‹‰æ–Ê X À•W‚̎擾(ˆÚ“®‚È‚Ç‚µ‚Ä‚¢‚È‚¢ê‡)
#--------------------------------------------------------------------------
def base_x(true_x = self.true_x)
return (true_x - @ox) * @real_zoom + @real_x
end
#--------------------------------------------------------------------------
# œ ƒoƒgƒ‹‰æ–Ê Y À•W‚̎擾(ˆÚ“®‚È‚Ç‚µ‚Ä‚¢‚È‚¢ê‡)
#--------------------------------------------------------------------------
def base_y(true_y = self.true_y)
return (true_y - @oy) * @real_zoom + @real_y
end
end
#==============================================================================
# ¡ Game_Party
#==============================================================================
class Game_Party
#--------------------------------------------------------------------------
# œ ƒAƒNƒ^[‚ð‰Á‚¦‚é
# actor_id : ƒAƒNƒ^[ ID
#--------------------------------------------------------------------------
alias side_view_add_actor add_actor
def add_actor(actor_id)
# ƒAƒNƒ^[‚ðŽæ“¾
actor = $game_actors[actor_id]
# ƒTƒCƒhƒrƒ…[ƒf[ƒ^‚̉Šú‰»
actor.start_battle
# –ß‚·
side_view_add_actor(actor_id)
end
end
#==============================================================================
# ¡ Scene_Battle
#==============================================================================
class Scene_Battle
include Side_view
#--------------------------------------------------------------------------
# œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
#--------------------------------------------------------------------------
attr_reader :phase # ƒtƒF[ƒY
attr_reader :phase4_step # ƒtƒF[ƒY‚SƒXƒeƒbƒv
attr_reader :active_battler # ‘ÎÛ‚Ì”z—ñ
attr_reader :target_battlers # ‘ÎÛ‚Ì”z—ñ
attr_reader :animation1_id # s“®ƒAƒjƒID
attr_reader :animation2_id # ‘ÎÛƒAƒjƒID
#--------------------------------------------------------------------------
# œ ƒƒCƒ“ˆ—
#--------------------------------------------------------------------------
alias side_view_main main
def main
# ƒoƒgƒ‰[‰Šú‰»
for battler in $game_party.actors + $game_troop.enemies
battler.start_battle
end
# –ß‚·
side_view_main
end
#--------------------------------------------------------------------------
# œ ‘M‚«”»’è
#--------------------------------------------------------------------------
def flash?
return @flash_flag ? true : false
end
#--------------------------------------------------------------------------
# œ ‘M‚«ƒAƒjƒ‘Ò‚¿ŽžŠÔŽæ“¾
#--------------------------------------------------------------------------
def flash_duration
animation = nil
if FLASH_ANIME
animation = $data_animations[FLASH_ANIMATION_ID]
end
return animation != nil ? animation.frame_max * 2 + 2 : 0
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 2 : ƒAƒNƒVƒ‡ƒ“ŠJŽn)
#--------------------------------------------------------------------------
alias side_view_update_phase4_step2 update_phase4_step2
def update_phase4_step2(*arg)
battler = convert_battler2(*arg)
battler.action
side_view_update_phase4_step2(*arg)
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 3 : s“®‘¤ƒAƒjƒ[ƒVƒ‡ƒ“)
#--------------------------------------------------------------------------
alias side_view_update_phase4_step3 update_phase4_step3
def update_phase4_step3(*arg)
battler = convert_battler2(*arg)
return if !battler.animation1_on and battler.action? and !battler.flash?
if battler.flash? and FLASH_ANIME
battler.flash_flag["normal"] = true
end
side_view_update_phase4_step3(*arg)
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒƒCƒ“ƒtƒF[ƒY ƒXƒeƒbƒv 4 : ‘ÎÛ‘¤ƒAƒjƒ[ƒVƒ‡ƒ“)
#--------------------------------------------------------------------------
alias side_view_update_phase4_step4 update_phase4_step4
def update_phase4_step4(*arg)
battler = convert_battler2(*arg)
targets = RTAB ? battler.target : @target_battlers
return if !battler.animation2_on and battler.action?
side_view_update_phase4_step4(*arg)
for target in targets
if RTAB
value = nil
if target.damage_sp.include?(battler)
value = target.damage_sp[battler]
end
if target.damage.include?(battler)
if value == nil or value == "Miss"
value = target.damage[battler]
elsif value.is_a?(Numeric) && value > 0
value = target.damage[battler] == "Miss" ? value : target.damage[battler]
end
end
else
value = target.damage
end
if target.is_a?(Game_Actor)
# ƒ_ƒ[ƒW‚Ìê‡
if value.is_a?(Numeric) && value > 0
# ƒVƒFƒCƒN‚ðŠJŽn
target.shake = true
end
elsif target.is_a?(Game_Enemy)
# ƒ_ƒ[ƒW‚Ìê‡
if value.is_a?(Numeric) && value > 0
# ƒVƒFƒCƒN‚ðŠJŽn
target.shake = true
end
end
end
end
#--------------------------------------------------------------------------
# œ ƒvƒŒƒoƒgƒ‹ƒtƒF[ƒYŠJŽn
#--------------------------------------------------------------------------
alias start_phase1_correct start_phase1
def start_phase1
# ƒJƒƒ‰‚ÌÝ’è
# Œ³Xƒtƒƒ“ƒgƒrƒ…[Œü‚¯‚Ì”’l‚É‚È‚Á‚Ä‚¢‚邽‚ß
@zoom_rate = [1.0, 1.0]
start_phase1_correct
end
#--------------------------------------------------------------------------
# œ ƒAƒNƒ^[ƒRƒ}ƒ“ƒhƒtƒF[ƒYŠJŽn
#--------------------------------------------------------------------------
alias start_phase3_correct start_phase3
def start_phase3
battler = convert_battler
start_phase3_correct
if RTAB
# ƒJƒƒ‰‚ÌÝ’è
# Œ³Xƒtƒƒ“ƒgƒrƒ…[Œü‚¯‚Ì”’l‚É‚È‚Á‚Ä‚¢‚邽‚ß
@camera = "command"
@spriteset.screen_target(0, 0, 1.0)
end
end
end
class Spriteset_Battle
include Side_view
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
#--------------------------------------------------------------------------
alias side_veiw_initialize initialize
def initialize
side_veiw_initialize
# ƒAƒNƒ^[ƒXƒvƒ‰ƒCƒg‚ð‰ð•ú
for sprite in @actor_sprites
sprite.dispose
end
# ƒAƒNƒ^[ƒXƒvƒ‰ƒCƒg‚ðì¬
@actor_sprites = []
for i in 1..Party_max
@actor_sprites.push(Sprite_Battler.new(@viewport1))
end
update
end
#--------------------------------------------------------------------------
# œ ‰æ–ʂ̃XƒNƒ[ƒ‹
#--------------------------------------------------------------------------
if method_defined?("screen_scroll")
alias side_view_screen_scroll screen_scroll
def screen_scroll
side_view_screen_scroll
# ƒAƒNƒ^[‚̈ʒu•â³
for actor in $game_party.actors
actor.real_x = @real_x
actor.real_y = @real_y
actor.real_zoom = @real_zoom
end
end
end
end
class Sprite_Battler < RPG::Sprite
include Side_view
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
# viewport : ƒrƒ…[ƒ|[ƒg
# battler : ƒoƒgƒ‰[ (Game_Battler)
#--------------------------------------------------------------------------
def initialize(viewport, battler = nil)
super(viewport)
@battler = battler
@battler_visible = false
@weapon = Sprite_Weapon.new(viewport, battler)
@flying = Sprite_Flying.new(viewport, battler)
@shadow = []
@fly = 0
@fly_direction = 1
@rand = rand(10)
@bitmaps = {}
self.effect_clear
end
#--------------------------------------------------------------------------
# œ ‰ð•ú
#--------------------------------------------------------------------------
alias side_view_dispose dispose
def dispose
side_view_dispose
@weapon.dispose if @weapon != nil
@flying.dispose if @flying != nil
if @_target_sprite != nil
@_target_sprite.bitmap.dispose
@_target_sprite.dispose
@_target_sprite = nil
end
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV
#--------------------------------------------------------------------------
def update
super
# ƒoƒgƒ‰[‚ª nil ‚Ìê‡
if @battler == nil
self.bitmap = nil
@weapon.bitmap = nil
loop_animation(nil)
return
end
# ƒoƒgƒ‰[XV
@battler.update
# ƒoƒgƒ‰[ƒAƒjƒ‚̃f[ƒ^Žæ“¾
@anime_type = @battler.anime_type
# bitmap ‚ðƒLƒƒƒbƒVƒ…‰»
path = @anime_type[0].to_s + "#" + @battler.pattern.to_s
if not @bitmaps.include?(path) or @bitmaps[path].disposed?
# ƒtƒ@ƒCƒ‹–¼‚©F‘Š‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
change = (@battler.character_name != @battler_name or @battler.character_hue != @battler_hue)
if change
# ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
@battler_name = @battler.character_name
@battler_hue = @battler.character_hue
@bitmap = RPG::Cache.character(@battler_name, @battler_hue)
@width = @bitmap.width / 4
@height = @bitmap.height / 4
self.ox = @width / 2
self.oy = @height / 2
@battler.height = @height
@flag = true
# 퓬•s”\‚Ü‚½‚͉B‚êó‘Ô‚È‚ç•s“§–¾“x‚ð 0 ‚É‚·‚é
if @battler.dead? or @battler.hidden
self.opacity = 0
end
end
if (@anime_type[0] != @battler_condition or
@battler.pattern != @battler_pattern or flag)
# ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
@battler_condition = @anime_type[0]
@battler_pattern = @battler.pattern
@sx = @battler.pattern * @width
@sy = @anime_type[0] % 4 * @height
self.bitmap = Bitmap.new(@width,@height)
self.bitmap.blt(0,0, @bitmap,Rect.new(@sx, @sy, @width, @height))
@bitmaps[path] = self.bitmap
flag = false
end
end
self.bitmap = @bitmaps[path]
# ”òs
update_fly
# ƒVƒFƒCƒN
update_shake
# ‰ñ“]
update_turning
# ”½“]
update_reverse
# ˆÚ“®
update_moving
# ’ljÁƒAƒjƒ
update_add_anime
# ƒGƒtƒFƒNƒgŒø‰Ê‚Ì“K—p
update_effect
# ƒAƒjƒ[ƒVƒ‡ƒ“ ID ‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
flag = RTAB ? true : @battler.damage == nil
if flag and @battler.state_animation_id != @state_animation_id
@state_animation_id = @battler.state_animation_id
loop_animation($data_animations[@state_animation_id])
end
# ƒVƒFƒCƒN
if @battler.shake
self.start_shake(5, 5, 5)
@battler.shake = false
end
# –¾–Å
if @battler.blink
blink_on
else
blink_off
end
# •s‰ÂŽ‹‚Ìê‡
unless @battler_visible
flag = RTAB ? (@battler.damage.size < 2 or @battler.damage_pop.size < 2) :
(@battler.damage == nil or @battler.damage_pop)
# oŒ»
if not @battler.hidden and not @battler.dead? and flag
appear
@battler_visible = true
end
end
if RTAB
# ƒ_ƒ[ƒW
for battler in @battler.damage_pop
if battler[0].class == Array
if battler[0][1] >= 0
$scene.skill_se
else
$scene.levelup_se
end
damage(@battler.damage[battler[0]], false, 2)
else
damage(@battler.damage[battler[0]], @battler.critical[battler[0]])
end
if @battler.damage_sp.include?(battler[0])
damage(@battler.damage_sp[battler[0]],
@battler.critical[battler[0]], 1)
@battler.damage_sp.delete(battler[0])
end
@battler.damage_pop.delete(battler[0])
@battler.damage.delete(battler[0])
@battler.critical.delete(battler[0])
end
end
# ‰ÂŽ‹‚Ìê‡
if @battler_visible
# “¦‘–
if @battler.hidden
$game_system.se_play($data_system.escape_se)
escape
@battler_visible = false
end
# ”’ƒtƒ‰ƒbƒVƒ…
if @battler.white_flash
whiten
@battler.white_flash = false
end
if RTAB
# ƒAƒjƒ[ƒVƒ‡ƒ“
if !@battler.animation.empty?
for animation in @battler.animation.reverse
if animation[2]
animation($data_animations[animation[0]], animation[1], true)
else
animation($data_animations[animation[0]], animation[1])
end
@battler.animation.delete(animation)
end
end
else
# ƒAƒjƒ[ƒVƒ‡ƒ“
if @battler.animation_id != 0
animation = $data_animations[@battler.animation_id]
animation(animation, @battler.animation_hit)
@battler.animation_id = 0
end
end
# ƒ_ƒ[ƒW
if !RTAB and @battler.damage_pop
damage(@battler.damage, @battler.critical)
@battler.damage = nil
@battler.critical = false
@battler.damage_pop = false
end
flag = RTAB ? (@battler.damage.empty? and $scene.dead_ok?(@battler)) :
@battler.damage == nil
# ƒRƒ‰ƒvƒX
if flag and @battler.dead?
if @battler.is_a?(Game_Actor)
$game_system.se_play($data_system.actor_collapse_se)
elsif @battler.is_a?(Game_Enemy)
$game_system.se_play($data_system.enemy_collapse_se)
end
collapse
@battler_visible = false
end
end
# ƒXƒvƒ‰ƒCƒg‚ÌÀ•W‚ðÝ’è
self.x = @battler.screen_x + @effect_ox
self.y = @battler.screen_y + @effect_oy
self.z = @battler.screen_z
self.zoom_x = @battler.real_zoom
self.zoom_y = @battler.real_zoom
# ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ðŒ¸‚ç‚·
@battler.wait_count -= 1
@battler.wait_count2 -= 1
# ƒAƒjƒ[ƒVƒ‡ƒ“‘Ò‚¿ŽžŠÔŽæ“¾
@battler.animation_duration = @_animation_duration
if @battler.is_a?(Game_Actor)
self.zoom_x *= CHAR_ZOOM
self.zoom_y *= CHAR_ZOOM
end
# ‰“‹——£ƒAƒjƒ
if @battler.flying_anime != [0,0,false,false] and @flying.nil?
@flying = Sprite_Flying.new(self.viewport, @battler)
elsif @battler.flying_anime == [0,0,false,false] and !@flying.nil?
@flying.dispose
@flying = nil
end
if @flying != nil
@flying.battler = @battler
@flying.update
end
if @battler.is_a?(Game_Actor)
# •ŠíƒAƒjƒ
if @battler.weapon_anime_type1 and @weapon.nil?
@weapon = Sprite_Weapon.new(self.viewport, @battler)
elsif !@battler.weapon_anime_type1 and !@weapon.nil?
@weapon.dispose
@weapon = nil
end
if @weapon != nil
@weapon.battler = @battler
@weapon.update
@weapon.opacity = self.opacity
@weapon.x = self.x + BLZ_X[@battler.weapon_anime_type3][@battler.pattern]
@weapon.y = self.y + BLZ_Y[@battler.weapon_anime_type3][@battler.pattern]
@weapon.angle = BLZ_ANGLE[@battler.weapon_anime_type3][@battler.pattern]
if self.mirror
@weapon.angle += @weapon.angle - 180
end
end
end
# Žc‘œ
if @battler.shadow
if Graphics.frame_count % 2 == 0
shadow = ::Sprite.new(self.viewport)
shadow.bitmap = self.bitmap.dup
shadow.x = self.x
shadow.y = self.y
shadow.ox = self.ox
shadow.oy = self.oy
shadow.mirror = self.mirror
shadow.angle = self.angle
shadow.opacity = 160
shadow.zoom_x = self.zoom_x
shadow.zoom_y = self.zoom_y
if @battler.is_a?(Game_Actor)
shadow.src_rect.set(@sx, @sy, @width, @height)
else
shadow.src_rect.set(0, 0, @width, @height)
end
@shadow.push([shadow,duration = 10,@battler.true_x + @effect_ox,@battler.true_y + @effect_oy])
end
end
for s in @shadow
if !s[0].disposed?
s[0].update
s[1] -= 1
if s[1] < 1
if s[0].bitmap != nil
s[0].bitmap.dispose
end
s[0].dispose
else
s[0].x = @battler.screen_x(s[2])
s[0].y = @battler.screen_y(s[3])
end
else
s = nil
end
end
@shadow.compact!
end
#--------------------------------------------------------------------------
# œ ƒGƒtƒFƒNƒg‚É‚æ‚éÀ•WŒn‚ÌXV
#--------------------------------------------------------------------------
def update_effect
# Šp“x‚ÌC³
if @_upside_down
self.angle = (@_turning + 180) % 360
else
self.angle = @_turning
end
# X À•W‚ÌC³’l
@effect_ox = @_shake + @_moving[0]
# Y À•W‚ÌC³’l
@effect_oy = -@fly + @_moving[1]
if @_animation == nil or (RTAB and @_animation.empty?)
self.effect_clear
end
end
#--------------------------------------------------------------------------
# œ ƒVƒFƒCƒNXV
#--------------------------------------------------------------------------
def update_shake
if @_shake_duration >= 1 or @_shake != 0
delta = (@_shake_power * @_shake_speed * @_shake_direction) / 10.0
if @_shake_duration <= 1 and @_shake * (@_shake + delta) < 0
@_shake = 0
else
@_shake += delta
end
if @_shake > @_shake_power * 2
@_shake_direction = -1
end
if @_shake < - @_shake_power * 2
@_shake_direction = 1
end
if @_shake_duration >= 1
@_shake_duration -= 1
end
end
end
#--------------------------------------------------------------------------
# œ ”òsXV
#--------------------------------------------------------------------------
def update_fly
if @rand > 0
@rand -= 1
return
end
if @battler.fly != 0
if @fly < @battler.fly / 4
@fly_direction = 1
elsif @fly > @battler.fly / 2
@fly_direction = -1
end
@fly += 0.5 * @fly_direction
end
end
#--------------------------------------------------------------------------
# œ ‰ñ“]XV
#--------------------------------------------------------------------------
def update_turning
if @_turning_duration > 0 or @_turning != 0
@_turning += @_turning_direction * @_turning_speed / 2.0
# Žc‚è‰ñ“]”‚ðŒ¸‚ç‚·
if @_turning_direction == -1
if @_turning_duration > 0 and @_turning < 0
@_turning_duration -= 1
end
elsif @_turning_direction == 1
if @_turning_duration > 0 and @_turning >= 360
@_turning_duration -= 1
end
end
# ˆÈ‰º•â³
while @_turning < 0
@_turning += 360
end
if @_turning_duration <= 0
@_turning = 0
end
@_turning %= 360
end
end
#--------------------------------------------------------------------------
# œ ¶‰E”½“]XV
#--------------------------------------------------------------------------
def update_reverse
if @last_reverse != (@_reverse or @battler.reverse)
self.mirror = (@_reverse or @battler.reverse)
@last_reverse = (@_reverse or @battler.reverse)
end
end
#--------------------------------------------------------------------------
# œ ˆÚ“®XV
#--------------------------------------------------------------------------
def update_moving
@move_distance = (@_move_coordinates[2] - @_move_coordinates[0]).abs +
(@_move_coordinates[3] - @_move_coordinates[1]).abs
if @move_distance > 0
return if @_moving[0] == @_move_coordinates[0] and @_moving[1] == @_move_coordinates[1]
array = @_move_coordinates
x = (array[2] + 1.0 * (array[0] - array[2]) * (@move_distance - @_move_duration) / @move_distance.to_f).to_i
y = (array[3] + 1.0 * (array[1] - array[3]) * (@move_distance - @_move_duration) / @move_distance.to_f).to_i
@_moving = [x, y]
if @_move_quick_return and @_move_duration == 0
@_move_coordinates = [0,0,array[0],array[1]]
@_move_duration = @move_distance
end
@_move_duration -= @_move_speed
@_move_duration = [@_move_duration, 0].max
end
end
#--------------------------------------------------------------------------
# œ ’ljÁƒAƒjƒXV (RTABŒÀ’è‹@”\)
#--------------------------------------------------------------------------
def update_add_anime
if RTAB
# ƒAƒjƒ[ƒVƒ‡ƒ“
if @_add_anime_id != 0
animation = $data_animations[@_add_anime_id]
animation(animation, true)
@_add_anime_id = 0
end
end
end
#--------------------------------------------------------------------------
# œ ƒGƒtƒFƒNƒg‰Šú‰»
#--------------------------------------------------------------------------
def effect_clear
@_effect_ox = 0
@_effect_oy = 0
@_shake_power = 0
@_shake_speed = 0
@_shake_duration = 0
@_shake_direction = 1
@_shake = 0
@_upside_down = false
@_reverse = false
@_turning_direction = 1
@_turning_speed = 0
@_turning_duration = 0
@_turning = 0
@_move_quick_return = true
@_move_speed = 0
@_move_coordinates = [0,0,0,0]
@_move_jump = false
@_move_duration = 0
@_moving = [0,0]
@_add_anime_id = 0
end
#--------------------------------------------------------------------------
# œ ƒVƒFƒCƒN‚ÌŠJŽn
# power : ‹‚³
# speed : ‘¬‚³
# duration : ŽžŠÔ
#--------------------------------------------------------------------------
def start_shake(power, speed, duration)
@_shake_power = power
@_shake_speed = speed
@_shake_duration = duration
end
#--------------------------------------------------------------------------
# œ ㉺”½“]‚ðŠJŽn
#--------------------------------------------------------------------------
def start_upside_down
@_upside_down = @_upside_down ? false : true
end
#--------------------------------------------------------------------------
# œ ¶‰E”½“]‚ðŠJŽn
#--------------------------------------------------------------------------
def start_reverse
@_reverse = @_reverse ? false : true
end
#--------------------------------------------------------------------------
# œ ‰ñ“]‚ðŠJŽn
# direction: •ûŒü
# speed : ‘¬‚³
# duration : ŽžŠÔ
#--------------------------------------------------------------------------
def start_turning(direction, speed, duration)
@_turning_direction = direction
@_turning_speed = speed
@_turning_duration = duration
@_turning = @_turning_direction == 1 ? 0 : 360
end
#--------------------------------------------------------------------------
# œ ˆÚ“®‚ðŠJŽn
# quick_return : –ß‚é‚©‚Ç‚¤‚©
# speed : ‘¬‚³
# x : X À•W
# y : Y À•W
#--------------------------------------------------------------------------
def start_moving(quick_return, speed, x, y)
@_move_quick_return = quick_return == 0 ? false : true
@_move_speed = speed
@_move_coordinates = [x,y,@_move_coordinates[0],@_move_coordinates[1]]
distance = (@_move_coordinates[2] - @_move_coordinates[0]).abs +
(@_move_coordinates[3] - @_move_coordinates[1]).abs
@_move_duration = distance
end
#--------------------------------------------------------------------------
# œ ƒAƒjƒ’ljÁ‚ðŠJŽn
# id : ID
# hit : –½’†ƒtƒ‰ƒbƒO
#--------------------------------------------------------------------------
def start_add_anime(id)
@_add_anime_id = id
end
#--------------------------------------------------------------------------
# œ ŠeŽíƒGƒtƒFƒNƒg‚ÌŠJŽn”»’è
#--------------------------------------------------------------------------
if !method_defined?("side_view_animation_process_timing")
alias side_view_animation_process_timing animation_process_timing
end
def animation_process_timing(timing, hit)
side_view_animation_process_timing(timing, hit)
if (timing.condition == 0) or
(timing.condition == 1 and hit == true) or
(timing.condition == 2 and hit == false)
if timing.se.name =~ SHAKE_FILE
names = timing.se.name.split(/#/)
power = names[1].nil? ? SHAKE_POWER : names[1].to_i
speed = names[2].nil? ? SHAKE_SPEED : names[2].to_i
duration = names[3].nil? ? SHAKE_DURATION : names[3].to_i
# ƒVƒFƒCƒN‚ðŠJŽn
self.start_shake(power, speed, duration)
end
if timing.se.name == UPSIDE_DOWN_FILE
# ㉺”½“]‚ðŠJŽn
self.start_upside_down
end
if timing.se.name == REVERSE_FILE
# ¶‰E”½“]‚ðŠJŽn
self.start_reverse
end
if timing.se.name =~ TURNING_FILE
names = timing.se.name.split(/#/)
direction = names[1].nil? ? TURNING_DIRECTION : names[1].to_i
speed = names[2].nil? ? TURNING_SPEED : names[2].to_i
duration = names[3].nil? ? TURNING_DURATION : names[3].to_i
# ‰ñ“]‚ðŠJŽn
self.start_turning(direction, speed, duration)
end
if timing.se.name =~ MOVE_FILE
names = timing.se.name.split(/#/)
quick_return= names[1].nil? ? MOVE_RETURN : names[1].to_i
speed = names[2].nil? ? MOVE_SPEED : names[2].to_i
x = names[3].nil? ? MOVE_COORDINATES[0] : names[3].to_i
y = names[3].nil? ? MOVE_COORDINATES[1] : names[4].to_i
# ˆÚ“®‚ðŠJŽn
self.start_moving(quick_return, speed, x, y)
end
if timing.se.name =~ ADD_ANIME_FILE
names = timing.se.name.split(/#/)
id = names[1].nil? ? ADD_ANIME_ID : names[1].to_i
# ƒAƒjƒ’ljÁ‚ðŠJŽn
self.start_add_anime(id)
end
end
end
end
#==============================================================================
# ¡ Sprite_Weapon
#------------------------------------------------------------------------------
# @ƒoƒgƒ‰[•\Ž¦—p‚̃Xƒvƒ‰ƒCƒg‚Å‚·BGame_Battler ƒNƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚ðŠÄŽ‹‚µA
# ƒXƒvƒ‰ƒCƒg‚Ìó‘Ô‚ðŽ©“®“I‚ɕω»‚³‚¹‚Ü‚·B
#==============================================================================
class Sprite_Weapon < ::Sprite
include Side_view
#--------------------------------------------------------------------------
# œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
#--------------------------------------------------------------------------
attr_accessor :battler # ƒoƒgƒ‰[
attr_reader :cw # ƒOƒ‰ƒtƒBƒbƒN‚Ì•
attr_reader :ch # ƒOƒ‰ƒtƒBƒbƒN‚Ì‚‚³
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
# viewport : ƒrƒ…[ƒ|[ƒg
# battler : ƒoƒgƒ‰[ (Game_Battler)
#--------------------------------------------------------------------------
def initialize(viewport, battler = nil)
super(viewport)
@battler = battler
@battler_visible = false
end
#--------------------------------------------------------------------------
# œ ‰ð•ú
#--------------------------------------------------------------------------
def dispose
if self.bitmap != nil
self.bitmap.dispose
end
super
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV
#--------------------------------------------------------------------------
def update
super
# ƒoƒgƒ‰[‚ª nil ‚Ìê‡
if @battler == nil or !@battler.is_a?(Game_Actor)
self.bitmap = nil
return
end
# ƒEƒGƒ|ƒ“ƒAƒjƒ‚̃f[ƒ^Žæ“¾
@weapon_anime_type = @battler.weapon_anime_type
# ݒ肪u”ñ•\Ž¦v‚Ìê‡
if !@weapon_anime_type[1] or @weapon_anime_type[0].nil?
self.visible = false
return
else
self.visible = true
end
# ƒtƒ@ƒCƒ‹–¼‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
if @weapon_anime_type[0] != @weapon_name
@weapon_name = @weapon_anime_type[0]
# ƒrƒbƒgƒ}ƒbƒv‚ðŽæ“¾AÝ’è
self.bitmap = RPG::Cache.icon(@weapon_name)
@width = bitmap.width
@height = bitmap.height
@flag = true
end
# Œ»ÝƒAƒjƒƒpƒ^[ƒ“‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
if @pattern != @battler.pattern or @flag or @condition != @battler.condition
@pattern = @battler.pattern
@condition = @battler.condition
self.ox = @width
self.oy = @height
self.z = battler.screen_z
self.zoom_x = @battler.real_zoom * CHAR_ZOOM
self.zoom_y = @battler.real_zoom * CHAR_ZOOM
self.src_rect.set(0, 0, @width, @height)
self.opacity = 255
# ƒoƒgƒ‰[‚æ‚èŽè‘O‚É•\Ž¦
if @weapon_anime_type[2]
self.z += 10
# ƒoƒgƒ‰[‚æ‚艜‚É•\Ž¦
else
self.z -= 10
end
@flag = false
end
end
end
#==============================================================================
# ¡ Sprite_Flying
#------------------------------------------------------------------------------
# @ƒoƒgƒ‰[•\Ž¦—p‚̃Xƒvƒ‰ƒCƒg‚Å‚·BGame_Battler ƒNƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚ðŠÄŽ‹‚µA
# ƒXƒvƒ‰ƒCƒg‚Ìó‘Ô‚ðŽ©“®“I‚ɕω»‚³‚¹‚Ü‚·B
#==============================================================================
class Sprite_Flying < RPG::Sprite
include Side_view
LATE_COUNT = 20
#--------------------------------------------------------------------------
# œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
#--------------------------------------------------------------------------
attr_accessor :battler # ƒoƒgƒ‰[
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
# viewport : ƒrƒ…[ƒ|[ƒg
# battler : ƒoƒgƒ‰[ (Game_Battler)
#--------------------------------------------------------------------------
def initialize(viewport, battler = nil)
super(viewport)
@battler = battler
@battler_visible = false
@later = LATE_COUNT
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV
#--------------------------------------------------------------------------
def update
super
# ƒoƒgƒ‰[‚ª nil ‚Ìê‡
if @battler == nil
self.bitmap = nil
loop_animation(nil)
return
end
# ‰“‹——£ƒAƒjƒ
flying_animation = @battler.flying_animation
flying_start = flying_animation[0]
flying_end = flying_animation[1]
# ƒAƒjƒ[ƒVƒ‡ƒ“ ID ‚ªŒ»Ý‚Ì‚à‚̂ƈقȂéê‡
if @anime_id != @battler.flying_anime[0]
@anime_id = @battler.flying_anime[0]
@animation = $data_animations[@anime_id]
end
# ƒAƒjƒ[ƒVƒ‡ƒ“ ŠJŽn
if flying_start
animation(@animation,true)
elsif flying_end
# Á‹Ž‚ð’x‚点‚Ä‚Ý‚½‚è‚·‚é
@later -= 1
if @later < 0
animation(nil, true)
@later = LATE_COUNT
end
end
self.x = @battler.flying_x
self.y = @battler.flying_y
self.z = @battler.screen_z + 1000
end
end
module RPG
class Skill
#--------------------------------------------------------------------------
# œ –‚–@‚©‚Ç‚¤‚©‚Ì”»’f
#--------------------------------------------------------------------------
def magic?
if @atk_f == 0
return true
else
return false
end
end
end
end
# ƒAƒ[ƒJ[ƒ\ƒ‹‚̈ʒuC³
class Arrow_Actor < Arrow_Base
include Side_view
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV
#--------------------------------------------------------------------------
alias side_view_update update
def update
side_view_update
# ƒXƒvƒ‰ƒCƒg‚ÌÀ•W‚ðÝ’è
if self.actor != nil && (self.x != self.actor.screen_x + ARROW_OX or self.y != self.actor.screen_y + ARROW_OY)
self.x = self.actor.screen_x + ARROW_OX
self.y = self.actor.screen_y + ARROW_OY
end
end
end
class Arrow_Enemy < Arrow_Base
include Side_view
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV
#--------------------------------------------------------------------------
alias side_view_update update
def update
side_view_update
# ƒXƒvƒ‰ƒCƒg‚ÌÀ•W‚ðÝ’è
if self.enemy != nil && (self.x != self.enemy.screen_x + ARROW_OX or self.y != self.enemy.screen_y + ARROW_OY)
self.x = self.enemy.screen_x + ARROW_OX
self.y = self.enemy.screen_y + ARROW_OY
end
end
endIm Forum
- Schickes sideview KS RPG XP · Yamon1907 · 02.08.2008
- Schickes sideview KS RPG XP · Yamon1907 · 02.08.2008