gamefic-standard 2.0.0

data/lib/gamefic-standard/entities.rb

@@ -0,0 +1,10 @@
+require 'gamefic-standard/entities/thing'
+require 'gamefic-standard/entities/character'
+require 'gamefic-standard/entities/fixture'
+require 'gamefic-standard/entities/item'
+require 'gamefic-standard/entities/portal'
+require 'gamefic-standard/entities/receptacle'
+require 'gamefic-standard/entities/room'
+require 'gamefic-standard/entities/scenery'
+require 'gamefic-standard/entities/rubble'
+require 'gamefic-standard/entities/supporter'

data/lib/gamefic-standard/entities/character.rb

@@ -0,0 +1,11 @@
+class Character < Thing
+  include Gamefic::Active
+
+  def gender
+    @gender ||= :other
+  end
+end
+
+Gamefic.script do
+  player_class Character
+end

data/lib/gamefic-standard/entities/fixture.rb

@@ -0,0 +1,3 @@
+class Fixture < Thing
+
+end

data/lib/gamefic-standard/entities/item.rb

@@ -0,0 +1,5 @@
+# An entity that is portable by default.
+#
+class Item < Thing
+  set_default portable: true
+end

data/lib/gamefic-standard/entities/portal.rb

@@ -0,0 +1,44 @@
+class Portal < Thing
+  attr_accessor :destination
+
+  # 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 direction= d
+    @direction = Direction.find(d)
+  end
+
+  def name
+    @name || (direction.nil? ? destination.name : direction.name)
+  end
+
+  def instruction
+    direction || (destination ? "to #{destination.definitely}" : name)
+  end
+
+  def synonyms
+    "#{super} #{@destination} #{@direction} #{!direction.nil? ? direction.synonyms : ''}"
+  end
+end

data/lib/gamefic-standard/entities/receptacle.rb

@@ -0,0 +1,3 @@
+class Receptacle < Thing
+  include Enterable
+end

data/lib/gamefic-standard/entities/room.rb

@@ -0,0 +1,79 @@
+class Room < Thing
+  attr_writer :explicit_exits
+
+  set_default explicit_exits: true
+
+  def explicit_exits?
+    @explicit_exits
+  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
+
+  class << self
+    def explicit_exits?
+      default_attributes[:explicit_exits]
+    end
+
+    def explicit_exits=(bool)
+      set_default explicit_exits: bool
+    end
+  end
+end
+
+# @todo Monkey patching might not be the best way to handle this. It's only
+#   necessary because of specs that make Plot#connect calls. Consider
+#   changing the specs instead.
+module Gamefic::World
+  # Create portals between rooms.
+  #
+  # @return [Portal]
+  def connect origin, destination, direction = nil, type: Portal, two_way: true
+    if direction.nil?
+      portal = make type, :parent => origin, :destination => destination
+      if two_way == true
+        portal2 = make type, :parent => destination, :destination => origin
+      end
+    else
+      if direction.kind_of?(String)
+        direction = Direction.find(direction)
+      end
+      portal = make type, :direction => direction, :parent => origin, :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 = make type, :direction => reverse, :parent => destination, :destination => origin
+        portal2.proper_named = true if type == Portal
+      end
+    end
+    portal
+  end
+end
+
+Room.module_exec self do |plot|
+  # Define the connect method dynamically so the plot is available
+  define_method :connect do |destination, direction = nil, type: Portal, two_way: true|
+    plot.connect self, destination, direction, type: Portal, two_way: true
+  end
+end
+class Room
+  # @!method connect destination, direction = nil, type: Portal, two_way: true
+  #   Create a portal to connect this room to a destination.
+  #   @return [Portal]
+end

data/lib/gamefic-standard/entities/rubble.rb

@@ -0,0 +1,11 @@
+# script 'standard/entities/scenery'
+require 'gamefic-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 Rubble < Scenery
+end

data/lib/gamefic-standard/entities/scenery.rb

@@ -0,0 +1,7 @@
+# Scenery is an entity that is not itemized by default. They're typically used
+# to provide a description for objects that can be observed but do not respond
+# to any other interactions.
+#
+class Scenery < Thing
+  set_default itemized: false
+end

data/lib/gamefic-standard/entities/supporter.rb

@@ -0,0 +1,7 @@
+class Supporter < Thing
+  include Enterable
+
+  set_default enter_verb: 'get on'
+  set_default leave_verb: 'get off'
+  set_default inside_verb: 'be on'
+end

data/lib/gamefic-standard/entities/thing.rb

