tung-tea 0.0.4

data/doc/example/smile_move.rb

@@ -0,0 +1,56 @@
+require 'tea'
+
+class Smile
+  def initialize
+    @bitmap = Tea::Bitmap.new('smile.png')
+    @x = (Tea::Screen.w - @bitmap.w) / 2
+    @y = (Tea::Screen.h - @bitmap.h) / 2
+    @dx = @dy = 0
+  end
+
+  def n(move) @dy += move ? -1 : 1 end
+  def s(move) @dy += move ? 1 : -1 end
+  def e(move) @dx += move ? 1 : -1 end
+  def w(move) @dx += move ? -1 : 1 end
+  def stopped?; @dx == 0 && @dy == 0; end
+
+  def update
+    @x += @dx
+    @y += @dy
+  end
+
+  def draw
+    Tea::Screen.blit @bitmap, @x, @y
+  end
+end
+
+Tea.init
+Tea::Screen.set_mode 640, 480
+player = Smile.new
+wait_for_event = true
+loop do
+  player.update
+  Tea::Screen.clear
+  player.draw
+  Tea::Screen.update
+
+  if e = Tea::Event.get(wait_for_event)
+    break if e.class == Tea::App::Exit
+
+    case e
+    when Tea::Kbd::Down then move = true
+    when Tea::Kbd::Up   then move = false
+    else next
+    end
+
+    case e.key
+    when Tea::Kbd::UP     then player.n(move)
+    when Tea::Kbd::DOWN   then player.s(move)
+    when Tea::Kbd::RIGHT  then player.e(move)
+    when Tea::Kbd::LEFT   then player.w(move)
+    when Tea::Kbd::ESCAPE then break
+    end
+
+    wait_for_event = player.stopped?
+  end
+end

data/doc/example/state_app.rb

@@ -0,0 +1,33 @@
+# Test that the app state is correctly reported.
+# Expected results: minimized app state, keybord and mouse focus is correctly
+# reported.
+
+require 'tea'
+
+puts <<TEST
+Try...
+
+ * minimising/restoring the window
+ * moving the mouse in/out of the window
+ * changing focus in/out of the window
+
+The app visibility, mouse and keyboard focus will be reported below.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 320, 240
+e = nil
+puts '%19s %20s%20s%20s' % ['EVENT', 'APP VISIBILITY', 'KEYBOARD', 'MOUSE']
+puts '-' * 80
+loop do
+  visible = Tea::App.visible?  ? 'visible'     : 'not visible'
+  kbd     = Tea::Kbd.in_app?   ? 'keyboard in' : 'keyboard not in'
+  mouse   = Tea::Mouse.in_app? ? 'mouse in'    : 'mouse not in'
+  puts '%19s:%20s%20s%20s' % [e.class, visible, kbd, mouse]
+  begin
+    e = Tea::Event.get(true)
+    exit if e.class == Tea::App::Exit
+  end until [Tea::App::Minimized, Tea::App::Restored,
+             Tea::Kbd::Lost,      Tea::Kbd::Gained,
+             Tea::Mouse::Lost,    Tea::Mouse::Gained].include?(e.class)
+end

data/doc/example/state_keyboard.rb

@@ -0,0 +1,23 @@
+# Test that the keyboard state is being picked up.
+# Expected output is that all keyboard events will print if the 'A' key is
+# being pressed, and if Num Lock is active.
+
+require 'tea'
+
+puts <<TEST
+Press some keys.  Printed lines will tell if 'A' is being pressed,
+and if Num Lock is active.
+TEST
+
+Tea.init
+Tea::Screen.set_mode 320, 240
+loop do
+  a_down = Tea::Kbd.key_down?(Tea::Kbd::A) ? 'DOWN' : 'UP'
+  num_lock_active = Tea::Kbd.mod_active?(Tea::Kbd::NUM_LOCK) ? 'ON' : 'OFF'
+  puts "'A' is #{a_down}; Num Lock is #{num_lock_active}"
+  begin
+    e = Tea::Event.get(true)
+    exit if e.class == Tea::App::Exit
+  end until e.class == Tea::Kbd::Down || e.class == Tea::Kbd::Up
+  print "(#{e.key}); "
+end

data/doc/example/state_mouse.rb

