adventure_rl 0.0.1.pre.ld42

data/lib/AdventureRL/EventHandlers/MouseButtons.rb

@@ -0,0 +1,142 @@
+module AdventureRL
+  module EventHandlers
+    class MouseButtons < Buttons
+      # This constant contains the IDs of all mouse buttons.
+      MOUSE_BUTTON_IDS = [
+        Gosu::MS_LEFT,
+        Gosu::MS_MIDDLE,
+        Gosu::MS_RIGHT,
+        Gosu::MS_WHEEL_DOWN,
+        Gosu::MS_WHEEL_UP
+      ] .concat((0 .. 7).map do |n|
+        next Gosu.const_get "MS_OTHER_#{n.to_s}"
+      end)
+
+      DEFAULT_SETTINGS = Settings.new(
+        only_mouse_buttons: true
+      )
+
+      def initialize settings = {}
+        @settings           = DEFAULT_SETTINGS.merge settings
+        @only_mouse_buttons = @settings.get :only_mouse_buttons
+        super @settings
+      end
+
+      def button_down btnid
+        super  unless (@only_mouse_buttons)
+        trigger(
+          :mouse_down,
+          get_semantic_button_name(btnid),
+          shift:   shift_button_pressed?,
+          control: control_button_pressed?,
+          alt:     alt_button_pressed?
+        )  if (MOUSE_BUTTON_IDS.include?(btnid))
+      end
+
+      def button_up btnid
+        return  unless (MOUSE_BUTTON_IDS.include? btnid)
+        trigger(
+          :mouse_up,
+          get_semantic_button_name(btnid),
+          shift:   shift_button_pressed?,
+          control: control_button_pressed?,
+          alt:     alt_button_pressed?
+        )
+      end
+
+      def update
+        pressed_btnids = MOUSE_BUTTON_IDS.select do |btnid|
+          next Gosu.button_down?(btnid)
+        end
+        return  unless (pressed_btnids.any?)
+        pressed_btnids.each do |btnid|
+          trigger(
+            :mouse_press,
+            get_semantic_button_name(btnid),
+            shift:   shift_button_pressed?,
+            control: control_button_pressed?,
+            alt:     alt_button_pressed?
+          )
+        end
+      end
+
+      def add_pressable_button *args
+        Helpers::Error.error(
+          "Cannot add pressable button(s) to #{self.class.name}."
+        )
+      end
+
+      private
+
+        def get_events
+          return super.concat([
+            get_event_mouse_down,
+            get_event_mouse_up,
+            get_event_mouse_press
+          ])
+        end
+
+        def get_event_mouse_down
+          event = Events::Mouse.new(:mouse_down)
+          event.on_trigger do |object, btn_name, mod_keys|
+            next  unless (object.methods.include?(:on_mouse_down) && object.collides_with?(get_mouse_point))
+            case object.method(:on_mouse_down).arity.abs
+            when 0
+              object.on_mouse_down
+            when 1
+              object.on_mouse_down btn_name
+            when 2
+              object.on_mouse_down btn_name, mod_keys
+            end
+          end
+          return event
+        end
+
+        def get_event_mouse_up
+          event = Events::Mouse.new(:mouse_up)
+          event.on_trigger do |object, btn_name, mod_keys|
+            next  unless (object.methods.include?(:on_mouse_up) && object.collides_with?(get_mouse_point))
+            case object.method(:on_mouse_up).arity.abs
+            when 0
+              object.on_mouse_up
+            when 1
+              object.on_mouse_up btn_name
+            when 2
+              object.on_mouse_up btn_name, mod_keys
+            end
+          end
+          return event
+        end
+
+        def get_event_mouse_press
+          event = Events::Mouse.new(:mouse_press)
+          event.on_trigger do |object, btn_name, mod_keys|
+            next  unless (object.methods.include?(:on_mouse_press) && object.collides_with?(get_mouse_point))
+            case object.method(:on_mouse_press).arity.abs
+            when 0
+              object.on_mouse_press
+            when 1
+              object.on_mouse_press btn_name
+            when 2
+              object.on_mouse_press btn_name, mod_keys
+            end
+          end
+          return event
+        end
+
+        def get_mouse_point
+          window = Window.get_window
+          return nil  unless (window)
+          return Point.new(window.mouse_x, window.mouse_y)
+        end
+
+        def get_semantic_button_name btnid
+          return Gosu.constants.map do |constant_name|
+            constant = Gosu.const_get constant_name
+            next constant_name.to_s.sub(/^MS_/,'').downcase.to_sym  if (constant == btnid && constant_name.match?(/_/))
+            next nil
+          end .compact.first
+        end
+    end
+  end
+end

