#!/usr/bin/env ruby

# This program is released to the PUBLIC DOMAIN.
# It 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.


# 
# This demo shows a simple example of game structure.
# It demonstrates how to use (or, one of many ways to use):
# 
# * Clock to limit the maximum framerate (to keep CPU usage low)
# 
# * Sprites to display player characters on the screen
# 
# * EventQueue, EventHandler, and the HasEventHandler mixin to
#   receive events from the keyboard, joystick, etc.
# 
# * A custom Game class to integrate it all and provide the game
#   structure and main loop.
# 


require "rubygame"


# Include these modules so we can type "Surface" instead of
# "Rubygame::Surface", etc. Purely for convenience/readability.

include Rubygame
include Rubygame::Events
include Rubygame::EventActions
include Rubygame::EventTriggers


# Make text we output appear on the console right away.
$stdout.sync = true


# Use smooth scaling/rotating? You can toggle this with S key
$smooth = false


# Make sure everything is set up properly.
Rubygame.init()


# SDL_gfx is required for drawing shapes and rotating/zooming Surfaces.
$gfx_ok = (VERSIONS[:sdl_gfx] != nil)

unless ( $gfx_ok )
	raise "You must have SDL_gfx support to run this demo!"
end


# Activate all joysticks so that their button press
# events, etc. appear in the event queue.
Joystick.activate_all




########################
# CUSTOM EVENT CLASSES #
########################


# Signals sprites to draw themselves on the screen
class DrawSprites
	attr_accessor :screen
	def initialize( screen )
		@screen = screen
	end
end

# Signals sprites to erase themselves from the screen
class UndrawSprites
	attr_accessor :screen, :background
	def initialize( screen, background )
		@screen, @background = screen, background
	end
end




######################
# AUTOLOADING IMAGES #
######################


# Set up autoloading for Surfaces. Surfaces will be loaded automatically
# the first time you use Surface["filename"]. Check out the docs for
# Rubygame::NamedResource for more info about that.
#
Surface.autoload_dirs = [ File.dirname(__FILE__) ]




#################
# PANDA CLASSES #
#################


# Base class for our panda sprites. This provides the core
# logic for initialization and movement of the sprites.
class Panda
	include Sprites::Sprite
	include EventHandler::HasEventHandler

	# Autoload the "panda.png" image and set its colorkey
	@@pandapic = Surface["panda.png"]
	@@pandapic.set_colorkey(@@pandapic.get_at(0,0))

	attr_accessor :vx, :vy, :speed
	def initialize(x,y)
		super()
		@vx, @vy = 0,0
		@speed = 40
		@image = @@pandapic
		@rect = Rect.new(x,y,*@@pandapic.size)

	end

	def update_image(time)
		# do nothing in base class, rotate/zoom image in subs
	end

	def update( tick_event )
		x,y = @rect.center
		self.update_image( tick_event.seconds * 1000.0 )
		@rect.size = @image.size

		base = @speed * tick_event.seconds
		@rect.centerx = x + @vx * base
		@rect.centery = y + @vy * base
	end

end


# A panda that spins around and around. The update_image
# method is called once per frame to generate the new
# image (in this case by rotating the original image).
class SpinnyPanda < Panda
	attr_accessor :rate
	def initialize(x,y,rate=0.1)
		super(x,y)
		@rate = rate
		@angle = 0
	end

	def update_image(time)
		@angle += (@rate * time) % 360
		@image = @@pandapic.rotozoom(@angle,1,$smooth)
	end
end


# A panda that grows and shrinks in size. Like the other
# panda classes, it updates its image every frame.
class ExpandaPanda < Panda
	attr_accessor :rate
	def initialize(x,y,rate=0.1)
		super(x,y)
		@rate = rate
		@delta = 0
	end

	def update_image(time)
		@delta = (@delta + time*@rate/36) % (Math::PI*2)
		zoom = 1 + Math.sin(@delta)/2
		@image = @@pandapic.zoom(zoom,$smooth)
	end
end


# A panda that wobbles and jiggles. Like the other
# panda classes, it updates its image every frame.
class WobblyPanda < Panda
	attr_accessor :rate
	def initialize(x,y,rate=0.1)
		super(x,y)
		@rate = rate
		@delta = 0
	end

	def update_image(time)
		@delta = (@delta + time*@rate/36) % (Math::PI*2)
		zoomx = (1.5 + Math.sin(@delta)/6) * @@pandapic.width
		zoomy = (1.5 + Math.cos(@delta)/5) * @@pandapic.height
		@image = @@pandapic.zoom_to(zoomx,zoomy,$smooth)
	end
