gamefic-sdk 1.0.0 → 1.0.1

data/scripts/media.plot.rb

@@ -0,0 +1,17 @@
+module Gamefic::Image
+  attr_accessor :image
+end
+
+class Gamefic::Entity
+  include Image
+end
+
+module Gamefic::ImageViewer
+  def show_image filename
+    tell "<figure><img src=\"media/#{filename}\" /></figure>"
+  end
+end
+
+class Gamefic::Character
+  include ImageViewer  
+end

data/scripts/multimedia.plot.rb

@@ -0,0 +1,41 @@
+class Gamefic::Entity
+  attr_accessor :image
+  def has_image?
+    (@image.to_s != '')
+  end
+end
+
+class Gamefic::Character
+  attr_writer :sees_image
+  def sees_image?
+    (@sees_image != false)
+  end
+  def show_image(filename)
+    stream "<img src=\"#{filename}\" />";
+    @sees_image = true
+  end
+  def play_sound(filename, loop = false)
+    # TODO: Implement
+  end
+  def play_ambient(filename, loop = false)
+    # TODO: Implement
+  end
+end
+
+assert_action :clear_last_image do |actor, action|
+  actor.sees_image = false
+  true
+end
+
+respond :look, Query::Visible.new() do |actor, subject|
+  actor.proceed
+  if subject.has_image?
+    actor.show_image subject.image
+  end
+end
+
+on_player_update do |actor|
+  if !actor.sees_image? and actor.room.has_image?
+    actor.show_image actor.room.image
+  end
+end

data/scripts/questions.plot.rb

@@ -0,0 +1,17 @@
+respond :what, Query::Text.new do |actor, question|
+  actor.tell "It looks like you're asking a question. Try giving a command instead. Use HELP for more information."
+end
+
+respond :what, Query::Reachable.new do |actor, thing|
+  actor.tell "It looks like you want information about #{the thing}. Try looking at it."
+end
+
+xlate "where :question", "what :question"
+xlate "when :question", "what :question"
+xlate "why :question", "what :question"
+xlate "who :question", "what :question"
+
+xlate "what is :thing", "look :thing"
+xlate "what's :thing", "look :thing"
+xlate "who is :thing", "look :thing"
+xlate "who's :thing", "look :thing"

data/scripts/room-modes.plot.rb

@@ -0,0 +1,48 @@
+module RoomModes
+  attr_writer :description_mode
+  def description_seen
+    @description_seen ||= Array.new
+  end
+  def description_seen=(value)
+    if value.kind_of?(Array)
+      @description_seen = value
+    else
+      raise "Character#description_seen must be an Array"
+    end
+  end
+  def description_mode
+    @description_mode ||= "verbose"
+  end
+end
+
+class Character
+  include RoomModes
+end
+
+respond :go, Query::Siblings.new(Portal) do |actor, portal|
+  actor.tell "You go #{portal.name}."
+  actor.parent = portal.destination
+  if actor.description_mode == "superbrief" or (actor.description_mode == "brief" and actor.description_seen.include?(actor.parent))
+    actor.tell actor.parent.name.cap_first
+  else
+    actor.perform "look"
+  end
+  if actor.description_seen.include?(actor.parent) == false
+    actor.description_seen.push actor.parent
+  end
+end
+
+meta :brief do |actor|
+  actor.description_mode = "brief"
+  actor.tell "You are now in BRIEF mode. Detailed descriptions of rooms will only be displayed the first time you visit them. Other options are SUPERBRIEF and VERBOSE."
+end
+
+meta :verbose do |actor|
+  actor.description_mode = "verbose"
+  actor.tell "You are now in VERBOSE mode. Detailed descriptions will be displayed every time you enter a room. Other options are BRIEF and SUPERBRIEF."
+end
+
+meta :superbrief do |actor|
+  actor.description_mode = "superbrief"
+  actor.tell "You are now in SUPERBRIEF mode. Detailed room descriptions will never be displayed unless you LOOK AROUND. Other options are BRIEF and VERBOSE."
+end

data/scripts/rough-sizes.plot.rb

@@ -0,0 +1,36 @@
+module Roughly
+  XSMALL = 1
+  SMALL = 2
+  MEDIUM = 3
+  LARGE = 4
+  XLARGE = 5
+end
+
+class Entity
+  attr_writer :size
+  def size
+    @size ||= (is?(:portable) ? Roughly::SMALL : Roughly::MEDIUM)
+  end
+end
+
+class Room
+  def size
+    @size ||= Roughly::XLARGE
+  end
+end
+
+respond :drop_in, Query::Children.new(), Query::Reachable.new(Container) do |actor, thing, container|
+  if container.size <= thing.size
+    actor.tell "#{The thing} can't fit in #{the container}."
+  else
+    actor.proceed
+  end
+end
+
+respond :drop_on, Query::Children.new(), Query::Reachable.new(Supporter) do |actor, thing, supporter|
+  if supporter.size < thing.size
+    actor.tell "#{The supporter} can't accommodate #{the thing}."
+  else
+    actor.proceed
+  end
+end

