# 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