gosu 0.7.39-x86-mingw32

data/Gosu/WinUtility.hpp

@@ -0,0 +1,75 @@
+//! \file WinUtility.hpp
+//! Contains some functions which are used to implement Gosu on Windows and
+//! might be useful for advanced users who try to integrate Gosu in a Win32
+//! application.
+
+#ifndef GOSU_WINUTILITY_HPP
+#define GOSU_WINUTILITY_HPP
+
+#include <windows.h>
+#include <Gosu/Platform.hpp>
+#include <Gosu/TR1.hpp>
+#include <string>
+
+namespace Gosu
+{
+    //! Implementation helpers for the Windows platform.
+    namespace Win
+    {
+        //! Returns the instance handle of the application.
+        HINSTANCE instance();
+
+        //! Blocking function which waits for the next message, processes it,
+        //! then returns.
+        void handleMessage();
+
+        //! Non-blocking function which processes all waiting messages but does
+        //! not wait for further incoming messages.
+        void processMessages();
+
+        //! Registers a function to be called by handleMessage and
+        //! processMessages. Every message is passed to the hooks and not
+        //! processed further if any hook function returns true.
+        void registerMessageHook(const std::tr1::function<bool (MSG&)>& hook);
+        
+        //! Throws an exception according to the error which GetLastError()
+        //! returns, optionally prefixed with "While (action), the following
+        //! error occured: ".
+        GOSU_NORETURN void throwLastError(const std::string& action = "");
+
+        //! Small helper function that throws an exception whenever the value
+        //! passed through is false. Note that this doesn't make sense for all
+        //! Windows API functions, but for most of them.
+        template<typename T>
+        inline T check(T valToCheck, const std::string& action = "")
+        {
+            if (!valToCheck)
+                throwLastError(action);
+            return valToCheck;
+        }
+
+        // IMPR: Why can't I use mem_fn for releasing objects even though it is
+        // shown like that in the shared_ptr documentation?
+        template<typename T>
+        void releaseComPtr(T* ptr)
+        {
+            ptr->Release();
+        }
+
+        //! Small helper function that transfers ownership of a COM interface
+        //! to a std::tr1::shared_ptr.
+        template<typename T>
+        inline std::tr1::shared_ptr<T> shareComPtr(T* ptr)
+        {
+            return std::tr1::shared_ptr<T>(ptr, releaseComPtr<T>);
+        }
+
+        //! Returns the executable's filename.
+        std::wstring appFilename();
+
+        //! Returns the executable's containing directory.
+        std::wstring appDirectory();
+    }
+}
+
+#endif

data/Gosu/Window.hpp

@@ -0,0 +1,124 @@
+//! \file Window.hpp
+//! Interface of the Window class.
+
+#ifndef GOSU_WINDOW_HPP
+#define GOSU_WINDOW_HPP
+
+#include <Gosu/Fwd.hpp>
+#include <Gosu/Platform.hpp>
+#include <Gosu/Input.hpp>
+#include <Gosu/TR1.hpp>
+#include <memory>
+#include <string>
+
+#ifdef GOSU_IS_WIN
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#include <windows.h>
+#endif
+
+namespace Gosu
+{
+    //! Convenient all-in-one class that serves as the foundation of a standard
+    //! Gosu application. Manages initialization of all of Gosu's core components
+    //! and provides timing functionality.
+    //! Note that you should really only use one instance of this class at the same time.
+    //! This may or may not change later.
+    class Window
+    {
+        struct Impl;
+        const std::auto_ptr<Impl> pimpl;
+	
+    public:
+        //! Constructs a Window.
+        //! \param updateInterval Interval in milliseconds between two calls
+        //! to the update member function.
+        Window(unsigned width, unsigned height, bool fullscreen,
+            double updateInterval = 16.666666);
+        virtual ~Window();
+
+        std::wstring caption() const;
+        void setCaption(const std::wstring& caption);
+        
+        double updateInterval() const;
+
+        //! Enters a modal loop where the Window is visible on screen and
+        //! receives calls to draw, update etc.
+        void show();
+        //! Closes the window if it is currently shown.
+        void close();
+
+        //! Called every updateInterval milliseconds while the window is being
+        //! shown. Your application's main game logic goes here.
+        virtual void update() {}
+        //! Called after every update and when the OS wants the window to
+        //! repaint itself. Your application's rendering code goes here.
+        virtual void draw() {}
+        
+        //! Gives the game a chance to say no to being redrawn.
+        //! This is not a definitive answer. The operating system can still cause
+        //! redraws for one reason or another.
+        //! By default, the window is redrawn all the time.
+        virtual bool needsRedraw() const { return true; }
+
+        //! If this function returns true, the system arrow cursor is drawn while
+        //! over the window.
+        virtual bool needsCursor() const { return false; }
+        
+        //! This function is called when the window loses focus on some platforms.
+        //! Most importantly, it is called on the iPhone or iPad when the user
+        //! locks the screen.
+        virtual void loseFocus() {}
+        
+        //! This function is called when the operating system's memory is low.
+        //! So far, it is only called in iOS applications.
+        virtual void releaseMemory() {}
+        
+        //! Called before update when the user pressed a button while the
+        //! window had the focus.
+        virtual void buttonDown(Gosu::Button) {}
+        //! Same as buttonDown. Called then the user released a button.
+        virtual void buttonUp(Gosu::Button) {}
+        
+        // Ignore when SWIG is wrapping this class for Ruby/Gosu.
+        #ifndef SWIG
+        
+        const Graphics& graphics() const;
+        Graphics& graphics();
+        
+        const Input& input() const;
+        Input& input();
+        
+        #ifdef GOSU_IS_WIN
+        // Only on Windows, used for integrating with GUI toolkits.
+        HWND handle() const;
+        virtual LRESULT handleMessage(UINT message, WPARAM wparam,
+            LPARAM lparam);
+        #endif
+        
+        #ifdef GOSU_IS_UNIX
+        // Context for creating shared contexts.
+        // Only on Unices (so far).
+        typedef std::tr1::shared_ptr<std::tr1::function<void()> > SharedContext;
+        SharedContext createSharedContext();
+        #endif
+        
+        #ifdef GOSU_IS_IPHONE
+        // iPhone-only callbacks for touch events.
+        // Note that it does not hurt to override them even if you compile
+        // for another platform; if you don't specify "virtual" the code
+        // should even be stripped away cleanly.
+        virtual void touchBegan(Touch touch) {}
+        virtual void touchMoved(Touch touch) {}
+        virtual void touchEnded(Touch touch) {}
+        #endif        
+        
+        const Audio& audio() const;
+        Audio& audio();
+
+        #endif
+    };
+}
+
+#endif

