Removed last possible usages of Graphics.frame_rate and Graphics.frame_count, improved screen scrolling code, player now animates walking into a wall

Data/Scripts/004_Game classes/004_Game_Map.rb

@@ -68,8 +68,8 @@ class Game_Map
     (1...$data_common_events.size).each do |i|
       @common_events[i]      = Game_CommonEvent.new(i)
     end
-    @scroll_direction        = 2
-    @scroll_rest             = 0
+    @scroll_distance_x       = 0
+    @scroll_distance_y       = 0
     @scroll_speed            = 4
   end
 
@@ -356,18 +356,42 @@ class Game_Map
     self.display_x += distance
   end
 
-  def start_scroll(direction, distance, speed)
-    @scroll_direction = direction
-    if [2, 8].include?(direction)   # down or up
-      @scroll_rest = distance * REAL_RES_Y
-    else
-      @scroll_rest = distance * REAL_RES_X
+  # speed is:
+  #   1: moves 1 tile in 1.6 seconds
+  #   2: moves 1 tile in 0.8 seconds
+  #   3: moves 1 tile in 0.4 seconds
+  #   4: moves 1 tile in 0.2 seconds
+  #   5: moves 1 tile in 0.1 seconds
+  #   6: moves 1 tile in 0.05 seconds
+  def start_scroll(direction, distance, speed = 4)
+    return if direction <= 0 || direction == 5 || direction >= 10
+    if [1, 3, 4, 6, 7, 9].include(direction)   # horizontal
+      @scroll_distance_x = distance
+      @scroll_distance_x *= -1 if [1, 4, 7].include?(direction)
+    end
+    if [1, 2, 3, 7, 8, 9].include?(direction)   # vertical
+      @scroll_distance_y = distance
+      @scroll_distance_y *= -1 if [7, 8, 9].include?(direction)
     end
     @scroll_speed = speed
+    @scroll_start_x = display_x
+    @scroll_start_y = display_y
+    @scroll_timer_start = System.uptime
+  end
+
+  # The two distances can be positive or negative.
+  def start_scroll_custom(distance_x, distance_y, speed = 4)
+    return if distance_x == 0 && distance_y == 0
+    @scroll_distance_x = distance_x
+    @scroll_distance_y = distance_y
+    @scroll_speed = speed
+    @scroll_start_x = display_x
+    @scroll_start_y = display_y
+    @scroll_timer_start = System.uptime
   end
 
   def scrolling?
-    return @scroll_rest > 0
+    return (@scroll_distance_x || 0) != 0 || (@scroll_distance_y || 0) != 0
   end
 
   # duration is time in 1/20ths of a second.
@@ -419,16 +443,17 @@ class Game_Map
       $map_factory.setCurrentMap
     end
     # If scrolling
-    if @scroll_rest > 0
-      distance = (1 << @scroll_speed) * 40.0 / Graphics.frame_rate
-      distance = @scroll_rest if distance > @scroll_rest
-      case @scroll_direction
-      when 2 then scroll_down(distance)
-      when 4 then scroll_left(distance)
-      when 6 then scroll_right(distance)
-      when 8 then scroll_up(distance)
-      end
-      @scroll_rest -= distance
+    if (@scroll_distance_x || 0) != 0
+      duration = @scroll_distance_x.abs * TILE_WIDTH.to_f / (10 * (2**@scroll_speed))
+      scroll_offset = lerp(0, @scroll_distance_x, duration, @scroll_timer_start, System.uptime)
+      self.display_x = @scroll_start_x + scroll_offset * REAL_RES_X
+      @scroll_distance_x = 0 if scroll_offset == @scroll_distance_x
+    end
+    if (@scroll_distance_y || 0) != 0
+      duration = @scroll_distance_y.abs * TILE_HEIGHT.to_f / (10 * (2**@scroll_speed))
+      scroll_offset = lerp(0, @scroll_distance_y, duration, @scroll_timer_start, System.uptime)
+      self.display_y = @scroll_start_y + scroll_offset * REAL_RES_Y
+      @scroll_distance_y = 0 if scroll_offset == @scroll_distance_y
     end
     # Only update events that are on-screen
     if !$game_temp.in_menu
