gamefic 0.2.0 → 0.6.0

data/lib/gamefic/scene/active.rb

@@ -0,0 +1,25 @@
+module Gamefic
+
+  class ActiveSceneManager < SceneManager
+    def scene_class
+      ActiveScene
+    end
+    def state
+      @state ||= "Active"
+    end
+  end
+  
+  class ActiveScene < Scene
+    def finish actor, input
+      @data.input = input
+      if @finish.nil?
+        last_order = actor.perform data.input
+        # HACK Set the last_order here so inline performs don't set it
+        actor.send(:last_order=, last_order)
+      else
+        @finish.call actor, data
+      end
+    end
+  end
+
+end

data/lib/gamefic/scene/concluded.rb

@@ -0,0 +1,22 @@
+module Gamefic
+
+  class ConcludedSceneManager < SceneManager
+    def scene_class
+      ConcludedScene
+    end
+    def state
+      @state ||= "Concluded"
+    end
+    def prompt
+      @prompt ||= "GAME OVER"
+    end
+  end
+  
+  class ConcludedScene < Scene
+    # TODO: This class might need some logic for closing the game. Then again,
+    # maybe not. The Concluded state might be enough for the plot to know what
+    # to do. In fact, if the plot detects the Concluded state, it might never
+    # get around to calling the scene's finish proc.
+  end
+
+end

data/lib/gamefic/scene/multiplechoice.rb

@@ -0,0 +1,74 @@
+module Gamefic
+
+  class MultipleChoiceSceneManager < SceneManager
+    def data_class
+      MultipleChoiceSceneData
+    end
+    def scene_class
+      MultipleChoiceScene
+    end
+    def state
+      @state ||= "MultipleChoice"
+    end
+    def prompt
+      @prompt ||= "Enter a choice:"
+    end
+  end
+  
+  class MultipleChoiceSceneData < SceneData
+    attr_accessor :index, :selection, :options
+    def options
+      @options ||= []
+    end
+  end
+
+  class MultipleChoiceScene < Scene
+    def initialize manager, key
+      super
+      @prompt ||= "Enter a choice:"
+    end
+    def start actor
+      super
+      list = '<ol class="multiple_choice">'
+      @data.options.each { |o|
+        list += "<li>#{o}</li>"
+      }
+      list += "</ol>"
+      actor.tell list
+      @data.prompt ||= @prompt
+    end
+    def finish actor, input
+      @data.input = input
+      @data.index = nil
+      @data.selection = nil
+      if @data.input.strip =~ /[0-9]+/
+        if input.to_i > 0
+          @data.index = input.to_i - 1
+          @data.selection = @data.options[@data.index]
+          @data.index = nil if @data.selection.nil?
+        end
+      else
+        i = 0
+        @data.options.each { |o|
+          if o.casecmp(@data.input).zero?
+            @data.index = i
+            @data.selection = o
+            break
+          end
+          i += 1
+        }
+      end
+      if @data.selection.nil?
+        # TODO: Consider allowing for an error block to customize this
+        # response.
+        actor.tell "That's not a valid selection."
+      else
+        @data.next_cue ||= :active
+        if !@finish.nil?
+          @finish.call actor, @data
+        end
+      end
+    end
+  end
+
+end

data/lib/gamefic/scene/paused.rb

@@ -0,0 +1,26 @@
+module Gamefic
+
+  class PausedSceneManager < SceneManager
+    def scene_class
+      PausedScene
+    end
+    def data_class
+      PausedSceneData
+    end
+    def state
+      @state ||= "Paused"
+    end
+    def prompt
+      @prompt ||= "Press enter to continue..."
+    end
+  end
+  
+  class PausedSceneData < SceneData
+    attr_accessor :next_cue
+  end
+  
+  class PausedScene < Scene
+  
+  end
+
+end

data/lib/gamefic/scene/yesorno.rb

@@ -0,0 +1,43 @@
+module Gamefic
+
+  class YesOrNoSceneManager < SceneManager
+    def scene_class
+      YesOrNoScene
+    end
+    def data_class
+      YesOrNoSceneData
+    end
+    def state
+      @state ||= "YesOrNo"
+    end
+    def prompt
+      @prompt ||= "Enter Yes Or No:"
+    end
+  end
+  
+  class YesOrNoSceneData < SceneData
+    # @!attribute [rw] answer
+    #   @return [String] The answer provided by the user, normalized to either "yes" or "no"
+    attr_accessor :answer
+  end
+  
+  class YesOrNoScene < Scene
+    def finish actor, input
+      @data.input = input
+      # The input in a YesOrNoScene gets normalized to "yes" or "no"
+      @data.answer = nil
+      if input.downcase[0, 1] == "y"
+        @data.answer = "yes"
+      elsif input.downcase[0, 1] == "n"
+        @data.answer = "no"
+      end
+      if @data.answer.nil?
+        actor.tell "Please enter Yes or No."
+      else
+        return if @finish.nil?
+        @finish.call actor, data
+      end
+    end
+  end
+
+end

data/lib/gamefic/scene.rb

