ray 0.0.0.pre1 → 0.0.0.pre2

data/lib/ray/dsl/listener.rb

@@ -0,0 +1,30 @@
+module Ray
+  module DSL
+    # The module that allows you to do something when something else happened.
+    module Listener
+      # The args part of this method may help you to say when you want your
+      # block to be called. Each argument applies to one argument of the
+      # event, and they must all match or your block won't get called.
+      #
+      # It will use == to see if two objects match, except in two cases: if you
+      # pass a Matcher, it will use match?, and if you pass a regex it will try
+      # to use =~.
+      #
+      # Your block will be called with the same arguments as the event, just in
+      # case you'd need them.
+      #
+      def on(event, *args, &block)
+        return unless listener_runner
+        listener_runner.add_handler(event, args, block)
+      end
+
+      def listener_runner
+        @__listener_runner
+      end
+
+      def listener_runner=(arg)
+        @__listener_runner = arg
+      end
+    end
+  end
+end

data/lib/ray/dsl/matcher.rb

@@ -0,0 +1,60 @@
+module Ray
+  # This is the module including all of your matchers as private methods,
+  # allowing you to use them when you call on.
+  module Matchers; end
+
+  module DSL
+    class Matcher
+      def initialize(target, &block)
+        @target = Ray.resolve_type(target)
+        @block = block
+      end
+
+      # @return [true, false] True if we can match on the object of that class
+      def can_match_on?(klass)
+        Ray.resolve_type(klass).ancestors.include? @target
+      end
+
+      # @return [true, false] True if the block this object was created with
+      #                       returns true when called with obj.
+      def match?(obj)
+        can_match_on?(obj.class) && @block.call(obj)
+      end
+
+      alias :=== :match?
+    end
+  end
+
+  # Describes a new matcher.
+  #
+  # @param [Symbol] name The name you'll use to call your matcher
+  # @param [Symbol, Module] target the type on which the matcher operates.
+  # @param [Proc] create_block a block called with the arguments of your matcher
+  #                            method, and returning the block that will be used
+  #                            to check if the condition is matched.
+  # @example
+  #   Ray.describe_matcher(:match, :string) do |regex|
+  #     lambda { |str| str =~ regex }
+  #   end
+  def self.describe_matcher(name, target = :anything, &create_block)
+    Matchers.module_eval do
+      define_method(name) do |*args, &block|
+        DSL::Matcher.new(target, &create_block.call(*args, &block))
+      end
+
+      private name
+    end
+  end
+
+  # This is the universal matcher, using a lambda so you can create
+  # an anonymous matcher if you only need it once, hence you don't want
+  # to name it.
+  #
+  # @example
+  #   on :foo, where { |i| i > 10 } do |i|
+  #     puts "#{i} is greater than 10!"
+  #   end
+  describe_matcher(:where) do |&block|
+    lambda { |o| block.call(o) }
+  end
+end

data/lib/ray/dsl/type.rb

@@ -0,0 +1,58 @@
+module Ray
+  module DSL
+    # The module that knows about all the type you registred.
+    module Type
+      @@types = {}
+
+      class << self
+        def register_type(name, klass)
+          @@types[name] = klass
+        end
+
+        def know_type?(name)
+          (@@types[name] != nil)
+        end
+
+        def resolve_type(name)
+          @@types[name]
+        end
+      end
+    end
+  end
+
+  # Registers a type. It allows you to say name instead of klass
+  # when Ray asks you for a typename.
+  # @param [Symbol] name The object that will represent klass
+  # @param [Module] klass The class name will be resolved as
+  def self.register_type(name, klass)
+    DSL::Type.register_type(name, klass)
+  end
+
+  # @return [true, false] True if name is a known type
+  def self.know_type?(name)
+    DSL::Type.know_type?(name)
+  end
+
+  # @param [Module, Symbol] name An object supposed to identify a module or a
+  #                              class.
+  # @return [Module, nil] The matchig module
+  def self.resolve_type(name)
+    if name.is_a? Module
+      name
+    else
+      DSL::Type.resolve_type(name)
+    end
+  end
+
+  register_type(:image, Ray::Image)
+  register_type(:color, Ray::Color)
+
+  register_type(:string, String)
+  register_type(:array, Array)
+  register_type(:hash, Hash)
+  register_type(:integer, Integer)
+  register_type(:float, Float)
+  register_type(:numeric, Numeric)
+
+  register_type(:anything, Object)
+end

data/lib/ray/game.rb

