ippa-movie_maker 0.3.0

data/lib/movie_maker/action.rb

@@ -0,0 +1,389 @@
+#
+# One Action specifies a certain action, for example the movement of a sprite
+# Or to show a sprite, rotate, zoom or hide etc
+#
+#
+module MovieMaker
+	module Action
+		#
+		# All actions inherit from this base-class and Should call super in their initialize.
+		# Takes an option-hash: 
+		# :start_at - start at X millisec into the movie
+		# :stop_at - stop at X millisec into the movie
+		# :sprite - the actuall spriteobject, needs to answer to x,x=,y,y= and image
+		# :screen - the screenobject, so it knows where to blit itself
+		# :background - the backgroundsurface so it can undraw itself properly
+		#
+		#
+		class SpriteAction
+			attr_accessor :sprite, :background, :screen
+			attr_reader :start_at, :stop_at, :image
+			def initialize(options = {}, *ignore)
+				@sprite = options[:object]
+				@background = options[:background]
+				@screen = options[:screen]
+				@start_at = (options[:start_at]||0) * 1000
+				@stop_at = (options[:stop_at]||0) * 1000
+				@cache = options[:cache] || false
+				@framework = options[:framework] || :rubygame
+				
+				@duration = @stop_at - @start_at
+				@playing = true
+				@finalized = false
+				@setup_done = false
+				@image = @sprite.image # used in MovieMaker#play
+			end
+
+			def setup
+				@setup_done = true
+			end
+
+			def finalize
+				@finalized = true
+			end
+
+			def finalized?
+				@finalized
+			end
+			
+			def started?(current_time)
+				current_time >= self.start_at
+			end
+
+			def playing?(current_time)
+				@playing and (current_time >= self.start_at) and (current_time < self.stop_at)
+			end
+		end
+		
+		#
+		# Moves a sprite to a set of coordinates
+		#
+		class Move < SpriteAction
+		
+			def initialize(options = {}, coordinates = [0,0])
+				super(options)
+				@to_x = coordinates[0]
+				@to_y = coordinates[1]
+				@prev_time = 0
+			end
+			
+			def setup
+				@from_x = @sprite.x
+				@from_y = @sprite.y
+				@x_step = (@to_x - @from_x).to_f / @duration.to_f
+				@y_step = (@to_y - @from_y).to_f / @duration.to_f
+				@setup_done = true
+			end
+			
+			# The core of the MoveClass, the actual move-logic
+			def update(time)
+				setup	unless @setup_done
+				
+				@diff = (time - @prev_time)
+				@prev_time = time
+				
+				@sprite.x += @diff * @x_step.to_f
+				@sprite.y += @diff * @y_step.to_f
+			end
+			
+			def finalize
+				@sprite.x = @to_x
+				@sprite.y = @to_y
+				@finalized = true
+			end
+			
+		end
+
+		#
+		# ACCELERATION
+		#
+		class Acceleration < SpriteAction
+			def initialize(options = {}, acceleration = [0,0])
+				super(options)
+				@acceleration_x = acceleration[0]
+				@acceleration_y = acceleration[1]
+				@velocity_x = @acceleration_x
+				@velocity_y = @acceleration_y
+			end
+			
+			def update(time)
+				@velocity_x += @acceleration_x
+				@velocity_y += @acceleration_y
+				
+				@sprite.x += @velocity_x
+				@sprite.y += @velocity_y
+			end			
+		end
+
+		#
+		# ACCELERATE
+		#
+		class Velocity < SpriteAction
+			def initialize(options = {}, velocity = [0,0])
+				super(options)
+				@velocity_x = velocity[0]
+				@velocity_y = velocity[1]
+			end
+			
+			def update(time)
+				@sprite.x += @velocity_x
+				@sprite.y += @velocity_y
+			end			
+		end
+
+		#
+		# ROTATE
+		#
+		class Rotate < SpriteAction
+			attr_reader :direction
+			def initialize(options = {}, angle = 360)
+				super(options)
+				@angle = angle
+			end
+			
+			def setup
+				@angle_step = @angle.to_f / @duration.to_f
+				@angle_step = -@angle_step 	if @framework == :rubygame
+				@setup_done = true
+			end
+			
+			def update(time)
+				setup	unless @setup_done
+				@sprite.angle = (@angle_step * time)
+			end
+			
+			def finalize
+				@sprite.angle = @angle
+				@finalized = true
+			end
+		end
+
+		# Zoom a sprite
+		class Zoom < SpriteAction
+			
+			def initialize(options = {}, factor = 1)
+				super(options)
+				@factor = factor
+			end
+			
+			def setup
+				@scale_from = @sprite.width_scaling || 1
+				@scale = (@scale_from - @factor).abs
+
+				@scale_step = @scale.to_f / @duration.to_f
+				@scale_step = -@scale_step 	if	@factor < @scale_from
+		
+				@setup_done = true
+			end
+			
+			def update(time)
+				setup	unless @setup_done
+	
+				scale = @scale_from + @scale_step * time
+				#puts "#{scale} = #{@scale_from} + #{@scale_step} * #{time}"
+				@sprite.width_scaling = scale
+				@sprite.height_scaling = scale
+			end
+			
+			def finalize
+				@sprite.width_scaling = @factor
+				@sprite.height_scaling = @factor
+				@finalized = true
+			end
+		end
+
+		#
+		# Moves a sprite from X,Y --> X2,Y2
+		#
+		class MoveFacingDirection < SpriteAction
+		
+			def initialize(options = {}, coordinates = [0,0])
+				super(options)
+				@to_x = coordinates[0]
+				@to_y = coordinates[1]
+			end
+			
+			def setup
+				@from_x = @sprite.x
+				@from_y = @sprite.y
+
+				@x_step = (@to_x - @from_x).to_f / @duration.to_f
+				@y_step = (@to_y - @from_y).to_f / @duration.to_f				
+				
+				#
+				# investigate this further later ...
+				#
+				@sprite.angle = (Math.atan(@y_step / @x_step) * 180.0/Math::PI) + 315
+				@sprite.angle -= 45		if @framework == :gosu
+				
+				@setup_done = true
+			end
+			
+			# The core of the MoveClass, the actual move-logic
+			def update(time)
+				setup	unless @setup_done
+				
+				@sprite.x = @from_x + time * @x_step
+				@sprite.y = @from_y + time * @y_step
+			end
+			
+			def finalize
+				@finalized = true
+			end
+			
+		end
+
+
+
+
+
+		# Shows a sprite
+		class Show < SpriteAction
+			def initialize(options = {})
+				super
+			end
+			
+			def update(time)
+			end
+		end
+
+		
+		# Fades a sprite 
+		class FadeTo < SpriteAction
+		
+			def initialize(options = {})
+				super(options)
+				@from = options[:from]
+				@to = options[:to]
+				@alpha = 255
+			end
+			
+			def update(time)
+				@sprite.image.set_alpha(@alpha)
+				@alpha -= 1	if @alpha > 0
+			end
+		end
+
+		#
+		# PULSATE
+		#
+		class Pulsate < SpriteAction
+			attr_reader :direction
+			def initialize(options = {})
+				super(options)
+				@pulse_duration = options[:duration] || 1
+				@times = options[:times] || 1		
+			end
+			
+			def setup
+				@setup_done = true
+			end
+			
+			def update(time)
+				setup	unless @setup_done
+			end
+			
+		end
+		
+		#
+		# Fades color to total trans
+		# 
+		class FadeOut < SpriteAction
+			def initialize(options = {}, color = 0xFFFFFFFF)
+				super(options)
+				@sprite = options[:object]
+				@prev_time = 0
+			end
+			
+			def setup
+				@alpha_step = @sprite.color.alpha / @duration
+				@setup_done = true
+			end
+			
+			def update(time)
+				setup	unless @setup_done
+				
+				@diff = (time - @prev_time)
+				@prev_time = time
+		
+				@sprite.color.alpha = @sprite.color.alpha - (@diff.to_f * @alpha_step.to_f).to_i
+			end
+			
+			def finalize
+				@sprite.color.alpha = 0
+				@finalized = true
+			end			
+		end
+
+		#
+		#
+		#
+		class SimpleAction			
+			attr_reader :start_at, :stop_at
+			def initialize(options = {})
+				@start_at = (options[:start_at]||0) * 1000
+				@stop_at = (options[:stop_at]||0) * 1000
+				@duration = @stop_at - @start_at
+				@finalized = false
+			end
+
+			def started?(current_time)
+				current_time > self.start_at
+			end
+
+			def finalized?
+				@finalized
+			end
+
+		end
+
+		#
+		# Sets Color
+		# 
+		class Color < SimpleAction
+			def initialize(options = {}, color = 0xFFFFFFFF)
+				super(options)
+				@sprite = options[:object]
+				@color = color
+				@color = ::Gosu::Color.new(color)	if color.is_a? Fixnum
+			end
+			def finalize
+				@sprite.color = @color
+				@finalized = true
+			end			
+		end
+
+
+		#
+		# Plays a sound
+		# 
+		class PlaySound < SimpleAction
+			attr_reader :playing
+			def initialize(options = {}, sound = nil)			
+				super(options)
+				@sound = sound || options[:object]
+				@volume = options[:volume] || 1.0
+				@repeats = options[:repeats] || 1
+				@fade_in = options[:fade_in] || nil
+				@stop_after = @duration				
+				
+				@sound.volume = @volume	if @sound.respond_to? :volume
+			end
+			
+			def playing?(current_time)
+				@playing
+			end
+						
+			def finalize
+				@sound.play
+				@finalized = true
+			end
+			
+			def stop
+				@sound.stop
+			end
+			
+		end
+		
+	end
+end

