Foros de Emudesc

#==============================================================================
# Game_Player
#==============================================================================

class Game_Player < Game_Character
UP    = 0                
DOWN  = 0              
SIDE  = 0              
SLANT = false            
#--------------------------------------------------------------------------
attr_reader   :event    
attr_accessor :move_speed  
#--------------------------------------------------------------------------
def update

if @move_speed == nil
@move_speed = 4
end
  if @revise_x == nil and @revise_y == nil
@revise_x = 0
@revise_y = 0
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)
   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
unless moving?
if last_moving
   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
          p 1
           turn_left
        else
           p 2
           turn_right
         end
       else
         if (last_real_y / 128.0).round > @y
           p 3
           turn_up
         else
           p 4
           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
   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
end
#--------------------------------------------------------------------------
def initialize
@revise_x = 0
@revise_y = 0
@move == false
super
end
#--------------------------------------------------------------------------
def moving?
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
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)
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 > 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
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
#--------------------------------------------------------------------------
def move_lower_right_p
unless @direction_fix
@direction = (@direction == 4 ? 6 : @direction == 8 ? 2 : @direction)
end
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 > 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
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
@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 > 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
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
#--------------------------------------------------------------------------
def move_upper_right_p
unless @direction_fix
@direction = (@direction == 4 ? 6 : @direction == 2 ? 8 : @direction)
end
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 > 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
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
#--------------------------------------------------------------------------
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 == ((@real_x - @revise_x) / 128.0).round and
     event.y == ((@real_y - @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
increase_steps
end
if @x > (@x + @revise_x / 128.0).round
@x -= 1
@revise_x += 128
increase_steps
end
if @x < (@x + @revise_x / 128.0).round
@x += 1
@revise_x -= 128
increase_steps
end
if @y > (@y + @revise_y / 128.0).round
@y -= 1
@revise_y += 128
increase_steps
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 = 3.5
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 == 4
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
attr_accessor  :move_speed
#--------------------------------------------------------------------------
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