gamefic 0.2.0 → 0.6.0

data/lib/gamefic/plot.rb

@@ -1,238 +1,297 @@
+# TODO: JSON support is currently experimental.
+#require 'gamefic/entityloader'
+require 'gamefic/stage'
+require 'gamefic/tester'
+require 'gamefic/source'
+require 'gamefic/script'
+require 'gamefic/query'
+require 'gamefic/plot/article_mount'
+require 'gamefic/plot/you_mount'
+
 module Gamefic
 
-  def self.bind(plot)
-    mod = Module.new do
-      def self.bind(plot)
-        @@plot = plot
-      end
-      def self.get_binding
-        binding
-      end
-      def self.method_missing(name, *args, &block)
-        if @@plot.respond_to?(name)
-          @@plot.send name, *args, &block
-        elsif Gamefic.respond_to?(name)
-          Gamefic.send name, *args, &block
-        end
-      end
+  class Plot
+    autoload :SceneMount, 'gamefic/plot/scene_mount'
+    autoload :CommandMount, 'gamefic/plot/command_mount'
+    autoload :EntityMount, 'gamefic/plot/entity_mount'
+    autoload :QueryMount, 'gamefic/plot/query_mount'
+    #autoload :ArticleMount, 'gamefic/plot/article_mount'
+    #autoload :YouMount, 'gamefic/plot/you_mount'
+    attr_reader :commands, :imported_scripts, :rules, :asserts, :source
+    attr_accessor :default_scene
+    include Stage
+    # TODO This include is only here to make the module's methods visible in the IDE.
+    # Gamefic Studio has a PlotStageMetaMapper that handles it, but it doesn't run if
+    # the plugin isn't activated.
+    include Gamefic, Tester, SceneMount, CommandMount, EntityMount, QueryMount, ArticleMount, YouMount
+    mount Gamefic, Tester, SceneMount, CommandMount, EntityMount, QueryMount, ArticleMount, YouMount
+    expose :script, :introduction, :assert_action, :on_update, :on_player_update, :entities, :on_ready, :on_player_ready, :players
+    
+    # @param [Source::Base]
+    def initialize(source = nil)
+      @source = source || Source::Text.new({})
+      @commands = Hash.new
+      @syntaxes = Array.new
+      @ready_procs = Array.new
+      @update_procs = Array.new
+      @player_ready = Array.new
+      @player_procs = Array.new
+      @working_scripts = Array.new
+      @imported_scripts = Array.new
+      @entities = Array.new
+      @players = Array.new
+      @asserts = Hash.new
+      @default_scene = :active
+      post_initialize
     end
-    mod.bind plot
-    mod.get_binding
-  end
-  
-  def self.safe_level
-    @@safe_level ||= (RUBY_VERSION.split('.')[0].to_i < 2 ? 2 : 3)
-  end
-  
-	class Plot
-		attr_reader :scenes, :commands, :conclusions, :imported_scripts, :rules
-		attr_accessor :story
-    include OptionMap
-		def commandwords
-			words = Array.new
-			@syntaxes.each { |s|
-        word = s.template[0]
-				words.push(word) if !word.kind_of?(Symbol)
-			}
-			words.uniq
-		end
-		def initialize
-			@scenes = Hash.new
-			@commands = Hash.new
-			@syntaxes = Array.new
-			@conclusions = Hash.new
-			@update_procs = Array.new
-      @available_scripts = Hash.new
-			@imported_scripts = Array.new
-			@entities = Array.new
-      @rules = Hash.new
-			post_initialize
-		end
-    def assert name, &block
-      @rules[name] = Requirement.new self, name, &block
+    
+    # Get an Array of all Actions defined in the Plot.
+    #
+    # @return Array[Action]
+    def actions
+      @commands.values.flatten
     end
