A lot of FPS agnosticism, added def lerp

Data/Scripts/017_Minigames/001_Minigame_Duel.rb

@@ -59,7 +59,7 @@ class PokemonDuel
     @viewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
     @viewport.z = 99999
     @sprites = {}
-    @sprites["player"] = IconSprite.new(-128 - 32, 96, @viewport)
+    @sprites["player"] = IconSprite.new(-160, 96, @viewport)
     @sprites["player"].setBitmap(GameData::TrainerType.front_sprite_filename($player.trainer_type))
     @sprites["opponent"] = IconSprite.new(Graphics.width + 32, 96, @viewport)
     @sprites["opponent"].setBitmap(GameData::TrainerType.front_sprite_filename(opponent.trainer_type))
@@ -69,17 +69,17 @@ class PokemonDuel
     @sprites["opponentwindow"] = DuelWindow.new(opponent.name, true)
     @sprites["opponentwindow"].x        = Graphics.width
     @sprites["opponentwindow"].viewport = @viewport
-    pbWait(Graphics.frame_rate / 2)
-    distance_per_frame = 8 * 20 / Graphics.frame_rate
-    while @sprites["player"].x < 0
-      @sprites["player"].x         += distance_per_frame
-      @sprites["playerwindow"].x   += distance_per_frame
-      @sprites["opponent"].x       -= distance_per_frame
-      @sprites["opponentwindow"].x -= distance_per_frame
-      Graphics.update
-      Input.update
-      pbUpdateSceneMap
+    pbWait(0.5)
+    pbWait(0.5) do |delta_t|
+      @sprites["player"].x = lerp(-160, 0, 0.4, delta_t)
+      @sprites["playerwindow"].x = lerp(-@sprites["playerwindow"].width, 160 - @sprites["playerwindow"].width, 0.4, delta_t)
+      @sprites["opponent"].x = lerp(Graphics.width + 32, Graphics.width - 128, 0.4, delta_t)
+      @sprites["opponentwindow"].x = lerp(Graphics.width, Graphics.width - 160, 0.4, delta_t)
     end
+    @sprites["player"].x = 0
+    @sprites["playerwindow"].x = 160 - @sprites["playerwindow"].width
+    @sprites["opponent"].x = Graphics.width - 128
+    @sprites["opponentwindow"].x = Graphics.width - 160
     @oldmovespeed = $game_player.move_speed
     @oldeventspeed = event.move_speed
     pbMoveRoute($game_player,
@@ -88,7 +88,7 @@ class PokemonDuel
     pbMoveRoute(event,
                 [PBMoveRoute::CHANGE_SPEED, 2,
                  PBMoveRoute::DIRECTION_FIX_ON])
-    pbWait(Graphics.frame_rate * 3 / 4)
+    pbWait(0.75)
   end
 
   def pbDuel(opponent, event, speeches)
@@ -146,13 +146,13 @@ class PokemonDuel
                      PBMoveRoute::SCRIPT_ASYNC, "moveRight90",
                      PBMoveRoute::SCRIPT_ASYNC, "moveRight90",
                      PBMoveRoute::SCRIPT_ASYNC, "moveLeft90"])
-        pbWait(Graphics.frame_rate / 2)
+        pbWait(0.5)
         pbMessage(_INTL("You study each other's movements..."))
       elsif action == 0 && command == 1
         pbMoveRoute($game_player,
                     [PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::FORWARD])