data/lib/AdventureRL/Events/Event.rb

@@ -0,0 +1,69 @@
+module AdventureRL
+  module Events
+    class Event
+      def initialize name
+        @name           = name
+        @objects        = []
+        @trigger_method = nil
+      end
+
+      # Returns the <tt>name</tt> of the Event.
+      def get_name
+        return @name
+      end
+
+      # Returns the objects that subscribed to this Event. (see #add_object)
+      def get_objects
+        return @objects
+      end
+
+      # Add one or multiple <tt>object</tt>(s) to this Event.
+      def add_object object
+        [object].flatten.each do |obj|
+          Helpers::Error.error(
+            "Object `#{obj.inspect}:#{obj.class.name}' cannot be given",
+            "to this Event `#{self.inspect}:#{self.class.name}'."
+          )  unless (valid_object? obj)
+          @objects << obj  unless (@objects.include? obj)
+        end
+      end
+      alias_method :add, :add_object
+      alias_method :<<,  :add_object
+
+      # Remove one or multiple <tt>object</tt>(s) from this Event.
+      def remove_object object
+        [object].flatten.each do |obj|
+          @objects.delete obj
+        end
+      end
+
+      # Pass a block, which will be called when this Event is triggered (see #trigger).
+      # The passed block takes an argument, which is a subscribed object.
+      def on_trigger &block
+        Helpers::Error.error(
+          "Method #on_trigger needs a block to be passed."
+        )  unless (block_given?)
+        @trigger_method = block
+      end
+
+      # The block defined with #on_trigger will be called
+      # for every subscribed object.
+      # Optionally, additional <tt>args</tt> arguments can be passed,
+      # which will be passed to the trigger method.
+      def trigger *args
+        get_objects.each do |object|
+          @trigger_method.call object, *args
+        end
+      end
+
+      private
+
+        # Returns <tt>true</tt> if the passed <tt>object</tt> can be given to this Event,
+        # 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

data/lib/AdventureRL/Events/Mouse.rb

@@ -0,0 +1,60 @@
+module AdventureRL
+  module Events
+    class Mouse < Event
+      def initialize *args
+        super
+        @quadtree = Quadtree.new
+      end
+
+      # Overwrite the #add_object method, so we can
+      # reset the object in the Quadtree if necessary,
+      # via the object's #move_by method.
+      def add_object object
+        super
+        [object].flatten.each do |obj|
+          get_quadtree.add_object obj
+          mouse_event = self
+          obj.define_singleton_method :move_by do |*args|
+            previous_position = get_position.dup
+            super(*args)
+            mouse_event.get_quadtree.reset_object self  if (get_position != previous_position)
+          end
+        end
+      end
+
+      # Overwrite the #remove_object method, so we can
+      # also remove the object(s) from the Quadtree.
+      def remove_object object
+        super
+        [object].flatten.each do |obj|
+          get_quadtree.remove_object obj
+        end
+      end
+
+      # Overwrite the #trigger method, to perform a
+      # Quadtree query for objects colliding with the mouse pointer.
+      # For improved performance.
+      def trigger *args
+        get_colliding_objects.each do |object|
+          @trigger_method.call object, *args
+        end
+      end
+
+      def get_quadtree
+        return @quadtree
+      end
+
+      private
+
+        def get_colliding_objects
+          return get_quadtree.get_colliding_objects_for get_mouse_point
+        end
+
+        def get_mouse_point
+          window = Window.get_window
+          return nil  unless (window)
+          return Point.new(window.mouse_x, window.mouse_y)
+        end
+    end
+  end
+end

