gamefic-sdk 1.6.0 → 1.7.0

data/lib/gamefic-sdk/plot_config.rb

@@ -1,25 +0,0 @@
-require 'yaml'
-
-module Gamefic::Sdk
-  
-  class PlotConfig
-    attr_reader :author, :title, :script_paths, :media_paths
-    def initialize filename = nil
-      @script_paths = []
-      @media_paths = []
-      if !filename.nil?
-	      config = YAML.load_file filename
-	      base_dir = File.dirname(filename)
-	      @author = config['author']
-	      @title = config['title']
-	      config['script_paths'].each { |p|
-	        @script_paths.push File.absolute_path(p, base_dir)
-	      } if !config['script_paths'].nil?
-	      config['media_paths'].map! { |p|
-	        @media_paths.push File.absolute_path(p, base_dir)
-	      } if !config['media_paths'].nil?
-      end
-    end
-  end
-  
-end

data/scripts/ansi.plot.rb

@@ -1,13 +0,0 @@
-meta :ansi do |actor|
-  actor.tell "Ansi is #{ansi ? 'ON' : 'OFF'}."
-end
-
-meta :ansi, Query::Text.new('on') do |actor, string|
-  actor.ansi = true
-  actor.tell "Ansi is ON."
-end
-
-meta :ansi, Query::Text.new('off') do |actor, string|
-  actor.ansi = false
-  actor.tell "Ansi is OFF."
-end

data/scripts/autosuggest.plot.rb

@@ -1,165 +0,0 @@
-script 'suggestible'
-
-module Gamefic::Autosuggest
-  def suggest_from entity
-    suggest_take_from entity
-    suggest_examine_from entity
-  end
-  def suggest_take_from entity
-    portables = entity.children.that_are(:portable?)
-    portables.each { |p|
-      suggest "take #{p.definitely}"
-    }
-  end
-  def suggest_examine_from entity
-    entity.children.that_are_not(Portal).that_are_not(self).each { |e|
-      suggest "examine #{e.definitely}"
-    }
-  end
-end
-
-class Gamefic::Character
-  include Autosuggest
-end
-
-# Suggestions get updated (future suggestions become current) in
-# on_player_ready. Autosuggest gathers suggestions in on_ready so it gets
-# done first.
-on_player_ready do |actor|
-  if (actor.scene == default_scene and actor.next_scene.nil?) or actor.next_scene == default_scene
-    actor.suggest "look around"
-    actor.suggest "inventory"
-    actor.room.children.that_are(Portal).each { |entity|
-      if entity.direction
-        actor.suggest "go #{entity.direction}"
-      else
-        actor.suggest "go to #{the entity.destination}"
-      end
-    }
-    Use.visible.context_from(actor).that_are_not(Portal).each { |entity|
-      actor.suggest "examine #{the entity}"
-    }
-    Use.visible.context_from(actor).that_are(:portable?).each { |entity|
-      actor.suggest "take #{the entity}" unless entity.parent == actor
-    }
-    Use.visible.context_from(actor).that_are(Container).that_are_not(:open?).each { |entity|
-      actor.suggest "close #{the entity}"
-    }
-    Use.visible.context_from(actor).that_are(Container).that_are(:open?).each { |entity|
-      actor.suggest "search #{the entity}"
-      actor.suggest "close #{the entity}"
-    }
-    Use.siblings.context_from(actor).that_are(Enterable).that_are(:enterable?).each { |entity|
-      actor.suggest "#{entity.enter_verb} #{the entity}"
-    }
-    Use.siblings.context_from(actor).that_are(Character).that_are_not(actor).each { |entity|
-      actor.suggest "talk to #{the entity}"
-    }
-    if (actor.parent != actor.room)
-      actor.suggest "#{actor.parent.leave_verb} #{the actor.parent}"
-    end
-    vicinity = actor.parent.children.that_are_not(Portal)
-    if actor.parent != actor.room
-      vicinity.concat actor.room.children.that_are_not(Portal)
-    end
-    vicinity = vicinity - [actor]
-    vicinity.each { |e|
-      actor.suggest "examine #{the e}"
-    }
-  end
-end
-
-respond :look, Use.visible(Supporter) do |actor, supporter|
-  actor.proceed
-  actor.suggest_from supporter
-end
-
-respond :look, Use.visible(Receptacle) do |actor, receptacle|
-  actor.proceed
-  # Include suggestions from the receptacle if they're visible
-  # (e.g., the receptacle is not a closed opaque container) 
-  available = Use.visible.context_from(actor) & receptacle.children
-  if available.length > 0
-    actor.suggest_from receptacle
-  end
-end
-
-respond :look, Use.visible(Container) do |actor, container|
-  actor.proceed
-  if container.open?
-    actor.suggest "close #{the container}"
-  else
-    if container.locked?
-      actor.suggest "unlock #{the container}"
-    else
-      actor.suggest "open #{the container}"
-      if !container.lock_key.nil?
-        actor.suggest "lock #{the container}"
-      end
-    end
-  end
-end
-
-respond :look, Use.visible(Character) do |actor, character|
-  actor.proceed
-  actor.suggest "talk to #{the character}"
-end
-
-respond :look, Use.room do |actor, room|
-  actor.proceed
-  actor.suggest_from room
-end
-
-respond :look, Use.visible(:portable?) do |actor, thing|
-  actor.proceed
-  actor.suggest "take #{the thing}" unless thing.parent == actor
-end
-
-respond :inventory do |actor|
-  actor.proceed
-  carried = actor.children.that_are_not(:attached?)
-  carried.each { |e|
-    actor.suggest "drop #{the e}"
-    actor.suggest "examine #{the e}"  
-  }
-  reachable = Use.reachable.context_from(actor)
-  reachable.that_are(Supporter).each { |supporter|
-    carried.each { |thing|
-      actor.suggest "put #{the thing} on #{the supporter}"
-    }
-  }
-  reachable.that_are(Receptacle).each { |receptacle|
-    carried.each { |thing|
-      actor.suggest "put #{the thing} in #{the receptacle}"
-    }
-  }
-end
-
-respond :drop, Use.children do |actor, thing|
-  actor.proceed
-  actor.quietly :inventory
-end
-
-respond :search, Use.reachable(Receptacle) do |actor, receptacle|
-  actor.proceed
-  actor.children.that_are_not(:attached?).each { |e|
-    actor.suggest "put #{the e} in #{the receptacle}"
-  }
-end
-
-respond :search, Use.reachable(Container) do |actor, container|
-  if container.open?
-    actor.proceed
-  else
-    if container.has_description?
-      actor.tell container.description
-    end
-    if container.locked?
-      actor.tell "#{The container} is locked."
-      actor.suggest "unlock #{the container}"
-    else
-      actor.tell "#{The container} is closed."
-      actor.suggest "open #{the container}"
-    end
-  end
-end