data/scripts/save-restore.plot.rb

@@ -0,0 +1,21 @@
+script 'snapshots'
+
+meta :save do |actor|
+  actor.perform :save, "game.sav"
+end
+
+meta :save, Query::Text.new() do |actor, filename|
+  actor.user.save filename, save
+end
+
+meta :restore do |actor|
+  actor.perform :restore, "game.sav"
+end
+
+meta :restore, Query::Text.new() do |actor, filename|
+  data = actor.user.restore(filename)
+  if !data.nil?
+    restore data
+    actor.tell "Game restored."
+  end
+end

data/scripts/snapshots.plot.rb

@@ -0,0 +1,14 @@
+module Snapshots
+  def self.history
+    @history ||= []
+  end
+end
+
+last_snapshot = nil
+
+on_player_ready do |actor|
+  if (actor.last_order.nil? or !actor.last_order.action.meta?) and !last_snapshot.nil?
+    Snapshots.history.push last_snapshot
+  end
+  last_snapshot = save
+end

data/scripts/standard.plot.rb

@@ -0,0 +1,12 @@
+# @gamefic.script standard
+# A general-purpose library that provides common actions and entities for
+# interactive fiction. Designed to be suitable for parser-based text
+# adventures, but easily extensible for other formats.
+
+script 'standard/use'
+script 'standard/modules'
+script 'standard/entities'
+script 'standard/queries'
+script 'standard/actions'
+script 'standard/rules'
+script 'standard/pathfinder'

data/scripts/standard/actions.plot.rb

@@ -0,0 +1,23 @@
+script 'standard/actions/close'
+script 'standard/actions/drop'
+script 'standard/actions/enter'
+script 'standard/actions/give'
+script 'standard/actions/go'
+script 'standard/actions/insert'
+script 'standard/actions/inventory'
+script 'standard/actions/leave'
+script 'standard/actions/lock'
+script 'standard/actions/look-under'
+script 'standard/actions/look'
+script 'standard/actions/nil'
+script 'standard/actions/open'
+script 'standard/actions/place'
+script 'standard/actions/quit'
+script 'standard/actions/read'
+script 'standard/actions/search'
+script 'standard/actions/show'
+script 'standard/actions/take'
+script 'standard/actions/talk'
+script 'standard/actions/unlock'
+script 'standard/actions/use'
+script 'standard/actions/wait'

data/scripts/standard/actions/close.plot.rb

@@ -0,0 +1,16 @@
+respond :close, Query::Text.new() do |actor, string|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any \"#{string}\" here."
+end
+
+respond :close, Query::Reachable.new() do |actor, thing|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} close #{the thing}."
+end
+
+respond :close, Query::Reachable.new(Gamefic::Openable) do |actor, container|
+  if !container.open?
+    actor.tell "It's already closed."
+  else
+    actor.tell "#{you.pronoun.Subj} close #{the container}."
+    container.open = false
+  end
+end

data/scripts/standard/actions/drop.plot.rb

@@ -0,0 +1,11 @@
+respond :drop, Query::Visible.new() do |actor, thing|
+  actor.tell "#{you.contract you.pronoun.Subj + ' ' + you.verb.be} not carrying #{the thing}."
+end
+
+respond :drop, Query::Children.new() do |actor, thing|
+  thing.parent = actor.parent
+  actor.tell "#{you.pronoun.Subj} drop #{the thing}."
+end
+
+interpret "put down :thing", "drop :thing"
+interpret "put :thing down", "drop :thing"

data/scripts/standard/actions/enter.plot.rb

@@ -0,0 +1,31 @@
+respond :enter, Use.siblings(Enterable, :enterable?) do |actor, supporter|
+  actor.parent = supporter
+  actor.tell "#{you.pronoun.Subj} #{you.verb[supporter.enter_verb]} #{the supporter}."
+end
+
+respond :enter, Use.siblings(Enterable, Openable, :enterable?) do |actor, container|
+  if container.open?
+    actor.proceed
+  else
+    actor.tell "#{The container} is closed."
+  end
+end
+
+respond :enter, Use.siblings do |actor, thing|
+  actor.tell "#{The thing} #{you.contract "can not"} accommodate #{you.pronoun.obj}."
+end
+
+respond :enter, Use.parent do |actor, container|
+  actor.tell "#{you.contract(you.pronoun.subj + ' ' + you.verb.be).cap_first} already in #{the container}."
+end
+
+respond :enter, Use.parent(Supporter) do |actor, supporter|
+  actor.tell "#{you.pronoun.Subj} #{you.verb[supporter.enter_verb]} #{the supporter} already."
+end
+
+respond :enter, Use.text do |actor, text|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any \"#{text}\" here."
+end
+
+interpret "get on :thing", "enter :thing"
+interpret "get in :thing", "enter :thing"

data/scripts/standard/actions/give.plot.rb