@@ -0,0 +1,60 @@
+# Test that the mouse status is correctly reported.
+# Expected results include the mouse x, y, left, middle and right button down
+# status, printed whenever the mouse is used in the 400x300 screen window.
+
+require 'tea'
+
+puts <<TEST
+Move the mouse in the window.  Mouse x, y, and left/middle/right button down
+status should be reported here.
+TEST
+
+##############################################################################
+# Swiped from event_mouse.rb.  I'd make a module, but I don't want to clutter
+# this demo directory.
+
+# We can avoid flooding the terminal with VT100 codes.  Sorry Windows.
+$windows = RUBY_PLATFORM =~ /w(?:in)?32/
+SAVE_POSITION = "\x1b[s"
+RESTORE_POSITION = "\x1b[u"
+HIDE_CURSOR = "\x1b[?25l"
+UNHIDE_CURSOR = "\x1b[?25h"
+CLEAR_TO_LINE_END = "\x1b[K"
+
+# VT100-enhanced printing function that overwrites the current terminal line.
+def pr(*args)
+  print HIDE_CURSOR, SAVE_POSITION if !$windows
+  print *args
+  if $windows
+    puts
+  else
+    print CLEAR_TO_LINE_END, RESTORE_POSITION, UNHIDE_CURSOR
+  end
+end
+
+##############################################################################
+
+Tea.init
+Tea::Screen.set_mode 400, 300
+have_mouse = true
+loop do
+  begin
+    e = Tea::Event.get(true)
+    exit if e.class == Tea::App::Exit
+  end until [Tea::Mouse::Move,
+             Tea::Mouse::Down,
+             Tea::Mouse::Up,
+             Tea::Mouse::Gained,
+             Tea::Mouse::Lost].include?(e.class)
+
+  case e
+  when Tea::Mouse::Gained then have_mouse = true
+  when Tea::Mouse::Lost   then have_mouse = false
+  end
+
+  if have_mouse
+    pr "Mouse (#{Tea::Mouse.x}, #{Tea::Mouse.y}), [#{Tea::Mouse.left?}|#{Tea::Mouse.middle?}|#{Tea::Mouse.right?}]"
+  else
+    pr "Mouse is out of the house"
+  end
+end

data/lib/tea/c_bitmap.rb

@@ -0,0 +1,55 @@
+# This file holds the Bitmap class, which are grids of pixels that hold
+# graphics.
+
+require 'sdl'
+
+require 'tea/m_blitting'
+require 'tea/m_primitive_drawing'
+
+#
+module Tea
+
+  # A Bitmap is a grid of pixels that holds graphics.
+  class Bitmap
+
+    # Create a new Bitmap from an image file.
+    #
+    # May raise Tea::Error if it fails.
+    def initialize(image_path)
+      begin
+        @buffer = SDL::Surface.load(image_path)
+
+        # Optimise for the screen mode, potentially making screen blits faster.
+        if Tea::Screen.mode_set?
+          @buffer = @buffer.display_format_alpha
+        else
+          Tea::Screen.on_set_mode lambda { @buffer = @buffer.display_format_alpha }
+        end
+      rescue SDL::Error => e
+        raise Tea::Error, e.message, e.backtrace
+      end
+    end
+
+    # Get the width of the Bitmap in pixels.
+    def w
+      @buffer.w
+    end
+
+    # Get the height of the Bitmap in pixels.
+    def h
+      @buffer.h
+    end
+
+    include Tea::Blitting
+    def blittable_buffer
+      @buffer
+    end
+
+    include Tea::PrimitiveDrawing
+    def primitive_buffer
+      @buffer
+    end
+
+  end
+
+end

data/lib/tea/c_error.rb

@@ -0,0 +1,10 @@
+# This file holds the Error class.
+
+#
+module Tea
+
+  # Error is the exception class raised when Bad Things happen in any of
+  # Tea's objects or methods.
+  class Error < StandardError; end
+
+end

data/lib/tea/m_blitting.rb

@@ -0,0 +1,31 @@
+# This file contains the Blitting mixin.
+
+require 'sdl'
+
+#
+module Tea
+
+  # The Blitting mixin allows objects with SDL::Surface to draw or 'blit' onto
+  # each other.
+  #
+  # To use this mixin, include it and write/alias a blittable_buffer method
+  # that gets the SDL::Surface.
+  #
+  #   include Blitting
+  #   def blittable_buffer
+  #     @my_sdl_surface
+  #   end
+  module Blitting
+
+    # Draw the source_blittable onto the current object at (x, y).
+    #
+    # source_blittable needs to include the Blitting mixin too.
+    def blit(source_blittable, x, y)
+      src = source_blittable.send(:blittable_buffer)
+      dest = blittable_buffer
+      SDL::Surface.blit src, 0, 0, src.w, src.h, dest, x, y
+    end
+
+  end
+
+end

data/lib/tea/m_event.rb