@@ -0,0 +1,125 @@
+module Gamefic
+
+  # SceneManagers handle the creation and execution of player scenes.
+  #
+  # @example Create a scene that lets the player select a name.
+  #   scene_managers[:get_name] = SceneManager.new do |manager|
+  #     manager.state = "Active" # Tell the Engine that this scene accepts input
+  #     manager.prompt = "Enter your name:"
+  #     manager.start do |actor, data|
+  #       actor.tell "Let's start with a formal introduction."
+  #     end
+  #     manager.finish do |actor, data|
+  #       actor[:name] = data.input
+  #       actor.tell "Howdy, #{actor[:name]}!"
+  #       actor.next_cue = :active # Proceed to the default :active scene
+  #     end
+  #   end
+  #
+  class SceneManager
+    attr_accessor :state
+    attr_writer :prompt
+    
+    def initialize &block
+      yield self if block_given?
+    end
+    
+    # Get the SceneData class that provide data about the current event to a
+    # Scene instance.
+    #
+    def data_class
+      SceneData
+    end
+    
+    # Get the name that describes this scene's state.
+    # Two common values for the state are Active and Passive. If a scene is
+    # Active, it is capable of accepting user input. If it is Passive, it
+    # is probably not interactive (e.g., a cutscene) and will usually cue
+    # an Active scene in order to continue gameplay.
+    #
+    # @return [String] The name of the state.
+    def state
+      @state ||= 'Passive'
+    end
+    
+    # Get the Scene class that the SceneManager uses to prepare a scene for
+    # the plot.
+    #
+    def scene_class
+      Scene
+    end
+    
+    # Define a Block to be executed when the scene starts. The Engine should
+    # execute this block before the player is queried for input.
+    #
+    # @yieldparam [Character]
+    # @yieldparam [SceneData]
+    def start &block
+      @start = block
+    end
+    
+    # Define a Block to be executed when the scene finishes. The engine should
+    # process user input in this block.
+    #
+    # @yieldparam [Character]
+    # @yieldparam [SceneData]
+    def finish &block
+      @finish = block
+    end
+    
+    # Prepare a new Scene for execution.
+    #
+    # @return [Scene]
+    def prepare key
+      scene_class.new(self, key)
+    end
+    
+    # Get the prompt to display to the user when requesting input.
+    #
+    # @return [String]
+    def prompt
+      @prompt ||= ">"
+    end
+end
+  
+  class SceneData
+    attr_accessor :input, :prompt, :next_cue
+  end
+  
+  class Scene
+    attr_reader :data, :state, :key
+    
+    def initialize(manager, key)
+      @manager = manager
+      @start = manager.instance_variable_get(:@start)
+      @finish = manager.instance_variable_get(:@finish)
+      @state = manager.state
+      @data = manager.data_class.new
+      @data.prompt = manager.prompt
+      @key = key
+    end
+    
+    # Start the scene. This method is typically called by the Plot.
+    #
+    # @param actor [Character] The Scene's Character.
+    def start actor
+      return if @start.nil?
+      @data.input = nil
+      @start.call actor, @data
+    end
+    
+    # Finish the scene. This method is typically called by the Plot.
+    # The Finish method is responsible for processing any input received
+    # from players.
+    #
+    # @param actor [Character] The Scene's Character.
+    # @param input [String] Input received from the Character (e.g., a player command).
+    def finish actor, input
+      @data.next_cue ||= :active
+      return if @finish.nil?
+      @data.input = input
+      @finish.call actor, @data
+    end
+  end
+
+end

data/lib/gamefic/script/base.rb

@@ -0,0 +1,33 @@
+module Gamefic
+
+  class Script::Base
+    def initialize
+      raise "#initialize must be defined in subclasses"
+    end
+    # Get the script's text.
+    # The text must be source code suitable for evaluation via Plot#stage.
+    #
+    # @return [String]
+    def read
+      raise "#read must be defined in subclasses"
+    end
+    # Get the script's path
+    #
+    # @return [String]
+    def path
+      raise "#path must be defined in subclasses"
+    end
+    # Get the absolute path of the script's original file
+    #
+    # @return [String]
+    def absolute_path
+      raise "#absolute_path must be defined in subclasses"
+    end
+    # @param other[Script::Base]
+    # @return [Boolean]
+    def==(other)
+      path == other.path
+    end
+  end
+
+end

data/lib/gamefic/script/file.rb

@@ -0,0 +1,14 @@
+module Gamefic
+
+  class Script::File < Script::Base
+    attr_reader :path, :absolute_path
+    def initialize filename, path
+      @absolute_path = filename.gsub(/\/+/, '/')
+      @path = path
+    end
+    def read
+      File.read(@absolute_path)
+    end
+  end
+
+end

data/lib/gamefic/script/text.rb

@@ -0,0 +1,14 @@
+module Gamefic
+  
+  class Script::Text < Script::Base
+    attr_reader :path, :absolute_path
+    def initialize path, code, absolute_path = nil
+      @path = path
+      @code = code
+      @absolute_path = absolute_path || path
+    end
+    def read
+      @code
+    end
+  end
+end

data/lib/gamefic/script.rb

@@ -0,0 +1,9 @@
+module Gamefic
+
+  module Script
+    autoload :Base, 'gamefic/script/base'
+    autoload :File, 'gamefic/script/file'
+    autoload :Text, 'gamefic/script/text'
+  end
+
+end

data/lib/gamefic/serialized.rb

@@ -0,0 +1,24 @@
+module Gamefic
+  module Serialized
+    def serialized_attributes
+      self.class.serializer.keys
+    end
+    module ClassMethods
+      def serialize *args
+        args.each { |a|
+          serializer[a] = nil
+        }
+      end
+      def serializer
+        @@serialized_attributes ||= from_superclass(:serializer, {}).dup
+      end
+      private
+      def from_superclass(m, default = nil)
+        superclass.respond_to?(m) ? superclass.send(m) : default
+      end
+    end
+    def self.included(base)
+      base.extend(Gamefic::Serialized::ClassMethods)
+    end
+  end
+end