@@ -0,0 +1,72 @@
+class Thing < Gamefic::Entity
+  include Grammar::Attributes
+
+  attr_writer :itemized
+
+  attr_writer :sticky
+
+  attr_writer :portable
+
+  # An optional description to use when itemizing entities in room
+  # descriptions. The locale_description will be used instead of adding
+  # the entity's name to a list.
+  #
+  attr_accessor :locale_description
+
+  # A message to be displayed in response to DROP actions when the entity is
+  # sticky.
+  #
+  attr_accessor :sticky_message
+
+  set_default itemized: true
+  set_default sticky: false
+  set_default portable: false
+
+  # Itemized entities are automatically listed in room descriptions.
+  #
+  # @return [Boolean]
+  def itemized?
+    @itemized
+  end
+
+  # Sticky entities cannot be dropped with DROP actions
+  #
+  # @return [Boolean]
+  def sticky?
+    @sticky
+  end
+
+  # Portable entities can be taken with TAKE actions.
+  #
+  # @return [Boolean]
+  def portable?
+    @portable
+  end
+
+  # @return [Boolean]
+  def attached?
+    @attached ||= false
+  end
+
+  # @param [Boolean]
+  def attached= bool
+    bool = false if parent.nil?
+    @attached = bool
+  end
+
+  def parent= p
+    self.attached = false unless p == parent
+    super
+  end
+
+  # The entity's parent room (i.e., the closest ascendant that is a Room).
+  #
+  # @return [Room]
+  def room
+    p = parent
+    until p.is_a?(Room) or p.nil?
+      p = p.parent
+    end
+    p
+  end
+end

data/lib/gamefic-standard/give.rb

@@ -0,0 +1,27 @@
+# @gamefic.script standard/give
+
+respond :give, Use.available, Gamefic::Query::Children.new do |actor, _character, gift|
+  actor.tell "Nothing happens."
+end
+
+respond :give, Use.available(Character), Use.available do |actor, character, gift|
+  if gift.sticky?
+    actor.tell gift.sticky_message || "You need to keep #{the gift} for now."
+  else
+    actor.tell "#{The character} doesn't want #{the gift}."
+  end
+end
+
+respond :give, Use.available(Character), Use.available do |actor, _character, gift|
+  if gift.parent == actor
+    actor.proceed
+  else
+    actor.tell "You don't have #{the gift}."
+  end
+end
+
+respond :give, Use.text, Use.available do |actor, character, _gift|
+  actor.tell "You don't see any \"#{character}\" here."
+end
+
+interpret "give :gift to :character", "give :character :gift"

data/lib/gamefic-standard/grammar.rb

@@ -0,0 +1,2 @@
+require 'gamefic-standard/grammar/attributes'
+require 'gamefic-standard/grammar/pronoun'

data/lib/gamefic-standard/grammar/attributes.rb

@@ -0,0 +1,37 @@
+module Grammar
+  # A collection of attributes that enable grammar features for entities, such
+  # as selecting their correct pronouns.
+  #
+  module Attributes
+    # @see #gender
+    attr_writer :gender
+
+    # @see #plural?
+    attr_writer :plural
+
+    # The gender of the object. Supported values are :male, :female, :neutral,
+    # and :other. Use :neutral for objects that don't have a gender (i.e.,
+    # "it"). Use :other for people or characters that have an unspecified or
+    # non-binary gender (i.e., "they").
+    #
+    # @return [Symbol]
+    def gender
+      @gender ||= :neutral
+    end
+
+    # True if the object should be referred to in the plural, e.g., "they"
+    # instead of "it."
+    # @return [Boolean]
+    #
+    def plural?
+      @plural ||= false
+    end
+
+    # For now, the object's person is always assumed to be third
+    # (he/she/it/they). A future version of this library might support first
+    # (I/me) and second (you).
+    def person
+      3
+    end
+  end
+end

