#==============================================================================
# ¡ Game_Player
#------------------------------------------------------------------------------
# @ƒvƒŒƒCƒ„[‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·BƒCƒxƒ“ƒg‚Ì‹N“®”»’è‚âAƒ}ƒbƒv‚̃XƒNƒ[ƒ‹‚È‚Ç‚Ì
# ‹@”\‚ðŽ‚Á‚Ä‚¢‚Ü‚·B‚±‚̃Nƒ‰ƒX‚̃Cƒ“ƒXƒ^ƒ“ƒX‚Í $game_player ‚ÅŽQÆ‚³‚ê‚Ü‚·B
#==============================================================================

class Game_Player < Game_Character
#--------------------------------------------------------------------------
# œ ’萔
#--------------------------------------------------------------------------
UP = 0 # ã•ûŒü‚Ì—]—T(0 <= UP <= 63)
SIDE = 0 # ¶‰E•ûŒü‚Ì—]—T(0 <= SIDE <= 63)
SLANT = false # ˆÚ“®ƒ‹[ƒg‚̎΂߈ړ®ŽžA‘¬“xC³
#--------------------------------------------------------------------------
# œ ŒöŠJƒCƒ“ƒXƒ^ƒ“ƒX•Ï”
#--------------------------------------------------------------------------
attr_reader :walk # ƒvƒŒ[ƒ„[ˆÚ“®‘¬“x
attr_reader :event # ƒCƒxƒ“ƒgŽžˆÚ“®‘¬“x
attr_accessor :move_speed # ˆÚ“®‘¬“x
#--------------------------------------------------------------------------
# œ ƒIƒuƒWƒFƒNƒg‰Šú‰»
#--------------------------------------------------------------------------
def initialize
super
# @walk:•às‘¬“x @dash:ƒ_ƒbƒVƒ…ŽžˆÚ“®‘¬“x
# @event:ƒCƒxƒ“ƒgŽžˆÚ“®‘¬“xi0‚ÌŽž‚́AƒCƒxƒ“ƒgŽž‚É‘¬“x•ÏX‚ð‚µ‚È‚¢j
@walk = 4
@dash = 5
@event = 4
@dot_m = true
@revise_x = 0
@revise_y = 0
@move == false
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV
#--------------------------------------------------------------------------
alias :update_original :update
def update
#ƒ_ƒbƒVƒ…‹@”\BƒGƒ“ƒ^[ƒL[‚ª‰Ÿ‚³‚ê‚Ä‚¢‚éŠÔAˆÚ“®‘¬“x‚ð•ÏX‚·‚éB
unless moving? or $game_system.map_interpreter.running? or
@move_route_forcing or $game_temp.message_window_showing
if @walk != @dash
if Input.press?(Input::C)
if @move_speed != @dash
@move_speed = @dash
end
else
if @move_speed != @walk
@move_speed = @walk
end
end
end
end
if @revise_x == nil and @revise_y == nil
@revise_x = 0
@revise_y = 0
end
unless @dot_m
update_original
return
end
if @move_route_forcing
# ƒ[ƒJƒ‹•Ï”‚Ɉړ®’†‚©‚Ç‚¤‚©‚ð‹L‰¯
last_moving = moving?
# ƒ[ƒJƒ‹•Ï”‚ɍÀ•W‚ð‹L‰¯
last_real_x = @real_x
last_real_y = @real_y
# À•W‚ª‚¸‚ê‚Ä‚¢‚éê‡
if (@revise_x != 0 or @revise_y != 0) and not jumping? and @move == true
if @revise_x != @real_x - @x * 128 or @revise_y != @real_y - @y * 128
@revise_x = @real_x - @x * 128
@revise_y = @real_y - @y * 128
end
# ˆÚ“®‹——£distance1‚Æ–Ú•W‹——£distance2‚ðÝ’è
distance1 = 2 ** @move_speed
distance2 = Math.sqrt(@revise_x ** 2 + @revise_y ** 2)
# ˆÚ“®‹——£‚ª–Ú•W‹——£‚ð‰z‚¦‚½ê‡
if distance1 > distance2
# ‹­§“I‚ɕ␳À•W‚ð—ë‚É‚·‚é
@real_x = @real_x - @revise_x
@real_y = @real_y - @revise_y
@revise_x = 0
@revise_y = 0
anime_update
# ˆÚ“®‹——£‚ª–Ú•W‹——£‚É’B‚µ‚È‚¢ê‡
else
# ˆÚ“®‹——£•ª–Ú•W‹——£‚ɋ߂­
@real_x -= (distance1 * @revise_x / distance2).round
@real_y -= (distance1 * @revise_y / distance2).round
@revise_x = @real_x - @x * 128
@revise_y = @real_y - @y * 128
anime_update
end
else
super
end
else
@move = false
# ˆÚ“®’†AƒCƒxƒ“ƒgŽÀs’†AˆÚ“®ƒ‹[ƒg‹­§’†A
# ƒƒbƒZ[ƒWƒEƒBƒ“ƒhƒE•\Ž¦’†‚Ì‚¢‚¸‚ê‚Å‚à‚È‚¢ê‡
unless moving? or $game_system.map_interpreter.running? or
@move_route_forcing or $game_temp.message_window_showing
@event_run = false
# •ûŒüƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ê‚Ä‚¢‚ê‚΁A‚»‚Ì•ûŒü‚ÖƒvƒŒƒCƒ„[‚ðˆÚ“®
case Input.dir8
when 1
move_lower_left_p
when 2
move_down_p
when 3
move_lower_right_p
when 4
move_left_p
when 6
move_right_p
when 7
move_upper_left_p
when 8
move_up_p
when 9
move_upper_right_p
end
end
# ƒ[ƒJƒ‹•Ï”‚ɍÀ•W‚ð‹L‰¯
last_real_x = @real_x
last_real_y = @real_y
# ˆÚ“®ˆ—
@real_x = @x * 128 + @revise_x
@real_y = @y * 128 + @revise_y
# ƒ[ƒJƒ‹•Ï”‚Ɉړ®’†‚©‚Ç‚¤‚©‚ð‹L‰¯
last_moving = moving?
# À•WXV
move_on
# Œ»Ý‚̍À•W‚ƈȑO‚̍À•W‚ªˆÙ‚È‚éê‡
if (last_real_x != @real_x or last_real_y != @real_y)
@move_distance = 0 if @move_distance == nil
@move_distance += Math.sqrt((last_real_x - @real_x) ** 2 +
(last_real_y - @real_y) ** 2)
if @move_distance >= 128
@move_distance %= 128
increase_steps
end
# ƒAƒjƒ[ƒVƒ‡ƒ“‚ðXV
anime_update
elsif @walk_anime
@pattern = @original_pattern
end
end
# ƒLƒƒƒ‰ƒNƒ^[‚ª‰º‚Ɉړ®‚µA‚©‚‰æ–ʏã‚̈ʒu‚ª’†‰›‚æ‚艺‚̏ꍇ
if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
# ƒ}ƒbƒv‚ð‰º‚ÉƒXƒNƒ[ƒ‹
$game_map.scroll_down(@real_y - last_real_y)
end
# ƒLƒƒƒ‰ƒNƒ^[‚ª¶‚Ɉړ®‚µA‚©‚‰æ–ʏã‚̈ʒu‚ª’†‰›‚æ‚荶‚̏ꍇ
if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
# ƒ}ƒbƒv‚ð¶‚ÉƒXƒNƒ[ƒ‹
$game_map.scroll_left(last_real_x - @real_x)
end
# ƒLƒƒƒ‰ƒNƒ^[‚ª‰E‚Ɉړ®‚µA‚©‚‰æ–ʏã‚̈ʒu‚ª’†‰›‚æ‚è‰E‚̏ꍇ
if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
# ƒ}ƒbƒv‚ð‰E‚ɃXƒNƒ[ƒ‹
$game_map.scroll_right(@real_x - last_real_x)
end
# ƒLƒƒƒ‰ƒNƒ^[‚ªã‚Ɉړ®‚µA‚©‚‰æ–ʏã‚̈ʒu‚ª’†‰›‚æ‚èã‚̏ꍇ
if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
# ƒ}ƒbƒv‚ðã‚ɃXƒNƒ[ƒ‹
$game_map.scroll_up(last_real_y - @real_y)
end
# ‘O‰ñƒvƒŒƒCƒ„[‚ªˆÚ“®’†‚¾‚Á‚½ê‡
if last_moving
# “¯ˆÊ’u‚̃Cƒxƒ“ƒg‚Ƃ̐ڐG‚É‚æ‚éƒCƒxƒ“ƒg‹N“®”»’è
result = check_event_trigger_here([1,2])
if result == true
if (last_real_x / 128.0).round != @x and
(last_real_y / 128.0).round != @y
if @direction == 2 or @direction == 8
if (last_real_x / 128.0).round > @x
turn_left
else
turn_right
end
else
if (last_real_y / 128.0).round > @y
turn_up
else
turn_down
end
end
elsif (last_real_x / 128.0).round > @x
turn_left
elsif (last_real_x / 128.0).round < @x
turn_right
elsif (last_real_y / 128.0).round > @y
turn_up
elsif (last_real_y / 128.0).round < @y
turn_down
end
end
# ‹N“®‚µ‚½ƒCƒxƒ“ƒg‚ª‚È‚¢ê‡
if result == false
# ƒfƒoƒbƒOƒ‚[ƒh‚ª ON ‚©‚ CTRL ƒL[‚ª‰Ÿ‚³‚ê‚Ä‚¢‚éê‡‚ðœ‚«
unless $DEBUG and Input.press?(Input::CTRL)
# ƒGƒ“ƒJƒEƒ“ƒg ƒJƒEƒ“ƒgƒ_ƒEƒ“
if @encounter_count > 0
@encounter_count -= 1
end
end
end
end
# C ƒ{ƒ^ƒ“‚ª‰Ÿ‚³‚ꂽê‡
if Input.trigger?(Input::C)
# “¯ˆÊ’u‚¨‚æ‚ѐ³–ʂ̃Cƒxƒ“ƒg‹N“®”»’è
check_event_trigger_here([0])
check_event_trigger_there([0,1,2])
end
end
#--------------------------------------------------------------------------
# œ ˆÚ“®”»’è
#--------------------------------------------------------------------------
def moving?
unless @dot_m
result = super
return result
end
# ‹­§ˆÚ“®‚̏ꍇƒIƒŠƒWƒiƒ‹‚Ì”»’è‚ð‚³‚¹‚é
if @move_route_forcing
if @move == false
return false
end
super
# ’ʏ펞‚ÍŒ»À•W‚ªŽÀÀ•W‚ƈقȂéê‡‚݈̂ړ®’†‚Æ”»’è
else
return (@x != (@real_x / 128.0).round or @y != (@real_y / 128.0).round)
end
end
#--------------------------------------------------------------------------
# œ ˆÚ“®”»’è
#--------------------------------------------------------------------------
def moving_a?
if @move == false
if (@move_route.list[@move_route_index].code <= 14 or
@move_route.list[@move_route_index].code == 25)
@move = true
end
return false
end
moving?
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ƒWƒƒƒ“ƒv)
#--------------------------------------------------------------------------
def update_jump
# ƒWƒƒƒ“ƒvƒJƒEƒ“ƒg‚ð 1 Œ¸‚ç‚·
@jump_count -= 1
# V‚µ‚¢À•W‚ðŒvŽZ
@real_x = (@real_x * @jump_count + @x * 12 / (@jump_count + 1)
@real_y = (@real_y * @jump_count + @y * 12 / (@jump_count + 1)
if @jump_count == 0
@revise_x = 0
@revise_y = 0
end
end
#--------------------------------------------------------------------------
# œ ˆÚ“®ƒ^ƒCƒv : ƒJƒXƒ^ƒ€
#--------------------------------------------------------------------------
def move_type_custom
unless @dot_m
super
return
end
# ’âŽ~’†‚Å‚È‚¯‚ê‚Î’†’f
if jumping? or moving_a?
return
end
# ˆÚ“®ƒRƒ}ƒ“ƒh‚̃ŠƒXƒg‚̍Ōã‚É“ž’B‚·‚é‚܂Ń‹[ƒv
while @move_route_index < @move_route.list.size
# ˆÚ“®ƒRƒ}ƒ“ƒh‚ðŽæ“¾
command = @move_route.list[@move_route_index]
# ƒRƒ}ƒ“ƒhƒR[ƒh 0 ”Ô (ƒŠƒXƒg‚̍Ōã) ‚̏ꍇ
if command.code == 0
# ƒIƒvƒVƒ‡ƒ“ [“®ì‚ðŒJ‚è•Ô‚·] ‚ª ON ‚̏ꍇ
if @move_route.repeat
# ˆÚ“®ƒ‹[ƒg‚̃Cƒ“ƒfƒbƒNƒX‚ðÅ‰‚É–ß‚·
@move_route_index = 0
end
# ƒIƒvƒVƒ‡ƒ“ [“®ì‚ðŒJ‚è•Ô‚·] ‚ª OFF ‚̏ꍇ
unless @move_route.repeat
# ˆÚ“®ƒ‹[ƒg‹­§’†‚̏ꍇ
if @move_route_forcing and not @move_route.repeat
# ˆÚ“®ƒ‹[ƒg‚Ì‹­§‚ð‰ðœ
@move_route_forcing = false
# ƒIƒŠƒWƒiƒ‹‚̈ړ®ƒ‹[ƒg‚𕜋A
@move_route = @original_move_route
@move_route_index = @original_move_route_index
@original_move_route = nil
end
# ’âŽ~ƒJƒEƒ“ƒg‚ðƒNƒŠƒA
@stop_count = 0
end
return
end
# ˆÚ“®ŒnƒRƒ}ƒ“ƒh (‰º‚Ɉړ®`ƒWƒƒƒ“ƒv) ‚̏ꍇ
if command.code <= 14
# ƒRƒ}ƒ“ƒhƒR[ƒh‚Å•ªŠò
case command.code
when 1 # ‰º‚Ɉړ®
move_down
when 2 # ¶‚Ɉړ®
move_left
when 3 # ‰E‚Ɉړ®
move_right
when 4 # ã‚Ɉړ®
move_up
when 5 # ¶‰º‚Ɉړ®
move_lower_left
when 6 # ‰E‰º‚Ɉړ®
move_lower_right
when 7 # ¶ã‚Ɉړ®
move_upper_left
when 8 # ‰Eã‚Ɉړ®
move_upper_right
when 9 # ƒ‰ƒ“ƒ_ƒ€‚Ɉړ®
move_random
when 10 # ƒvƒŒƒCƒ„[‚ɋ߂­
move_toward_player
when 11 # ƒvƒŒƒCƒ„[‚©‚牓‚´‚©‚é
move_away_from_player
when 12 # ˆê•à‘Oi
move_forward
when 13 # ˆê•àŒã‘Þ
move_backward
when 14 # ƒWƒƒƒ“ƒv
jump(command.parameters[0], command.parameters[1])
end
# ƒIƒvƒVƒ‡ƒ“ [ˆÚ“®‚Å‚«‚È‚¢ê‡‚Í–³Ž‹] ‚ª OFF ‚ŁAˆÚ“®Ž¸”s‚̏ꍇ
if not @move_route.skippable and not moving? and not jumping?
return
end
@move_route_index += 1
return
end
# ƒEƒFƒCƒg‚̏ꍇ
if command.code == 15
# ƒEƒFƒCƒgƒJƒEƒ“ƒg‚ðÝ’è
@wait_count = command.parameters[0] * 2 - 1
@move_route_index += 1
return
end
# Œü‚«•ÏXŒn‚̃Rƒ}ƒ“ƒh‚̏ꍇ
if command.code >= 16 and command.code <= 26
# ƒRƒ}ƒ“ƒhƒR[ƒh‚Å•ªŠò
case command.code
when 16 # ‰º‚ðŒü‚­
turn_down
when 17 # ¶‚ðŒü‚­
turn_left
when 18 # ‰E‚ðŒü‚­
turn_right
when 19 # ã‚ðŒü‚­
turn_up
when 20 # ‰E‚É 90 “x‰ñ“]
turn_right_90
when 21 # ¶‚É 90 “x‰ñ“]
turn_left_90
when 22 # 180 “x‰ñ“]
turn_180
when 23 # ‰E‚©¶‚É 90 “x‰ñ“]
turn_right_or_left_90
when 24 # ƒ‰ƒ“ƒ_ƒ€‚É•ûŒü“]Š·
turn_random
when 25 # ƒvƒŒƒCƒ„[‚Ì•û‚ðŒü‚­
turn_toward_player
when 26 # ƒvƒŒƒCƒ„[‚Ì‹t‚ðŒü‚­
turn_away_from_player
end
@move_route_index += 1
return
end
# ‚»‚Ì‘¼‚̃Rƒ}ƒ“ƒh‚̏ꍇ
if command.code >= 27
# ƒRƒ}ƒ“ƒhƒR[ƒh‚Å•ªŠò
case command.code
when 27 # ƒXƒCƒbƒ` ON
$game_switches[command.parameters[0]] = true
$game_map.need_refresh = true
when 28 # ƒXƒCƒbƒ` OFF
$game_switches[command.parameters[0]] = false
$game_map.need_refresh = true
when 29 # ˆÚ“®‘¬“x‚̕ύX
@move_speed = command.parameters[0]
when 30 # ˆÚ“®•p“x‚̕ύX
@move_frequency = command.parameters[0]
when 31 # ˆÚ“®ŽžƒAƒjƒ ON
@walk_anime = true
when 32 # ˆÚ“®ŽžƒAƒjƒ OFF
@walk_anime = false
when 33 # ’âŽ~ŽžƒAƒjƒ ON
@step_anime = true
when 34 # ’âŽ~ŽžƒAƒjƒ OFF
@step_anime = false
when 35 # Œü‚«ŒÅ’è ON
@direction_fix = true
when 36 # Œü‚«ŒÅ’è OFF
@direction_fix = false
when 37 # ‚·‚蔲‚¯ ON
@through = true
when 38 # ‚·‚蔲‚¯ OFF
@through = false
when 39 # Å‘O–Ê‚É•\Ž¦ ON
@always_on_top = true
when 40 # Å‘O–Ê‚É•\Ž¦ OFF
@always_on_top = false
when 41 # ƒOƒ‰ƒtƒBƒbƒN•ÏX
@tile_id = 0
@character_name = command.parameters[0]
@character_hue = command.parameters[1]
if @original_direction != command.parameters[2]
@direction = command.parameters[2]
@original_direction = @direction
@prelock_direction = 0
end
if @original_pattern != command.parameters[3]
@pattern = command.parameters[3]
@original_pattern = @pattern
end
when 42 # •s“§–¾“x‚̕ύX
@opacity = command.parameters[0]
when 43 # ‡¬•û–@‚̕ύX
@blend_type = command.parameters[0]
when 44 # SE ‚̉‰‘t
$game_system.se_play(command.parameters[0])
when 45 # ƒXƒNƒŠƒvƒg
result = eval(command.parameters[0])
end
@move_route_index += 1
return
end
end
end
#--------------------------------------------------------------------------
# œ ‰º‚Ɉړ®
#--------------------------------------------------------------------------
def move_down_p
# ‰º‚ðŒü‚­
turn_down
# ˆÚ“®‹——£‚ðŽZo
distance = 2 ** @move_speed
down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# œ ‰º‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚P
#--------------------------------------------------------------------------
def down1(x, y, distance, down = false)
result = down2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x, y+1)
return result
end
if @revise_x < -SIDE
result = down2(x, y + 1, distance, 4)
result &= down2(x - 1, y, distance)
if result == false
if down
move_lower_right_p
if @revise_x > SIDE
@revise_x = SIDE
end
end
return result
end
elsif @revise_x > SIDE
result = down2(x, y + 1, distance, 6)
result &= down2(x + 1, y, distance)
if result == false
if down
move_lower_left_p
if @revise_x < -SIDE
@revise_x = -SIDE
end
end
return result
end
end
# ‰º‚Ɉړ®‰Â”\‚È‚ç‚΋——£•ªˆÚ“®
@revise_y += distance
return result
end
#--------------------------------------------------------------------------
# œ ‰º‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚Q
#--------------------------------------------------------------------------
def down2(x, y, distance, d = 2)
if @revise_y + distance > 0
unless passable?(x, y, d)
if @revise_y < 0
@revise_y = 0
end
return false
end
end
return true
end
#--------------------------------------------------------------------------
# œ ¶‚Ɉړ®
#--------------------------------------------------------------------------
def move_left_p
# ¶‚ðŒü‚­
turn_left
distance = 2 ** @move_speed
left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# œ ¶‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚P
#--------------------------------------------------------------------------
def left1(x, y, distance, left = false)
result = left2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x-1, y)
return result
end
if @revise_y < -UP
result = left2(x - 1, y, distance,
result &= left2(x, y - 1, distance)
if result == false
if left
move_lower_left_p
if @revise_y > 0
@revise_y = 0
end
end
return result
end
elsif @revise_y > 0
result = left2(x - 1, y, distance, 2)
result &= left2(x, y + 1, distance)
if result == false
if left
move_upper_left_p
if @revise_y < -UP
@revise_y = -UP
end
end
return result
end
end
@revise_x -= distance
return result
end
#--------------------------------------------------------------------------
# œ ¶‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚Q
#--------------------------------------------------------------------------
def left2(x, y, distance, d = 4)
if @revise_x - distance < -SIDE
unless passable?(x, y, d)
if @revise_x > -SIDE
@revise_x = -SIDE
end
return false
end
end
return true
end
#--------------------------------------------------------------------------
# œ ‰E‚Ɉړ®
#--------------------------------------------------------------------------
def move_right_p
# ‰E‚ðŒü‚­
turn_right
distance = 2 ** @move_speed
right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# œ ‰E‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚P
#--------------------------------------------------------------------------
def right1(x, y, distance, right = false)
result = right2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x+1, y)
return result
end
if @revise_y < -UP
result = right2(x + 1, y, distance,
result &= right2(x, y - 1, distance)
if result == false
if right
move_lower_right_p
if @revise_y > 0
@revise_y = 0
end
end
return result
end
elsif @revise_y > 0
result = right2(x + 1, y, distance, 2)
result &= right2(x, y + 1, distance)
if result == false
if right
move_upper_right_p
if @revise_y < -UP
@revise_y = -UP
end
end
return result
end
end
@revise_x += distance
return result
end
#--------------------------------------------------------------------------
# œ ‰E‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚Q
#--------------------------------------------------------------------------
def right2(x, y, distance, d = 6)
if @revise_x + distance > SIDE
unless passable?(x, y, d)
if @revise_x < SIDE
@revise_x = SIDE
end
return false
end
end
return true
end
#--------------------------------------------------------------------------
# œ ã‚Ɉړ®
#--------------------------------------------------------------------------
def move_up_p
# ã‚ðŒü‚­
turn_up
# ‰º‚Ɉړ®
distance = 2 ** @move_speed
up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
# œ ã‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚P
#--------------------------------------------------------------------------
def up1(x, y, distance, up = false)
result = up2(x, y, distance)
if result == false
@event_run = check_event_trigger_touch(x, y-1)
return result
end
if @revise_x < -SIDE
result = up2(x, y - 1, distance, 4)
result &= up2(x - 1, y, distance)
if result == false
if up
move_upper_right_p
if @revise_x > SIDE
@revise_x = SIDE
end
end
return result
end
elsif @revise_x > SIDE
result = up2(x, y - 1, distance, 6)
result &= up2(x + 1, y, distance)
if result == false
if up
move_upper_left_p
if @revise_x < -SIDE
@revise_x = -SIDE
end
end
return result
end
end
@revise_y -= distance
return result
end
#--------------------------------------------------------------------------
# œ ã‚Ɉړ®‰Â”\‚©‚Ç‚¤‚©‚Ì”»’è‚Q
#--------------------------------------------------------------------------
def up2(x, y, distance, d =
if @revise_y - distance < -UP
unless passable?(x, y, d)
if @revise_y > -UP
@revise_y = -UP
end
return false
end
end
return true
end
#--------------------------------------------------------------------------
# œ ¶‰º‚Ɉړ®
#--------------------------------------------------------------------------
def move_lower_left_p
# Œü‚«ŒÅ’è‚Å‚È‚¢ê‡
unless @direction_fix
# ‰EŒü‚«‚¾‚Á‚½ê‡‚͍¶‚ðAãŒü‚«‚¾‚Á‚½ê‡‚͉º‚ðŒü‚­
@direction = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
end
# ¶‰º‚Ɉړ®
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 2
turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 2, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_y > 0 and -UP > @revise_y - distance
@revise_y = 0
end
turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
end
else
turn_down unless left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 4, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_x + distance> SIDE and -SIDE > @revise_x
@revise_x = -SIDE
end
turn_left unless down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
end
end
end
#--------------------------------------------------------------------------
# œ ‰E‰º‚Ɉړ®
#--------------------------------------------------------------------------
def move_lower_right_p
# Œü‚«ŒÅ’è‚Å‚È‚¢ê‡
unless @direction_fix
# ¶Œü‚«‚¾‚Á‚½ê‡‚͉E‚ðAãŒü‚«‚¾‚Á‚½ê‡‚͉º‚ðŒü‚­
@direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
end
# ‰E‰º‚Ɉړ®
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 2
turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 2, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_y > 0 and -UP > @revise_y - distance
@revise_y = 0
end
turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
end
else
turn_down unless right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 6, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_x > SIDE and -SIDE > @revise_x - distance
@revise_x = SIDE
end
turn_right unless down1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_down if @event_run
end
end
end
#--------------------------------------------------------------------------
# œ ¶ã‚Ɉړ®
#--------------------------------------------------------------------------
def move_upper_left_p
# Œü‚«ŒÅ’è‚Å‚È‚¢ê‡
unless @direction_fix
# ‰EŒü‚«‚¾‚Á‚½ê‡‚͍¶‚ðA‰ºŒü‚«‚¾‚Á‚½ê‡‚͏ã‚ðŒü‚­
@direction = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
end
# ¶ã‚Ɉړ®
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 8
turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 8, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_y + distance > 0 and -UP > @revise_y
@revise_y = -UP
end
turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
end
else
turn_up unless left1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_left if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 4, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_x > SIDE and -SIDE > @revise_x - distance
@revise_x = SIDE
end
turn_left unless up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
end
end
end
#--------------------------------------------------------------------------
# œ ‰Eã‚Ɉړ®
#--------------------------------------------------------------------------
def move_upper_right_p
# Œü‚«ŒÅ’è‚Å‚È‚¢ê‡
unless @direction_fix
# ¶Œü‚«‚¾‚Á‚½ê‡‚͉E‚ðA‰ºŒü‚«‚¾‚Á‚½ê‡‚͏ã‚ðŒü‚­
@direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
end
# ‰Eã‚Ɉړ®
distance = (2 ** @move_speed) / Math.sqrt(2)
if @direction == 8
turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 8, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_y + distance > 0 and -UP > @revise_y
@revise_y = -UP
end
turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
end
else
turn_up unless right1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_right if @event_run
unless @event_run
if last_move?(@real_x, @real_y, 6, distance)
result = check_event_trigger_here([1,2], false)
if result == true
return
end
end
move_on
if @revise_x > SIDE and -SIDE > @revise_x - distance
@revise_x = SIDE
end
turn_right unless up1(((@x * 128 + @revise_x) / 128.0).round,
((@y * 128 + @revise_y) / 128.0).round, distance)
turn_up if @event_run
end
end
end
#--------------------------------------------------------------------------
# œ “¯ˆÊ’u‚̃Cƒxƒ“ƒg‹N“®”»’è
#--------------------------------------------------------------------------
def check_event_trigger_here(triggers, run = true)
result = false
# ƒCƒxƒ“ƒgŽÀs’†‚̏ꍇ
if $game_system.map_interpreter.running?
return result
end
# ‘SƒCƒxƒ“ƒg‚̃‹[ƒv
for event in $game_map.events.values
# ƒCƒxƒ“ƒg‚̍À•W‚ƃgƒŠƒK[‚ªˆê’v‚µ‚½ê‡
if event.x == ((@x * 128 + @revise_x) / 128.0).round and
event.y == ((@y * 128 + @revise_y) / 128.0).round and
triggers.include?(event.trigger)
# ƒWƒƒƒ“ƒv’†ˆÈŠO‚ŁA‹N“®”»’肪“¯ˆÊ’u‚̃Cƒxƒ“ƒg‚È‚ç
if not event.jumping? and event.over_trigger?
if event.list.size > 1
if run == true
event.start
end
result = true
end
end
end
end
return result
end
#--------------------------------------------------------------------------
# œ À•WC³
#--------------------------------------------------------------------------
def move_on
if @y < (@y + @revise_y / 128.0).round
@y += 1
@revise_y -= 128
end
if @x > (@x + @revise_x / 128.0).round
@x -= 1
@revise_x += 128
end
if @x < (@x + @revise_x / 128.0).round
@x += 1
@revise_x -= 128
end
if @y > (@y + @revise_y / 128.0).round
@y -= 1
@revise_y += 128
end
end
#--------------------------------------------------------------------------
# œ ƒAƒjƒ[ƒVƒ‡ƒ“ƒAƒbƒvƒf[ƒg
#--------------------------------------------------------------------------
def anime_update
# ˆÚ“®ŽžƒAƒjƒ‚ª ON ‚̏ꍇ
if @walk_anime
# ƒAƒjƒƒJƒEƒ“ƒg‚ð 1.5 ‘‚â‚·
@anime_count += 1.5
# ˆÚ“®ŽžƒAƒjƒ‚ª OFF ‚ŁA’âŽ~ŽžƒAƒjƒ‚ª ON ‚̏ꍇ
elsif @step_anime
# ƒAƒjƒƒJƒEƒ“ƒg‚ð 1 ‘‚â‚·
@anime_count += 1
end
# ƒAƒjƒƒJƒEƒ“ƒg‚ªÅ‘å’l‚ð’´‚¦‚½ê‡
# ¦Å‘å’l‚́AŠî–{’l 18 ‚©‚çˆÚ“®‘¬“x * 1 ‚ðˆø‚¢‚½’l
if @anime_count > 18 - @move_speed * 2
# ’âŽ~ŽžƒAƒjƒ‚ª OFF ‚©‚ ’âŽ~’†‚̏ꍇ
if not @step_anime and @stop_count > 0
# ƒpƒ^[ƒ“‚ðƒIƒŠƒWƒiƒ‹‚É–ß‚·
@pattern = @original_pattern
# ’âŽ~ŽžƒAƒjƒ‚ª ON ‚Ü‚½‚Í ˆÚ“®’†‚̏ꍇ
else
# ƒpƒ^[ƒ“‚ðXV
@pattern = (@pattern + 1) % 4
end
# ƒAƒjƒƒJƒEƒ“ƒg‚ðƒNƒŠƒA
@anime_count = 0
end
end
#--------------------------------------------------------------------------
# œ Žw’èˆÊ’u‚Ɉړ®
#--------------------------------------------------------------------------
# ƒIƒŠƒWƒiƒ‹‚̃Cƒxƒ“ƒg‚ð‰ü–¼
alias :moveto_original :moveto
def moveto(x, y)
# •â³À•W‚ð‰Šú‰»
@revise_x = 0
@revise_y = 0
# ƒIƒŠƒWƒiƒ‹‚̃Cƒxƒ“ƒg‚ðŒÄ‚яo‚µ
moveto_original(x, y)
end
#--------------------------------------------------------------------------
# œ ˆÚ“®‚µ‚½‚©‚Ç‚¤‚©‚Ì”»’è
#--------------------------------------------------------------------------
def last_move?(x, y, direction, distance)
if direction == 2 or direction == 6
distance *= -1
end
if (direction == 2 or direction == and
(y / 128.0).round != ((y - distance) / 128.0).round
return true
end
if (direction == 4 or direction == 6) and
(x / 128.0).round != ((x - distance) / 128.0).round
return true
end
return false
end
end

#==============================================================================
# ¡ Game_Character (•ªŠ„’è‹` 1)
#------------------------------------------------------------------------------
# @ƒLƒƒƒ‰ƒNƒ^[‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·B‚±‚̃Nƒ‰ƒX‚Í Game_Player ƒNƒ‰ƒX‚Æ Game_Event
# ƒNƒ‰ƒX‚̃X[ƒp[ƒNƒ‰ƒX‚Æ‚µ‚ÄŽg—p‚³‚ê‚Ü‚·B
#==============================================================================

class Game_Character
#--------------------------------------------------------------------------
# œ ‰æ–Ê X À•W‚̎擾
#--------------------------------------------------------------------------
def screen_x
# ŽÀÀ•W‚ƃ}ƒbƒv‚Ì•\Ž¦ˆÊ’u‚©‚ç‰æ–ʍÀ•W‚ð‹‚ß‚é
return ((@real_x - $game_map.display_x) / 4).ceil + 16
end
#--------------------------------------------------------------------------
# œ ‰æ–Ê Y À•W‚̎擾
#--------------------------------------------------------------------------
def screen_y
# ŽÀÀ•W‚ƃ}ƒbƒv‚Ì•\Ž¦ˆÊ’u‚©‚ç‰æ–ʍÀ•W‚ð‹‚ß‚é
y = ((@real_y - $game_map.display_y) / 4).ceil + 32
# ƒWƒƒƒ“ƒvƒJƒEƒ“ƒg‚ɉž‚¶‚Ä Y À•W‚ð¬‚³‚­‚·‚é
if @jump_count >= @jump_peak
n = @jump_count - @jump_peak
else
n = @jump_peak - @jump_count
end
return y - (@jump_peak * @jump_peak - n * n) / 2
end
#--------------------------------------------------------------------------
# œ ƒtƒŒ[ƒ€XV (ˆÚ“®)
#--------------------------------------------------------------------------
def update_move
# ˆÚ“®‘¬“x‚©‚çƒ}ƒbƒvÀ•WŒn‚ł̈ړ®‹——£‚É•ÏŠ·
distance = 2 ** @move_speed
if @x * 128 != @real_x and @y * 128 != @real_y and Game_Player::SLANT
distance /= Math.sqrt(2)
end
# ˜_—À•W‚ªŽÀÀ•W‚æ‚艺‚̏ꍇ
if @y * 128 > @real_y
# ‰º‚Ɉړ®
@real_y = [@real_y + distance, @y * 128].min
end
# ˜_—À•W‚ªŽÀÀ•W‚æ‚荶‚̏ꍇ
if @x * 128 < @real_x
# ¶‚Ɉړ®
@real_x = [@real_x - distance, @x * 128].max
end
# ˜_—À•W‚ªŽÀÀ•W‚æ‚è‰E‚̏ꍇ
if @x * 128 > @real_x
# ‰E‚Ɉړ®
@real_x = [@real_x + distance, @x * 128].min
end
# ˜_—À•W‚ªŽÀÀ•W‚æ‚èã‚̏ꍇ
if @y * 128 < @real_y
# ã‚Ɉړ®
@real_y = [@real_y - distance, @y * 128].max
end
# ˆÚ“®ŽžƒAƒjƒ‚ª ON ‚̏ꍇ
if @walk_anime
# ƒAƒjƒƒJƒEƒ“ƒg‚ð 1.5 ‘‚â‚·
@anime_count += 1.5
# ˆÚ“®ŽžƒAƒjƒ‚ª OFF ‚ŁA’âŽ~ŽžƒAƒjƒ‚ª ON ‚̏ꍇ
elsif @step_anime
# ƒAƒjƒƒJƒEƒ“ƒg‚ð 1 ‘‚â‚·
@anime_count += 1
end
end
end

#==============================================================================
# ¡ Game_Event
#------------------------------------------------------------------------------
# @ƒCƒxƒ“ƒg‚ðˆµ‚¤ƒNƒ‰ƒX‚Å‚·BðŒ”»’è‚É‚æ‚éƒCƒxƒ“ƒgƒy[ƒWØ‚è‘Ö‚¦‚âA•À—ñˆ—
# ƒCƒxƒ“ƒgŽÀs‚È‚Ç‚Ì‹@”\‚ðŽ‚Á‚Ä‚¨‚èAGame_Map ƒNƒ‰ƒX‚Ì“à•”‚ÅŽg—p‚³‚ê‚Ü‚·B
#==============================================================================

class Game_Event < Game_Character
#--------------------------------------------------------------------------
# œ ƒCƒxƒ“ƒg‹N“®
#--------------------------------------------------------------------------
def start
# ŽÀs“à—e‚ª‹ó‚Å‚È‚¢ê‡
if @list.size > 1
# $game_player.event ‚ª0‚Å‚È‚¢ê‡
if $game_player.event != 0
# ˆÚ“®‘¬“x‚ð $game_player.event ‚É‚·‚é
$game_player.move_speed = $game_player.event
elsif self.trigger == 0
$game_player.move_speed = $game_player.walk
end
@starting = true
end
end
end