@@ -0,0 +1,65 @@
+# This file holds the core Event module.
+
+require 'sdl'
+
+require 'tea/c_error'
+require 'tea/m_event_app'
+require 'tea/m_event_keyboard'
+require 'tea/m_event_mouse'
+
+#
+module Tea
+
+  # The Event module allows access to the event queue, and the classes of
+  # events that come out.  Event handling is the heart and soul of most games,
+  # so this module is quite important.
+  module Event
+
+    # Tea's generated event queue.  Add to the back, get from the front.
+    @@event_queue = []
+
+    # Get the next event in the event queue.  If wait is true and there are no
+    # events to return, this method will wait until there is one and return it.
+    # Otherwise, an empty event queue will return nil.
+    #
+    # May raise Tea::Error if getting an event fails.
+    def Event.get(wait=false)
+      if @@event_queue.length == 0
+        if wait
+          begin
+            sdl_event = SDL::Event.wait
+            if (out_events = translate_event(sdl_event))
+              @@event_queue.push *out_events
+            end
+          end until @@event_queue.length > 0
+        else
+          if (out_events = translate_event(SDL::Event.poll))
+            @@event_queue.push *out_events
+          end
+        end
+      end
+
+      tea_event = @@event_queue.shift
+      [App, Mouse, Kbd].each { |state_holder| state_holder.update_state tea_event }
+      tea_event
+    rescue SDL::Error => e
+      raise Tea::Error, e.message, e.backtrace
+    end
+
+    # Convert an SDL::Event into one or more Tea events.  May return nil, a
+    # single event object or multiple events in an array.
+    def Event.translate_event(sdl_event)
+      case sdl_event
+      when SDL::Event::Active, SDL::Event::Quit
+        translate_app_event sdl_event
+      when SDL::Event::MouseMotion, SDL::Event::MouseButtonDown, SDL::Event::MouseButtonUp
+        translate_mouse_event sdl_event
+      when SDL::Event::KeyDown, SDL::Event::KeyUp
+        translate_keyboard_event sdl_event
+      end
+    end
+    private_class_method :translate_event
+
+  end
+
+end

data/lib/tea/m_event_app.rb

@@ -0,0 +1,91 @@
+# This file holds app-related event handling.
+
+require 'sdl'
+
+# A hot-patch to Ruby/SDL for missing SDL::Event::Active#state constants.
+module SDL
+  class Event
+    APPMOUSEFOCUS = 0x01
+    APPINPUTFOCUS = 0x02
+    APPACTIVE     = 0x04
+  end
+end
+
+#
+module Tea
+
+  module Mouse
+    # Event generated when mouse focus is gained.
+    class Gained; end
+
+    # Event generated when mouse focus is lost.
+    class Lost; end
+  end
+
+  module Kbd
+    # Event generated when keyboard input focus is gained.
+    class Gained; end
+
+    # Event generated when keyboard input focus is lost.
+    class Lost; end
+  end
+
+  module App
+    # Event generated when the player acts to close the screen window.
+    class Exit; end
+
+    # Event generated when the screen window is minimised.
+    class Minimized; end
+
+    # Event generated when the screen window is restored from being minimised.
+    class Restored; end
+
+    # Returns true if the screen window has not been minimised, otherwise
+    # false.
+    def App.visible?
+      @visible = true if !instance_variable_defined?(:@visible)
+      @visible
+    end
+
+    # Update the reported app state when a Tea event is retrieved, so
+    # App.visible? returns the right status.  Called automatically by
+    # Event.get.
+    def App.update_state(tea_event)
+      case tea_event
+      when Minimized then @visible = false
+      when Restored  then @visible = true
+      end
+      @visible
+    end
+  end
+
+  module Event
+
+    # Translates an app-related SDL::Event into an array of Tea::Event
+    # objects.  For internal use only.
+    def Event.translate_app_event(sdl_event)
+      out_events = []
+
+      case sdl_event
+      when SDL::Event::Quit
+        out_events.push App::Exit.new
+
+      when SDL::Event::Active
+        if (sdl_event.state & SDL::Event::APPACTIVE) != 0
+          out_events.push sdl_event.gain ? App::Restored.new : App::Minimized.new
+        end
+        if (sdl_event.state & SDL::Event::APPINPUTFOCUS) != 0
+          out_events.push sdl_event.gain ? Kbd::Gained.new : Kbd::Lost.new
+        end
+        if (sdl_event.state & SDL::Event::APPMOUSEFOCUS) != 0
+          out_events.push sdl_event.gain ? Mouse::Gained.new : Mouse::Lost.new
+        end
+      end
+
+      out_events
+    end
+    private_class_method :translate_app_event
+
+  end
+
+end