story-teller 1.1.3

data/game/modules/parser_extensions.rb

@@ -0,0 +1,264 @@
+# game/modules/parser_extensions.rb
+# encoding: utf-8
+# frozen_string_literal: false
+
+# Copyright Nels Nelson 2008-2025 but freely usable (see license)
+#
+# This file is part of the StoryTeller.
+#
+# The StoryTeller is free software: you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# The StoryTeller is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with the StoryTeller.  If not, see <http://www.gnu.org/licenses/>.
+
+# The Inform module
+module Inform
+# The Parser module
+module Parser
+  # §28 How nouns are parsed
+  #
+  # So: a parse_name routine, if provided, is expected to try to match as many
+  # words as possible starting from the current position of wn and reading them
+  # in one at a time using the NextWord() routine. Thus it must not stop just
+  # because the first word makes sense, but must keep reading and find out how
+  # many words in a row make sense. It should return:
+  #
+  #   0   if the text didn't make any sense at all,
+  #   k   if k words in a row of the text seem to refer to the object, or
+  #   −1  to tell the parser it doesn't want to decide after all.
+  #
+  # §A5 Entry point ParseNoun routine
+  #
+  # To do the job of parsing the name property (if parse_name hasn't done it
+  # already). This takes one argument, the object in question, and returns a
+  # value as if it were a parse_name routine.
+  #
+  # The ParseNoun entry point routine returns the number of words matched, or 0
+  # if there is no match, or −1 to decline to make a decision and give the job
+  # back to the parser. Note that if −1 is returned, the word number variable
+  # wn must be left set to the first word the parser should look at — probably
+  # the same value it had when ParseNoun was called, but not necessarily.
+  def ParseNoun(obj)
+    i = @wn - 1; m = 0; p = 0
+    if obj.in? InformLibrary::Compass
+      while (word = NextWord())
+        break unless word.matches_exactly?(obj)
+        m += 1
+      end
+    else
+      while (word = NextWord())
+        word_is_plural = plural?(word)
+        # singular_word = singularize(word)
+        if word_is_plural && word.matches_last_exactly?(obj)
+          m += 1
+        elsif Prepositions.include?(word) && word.matches_any_exactly?(obj)
+          p += 1
+          m += 1
+        elsif !Prepositions.include?(word) && word.matches_any_exactly?(obj)
+          m += 1
+        elsif word.matches?(obj)
+          m += 1
+        else
+          break
+        end
+      end
+    end
+    @wn = i + 1
+    m <= 0 ? -1 : p + m
+  end
+
+  def ScoreMatchL(context, match_list, match_scores, number_matched, threshold = 0)
+    threshold += 1 if @indef_type.anybits?(OTHER_BIT)
+    threshold += 1 if @indef_type.anybits?(MY_BIT)
+    threshold += 1 if @indef_type.anybits?(THAT_BIT)
+    threshold += 1 if @indef_type.anybits?(LIT_BIT)
+    threshold += 1 if @indef_type.anybits?(UNLIT_BIT)
+    threshold += 1 if @indef_owner
+
+    if defined?(DEBUG)
+      if @parser_trace >= 4
+        print "   Scoring match list: indef mode " + @indef_mode + ", type " +
+              @indef_type + ", satisfying " + threshold + " requirements:\n"
+      end
+    end
+    # DEBUG
+
+    # if defined?(PREFER_HELD)
+    #   a_s = SCORE__BESTLOC; l_s = SCORE__NEXTBESTLOC
+    #   if @action_to_be == :Take || @action_to_be == :Remove
+    #     a_s = SCORE__NEXTBESTLOC; l_s = SCORE__BESTLOC
+    #   end
+    #   # TODO: FIXME
+    #   # Verify this is needed
+    #   context = context # silence empty block warning
+    # else # not PREFER_HELD
+    a_s = SCORE__NEXTBESTLOC; l_s = SCORE__BESTLOC
+    if %i[held multiheld multiexcept].include?(context)
+      a_s = SCORE__BESTLOC; l_s = SCORE__NEXTBESTLOC
+    end
+    # end
+    # # PREFER_HELD
+
+    if number_matched > 20
+      log.warn "Matched more than 20 objects!"
+      # caller.each { |t| log.warn t }
+    end
+    # TODO: FIXME The @match_list traversal here is buggy and
+    # sometimes produces a situation where obj is nil.
+    for i in (0...number_matched)
+    # match_list.compact.each_with_index do |obj, i|
+      obj = match_list[i]; its_owner = parent(obj); its_score=0; met=0
+      # TODO: Remove:
+      if obj.nil?
+        log.warn "ScoreMatchL: obj is nil in iteration: #{i}, number_matched: " \
+          "#{number_matched}, match_list: #{match_list.length}"
+        next
+      end
+
+      mine = @actor.descendants
+      mine += @actor.body.descendants if @actor.respond_to?(:body)
+      other = @actors_location.descendants - mine
+
+      if defined?(DEBUG) && @scope_reason == PARSING_REASON && @parser_trace >= 10
+        println ">>In ScoreMatchL..."
+        println ">>  ...context is #{context}"
+        println ">>  ...@actor is #{@actor}"
+        println ">>  ...mine are #{mine}"
+        println ">>  ...obj is #{obj} (#{obj.identity})"
+        println ">>  ...obj.in? mine are #{mine.include?(obj)}"
+        println ">>  ...other are #{other}"
+        println ">>  ...obj.in? other are #{other.include?(obj)}"
+        println ">>  ...@indef_type & MY_BIT #{@indef_type & MY_BIT}"
+        println ">>  ...@indef_type & MY_BIT != 0 #{@indef_type & MY_BIT != 0}"
+      end
+
+      # met += 1 if @indef_type & OTHER_BIT != 0 && obj.notin?($itobj, $himobj, $herobj)
+      met += 1 if @indef_type.anybits?(OTHER_BIT) && !language_pronouns.values.map(&:last).include?(obj)
+      met += 1 if @indef_type.anybits?(MY_BIT) && (its_owner == @actor || mine.include?(obj))
+      met += 1 if @indef_type.anybits?(THAT_BIT) && (its_owner == @actors_location || other.include?(obj))
+      met += 1 if @indef_type.anybits?(LIT_BIT) && obj.has?(:light)
+      met += 1 if @indef_type.anybits?(UNLIT_BIT) && obj.hasnt?(:light)
+      met += 1 if @indef_owner && its_owner == @indef_owner
+
+      if defined?(DEBUG) && @scope_reason == PARSING_REASON && @parser_trace >= 10
+        println ">>  ...met is #{met}"
+      end
+
+      if met < threshold
+        if defined?(DEBUG)
+          if @parser_trace >= 4
+            print "   " + The(match_list[i]) + " (" + match_list[i] + ") in " +
+                  the(its_owner) + " is rejected (doesn't match descriptors)\n"
+          end
+        end
+        # DEBUG
+        match_list[i] = nil
+      else
+        its_score = 0
+        its_score = SCORE__UNCONCEALED if obj != @player && obj.hasnt?(:concealed)
+
+        if its_owner == @actor
+          its_score += a_s
+        elsif its_owner == @actors_location
+          its_score += l_s
+        elsif its_owner != Inform::English::Compass
+          its_score += SCORE__NOTCOMPASS
+        end
+
+        its_score += (SCORE__CHOOSEOBJ * ChooseObjects(obj, 2))
+
+        its_score += SCORE__NOTSCENERY if obj.hasnt? :scenery
+        its_score += SCORE__NOTACTOR if obj != @actor
+
+        #   A small bonus for having the correct GNA,
+        #   for sorting out ambiguous articles and the like.
+
+        if @indef_cases & PowersOfTwo_TB[GetGNAOfObject(obj)]
+          its_score += SCORE__GNA
+        end
+
+        match_scores[i] ||= 0
+        begin
+          match_scores[i] += its_score
+        rescue StandardError => e
+          log.error "Failed to accumulate score", e
+        end
+        if defined?(DEBUG)
+        if @parser_trace >= 4
+          print "     " + The(match_list[i]) + " (#{match_list[i].object_id}) in " +
+                the(its_owner) + " : #{match_scores[i]} points\n"
+        end
+        end
+        # DEBUG
+      end
+    end
+
+    # TODO: There has to be a better way
+    log.debug " ScoreMatchL match_list: #{match_list.map { |a| a&.name || 'nil' }}"
+    while (i = match_list.index(nil))
+      log.debug " ScoreMatchL deleting from match_list: #{i}"
+      match_list.delete_at(i)
+      match_scores.delete_at(i)
+      number_matched = match_list.length
+    end
+
+    [match_list, match_scores, number_matched]
+  end
+
+  def time_parse_routine
+    return false unless defined?(Chronic)
+    begin
+      println "Parsing time token..."
+      timestamp = Chronic.parse(consume_remaining_text)
+      println "  result #=> #{timestamp}"
+      return timestamp
+    rescue StandardError => e
+      log.error e
+      @etype = e
+    end
+    false
+  end
+
+  def id_parse_routine
+    l = TryNumber(@wn); @wn += 1
+    return false unless l.number?
+    getobject(l.to_i)
+  end
+
+  def query_parse_routine
+    l = consume_remaining_text
+    return false if l.empty?
+    @consult_words = l
+    @search_results = findobject(/#{l}.*/i) if l.length > 2
+    @search_results.first
+  end
+
+  def text_parse_routine
+    @consult_words = consume_remaining_text
+    if @consult_words.empty?
+      @consult_words = nil
+      return false
+    end
+    GPR_TEXT
+  end
+  alias emote_parse_routine text_parse_routine
+
+  def user_parse_routine
+    l = consume_remaining_text
+    return false if l.empty?
+    @consult_words = l
+    @search_results = Account.where(username: l) if l.length > 2
+    @search_results.first
+  end
+end
+# module Parser
+end
+# module Inform

data/game/rules/example_state.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+# frozen_string_literal: false

data/game/scripts/example_script.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+# frozen_string_literal: false

data/game/topics/example_topic.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+# frozen_string_literal: false

data/game/verbs/game_verbs.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# The Inform module
+module Inform
+# The Verb module
+module Verbs
+  def ExampleSub
+    "This is just an example."
+  end
+  def GrinSub
+    "You grin."
+  end
+  def SmileSub
+    "You smile."
+  end
+  def HugSub
+    return "You wrap your arms around your torso and squeeze." if noun == @player
+    return if ObjectIsUntouchable(noun)
+    if noun.life? :Hug
+      j = RunLife(noun, :Hug)
+      if j.is_a?(String)
+        println j
+      else
+        println "You give " + the(noun) + " a big hug!"
+      end
+      return false if j
+    elsif noun.has? :animate
+      return The(noun) + " graciously declines."
+    end
+    return true if AfterRoutines()
+    "You give " + the(noun) + " a big hug!"
+  end
+end
+end