adventure_rl 0.0.1.pre.ld42

data/lib/AdventureRL/Clip.rb

@@ -0,0 +1,91 @@
+module AdventureRL
+  class Clip < FileGroup
+    IMAGE_FILENAME_REGEX = /\A\d+\.(png|jpe?g)\z/i
+    INTERNAL_DEFAULT_SETTINGS = Settings.new({
+      name:      :clip_name,
+      directory: nil,
+      fps:       24,
+      audio:     false
+    })
+    @@default_settings = nil
+    @@root_directory   = Pathname.new($0).dirname
+
+    class << self
+      # Set the root directory for the images directory.
+      # All settings 'directory' values will be relative to this.
+      # Defaults to the entry scripts (the script that was called, <tt>$0</tt>) directory.
+      # Pass either a String with the directory path, or an instance of Pathname.
+      def set_root_directory directory
+        directory = Pathname.new directory  unless (directory.is_a? Pathname)
+        @@root_directory = Pathname.new directory
+      end
+      alias_method :root=, :set_root_directory
+
+      # Returns the currently set root images directory.
+      def get_root_directory
+        return @@root_directory
+      end
+      alias_method :root, :get_root_directory
+
+      # Set the default Settings.
+      # Pass either String to a YAML settings file,
+      # or a Hash with your default settings.
+      def set_default_settings settings
+        default_settings = nil
+        if    ([String, Pathname].include? settings.class)
+          filepath = settings
+          filepath = Pathname.new filepath  unless (filepath.is_a? Pathname)
+          if (filepath.absolute?)
+            default_settings = Settings.new filepath
+          else
+            if (File.file?(filepath))
+              default_settings = Settings.new filepath
+            else
+              default_settings = Settings.new get_root_directory.join(filepath)
+            end
+          end
+        elsif (settings.is_a? Hash)
+          default_settings = Settings.new settings
+        end
+        @@default_settings = default_settings
+      end
+      alias_method :default_settings=, :set_default_settings
+    end
+
+    # Initialize with either a path to a YAML settings file as a String,
+    # or a Hash containing your settings.
+    def initialize settings
+      super
+      audio_settings = get_settings :audio
+      @audio = load_audio audio_settings  if (audio_settings)
+    end
+
+    # Returns this Clip's Audio, if one was provided at #new.
+    def get_audio
+      return @audio
+    end
+
+    # Returns true if this Clip has Audio.
+    def has_audio?
+      return !!get_audio
+    end
+
+    private
+
+      # Loads Audio, if one was provided
+      def load_audio audio_settings
+        return Audio.new audio_settings
+      end
+
+      # Returns this class' specific INTERNAL_DEFAULT_SETTINGS.
+      def get_default_settings
+        return INTERNAL_DEFAULT_SETTINGS.merge @@default_settings  if (@@default_settings)
+        return INTERNAL_DEFAULT_SETTINGS
+      end
+
+      # Should return the regex which must match the filenames.
+      def get_filename_regex
+        return IMAGE_FILENAME_REGEX
+      end
+  end
+end

data/lib/AdventureRL/ClipPlayer.rb

