gamefic-sdk 1.6.0 → 1.7.0

data/scripts/media.plot.rb

@@ -1,17 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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
-  actor.tell "Game saved."
-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/standard/actions/close.plot.rb

@@ -1,16 +0,0 @@
-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, Use.reachable() do |actor, thing|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} close #{the thing}."
-end
-
-respond :close, Use.reachable(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/lock.plot.rb

@@ -1,59 +0,0 @@
-respond :lock, Query::Text.new() do |actor, string|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any \"#{string}\" here."
-end
-
-respond :lock, Use.family() do |actor, thing|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} lock #{the thing}."
-end
-
-respond :lock, Use.family(Lockable, :has_lock_key?) do |actor, container|
-  # Portable containers need to be picked up before they are locked.
-  if container.portable? and container.parent != actor
-    actor.perform :take, container
-    if container.parent != actor
-      break
-    end
-  end
-  if container.locked?
-    actor.tell "It's already locked."
-  else
-    #if container.is?(:auto_lockable)
-      key = nil
-      if container.lock_key.nil? == false
-        if container.lock_key.parent == actor
-          key = container.lock_key
-        end
-      end
-      if key.nil?
-        actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} have any way to lock #{the container}."
-      else
-        actor.tell "#{you.pronoun.Subj} #{you.verb.lock} #{the container} with #{the key}."
-        container.locked = true
-      end
-    #else
-    #  actor.tell "What do you want to lock #{the container} with?"
-    #end
-  end
-end
-
-respond :lock, Use.family(Lockable, :has_lock_key?), Query::Children.new do |actor, container, key|
-  if container.locked == false
-    if container.lock_key == key
-      #if container.is?(:not_auto_lockable)
-      #  container.is :auto_lockable
-      #  actor.perform :lock, container
-      #  container.is :not_auto_lockable
-      #else
-      #  actor.perform :lock, container
-      #end
-      actor.tell "#{you.pronoun.Subj} #{you.verb.lock} #{the container} with #{the key}."
-      container.locked = true
-    else
-      actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} lock #{the container} with #{the key}."
-    end
-  else
-    actor.tell "It's already locked."
-  end
-end
-
-xlate "lock :container with :key", "lock :container :key"

data/scripts/standard/actions/look-under.plot.rb

@@ -1,8 +0,0 @@
-script 'standard/actions/look'
-
-respond :look_under, Use.family() do |actor, thing|
-  actor.tell "There's nothing to see under #{the thing}."
-end
-
-interpret "look beneath :thing", "look under :thing"
-interpret "look below :thing", "look under :thing"

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

@@ -1,34 +0,0 @@
-respond :open, Use.text do |actor, string|
-  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.do + ' not')} see any \"#{string}\" here."
-end
-
-respond :open, Use.reachable() do |actor, thing|
-  actor.tell "#{you.pronoun.Subj} #{you.contract(you.verb.can + ' not')} open #{the thing}."
-end
-
-respond :open, Use.reachable(Openable) do |actor, container|
-  # Portable containers need to be picked up before they are opened.
-  if container.portable? and container.parent != actor
-    actor.perform :take, container
-    if container.parent != actor
-      break
-    end
-  end
-  if !container.open?
-    actor.tell "#{you.pronoun.Subj} #{you.verb['open']} #{the container}."
-    container.open = true
-    if container.children.that_are_not(:attached?).length > 0
-      actor.perform :search, container
-    end
-  else
-    actor.tell "It's already open."
-  end
-end
-
-respond :open, Use.reachable(Openable, Lockable) do |actor, container|
-  if container.locked?
-    actor.tell "#{The container} is locked."
-  else
-    actor.proceed
-  end
-end

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

@@ -1,3 +0,0 @@
-respond :read, Use.family do |actor, thing|
-  actor.perform :look, thing
-end

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