@@ -0,0 +1,107 @@
+module Ray
+  # a game is represented as a stack of scenes : you register scenes,
+  # and then you push and pop them until the stack is empty.
+  #
+  # The game will run eerything when it is created, and free it when
+  # it is done running.
+  class Game
+    # Creates a new game.
+    # You can poss all the argument you would pass to create_window,
+    # except width and height which should be given in :video_mode, like this :
+    #   Ray::Game.new(:video_modes = %w(480x272 640x480))
+    #
+    # It will try to get the biggest resolution available (so it will most
+    # likely choose 640x480).
+    #
+    # If a block is passes, it is instance evaluated, and then the game is
+    # directly run.
+    def initialize(hash = {}, &block)
+      @registred_scenes = {}
+      @scenes = []
+
+      defaults = {
+        :double_buf => true,
+        :bpp        => 32,
+        :hw_surface => true,
+        :sw_surface => false
+      }
+
+      options = defaults.merge(hash)
+
+      common_settings = {
+        :sw_surface => options[:sw_surface],
+        :hw_surface => options[:hw_surface],
+        :bpp        => options[:bpp] || options[:bits_per_pixel],
+        :async_blit => options[:async_blit],
+        :double_buf => options[:double_buf],
+        :fullscreen => options[:fullscreen],
+        :no_frame   => options[:no_frame]
+      }
+
+      modes = options[:video_modes].map { |m| m.split('x').map { |i| i.to_i } }
+
+      # The biggest resolution is privileged
+      modes = modes.sort_by { |(w, h)| w * h }.map do |(w, h)|
+        common_settings.merge(:w => w, :h => h)
+      end
+
+      Ray.init
+
+      last_mode = modes.select { |mode| Ray.can_use_mode? mode }.last
+      raise ArgumentError, "No valid mode found" unless last_mode
+
+      @window = Ray.create_window(last_mode)
+
+      if block
+        instance_eval(&block)
+        run
+      end
+    end
+
+    # Adds a scene to the stack by its name.
+    # You must call Game#scene before this. If you subclassed scene,
+    # then call bind to register it.
+    def push_scene(scene_name)
+      scene = @registred_scenes[scene_name]
+      raise ArgumentError, "Unknown scene #{scene_name}" unless scene
+
+      @scenes << scene
+    end
+
+    # Pops the last scene.
+    def pop_scene
+      @scenes.delete_at(-1)
+    end
+
+    # Registers a new scene with a given name. the block will be passed
+    # to klass.new.
+    #
+    # @param [Symobl] name the name of the new scene
+    # @param [Class] klass the class of the scene.
+    def scene(name, klass = Scene, &block)
+      @registred_scenes[name] = klass.new(&block)
+    end
+
+    # Runs the game until the last scene gets popped.
+    def run
+      until @scenes.empty?
+        @runner = Ray::DSL::EventRunner.new
+
+        @scenes.each do |scene|
+          scene.game         = self
+          scene.window       = @window
+          scene.event_runner = @runner
+
+          scene.register_events
+        end
+
+        scene = @scenes.last
+
+        scene.need_render!
+        scene.run
+      end
+
+      Ray.stop
+    end
+  end
+end

data/lib/ray/helper.rb

@@ -0,0 +1,17 @@
+module Ray
+  # This module includes the methods you may want to use in your code.
+  # It allows you to play with events (listen to them, raise them) and
+  # includes the matchers you described, which you may want to use when
+  # you want to listen to the events matching a condition.
+  module Helper
+    include Ray::DSL::EventRaiser
+    include Ray::DSL::Listener
+
+    include Ray::Matchers
+
+    def event_runner=(value)
+      self.listener_runner = value
+      self.raiser_runner   = value
+    end
+  end
+end

data/lib/ray/image.rb

@@ -0,0 +1,11 @@
+module Ray
+  class Image
+    def inspect
+      "#<#{self} w=#{w} h=#{h} bpp=#{bpp}>"
+    end
+
+    alias :bits_per_pixel :bpp
+    alias :width :w
+    alias :height :h
+  end
+end

data/lib/ray/ray.rb

@@ -9,3 +9,11 @@ end
 
 require 'ray/color'
 require 'ray/rect'
+
+require 'ray/config'
+
+require 'ray/dsl'
+require 'ray/helper'
+
+require 'ray/scene'
+require 'ray/game'

data/lib/ray/scene.rb