-        pbWait(Graphics.frame_rate * 4 / 10)
+        pbWait(0.4)
         pbShake(9, 9, 8)
         pbFlashScreens(false, true)
         pbMoveRoute($game_player,
@@ -167,7 +167,7 @@ class PokemonDuel
         pbMoveRoute(event,
                     [PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::BACKWARD])
-        pbWait(Graphics.frame_rate)
+        pbWait(1.0)
         pbMoveRoute($game_player,
                     [PBMoveRoute::CHANGE_SPEED, 2,
                      PBMoveRoute::BACKWARD])
@@ -179,12 +179,12 @@ class PokemonDuel
         pbMoveRoute($game_player,
                     [PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::SCRIPT_ASYNC, "jumpForward"])
-        pbWait(Graphics.frame_rate * 4 / 10)
+        pbWait(0.4)
         pbMoveRoute(event,
                     [PBMoveRoute::CHANGE_SPEED, 5,
                      PBMoveRoute::BACKWARD,
                      PBMoveRoute::CHANGE_SPEED, 2])
-        pbWait(Graphics.frame_rate / 2)
+        pbWait(0.5)
         pbShake(9, 9, 8)
         pbFlashScreens(false, true)
         pbMoveRoute($game_player,
@@ -199,7 +199,7 @@ class PokemonDuel
         pbMoveRoute(event,
                     [PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::FORWARD])
-        pbWait(Graphics.frame_rate * 4 / 10)
+        pbWait(0.4)
         pbShake(9, 9, 8)
         pbFlashScreens(true, false)
         pbMoveRoute(event,
@@ -211,17 +211,17 @@ class PokemonDuel
         pbMoveRoute($game_player,
                     [PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::FORWARD])
-        pbWait(Graphics.frame_rate * 6 / 10)
+        pbWait(0.6)
         pbMoveRoute($game_player,
                     [PBMoveRoute::CHANGE_SPEED, 2,
                      PBMoveRoute::BACKWARD])
         pbMoveRoute(event,
                     [PBMoveRoute::CHANGE_SPEED, 2,
                      PBMoveRoute::FORWARD])
-        pbWait(Graphics.frame_rate * 6 / 10)
+        pbWait(0.6)
         pbMoveRoute(event, [PBMoveRoute::BACKWARD])
         pbMoveRoute($game_player, [PBMoveRoute::FORWARD])
-        pbWait(Graphics.frame_rate * 6 / 10)
+        pbWait(0.6)
         pbMoveRoute($game_player, [PBMoveRoute::BACKWARD])
         pbMessage(_INTL("You cross blades with the opponent!"))
       elsif (action == 1 && command == 2) ||
@@ -231,11 +231,11 @@ class PokemonDuel
                     [PBMoveRoute::BACKWARD,
                      PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::SCRIPT_ASYNC, "jumpForward"])
-        pbWait(Graphics.frame_rate * 8 / 10)
+        pbWait(0.8)
         pbMoveRoute(event,
                     [PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::FORWARD])
-        pbWait(Graphics.frame_rate * 9 / 10)
+        pbWait(0.9)
         pbShake(9, 9, 8)
         pbFlashScreens(true, true)
         pbMoveRoute($game_player,
@@ -245,7 +245,7 @@ class PokemonDuel
                     [PBMoveRoute::BACKWARD,
                      PBMoveRoute::BACKWARD,
                      PBMoveRoute::CHANGE_SPEED, 2])
-        pbWait(Graphics.frame_rate)
+        pbWait(1.0)
         pbMoveRoute(event, [PBMoveRoute::FORWARD])
         pbMoveRoute($game_player, [PBMoveRoute::FORWARD])
         @hp[0] -= action    # Enemy action
@@ -258,7 +258,7 @@ class PokemonDuel
         pbMoveRoute($game_player,
                     [PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::SCRIPT_ASYNC, "jumpBackward"])
-        pbWait(Graphics.frame_rate)
+        pbWait(1.0)
         pbMoveRoute($game_player,
                     [PBMoveRoute::CHANGE_SPEED, 2,
                      PBMoveRoute::FORWARD])
@@ -270,12 +270,12 @@ class PokemonDuel
         pbMoveRoute(event,
                     [PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::SCRIPT_ASYNC, "jumpForward"])
-        pbWait(Graphics.frame_rate * 4 / 10)
+        pbWait(0.4)
         pbMoveRoute($game_player,
                     [PBMoveRoute::CHANGE_SPEED, 5,
                      PBMoveRoute::BACKWARD,
                      PBMoveRoute::CHANGE_SPEED, 2])
-        pbWait(Graphics.frame_rate / 2)
+        pbWait(0.5)
         pbShake(9, 9, 8)
         pbFlashScreens(true, false)
         pbMoveRoute($game_player,
@@ -295,7 +295,7 @@ class PokemonDuel
                     [PBMoveRoute::WAIT, 15,
                      PBMoveRoute::CHANGE_SPEED, 4,
                      PBMoveRoute::SCRIPT_ASYNC, "jumpForward"])
-        pbWait(Graphics.frame_rate)
+        pbWait(1.0)
         pbMoveRoute(event,
                     [PBMoveRoute::CHANGE_SPEED, 5,
                      PBMoveRoute::BACKWARD,
@@ -318,69 +318,60 @@ class PokemonDuel
   end
 
   def pbEndDuel
-    pbWait(Graphics.frame_rate * 3 / 4)
+    pbWait(0.75)
     pbMoveRoute($game_player,
                 [PBMoveRoute::DIRECTION_FIX_OFF,
                  PBMoveRoute::CHANGE_SPEED, @oldmovespeed])
     pbMoveRoute(@event,
                 [PBMoveRoute::DIRECTION_FIX_OFF,
                  PBMoveRoute::CHANGE_SPEED, @oldeventspeed])
-    fade_time = Graphics.frame_rate * 4 / 10
-    alpha_diff = (255.0 / fade_time).ceil
-    fade_time.times do
-      @sprites["player"].opacity                  -= alpha_diff
-      @sprites["opponent"].opacity                -= alpha_diff
-      @sprites["playerwindow"].contents_opacity   -= alpha_diff
-      @sprites["opponentwindow"].contents_opacity -= alpha_diff
-      @sprites["playerwindow"].opacity            -= alpha_diff
-      @sprites["opponentwindow"].opacity          -= alpha_diff
-      Graphics.update
-      Input.update
-      pbUpdateSceneMap
+    pbWait(0.4) do |delta_t|
+      new_opacity = lerp(255, 0, 0.4, delta_t)
+      @sprites["player"].opacity = new_opacity
+      @sprites["opponent"].opacity = new_opacity
+      @sprites["playerwindow"].contents_opacity = new_opacity
+      @sprites["opponentwindow"].contents_opacity = new_opacity
+      @sprites["playerwindow"].opacity = new_opacity
+      @sprites["opponentwindow"].opacity = new_opacity
     end
     pbDisposeSpriteHash(@sprites)
     @viewport.dispose
   end
 
   def pbFlashScreens(player, opponent)
-    i = 0
-    flash_time = Graphics.frame_rate * 2 / 10
-    alpha_diff = (2 * 255.0 / flash_time).ceil
-    flash_time.times do
-      i += 1
+    pbWait(0.2) do |delta_t|
+      new_alpha = lerp(0, 255, 0.2, delta_t)
       if player
-        @sprites["player"].color       = Color.new(255, 255, 255, i * alpha_diff)
-        @sprites["playerwindow"].color = Color.new(255, 255, 255, i * alpha_diff)
+        @sprites["player"].color = Color.new(255, 255, 255, new_alpha)
+        @sprites["playerwindow"].color = Color.new(255, 255, 255, new_alpha)
       end
       if opponent
-        @sprites["opponent"].color       = Color.new(255, 255, 255, i * alpha_diff)
-        @sprites["opponentwindow"].color = Color.new(255, 255, 255, i * alpha_diff)
+        @sprites["opponent"].color = Color.new(255, 255, 255, new_alpha)
+        @sprites["opponentwindow"].color = Color.new(255, 255, 255, new_alpha)
       end
-      Graphics.update
-      Input.update
-      pbUpdateSceneMap
     end
-    flash_time.times do
-      i -= 1
+    pbWait(0.2) do |delta_t|
+      new_alpha = lerp(255, 0, 0.2, delta_t)
       if player
-        @sprites["player"].color       = Color.new(255, 255, 255, i * alpha_diff)
-        @sprites["playerwindow"].color = Color.new(255, 255, 255, i * alpha_diff)
+        @sprites["player"].color = Color.new(255, 255, 255, new_alpha)
+        @sprites["playerwindow"].color = Color.new(255, 255, 255, new_alpha)
       end
       if opponent
-        @sprites["opponent"].color       = Color.new(255, 255, 255, i * alpha_diff)
-        @sprites["opponentwindow"].color = Color.new(255, 255, 255, i * alpha_diff)
+        @sprites["opponent"].color = Color.new(255, 255, 255, new_alpha)
+        @sprites["opponentwindow"].color = Color.new(255, 255, 255, new_alpha)
       end
-      Graphics.update
-      Input.update
-      pbUpdateSceneMap
     end
-    pbWait(Graphics.frame_rate * 4 / 10) if !player || !opponent
+    @sprites["player"].color.alpha = 0
+    @sprites["playerwindow"].color.alpha = 0
+    @sprites["opponent"].color.alpha = 0
+    @sprites["opponentwindow"].color.alpha = 0
+    pbWait(0.4) if !player || !opponent
   end
 
   def pbRefresh
     @sprites["playerwindow"].hp   = @hp[0]
     @sprites["opponentwindow"].hp = @hp[1]
-    pbWait(Graphics.frame_rate / 4)
+    pbWait(0.25)
   end
 end
 

Data/Scripts/017_Minigames/004_Minigame_VoltorbFlip.rb

@@ -265,7 +265,7 @@ class VoltorbFlip
           end
         end
         pbDrawImagePositions(@sprites["mark"].bitmap, @marks)
-        pbWait(Graphics.frame_rate / 20)
+        pbWait(0.05)
       else
         # Display the tile for the selected spot
         icons = []
@@ -283,7 +283,7 @@ class VoltorbFlip
                 animation[0] = icons[0] = [@directory + "tiles", (@index[0] * 64) + 128, @index[1] * 64,
                                            704 + (64 * j), 0, 64, 64]
                 pbDrawImagePositions(@sprites["animation"].bitmap, animation)
-                pbWait(Graphics.frame_rate / 20)
+                pbWait(0.05)
                 @sprites["animation"].bitmap.clear
               end
               # Part2
@@ -292,7 +292,7 @@ class VoltorbFlip
                 animation[0] = [@directory + "explosion", (@index[0] * 64) - 32 + 128, (@index[1] * 64) - 32,
                                 j * 128, 0, 128, 128]
                 pbDrawImagePositions(@sprites["animation"].bitmap, animation)
-                pbWait(Graphics.frame_rate / 10)
+                pbWait(0.1)
                 @sprites["animation"].bitmap.clear
               end
               # Unskippable text block, parameter 2 = wait time (corresponds to ME length)
@@ -334,7 +334,7 @@ class VoltorbFlip
                 animation[0] = [@directory + "flipAnimation", (@index[0] * 64) - 14 + 128, (@index[1] * 64) - 16,
                                 j * 92, 0, 92, 96]
                 pbDrawImagePositions(@sprites["animation"].bitmap, animation)
-                pbWait(Graphics.frame_rate / 20)
+                pbWait(0.05)
                 @sprites["animation"].bitmap.clear
               end
               if @points == 0
@@ -474,7 +474,7 @@ class VoltorbFlip
       points = tile if i == 2
       icons[i] = [@directory + "tiles", x, y, 320 + (i * 64) + (points * 64), 0, 64, 64]
       pbDrawImagePositions(@sprites["icon"].bitmap, icons)
-      pbWait(Graphics.frame_rate / 20)
+      pbWait(0.05)
     end
     icons[3] = [@directory + "tiles", x, y, tile * 64, 0, 64, 64]
     pbDrawImagePositions(@sprites["icon"].bitmap, icons)
@@ -485,14 +485,14 @@ class VoltorbFlip
     # Make pre-rendered sprites visible (this approach reduces lag)
     5.times do |i|
       @sprites[i].visible = true
-      pbWait(Graphics.frame_rate / 20) if i < 3
+      pbWait(0.05) if i < 3
       @sprites[i].bitmap.clear
       @sprites[i].z = 99997
     end
     pbSEPlay("Voltorb Flip tile")
     @sprites[5].visible = true
     @sprites["mark"].bitmap.clear
-    pbWait(Graphics.frame_rate / 10)
+    pbWait(0.1)
     # Wait for user input to continue
     loop do
       Graphics.update
@@ -511,22 +511,22 @@ class VoltorbFlip
                     448 + (@squares[i + (j * 5)][2] * 64), 0, 64, 64]
       end
       pbDrawImagePositions(@sprites[i].bitmap, icons)
-      pbWait(Graphics.frame_rate / 20)
+      pbWait(0.05)
       5.times do |j|
         icons[j] = [@directory + "tiles", @squares[i + (j * 5)][0], @squares[i + (j * 5)][1], 384, 0, 64, 64]
       end
       pbDrawImagePositions(@sprites[i].bitmap, icons)
-      pbWait(Graphics.frame_rate / 20)
+      pbWait(0.05)
       5.times do |j|
         icons[j] = [@directory + "tiles", @squares[i + (j * 5)][0], @squares[i + (j * 5)][1], 320, 0, 64, 64]
       end
       pbDrawImagePositions(@sprites[i].bitmap, icons)
-      pbWait(Graphics.frame_rate / 20)
+      pbWait(0.05)
       5.times do |j|
         icons[j] = [@directory + "tiles", @squares[i + (j * 5)][0], @squares[i + (j * 5)][1], 896, 0, 64, 64]
       end
       pbDrawImagePositions(@sprites[i].bitmap, icons)
-      pbWait(Graphics.frame_rate / 20)
+      pbWait(0.05)
     end
     @sprites["icon"].bitmap.clear
     6.times do |i|
@@ -538,9 +538,7 @@ class VoltorbFlip
 #  def pbWaitText(msg,frames)
 #    msgwindow=pbCreateMessageWindow
 #    pbMessageDisplay(msgwindow,msg)
-#    frames.times do
-#      pbWait(1)
-#    end
+#    pbWait(frames / 20.0)
 #    pbDisposeMessageWindow(msgwindow)
 #  end
 

Data/Scripts/017_Minigames/006_Minigame_Mining.rb

@@ -530,12 +530,12 @@ class MiningGameScene
         collapseviewport = Viewport.new(0, 0, Graphics.width, Graphics.height)
         collapseviewport.z = 99999
         @sprites["collapse"] = BitmapSprite.new(Graphics.width, Graphics.height, collapseviewport)
-        collapseTime = Graphics.frame_rate * 8 / 10
-        collapseFraction = (Graphics.height.to_f / collapseTime).ceil
-        (1..collapseTime).each do |i|
-          @sprites["collapse"].bitmap.fill_rect(0, collapseFraction * (i - 1),
-                                                Graphics.width, collapseFraction * i, Color.black)
+        timer_start = System.uptime
+        loop do
+          collapse_height = lerp(0, Graphics.height, 0.8, timer_start, System.uptime)
+          @sprites["collapse"].bitmap.fill_rect(0, 0, Graphics.width, collapse_height, Color.black)
           Graphics.update
+          break if collapse_height == Graphics.height
         end
         pbMessage(_INTL("The wall collapsed!"))
         break
@@ -547,7 +547,7 @@ class MiningGameScene
       end
       if foundall
         @sprites["cursor"].visible = false
-        pbWait(Graphics.frame_rate * 3 / 4)
+        pbWait(0.75)
         pbSEPlay("Mining found all")
         pbMessage(_INTL("Everything was dug up!"))
         break

Data/Scripts/017_Minigames/007_Minigame_TilePuzzles.rb

@@ -309,17 +309,16 @@ class TilePuzzleScene
       if anim
         @sprites["cursor"].visible = false
         @sprites["tile#{@heldtile}"].z = 1
-        oldAngle = @sprites["tile#{@heldtile}"].angle
-        rotateTime = Graphics.frame_rate / 4
-        angleDiff = 90.0 / rotateTime
-        rotateTime.times do
-          @sprites["tile#{@heldtile}"].angle -= angleDiff
+        old_angle = @sprites["tile#{@heldtile}"].angle
+        timer_start = System.uptime
+        loop do
+          @sprites["tile#{@heldtile}"].angle = lerp(old_angle, old_angle - 90, 0.25, timer_start, System.uptime)
           pbUpdateSpriteHash(@sprites)
           Graphics.update
           Input.update
+          break if @sprites["tile#{@heldtile}"].angle == old_angle - 90
         end
         @sprites["tile#{@heldtile}"].z = 0
-        @sprites["tile#{@heldtile}"].angle = oldAngle - 90
         @sprites["cursor"].visible = true if !pbCheckWin
       end
       @angles[@heldtile] -= 1
@@ -329,24 +328,23 @@ class TilePuzzleScene
       group = pbGetNearTiles(pos)
       if anim
         @sprites["cursor"].visible = false
-        oldAngles = []
+        old_angles = []
         group.each do |i|
           @sprites["tile#{@tiles[i]}"].z = 1
-          oldAngles[i] = @sprites["tile#{@tiles[i]}"].angle
+          old_angles.push(@sprites["tile#{@tiles[i]}"].angle)
         end
-        rotateTime = Graphics.frame_rate / 4
-        angleDiff = 90.0 / rotateTime
-        rotateTime.times do
-          group.each do |i|
-            @sprites["tile#{@tiles[i]}"].angle -= angleDiff
+        timer_start = System.uptime
+        loop do
+          group.each_with_index do |idx, i|
+            @sprites["tile#{@tiles[idx]}"].angle = lerp(old_angles[i], old_angles[i] - 90, 0.25, timer_start, System.uptime)
           end
           pbUpdateSpriteHash(@sprites)
           Graphics.update
           Input.update
+          break if @sprites["tile#{@tiles[group[0]]}"].angle == old_angles[0] - 90
         end
         group.each do |i|
           @sprites["tile#{@tiles[i]}"].z = 0
-          @sprites["tile#{@tiles[i]}"].angle = oldAngles[i] - 90
         end
         @sprites["cursor"].visible = true if !pbCheckWin
       end
@@ -374,26 +372,33 @@ class TilePuzzleScene
     movetile = pbMoveCursor(cursor, dir)
     @sprites["cursor"].visible = false
     @sprites["tile#{@tiles[cursor]}"].z = 1
-    swapTime = Graphics.frame_rate * 3 / 10
+    duration = 0.3
+    timer_start = System.uptime
     if [2, 8].include?(dir)   # Swap vertically
-      distancePerFrame = (@tileheight.to_f / swapTime).ceil
+      start_sprite_pos = @sprites["tile#{@tiles[movetile]}"].y
+      start_cursor_pos = @sprites["tile#{@tiles[cursor]}"].y
       dist = (dir / 4).floor - 1
-      swapTime.times do
-        @sprites["tile#{@tiles[movetile]}"].y += dist * distancePerFrame
-        @sprites["tile#{@tiles[cursor]}"].y   -= dist * distancePerFrame
+      loop do
+        delta_y = lerp(0, @tileheight * dist, duration, timer_start, System.uptime)
+        @sprites["tile#{@tiles[movetile]}"].y = start_sprite_pos + delta_y
+        @sprites["tile#{@tiles[cursor]}"].y = start_cursor_pos - delta_y
         pbUpdateSpriteHash(@sprites)
         Graphics.update
         Input.update
+        break if @sprites["tile#{@tiles[movetile]}"].y == start_sprite_pos + @tileheight * dist
       end
     else   # Swap horizontally
-      distancePerFrame = (@tilewidth.to_f / swapTime).ceil
+      start_sprite_pos = @sprites["tile#{@tiles[movetile]}"].x
+      start_cursor_pos = @sprites["tile#{@tiles[cursor]}"].x
       dist = dir - 5
-      swapTime.times do
-        @sprites["tile#{@tiles[movetile]}"].x -= dist * distancePerFrame
-        @sprites["tile#{@tiles[cursor]}"].x   += dist * distancePerFrame
+      loop do
+        delta_x = lerp(0, @tilewidth * dist, duration, timer_start, System.uptime)
+        @sprites["tile#{@tiles[movetile]}"].x = start_sprite_pos - delta_x
+        @sprites["tile#{@tiles[cursor]}"].x = start_cursor_pos + delta_x
         pbUpdateSpriteHash(@sprites)
         Graphics.update
         Input.update
+        break if @sprites["tile#{@tiles[movetile]}"].x == start_sprite_pos - @tilewidth * dist
       end
     end
     @tiles[cursor], @tiles[movetile] = @tiles[movetile], @tiles[cursor]
@@ -428,35 +433,42 @@ class TilePuzzleScene
       end
     end
     # Shift tiles
-    fadeTime = Graphics.frame_rate * 4 / 10
-    fadeDiff = (255.0 / fadeTime).ceil
+    fade_duration = 0.4
     if anim
       @sprites["cursor"].visible = false
-      fadeTime.times do
-        @sprites["tile#{@tiles[tiles[tiles.length - 1]]}"].opacity -= fadeDiff
+      timer_start = System.uptime
+      loop do
+        end_tile = @sprites["tile#{@tiles[tiles[tiles.length - 1]]}"]
+        end_tile.opacity = lerp(255, 0, fade_duration, timer_start, System.uptime)
         Graphics.update
         Input.update
+        break if end_tile.opacity == 0
       end
-      shiftTime = Graphics.frame_rate * 3 / 10
+      duration = 0.3
+      timer_start = System.uptime
       if [2, 8].include?(dir)
-        distancePerFrame = (@tileheight.to_f / shiftTime).ceil
-        shiftTime.times do
-          tiles.each do |i|
-            @sprites["tile#{@tiles[i]}"].y -= dist * distancePerFrame
+        start_pos = []
+        tiles.each { |i| start_pos.push(@sprites["tile#{@tiles[i]}"].y) }
+        loop do
+          tiles.each_with_index do |idx, i|
+            @sprites["tile#{@tiles[idx]}"].y = lerp(start_pos[i], start_pos[i] - @tileheight * dist, duration, timer_start, System.uptime)
           end
           pbUpdateSpriteHash(@sprites)
           Graphics.update
           Input.update
+          break if @sprites["tile#{@tiles[tiles[0]]}"].y == start_pos[0] - @tileheight * dist
         end
       else
-        distancePerFrame = (@tilewidth.to_f / shiftTime).ceil
-        shiftTime.times do
-          tiles.each do |i|
-            @sprites["tile#{@tiles[i]}"].x += dist * distancePerFrame
+        start_pos = []
+        tiles.each { |i| start_pos.push(@sprites["tile#{@tiles[i]}"].x) }
+        loop do
+          tiles.each_with_index do |idx, i|
+            @sprites["tile#{@tiles[idx]}"].x = lerp(start_pos[i], start_pos[i] + @tilewidth * dist, duration, timer_start, System.uptime)
           end
           pbUpdateSpriteHash(@sprites)
           Graphics.update
           Input.update
+          break if @sprites["tile#{@tiles[tiles[0]]}"].x == start_pos[0] + @tilewidth * dist
         end
       end
     end
@@ -469,10 +481,13 @@ class TilePuzzleScene
     end
     if anim
       update
-      fadeTime.times do
-        @sprites["tile#{@tiles[tiles[0]]}"].opacity += fadeDiff
+      timer_start = System.uptime
+      loop do
+        end_tile = @sprites["tile#{@tiles[tiles[0]]}"]
+        end_tile.opacity = lerp(0, 255, fade_duration, timer_start, System.uptime)
         Graphics.update
         Input.update
+        break if end_tile.opacity == 255
       end
       @sprites["cursor"].selected = false
       @sprites["cursor"].visible = true if !pbCheckWin
@@ -509,15 +524,15 @@ class TilePuzzleScene
                                Rect.new(@tilewidth * (@boardwidth - 1), @tileheight * (@boardheight - 1),
                                         @tilewidth, @tileheight))
           extratile.opacity = 0
-          appearTime = Graphics.frame_rate * 8 / 10
-          opacityDiff = (255.0 / appearTime).ceil
-          appearTime.times do
-            extratile.opacity += opacityDiff
+          timer_start = System.uptime
+          loop do
+            extratile.opacity = lerp(0, 255, 0.8, timer_start, System.uptime)
             Graphics.update
             Input.update
+            break if extratile.opacity >= 255
           end
         else
-          pbWait(Graphics.frame_rate / 2)
+          pbWait(0.5)
         end
         loop do
           Graphics.update