@@ -463,26 +488,74 @@ end
 #===============================================================================
 #
 #===============================================================================
-def pbScrollMap(direction, distance, speed)
+# Scroll the map in the given direction by the given distance at the (optional)
+# given speed.
+def pbScrollMap(direction, distance, speed = 4)
   if speed == 0
-    case direction
-    when 2 then $game_map.scroll_down(distance * Game_Map::REAL_RES_Y)
-    when 4 then $game_map.scroll_left(distance * Game_Map::REAL_RES_X)
-    when 6 then $game_map.scroll_right(distance * Game_Map::REAL_RES_X)
-    when 8 then $game_map.scroll_up(distance * Game_Map::REAL_RES_Y)
+    if [1, 2, 3].include?(direction)
+      $game_map.scroll_down(distance * Game_Map::REAL_RES_Y)
+    elsif [7, 8, 9].include?(direction)
+      $game_map.scroll_up(distance * Game_Map::REAL_RES_Y)
+    end
+    if [3, 6, 9].include?(direction)
+      $game_map.scroll_right(distance * Game_Map::REAL_RES_X)
+    elsif [1, 4, 7].include?(direction)
+      $game_map.scroll_left(distance * Game_Map::REAL_RES_X)
     end
   else
     $game_map.start_scroll(direction, distance, speed)
-    oldx = $game_map.display_x
-    oldy = $game_map.display_y
     loop do
       Graphics.update
       Input.update
-      break if !$game_map.scrolling?
       pbUpdateSceneMap
-      break if $game_map.display_x == oldx && $game_map.display_y == oldy
-      oldx = $game_map.display_x
-      oldy = $game_map.display_y
+      break if !$game_map.scrolling?
     end
   end
 end
+
+# Scroll the map to center on the given coordinates at the (optional) given
+# speed. The scroll can happen in up to two parts, depending on where the target
+# is relative to the current location: an initial diagonal movement and a
+# following cardinal (vertical/horizontal) movement.
+def pbScrollMapTo(x, y, speed = 4)
+  if !$game_map.valid?(x, y)
+    print "pbScrollMapTo: given x,y is invalid"
+    return
+  elsif !(0..6).include?(speed)
+    print "pbScrollMapTo: invalid speed (0-6 only)"
+    return
+  end
+  # Get tile coordinates that the screen is currently scrolled to
+  screen_offset_x = (Graphics.width - Game_Map::TILE_WIDTH) * Game_Map::X_SUBPIXELS / 2
+  screen_offset_y = (Graphics.height - Game_Map::TILE_HEIGHT) * Game_Map::Y_SUBPIXELS / 2
+  current_tile_x = ($game_map.display_x + screen_offset_x) / Game_Map::REAL_RES_X
+  current_tile_y = ($game_map.display_y + screen_offset_y) / Game_Map::REAL_RES_Y
+  offset_x = x - current_tile_x
+  offset_y = y - current_tile_y
+  return if offset_x == 0 && offset_y == 0
+  if speed == 0
+    if offset_y > 0
+      $game_map.scroll_down(offset_y.abs * Game_Map::REAL_RES_Y)
+    elsif offset_y < 0
+      $game_map.scroll_up(offset_y.abs * Game_Map::REAL_RES_Y)
+    end
+    if offset_x > 0
+      $game_map.scroll_right(offset_x.abs * Game_Map::REAL_RES_X)
+    elsif offset_x < 0
+      $game_map.scroll_left(offset_x.abs * Game_Map::REAL_RES_X)
+    end
+  else
+    $game_map.start_scroll_custom(offset_x, offset_y, speed)
+    loop do
+      Graphics.update
+      Input.update
+      pbUpdateSceneMap
+      break if !$game_map.scrolling?
+    end
+  end
+end
+
+# Scroll the map to center on the player at the (optional) given speed.
+def pbScrollMapToPlayer(speed = 4)
+  pbScrollMapTo($game_player.x, $game_player.y, speed)
+end