@@ -1,40 +0,0 @@
-respond :search, Use.reachable(Receptacle) do |actor, receptacle|
-  # TODO Show the contents of the receptacle
-  contents = receptacle.children.that_are_not(:attached?)
-  if contents.length > 0
-    actor.tell "Inside #{contents.length > 1 ? 'are' : 'is'} #{contents.join_and}."
-  else
-    actor.tell "#{The receptacle} #{receptacle.verb.be} empty."
-  end
-end
-
-respond :search, Use.reachable(Container) do |actor, container|
-  next unless container.kind_of?(Container)
-  if container.open? or container.transparent?
-    actor.proceed
-  else
-    actor.tell "#{The container} #{container.verb.be} closed."
-  end
-end
-
-respond :search, Use.reachable do |actor, thing|
-  actor.perform :look, thing
-end
-
-respond :search, Use.room do |actor, room|
-  actor.perform :look, room
-end
-
-respond :search, Use.reachable do |actor, entity|
-  attached = entity.children.that_are(:attached?).that_are(Container)
-  if attached.length > 1
-    actor.tell "#{you.pronoun.Subj} #{you.verb.can} search #{attached.join_or}"
-  elsif attached.length == 1
-    actor.perform :search, attached[0]
-  else
-    actor.proceed
-  end
-end
-
-interpret "look in :thing", "search :thing"
-interpret "look inside :thing", "search :thing"

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

@@ -1,13 +0,0 @@
-respond :show, Use.reachable(Character), Use.children do |actor, character, thing|
-  actor.tell "#{The character} isn't interested in #{the thing}."
-end
-
-respond :show, Use.reachable, Use.children do |actor, witness, thing|
-  actor.tell "Nothing happens."
-end
-
-respond :show, Use.children, Use.text do |actor, thing, text|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any \"#{text}\" here."
-end
-
-interpret "show :thing to :character", "show :character :thing"

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

@@ -1,77 +0,0 @@
-respond :unlock, Query::Text.new() do |actor, string|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any \"#{string}\" here."
-end
-
-respond :unlock, Use.family() do |actor, thing|
-  actor.tell "#{you.pronoun.Subj} can't unlock #{the thing}."
-end
-
-respond :unlock, Use.family(Lockable) do |actor, container|
-  # Portable containers need to be picked up before they are unlocked.
-  if container.portable? and container.parent != actor
-    actor.perform :take, container
-    if container.parent != actor
-      break
-    end
-  end
-  if container.locked? == false
-    actor.tell "#{The container} isn't locked."
-  else
-    #if container.is?(:auto_lockable)
-      key = nil
-      if container.lock_key.nil? == false
-        if container.lock_key.parent == actor
-          key = container.lock_key
-        end
-      end
-      if key.nil?
-        actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} have any way to unlock #{the container}."
-      else
-        actor.tell "#{you.pronoun.Subj} #{you.verb.unlock} #{the container} with #{the key}."
-        container.locked = false
-      end
-    #takeelse
-    #  actor.tell "What do you want to unlock #{the container} with?"
-    #end
-  end
-end
-
-respond :unlock, Use.family(Lockable), Query::Text.new do |actor, container, thing|
-  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} have anything called '#{thing}.'"
-end
-
-respond :unlock, Use.family(Lockable, :has_lock_key?), Query::Children.new do |actor, container, key|
-  if container.is?(:locked)
-    if container.key == key
-      #if container.is?(:not_auto_lockable)
-      #  container.is :auto_lockable
-      #  actor.perform :unlock, container
-      #  container.is :not_auto_lockable
-      #else
-        actor.perform :unlock, container
-      #end
-    else
-      actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.can + ' not'} unlock #{the container} with #{the key}."
-    end
-  else
-    actor.tell "#{The container} isn't locked."
-  end
-end
-
-respond :open, Use.family(Lockable, :has_lock_key?), Query::Children.new do |actor, container, key|
-  if container.is?(:locked)
-    actor.perform :unlock, container, key
-    if !container.is?(:locked)
-      actor.perform :open, container
-    end
-  else
-    actor.perform :open, container
-  end
-end
-
-respond :use, Query::Children.new, Use.family(Lockable, :has_lock_key?) do |actor, key, container|
-  actor.perform :unlock, container, key
-end
-
-xlate "unlock :container with :key", "unlock :container :key"
-xlate "open :container with :key", "open :container :key"