end


# Create the very cute panda objects!
panda1 = SpinnyPanda.new(100,50)
panda2 = ExpandaPanda.new(150,50)
panda3 = WobblyPanda.new(200,50,0.5)

# Set their depths. This affects which one appears in front
# of the other in case they overlap.
panda1.depth = 0        # in between the others
panda2.depth = 10       # behind both of the others
panda3.depth = -10      # in front of both of the others




###############
# PANDA GROUP #
###############


# Create a spritegroup to manage the pandas.
pandas = Sprites::Group.new
pandas.extend(Sprites::UpdateGroup)
pandas.extend(Sprites::DepthSortGroup)

# Add the pandas to the group.
pandas.push(panda1,panda2,panda3)


# Extend the pandas group with event hooks.
class << pandas
	include EventHandler::HasEventHandler

	# Draw all the sprites and refresh
	# those parts of the screen
	def do_draw( event )
		dirty_rects = draw( event.screen )
		event.screen.update_rects(dirty_rects)
	end

	# Erase the sprites from the screen by
	# drawing over them with the background.
	def do_undraw( event )
		undraw( event.screen, event.background )
	end
end

pandas.make_magic_hooks( :tick         => :update,
                         DrawSprites   => :do_draw,
                         UndrawSprites => :do_undraw )



##########
# SCREEN #
##########


# Create the SDL window
screen = Screen.set_mode([320,240])
screen.title = "Rubygame test"
screen.show_cursor = false;




###############
# BACKGROUND  #
###############


# Make the background surface. We'll draw on this, then blit (copy) it
# onto the screen. We'll also use it as the background for "erasing"
# the pandas from their old positions each frame.
background = Surface.new( screen.size )

# Fill the background with a nice blue color.
background.fill( Color::ColorRGB.new([0.1, 0.2, 0.35]) )


# Render instructions with TTF (TrueType Font)
TTF.setup()
ttfont_path = File.join(File.dirname(__FILE__),"FreeSans.ttf")
ttfont = TTF.new( ttfont_path, 14 )

ttfont.render( "Use arrow keys or joystick to move pandas.",
               true, [250,250,250] ).blit( background, [20,160] )

ttfont.render( "Press escape or q to quit.",
               true, [250,250,250] ).blit( background, [20,180] )




############################
# EVENT HOOKS AND HANDLING #
############################


# Factory methods for creating event triggers

# Returns a trigger that matches the released key event
def released( key )
	return KeyReleaseTrigger.new( key )
end


# Returns a trigger that matches the joystick axis event.
# There are no built-in joystick event triggers in Rubygame
# yet, sorry.
def joyaxis( axis )
	return AndTrigger.new( InstanceOfTrigger.new( JoystickAxisMoved ),
	                       AttrTrigger.new(:joystick_id => 0,
	                                       :axis => axis))
end


# Returns a trigger that matches the joystick button press event.
def joypressed( button )
	return AndTrigger.new( InstanceOfTrigger.new( JoystickButtonPressed ),
	                       AttrTrigger.new(:joystick_id => 0,
	                                       :button => button))
end


# Returns a trigger that matches the joystick button press event.
def joyreleased( button )
	return AndTrigger.new( InstanceOfTrigger.new( JoystickButtonReleased ),
	                       AttrTrigger.new(:joystick_id => 0,
	                                       :button => button))
end


#######################
# PANDA 1 EVENT HOOKS #
#######################

hooks = {
	# Start moving when an arrow key is pressed
	:up    =>  proc { |owner, event| owner.vy = -1 },
	:down  =>  proc { |owner, event| owner.vy =  1 },
	:left  =>  proc { |owner, event| owner.vx = -1 },
	:right =>  proc { |owner, event| owner.vx =  1 },

	# Stop moving when the arrow key is released
	released( :up    ) =>  proc { |owner, event| owner.vy = 0 },
	released( :down  ) =>  proc { |owner, event| owner.vy = 0 },
	released( :left  ) =>  proc { |owner, event| owner.vx = 0 },
	released( :right ) =>  proc { |owner, event| owner.vx = 0 },

	# Move according to how far the joystick axis is moved
	joyaxis( 0 ) =>  proc { |owner, event| owner.vx = event.value },
	joyaxis( 1 ) =>  proc { |owner, event| owner.vy = event.value },

	# Fast speed when button is pressed, normal speed when released
	joypressed(  4 ) => proc { |owner, event| owner.speed *= 2.0 },
	joyreleased( 4 ) => proc { |owner, event| owner.speed *= 0.5 }
}

