[RGSS/2/3] Drago - Transition Pack

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
# Drago Transition Pack
# Version: 1.05
# Author : LiTTleDRAgo
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#
#  How to Use :
#
#  DragoTransition.start(scene, method, *args)
#   - scene =  "Scene_Something.new(0)" # Note : (as a string)
#
#   - method =                          # Note : (as a symbol)
#            :zoom_in         :explode
#            :zoom_out        :explode_cp
#            :shred_h         :transpose
#            :shred_v         :shutter
#            :fade            :drop_off
#
#            :ff_IV_style     :double_zoom
#            :downward_spiral :uncover
#            :blackhole       :frost      **
#            :wave_distort    :pixelate   **
#            :radial_break
#
#   - args   = *args of the method
#
#        ** Very time consuming
#          Don't try it without WhiteFlute's Bitmap-EX script
#
# You can also use the transition in the current scene by using
#   DragoTransition.start(:method)
#   DragoTransition.start([:method,*args])
#   DragoTransition.start([[:method,*args],[:method,*args],....])
#
#==============================================================================
($imported ||= {})[:drg_transition_pack] = 1.05

text = "This script needs Drago - Core Engine ver 1.32 or above"
($imported[:drg_core_engine] || 0) >= 1.32 || raise(text)

#==============================================================================
# ** Graphics
#------------------------------------------------------------------------------
#
#==============================================================================
module Graphics
  #----------------------------------------------------------------------------
  # ● class << self
  #----------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # ● Alias Method
    #--------------------------------------------------------------------------
    alias_sec_method :drg_transition_pack_transition, :transition
    #--------------------------------------------------------------------------
    # ● transition
    #--------------------------------------------------------------------------
    def transition(*args)
      if $skip_trans
        DragoTransition.drg_transition_start_phase2(*$skip_trans)
        args[0] = 0
        $skip_trans = nil
      end
      drg_transition_pack_transition(*args)
    end
    #--------------------------------------------------------------------------
    # ● drg_transition_start_phase1
    #--------------------------------------------------------------------------
    def drg_transition_start_phase1(show_next,reserve,type,args,bitmap,scene)
      $skip_trans = [show_next,reserve,type,args,bitmap,scene]
      freeze
      scene ? LiTTleDRAgo.scene = eval(scene) : transition
    end
  end
end