@@ -0,0 +1,187 @@
+module AdventureRL
+  class ClipPlayer < FileGroupPlayer
+    # Default settings for ClipPlayer.
+    # Are superseded by settings passed to #new.
+    DEFAULT_SETTINGS = Settings.new({
+      speed: 1.0,
+      loop:  true,
+      mask: {
+        position: {
+          x: 0,
+          y: 0
+        },
+        size: {
+          width:  960,
+          height: 540
+        },
+        origin: {
+          x: :left,
+          y: :top
+        }
+      },
+      z_index: 0,
+      color:   0xff_ffffff,
+      image_options: {
+        retro: true
+      }
+    })
+    AUDIO_PLAYER_METHODS = [
+      :pause,
+      :resume,
+      :stop,
+      :reset,
+      :set_current_time,
+      :increase_current_time,
+      :set_speed,
+      :increase_speed,
+      :update
+    ]
+
+    class << self
+      # Returns the method names of all methods aliased to method <tt>method_name</tt>.
+      def get_aliased_methods method_name
+        real_method = instance_method method_name
+        return instance_methods.select do |instance_method_name|
+          next (
+            real_method == instance_method(instance_method_name) &&
+            method_name != instance_method_name
+          )
+        end
+      end
+
+      # Overwrite a bunch of FileGroupPlayer methods,
+      # so they also handle Audio, if Clip has one.
+      # See AUDIO_PLAYER_METHODS for the list of methods.
+      def define_audio_player_methods
+        AUDIO_PLAYER_METHODS.each do |real_method_name|
+          [real_method_name, get_aliased_methods(real_method_name)].flatten.each do |method_name|
+            define_method(method_name) do |*args|
+              super *args
+              get_audio_player.method(method_name).call(*args)  if (has_audio_player?)
+              # NOTE: Write #sync_audio_player method, maybe?
+              #       Should be unnecessarilty doubled work,
+              #       but it would garantee that both Players are synced.
+              # sync_audio_player
+            end
+          end
+        end
+      end
+    end
+
+    define_audio_player_methods
+
+    # Pass settings Hash or Settings as argument.
+    # Supersedes DEFAULT_SETTINGS.
+    def initialize settings = {}
+      super
+      @audio_player = nil
+      set_mask_from get_settings(:mask)
+    end
+
+    # Returns the current AudioPlayer, if there is one.
+    def get_audio_player
+      return @audio_player
+    end
+
+    # Returns true if an AudioPlayer was instantiated for this ClipPlayer.
+    def has_audio_player?
+      return !!get_audio_player
+    end
+
+    # Returns the currently active Clip.
+    # Wrapper for FileGroupPlayer#get_filegroup
+    alias_method :get_clip, :get_filegroup
+
+    # Returns true if there is a currently active Clip.
+    # Wrapper for FileGroupPlayer#has_filegroup?
+    alias_method :has_clip?, :has_filegroup?
+
+    # Overwrite FileGroupPlayer#play separately from above,
+    # because it should call #handle_play_for_audio_player
+    # to create a new AudioPlayer, if necessary.
+    def play *args
+      super
+      if (get_clip.has_audio?)
+        handle_play_for_audio_player
+      end
+    end
+
+    # Draw the current image in the currently active Clip.
+    # This should be called every frame.
+    def draw
+      image = get_current_file
+      return  unless (image)
+      scale = get_scale_for_image image
+      image.draw(
+        get_side(:left), get_side(:top), get_settings(:z_index),
+        scale[:x], scale[:y],
+        get_settings(:color)
+      )
+    end
+
+    private
+
+      # Set the Mask for the ClipPlayer.
+      def set_mask_from mask
+        if    (mask.is_a?(Mask))
+          mask.assign_to self
+        elsif (mask.is_a?(Hash))
+          Mask.new(
+            mask.merge(
+              assign_to: self
+            )
+          )
+        else
+          error "Cannot set Mask as #{mask.inspect}:#{mask.class.name} for ClipPlayer."
+        end
+      end
+
+      # Loads the image file <tt>file</tt>
+      def load_file file
+        if (get_current_image.is_a? Gosu::Image)
+          get_current_image.insert file, 0, 0
+        else
+          set_current_image Gosu::Image.new(
+            file,
+            get_settings(:image_options)
+          )
+        end
+      end
+
+      # Returns the current image.
+      # Wrapper for FileGroupPlayer#get_current_file
+      alias_method :get_current_image, :get_current_file
+
+      # Set a new current image.
+      # Wrapper for FileGroupPlayer#set_current_file
+      alias_method :set_current_image, :set_current_file
+
+      def get_scale_for_image image = get_current_file
+        return {
+          x: (get_size(:width).to_f  / image.width.to_f),
+          y: (get_size(:height).to_f / image.height.to_f)
+        }
+      end
+
+      # Create, change, or remove AudioPlayer,
+      # depending on if the current Clip has Audio.
+      def handle_play_for_audio_player
+        clip = get_clip
+        if    (clip.has_audio?)
+          if (has_audio_player?)
+            @audio_player.play clip.get_audio
+          else
+            @audio_player = AudioPlayer.new get_settings
+            @audio_player.play clip.get_audio
+          end
+        elsif (has_audio_player?)
+          get_audio_player.stop
+        end
+      end
+
+      # Returns this class' DEFAULT_SETTINGS.
+      def get_default_settings
+        return DEFAULT_SETTINGS
+      end
+  end
+end