panda1.make_magic_hooks( hooks )


#######################
# PANDA 2 EVENT HOOKS #
#######################

hooks = {
	# Move according to how far the joystick axis is moved
	joyaxis( 2 ) =>  proc { |owner, event| owner.vx = event.value },
	joyaxis( 3 ) =>  proc { |owner, event| owner.vy = event.value },

	# Fast speed when button is pressed, normal speed when released
	joypressed(  5 ) => proc { |owner, event| owner.speed *= 2.0 },
	joyreleased( 5 ) => proc { |owner, event| owner.speed *= 0.5 }
}

panda2.make_magic_hooks( hooks )




##############
# GAME CLASS #
##############


# The Game class helps organize thing. It takes events
# from the queue and handles them, sometimes performing
# its own action (e.g. Escape key = quit), but also
# passing the events to the pandas to handle.
#
class Game
	include EventHandler::HasEventHandler

	attr_reader :clock, :queue

	def initialize( screen, background )

		@screen = screen
		@background = background

		setup_clock()
		setup_queue()
		setup_event_hooks()

		# Now blit the background onto the screen and update the screen
		# once. During the loop, we'll use 'dirty rect' updating to
		# refresh only the parts of the screen that have changed.
		@background.blit(screen,[0,0])
		@screen.update()

	end


	# The "main loop". Repeat the #step method
	# over and over and over until the user quits.
	def go
		catch(:quit) do
			loop do
				step
			end
		end
	end


	# Register the object to receive all events.
	# Events will be passed to the object's #handle method.
	def register( *objects )
		objects.each do |object|
			append_hook( :owner   => object,
									 :trigger => YesTrigger.new,
									 :action  => MethodAction.new(:handle) )
		end
	end


	private


	# Quit the game
	def quit
		puts "Quitting!"
		throw :quit
	end


	# Create a new Clock to manage the game framerate
	# so it doesn't use 100% of the CPU
	def setup_clock
		@clock = Clock.new()
		@clock.target_framerate = 50

    # Adjust the assumed granularity to match the system.
    # This helps minimize CPU usage on systems with clocks
    # that are more accurate than the default granularity.
		@clock.calibrate

    # Make Clock#tick return a ClockTicked event.
    @clock.enable_tick_events
	end


	# Set up the event hooks to perform actions in
	# response to certain events.
	def setup_event_hooks
		hooks = {
			:escape  =>  :quit,
			:q       =>  :quit,
			:s       =>  :toggle_smooth,

			QuitRequested     =>  :quit,

			# Tell the user where they clicked.
			MousePressed      => proc { |owner, event|
			                       puts "click: [%d,%d]"%event.pos
			                     },

			# These help to ensure everything is refreshed after the
			# Rubygame window has been covered up by a different window.
			InputFocusGained  => :update_screen,
			WindowUnminimized => :update_screen,
			WindowExposed     => :update_screen,

			# Refresh the window title.
			:tick             => :update_framerate
		}

		make_magic_hooks( hooks )
	end


	# Create an EventQueue to take events from the keyboard, etc.
	# The events are taken from the queue and passed to objects
	# as part of the main loop.
	def setup_queue
		# Create EventQueue with new-style events (added in Rubygame 2.4)
		@queue = EventQueue.new()
		@queue.enable_new_style_events

		# Don't care about mouse movement, so let's ignore it.
		@queue.ignore = [MouseMoved]
	end


	# Do everything needed for one frame.
	def step
		@queue << UndrawSprites.new( @screen, @background )
		@queue.fetch_sdl_events
		@queue << DrawSprites.new( @screen )
		@queue << $game.clock.tick
		@queue.each do |event|
			handle( event )
		end
	end


	# Toggle smooth effects
	def toggle_smooth
		$smooth = !$smooth
		puts "#{$smooth?'En':'Dis'}abling smooth scale/rotate."
	end


	# Update the window title to display the current framerate.
	def update_framerate( event )
    new_framerate = @clock.framerate.to_i
		unless @old_framerate == new_framerate
			@screen.title = "Rubygame test [%d fps]"%new_framerate
			@old_framerate = new_framerate
		end
	end


	# Refresh the whole screen.
	def update_screen
		@screen.update()
	end

end


$game = Game.new( screen, background )

# Register the pandas to receive events.
$game.register( pandas, panda1, panda2 )

# Start the main game loop. It will repeat forever
# until the user quits the game!
$game.go

# Make sure everything is cleaned up properly.
Rubygame.quit()