rubydraw 0.1.0

data/README

@@ -0,0 +1,20 @@
+Rubydraw is a high level game/graphics library, like Gosu or Rubygame, and is written in Ruby.
+Its only dependency is ruby-sdl-ffi, which it uses to access SDL functions.
+–––––
+NOTE: I can't get +ruby-sdl-ffi+ (the library Rubydraw uses to access SDL) to work with +Ruby
+1.9.2+, so I don't know if it even does. If it does work, and/or you know how to make it work,
+I would appreciate it if you notify me. So basically, I can't test anything with +1.9.2+. Sorry
+for the inconvenience!
+
+HOW TO INSTALL
+To install this library which isn't on Rubygems.org YET, navigate to this directory in the command
+line tool and give "rubydraw/build_and_install" permissions to run. Then simply run it. Hooray, it
+should be working now! Test it in irb with "require 'rubydraw'". Also: I will upload this gem to
+rubygems when it is actually usable (if it ever is).
+
+HOW TO USE
+There isn't a proper guide yet, so just read the comments in the other files. Or you can fire up the
+gem server and read the RDoc.
+
+Thanks for checking this little project. I hope it doesn't give you headaches.
+Have fun!

data/examples/image_ex.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rubydraw'
+
+class MyWindow < Rubydraw::Window
+  # Create a new window with an bug image inside it
+  def initialize(width, height)
+    super(width, height)
+    @image = Rubydraw::Image.new(self, "media/bug.png")
+    @max = 100
+
+    register_action(Rubydraw::Events::MouseMove) {|event| puts "Mouse moved! New position: #{event.position.x}, #{event.position.y}"}
+    register_action(Rubydraw::Events::QuitRequest) {close}
+  end
+
+  def mouse_moved(event)
+    new_position = event.position
+    puts "Mouse moved! New position: #{new_position.x}, #{new_position.y}"
+  end
+
+  # Draw the image inside this window.
+  def tick
+    @image.draw(Rubydraw::Point[width / 2, height / 2])
+  end
+end
+
+w = MyWindow.new(300, 300)
+w.open

data/examples/window_ex.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'rubydraw'
+
+class MyWindow < Rubydraw::Window
+  def initialize(width, height)
+    super(width, height)
+    puts "New window created with width: #{@width} and height #{@height}"
+  end
+  def handle_event(event)
+    case event
+    when Rubydraw::Event::Quit
+      close
+    end
+  end
+end
+
+print "Window height: "
+w = gets.to_i
+print "Window width: "
+h = gets.to_i
+
+window = MyWindow.new(w, h).open
+
+# Wait for a while to let the user enjoy the window
+sleep 10

data/lib/rubydraw.rb

@@ -0,0 +1,32 @@
+# The only dependency
+require 'ruby-sdl-ffi'
+
+# Require all the rubydraw files
+#files = ["window", "image", "sdl_error", "event_queue", "events", "point"]
+files = %w[
+  window
+  image
+  sdl_error
+  keys
+  event_queue
+  events
+  point]
+files.each {|f| require("rubydraw/" + f)}
+
+# Rubydraw is a high level game/graphics library, like Gosu or Rubygame, and is written completely
+# in Ruby. Its only dependency is ruby-sdl-ffi, which it uses to access SDL functions.
+#
+# NOTE: I can't get +ruby-sdl-ffi+ (the library Rubydraw uses to access SDL) to work with +Ruby
+# 1.9.2,+ so I don't know if it even does. If it does work, and/or you know how to make it work,
+# I would appreciate it if you notify me. So basically, I can't test anything with +1.9.2+. Sorry
+# for the inconvenience!
+module Rubydraw
+  # Initialize SDL.
+  def self.initialize_sdl
+    if SDL::Init(SDL::INIT_EVERYTHING) != 0
+      raise DrawError "Could not initialize SDL"
+    end
+  end
+end
+
+Rubydraw::initialize_sdl

data/lib/rubydraw/event_queue.rb

@@ -0,0 +1,16 @@
+module Rubydraw
+  # Rubydraw uses an EventQueue to collect SDL events, e.g. mouse movements
+  # keystrokes, and window actions. A new EventQueue is automatically created
+  # when a Rubydraw::Window is initialized. Every tick, the window asks its
+  # event queue (created in Rubydraw::Window#initialize) for the new events
+  class EventQueue
+    # Get all the new events
+    def get_events
+      events = []
+      until((event = SDL::PollEvent()).nil?)
+        events << Events.match(event)
+      end
+      events
+    end
+  end
+end