data/lib/AdventureRL/Deltatime.rb

@@ -0,0 +1,51 @@
+module AdventureRL
+  class Deltatime
+    # This Array is filled with _all_ initialized Deltatime instances.
+    # The point of it is, that they are all reset once the Window opens ( Window#show ).
+    DELTATIMES = []
+
+    def initialize
+      @last_update_at = nil
+      @deltatime      = nil
+      set_last_update_at
+      set_deltatime
+      DELTATIMES << self
+    end
+
+    # Returns the value of the last calculated deltatime.
+    def get_deltatime
+      return @deltatime
+    end
+    alias_method :get, :get_deltatime
+    alias_method :dt,  :get_deltatime
+
+    # Call this method every tick / frame
+    # to update the deltatime value.
+    def update
+      set_deltatime
+      set_last_update_at
+    end
+
+    # Resets last updated deltatime.
+    # Used when wanting to pause this deltatime's calculations,
+    # so when resumed, deltatime isn't a large number.
+    def reset
+      set_last_update_at
+    end
+
+    private
+
+      def set_deltatime
+        diff_in_secs = get_elapsed_seconds - @last_update_at
+        @deltatime = diff_in_secs
+      end
+
+      def set_last_update_at
+        @last_update_at = get_elapsed_seconds
+      end
+
+      def get_elapsed_seconds
+        return Gosu.milliseconds.to_f / 1000.0
+      end
+  end
+end

data/lib/AdventureRL/EventHandlers/Buttons.rb