@@ -0,0 +1,26 @@
+respond :give, Query::Reachable.new(Character), Query::Reachable.new do |actor, character, gift|
+  if gift.parent != actor
+    actor.perform :take, gift
+  end
+  if gift.parent == actor
+    actor.perform :give, character, gift
+  end
+end
+
+respond :give, Query::Reachable.new, Query::Children.new do |actor, character, gift|
+  actor.tell "Nothing happens."
+end
+
+respond :give, Query::Reachable.new, Query::Reachable.new do |actor, character, gift|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} have #{the gift}."
+end
+
+respond :give, Query::Reachable.new(Character), Query::Children.new do |actor, character, gift|
+  actor.tell "#{The character} doesn't want #{the gift}."
+end
+
+respond :give, Query::Text.new, Query::Children.new do |actor, character, gift|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any \"#{character}\" here."
+end
+
+xlate "give :gift to :character", "give :character :gift"

data/scripts/standard/actions/go.plot.rb

@@ -0,0 +1,81 @@
+respond :go, Query::Reachable.new(Portal) do |actor, portal|
+  if actor.parent != actor.room
+    actor.perform :leave
+  end
+  if actor.parent == actor.room
+    if portal.destination.nil?
+      actor.tell "That portal leads nowhere."
+    else
+      actor.parent = portal.destination
+      if !portal.direction.nil?
+        actor.tell "#{you.pronoun.Subj} go #{portal.direction}"
+      end
+      actor.perform :look, actor.room
+    end
+  end
+end
+
+respond :go, Query::Reachable.new(Door, :locked?) do |actor, door|
+  actor.tell "#{The door} is locked."
+end
+
+respond :go, Query::Reachable.new(Door, :closed?) do |actor, door|
+  if door.automatic?
+    actor.perform :open, door
+    if door.open?
+      actor.proceed
+    end
+  else
+    actor.tell "#{The door} is closed."
+  end
+end
+
+respond :go, Query::Text.new() do |actor, string|
+  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any exit \"#{string}\" from here."
+end
+
+respond :go, Use.text do |actor, text|
+  # This version of the Go action identifies portals by their destinations.
+  portals = actor.room.children.that_are(Portal)
+  destinations = []
+  d_map = {}
+  portals.each { |portal|
+    next if portal.destination.nil?
+    destinations.push portal.destination
+    d_map[portal.destination] = portal
+  }
+  matches = Query::Base.new.execute(destinations, text)
+  if matches.objects.length == 1
+    actor.perform :go, d_map[matches.objects[0]]
+  else
+    actor.proceed
+  end
+end
+
+respond :go do |actor|
+  actor.tell "Where do you want to go?"
+end
+
+xlate "north", "go north"
+xlate "south", "go south"
+xlate "west", "go west"
+xlate "east", "go east"
+xlate "up", "go up"
+xlate "down", "go down"
+xlate "northwest", "go northwest"
+xlate "northeast", "go northeast"
+xlate "southwest", "go southwest"
+xlate "southeast", "go southeast"
+
+xlate "n", "go north"
+xlate "s", "go south"
+xlate "w", "go west"
+xlate "e", "go east"
+xlate "u", "go up"
+xlate "d", "go down"
+xlate "nw", "go northwest"
+xlate "ne", "go northeast"
+xlate "sw", "go southwest"
+xlate "se", "go southeast"
+
+interpret "go to :place", "go :place"

data/scripts/standard/actions/insert.plot.rb

@@ -0,0 +1,47 @@
+script 'standard'
+
+respond :insert, Use.visible, Use.reachable do |actor, thing, target|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} put #{the thing} inside #{the target}."
+end
+
+respond :insert, Use.visible, Use.reachable(Receptacle) do |actor, thing, receptacle|
+  if actor.auto_takes?(thing)
+    actor.tell "#{you.pronoun.Subj} put #{the thing} in #{the receptacle}."
+    thing.parent = receptacle
+  end
+end
+
+respond :insert, Use.visible, Use.reachable(Container) do |actor, thing, container|
+  if container.open?
+    actor.proceed
+  else
+    actor.tell "#{The container} is closed."
+  end
+end
+
+respond :insert, Use.visible, Use.text do |actor, thing, container|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see anything called \"#{container}\" here."
+end
+
+respond :insert, Use.text, Use.visible do |actor, thing, container|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see anything called \"#{thing}\" here."
+end
+
+respond :insert, Use.text, Use.text do |actor, thing, container|
+  actor.tell "I don't know what you mean by \"#{thing}\" or \"#{container}.\""
+end
+
+interpret "drop :item in :container", "insert :item :container"
+interpret "put :item in :container", "insert :item :container"
+interpret "place :item in :container", "insert :item :container"
+interpret "insert :item in :container", "insert :item :container"
+
+interpret "drop :item inside :container", "insert :item :container"
+interpret "put :item inside :container", "insert :item :container"
+interpret "place :item inside :container", "insert :item :container"
+interpret "insert :item inside :container", "insert :item :container"
+
+interpret "drop :item into :container", "insert :item :container"
+interpret "put :item into :container", "insert :item :container"
+interpret "place :item into :container", "insert :item :container"
+interpret "insert :item into :container", "insert :item :container"