data/lib/rubydraw/events.rb

@@ -0,0 +1,192 @@
+class Object
+  # Returns false by default. Is overridden in Rubydraw::Events::Event#is_event?
+  def event?
+    false
+  end
+end
+
+class Class
+  # Returns all subclasses. Credit goes to http://stackoverflow.com/questions/436159/how-to-get-all-subclasses
+  def all_subclasses
+    result = []
+    ObjectSpace.each_object(Class) { |klass| result << klass if klass < self }
+    result
+  end
+end
+
+module Rubydraw
+  # A module containing Rubydraw events and their SDL event "bindings".
+  module Events
+    # Translate the given SDL event to its corresponding Rubydraw event, by asking
+    # each event class if it matches the SDL event. No case statements here.
+    def self.match(sdl_event)
+      sdl_event_type = sdl_event.type
+      event_classes = Event.all_subclasses.compact
+      rubydraw_event = UnknownEvent.new
+      event_classes.each { |event| rubydraw_event = event.from_sdl_event(sdl_event) if event.matches?(sdl_event_type) }
+      rubydraw_event
+    end
+
+    # The basic Event class. All events should inherit from this class, otherwise it
+    # won't be recognized as an event and therefore will *not* participate in event
+    # matching.
+    class Event
+      # Just creates a new instance of this class by default. Override this if the subclass
+      # requires parameters in +initialize,+ like Rubydraw::Events::MouseDown::from_sdl_event.
+      def self.from_sdl_event(sdl_event)
+        self.new
+      end
+
+      # Returns true if this is the overlaying class for the given SDL event. Override this
+      # for custom matching.
+      def self.matches?(sdl_event)
+        sdl_event == matching_sdl_event
+      end
+
+      # Returns true for all event objects. Also see Object#event?
+      def event?
+        true
+      end
+
+      # Returns the matching SDL event, override this in subclasses. Returns nil by
+      # default.
+      def self.matching_sdl_event
+        nil
+      end
+    end
+
+    # A special event class that is called when no Rubydraw event is matched to an
+    # SDL event.
+    class UnknownEvent < Event
+    end
+
+    # Provides methods used in both Rubydraw::Events::KeyPressed and
+    # Rubydraw::Events::KeyReleased. No instances of this class should be created,
+    # but instances of subclasses are fine.
+    class KeyboardEvent < Event
+      def self.from_sdl_event(sdl_event)
+        self.new(sdl_event.keysym.sym)
+      end
+
+      attr_reader(:key)
+
+      def initialize(key)
+        unless key.is_a?(Numeric)
+          raise SDLError "Failed to create new event because key is not a number."
+        end
+
+        @key = key
+      end
+    end
+
+    # Created when any keyboard button is pressed, specifying the key.
+    #
+    # @key::  An integer specifying the key, which can be matched with a Rubydraw
+    #         button constants.
+    class KeyPressed < KeyboardEvent
+      def self.matching_sdl_event
+        SDL::KEYDOWN
+      end
+    end
+
+    # Created when any keyboard button is released, specifying the key.
+    #
+    # @key::  An integer specifying the key, which can be matched with a Rubydraw
+    #         button constants.
+    class KeyReleased < KeyboardEvent
+      def self.matching_sdl_event
+        SDL::KEYUP
+      end
+    end
+
+    # Provides methods used in Rubydraw::Events::MousePressed and Rubydraw::Events::MouseReleased.
+    # No instances of this class should be created, but instances of subclasses are find.
+    class MouseButtonEvent
+      def from_sdl_event(sdl_event)
+        self.new(Point[sdl_event.x, sdl_event.y], sdl_events.button)
+      end
+
+      attr_reader(:position, :button)
+
+      def initialize(position, button)
+        @position, @button = position, button
+      end
+    end
+
+    # Created when a mouse button is down. Note: this event is used for *any* mouse
+    # button.
+    class MousePressed < Event
+      def self.from_sdl_event(sdl_event)
+        self.new(Point[sdl_event.x, sdl_event.y], sdl_event.button)
+      end
+
+      def self.matching_sdl_event
+        SDL::MOUSEBUTTONDOWN
+      end
+
+      attr_reader(:position, :button)
+
+      # Creates a new MousePressed event, specifying where (the position) it happened
+      # and what button was pressed.
+      def initialize(position, button)
+        @position, @button = position, button
+      end
+    end
+
+    # Created when a mouse button is released. Note: this event is used for *any* mouse
+    # button.
+    class MouseReleased < Event
+      def self.from_sdl_event(sdl_event)
+        self.new(Point[sdl_event.x, sdl_event.y], sdl_event.button)
+      end
+
+      def self.matching_sdl_event
+        SDL::MOUSEBUTTONUP
+      end
+
+      attr_reader(:position, :button)
+
+      # Creates a new MouseReleased event, specifying where (the position) it happened and
+      # what button was released.
+      def initialize(position, button)
+        @position, @button = position, button
+      end
+    end
+
+    # Created when the mouse is moved.
+    class MouseMove < Event
+      def self.from_sdl_event(sdl_event)
+        self.new(Point[sdl_event.x, sdl_event.y], Point[sdl_event.xrel, sdl_event.yrel])
+      end
+
+      def self.matching_sdl_event
+        SDL::MOUSEMOTION
+      end
+
+      attr_reader(:position, :relative_position)
+
+      # Create a new MouseMove event with the new mouse position.
+      #
+      # +x+ and +y+:                     The new position of the cursor.
+      #
+      # +relative_x+ and +relative_y+:  The relative movement of the cursor since the last tick.
+      def initialize(position, relative_position)
+        @position, @relative_position = position, relative_position
+      end
+    end
+
+    # Created either when the window gains or loses focus.
+    class WindowFocus
+      def from_sdl_event(sdl_event)
+        self.new(sdl_event.gain)
+      end
+    end
+
+    # Created when the user attempts to close the window.
+    class QuitRequest < Event
+      def self.matching_sdl_event
+        SDL::QUIT
+      end
+    end
+  end
+end