data/scripts/clothing.plot.rb

@@ -1,2 +0,0 @@
-script 'clothing/entities'
-script 'clothing/actions'

data/scripts/clothing/actions.plot.rb

@@ -1,4 +0,0 @@
-script 'clothing/actions/doff'
-script 'clothing/actions/drop'
-script 'clothing/actions/inventory'
-script 'clothing/actions/wear'

data/scripts/clothing/actions/wear.plot.rb

@@ -1,19 +0,0 @@
-respond :wear, Use.family(Clothing) do |actor, clothing|
-  if actor.auto_takes?(clothing)
-    if clothing.attached?
-      actor.tell "You're already wearing #{the clothing}."
-    else
-      already = actor.children.that_are(clothing.class).that_are(:attached?)
-      if already.length == 0
-        clothing.attached = true
-        actor.tell "You put on #{the clothing}."
-      else
-        actor.tell "You're already wearing #{an already[0]}."
-      end
-    end
-  end
-end
-
-xlate "put on :clothing", "wear :clothing"
-xlate "put :clothing on", "wear :clothing"
-xlate "don :clothing", "wear :clothing"

data/scripts/clothing/entities.plot.rb

@@ -1,7 +0,0 @@
-script 'clothing/entities/clothing'
-script 'clothing/entities/coat'
-script 'clothing/entities/gloves'
-script 'clothing/entities/hat'
-script 'clothing/entities/pants'
-script 'clothing/entities/shirt'
-script 'clothing/entities/shoes'

data/scripts/clothing/entities/coat.plot.rb

@@ -1,5 +0,0 @@
-script 'clothing/entities/clothing'
-
-class Coat < Clothing
-
-end