data/lib/AdventureRL/FileGroup.rb

@@ -0,0 +1,100 @@
+module AdventureRL
+  # This is an abstract class, which is inherited by
+  # - Clip
+  # - Audio
+  class FileGroup
+    include Helpers::Error
+
+    # Initialize with either a path to a YAML settings file as a String,
+    # or a Hash containing your settings.
+    def initialize settings_arg
+      settings   = Settings.new settings_arg
+      @settings  = get_settings_with settings
+      @name      = @settings.get :name
+      @directory = get_directory_from_settings @settings
+      validate_directory @directory
+      @files     = get_file_paths
+    end
+
+    # Returns the settings as <tt>AdventureRL::Settings</tt>,
+    # unless <tt>*keys</tt> are given, then it returns the value of
+    # <tt>@settings.get(*keys)</tt>.
+    def get_settings *keys
+      return @settings  if (keys.empty?)
+      return @settings.get(*keys)
+    end
+
+    # Returns the Clip's name.
+    def get_name
+      return @name
+    end
+
+    # Returns an Array of the filepaths.
+    def get_files
+      return @files
+    end
+
+    # Returns the filepath at index <tt>index</tt>.
+    def get_file index
+      return @files[index]
+    end
+
+    # Returns the set directory of files.
+    def get_file_directory
+      return @directory
+    end
+    alias_method :get_directory, :get_file_directory
+
+    # Returns true if <tt>index</tt> file exists.
+    def has_file_index? index
+      return index < @files.size && index >= 0
+    end
+    alias_method :has_index?, :has_file_index?
+
+    private
+
+      def get_settings_with custom_settings
+        return get_default_settings.merge custom_settings
+      end
+
+      # This method should be overwritten by the child class,
+      # and return their specific <tt>INTERNAL_DEFAULT_SETTINGS</tt>.
+      def get_default_settings
+        return {}
+      end
+
+      def get_directory_from_settings settings = @settings
+        directory = settings.get(:directory)
+        directory = directory.to_path  if (directory.is_a? Pathname)
+        error(
+          "`:directory' key must be given in settings hash to #new."
+        )  unless (directory)
+        return Pathname.new File.join(self.class.get_root_directory, directory)
+      end
+
+      def validate_directory directory = get_directory
+        error_no_directory directory  unless (directory_exists? directory)
+      end
+
+      def get_file_paths
+        return sort_files(get_directory.each_child.select do |file|
+          next false  unless (file.file?)
+          next file.basename.to_path.match? get_filename_regex
+        end)
+      end
+
+      def sort_files files
+        return files.sort do |file_one, file_two|
+          number_one = file_one.basename.to_path.match(/\A(\d+)\..+\z/)[1].to_i
+          number_two = file_two.basename.to_path.match(/\A(\d+)\..+\z/)[1].to_i
+          next number_one <=> number_two
+        end
+      end
+
+      # This method should be overwritten by the child class.
+      # It should return the regex which must match the filenames.
+      def get_filename_regex
+        return /\A.+\..+\z/
+      end
+  end
+end

data/lib/AdventureRL/FileGroupPlayer.rb