data/lib/rubydraw/image.rb

@@ -0,0 +1,53 @@
+module Rubydraw
+  # Image instances can be initialized with Image#new, passing the
+  # window to draw in, and the path to the image file to draw with.
+  # Then to actually draw the image (doesn't happen immediatley;
+  # read the documentation for Image#draw), call it's #draw method
+  # and pass it the +x+ and +y+ coordinates.
+  class Image
+    # Create a new image in the given window and load the image from
+    # +path.+
+    def initialize(window, path)
+      @window = window
+      unless window.is_a?(Rubydraw::Window)
+        raise Rubydraw::SDLError "Window cannot be nil"
+      end
+      # In case program is being run from a different directory,
+      # provide the _full_ path. Nothing relative here.
+      full_path = File.expand_path path
+      @sdl_image = SDL::Image.Load(full_path)
+      if @sdl_image.pointer.null?
+        # SDL couln't load the image; usually happens because it doesn't
+        # exist.
+        raise Rubydraw::SDLError "Failed to load image from: '#{full_path}'"
+      end
+    end
+
+    # Blit (copy) into the window at +position+ (see point.rb).
+    # No graphical effects are applied.
+    #
+    # Notice that you don't blit surfaces to other surfaces when using
+    # Rubygame, but instead you draw things.
+    def draw(position)
+      source_rect = SDL::Rect.new([0, 0, width, height])
+      blit_rect = SDL::Rect.new([position.x, position.y, @window.width, @window.height])
+      SDL::BlitSurface(@sdl_image, source_rect, @window.sdl_surface, blit_rect)
+    end
+
+    # Returns the image width
+    def width
+      @sdl_image.w
+    end
+
+    # Returns the image height
+    def height
+      @sdl_image.h
+    end
+
+    # Returns the SDL image that was created in Image#initialize.
+    # Rubydraw::Window uses this to draw this Image instance.
+    def sdl_image
+      @sdl_image
+    end
+  end
+end

data/lib/rubydraw/keys.rb