data/scripts/clothing/entities/gloves.plot.rb

@@ -1,5 +0,0 @@
-script 'clothing/entities/clothing'
-
-class Gloves < Clothing
-
-end

data/scripts/clothing/entities/hat.plot.rb

@@ -1,5 +0,0 @@
-script 'clothing/entities/clothing'
-
-class Hat < Clothing
-
-end

data/scripts/clothing/entities/pants.plot.rb

@@ -1,5 +0,0 @@
-script 'clothing/entities/clothing'
-
-class Pants < Clothing
-
-end

data/scripts/clothing/entities/shirt.plot.rb

@@ -1,5 +0,0 @@
-script 'clothing/entities/clothing'
-
-class Shirt < Clothing
-
-end

data/scripts/clothing/entities/shoes.plot.rb

@@ -1,5 +0,0 @@
-script 'clothing/entities/clothing'
-
-class Shoes < Clothing
-
-end

data/scripts/cover.plot.rb

@@ -1,30 +0,0 @@
-script 'media'
-
-module Gamefic::CoverImageViewer
-  attr_accessor :cover_image
-end
-
-class Gamefic::Character
-  include CoverImageViewer
-end
-
-on_player_update do |actor|
-  if !actor.cover_image.nil?
-    actor.stream "<figure class=\"cover\"><img src=\"media/#{actor.cover_image}\" /></figure>"
-  end
-  actor.cover_image = nil
-end
-
-respond :look, Use.room do |actor, room|
-  if !room.image.nil?
-    actor.cover_image = room.image
-  end
-  actor.proceed
-end
-
-respond :look, Use.reachable do |actor, thing|
-  if !thing.image.nil?
-    actor.cover_image = thing.image
-  end
-  actor.proceed
-end

data/scripts/furniture.plot.rb

@@ -1,35 +0,0 @@
-class Gamefic::Seat < Gamefic::Entity
-  include Enterable
-  def initialize plot, args = {}
-    self.enterable = true
-    self.enter_verb = "sit on"
-    self.leave_verb = "stand up from"
-    self.inside_verb = "be sitting on"
-    super
-  end
-end
-
-respond :sit do |actor|
-  seats = Use.reachable.context_from(actor).that_are(Seat)
-  if seats.length == 1
-    actor.perform :enter, seats[0]
-  elsif seats.length > 1
-    actor.tell "I don't know where you want to sit: #{seats.join_or}"
-  else
-    actor.tell "There's nowhere to sit here."
-  end
-end
-
-respond :stand do |actor|
-  if actor.parent == actor.room
-    actor.tell "You're already standing."
-  else
-    actor.perform :leave, actor.parent
-  end
-end
-
-interpret "sit :seat", "enter :seat"
-interpret "sit on :seat", "enter :seat"
-interpret "stand up from :seat", "leave :seat"
-interpret "sit down", "sit"
-interpret "stand up", "stand"

data/scripts/hints.plot.rb

@@ -1,31 +0,0 @@
-class Character
-  def hints
-    @hints ||= []
-  end
-  def hint message
-    hints.push message
-    if self.is? :strongly_guided
-      self.stream "<p class=\"hint\">#{message}</p>"
-    end
-  end
-end
-
-options Character, :lightly_guided, :strongly_guided, :never_guided
-
-finish_action :reset_hints do |actor|
-  actor.hints.clear
-end
-
-meta :hint do |actor|
-  if !actor.is? :never_guided
-    if actor.hints.length > 0
-      actor.hints.each { |hint|
-        actor.tell hint
-      }
-    else
-      actor.tell "There are no hints available right now."
-    end
-  else
-    actor.tell "There are no hints available in this game."
-  end
-end

data/scripts/hypertext.plot.rb

