Ruby Quellcode

# http://members.jcom.home.ne.jp/cogwheel/
#==============================================================================
# Game_Player
#==============================================================================
class Game_Player < Game_Character
UP	= 0
DOWN  = 0
SIDE  = 0
SLANT = false
#--------------------------------------------------------------------------
attr_reader   :event
attr_accessor :move_speed
#--------------------------------------------------------------------------
alias :update_original :update
def update
  @walk  = 4
  @dash  = 5
  @event = 4
  @dot_m = true
  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
	last_moving = moving?
	last_real_x = @real_x
	last_real_y = @real_y
	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 = 2 ** @move_speed
  	distance2 = Math.sqrt(@revise_x ** 2 + @revise_y ** 2)
  	if distance1 > distance2
    	@real_x = @real_x - @revise_x
    	@real_y = @real_y - @revise_y
    	@revise_x = 0
    	@revise_y = 0
    	anime_update
  	else
    	@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
	unless moving? or $game_system.map_interpreter.running? or
       	@move_route_forcing or $game_temp.message_window_showing
  	@event_run = false
  	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
	last_real_x = @real_x
	last_real_y = @real_y
	@real_x = @x * 128 + @revise_x
	@real_y = @y * 128 + @revise_y
	last_moving = moving?
	move_on
	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
  	anime_update
	else
  	@pattern = 0
	end
  end
  if @real_y > last_real_y and @real_y - $game_map.display_y > CENTER_Y
	$game_map.scroll_down(@real_y - last_real_y)
  end
  if @real_x < last_real_x and @real_x - $game_map.display_x < CENTER_X
	$game_map.scroll_left(last_real_x - @real_x)
  end
  if @real_x > last_real_x and @real_x - $game_map.display_x > CENTER_X
	$game_map.scroll_right(@real_x - last_real_x)
  end
  if @real_y < last_real_y and @real_y - $game_map.display_y < CENTER_Y
	$game_map.scroll_up(last_real_y - @real_y)
  end
  if last_moving
	result = check_event_trigger_here([1,2])
	if result == false
  	unless $DEBUG and Input.press?(Input::CTRL)
    	if @encounter_count > 0
      	@encounter_count -= 1
    	end
  	end
	end
  end
  if Input.trigger?(Input::C)
	check_event_trigger_here([0])
	check_event_trigger_there([0,1,2])
  end
end
#--------------------------------------------------------------------------
def initialize
  @revise_x = 0
  @revise_y = 0
  @move == false
  super
end
#--------------------------------------------------------------------------
def moving?
  unless @dot_m
	result = super
	return result
  end
  if @move_route_forcing
	if @move == false
  	return false
	end
	super
  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
#--------------------------------------------------------------------------
def update_jump
  @jump_count -= 1
  @real_x = (@real_x * @jump_count + @x * 128) / (@jump_count + 1)
  @real_y = (@real_y * @jump_count + @y * 128) / (@jump_count + 1)
  if @jump_count == 0
	@revise_x = 0
	@revise_y = 0
  end
end
#--------------------------------------------------------------------------
def move_type_custom
  unless @dot_m
	super
	return
  end
  if jumping? or moving_a?
	return
  end
  while @move_route_index < @move_route.list.size
	command = @move_route.list[@move_route_index]
	if command.code == 0
  	if @move_route.repeat
    	@move_route_index = 0
  	end
  	unless @move_route.repeat
    	if @move_route_forcing and not @move_route.repeat
      	@move_route_forcing = false
      	@move_route = @original_move_route
      	@move_route_index = @original_move_route_index
      	@original_move_route = nil
    	end
    	@stop_count = 0
  	end
  	return
	end
	if command.code <= 14
  	case command.code
  	when 1
    	move_down
  	when 2
    	move_left
  	when 3
    	move_right
  	when 4
    	move_up
  	when 5
    	move_lower_left
  	when 6
    	move_lower_right
  	when 7
    	move_upper_left
  	when 8
    	move_upper_right
  	when 9
    	move_random
  	when 10
    	move_toward_player
  	when 11
    	move_away_from_player
  	when 12
    	move_forward
  	when 13
    	move_backward
  	when 14
    	jump(command.parameters[0], command.parameters[1])
  	end
  	if not @move_route.skippable and not moving? and not jumping?
    	return
  	end
  	@move_route_index += 1
  	return
	end
	if command.code == 15
  	@wait_count = command.parameters[0] * 2 - 1
  	@move_route_index += 1
  	return
	end
	if command.code >= 16 and command.code <= 26
  	case command.code
  	when 16
    	turn_down
  	when 17
    	turn_left
  	when 18
    	turn_right
  	when 19
    	turn_up
  	when 20
    	turn_right_90
  	when 21
    	turn_left_90
  	when 22
    	turn_180
  	when 23
    	turn_right_or_left_90
  	when 24
    	turn_random
  	when 25
    	turn_toward_player
  	when 26
    	turn_away_from_player
  	end
  	@move_route_index += 1
  	return
	end
	if command.code >= 27
  	case command.code
  	when 27
    	$game_switches[command.parameters[0]] = true
    	$game_map.need_refresh = true
  	when 28
    	$game_switches[command.parameters[0]] = false
    	$game_map.need_refresh = true
  	when 29
    	@move_speed = command.parameters[0]
  	when 30
    	@move_frequency = command.parameters[0]
  	when 31
    	@walk_anime = true
  	when 32
    	@walk_anime = false
  	when 33
    	@step_anime = true
  	when 34
    	@step_anime = false
  	when 35
    	@direction_fix = true
  	when 36
    	@direction_fix = false
  	when 37
    	@through = true
  	when 38
    	@through = false
  	when 39
    	@always_on_top = true
  	when 40
    	@always_on_top = false
  	when 41
    	@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
    	@opacity = command.parameters[0]
  	when 43
    	@blend_type = command.parameters[0]
  	when 44
    	$game_system.se_play(command.parameters[0])
  	when 45
    	result = eval(command.parameters[0])
  	end
  	@move_route_index += 1
  	return
	end
  end
