#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=: # 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