@@ -0,0 +1,225 @@
+module AdventureRL
+  module EventHandlers
+    class Buttons < EventHandler
+      # This constant will be filled with
+      # EventHandlers::Buttons and EventHandlers::MouseButtons
+      # instances as they are created.
+      # It is used by the following class methods
+      # EventHandler::Buttons#button_down,
+      # EventHandler::Buttons#button_up, and
+      # EventHandler::Buttons#update.
+      BUTTON_EVENT_HANDLERS = []
+
+      def self.button_down btnid
+        BUTTON_EVENT_HANDLERS.each do |handler|
+          handler.button_down btnid
+        end
+      end
+      def self.button_up btnid
+        BUTTON_EVENT_HANDLERS.each do |handler|
+          handler.button_up btnid
+        end
+      end
+      def self.update
+        BUTTON_EVENT_HANDLERS.each &:update
+      end
+
+      DEFAULT_SETTINGS = Settings.new(
+        pressable_buttons: [],
+        auto_update:       false
+      )
+
+      def initialize settings = {}
+        @settings = DEFAULT_SETTINGS.merge settings
+        super
+        @pressable_buttons = []
+        pressable_buttons = [@settings.get(:pressable_buttons)].flatten
+        add_pressable_button pressable_buttons  if (pressable_buttons.any?)
+        @events = get_events
+        BUTTON_EVENT_HANDLERS << self  if (@settings.get(:auto_update))
+      end
+
+      # Add one or multiple button character(s) <tt>btns</tt>,
+      # which will trigger the #on_button_press methods on subscribed objects,
+      # when the given button is being pressed.
+      # Instead of passing single alphanumeric strings / symbols,
+      # you can pass hashes, whose keys will be passed to the #on_button_press methods,
+      # when _any_ of its values are pressed.
+      # Case-sensitive.
+      def add_pressable_button *btns
+        btns.flatten.each do |button|
+          if (button.is_a?(Symbol) || button.is_a?(String))
+            validate_button button
+            btnid = Gosu.char_to_button_id button
+            pressable_button = {
+              name: button,
+              ids:  [btnid]
+            }
+            @pressable_buttons << pressable_button  unless (@pressable_buttons.include? pressable_button)
+          elsif (button.is_a?(Hash))
+            button.each do |btn_name, btn_buttons|
+              pressable_button = {
+                name: btn_name,
+                ids:  [btn_buttons].flatten.map do |btn|
+                  validate_button btn
+                  next Gosu.char_to_button_id btn
+                end
+              }
+              @pressable_buttons << pressable_button  unless (@pressable_buttons.include? pressable_button)
+            end
+          end
+        end
+      end
+      alias_method :add_pressable_buttons, :add_pressable_button
+
+      def button_down btnid
+        trigger(
+          :button_down,
+          get_semantic_button_name(btnid),
+          shift:   shift_button_pressed?,
+          control: control_button_pressed?,
+          alt:     alt_button_pressed?
+        )
+      end
+
+      def button_up btnid
+        trigger(
+          :button_up,
+          get_semantic_button_name(btnid),
+          shift:   shift_button_pressed?,
+          control: control_button_pressed?,
+          alt:     alt_button_pressed?
+        )
+      end
+
+      def update
+        return  unless (get_pressable_buttons.any?)
+        pressed_btns = get_pressable_buttons.map do |btn|
+          next btn[:name]  if (btn[:ids].any? { |id| Gosu.button_down?(id) })
+          next nil
+        end .compact.uniq
+        return  unless (pressed_btns.any?)
+        pressed_btns.each do |btn|
+          trigger(
+            :button_press,
+            btn,
+            shift:   shift_button_pressed?,
+            control: control_button_pressed?,
+            alt:     alt_button_pressed?
+          )
+        end
+      end
+
+      def get_pressable_buttons
+        return @pressable_buttons
+      end
+
+      private
+
+        def get_events
+          return [
+            get_event_button_down,
+            get_event_button_up,
+            get_event_button_press
+          ]
+        end
+
+        def get_event_button_down
+          event = Events::Event.new(:button_down)
+          event.on_trigger do |object, btn_name, mod_keys|
+            next  unless (object.methods.include? :on_button_down)
+            case object.method(:on_button_down).arity.abs
+            when 0
+              object.on_button_down
+            when 1
+              object.on_button_down btn_name
+            when 2
+              object.on_button_down btn_name, mod_keys
+            end
+          end
+          return event
+        end
+
+        def get_event_button_up
+          event = Events::Event.new(:button_up)
+          event.on_trigger do |object, btn_name, mod_keys|
+            next  unless (object.methods.include? :on_button_up)
+            case object.method(:on_button_up).arity.abs
+            when 0
+              object.on_button_up
+            when 1
+              object.on_button_up btn_name
+            when 2
+              object.on_button_up btn_name, mod_keys
+            end
+          end
+          return event
+        end
+
+        def get_event_button_press
+          event = Events::Event.new(:button_press)
+          event.on_trigger do |object, btn_name, mod_keys|
+            next  unless (object.methods.include? :on_button_press)
+            case object.method(:on_button_press).arity.abs
+            when 0
+              object.on_button_press
+            when 1
+              object.on_button_press btn_name
+            when 2
+              object.on_button_press btn_name, mod_keys
+            end
+          end
+          return event
+        end
+
+        def validate_button btn
+          Helpers::Error.error(
+            "Passed invalid button character. Expected a printable alphanumeric, but got",
+            "`#{btn.inspect}:#{btn.class.name}'."
+          )  unless (Gosu.char_to_button_id btn)
+        end
+
+        def get_semantic_button_name btnid
+          pressable_button = get_pressable_buttons.detect do |pressable_button|
+            next pressable_button[:ids].include?(btnid)
+          end
+          return pressable_button[:name]  if (pressable_button)
+          btn_char = Gosu.button_id_to_char btnid
+          return get_semantic_constant_button_name btnid  if (btn_char.empty?)
+          return btn_char.to_sym
+        end
+
+        def get_semantic_constant_button_name btnid
+          return Gosu.constants.map do |constant_name|
+            constant = Gosu.const_get constant_name
+            next constant_name.to_s.sub(/^(KB_|MS_|GP_)/,'').downcase.to_sym  if (constant == btnid && constant_name.match?(/_/))
+            next nil
+          end .compact.first
+        end
+
+        # Returns <tt>true</tt> if either <tt>LEFT_SHIFT</tt> or <tt>RIGHT_SHIFT</tt> is pressed,
+        # returns <tt>false</tt> otherwise.
+        def shift_button_pressed?
+          return Gosu.button_down?(Gosu::KB_LEFT_SHIFT) || Gosu.button_down?(Gosu::KB_RIGHT_SHIFT)
+        end
+
+        # Returns <tt>true</tt> if either <tt>LEFT_CONTROL</tt> or <tt>RIGHT_CONTROL</tt> is pressed,
+        # returns <tt>false</tt> otherwise.
+        def control_button_pressed?
+          return Gosu.button_down?(Gosu::KB_LEFT_CONTROL) || Gosu.button_down?(Gosu::KB_RIGHT_CONTROL)
+        end
+
+        # Returns <tt>true</tt> if either <tt>LEFT_ALT</tt> or <tt>RIGHT_ALT</tt> is pressed,
+        # returns <tt>false</tt> otherwise.
+        def alt_button_pressed?
+          return Gosu.button_down?(Gosu::KB_LEFT_ALT) || Gosu.button_down?(Gosu::KB_RIGHT_ALT)
+        end
+
+        # Subscribing objects must be a Mask or have a Mask assigned to them.
+        def valid_object? object
+          ret = object.has_mask?  rescue false
+          return ret
+        end
+    end
+  end
+end