data/lib/movie_maker/core_extensions.rb

@@ -0,0 +1,17 @@
+module Rubygame
+	class Surface
+	
+		def rotozoom_cached(angle, zoom, smooth=true, file="default")
+			@@rotozoom_cached_surfaces ||= {}
+			@@rotozoom_cached_surfaces[file] ||= []
+			key = angle.to_i.abs
+			
+			## DEBUG
+			#puts "[#{file}][#{key}]: HIT"	if @@rotozoom_cached_surfaces[file][key]
+			#puts "[#{file}][#{key}]: MISS"	if !@@rotozoom_cached_surfaces[file][key]
+			
+			@@rotozoom_cached_surfaces[file][key] ||= self.rotozoom(angle, zoom, smooth)
+		end
+
+	end
+end

data/lib/movie_maker/gosu_autoload.rb

@@ -0,0 +1,38 @@
+#
+# Rubygames Named Resources for GOSU
+# Assumes a global variable $screen having the Gosu::Window instance.
+# Quick 'n easy access to sprites, sounds and tiles!
+#
+begin
+	require 'named_resource'	# Part of rubygame 2.3+
+rescue
+	require 'rubygame'
+end
+include Gosu
+
+class Image
+	include Rubygame::NamedResource
+	
+	def self.autoload(name)
+		(path = find_file(name)) ? Image.new($screen, path, true) : nil
+	end
+end
+Surface = Image
+
+class Sample
+	include Rubygame::NamedResource
+	
+	
+	def self.autoload(name)
+		(path = find_file(name)) ? Sample.new($screen, path) : nil
+	end
+end
+Sound = Sample
+
+class Tile
+	include Rubygame::NamedResource
+	
+	def self.autoload(name)
+		(path = find_file(name)) ? Image.load_tiles($screen, path, 32, 32, true) : nil
+	end
+end