data/README.txt

@@ -0,0 +1,25 @@
+ Moin and welcome to Gosu!
+
+ Gosu's main website is http://www.libgosu.org/, which always has the latest
+links to all relevant information.
+
+ The actual source code, wiki, issue tracker etc. are all hosted on GitHub:
+
+    http://github.com/jlnr/gosu/
+
+ The best entry point into Gosu's documentation is the wiki home page:
+
+    http://github.com/jlnr/gosu/wiki
+
+ Try doing the tutorial there if you don't know how to start out. Or look at
+one of the games in the Gosu Users board.
+
+ Remember that Gosu is licensed under the MIT license and feel invited to fork,
+port and transmogrify all parts of it. The only license that may affect you by
+indirection is libogg's (BSD-style). If you release a Gosu game in any common
+binary form, you will need to mention use of libogg and libvorbis somewhere.
+ 
+ Complaints, questions, feedback?
+* Visit the boards,                         http://www.libgosu.org/
+* try your luck in the chat,              irc://irc.freenode.org/gosu
+* or e-mail me. Have fun, write games!         julian@raschke.de

data/examples/ChipmunkIntegration.rb

@@ -0,0 +1,275 @@
+## File: ChipmunkIntegration.rb
+## Author: Dirk Johnson
+## Version: 1.0.0
+## Date: 2007-10-05
+## License: Same as for Gosu (MIT)
+## Comments: Based on the Gosu Ruby Tutorial, but incorporating the Chipmunk Physics Engine
+## See https://github.com/jlnr/gosu/wiki/Ruby-Chipmunk-Integration for the accompanying text.
+
+require 'rubygems'
+require 'gosu'
+require 'chipmunk'
+
+SCREEN_WIDTH = 640
+SCREEN_HEIGHT = 480
+
+# The number of steps to process every Gosu update
+# The Player ship can get going so fast as to "move through" a
+# star without triggering a collision; an increased number of
+# Chipmunk step calls per update will effectively avoid this issue
+SUBSTEPS = 6
+
+# Convenience method for converting from radians to a Vec2 vector.
+class Numeric
+  def radians_to_vec2
+    CP::Vec2.new(Math::cos(self), Math::sin(self))
+  end
+end
+
+# Layering of sprites
+module ZOrder
+  Background, Stars, Player, UI = *0..3
+end
+
+# This game will have one Player in the form of a ship
+class Player
+  attr_reader :shape
+
+  def initialize(window, shape)
+    @image = Gosu::Image.new(window, "media/Starfighter.bmp", false)
+    @shape = shape
+    @shape.body.p = CP::Vec2.new(0.0, 0.0) # position
+    @shape.body.v = CP::Vec2.new(0.0, 0.0) # velocity
+    
+    # Keep in mind that down the screen is positive y, which means that PI/2 radians,
+    # which you might consider the top in the traditional Trig unit circle sense is actually
+    # the bottom; thus 3PI/2 is the top
+    @shape.body.a = (3*Math::PI/2.0) # angle in radians; faces towards top of screen
+  end
+  
+  # Directly set the position of our Player
+  def warp(vect)
+    @shape.body.p = vect
+  end
+  
+  # Apply negative Torque; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep turning rate constant
+  # even if the number of steps per update are adjusted
+  def turn_left
+    @shape.body.t -= 400.0/SUBSTEPS
+  end
+  
+  # Apply positive Torque; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep turning rate constant
+  # even if the number of steps per update are adjusted
+  def turn_right
+    @shape.body.t += 400.0/SUBSTEPS
+  end
+  
+  # Apply forward force; Chipmunk will do the rest
+  # SUBSTEPS is used as a divisor to keep acceleration rate constant
+  # even if the number of steps per update are adjusted
+  # Here we must convert the angle (facing) of the body into
+  # forward momentum by creating a vector in the direction of the facing
+  # and with a magnitude representing the force we want to apply
+  def accelerate
+    @shape.body.apply_force((@shape.body.a.radians_to_vec2 * (3000.0/SUBSTEPS)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Apply even more forward force
+  # See accelerate for more details
+  def boost
+    @shape.body.apply_force((@shape.body.a.radians_to_vec2 * (3000.0)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Apply reverse force
+  # See accelerate for more details
+  def reverse
+    @shape.body.apply_force(-(@shape.body.a.radians_to_vec2 * (1000.0/SUBSTEPS)), CP::Vec2.new(0.0, 0.0))
+  end
+  
+  # Wrap to the other side of the screen when we fly off the edge
+  def validate_position
+    l_position = CP::Vec2.new(@shape.body.p.x % SCREEN_WIDTH, @shape.body.p.y % SCREEN_HEIGHT)
+    @shape.body.p = l_position
+  end
+  
+  def draw
+    @image.draw_rot(@shape.body.p.x, @shape.body.p.y, ZOrder::Player, @shape.body.a.radians_to_gosu)
+  end
+end
+
+# See how simple our Star is?
+# Of course... it just sits around and looks good...
+class Star
+  attr_reader :shape
+  
+  def initialize(animation, shape)
+    @animation = animation
+    @color = Gosu::Color.new(0xff000000)
+    @color.red = rand(255 - 40) + 40
+    @color.green = rand(255 - 40) + 40
+    @color.blue = rand(255 - 40) + 40
+    @shape = shape
+    @shape.body.p = CP::Vec2.new(rand * SCREEN_WIDTH, rand * SCREEN_HEIGHT) # position
+    @shape.body.v = CP::Vec2.new(0.0, 0.0) # velocity
+    @shape.body.a = (3*Math::PI/2.0) # angle in radians; faces towards top of screen
+  end
+
+  def draw  
+    img = @animation[Gosu::milliseconds / 100 % @animation.size];
+    img.draw(@shape.body.p.x - img.width / 2.0, @shape.body.p.y - img.height / 2.0, ZOrder::Stars, 1, 1, @color, :add)
+  end
+end
+
+# The Gosu::Window is always the "environment" of our game
+# It also provides the pulse of our game
+class GameWindow < Gosu::Window
+  def initialize
+    super(SCREEN_WIDTH, SCREEN_HEIGHT, false, 16)
+    self.caption = "Gosu & Chipmunk Integration Demo"
+    @background_image = Gosu::Image.new(self, "media/Space.png", true)
+
+    # Put the beep here, as it is the environment now that determines collision
+    @beep = Gosu::Sample.new(self, "media/Beep.wav")
+    
+    # Put the score here, as it is the environment that tracks this now
+    @score = 0
+    @font = Gosu::Font.new(self, Gosu::default_font_name, 20)
+    
+    # Time increment over which to apply a physics "step" ("delta t")
+    @dt = (1.0/60.0)
+    
+    # Create our Space and set its damping
+    # A damping of 0.8 causes the ship bleed off its force and torque over time
+    # This is not realistic behavior in a vacuum of space, but it gives the game
+    # the feel I'd like in this situation
+    @space = CP::Space.new
+    @space.damping = 0.8    
+    
+    # Create the Body for the Player
+    body = CP::Body.new(10.0, 150.0)
+    
+    # In order to create a shape, we must first define it
+    # Chipmunk defines 3 types of Shapes: Segments, Circles and Polys
+    # We'll use s simple, 4 sided Poly for our Player (ship)
+    # You need to define the vectors so that the "top" of the Shape is towards 0 radians (the right)
+    shape_array = [CP::Vec2.new(-25.0, -25.0), CP::Vec2.new(-25.0, 25.0), CP::Vec2.new(25.0, 1.0), CP::Vec2.new(25.0, -1.0)]
+    shape = CP::Shape::Poly.new(body, shape_array, CP::Vec2.new(0,0))
+    
+    # The collision_type of a shape allows us to set up special collision behavior
+    # based on these types.  The actual value for the collision_type is arbitrary
+    # and, as long as it is consistent, will work for us; of course, it helps to have it make sense
+    shape.collision_type = :ship
+    
+    @space.add_body(body)
+    @space.add_shape(shape)
+
+    @player = Player.new(self, shape)
+    @player.warp(CP::Vec2.new(320, 240)) # move to the center of the window
+    
+    @star_anim = Gosu::Image::load_tiles(self, "media/Star.png", 25, 25, false)
+    @stars = Array.new
+        
+    # Here we define what is supposed to happen when a Player (ship) collides with a Star
+    # I create a @remove_shapes array because we cannot remove either Shapes or Bodies
+    # from Space within a collision closure, rather, we have to wait till the closure
+    # is through executing, then we can remove the Shapes and Bodies
+    # In this case, the Shapes and the Bodies they own are removed in the Gosu::Window.update phase
+    # by iterating over the @remove_shapes array
+    # Also note that both Shapes involved in the collision are passed into the closure
+    # in the same order that their collision_types are defined in the add_collision_func call
+    @remove_shapes = []
+    @space.add_collision_func(:ship, :star) do |ship_shape, star_shape|
+      @score += 10
+      @beep.play
+      @remove_shapes << star_shape
+    end
+    
+    # Here we tell Space that we don't want one star bumping into another
+    # The reason we need to do this is because when the Player hits a Star,
+    # the Star will travel until it is removed in the update cycle below
+    # which means it may collide and therefore push other Stars
+    # To see the effect, remove this line and play the game, every once in a while
+    # you'll see a Star moving
+    @space.add_collision_func(:star, :star, &nil)
+  end
+
+  def update
+    # Step the physics environment SUBSTEPS times each update
+    SUBSTEPS.times do
+      # This iterator makes an assumption of one Shape per Star making it safe to remove
+      # each Shape's Body as it comes up
+      # If our Stars had multiple Shapes, as would be required if we were to meticulously
+      # define their true boundaries, we couldn't do this as we would remove the Body
+      # multiple times
+      # We would probably solve this by creating a separate @remove_bodies array to remove the Bodies
+      # of the Stars that were gathered by the Player
+      @remove_shapes.each do |shape|
+        @stars.delete_if { |star| star.shape == shape }
+        @space.remove_body(shape.body)
+        @space.remove_shape(shape)
+      end
+      @remove_shapes.clear # clear out the shapes for next pass
+      
+      # When a force or torque is set on a Body, it is cumulative
+      # This means that the force you applied last SUBSTEP will compound with the
+      # force applied this SUBSTEP; which is probably not the behavior you want
+      # We reset the forces on the Player each SUBSTEP for this reason
+      @player.shape.body.reset_forces
+      
+      # Wrap around the screen to the other side
+      @player.validate_position
+      
+      # Check keyboard
+      if button_down? Gosu::KbLeft
+        @player.turn_left
+      end
+      if button_down? Gosu::KbRight
+        @player.turn_right
+      end
+      
+      if button_down? Gosu::KbUp
+        if ( (button_down? Gosu::KbRightShift) || (button_down? Gosu::KbLeftShift) )
+          @player.boost
+        else
+          @player.accelerate
+        end
+      elsif button_down? Gosu::KbDown
+        @player.reverse
+      end
+      
+      # Perform the step over @dt period of time
+      # For best performance @dt should remain consistent for the game
+      @space.step(@dt)
+    end
+    
+    # Each update (not SUBSTEP) we see if we need to add more Stars
+    if rand(100) < 4 and @stars.size < 25 then
+      body = CP::Body.new(0.0001, 0.0001)
+      shape = CP::Shape::Circle.new(body, 25/2, CP::Vec2.new(0.0, 0.0))
+      shape.collision_type = :star
+      
+      @space.add_body(body)
+      @space.add_shape(shape)
+      
+      @stars.push(Star.new(@star_anim, shape))
+    end
+  end
+
+  def draw
+    @background_image.draw(0, 0, ZOrder::Background)
+    @player.draw
+    @stars.each { |star| star.draw }
+    @font.draw("Score: #{@score}", 10, 10, ZOrder::UI, 1.0, 1.0, 0xffffff00)
+  end
+
+  def button_down(id)
+    if id == Gosu::KbEscape
+      close
+    end
+  end
+end
+
+window = GameWindow.new
+window.show