#==============================================================================
# ** DragoTransition
#------------------------------------------------------------------------------
#
#==============================================================================
class DragoTransition
  #----------------------------------------------------------------------------
  # ● Constant
  #----------------------------------------------------------------------------
  Explosion_Sound = nil
  Clink_Sound     = nil
  #----------------------------------------------------------------------------
  # ● class << self
  #----------------------------------------------------------------------------
  class << self
    #--------------------------------------------------------------------------
    # ● Start
    #--------------------------------------------------------------------------
    def start(show_next = true,type = nil,*args)
      show_next = [show_next] unless show_next.is_a?(Array)
      @show_next = show_next.shift
      @reserve = show_next
      @type = type
      @args = args
      if @type.nil?
        if @show_next.is_a?(Array)
          @type      = @show_next.at(0)
          @args      = @show_next.at(1)
          @show_next = @reserve.shift
        elsif @show_next.is_a?(Symbol)
          @type      = @show_next
          @args      = []
          unless @reserve.first.is_a?(Symbol)
            @args.concat(@reserve)
            @reserve.clear
          end
          @show_next = @reserve.shift
        else
          @type      = :fade
          @args      = []
        end
      end
      Graphics.update
      @bitmap = Graphics.snap_to_bitmap
      change_scene
      Graphics.drg_transition_start_phase1(@show_next,@reserve,@type,
          @args,@bitmap,@scene)
    end
    #--------------------------------------------------------------------------
    # ● drg_transition_start_phase2
    #--------------------------------------------------------------------------
    def drg_transition_start_phase2(show_next,reserve,type,args,bitmap,scene)
      @show_next = show_next
      @reserve = reserve
      @type = type
      @args = args
      @bitmap = bitmap
      @scene = scene
      create_sprite
      perform_transition
      execute_transition(@type, *@args)
      graphics_freeze unless is_a_true?
      forced_freeze if $forced_freeze
      terminate
      execute_reserve unless is_a_true?
    end
    #--------------------------------------------------------------------------
    # ● is_a_true?
    #--------------------------------------------------------------------------
    def is_a_true?
      (@show_next || true).is_a?(TrueClass)
    end
    #--------------------------------------------------------------------------
    # ● is_a_scene?
    #--------------------------------------------------------------------------
    def is_a_scene?
      @show_next::method_defined?(:main) rescue false
    end
    #--------------------------------------------------------------------------
    # ● change_scene
    #--------------------------------------------------------------------------
    def change_scene
      @scene = nil
      if is_a_scene?
        @scene = "#{@show_next.new}"
      elsif "#{@show_next}".scan(/.new/i).flatten != []
        @scene = "#{@show_next}"
      end
    end
    #--------------------------------------------------------------------------
    # ● Create Sprite
    #--------------------------------------------------------------------------
    def create_sprite
      @spriteviewport       = Viewport.new(0,0,Graphics.width,Graphics.height)
      @spriteviewport.z     = 0x3FFFFFFF
      @sprite = Sprite.new(@spriteviewport)
      if @bitmap.is_a?(Bitmap) && @bitmap.not.disposed?
        @sprite.bitmap = @bitmap
      else
        @sprite.bitmap = Graphics.snap_to_bitmap
      end
      @show_back = Sprite.new
      unless @show_next
        @show_back.bitmap = @sprite.bitmap.clone
        @show_back.bitmap.fill_rect(@show_back.bitmap.rect,Color.new(0,0,0))
      end
      if @show_next.is_a?(Bitmap)
        @show_back.bitmap = @show_next.clone
        @show_next.dispose
        @show_next = true
      end
      @sprite.x = @sprite.ox = @sprite.bitmap.width / 2
      @sprite.y = @sprite.oy = @sprite.bitmap.height / 2
      @sprite.z = 100000
    end
    #--------------------------------------------------------------------------
    # ● perform_transition
    #--------------------------------------------------------------------------
    def perform_transition
      Graphics.drg_transition_pack_transition(10)
    end
    #--------------------------------------------------------------------------
    # ● execute_transition
    #--------------------------------------------------------------------------
    def execute_transition(type, *args)
      send(type, *args)
    end
    #--------------------------------------------------------------------------
    # ● graphics_freeze
    #--------------------------------------------------------------------------
    def graphics_freeze
      Graphics.freeze
    end
    #--------------------------------------------------------------------------
    # ● forced_freeze
    #--------------------------------------------------------------------------
    def forced_freeze
      graphics_freeze
      $forced_freeze = nil
    end
    #--------------------------------------------------------------------------
    # ● terminate
    #--------------------------------------------------------------------------
    def terminate
      all_variable_dispose
    end
    #--------------------------------------------------------------------------
    # ● execute_reserve
    #--------------------------------------------------------------------------
    def execute_reserve
      if @show_next.is_a?(Array)
        show_next = @show_next.shift
        DragoTransition.start(@reserve,show_next,*@show_next)
      elsif @show_next.is_a?(Symbol)
        DragoTransition.start(@reserve.empty? || @reserve,@show_next)
      else
        perform_transition
      end
    end
    #--------------------------------------------------------------------------
    # ● play_se
    #--------------------------------------------------------------------------
    def play_se(filename, pitch=nil, volume=nil)
      se = RPG::AudioFile.new(filename)
      se.pitch  = pitch unless pitch.nil?
      se.volume = volume unless volume.nil?
      $game_system.se_play(se)
    end

    #==========================================================================
    #::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    # ** Effect Library
    #::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
    #==========================================================================

    #--------------------------------------------------------------------------
    # * Pixelate
    #     frames : Effect duration in frames
    #--------------------------------------------------------------------------
    def pixelate(frames=20)
      # Change bitmap to pixelate
      frames.times do
        @sprite.pixelate!
        Graphics.update
      end
      unit_opacity = (255.0 / frames).ceil
      frames.times do
        @sprite.opacity -= unit_opacity
        Graphics.update
      end
    end
    #--------------------------------------------------------------------------
    # * Frost
    #     frames : Effect duration in frames
    #--------------------------------------------------------------------------
    def frost(frames=20)
      # Change bitmap to frost
      frames.times do
        @sprite.frost!
        Graphics.update
      end
      unit_opacity = (255.0 / frames).ceil
      frames.times do
        @sprite.opacity -= unit_opacity
        Graphics.update
      end
    end
    #--------------------------------------------------------------------------
    # * Double Zoom
    #     frames : Effect duration in frames
    #   zoom1 : The max amount the screen zooms stage 1
    #   zoom2 : The max amount the screen zooms stage 2
    #--------------------------------------------------------------------------
    def double_zoom(frames = 30, zoom1 = 12, zoom2 = 32)
      # Calculate the stages. Account for final zoom being longer.
      stage3 = (frames * (zoom1.to_f / zoom2)).round
      stages = [(frames - stage3) / 2, (frames - stage3) / 2, stage3]
      # Calculate the zoom rates to apply each frame, for each stage.
      zoom_rates, opacity_rate = [zoom1-1, -zoom1+1, zoom2], (255 / frames.to_f)
      zoom_rates.each_index {|i| zoom_rates[i] /= stages[i].to_f }
      # Initialize local variable to keep track of current stage being executed.
      current_stage = 0
      3.times do
        # Iterate each stage, using the calculated rates for each one.
        stages[current_stage].times do
          @sprite.zoom_x += zoom_rates[current_stage]
          @sprite.zoom_y += zoom_rates[current_stage]
          @sprite.opacity -= opacity_rate
          Graphics.update
        end
        current_stage += 1
      end
    end
    #--------------------------------------------------------------------------
    # * Zoom In
    #     frames : Effect duration in frames
    #   max_zoom : The max amount the screen zooms out
    #--------------------------------------------------------------------------
    def zoom_in(frames=20, max_zoom=12)
      # Calculate difference b/w current and target
      # zooms (1 and max_zoom)
      zoom_diff = max_zoom - 1
      # Calculate unit values
      unit_zoom = zoom_diff.to_f / frames
      unit_opacity = (255.0 / frames).ceil
      # Apply unit values to sprite
      frames.times do
        @sprite.zoom_x += unit_zoom
        @sprite.zoom_y += unit_zoom
        @sprite.opacity -= unit_opacity
        Graphics.update
      end
    end
    #--------------------------------------------------------------------------
    # * Zoom Out
    #     frames : Effect duration in frames
    #--------------------------------------------------------------------------
    def zoom_out(frames=20)
      # Calculate unit values
      unit_zoom = 1.0 / frames
      unit_opacity = (255.0 / frames).ceil
      # Apply unit values to sprite
      frames.times do
        @sprite.zoom_x -= unit_zoom
        @sprite.zoom_y -= unit_zoom
        @sprite.opacity -= unit_opacity
        Graphics.update
      end
    end
    #--------------------------------------------------------------------------
    # * Shred Horizontal
    #      thickness : Shred thickness
    #       slowness : How slow the screens move out
    #    start_speed : Speed of first step in pixels
    #--------------------------------------------------------------------------
    def shred_h(thickness=4, slowness=4, start_speed=8)
      t = thickness
      # Shred screen
      sprite2 = Sprite.new(@sprite.viewport)
      sprite2.bitmap = Bitmap.new(@sprite.bitmap.width, @sprite.bitmap.height)
      sprite2.x = sprite2.ox = sprite2.bitmap.width / 2
      sprite2.y = sprite2.oy = sprite2.bitmap.height / 2
      for i in 0..(480/t)
        sprite2.bitmap.blt(0, i*t*2, @sprite.bitmap, Rect.new(0, i*t*2, 640, t))
        @sprite.bitmap.fill_rect(0, i*t*2, 640, t, Color.new(0, 0, 0, 0))
      end
      # Make sure starting step is not zero
      start_speed = slowness if start_speed < slowness
      # Move sprites
      dist = 640 - @sprite.x + start_speed
      loop do
        x_diff = (dist - (640 - @sprite.x)) / slowness
        @sprite.x += x_diff
        sprite2.x -= x_diff
        Graphics.update
        break if @sprite.x >= 640 + 320
      end
      sprite2.bitmap.dispose
      sprite2.dispose
    end
    #--------------------------------------------------------------------------
    # * Shred Vertical
    #      thickness : Shred thickness
    #       slowness : How slow the screens move out
    #    start_speed : Speed of first step in pixels
    #--------------------------------------------------------------------------
    def shred_v(thickness=4, slowness=4, start_speed=8)
      t = thickness
      # Shred screen
      sprite2 = Sprite.new(@sprite.viewport)
      sprite2.bitmap = Bitmap.new(@sprite.bitmap.width, @sprite.bitmap.height)
      sprite2.x = sprite2.ox = sprite2.bitmap.width / 2
      sprite2.y = sprite2.oy = sprite2.bitmap.height / 2
      # Shred bitmap
      for i in 0..(640/t)
        sprite2.bitmap.blt(i*t*2, 0, @sprite.bitmap, Rect.new(i*t*2, 0, t, 480))
        @sprite.bitmap.fill_rect(i*t*2, 0, t, 480, Color.new(0, 0, 0, 0))
      end
      # Make sure starting step is not zero
      start_speed = slowness if start_speed < slowness
      # Move sprites
      dist = 480 - @sprite.y + start_speed
      loop do
        y_diff = (dist - (480 - @sprite.y)) / slowness
        @sprite.y += y_diff
        sprite2.y -= y_diff
        Graphics.update
        break if @sprite.y >= 480 + 240
      end
      sprite2.bitmap.dispose
      sprite2.dispose
    end
    #--------------------------------------------------------------------------
    # * Shred Grid
    #      thickness : Shred thickness
    #       slowness : How slow the screens move out
    #    start_speed : Speed of first step in pixels
    #       priority : Which direction comes first (0 - vertical, 1 - horizontal)
    #--------------------------------------------------------------------------
    def shred_g(thickness=4, slowness=4, start_speed=8, priority = 0)
      t = thickness
      # Shred screen
      sprite2 = Sprite.new(@sprite.viewport)
      sprite2.bitmap = Bitmap.new(@sprite.bitmap.width, @sprite.bitmap.height)
      sprite2.x = sprite2.ox = sprite2.bitmap.width / 2
      sprite2.y = sprite2.oy = sprite2.bitmap.height / 2
      sprite3 = Sprite.new(@sprite.viewport)
      sprite3.bitmap = Bitmap.new(@sprite.bitmap.width, @sprite.bitmap.height)
      sprite3.x = sprite3.ox = sprite3.bitmap.width / 2
      sprite3.y = sprite3.oy = sprite3.bitmap.height / 2
      sprite4 = Sprite.new(@sprite.viewport)
      sprite4.bitmap = @sprite.bitmap.clone
      sprite4.x = sprite4.ox = sprite4.bitmap.width / 2
      sprite4.y = sprite4.oy = sprite4.bitmap.height / 2
      #sprite2.visible = sprite3.visible = sprite4.visible = false
      # Shred bitmap
      if priority == 0
        for i in 0..(640/t)
          sprite2.bitmap.blt(i*t*2, 0, @sprite.bitmap, Rect.new(i*t*2, 0, t, 480))
          @sprite.bitmap.fill_rect(i*t*2, 0, t, 480, Color.new(0, 0, 0, 0))
          sprite4.bitmap.fill_rect(i*t*2, 0, t, 480, Color.new(0, 0, 0, 0))
          sprite2.z = 4
          sprite3.z = 3
          @sprite.z = 2
          sprite4.z = 1
        end
        for i in 0..(480/t)
          sprite3.bitmap.blt(0, i*t*2, @sprite.bitmap, Rect.new(0, i*t*2, 640, t))
          @sprite.bitmap.fill_rect(0, i*t*2, 640, t, Color.new(0, 0, 0, 0))
          sprite4.bitmap.fill_rect(0, i*t*2, 640, t, Color.new(0, 0, 0, 0))
        end
      else
        for i in 0..(480/t)
          sprite3.bitmap.blt(0, i*t*2, @sprite.bitmap, Rect.new(0, i*t*2, 640, t))
          @sprite.bitmap.fill_rect(0, i*t*2, 640, t, Color.new(0, 0, 0, 0))
          sprite4.bitmap.fill_rect(0, i*t*2, 640, t, Color.new(0, 0, 0, 0))
          sprite3.z = 4
          sprite2.z = 3
          @sprite.z = 2
          sprite4.z = 1
        end
        for i in 0..(640/t)
          sprite2.bitmap.blt(i*t*2, 0, @sprite.bitmap, Rect.new(i*t*2, 0, t, 480))
          @sprite.bitmap.fill_rect(i*t*2, 0, t, 480, Color.new(0, 0, 0, 0))
          sprite4.bitmap.fill_rect(i*t*2, 0, t, 480, Color.new(0, 0, 0, 0))
        end
      end
      # Make sure starting step is not zero
      start_speed = slowness if start_speed < slowness
      # Move sprites
      disty = 480 - sprite4.y + start_speed
      distx = 640 - @sprite.y + start_speed
      loop do
        y_diff = (disty - (480 - sprite4.y)) / slowness
        x_diff = (distx - (640 - @sprite.x)) / slowness
        sprite4.y += y_diff
        sprite2.y -= y_diff
        @sprite.x += x_diff
        sprite3.x -= x_diff
        Graphics.update
        break if @sprite.x >= 640 + 320
      end
      sprite2.bitmap.dispose
      sprite2.dispose
      sprite3.bitmap.dispose
      sprite3.dispose
      sprite4.bitmap.dispose
      sprite4.dispose
    end
    #--------------------------------------------------------------------------
    # * Custom Tile Sprites
    #--------------------------------------------------------------------------
    def custom_tile_sprites(size_x, size_y, conditions, properties, centered = true)
      raise "Tile Error: not the same amount of conditions and properties" if conditions.length != properties.length
      tiles = []
      # Iterate through main sprite, creating sprites for each square.
      (0...@sprite.bitmap.width / size_x).each {|col|
        (0...@sprite.bitmap.height / size_y).each {|row|
          sprite = Sprite.new(@sprite.viewport)
          sprite.x += col*size_x
          sprite.y += row*size_y
          sprite.bitmap = Bitmap.new(size_x, size_y)
          rect = Rect.new(sprite.x, sprite.y, size_x, size_y)
          sprite.bitmap.blt(0, 0, @sprite.bitmap, rect)
          for i in 0...conditions.length
            if conditions[i].call(col, row)
              properties[i].each { |prop|
                sprite.send("#{prop[0]}=", prop[1])
                #sprite.zoom_x = 1
                #sprite.zoom_y = 1
              }
              break
            end
          end
          if centered
            sprite.ox = size_x / 2
            sprite.oy = size_y / 2
            sprite.x += size_x / 2
            sprite.y += size_y / 2
          end
          tiles.push(sprite)
        }
      }
      @sprite.opacity = 0
      return tiles
    end
    #--------------------------------------------------------------------------
    # * tile_sprites
    #--------------------------------------------------------------------------
    def tile_sprites(tilesize)
      tiles = []
      # Iterate through main sprite, creating sprites for each square.
      (0...@sprite.bitmap.width / tilesize).each {|x|
        (0...@sprite.bitmap.height / tilesize).each {|y|
          sprite = Sprite.new
          sprite.x, sprite.y = x*tilesize, y*tilesize
          sprite.bitmap = Bitmap.new(tilesize, tilesize)
          rect = Rect.new(sprite.x, sprite.y, tilesize, tilesize)
          sprite.bitmap.blt(0, 0, @sprite.bitmap, rect)
          tiles.push(sprite)
        }
      }
      @sprite.opacity = 0
      return tiles
    end
    #--------------------------------------------------------------------------
    # * Effect3
    #--------------------------------------------------------------------------
    def effect3(size_x = 640, size_y = 4)
      tiles = custom_tile_sprites(size_x, size_y, [proc { true }], [{}])
      # Make sure starting step is not zero
      #start_speed = slowness if start_speed < slowness
      frames = 0
      while (tiles.select { |i| i.visible == true }).length > 0
        selected_length = (tiles.select { |i| i.visible == true }).length
        frames += 1
        for i in tiles
          i.visible = false if rand(selected_length / 4) == 0
        end
        Graphics.update
      end
      tiles.each { |tile|
        tile.bitmap.dispose
        tile.dispose
      }
    end
    #--------------------------------------------------------------------------
    # * Effect2
    #--------------------------------------------------------------------------
    def effect2(fade_length = 10, size_x = 20, size_y = 20)
      tiles = custom_tile_sprites(size_x, size_y, [proc { true }], [{}])
      # Make sure starting step is not zero
      #start_speed = slowness if start_speed < slowness
      frames = 0
      opac_diff = 255 / fade_length
      while (tiles.select { |i| i.visible == true }).length > 0
        selected_length = (tiles.select { |i| i.visible == true }).length
        frames += 1
        for i in tiles
          i.opacity -= opac_diff if (i.opacity != 255 and i.opacity > 0) or rand(selected_length / 4) == 0
          i.visible = false if i.opacity <= 0 and i.visible
        end
        Graphics.update
      end
      tiles.each { |tile|
        tile.bitmap.dispose
        tile.dispose
      }
    end
    #--------------------------------------------------------------------------
    # * Uncover
    #--------------------------------------------------------------------------
    def uncover(dir = 0, duration = 40)
      frames = 0
      x_mod = case dir;when 7,0,1 then -640; when 3,4,5 then 640;else 0;end
      y_mod = case dir;when 1,2,3 then -480; when 5,6,7 then 480;else 0;end
      s_pos = [@sprite.x, @sprite.y]
      d_pos = [s_pos[0] + x_mod, s_pos[1] + y_mod]
      loop do
        frames += 1
        @sprite.x = (s_pos[0] * (duration - frames) + d_pos[0] * frames) / duration
        @sprite.y = (s_pos[1] * (duration - frames) + d_pos[1] * frames) / duration
        Graphics.update
        break if frames == duration
      end
    end
    #--------------------------------------------------------------------------
    # * Fade
    #     target_color : Color to fade to
    #           frames : Effect duration in frames
    #--------------------------------------------------------------------------
    def fade(target_color=Color.new(255, 255, 255), frames=40)
      loop do
        r = (@sprite.color.red   * (frames - 1) + target_color.red)   / frames
        g = (@sprite.color.green * (frames - 1) + target_color.green) / frames
        b = (@sprite.color.blue  * (frames - 1) + target_color.blue)  / frames
        a = (@sprite.color.alpha * (frames - 1) + target_color.alpha) / frames
        @sprite.color.red   = r
        @sprite.color.green = g
        @sprite.color.blue  = b
        @sprite.color.alpha = a
        frames -= 1
        Graphics.update
        break if frames <= 0
      end
      #Graphics.freeze
    end
    #--------------------------------------------------------------------------
    # * Explode
    #     explosion_sound : The SE filename to use for explosion sound
    #--------------------------------------------------------------------------
    def explode(explosion_sound=Explosion_Sound)
      shake_count = 2
      shakes = 40
      tone = 0
      shakes.times do
        @sprite.ox = 320 + (rand(2) == 0 ? -1 : 1) * shake_count
        @sprite.oy = 240 + (rand(2) == 0 ? -1 : 1) * shake_count
        shake_count += 0.2
        tone += 128/shakes
        @sprite.tone.set(tone, tone, tone)
        Graphics.update
      end
      @sprite.ox, @sprite.oy = 320, 240
      Graphics.update
      bitmap = @sprite.bitmap.clone
      viewport = @sprite.viewport
      @sprite.bitmap.dispose
      @sprite.dispose
      # Slice bitmap and create nodes (sprite parts)
      hor = []
      20.times do |i|
        ver = []
        15.times do |j|
          # Set node properties
          s = Sprite.new(viewport)
          s.ox, s.oy = 8 + rand(25), 8 + rand(25)
          s.x, s.y = s.ox + 32 * i, s.oy + 32 * j
          s.bitmap = Bitmap.new(32, 32)
          s.bitmap.blt(0, 0, bitmap, Rect.new(i * 32, j * 32, 32, 32))
          s.tone.set(128, 128, 128)
          # Set node physics
          angle  = (rand(2) == 0 ? -1 : 1) * (4 + rand(4) * 10)
          zoom_x = (rand(2) == 0 ? -1 : 1) * (rand(2) + 1).to_f / 100
          zoom_y = (rand(2) == 0 ? -1 : 1) * (rand(2) + 1).to_f / 100
          (zoom_x > zoom_y) ? (zoom_y = -zoom_x) : (zoom_x = -zoom_y)
          x_rand = (2 + rand(2) == 0 ? -2 : 2)
          y_rand = (1 + rand(2) == 0 ? -1 : 1)
          # Store node and it's physics
          ver.push([s, angle, zoom_x, zoom_y, x_rand, y_rand])
        end
        hor.push(ver)
      end
      bitmap.dispose
      # Play sound
      play_se(explosion_sound) if explosion_sound != nil
      # Move pics
      40.times do |k|
        hor.each_with_index do |ver, i|
          ver.each_with_index do |data, j|
            # Get node and it's physics
            s, angle, zoom_x, zoom_y = data[0], data[1], data[2], data[3]
            x_rand, y_rand = data[4], data[5]
            # Manipulate nodes
            s.x += (i - 10) * x_rand
            s.y += (j - 8) * y_rand + (k - 20)/2
            s.zoom_x += zoom_x
            s.zoom_y += zoom_y
            tone = s.tone.red - 8
            s.tone.set(tone, tone, tone)
            s.opacity -= 13 if k > 19
            s.angle += angle % 360
          end
        end
        Graphics.update
      end
      # Dispose
      for ver in hor
        for data in ver
          data[0].bitmap.dispose
          data[0].dispose
        end
      end
      hor = nil
    end
    #--------------------------------------------------------------------------
    # * Explode (Chaos Project Style)
    #     explosion_sound : The SE filename to use for explosion sound
    #--------------------------------------------------------------------------
    def explode_cp(explosion_sound=Explosion_Sound)
      bitmap = @sprite.bitmap.clone
      viewport = @sprite.viewport
      @sprite.bitmap.dispose
      @sprite.dispose
      # Slice bitmap and create nodes (sprite parts)
      hor = []
      20.times do |i|
        ver = []
        15.times do |j|
          # Set node properties
          s = Sprite.new(viewport)
          s.ox = s.oy = 16
          s.x, s.y = s.ox + 32 * i, s.oy + 32 * j
          s.bitmap = Bitmap.new(32, 32)
          s.bitmap.blt(0, 0, bitmap, Rect.new(i * 32, j * 32, 32, 32))
          # Set node physics
          angle  = (rand(2) == 0 ? -1 : 1) * rand(8)
          zoom_x = (rand(2) == 0 ? -1 : 1) * (rand(2) + 1).to_f / 100
          zoom_y = (rand(2) == 0 ? -1 : 1) * (rand(2) + 1).to_f / 100
          # Store node and it's physics
          ver.push([s, angle, zoom_x, zoom_y])
        end
        hor.push(ver)
      end
      bitmap.dispose
      # Play sound
      play_se(explosion_sound) if explosion_sound != nil
      # Move pics
      40.times do |k|
        hor.each_with_index do |ver, i|
          ver.each_with_index do |data, j|
            # Get node and it's physics
            s, angle, zoom_x, zoom_y = data[0], data[1], data[2], data[3]
            # Manipulate node
            s.x += i - 9
            s.y += j - 8 + k
            s.zoom_x += zoom_x
            s.zoom_y += zoom_y
            s.angle += angle % 360
          end
        end
        Graphics.update
      end
      # Dispose
      for ver in hor
        for data in ver
          data[0].bitmap.dispose
          data[0].dispose
        end
      end
      hor = nil
    end
    #--------------------------------------------------------------------------
    # * Transpose (bt Blizzard)
    #     frames : Effect duration in frames
    #   max_zoom : The max amount the screen zooms out
    #      times : Number of times screen is zoomed (times * 3 / 2)
    #--------------------------------------------------------------------------
    def transpose(frames=80, max_zoom=12, times=3)
      max_zoom -= 1 # difference b/w zooms
      max_zoom = max_zoom.to_f / frames / times # unit zoom
      unit_opacity = (255.0 / frames).ceil
      spr_opacity = (255.0 * times / 2 / frames).ceil
      @sprites = []
      (times * 3 / 2).times {
        s = Sprite.new(@sprite.viewport)
        s.x, s.y, s.ox, s.oy = 320, 240, 320, 240
        s.bitmap = @sprite.bitmap
        s.blend_type = 1
        s.opacity = 128
        s.visible = false
        @sprites.push(s)}
      count = 0
      loop {
          @sprites[count].visible = true
          count += 1 if count < times * 3 / 2 - 1
          (frames / times / 2).times {
              @sprites.each {|s|
                  break if s.not.visible
                  s.zoom_x += max_zoom
                  s.zoom_y += max_zoom
                  s.opacity -= spr_opacity}
              @sprite.opacity -= unit_opacity
          Graphics.update}
          break if @sprite.opacity == 0}
      @sprites.each {|s| s.dispose}
    end
    #--------------------------------------------------------------------------
    # * Shutter
    #       open_gap : How much the shutters open before moving away
    #       flip_dir : Whether or not the direction of shutters if reversed
    #       slowness : How slow the screens move out
    #    start_speed : Speed of first step in pixels
    #--------------------------------------------------------------------------
    def shutter(flip_dir=true, open_gap=16, slowness=4, start_speed=8)
      # Shred screen
      sprite2 = Sprite.new(@sprite.viewport)
      sprite2.bitmap = Bitmap.new(@sprite.bitmap.width, @sprite.bitmap.height)
      sprite2.x = sprite2.ox = sprite2.bitmap.width / 2
      sprite2.y = sprite2.oy = sprite2.bitmap.height / 2
      if flip_dir
        ver_step = 1
        sprite2.bitmap.blt(0, 240, @sprite.bitmap, Rect.new(0, 240, 640, 240))
        @sprite.bitmap.fill_rect(0, 240, 640, 240, Color.new(0, 0, 0, 0))
      else
        ver_step = -1
        sprite2.bitmap.blt(0, 0, @sprite.bitmap, Rect.new(0, 0, 640, 240))
        @sprite.bitmap.fill_rect(0, 0, 640, 240, Color.new(0, 0, 0, 0))
      end
      # Move the shutters apart
      open_gap.times do
        @sprite.y -= ver_step
        sprite2.y += ver_step
        Graphics.update
      end
      # Make sure starting step is not zero
      start_speed = slowness if start_speed < slowness
      # Move sprites
      dist = 640 - @sprite.x + start_speed
      loop do
        x_diff = (dist - (640 - @sprite.x)) / slowness
        @sprite.x += x_diff
        sprite2.x -= x_diff
        Graphics.update
        break if @sprite.x >= 640 + 320
      end
      sprite2.bitmap.dispose
      sprite2.dispose
    end
    #--------------------------------------------------------------------------
    # * Drop Off
    #     clink_sound : The SE filename to use for clinking sound
    #--------------------------------------------------------------------------
    def drop_off(clink_sound=Clink_Sound)
      bitmap = @sprite.bitmap.clone
      viewport = @sprite.viewport
      @sprite.bitmap.dispose
      @sprite.dispose
      # Slice bitmap and create nodes (sprite parts)
      max_time = 0
      hor = []
      10.times do |i|
        ver = []
        8.times do |j|
          # Set node properties
          s = Sprite.new(viewport)
          s.ox = rand(32)
          s.oy = 0
          s.x = s.ox + 64 * i
          s.y = s.oy + 64 * j
          s.bitmap = Bitmap.new(64, 64)
          s.bitmap.blt(0, 0, bitmap, Rect.new(i * 64, j * 64, 64, 64))
          # Set node physics
          angle = rand(4) * 2
          angle *= rand(2) == 0 ? -1 : 1
          start_time = rand(30)
          max_time = start_time if max_time < start_time
          # Store node and it's physics
          ver.push([s, angle, start_time])
        end
        hor.push(ver)
      end
      bitmap.dispose
      # Play sound
      play_se(clink_sound) if clink_sound != nil
      # Move pics
      (40 + max_time).times do |k|
        hor.each_with_index do |ver, i|
          ver.each_with_index do |data, j|
            # Get node and it's physics
            s, angle, start_time = data[0], data[1], data[2]
            # Manipulate node
            if k > start_time
              tone = s.tone.red - 6
              s.tone.set(tone, tone, tone)
              s.y += k - start_time
              s.angle += angle % 360
            elsif k == start_time
              tone = 128
              s.tone.set(tone, tone, tone)
              play_se(clink_sound) if clink_sound != nil
            end
          end
        end
        Graphics.update
      end
      # Dispose
      for ver in hor
        for data in ver
          data[0].bitmap.dispose
          data[0].dispose
        end
      end
      hor = nil
    end
    #--------------------------------------------------------------------------
    # * ff_IV_style
    #--------------------------------------------------------------------------
    def ff_IV_style(zoom1 = 1.2, zoom2 = 32)
      # Set number of frames and zoom rates for each stage.
      stages = [4, 4, 4, 4, 20]
      zooms = [zoom1, -zoom1, zoom1, -zoom1, zoom2]
      zooms.each_index {|i| zooms[i] /= stages[i].to_f }
      current_stage = 0
      5.times do
        # Begin processing.
        stages[current_stage].times do
          @sprite.zoom_x += zooms[current_stage]
          @sprite.zoom_y += zooms[current_stage]
          @sprite.opacity -= 12 if current_stage == 4
          Graphics.update
        end
        # Increase current stage.
        current_stage += 1
      end
    end
    #--------------------------------------------------------------------------
    # * downward_spiral
    #--------------------------------------------------------------------------
    def downward_spiral(frames = 40, rotation_speed = 15)
      # Calculate the zoom to subtract each frame.
      zoom, opacity = 1.0 / frames, 128.0 / frames
      frames.times do
        # Begin processing.
        @sprite.zoom_x -= zoom
        @sprite.zoom_y -= zoom
        @sprite.opacity -= opacity
        @sprite.angle += rotation_speed
        Graphics.update
      end
    end
    #--------------------------------------------------------------------------
    # * blackhole
    #--------------------------------------------------------------------------
    def blackhole(speed = 4, tilesize = 12, source = [320, 240])
      # Initialize squares array to hold each sprite.
      tiles = tile_sprites(tilesize)
      # Make each sprite slightly smaller than full size.
      tiles.each {|tile| tile.zoom_x = tile.zoom_y = 0.85 }
      # Begin looping until all sprites have been disposed.
      until tiles.compact == []
        # Iterate each tiles.
        tiles.each_index {|i|
          next if tiles[i] == nil
          # Get distance of this sprite from the source for each axis.
          sx = source[0] - tiles[i].x
          sy = source[1] - tiles[i].y
          # Calculate total distance and set base speed for each axis.
          dist = Math.hypot(sx, sy).to_f
          move_x = (dist / (sx == 0 ? 1 : sx))
          move_y = (dist / (sy == 0 ? 1 : sy))
          # Add a little randomness to the mix.
          move_x += move_x < 0 ? -rand(speed) : rand(speed)
          move_y += move_y < 0 ? -rand(speed) : rand(speed)
          # Apply movement.
          tiles[i].x += move_x
          tiles[i].y += move_y
          tiles[i].angle += rand(20)
          # If tile is within its own size from source, dispose it.
          if sx.abs <= tilesize && sy.abs <= tilesize
             tiles[i].bitmap.dispose
             tiles[i] = tiles[i].dispose
          end
        }
        Graphics.update
      end
    end
    #--------------------------------------------------------------------------
    # * wave_distort
    #--------------------------------------------------------------------------
    def wave_distort(frames = 60, direction = 2, power = 0.4)
      radius, tiles = 0, tile_sprites(16)
      # Define starting point for zoom, depending on direction.
      origin = case direction
      when 2 then [@sprite.bitmap.width / 2, @sprite.bitmap.height]
      when 4 then [0, @sprite.bitmap.height / 2]
      when 6 then [@sprite.bitmap.width, @sprite.bitmap.height / 2]
      when 8 then [@sprite.bitmap.width / 2, 0]
      end
      # Initialize local variable for the rate the radius will increase.
      rate = Math.hypot(@sprite.bitmap.width, @sprite.bitmap.height) / frames
      # Begin processing.
      frames.times do
        # Iterate through each tile, calculating distance from focal point.
        tiles.each {|tile|
          dist = Math.hypot((origin[0] - tile.x), (origin[1] - tile.y))
          # Zoom tile on one axis, depending on direction.
          next if radius < dist
          [4, 6].include?(direction) ? tile.zoom_x += power : tile.zoom_y += power
        }
        # Increase radius for next iteration.
        radius += rate
        Graphics.update
      end
      # Dispose each bitmap and sprite used for the tiles.
      tiles.each {|tile| tile.bitmap.dispose; tile.dispose }
    end
    #--------------------------------------------------------------------------
    # * radial_break
    #--------------------------------------------------------------------------
    def radial_break(frames = 60, tilesize = 16, direction = 4, speed = 9)
      radius, tiles = 0, tile_sprites(tilesize)
      # Define starting point for zoom, depending on direction.
      origin = case direction
      when 2 then [@sprite.bitmap.width / 2, @sprite.bitmap.height]
      when 4 then [0, @sprite.bitmap.height / 2]
      when 6 then [@sprite.bitmap.width, @sprite.bitmap.height / 2]
      when 8 then [@sprite.bitmap.width / 2, 0]
      end
      # Initialize local variable for the rate the radius will increase.
      rate = Math.hypot(@sprite.bitmap.width, @sprite.bitmap.height) / frames
      # Begin processing.
      until tiles == []
        tiles.compact!
        # Iterate through each tile, calculating distance from focal point.
        tiles.each_index {|i|
          # Get distance of this sprite from the source for each axis.
          sx = origin[0] - tiles[i].x
          sy = origin[1] - tiles[i].y
          dist = Math.hypot(sx, sy).to_f
          # Zoom tile on one axis, depending on direction.
          next if radius < dist
          # Calculate total distance and set base speed for each axis.
          move_x = (dist / (sx == 0 ? 1 : sx))
          move_y = (dist / (sy == 0 ? 1 : sy))
          # Add a little randomness to the mix.
          move_x += move_x < 0 ? -rand(speed) : rand(speed)
          move_y += move_y < 0 ? -rand(speed) : rand(speed)
          # Half distance of one axis, depending on rate.
          [2, 8].include?(direction) ? move_x /= 2 : move_y /= 2
          # Apply movement.
          tiles[i].x += move_x
          tiles[i].y += move_y
          angle = (tiles[i].object_id % 2 == 0) ? rand(25) : -rand(25)
          tiles[i].angle += (angle + 5)
          # If tile is within its own size from source, dispose it.
          if sx.abs <= tilesize || sy.abs <= tilesize
             tiles[i].bitmap.dispose
             tiles[i] = tiles[i].dispose
          end
        }
        # Increase radius for next iteration.
        radius += rate / 2
        Graphics.update
      end
    end
  end
end