@@ -0,0 +1,95 @@
+module Rubydraw
+  # Keys defines constants which identify with a key integer.
+  #
+  # Example:
+  #
+  #   def handle_event(event)
+  #     case event
+  #       when Rubydraw::Events::KeyPressed
+  #         case event.key
+  #           when Rubydraw::Keys::UpArrow
+  #             @y -= 5
+  #           when Rubydraw::Keys::DownArrow
+  #             @y += 5
+  #           when Rubydraw::Keys::RightArrow
+  #             @x += 1
+  #           when Rubydraw::Keys::LeftArrow
+  #             @x -= 1
+  #         end
+  #   end
+  module Keys
+    UpArrow         = SDL::K_UP
+    DownArrow       = SDL::K_DOWN
+    RightArrow      = SDL::K_RIGHT
+    LeftArrow       = SDL::K_LEFT
+	  # Letters
+    A               = SDL::K_a
+	  B               = SDL::K_b
+	  C               = SDL::K_c
+	  D               = SDL::K_d
+	  E               = SDL::K_e
+	  F               = SDL::K_f
+    G               = SDL::K_g
+    H               = SDL::K_h
+    I               = SDL::K_i
+    J               = SDL::K_j
+    K               = SDL::K_k
+    L               = SDL::K_l
+    M               = SDL::K_m
+    N               = SDL::K_n
+    O               = SDL::K_o
+    P               = SDL::K_p
+    Q               = SDL::K_q
+    R               = SDL::K_r
+    S               = SDL::K_s
+    T               = SDL::K_t
+    U               = SDL::K_u
+    V               = SDL::K_v
+    W               = SDL::K_w
+    X               = SDL::K_x
+    Y               = SDL::K_y
+    Z               = SDL::K_z
+    # Numbers
+    Num0            = SDL::K_0
+    Num1            = SDL::K_1
+    Num2            = SDL::K_2
+    Num3            = SDL::K_3
+    Num4            = SDL::K_4
+    Num5            = SDL::K_5
+    Num6            = SDL::K_6
+    Num7            = SDL::K_7
+    Num8            = SDL::K_8
+    Num9            = SDL::K_9
+    # Shift
+    LeftShift       = SDL::K_LSHIFT
+    RightShift      = SDL::K_RSHIFT
+    # Whitespaces
+    Space           = SDL::K_SPACE
+    Tab             = SDL::K_TAB
+    # Control
+    # Alt/option
+    LeftAlt         = SDL::K_LALT
+    RightAlt        = SDL::K_RALT
+    LeftOption      = LeftAlt
+    RightOption     = RightAlt
+    # Function buttons
+    F1              = SDL::K_F1
+    F2              = SDL::K_F2
+    F3              = SDL::K_F3
+    F4              = SDL::K_F4
+    F5              = SDL::K_F5
+    F6              = SDL::K_F6
+    F7              = SDL::K_F7
+    F8              = SDL::K_F8
+    F9              = SDL::K_F9
+    F10             = SDL::K_F10
+    F11             = SDL::K_F11
+    F12             = SDL::K_F12
+    # Other stuff
+    Escape          = SDL::K_ESCAPE
+    CapsLock        = SDL::K_CAPSLOCK
+    Backspace       = SDL::K_BACKSPACE
+    Delete          = SDL::K_DELETE
+
+  end
+end

data/lib/rubydraw/point.rb

@@ -0,0 +1,22 @@
+module Rubydraw
+  # Used for specifying x and y positions in one class, instead of by themselves or
+  # arrays. Might look like:
+  #
+  # @image.draw(Point[5, 6])
+  class Point
+    # Shorthand new method
+    def self.[](x, y)
+      self.new(x, y)
+    end
+
+    attr_accessor(:x, :y)
+
+    # Create a new point with the given +x+ and +y+ positions.
+    def initialize(x, y)
+      unless x.is_a?(Numeric) and y.is_a?(Numeric)
+        raise RuntimeError "New Point x and y must be a number."
+      end
+      @x, @y = x, y
+    end
+  end
+end

data/lib/rubydraw/sdl_error.rb

@@ -0,0 +1,6 @@
+module Rubydraw
+  # Usually raised by anything pertaining to drawing things with SDL.
+  # Look at the uses to see examples.
+  class SDLError < RuntimeError
+  end
+end

data/lib/rubydraw/window.rb