-		def post_initialize
+    
+    # Get an Array of all Actions associated with the specified verb.
+    #
+    # @param verb [Symbol] The Symbol for the verb (e.g., :go or :look)
+    # @return Array<Action> The verb's associated Actions
+    def actions_with_verb(verb)
+      @commands[verb].clone || []
+    end
+    
+    # Get an Array of all scripts that have been imported into the Plot.
+    #
+    # @return [Array<Script>] The imported scripts
+    def imported_scripts
+      @imported_scripts ||= []
+    end
+    
+    # Add a Block to be executed for the given verb.
+    # If the block returns false, the Action is cancelled.
+    #
+    # @example Require the player to have a property enabled before performing the Action.
+    #   assert_action :authorize do |actor, verb, arguments|
+    #     if actor[:can_authorize] == true
+    #       true
+    #     else
+    #       actor.tell "You don't have permission to use the authorize command."
+    #       false
+    #     end
+    #   end
+    #
+    # @yieldparam [Character] The character performing the Action.
+    # @yieldparam [Symbol] The verb associated with the Action.
+    # @yieldparam [Array] The arguments that will be passed to the Action's #execute method.
+    def assert_action name, &block
+      @asserts[name] = Assert.new(name, &block)
+    end
+    
+    def post_initialize
       # TODO: Should this method be required by extended classes?
-		end
-		def meta(command, *queries, &proc)
-			act = Meta.new(self, command, *queries, &proc)
-		end
-		def action(command, *queries, &proc)
-			act = Action.new(self, command, *queries, &proc)
-		end
-		def respond(command, *queries, &proc)
-			self.action(command, *queries, &proc)
-		end
-		def before(command, *queries, &proc)
-			bef = Before.new(self, command, *queries, &proc)
-		end
-		def make(cls, args = {})
-			ent = cls.new(self, args)
-			if ent.kind_of?(Entity) == false
-				raise "Invalid entity class"
-			end
-			ent
-		end
-		def syntax(*args)
-      xlate *args
-		end
-		def xlate(*args)
-			syn = Syntax.new(self, *args)
-			@syntaxes.push syn
-			syn
-		end
-		def entities
-			@entities.clone
-		end
-		def syntaxes
-			@syntaxes.clone
-		end
-		def on_update(&block)
-			@update_procs.push block
-		end
-		def introduction (&proc)
-			@introduction = proc
-		end
-		def conclusion(key, &proc)
-			@conclusions[key] = proc
-		end
-		def scene(key, &proc)
-			@scenes[key] = proc
-		end
-		def introduce(player)
-			if @introduction != nil
-				@introduction.call(player)
-			end
-		end
-		def conclude(player, key = nil)
-			if key != nil and @conclusions[key]
-				@conclusions[key].call(player)
-        player.state = GameOverState.new(player)
-			end
-		end
-		def cue scene
-			@scenes[scene].call
-		end
-		def passthru
-			Director::Delegate.passthru
-		end
-    def pass requirement
-      Director::Delegate.pass requirement
     end
-    def deny requirement
-      Director::Delegate.deny requirement
+    
+    # Get an Array of the Plot's current Entities.
+    #
+    # @return [Array<Entity>]
+    def entities
+      @entities.clone
     end
-		def update
-			@update_procs.each { |p|
-				p.call
-			}
-      @entities.each { |e|
-				e.update
-			}
-		end
-
-		def tell entities, message, refresh = false
-			entities.each { |entity|
-				entity.tell message, refresh
-			}
-		end
-
-    def load script, with_libs = true
-      code = File.read(script)
-      code.untaint
-      @source_directory = File.dirname(script)
-      if with_libs == true
-        $LOAD_PATH.reverse.each { |path|
-          get_scripts path + '/gamefic/import'
-        }
+    
+    # Get an Array of the Plot's current Syntaxes.
+    #
+    # @return [Array<Syntax>]
+    def syntaxes
+      @syntaxes.clone
+    end
+    
+    # Get an Array of current players.
+    #
+    # @return [Array<Character>] The players.
+    def players
+      @players.clone
+    end
+    
+    # Add a block to be executed on preparation of every turn.
+    # Each on_ready block is executed once per turn, as opposed to
+    # on_player_ready blocks, which are executed once for each player.
+    #
+    # @example Increment a turn counter
+    #   turn = 0
+    #   on_ready do
+    #     turn += 1
+    #   end
+    #
+    def on_ready(&block)
+      @ready_procs.push block
+    end
+    
+    # Add a block to be executed after the Plot is finished updating a turn.
+    # Each on_update block is executed once per turn, as opposed to
+    # on_player_update blocks, which are executed once for each player.
+    def on_update(&block)
+      @update_procs.push block
+    end
+    
+    # Add a block to be executed when a player is added to the game.
+    # Each Plot can only have one introduction. Subsequent calls will
+    # overwrite the existing one.
+    #
+    # @example Welcome the player to the game
+    #   introduction do |actor|
+    #     actor.tell "Welcome to the game!"
+    #   end
+    #
+    # @yieldparam [Character]
+    def introduction (&proc)
+      @introduction = proc
+    end
+    
+    # Introduce a player to the game.
+    # This method is typically called by the Engine that manages game execution.
+    def introduce(player)
+      @players.push player
+      if @introduction != nil
+        @introduction.call(player)
+      end
+      # TODO: There should probably be a default state specified
+      # by the plot, which would be :active by default. We could
+      # get it like player.cue nil.
+      if player.scene.nil?
+        cue player, default_scene
+        ready
+        update
       end
