gamefic-standard 3.2.4 → 4.0.0

data/lib/gamefic/standard/entities/door.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # An openable and lockable portal.
+    #
+    class Door < Portal
+      include Gamefic::Standard::Openable
+      include Gamefic::Standard::Lockable
+
+      def post_initialize
+        update_reverse_open
+        update_reverse_lock
+      end
+
+      def open=(bool)
+        super
+        reverse&.lock_key = lock_key
+        update_reverse_open
+        update_reverse_lock
+      end
+
+      def locked=(bool)
+        super
+        update_reverse_lock
+      end
+
+      def two_way_lock_key=(key)
+        self.lock_key = key
+        reverse&.lock_key = key
+      end
+
+      private
+
+      def update_reverse_open
+        rev = find_reverse
+        rev&.open = open? unless rev&.open? == open?
+      end
+
+      def update_reverse_lock
+        rev = find_reverse
+        rev&.locked = locked? unless rev&.locked? == locked?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    class Fixture < Thing
+    end    
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # An entity that is portable by default.
+    #
+    class Item < Thing
+      set_default portable: true
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # An entity that provides access from one room to another.
+    #
+    class Portal < Thing
+      # @return [Gamefic::Entity]
+      attr_accessor :destination
+
+      # 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."
+      #
+      # A portal's destination can also be nil, in which case it can be referenced
+      # in commands by its destination, e.g., "go to the house."
+      #
+      # @return [Direction, nil]
+      attr_reader :direction
+
+      # Find the portal in the destination that returns to this portal's parent
+      #
+      # @return [Room, nil]
+      def reverse
+        return nil if destination.nil?
+
+        destination.children.that_are(Portal).find do |portal|
+          portal.destination == parent
+        end
+      end
+      alias find_reverse reverse
+
+      def direction=(dir)
+        @direction = Direction.find(dir)
+      end
+
+      def name
+        @name || direction&.name || destination.name
+      end
+
+      def instruction
+        direction || (destination ? "to #{destination.definitely}" : name)
+      end
+
+      def synonyms
+        "#{super} #{@destination} #{@direction} #{!direction.nil? ? direction.synonyms : ''}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    class Receptacle < Thing
+      include Gamefic::Standard::Enterable
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    class Room < Thing
+      attr_writer :explicit_exits
+
+      set_default explicit_exits: true
+
+      def explicit_exits?
+        @explicit_exits
+      end
+
+      def tell(message)
+        children.each { |c| c.tell message }
+      end
+
+      # @return [Array<Portal>]
+      def portals
+        children.that_are(Portal)
+      end
+
+      # @param destination [Room]
+      # @param direction [Direction, String, nil]
+      # @param type [Class<Portal>]
+      # @param two_way [Boolean]
+      # @return [Portal, Array<Portal>]
+      def connect(destination, direction: nil, type: Portal, two_way: true, **opts)
+        direction = Direction.find(direction)
+        here = type.new parent: self, destination: destination, direction: Direction.find(direction), **opts
+        return here unless two_way
+
+        there = type.new parent: destination, destination: self, direction: direction&.reverse, **opts
+        [here, there]
+      end
+
+      protected
+
+      %w[north south west east northeast southeast southwest northwest up down].each do |direction|
+        define_method "#{direction}=" do |destination|
+          connect destination, direction: direction
+        end
+      end
+
+      def connect=(destinations)
+        all = [destinations].flatten
+        until all.empty?
+          destination = all.shift
+          direction = (all.first.is_a?(String) ? all.shift : nil)
+          connect destination, direction: direction
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'gamefic/standard/entities/scenery'
+
+module Gamefic
+  module Standard
+    # 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
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # 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
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    class Supporter < Thing
+      include Enterable
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    Thing = Gamefic::Entity
+    Thing.set_default itemized: true, portable: false
+    Thing.include Gamefic::Standard::Standardized
+  end
+end

