gamefic-sdk 1.0.0 → 1.0.1

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

@@ -0,0 +1,31 @@
+respond :talk do |actor|
+  actor.tell "#{you.pronoun.Subj} #{you.verb.talk} to #{you.pronoun.reflex}."
+end
+
+respond :talk, Query::Self.new do |actor, yourself|
+  actor.perform :talk
+end
+
+respond :talk, Query::Reachable.new do |actor, thing|
+  actor.tell "Nothing happens."
+end
+
+respond :talk, Query::Reachable.new(Character) do |actor, character|
+  if actor == character
+    actor.perform :talk
+  else
+    actor.tell "#{The character} has nothing to say."
+  end
+end
+
+respond :talk, Query::Reachable.new(Character), Query::Text.new do |actor, character, text|
+  actor.perform :talk, character
+end
+
+xlate "talk to :character", "talk :character"
+xlate "talk to :character about :subject", "talk :character :subject"
+xlate "ask :character :subject", "talk :character :subject"
+xlate "ask :character about :subject", "talk :character :subject"
+xlate "tell :character :subject", "talk :character :subject"
+xlate "tell :character about :subject", "talk :character :subject"
+xlate "ask :character for :subject", "talk :character :subject"

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

@@ -0,0 +1,77 @@
+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, Query::Reachable.new() do |actor, thing|
+  actor.tell "#{you.pronoun.Subj} can't unlock #{the thing}."
+end
+
+respond :unlock, Query::Reachable.new(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, Query::Reachable.new(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, Query::Reachable.new(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, Query::Reachable.new(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, Query::Reachable.new(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"

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

@@ -0,0 +1,25 @@
+respond :use, Query::Reachable.new do |actor, tool|
+  actor.tell "I don't know how to use #{the tool}. (A more specific command might work.)"
+end
+
+respond :use, Gamefic::Query::Text.new do |actor, thing|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any '#{thing}' #{you.pronoun.subj} can use here."
+end
+
+respond :use, Query::Reachable.new, Query::Reachable.new do |actor, tool, object|
+  actor.tell "#{you.contract you.pronoun.Subj + ' ' + you.verb.be} not carrying the #{tool}."
+end
+
+respond :use, Gamefic::Query::Children.new, Gamefic::Query::Text.new do |actor, tool, object|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} see any '#{object}' here."
+end
+
+respond :use, Query::Text.new, Query::Reachable.new do |actor, tool, object|
+  actor.tell "#{you.pronoun.Subj} #{you.contract you.verb.do + ' not'} have anything called '#{tool}.'"
+end
+
+respond :use, Query::Children.new, Query::Reachable.new do |actor, tool, object|
+  actor.tell "I don't know how to use #{the tool} on #{the object}. (A more specific command might work.)"
+end
+
+xlate "use :tool on :object", "use :tool :object"

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

@@ -0,0 +1,3 @@
+respond :wait do |actor|
+  actor.tell "Time passes."
+end

data/scripts/standard/entities.plot.rb

@@ -0,0 +1,12 @@
+script 'standard/entities/entity'
+script 'standard/entities/character'
+script 'standard/entities/container'
+script 'standard/entities/door'
+script 'standard/entities/fixture'
+script 'standard/entities/item'
+script 'standard/entities/portal'
+script 'standard/entities/receptacle'
+script 'standard/entities/room'
+script 'standard/entities/scenery'
+script 'standard/entities/rubble'
+script 'standard/entities/supporter'

data/scripts/standard/entities/character.plot.rb

@@ -0,0 +1,9 @@
+class Gamefic::Character
+  include ParentRoom
+  include Attachable
+  include Itemizable
+  include AutoTakes
+  
+  serialize :attached?, :itemized?
+  
+end

data/scripts/standard/entities/container.plot.rb

@@ -0,0 +1,11 @@
+script 'standard/entities/receptacle'
+
+class Gamefic::Container < Gamefic::Receptacle
+  include Enterable
+  include Openable
+  include Lockable
+  include Transparent
+  
+  serialize :enterable?, :open?, :locked?, :lock_key, :transparent?
+  
+end

data/scripts/standard/entities/door.plot.rb

@@ -0,0 +1,53 @@
+script 'standard/entities/portal'
+
+class Gamefic::Door < Gamefic::Portal
+  include Openable
+  include Lockable
+  
+  serialize :open?, :locked?, :lock_key, :automatic?
+  
+  def post_initialize
+    super
+    if @name.nil? and !@direction.nil?
+      proper_named = false
+      rev = @direction.reverse
+      self.name = "the #{@direction.adjective} door"
+    end
+  end
+  def open=(bool)
+    super
+    rev = find_reverse
+    if !rev.nil? and rev.open? != bool
+      rev.open = bool
+    end
+  end
+  def locked=(bool)
+    super
+    rev = find_reverse
+    if !rev.nil? and rev.locked? != bool
+      rev.locked = bool
+    end
+  end
+  def automatic=(bool)
+    @automatic = bool
+    rev = find_reverse
+    if !rev.nil? and rev.automatic? != bool
+      rev.automatic = bool
+    end
+  end
+  # HACK Even though Door includes Lockable, we need
+  # to add the lock_key definitions here for Opal.
+  def lock_key
+    @lock_key
+  end
+  def lock_key=(entity)
+    @lock_key = entity
+    rev = find_reverse
+    if !rev.nil? and rev.lock_key != entity
+      rev.lock_key = entity
+    end
+  end
+  def automatic?
+    @automatic ||= true
+  end
+end

data/scripts/standard/entities/entity.plot.rb

@@ -0,0 +1,13 @@
+class Gamefic::Entity
+  include Portable
+  include Itemizable
+  include ParentRoom
+  include Attachable
+
+  attr_writer :locale_description
+  serialize :locale_description, :portable?, :itemized?, :attached?
+  
+  def locale_description
+    @locale_description ||= ""
+  end
+end

data/scripts/standard/entities/exterior.plot.rb

@@ -0,0 +1,5 @@
+script 'standard/entities/room'
+
+class Gamefic::Exterior < Gamefic::Room
+  
+end

data/scripts/standard/entities/fixture.plot.rb

@@ -0,0 +1,3 @@
+class Gamefic::Fixture < Gamefic::Entity
+
+end

data/scripts/standard/entities/item.plot.rb

@@ -0,0 +1,5 @@
+class Gamefic::Item < Gamefic::Entity
+  def pre_initialize
+    self.portable = true
+  end
+end

data/scripts/standard/entities/portal.plot.rb

@@ -0,0 +1,37 @@
+class Gamefic::Portal < Gamefic::Entity
+  attr_accessor :destination, :direction
+  serialize :destination, :direction
+
+  # Find the portal in the destination that returns to this portal's parent
+  #
+  # @return [Room]
+  def find_reverse
+    return nil if destination.nil?
+    rev = direction.reverse
+    if rev != nil
+      destination.children.that_are(Portal).each { |c|
+        if c.direction == rev
+          return c
+        end
+      }
+    end
+    nil
+  end
+  
+  # Get the ordinal direction of this Portal
+  # Portals have distinct direction and name properties so games can display a
+  # bare compass direction for exits, e.g., "south" vs. "the southern door."
+  #
+  # @return [Direction]
+  def direction
+    @direction
+  end
+  
+  def name
+    @name || direction.name
+  end
+  
+  def synonyms
+    "#{super} #{@direction} #{!direction.nil? ? direction.synonyms : ''}"
+  end
+end

data/scripts/standard/entities/receptacle.plot.rb

@@ -0,0 +1,4 @@
+class Gamefic::Receptacle < Gamefic::Entity
+  include Enterable
+  serialize :enterable?, :enter_verb, :leave_verb, :inside_verb
+end

data/scripts/standard/entities/room.plot.rb

@@ -0,0 +1,47 @@
+class Gamefic::Room < Gamefic::Entity
+  include Darkenable
+  include ExplicitExits
+  
+  serialize :dark?, :explicit_exits?
+  
+  def connect(destination, direction = nil, type = Portal, two_way = true)
+    if direction.nil?
+      portal = type.new self.plot, :parent => self, :destination => destination, :name => destination.definitely
+      if two_way == true
+        portal2 = type.new self.plot, :parent => destination, :destination => self, :name => self.definitely
+      end
+    else
+      if direction.kind_of?(String)
+        direction = Direction.find(direction)
+      end
+      portal = type.new self.plot, :direction => direction, :parent => self, :destination => destination
+      portal.proper_named = true if type == Portal
+      if two_way == true
+        reverse = direction.reverse
+        if reverse == nil
+          raise "#{direction.name.cap_first} does not have an opposite direction"
+        end
+        portal2 = type.new(self.plot, {
+          :direction => reverse,
+          :parent => destination,
+          :destination => self
+        })
+        portal2.proper_named = true if type == Portal
+      end
+    end
+    portal
+  end
+  def synonyms
+    @synonyms.to_s + " around here room"
+  end
+  def tell(message)
+    children.each { |c|
+      c.tell message
+    }
+  end
+  def find_portal(direction)
+    d = direction.to_s
+    portals = children.that_are(Portal).delete_if { |p| p.direction.to_s != d }
+    portals[0]
+  end
+end

data/scripts/standard/entities/rubble.plot.rb

@@ -0,0 +1,11 @@
+script 'standard/entities/scenery'
+
+# Rubble is Scenery with slightly modified action responses.
+# Intended for things that might be portable but are useless.
+# Rule of thumb: Scenery is something that can't be carried,
+# like a table or the sky; and Rubble is something that might
+# be portable but is otherwise useless, like trash or debris.
+
+class Gamefic::Rubble < Gamefic::Scenery
+  
+end

data/scripts/standard/entities/scenery.plot.rb

@@ -0,0 +1,5 @@
+class Gamefic::Scenery < Gamefic::Entity
+  def pre_initialize
+    self.itemized = false
+  end
+end

data/scripts/standard/entities/supporter.plot.rb

@@ -0,0 +1,10 @@
+class Gamefic::Supporter < Gamefic::Entity
+  include Enterable
+  serialize :enterable?
+  def initialize(plot, args = {})
+    self.enter_verb = "get on"
+    self.leave_verb = "get off"
+    self.inside_verb = "be on"
+    super
+  end
+end

data/scripts/standard/modules.plot.rb

@@ -0,0 +1,11 @@
+script 'standard/modules/attachable'
+script 'standard/modules/auto_takes'
+script 'standard/modules/darkenable'
+script 'standard/modules/enterable'
+script 'standard/modules/explicit_exits'
+script 'standard/modules/itemizable'
+script 'standard/modules/lockable'
+script 'standard/modules/openable'
+script 'standard/modules/parent-room'
+script 'standard/modules/portable'
+script 'standard/modules/transparent'

data/scripts/standard/modules/attachable.plot.rb

@@ -0,0 +1,11 @@
+module Gamefic::Attachable
+  def attached?
+    if @attached.nil?
+      @attached = false
+    end
+    @attached
+  end
+  def attached=(bool)
+    @attached = bool
+  end
+end

data/scripts/standard/modules/auto_takes.plot.rb

@@ -0,0 +1,50 @@
+module Gamefic::AutoTakes
+  def auto_takes?(entity)
+    return true if entity.parent == self
+    if AutoTakes.enabled?
+      if AutoTakes.taking_message.to_s != ""
+        self.tell (AutoTakes.taking_message % {:name => entity.definitely, :Name => entity.definitely.cap_first})
+      end
+      buff = self.quietly :take, entity
+      if entity.parent != self
+        self.tell buff
+        false
+      else
+        if AutoTakes.taken_message.to_s != ""
+          self.tell (AutoTakes.taken_message % {:name => entity.definitely, :Name => entity.definitely.cap_first})
+        end
+        true
+      end
+    else
+      self.tell (AutoTakes.untaken_message % {:name => entity.definitely, :Name => entity.definitely.cap_first})
+      false
+    end
+  end
+  def self.enabled?
+    if @enabled.nil?
+      @enabled = true
+    end
+    @enabled
+  end
+  def self.enabled=(bool)
+    @enabled = bool
+  end
+  def self.taking_message
+    @taking_message ||= ""
+  end
+  def self.taking_message=(text)
+    @taking_message = text
+  end
+  def self.taken_message
+    @taken_message ||= ""
+  end
+  def self.taken_message=(text)
+    @taken_message = text
+  end
+  def self.untaken_message
+    @untaken_message ||= "You don't have %{name}."
+  end
+  def self.untaken_message=(text)
+    @untaken_message = text
+  end
+end