@@ -0,0 +1,226 @@
+module AdventureRL
+  # This is an abstract class, which is inherited by
+  # - ClipPlayer
+  # - AudioPlayer
+  # At its core, it takes a FileGroup in its #play method,
+  # and <em>"plays"</em> it.
+  class FileGroupPlayer
+    include Helpers::Error
+
+    # Pass settings Hash or Settings as argument.
+    # Supersedes the child class' <tt>DEFAULT_SETTINGS</tt>.
+    def initialize settings = {}
+      @settings = get_default_settings.merge settings
+      @playing                  = false
+      @speed                    = @settings.get(:speed)
+      @filegroup_index          = 0
+      @filegroup                = nil
+      @current_file             = nil
+      @current_time             = 0.0
+      @last_current_time        = 0.0
+      @target_frame_delay       = 1.0 / 24.0  # Default, will be overwritten in #play
+      @deltatime                = Deltatime.new
+    end
+
+    # Returns the settings as <tt>AdventureRL::Settings</tt>,
+    # unless <tt>*keys</tt> are given, then it returns the value of
+    # <tt>@settings.get(*keys)</tt>.
+    def get_settings *keys
+      return @settings  if (keys.empty?)
+      return @settings.get(*keys)
+    end
+
+    # Returns the currently set FileGroup.
+    def get_filegroup
+      return @filegroup
+    end
+
+    # Returns the current playback time in seconds.
+    def get_current_time
+      return @current_time
+    end
+    alias_method :get_time, :get_current_time
+
+    # Set a new current playback time in seconds.
+    def set_current_time seconds
+      error(
+        "Passed seconds must be an Integer or Float,",
+        "but got #{seconds.inspect}:#{seconds.class.name}"
+      )  unless ([Integer, Float].include? seconds.class)
+      @current_time = seconds
+    end
+    alias_method :set_time, :set_current_time
+
+    # Increase (or decrease) current_time.
+    def increase_current_time seconds
+      error(
+        "Passed seconds must be an Integer or Float,",
+        "but got #{seconds.inspect}:#{seconds.class.name}"
+      )  unless ([Integer, Float].include? seconds.class)
+      @current_time += seconds
+    end
+    alias_method :increase_time, :increase_current_time
+    alias_method :seek,          :increase_current_time
+
+    # Returns the current playback speed multiplier.
+    def get_speed
+      return @speed
+    end
+
+    # Set playback speed multiplier.
+    def set_speed speed
+      error(
+        "Argument passed to #set_speed must be a Float or Integer, but got",
+        "#{speed.inspect}:#{speed.class.name}"
+      )  unless ([Float, Integer].include? speed.class)
+      @speed = speed
+    end
+
+    # Increment (or decrement) the speed value by <tt>amount</tt>.
+    def increase_speed amount
+      error(
+        "Argument passed to #increment_speed must be a Float or Integer, but got",
+        "#{seconds.inspect}:#{amount.class.name}"
+      )  unless ([Float, Integer].include? amount.class)
+      @speed += amount
+    end
+
+    # Start playing FileGroup <tt>filegroup</tt>.
+    def play filegroup
+      load_filegroup filegroup
+      @playing = true
+      reset
+    end
+
+    # Load a FileGroup as active FileGroup.
+    def load_filegroup filegroup
+      error(
+        "Passed argument must be an instance of FileGroup, but got",
+        "#{filegroup.inspect}:#{filegroup.class.name}."
+      )  unless (filegroup.is_a? FileGroup)
+      set_filegroup filegroup
+      @target_frame_delay = 1.0 / get_filegroup.get_settings(:fps).to_f
+    end
+
+    # Pause the currently playing FileGroup.
+    def pause
+      @playing = false
+    end
+
+    # Resumes playing paused FileGroup.
+    def resume
+      return  unless (has_filegroup?)
+      @playing = true
+      @deltatime.reset
+    end
+
+    # Returns true if there is a currently active FileGroup.
+    def has_filegroup?
+      return !!get_filegroup
+    end
+
+    # Stop playing and clear active FileGroup.
+    # Cannot call #resume after this,
+    # before calling #play again.
+    def stop
+      @filegroup = nil
+      @playing   = false
+    end
+
+    # Calls #resume if is paused,
+    # or calls #pause if is playing.
+    def toggle
+      if    (is_playing?)
+        pause
+      elsif (has_filegroup?)
+        resume
+      end
+    end
+
+    # Reset the current playback.
+    # Start playing from the start again.
+    def reset
+      @deltatime.reset
+      @current_time    = 0.0
+      @filegroup_index = 0
+      set_file
+    end
+
+    # Returns <tt>true</tt> if is currently _playing_,
+    # and <tt>false</tt> if is _paused_ or _stopped_.
+    def is_playing?
+      return @playing
+    end
+
+    # Check which file from FileGroup is supposed to be played.
+    # This should be called every frame.
+    def update
+      return  unless (is_playing?)
+      set_filegroup_index
+      update_timing
+    end
+
+    private
+
+      # This method should be overwritten by the child class,
+      # and return their specific <tt>DEFAULT_SETTINGS</tt>.
+      def get_default_settings
+        return {}
+      end
+
+      def set_filegroup filegroup
+        @filegroup_index = 0
+        @filegroup       = filegroup
+        set_file
+      end
+
+      def set_file
+        filegroup = get_filegroup
+        return  if (
+          !filegroup ||
+          !filegroup.has_index?(get_filegroup_index)
+        )
+        load_file filegroup.get_file(get_filegroup_index).to_s
+      end
+
+      # This method should be overwritten by the child class.
+      # It is passed the filepath <tt>file</tt>.
+      def load_file file
+      end
+
+      def get_filegroup_index
+        return @filegroup_index
+      end
+      alias_method :get_index, :get_filegroup_index
+
+      def set_filegroup_index
+        previous_index = get_filegroup_index
+        index = (get_current_time / @target_frame_delay).floor
+        return  if (previous_index == index)
+        @filegroup_index = index
+        filegroup = get_filegroup
+        unless (filegroup.has_index? get_filegroup_index)
+          if (get_settings(:loop))
+            reset
+          else
+            stop
+          end
+          return
+        end
+        set_file
+      end
+
+      def update_timing
+        @current_time += @deltatime.dt * @speed
+        @deltatime.update
+      end
+
+      def get_current_file
+        return @current_file
+      end
+
+      def set_current_file new_file
+        @current_file = new_file
+      end
+  end
+end