@@ -0,0 +1,102 @@
+module Ray
+  class Scene
+    include Ray::Helper
+
+    class << self
+      # If you want to subclass Scene, this is the method you need to call.
+      # It will return a subclass, responding to bind, which allows you to
+      # register it.
+      #
+      # @example
+      #   Klass = Scene.create(:foo) do ... end
+      #   Klass.bind(game)
+      #   game.push_scene(:foo)
+      def create(scene_name, &block)
+        klass = Class.new(self)
+        klass.instance_variable_set("@block", block)
+
+        (class << klass; self; end).class_eval do
+          define_method(:bind) do |game|
+            game.scene(scene_name, self, &@block)
+          end
+
+          define_method(:inspect) { "Scene:#{scene_name}" }
+          define_method(:block) { @block }
+        end
+
+        klass.class_eval do
+          define_method(:initialize) do
+            super(&self.class.block)
+          end
+        end
+
+        return klass
+      end
+    end
+
+    # Creates a new scene. block will be instance evaluated
+    # every time the current scene changes.
+    def initialize(&block)
+      @exit = false
+      @block = block
+    end
+
+    def register_events
+      instance_eval(&@block)
+    end
+
+    # Runs until you exit the scene.
+    # This will also raise events if the mouse moves, ... allowing you
+    # to directly listen to a such event.
+    def run
+      until @exit
+        ev = DSL::EventTranslator.translate_event(Ray::Event.new)
+        raise_event(*ev) if ev
+
+        @always.call if @always
+
+        listener_runner.run
+
+        if @need_render
+          @need_render = false
+
+          @render.call(@window)
+          @window.flip
+        end
+      end
+    end
+
+    # Exits the scene, but does not pops the scene (the next scene
+    # will be the same one)
+    def exit
+      @exit = true
+    end
+
+    # Exits the scene and pops it.
+    def exit!
+      exit
+      game.pop_scene
+    end
+
+    # Register a block to be excuted as often as possible.
+    def always(&block)
+      @always = block
+    end
+
+    # Marks the scene should be redrawn.
+    def need_render!
+      @need_render = true
+    end
+
+    # Registers the block to draw the scene.
+    #
+    # @yield [window] Block to render this scene.
+    # @yieldparam [Ray::Image] window The window you should draw on
+    def render(&block)
+      @render = block
+    end
+
+    attr_accessor :game
+    attr_accessor :window
+  end
+end

data/psp/SDL_psp_main.c

@@ -0,0 +1,84 @@
+/*
+  SDL - Simple DirectMedia Layer
+  Copyright (C) 1997-2004 Sam Lantinga
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Library General Public
+  License as published by the Free Software Foundation; either
+  version 2 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
+  Library General Public License for more details.
+
+  You should have received a copy of the GNU Library General Public
+  License along with this library; if not, write to the Free
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+  Sam Lantinga
+  slouken@libsdl.org
+*/
+
+/*
+  PSP port contributed by:
+  Marcus R. Brown <mrbrown@ocgnet.org>
+  Jim Paris <jim@jtan.com>
+  Matthew H <matthewh@webone.com.au>
+*/
+
+#include <SDL/SDL_main.h>
+
+#include <pspkernel.h>
+#include <pspdebug.h>
+#include <pspsdk.h>
+#include <pspthreadman.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+/* If application's main() is redefined as SDL_main, and libSDLmain is
+   linked, then this file will create the standard exit callback,
+   define the PSP_MODULE_INFO macro, and exit back to the browser when
+   the program is finished.
+
+   You can still override other parameters in your own code if you
+   desire, such as PSP_HEAP_SIZE_KB, PSP_MAIN_THREAD_ATTR,
+   PSP_MAIN_THREAD_STACK_SIZE, etc.
+*/
+
+extern int SDL_main(int argc, char *argv[]);
+
+PSP_MODULE_INFO("ray", 0, 1, 1);
+
+int sdl_psp_exit_callback(int arg1, int arg2, void *common) {
+   exit(0);
+   return 0;
+}
+
+int sdl_psp_callback_thread(SceSize args, void *argp) {
+   int cbid;
+   cbid = sceKernelCreateCallback("Exit Callback",
+                                  sdl_psp_exit_callback, NULL);
+   sceKernelRegisterExitCallback(cbid);
+   sceKernelSleepThreadCB();
+   return 0;
+}
+
+int sdl_psp_setup_callbacks(void) {
+   int thid = 0;
+   thid = sceKernelCreateThread("update_thread",
+                                sdl_psp_callback_thread, 0x11, 0xFA0, 0, 0);
+   if(thid >= 0)
+      sceKernelStartThread(thid, 0, 0);
+   return thid;
+}
+
+int main(int argc, char *argv[]) {
+   pspDebugScreenInit();
+   sdl_psp_setup_callbacks();
+
+   /* Register sceKernelExitGame() to be called when we exit */
+   atexit(sceKernelExitGame);
+
+   return SDL_main(argc, argv);
+}