@@ -0,0 +1,120 @@
+module Rubydraw
+  # Instances of Rubydraw::Window can draw themselves on the screen after you open them.
+  # Note: there can only be one window on the screen at a time; it is a limit
+  # of SDL. One important things about instances of Rubydraw::Window: its main loop
+  # (which starts when Rubydraw::Window#open is called) is *not* forked! It will break
+  # when Rubydraw::Window#close is called (as soon as I get around to implementing this).
+  class Window
+    # Create a new window.
+    def initialize(width, height)
+      unless height.is_a?(Numeric) and width.is_a?(Numeric)
+        # Raise an error
+        raise SDLError "Window width and height have to be a number."
+      end
+
+      @width = width
+      @height = height
+      @open = false
+
+      @event_queue = EventQueue.new
+
+      @registered_actions = {}
+    end
+
+    # Call this method to start updating and drawing.
+    def open
+      @open = true
+      # Behold, the main loop. Drumroll!
+      @screen = SDL::SetVideoMode(@width, @height, 0, 0)
+      loop do
+        handle_events
+        if @open
+          tick
+          # Update the screen to show any changes.
+          SDL::UpdateRect(@screen, 0, 0, 0, 0)
+        else
+          # This is where the loop is broken after Rubydraw::Window#close is called.
+          break
+        end
+          # Pause for a bit, so it's not such a tight loop.
+        sleep 0.1
+      end
+    end
+
+    # Call this method to tell SDL to quit drawing. The loop (started in
+    # Rubydraw::Window#open) would continue if +close+ only stopped drawing, so
+    # break the loop too.
+    def close
+      break_main_loop
+      SDL.QuitSubSystem(SDL::INIT_VIDEO)
+    end
+
+    # Collect and handle new events by executing blocks in +@regestered_events+. See
+    # Rubydraw::Window#register_action on how to use it.
+    def handle_events
+      events = @event_queue.get_events
+
+      events.each {|event|
+        block = @registered_actions[event.class]
+        block.call(event) unless block.nil?}
+    end
+
+    # Redefine this in a subclass to use custom event handling. Does nothing by
+    # default.
+    def handle_event(event)
+    end
+
+    # This causes the main loop to exit. Use Rubydraw::Window#close to close the
+    # window, not this.
+    def break_main_loop
+      @open = false
+    end
+
+    # Returns if this window is open.
+    def open?
+      @open
+    end
+
+    # Return the SDL surface object. Only used in Rubydraw::Image#draw for blitting to
+    # this window.
+    def sdl_surface
+      @screen
+    end
+
+
+    # Redefine Rubydraw::Window#tick with any code you want to be executed
+    # every frame, like drawing functions.
+    #
+    # Does nothing by default.
+    def tick
+    end
+
+    # Return the width of this window.
+    def width
+      @width
+    end
+
+    # Return the height of this window.
+    def height
+      @height
+    end
+
+    # Send +selector+ to +reciever+ when +event+ happens, and include the specific event
+    # instace as a parameter if send_params = true.
+
+    # Execute the given block on the appearance of an instance of +event+.
+    #
+    # Example:
+    #    class MyWindow < Rubydraw::Window
+    #      def initialize
+    #        super(300, 300)
+    #
+    #        register_action(Rubydraw::Events::MouseMove) {|event| new_pos = event.position; puts "Mouse moved to #{new_pos.x}, #{new_pos.y}"}
+    #        register_action(Rubydraw::Events::QuitRequest) {puts "Goodbye!"; close}
+    #      end
+    #    end
+    def register_action(event, &block)
+      @registered_actions[event] = block
+    end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification 
+name: rubydraw
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- J. Wostenberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby-sdl-ffi
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 4
+        version: "0.4"
+  type: :runtime
+  version_requirements: *id001
+description: |-
+  
+      Rubydraw is a high level drawing/game library,
+      like Gosu or Rubygame. Its only dependency is
+      ruby-sdl-ffi, which it uses to access SDL
+      functions.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/rubydraw.rb
+- lib/rubydraw/window.rb
+- lib/rubydraw/image.rb
+- lib/rubydraw/sdl_error.rb
+- lib/rubydraw/keys.rb
+- lib/rubydraw/event_queue.rb
+- lib/rubydraw/events.rb
+- lib/rubydraw/point.rb
+- examples/window_ex.rb
+- examples/image_ex.rb
+- examples/media/bug.png
+has_rdoc: true
+homepage: https://github.com/awostenberg/rubydraw
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Rubydraw is a high level drawing/graphics library, like Gosu or Rubygame
+test_files: []
+