data/lib/movie_maker/gosu_clock.rb

@@ -0,0 +1,139 @@
+#--
+#	Rubygame -- Ruby code and bindings to SDL to facilitate game creation
+#	Copyright (C) 2004-2007  John Croisant
+#
+#	This library is free software; you can redistribute it and/or
+#	modify it under the terms of the GNU Lesser General Public
+#	License as published by the Free Software Foundation; either
+#	version 2.1 of the License, or (at your option) any later version.
+#
+#	This library is distributed in the hope that it will be useful,
+#	but WITHOUT ANY WARRANTY; without even the implied warranty of
+#	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#	Lesser General Public License for more details.
+#
+#	You should have received a copy of the GNU Lesser General Public
+#	License along with this library; if not, write to the Free Software
+#	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#++
+
+module Gosu
+		#  Clock provides class methods for tracking running time and delaying
+		#  execution of the program for specified time periods. This is used to
+		#  provide a consistent framerate, prevent the program from using
+		#  all the processor time, etc.
+		# 
+		#  Clock also provides instance methods to make it convenient to
+		#  monitor and limit application framerate. See #tick.
+		class Clock
+			# The runtime when the Clock was initialized.
+			attr_reader :start        
+			# The number of times #tick has been called.
+			attr_reader :ticks        
+			
+			# Make Rubygame::Clock work with GOSUs "milliseconds"
+			def self.runtime
+				Gosu::milliseconds
+			end
+			
+			def self.delay(time)
+				sleep_time = time/1000.0
+				sleep_time = 0 if sleep_time < 0
+				sleep(sleep_time)
+			end
+
+			# Create a new Clock instance.
+			def initialize()
+				@start = Clock.runtime()
+				@last_tick = @start
+				@ticks = 0
+				@target_frametime = nil
+				yield self if block_given?
+			end
+
+			# The target frametime (milliseconds/frame). See #tick
+			attr_accessor :target_frametime
+
+			# Returns the current target framerate (frames/second).
+			# This is an alternate way to access @target_frametime.
+			# Same as: 1000.0 / #target_frametime
+			def target_framerate
+				if @target_frametime
+					1000.0 / @target_frametime
+				else
+					nil
+				end
+			rescue ZeroDivisionError
+				return nil
+			end
+
+			# Sets the target number of frames per second to +framerate+.
+			# This is an alternate way to access @target_frametime.
+			# Same as: #target_frametime = 1000.0 / framerate
+			def target_framerate=( framerate )
+				if framerate
+					@target_frametime = 1000.0 / framerate
+				else
+					@target_frametime = nil
+				end
+			rescue ZeroDivisionError
+				@target_frametime = nil
+			end
+
+			# call-seq: lifetime()  ->  Numeric
+			# 
+			# Returns time in milliseconds since this Clock instance was created.
+			def lifetime
+				Clock.runtime() - @start
+			end
+
+			# call-seq: framerate()  ->  Numeric
+			# 
+			# Return the actual framerate (frames per second) recorded by the Clock.
+			# See #tick.
+			# 
+			# TODO: sample only a few seconds in the past, instead of the
+			# entire lifetime of the Clock. 
+			def framerate
+				# below is same as: return @ticks / (lifetime / 1000.0)
+				return 1000.0 * @ticks / lifetime()
+			rescue ZeroDivisionError
+				return 0
+			end
+
+			# Returns the number of milliseconds since you last called this method.
+			# 
+			# You must call this method once per frame (i.e. per iteration of
+			# your main loop) if you want to use the framerate monitoring and/or
+			# framerate limiting features.
+			# 
+			# Framerate monitoring allows you to check the framerate (frames per
+			# second) with the #framerate method.
+			# 
+			# Framerate limiting allows you to prevent the application from running
+			# too fast (and using 100% of processor time) by pausing the program
+			# very briefly each frame. The pause duration is calculated each frame
+			# to maintain a constant framerate.
+			# 
+			# Framerate limiting is only enabled if you have set the
+			# #target_framerate= or #target_frametime=.
+			# If you have done that, this method will automatically perform the
+			# delay each time you call it.
+			# 
+			# (Please note that no effort is made to correct a framerate
+			# which is *slower* than the target framerate. Clock can't
+			# make your code run faster, only slow it down if it is
+			# running too fast.)
+			def tick()
+				passed = Clock.runtime() - @last_tick  # how long since the last tick?
+				if @target_frametime
+					return Clock.delay(@target_frametime - passed) + passed
+				end
+				return passed
+			ensure
+				@last_tick = Clock.runtime()
+				@ticks += 1
+			end
+
+		end # class Clock
+end #module Gosu