@@ -1,280 +0,0 @@
-script 'clothing'
-
-module Gamefic::Hypertext
-  def self.link command, text = nil
-    "<a rel=\"gamefic\" href=\"#\" data-command=\"#{command}\">#{text || command}</a>"
-  end
-end
-
-class Gamefic::Entity
-  attr_writer :default_command
-  def default_command
-    @default_command || "examine #{definitely}"
-  end
-end
-
-class Gamefic::Character
-  def suggest command, text = nil
-    stream "<nav class=\"suggestions\"><p>#{Hypertext.link(command, text)}</p></nav>"
-  end
-end
-
-assert_action :clear_room_mode do |actor, action|
-  actor[:looking_at_room] = false
-  actor[:checking_inventory] = false
-  true
-end
-
-respond :look, Query::Room.new(Room) do |actor, room|
-  actor.tell "<strong>#{room.name.cap_first}</strong>"
-  actor.tell room.description
-  with_locales = []
-  chars = room.children.that_are(Character) - [actor]
-  charsum = []
-  chars.each { |char|
-    if char.locale_description != ""
-      with_locales.push char
-    else
-      if charsum.length == 0
-        charsum.push Hypertext.link char.default_command, char.indefinitely.cap_first
-      else
-        charsum.push Hypertext.link char.default_command, char.indefinitely
-      end
-    end
-  }
-  if charsum.length > 0
-    actor.tell "#{charsum.join_and} #{charsum.length == 1 ? 'is' : 'are'} here."
-  end
-  items = room.children.that_are(:itemized) - [actor] - room.children.that_are(Character)
-  itemsum = []
-  items.each { |item|
-    if item.locale_description != ""
-      with_locales.push item
-    else
-      itemsum.push Hypertext.link item.default_command, item.indefinitely
-    end
-  }
-  if itemsum.length > 0
-    actor.tell "You see #{itemsum.join_and}."
-  end
-  with_locales.each { |entity|
-    actor.tell entity.locale_description
-  }
-  if room.is? :explicit_with_exits
-    portals = room.children.that_are(Portal)
-    if portals.length > 0
-      if portals.length == 1
-        actor.tell "There is an exit #{Hypertext.link portals[0].default_command, portals[0].direction}."
-      else
-        dirs = []
-        portals.each { |p|
-          dirs.push Hypertext.link p.default_command, p.direction
-        }
-        actor.tell "There are exits #{dirs.join_and(', ')}."
-      end
-    end
-  end
-  if actor.is? :supported
-    actor.tell "You are on #{the actor.parent}."
-    actor.parent.children.that_are(:supported).that_are_not(actor).each { |s|
-      actor.tell "#{Hypertext.link s.default_command, s.indefinitely.cap_first} is on #{the actor.parent}."
-    }
-  end
-  actor[:looking_at_room] = true
-end
-
-respond :look, Query::Visible.new(Character) do |actor, character|
-  actor.proceed
-  actor.suggest "talk to #{the character}"
-end
-
-respond :look, Query::Visible.new do |actor, thing|
-  actor.proceed
-  if thing.is? :portable
-    if thing.parent == actor
-      actor.suggest "drop #{the thing}"
-    else
-      actor.suggest "take #{the thing}"    
-    end
-  end
-  objects = thing.children.that_are(:attached)
-  actor.stream '<nav class="objects">'
-  objects.each { |object|
-    actor.tell Hypertext.link "look #{object}", object
-  }
-  actor.stream '</nav>'
-end
-
-respond :look, Query::Visible.new(Container) do |actor, container|
-  actor.tell container.description
-  container.children.that_are(:attached).that_are(:itemized).each { |item|
-    actor.tell "#{An item} is attached to #{the container}."
-  }
-  if container.is? :openable
-    actor.tell "#{The container} is #{container.is?(:open) ? 'open' : 'closed'}."
-  end
-  if container.is? :open
-    contents = container.children.that_are(:contained)
-    if contents.length > 0
-      array = []
-      contents.each { |entity|
-        array.push Hypertext.link entity.default_command, entity.indefinitely
-      }
-      actor.tell "You see #{array.join_and} inside #{the container}."
-    end
-  end
-  if container.is?(:lockable) and container.is?(:locked)
-    actor.suggest "unlock #{the container}"
-  elsif container.is?(:openable) and container.is?(:closed)
-    actor.suggest "open #{the container}"
-  else
-    if container.is?(:openable) and container.is?(:open)
-      actor.suggest "close #{the container}"
-    end
-    if container.is?(:open)
-      actor.stream '<nav class="objects">'
-      objects = container.children.that_are(:itemized)
-      objects.each { |object|
-        actor.stream Hypertext.link "look #{object}", object
-      }
-      actor.stream '</nav>'
-    end
-  end
-  if container.is?(:enterable)
-    actor.suggest "enter #{the container}"
-  end
-end
-
-respond :look, Query::Children.new(Clothing) do |actor, clothing|
-  actor.proceed
-  if clothing.is?(:worn)
-    actor.suggest "remove #{the clothing}"
-  else
-    actor.suggest "wear #{the clothing}"
-  end
-end
-
-respond :open, Query::Visible.new(Container) do |actor, container|
-  actor.proceed
-  if container.is? :open
-    actor.perform :look, container
-  end
-end
-
-#respond :look, Query::Visible.new(Device) do |actor, device|
-#  actor.proceed
-#  if device.is? :on
-#    actor.suggest "turn on #{the device}"
-#  else
-#    actor.suggest "turn off #{the device}"
-#  end
-#end
-
-respond :inventory do |actor|
-  if actor.children.length > 0
-    carried = actor.children.that_are_not(:worn)
-    worn = actor.children.that_are(:worn)
-    if carried.length > 0
-      array = []
-      carried.each { |entity|
-        array << "#{Hypertext.link(entity.default_command, entity.indefinitely)}"
-      }
-      actor.tell "You are carrying #{array.join_and}."
-    end
-    if worn.length > 0
-      array = []
-      worn.each { |entity|
-        array << "#{Hypertext.link(entity.default_command, entity.indefinitely)}"
-      }
-      actor.tell "You are wearing #{array.join_and}."
-    end
-    actor.stream '<nav class="objects">'
-    actor.children.each { |object|
-      actor.tell Hypertext.link "look #{object}", object.definitely
-    }
-    actor.stream '</nav>'
-  else
-    actor.tell "You aren't carrying anything."
-  end
-  actor[:checking_inventory] = true
-end
-
-respond :go, Query::Reachable.new(Door, :locked) do |actor, door|
-  actor.proceed
-  if door.is? :locked
-    actor.suggest "unlock #{the door}"
-  end
-end
-
-respond :unlock, Query::Reachable.new(:lockable) do |actor, container|
-  actor.proceed
-  if container.is?(:closed)
-    actor.suggest "open #{the container}"
-  end
-end
-
-respond :take, Query::Reachable.new(Clothing) do |actor, clothing|
-  actor.proceed
-  if clothing.parent == actor
-    actor.suggest "wear #{the clothing}"
-  end
-end
-
-on_player_update do |actor|
-  if actor.scene.key != :active and actor.scene.kind_of?(Gamefic::ActiveScene) == false
-    next
-  end
-  if actor.parent != actor.room
-    if actor.parent.kind_of?(Container)
-      actor.suggest "exit", "leave #{the actor.parent}"
-    else
-      actor.suggest "exit", "get off #{the actor.parent}"
-    end
-  end
-  if actor[:looking_at_room] != true
-    actor.suggest "look around"
-  end
-  if actor[:checking_inventory] != true
-    actor.suggest "inventory"
-  end
-  entities = Query::Siblings.new.context_from(actor)
-  portals = entities.that_are(Portal)
-  if portals.length > 0
-    actor.stream '<nav class="portals">'
-    actor.stream "Exits: "
-    portals.each { |portal|
-      actor.stream Hypertext.link("go #{portal.direction}", "#{portal.direction}") + " "
-    }
-    actor.stream '</nav>'
-  end
-  if actor.room.is? :dark
-    next
-  end
-  characters = entities.that_are(Character) - [actor]
-  if characters.length > 0
-    actor.stream '<nav class="characters">'
-    actor.stream "Characters: "
-    characters.each { |entity|
-      actor.stream Hypertext.link("examine #{the entity}", "#{the entity}") + " "
-    }
-    actor.stream '</nav>'
-  end
-  objects = entities.that_are(:itemized) - characters - [actor] - portals
-  if objects.length > 0
-    actor.stream '<nav class="objects">'
-    actor.stream "Objects: "
-    objects.each { |entity|
-      actor.stream Hypertext.link(entity.default_command, "#{the entity}") + " "
-    }
-    actor.stream '</nav>'
-  end
-  extras = entities.that_are(:not_itemized) - characters - [actor] - portals
-  if extras.length > 0
-    actor.stream '<nav class="incidentals">'
-    actor.stream "Incidentals: "
-    extras.each { |entity|
-      actor.stream Hypertext.link("examine #{the entity}", "#{the entity}") + " "
-    }
-    actor.stream '</nav>'
-  end
-end