data/lib/gamefic-standard/grammar/pronoun.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Grammar
+  # Functions to select pronouns based on an entity's attributes, such as
+  # gender.
+  #
+  module Pronoun
+    class << self
+      # @param entity [#person, #plural?, #gender]
+      # @return [String]
+      def subjective(entity)
+        map(entity)[:subjective]
+      end
+      alias they subjective
+      alias he subjective
+      alias she subjective
+
+      # @param entity [#person, #plural?, #gender]
+      # @return [String]
+      def subjective_(entity)
+        subjective(entity).cap_first
+      end
+      alias they_ subjective_
+      alias he_ subjective_
+      alias she_ subjective_
+
+      # @param entity [#person, #plural?, #gender]
+      # @return [String]
+      def objective(entity)
+        map(entity)[:objective]
+      end
+      alias them objective
+
+      # @param entity [#person, #plural?, #gender]
+      # @return [String]
+      def objective_(entity)
+        objective(entity).cap_first
+      end
+      alias them_ objective_
+
+      # @param entity [#person, #plural?, #gender]
+      # @return [String]
+      def possessive(entity)
+        map(entity)[:possessive]
+      end
+      alias their possessive
+
+      # @param entity [#person, #plural?, #gender]
+      # @return [String]
+      def possessive_(entity)
+        possessive(entity).cap_first
+      end
+      alias their_ possessive_
+
+      # @param entity [#person, #plural?, #gender]
+      # @return [String]
+      def reflexive(entity)
+        map(entity)[:reflexive]
+      end
+      alias themselves reflexive
+      alias themself reflexive
+
+      # @param entity [#person, #plural?, #gender]
+      # @return [String]
+      def reflexive_(entity)
+        reflexive(entity).cap_first
+      end
+      alias themselves_ reflexive_
+      alias themself_ reflexive_
+
+      # @param entity [#person, #plural?, #gender]
+      # @return [Hash]
+      def map(entity)
+        plurality = (entity.plural? ? :plural : :singular)
+        maps[[(entity.person || 3), plurality, entity.gender]] ||
+          maps[[(entity.person || 3), plurality]]
+      end
+
+      private
+
+      def maps
+        @maps ||= {
+          [1, :singular] => Hash[map_keys.zip(%w[I me my myself])],
+          [2, :singular] => Hash[map_keys.zip(%w[you you your yourself])],
+          [3, :singular] => Hash[map_keys.zip(%w[it it its itself])],
+          [3, :singular, :male] => Hash[map_keys.zip(%w[he him his himself])],
+          [3, :singular, :female] => Hash[map_keys.zip(%w[she her her herself])],
+          [3, :singular, :other] => Hash[map_keys.zip(%w[they them their themselves])],
+          [3, :singular, :neutral] => Hash[map_keys.zip(%w[it it its itself])],
+          [1, :plural] => Hash[map_keys.zip(%w[we us our ourselves])],
+          [2, :plural] => Hash[map_keys.zip(%w[you you your yourselves])],
+          [3, :plural] => Hash[map_keys.zip(%w[they them their themselves])]
+        }
+      end
+
+      def map_keys
+        @map_keys ||= %i[subjective objective possessive reflexive]
+      end
+    end
+  end
+end

data/lib/gamefic-standard/lockable.rb

@@ -0,0 +1,93 @@
+# @gamefic.script standard/lockable
+
+require 'gamefic-standard/openable'
+
+# A module for entities that are both openable and lockable.
+#
+module Lockable
+  include Openable
+
+  attr_accessor :lock_key
+
+  def locked=(bool)
+    @locked = bool
+    if @locked == true
+      self.open = false
+    end
+  end
+
+  def open=(bool)
+    @open = bool
+    @locked = false if @open == true
+  end
+
+  def locked?
+    @locked ||= false
+  end
+
+  def has_lock_key?
+    !@lock_key.nil?
+  end
+end
+
+Gamefic.script do
+  respond :lock, Use.available do |actor, thing|
+    actor.tell "You can't lock #{the thing}."
+  end
+
+  respond :_toggle_lock, Use.available(Lockable, :has_lock_key?) do |actor, thing|
+    verb = thing.locked? ? 'unlock' : 'lock'
+    key = nil
+    if thing.lock_key.parent == actor
+      key = thing.lock_key
+    end
+    if key.nil?
+      actor.tell "You don't have any way to #{verb} #{the thing}."
+    else
+      actor.tell "You #{verb} #{the thing} with #{the key}."
+      thing.locked = !thing.locked?
+    end
+  end
+
+  respond :lock, Use.available(Lockable, :has_lock_key?), Use.children do |actor, thing, key|
+    if thing.lock_key == key
+      actor.perform :_toggle_lock, thing
+    else
+      actor.tell "You can't unlock #{the thing} with #{the key}."
+    end
+  end
+
+  respond :lock, Use.available(Lockable, :has_lock_key?), Use.available do |actor, thing, key|
+    actor.perform :take, key if key.parent != actor
+    actor.proceed if key.parent == actor
+  end
+
+  respond :unlock, Use.available do |actor, thing|
+    actor.tell "You can't unlock #{the thing}."
+  end
+
+  respond :unlock, Use.available(Lockable, :has_lock_key?), Use.children do |actor, thing, key|
+    if thing.lock_key == key
+      actor.perform :_toggle_lock, thing
+    else
+      actor.tell "You can't unlock #{the thing} with #{the key}."
+    end
+  end
+
+  respond :unlock, Use.available(Lockable, :has_lock_key?), Use.available do |actor, thing, key|
+    actor.perform :take, key if key.parent != actor
+    actor.proceed if key.parent == actor
+  end
+
+  respond :open, Use.available(Lockable) do |actor, thing|
+    if thing.locked?
+      actor.tell "#{The thing} is locked."
+    else
+      actor.proceed
+    end
+  end
+
+  interpret "lock :container with :key", "lock :container :key"
+  interpret "unlock :container with :key", "unlock :container :key"
+  interpret "open :container with :key", "unlock :container :key"
+end