data/lib/gamefic/standard/entities.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    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/door'
+    require 'gamefic/standard/entities/receptacle'
+    require 'gamefic/standard/entities/container'
+    require 'gamefic/standard/entities/room'
+    require 'gamefic/standard/entities/scenery'
+    require 'gamefic/standard/entities/rubble'
+    require 'gamefic/standard/entities/supporter'
+  end
+end

data/lib/gamefic/standard/introduction.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # Add a simple introduction that sets an appropriate name and synonyms for
+    # the player character.
+    #
+    module Introduction
+      extend Gamefic::Scriptable
+
+      introduction do |actor|
+        actor.name = 'you'
+        actor.synonyms = 'self me yourself myself'
+        actor.proper_named = true
+      end
+    end
+  end
+end

data/lib/gamefic/standard/lockable.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # A module for entities that are both openable and lockable.
+    #
+    module Lockable
+      include Openable
+
+      attr_accessor :lock_key
+
+      def lock
+        self.locked = true
+      end
+
+      def unlock
+        self.locked = false
+      end
+
+      def locked=(bool)
+        @locked = bool
+        @open = false if @locked
+      end
+
+      def open=(bool)
+        @open = bool
+        @locked = false if @open
+      end
+
+      def locked?
+        @locked ||= false
+      end
+
+      def unlocked?
+        !locked?
+      end
+
+      def lock_key?
+        !@lock_key.nil?
+      end
+      alias has_lock_key? lock_key?
+    end
+  end
+end

data/lib/gamefic/standard/openable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # A module for entities that are openable.
+    #
+    module Openable
+      def open
+        self.open = true
+      end
+
+      def close
+        self.open = false
+      end
+
+      def open=(bool)
+        @open = bool
+      end
+
+      def open?
+        @open ||= false
+      end
+
+      def closed?
+        !open?
+      end
+
+      def accessible
+        open? ? children : []
+      end
+    end
+  end
+end

data/lib/gamefic/standard/pathfinder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # Pathfinders provide the shortest route between two rooms. The destination
+    # needs to be accessible from the origin through portals. Note that
+    # Pathfinder does not take into account portals that characters should not
+    # be able to traverse, such as locked doors.
+    #
+    class Pathfinder
+      # @return [Room]
+      attr_reader :origin
+
+      # @return [Room]
+      attr_reader :destination
+
+      # @param origin [Room]
+      # @param destination [Room]
+      def initialize(origin, destination)
+        @origin = origin
+        @destination = destination
+        @visited = []
+        if origin == destination
+          @path = []
+        else
+          embark [[origin]]
+        end
+      end
+
+      # An array of rooms starting with the first room after the origin and
+      # ending with the destination.
+      #
+      # The path will be empty if a path could not be found or the origin and
+      # destination are the same room.
+      #
+      # @return [Array<Room>]
+      def path
+        @path || []
+      end
+
+      # True if there is a valid path from the origin to the destination (or
+      # the origin and destination are the same room).
+      #
+      def valid?
+        !!@path
+      end
+
+      private
+
+      def embark(paths)
+        return if paths.empty?
+
+        new_paths = paths.each_with_object([]) do |path, acc|
+          updates = traverse(path)
+          acc.concat updates
+        end
+
+        if new_paths.last&.last == destination
+          @path = new_paths.last
+        else
+          embark new_paths
+        end
+      end
+
+      def traverse(path)
+        portals_with_destination(path).map do |portal|
+          next if @visited.include?(portal.destination)
+
+          return [path[1..] + [portal.destination]] if portal.destination == destination
+
+          @visited.push portal.destination
+          path + [portal.destination]
+        end
+        .compact
+      end
+
+      def portals_with_destination(path)
+        path.last.children.that_are(Portal).select(&:destination)
+      end
+    end
+  end
+end

data/lib/gamefic/standard/queries.rb