-      get_scripts @source_directory + '/import'
-      proc {
-        $SAFE = Gamefic.safe_level
-        eval code, ::Gamefic.bind(self), script, 1
-      }.call
     end
     
-    def import script
-      if script[-2, 2] == '/*'
-        directory = script[0..-3]
-        resolved = directory
-        @available_scripts.each { |f, c|
-          if f.start_with?(resolved)
-            self.import f
-          end
+    # Prepare the Plot for the next turn of gameplay.
+    # This method is typically called by the Engine that manages game execution.
+    def ready
+      @ready_procs.each { |p|
+        p.call
+      }
+      # Prepare player scenes for the update.
+      @players.each { |player|
+        @player_ready.each { |block|
+          block.call player
         }
+        player.scene.start player
+      }
+    end
+    
+    # Update the Plot's current turn of gameplay.
+    # This method is typically called by the Engine that manages game execution.
+    def update
+      # Update the plot.
+      @players.each { |player|
+        process_input player
+      }
+      @entities.each { |e|
+        e.update
+      }
+      @players.each { |player|
+        update_player player
+        cue player, player.scene.data.next_cue if !player.scene.data.next_cue.nil?
+      }
+      @update_procs.each { |p|
+        p.call
+      }
+    end
+
+    def tell entities, message, refresh = false
+      entities.each { |entity|
+        entity.tell message, refresh
+      }
+    end
+
+    # Load a script into the current Plot.
+    # This method is similar to Kernel#require, except that the script is
+    # evaluated within the Plot's context via #stage.
+    #
+    # @param path [String] The path to the script being evaluated
+    # @return [Boolean] true if the script was loaded by this call or false if it was already loaded.
+    def script path
+      imported_script = source.export(path)
+      if imported_script.nil?
+        raise "Script not found: #{path}"
+      end
+      if !@working_scripts.include?(imported_script) and !imported_scripts.include?(imported_script)
+        @working_scripts.push imported_script
+        stage imported_script.read, imported_script.absolute_path
+        @working_scripts.pop
+        imported_scripts.push imported_script
+        true
       else
-        resolved = script
-        if !@available_scripts.has_key?(resolved)
-          if @available_scripts.has_key?(resolved + '.rb')
-            resolved = resolved + '.rb'
-          end
-        end
-        if @available_scripts.has_key?(resolved)
-          if @available_scripts[resolved] != nil
-            script_object = @available_scripts[resolved]
-            @available_scripts[resolved] = nil
-            proc {
-              $SAFE = Gamefic.safe_level
-              @imported_scripts.push script_object
-              eval script_object.code, Gamefic.bind(self), script_object.filename, 1
-            }.call
-          end
-        else
-          raise "Unavailable import: #{resolved}"
-        end
+        false
       end
     end
     
-		private
-    def get_scripts(directory)
-      Dir[directory + '/*'].each { |f|
-        if File.directory?(f)
-          get_scripts f
-        else
-          relative = f[(f.index('/import/')+8)..-1]
-          @available_scripts[relative] = Script.new(f)
-        end
+    # Add a block to be executed for each player when the Plot prepares them
+    # for the next turn in the game.
+    #
+    # @yieldparam [Character]
+    def on_player_ready &block
+      @player_ready.push block
+    end
+    
+    # Add a block to  be executed for each player after they have completed a
+    # turn in the game.
+    #
+    # @yieldparam [Character]
+    def on_player_update &block
+      @player_procs.push block
+    end
+
+    private
+    def process_input player
+      line = player.queue.shift
+      if !line.nil?
+        player.scene.finish player, line
+        #cue player, player.scene.data.next_cue if !player.scene.data.next_cue.nil?
+      end
+    end
+    def update_player player
+      @player_procs.each { |proc|
+        proc.call player
       }
+      # HACK Exception for running tests
+      if player[:testing] == true
+        cue player, :test
+      end
     end
-		def rem_entity(entity)
-			@entities.delete(entity)
-		end
-		def recursive_update(entity)
-			entity.update
-			entity.children.each { |e|
-				recursive_update e
-			}
-		end	
-		def add_syntax syntax
-			if @commands[syntax.command] == nil
-				raise "Action \"#{syntax.command}\" does not exist"
-			end
-			@syntaxes.unshift syntax
-			@syntaxes.sort! { |a, b|
-				al = a.template.length
-        if (a.command.nil?)
-          al -= 1
-        end
-				bl = b.template.length
-        if (b.command.nil?)
-          bl -= 1
+    def rem_entity(entity)
+      @entities.delete(entity)
+    end
+    def recursive_update(entity)
+      entity.update
+      entity.children.each { |e|
+        recursive_update e
+      }
+    end  
+    def add_syntax syntax
+      if @commands[syntax.verb] == nil
+        raise "Action \"#{syntax.verb}\" does not exist."
+      end
+      # Delete duplicate syntaxes
+      @syntaxes = @syntaxes.delete_if { |existing|
+        existing == syntax
+      }
+      @syntaxes.unshift syntax
+      @syntaxes.sort! { |a, b|
+        if a.token_count == b.token_count
+          # For syntaxes of the same length, length of action takes precedence
+          b.first_word <=> a.first_word
+        else
+          b.token_count <=> a.token_count
         end
-				if al == bl
-					# For syntaxes of the same length, creation order takes precedence
-					0
-				else
-					bl <=> al
-				end
-			}			
-		end
-		def add_action(action)
-			if (@commands[action.command] == nil)
-				@commands[action.command] = Array.new
-			end
-			@commands[action.command].unshift action
-			@commands[action.command].sort! { |a, b|
+      }      
+    end
+    def add_action(action)
+      if (@commands[action.verb] == nil)
+        @commands[action.verb] = Array.new
+      end
+      @commands[action.verb].unshift action
+      @commands[action.verb].sort! { |a, b|
         if a.specificity == b.specificity
           # Newer action takes precedence
           b.order_key <=> a.order_key
@@ -240,41 +299,31 @@ module Gamefic
           # Higher specificity takes precedence
           b.specificity <=> a.specificity
         end
-			}
-      #if action.command != nil
-        user_friendly = action.command.to_s.sub(/_/, ' ')
-        args = Array.new
-        used_names = Array.new
-        action.queries.each { |c|
-          num = 1
-          new_name = "var"
-          while used_names.include? new_name
-            num = num + 1
-            new_name = "var#{num}"
-          end
-          used_names.push new_name
-          user_friendly += " :#{new_name}"
-          args.push new_name.to_sym
-        }
-        Syntax.new self, *[user_friendly.strip, action.command] + args
-      #end
-		end
+      }
+      user_friendly = action.verb.to_s.gsub(/_/, ' ')
+      args = Array.new
+      used_names = Array.new
+      action.queries.each { |c|
+        num = 1
+        new_name = ":var"
+        while used_names.include? new_name
+          num = num + 1
+          new_name = ":var#{num}"
+        end
+        used_names.push new_name
+        user_friendly += " #{new_name}"
+        args.push new_name
+      }
+      Syntax.new self, user_friendly.strip, "#{action.verb} #{args.join(' ')}"
+    end
     def rem_action(action)
-      @commands[action.command].delete(action)
+      @commands[action.verb].delete(action)
     end
     def rem_syntax(syntax)
       @syntaxes.delete syntax
     end
-		def add_entity(entity)
-			@entities.push entity
-		end
-    class Script
-      attr_reader :filename, :code
-      def initialize filename
-        @filename = filename
-        @code = File.read(filename)
-        @code.untaint
-      end
+    def add_entity(entity)
+      @entities.push entity
     end
   end
 

data/lib/gamefic/query/ambiguous_children.rb

@@ -0,0 +1,5 @@
+class Gamefic::Query::AmbiguousChildren < Gamefic::Query::ManyChildren
+  def allow_ambiguous?
+    true
+  end
+end