data/lib/AdventureRL/Helpers/Error.rb

@@ -0,0 +1,68 @@
+module AdventureRL
+  module Helpers
+    module Error
+      PADDING = '  '
+      STACK_TRACE_SIZE    = 20
+      STACK_TRACE_PADDING = 1
+
+      def self.error *messages
+        message = messages.join ?\n
+        message.gsub! /^/, PADDING
+        stack_trace_lines = caller[STACK_TRACE_PADDING ... (STACK_TRACE_SIZE + STACK_TRACE_PADDING)].map do |line|
+          next "#{PADDING}#{line}"
+        end .reverse
+        abort([
+          "#{DIR[:entry].to_s} Error:",
+          message,
+          "#{PADDING}Exiting.",
+          "Stack traceback (most recent call last):",
+          stack_trace_lines
+        ].flatten.join(?\n))
+      end
+
+      def self.error_no_file file
+        filepath = file
+        filepath = file.to_path  if (file.is_a? Pathname)
+        error "File does not exist, or is a directory:", "  '#{filepath}'"
+      end
+
+      def self.error_no_directory directory
+        dirpath = directory
+        dirpath = directory.to_path  if (directory.is_a? Pathname)
+        error "Directory does not exist, or is a file:", "  '#{dirpath}'"
+      end
+
+      def self.file_exists? file
+        return false  unless (file)
+        return File.file? file
+      end
+
+      def self.directory_exists? directory
+        return false  unless (directory)
+        return File.directory? directory
+      end
+
+      private
+
+        def error *messages
+          AdventureRL::Helpers::Error.error *messages
+        end
+
+        def error_no_file file
+          AdventureRL::Helpers::Error.error_no_file file
+        end
+
+        def error_no_directory directory
+          AdventureRL::Helpers::Error.error_no_directory directory
+        end
+
+        def file_exists? file
+          return AdventureRL::Helpers::Error.file_exists? file
+        end
+
+        def directory_exists? directory
+          return AdventureRL::Helpers::Error.directory_exists? directory
+        end
+    end
+  end
+end

data/lib/AdventureRL/Helpers/MethodHelper.rb

@@ -0,0 +1,20 @@
+module AdventureRL
+  module Helpers
+    module MethodHelper
+      private
+
+        def method_exists? method_name
+          return (
+            methods.include?(method_name) ||
+            private_methods.include?(method_name)
+          )
+        end
+
+        def method_takes_arguments? method_name
+          return nil  unless (method_exists?(method_name))
+          meth = method method_name
+          return meth.arity.abs > 0
+        end
+    end
+  end
+end