end
#--------------------------------------------------------------------------
def move_down_p
  turn_down
  distance = 2 ** @move_speed
  down1(((@x * 128 + @revise_x) / 128.0).round,
    	((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
def down2(x, y, distance, d = 2)
  if @revise_y + distance > DOWN
	unless passable?(x, y, d)
  	if @revise_y < DOWN
    	@revise_y = DOWN
  	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
#--------------------------------------------------------------------------
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, 8)
	result &= left2(x, y - 1, distance)
	if result == false
  	if left
    	move_lower_left_p
    	if @revise_y > DOWN
      	@revise_y = DOWN
    	end
  	end
  	return result
	end
  elsif @revise_y > DOWN
	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
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
def move_right_p
	turn_right
  distance = 2 ** @move_speed
  right1(((@x * 128 + @revise_x) / 128.0).round,
      	((@y * 128 + @revise_y) / 128.0).round, distance, true)
end
#--------------------------------------------------------------------------
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, 8)
	result &= right2(x, y - 1, distance)
	if result == false
  	if right
    	move_lower_right_p
    	if @revise_y > DOWN
      	@revise_y = DOWN
    	end
  	end
  	return result
	end
  elsif @revise_y > DOWN
	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
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
def up2(x, y, distance, d = 8)
  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
	@direction = (@direction == 6 ? 4 : @direction == 8 ? 2 : @direction)
  end
  distance = (2 ** @move_speed) / Math.sqrt(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 > DOWN and -UP > @revise_y - distance
  	@revise_y = DOWN
	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
end
#--------------------------------------------------------------------------
def move_lower_right_p
  unless @direction_fix
	@direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
  end
  distance = (2 ** @move_speed) / Math.sqrt(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 > DOWN and -UP > @revise_y - distance
  	@revise_y = DOWN
	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
end
#--------------------------------------------------------------------------
def move_upper_left_p
  unless @direction_fix
	@direction = (@direction == 6 ? 4 : @direction == 2 ? 8 : @direction)
  end
  distance = (2 ** @move_speed) / Math.sqrt(2)
  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 > DOWN 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
end
#--------------------------------------------------------------------------
def move_upper_right_p
  unless @direction_fix
	@direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
  end
  distance = (2 ** @move_speed) / Math.sqrt(2)
  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 > DOWN 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
end
#--------------------------------------------------------------------------
def check_event_trigger_here(triggers, run = true)
  result = false
  if $game_system.map_interpreter.running?
	return result
  end
  for event in $game_map.events.values
	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)
  	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
#--------------------------------------------------------------------------
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
#--------------------------------------------------------------------------
def anime_update
  if @walk_anime
	@anime_count += 1.5
  elsif @step_anime
	@anime_count += 1
  end
  if @anime_count > 18 - @move_speed * 2
	if not @step_anime and @stop_count > 0
  	@pattern = @original_pattern
	else
  	@pattern = (@pattern + 1) % 4
	end
	@anime_count = 0
  end
end
#--------------------------------------------------------------------------
alias :moveto_original :moveto
def moveto(x, y)
  @revise_x = 0
  @revise_y = 0
  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 == 8) 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
#==============================================================================
class Game_Character
def update_move
  distance = 2 ** @move_speed
  if @x * 128 != @real_x and @y * 128 != @real_y and Game_Player::SLANT
	distance /= Math.sqrt(2)
  end
  if @y * 128 > @real_y
	@real_y = [@real_y + distance, @y * 128].min
  end
  if @x * 128 < @real_x
	@real_x = [@real_x - distance, @x * 128].max
  end
  if @x * 128 > @real_x
	@real_x = [@real_x + distance, @x * 128].min
  end
  if @y * 128 < @real_y
	@real_y = [@real_y - distance, @y * 128].max
  end
  if @walk_anime
	@anime_count += 1.5
  elsif @step_anime
	@anime_count += 1
  end
end
end
#==============================================================================
# Game_Event
#==============================================================================
class Game_Event < Game_Character
def start
  if @list.size > 1
	if $game_player.event != 0
  	$game_player.move_speed = $game_player.event
	end
	@starting = true
  end
end
end