@@ -0,0 +1,24 @@
+module Gamefic
+  module Standard
+    module Queries
+      class RoomQuery < Gamefic::Query::Base
+        def span(subject)
+          [subject.room].compact
+        end
+      end
+    end
+  end
+end
+
+# @todo Monkey patch
+module Gamefic
+  module Scriptable
+    module Queries
+      include Gamefic::Standard::Queries
+
+      def room *args
+        RoomQuery.new(Gamefic::Standard::Room, *args, name: 'room')
+      end
+    end
+  end
+end

data/lib/gamefic/standard/standardized.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Gamefic
+  module Standard
+    # Common features of standard entities.
+    #
+    module Standardized
+      # @return [Boolean]
+      attr_writer :itemized
+
+      # @return [Boolean]
+      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.
+      #
+      # @return [String, nil]
+      attr_accessor :locale_description
+
+      # Itemized entities are automatically listed in room descriptions.
+      #
+      # @return [Boolean]
+      def itemized?
+        @itemized
+      end
+
+      # Portable entities can be taken with TAKE actions.
+      #
+      # @return [Boolean]
+      def portable?
+        @portable
+      end
+
+      # @return [Boolean]
+      def attached?
+        @attached ||= false
+      end
+
+      # @param bool [Boolean]
+      def attached=(bool)
+        @attached = if parent.nil?
+                      # @todo Log attachment failure
+                      false
+                    else
+                      bool
+                    end
+      end
+
+      def parent=(new_parent)
+        self.attached = false unless new_parent == parent
+        super
+      end
+
+      # The entity's parent room (i.e., the closest ascendant that is a Room).
+      #
+      # @return [Room]
+      def room
+        ascendant = parent
+        ascendant = ascendant.parent until ascendant.is_a?(Room) || ascendant.nil?
+        ascendant
+      end
+    end
+  end
+end

data/lib/{gamefic-standard → gamefic/standard}/version.rb

@@ -2,6 +2,6 @@
 
 module Gamefic
   module Standard
-    VERSION = '3.2.4'
+    VERSION = '4.0.0'
   end
 end

data/lib/gamefic/standard.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'gamefic'
+require 'gamefic-grammar'
+require 'gamefic-what'
+
+module Gamefic
+  # The Gamefic standard library provides a base collection of entities and
+  # rules for interactive fiction.
+  #
+  module Standard
+    extend Gamefic::Scriptable
+
+    require 'gamefic/standard/version'
+    require 'gamefic/standard/articles'
+    require 'gamefic/standard/queries'
+    require 'gamefic/standard/standardized'
+    require 'gamefic/standard/enterable'
+    require 'gamefic/standard/openable'
+    require 'gamefic/standard/lockable'
+    require 'gamefic/standard/direction'
+    require 'gamefic/standard/entities'
+    require 'gamefic/standard/actions'
+    require 'gamefic/standard/introduction'
+    require 'gamefic/standard/pathfinder'
+
+    include Articles
+    include Grammar::Pronoun
+    include Actions
+    include Introduction
+  end
+end

data/lib/gamefic-standard.rb

@@ -1,29 +1,3 @@
 # frozen_string_literal: true
 
-require 'gamefic'
-
-module Gamefic
-  # The Gamefic standard library provides a base collection of entities and
-  # rules for interactive fiction.
-  #
-  module Standard
-    extend Gamefic::Scriptable
-
-    require 'gamefic-standard/version'
-    require 'gamefic-standard/grammar'
-    require 'gamefic-standard/articles'
-    require 'gamefic-standard/queries'
-    require 'gamefic-standard/modules'
-    require 'gamefic-standard/direction'
-    require 'gamefic-standard/entities'
-    require 'gamefic-standard/actions'
-    require 'gamefic-standard/introduction'
-    require 'gamefic-standard/give'
-
-    include Articles
-
-    def connect(origin, destination, direction = nil, type: Portal, two_way: true)
-      origin.connect destination, direction: direction, type: type, two_way: two_way
-    end
-  end
-end
+require 'gamefic/standard'