data/lib/AdventureRL/EventHandlers/EventHandler.rb

@@ -0,0 +1,62 @@
+module AdventureRL
+  module EventHandlers
+    # An EventHandler can have multiple Event s.
+    # You can subscribe an object to a specific Event using its name,
+    # through the EventHandler.
+    class EventHandler
+      def initialize settings = {}
+        @events = []
+      end
+
+      # Add an Event to this EventHandler.
+      def add_event event
+        Helpers::Error.error(
+          "Passed `event' is not an instance of `Event'.",
+          "Got `#{event.inspect}:#{event.class.name}'."
+        )  unless (event.is_a? Event)
+        @events << event
+      end
+      alias_method :add, :add_event
+      alias_method :<<,  :add_event
+
+      # Subscribe an <tt>object</tt> to all Event s in this EventHandler.
+      def subscribe object
+        Helpers::Error.error(
+          "Object `#{object.inspect}:#{object.class.name}' cannot subscribe",
+          "to this EventHandler `#{self.inspect}:#{self.class.name}'."
+        )  unless (valid_object? object)
+        @events.each do |event|
+          event.add_object object
+        end
+      end
+
+      # Unsubscribe an <tt>object</tt> from all Event s in this EventHandler.
+      def unsubscribe object
+        @events.each do |event|
+          event.remove_object object
+        end
+      end
+
+      # Trigger the Event with the name <tt>event_name</tt>.
+      # Returns <tt>true</tt> if the Event was found and <tt>false</tt> if not.
+      # Optionally, additional <tt>args</tt> arguments can be passed,
+      # which will be passed to the trigger methods on the Event s.
+      def trigger event_name, *args
+        event = @events.detect do |evnt|
+          evnt.get_name == event_name
+        end
+        event.trigger *args  if (event)
+        return !!event
+      end
+
+      private
+
+        # Returns <tt>true</tt> if the passed <tt>object</tt> can be subscribed to this EventHandler,
+        # and <tt>false</tt> if not.
+        # This method should be overwritten to fit specific requirements.
+        def valid_object? object
+          return !!object
+        end
+    end
+  end
+end