inform6lib 0.0.4

data/lib/inform/verblibm.h.rb

@@ -0,0 +1,2481 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# rubocop: disable Lint/UselessAssignment
+
+# ==============================================================================
+#   VerbLib:  Core of standard verbs library.
+#
+#   Supplied for use with Inform 6 -- Release 6/11 -- Serial number 040227
+#
+#   Copyright Graham Nelson 1993-2004 but freely usable (see manuals)
+#
+#   This file is automatically Included in your game file by "VerbLib".
+# ==============================================================================
+
+# Copyright Nels Nelson 2008-2022 but freely usable (see license)
+#
+# You should have received a copy of the Artistic License
+# along with the Inform6 Ruby Port.
+#
+# If not, see <https://www.perlfoundation.org/artistic-license-20.html>.
+
+# The Inform module
+module Inform
+NEWLINE_BIT   =    1         # New-line after each entry
+INDENT_BIT    =    2         # Indent each entry by depth
+FULLINV_BIT   =    4         # Full inventory information after entry
+ENGLISH_BIT   =    8         # English sentence style, with commas and and
+RECURSE_BIT   =   16         # Recurse downwards with usual rules
+ALWAYS_BIT    =   32         # Always recurse downwards
+TERSE_BIT     =   64         # More terse English style
+PARTINV_BIT   =  128         # Only brief inventory information after entry
+DEFART_BIT    =  256         # Use the definite article in list
+WORKFLAG_BIT  =  512         # At top level (only), only list objects
+                             # which have the "workflag" attribute
+ISARE_BIT     = 1024         # Print " is" or " are" before list
+CONCEAL_BIT   = 2048         # Omit objects with "concealed" or "scenery":
+                             # if WORKFLAG_BIT also set, then does _not_
+                             # apply at top level, but does lower down
+NOARTICLE_BIT = 4096         # Print no articles, definite or not
+
+EXTRAINDENT_BIT = 8192       # Used only by I7: extra indentation of 1 level
+EXTRA_WORKFLAG_BIT = 16_384  # Ditto: like WORKFLAG_BIT but at level 1
+
+# The Verbs module
+module Verbs
+  include Inform::English
+
+  def Banner
+    if defined?(Story) && !Story.nil? && !Story.empty?
+      style :bold
+      print Story
+      style :roman
+    end
+
+    print Headline if defined?(Headline) && !Headline.nil? && !Headline.empty?
+    print " by " + Story_Author if defined?(Story_Author) && !Story_Author.nil? && !Story_Author.empty?
+    print "Release " + (HDR_GAMERELEASE & 0x03ff)
+    print " / Serial number "
+    print HDR_GAMESERIAL
+    # defined?(TARGET_)
+    print " / #{executable} v"; inversion
+    print " Library " + LibRelease.to_s + " "
+    if defined? STRICT_MODE
+      print "S"
+    end
+    # defined? STRICT_MODE
+    if defined? INFIX
+      print "X"
+    else
+    if defined? DEBUG
+      print "D"
+    end
+    # defined? DEBUG
+    end
+    # defined? INFIX
+    new_line
+  end
+
+  def VersionSub
+    Banner()
+    if standard_interpreter > 0
+      print "Standard interpreter " + (standard_interpreter / 256) + "." + (standard_interpreter % 256) +
+        " (" + HDR_TERPNUMBER[0]
+      if version_number == 6
+        print '.' + HDR_TERPVERSION[0]
+      else
+        print HDR_TERPVERSION[0]
+      end
+      print ") / "
+    else
+      print "Interpreter " + HDR_TERPNUMBER[0] + " Version "
+      if version_number == 6
+        print HDR_TERPVERSION[0].to_s
+      else
+        print HDR_TERPVERSION[0]
+      end
+      print " / "
+    end
+  end
+
+  def RunTimeError(n, p1 = nil, p2 = nil)
+    if defined? DEBUG
+      print "** Library error #{n} (p1,p2) **\n** "
+      case n
+      when 1  then   print "preposition not found (this should not occur)"
+      when 2  then   print "Property value not routine or string: \"#{p2}\" of \"#{p1}\"" +
+                           " (#{p1})";
+      when 3  then   print "Entry in property list not routine or string: \"#{p2}\" list of \"#{p1}\"" +
+                           " (#{p1})"
+      when 4  then   print "Too many timers/daemons are active simultaneously. " +
+                           "The limit is the library constant MAX_TIMERS (currently #{MAX_TIMERS}) " +
+                           "and should be increased"
+      when 5  then   print "Object \"#{p1}\" has no \"time_left\" property"
+      when 7  then   print "The object \"#{p1}\" can only be used as a player object if it has " +
+                           "the \"number\" property"
+      when 8  then   print "Attempt to take random entry from an empty table array"
+      when 9  then   print "#{p1} is not a valid direction property number"
+      when 10 then   print "The player-object is outside the object tree"
+      when 11 then   print "The room \"#{p1}\" has no \"description\" property"
+      when 12 then   print "Tried to set a non-existent pronoun using SetPronoun"
+      when 13 then   print "A 'topic' token can only be followed by a preposition"
+      else
+                     print "(unexplained)";
+      end
+      " **"
+    else
+      "** Library error #{n} (#{p1},#{p2}) **"
+    end
+  end
+
+# ----------------------------------------------------------------------------
+#  The WriteListFrom routine, a flexible object-lister taking care of
+#  plurals, inventory information, various formats and so on.  This is used
+#  by everything in the library which ever wants to list anything.
+#
+#  If there were no objects to list, it prints nothing and returns false;
+#  otherwise it returns true.
+#
+#  o is the object, and style is a bitmap, whose bits are given by:
+# ----------------------------------------------------------------------------
+
+  def NextEntry(o, odepth, lt_value = @lt_value, c_style = @c_style, &_block)
+    loop do
+      o = o.sibling
+      return nil if o.nil?
+      next if lt_value == true && o.list_together != lt_value
+      next if (c_style & WORKFLAG_BIT) != 0 && odepth == 0 && o.hasnt?(:workflag)
+      next if (c_style & CONCEAL_BIT) != 0 && o.hasany?(:concealed, :scenery)
+      return o
+    end
+  end
+
+  def WillRecurs(o, c_style = @c_style)
+    return true if (c_style & ALWAYS_BIT) != 0
+    return false if (c_style & RECURSE_BIT) == 0
+    return true if o.hasany?(:transparent, :supporter)
+    return true if o.has?(:open, :container)
+    return false
+  end
+
+  def ListEqual(o1, o2, c_style = @c_style)
+    return false if child(o1) && WillRecurs(o1)
+    return false if child(o2) && WillRecurs(o2)
+    if c_style & (FULLINV_BIT + PARTINV_BIT) != 0
+      return false if (o1.hasnt?(:worn) && o2.has?(:worn)) || (o2.hasnt?(:worn) && o1.has?(:worn))
+      return false if (o1.hasnt?(:light) && o2.has?(:light)) || (o2.hasnt?(:light) && o1.has?(:light))
+      if o1.has?(:container)
+        return false if o2.hasnt?(:container)
+        return false if o1.has?(:open) && o2.hasnt?(:open)
+        return false if o2.has?(:open) && o1.hasnt?(:open)
+      elsif o2.has?(:container)
+        return false
+      end
+    end
+    return Identical(o1, o2)
+  end
+
+  def SortTogether(obj, value)
+    # println "Sorting together possessions of " + obj + " by value " + value
+    # x = child(obj)
+    # loop do
+    #   break if x.nil?
+    #   println the(x) + " no: " + x + " lt: " + x.list_together
+    #   x = sibling(x)
+    # end
+    a = [] # out
+    b = [] # in
+    while child(obj)
+      if child(obj).list_together != value
+        a << child(obj)
+      else
+        b << child(obj)
+      end
+      child(obj).delete
+    end
+    b.each { |o| move o, obj } # out
+    a.each { |o| move o, obj } # in
+  end
+
+  def SortOutList(obj)
+    # print "\n\nSorting out list from " + obj.name + "\n  "
+    # i = child(@location)
+    # loop do
+    #   break if i.nil?
+    #   print i.name + " --> "
+    #   i = sibling(i)
+    # end
+    # new_line
+    catch :AP_SOL do
+      i = obj
+      loop do
+        break if i.nil?
+        k = i.list_together
+        unless k.nil?
+          i = sibling(i)
+          loop do
+            break if i.nil? || i.list_together != k
+            i = sibling(i)
+          end
+          return false if i.nil?
+          l = sibling(i)
+          loop do
+            break if l.nil?
+            if l.list_together == k
+              SortTogether(parent(obj), k)
+              obj = parent(child(obj))
+              throw AP_SOL
+            end
+            l = sibling(l)
+          end
+        end
+        i = sibling(i)
+      end
+    end
+    # AP_SOL
+  end
+
+  def Print__Spaces(n)
+    return if n == 0
+    spaces n
+  end
+
+  def WriteListFrom(o, style, depth = 0, &query)
+    if o.nil? || parent(o).nil? || (!query.nil? && parent(o).none?(&query))
+      print NOTHING__TX
+      new_line if style & NEWLINE_BIT != 0
+      return
+    end
+    if o == parent(child(o))
+      SortOutList(o)
+      o = parent(child(o))
+    end
+    # @c_style = style
+    # @wlf_indent = 0
+    WriteListR(o, depth, stack_pointer = 0, c_style = style, &query)
+    true
+  end
+
+  def WriteListR(o, depth, stack_pointer = 0,
+                 c_style = @c_style, lt_value = @lt_value, listing_together = @listing_together,
+                 listing_size = @listing_size, wlf_indent = @wlf_indent, &query)
+    return if o.nil? || parent(o).nil?
+    senc = 0
+
+    if depth > 0 && o == parent(child(o))
+      SortOutList(o)
+      o = parent(child(o))
+    end
+
+    loop do
+      return false if o.nil?
+      if (c_style & WORKFLAG_BIT) != 0 && depth == 0 && o.hasnt?(:workflag)
+        o = o.sibling
+        next
+      end
+      if (c_style & CONCEAL_BIT) != 0 && o.hasany?(:concealed, :scenery)
+        o = o.sibling
+        next
+      end
+      if o == @player || (!query.nil? && !query.call(o))
+        o = o.sibling
+        next
+      end
+      break
+    end
+
+    classes_p = @match_classes.is_a?(Array) ? @match_classes.dup : []
+    sizes_p   = @match_list.is_a?(Array)    ? @match_list.dup    : []
+
+    i = o; j = 0; k = 0
+    loop do
+      break if i.nil?
+      classes_p[j] = 0
+      k += 1 if i.&:plural
+      i = NextEntry(i, depth, lt_value, c_style, &query)
+      j += 1
+    end
+
+    if (c_style & ISARE_BIT) != 0
+      if j == 1 && o.hasnt?(:pluralname) then print IS__TX
+      else                                    print ARE__TX
+      end
+      if (c_style & NEWLINE_BIT) != 0 then println ":"
+      else                                    print ' '
+      end
+      c_style = c_style - ISARE_BIT
+    end
+
+    stack_pointer += (j + 1)
+
+    if k < 2 # It takes two to plural
+      return EconomyVersion(o, j, depth, senc, stack_pointer,
+                            c_style, lt_value,
+                            listing_together, listing_size,
+                            wlf_indent, &query)
+    end
+
+    n = 1; i = o; k = 0
+    loop do
+      break if k >= j
+      if classes_p[k] == 0
+        classes_p[k] = n; sizes_p[n] = 1
+        l = NextEntry(i, depth, lt_value, c_style, &query)
+        m = k + 1
+        loop do
+          break if l.nil? || m >= j
+          if classes_p[m] == 0 && i.&(:plural) && l.&(:plural)
+            if ListEqual(i, l)
+              sizes_p[n] += 1
+              classes_p[m] = n
+            end
+          end
+          l = NextEntry(l, depth, lt_value, c_style, &query)
+          m += 1
+        end
+        n += 1
+      end
+      i = NextEntry(i, depth, lt_value, c_style, &query)
+      k += 1
+    end
+    n -= 1
+
+    i = 1; j = o; k = 0
+    loop do
+      break if i > n
+      loop do
+        break if (classes_p[k] == i) || (classes_p[k] == -i)
+        k += 1; j = NextEntry(j, depth, lt_value, c_style, &query)
+      end
+      m = sizes_p[i]
+      if j.nil? then mr = nil
+      else
+        if !j.list_together.nil? || (!lt_value.nil? && [2, 3].include?(ZRegion(j.list_together)) &&
+            j.list_together == mr)
+          senc -= 1
+        end
+        mr = j.list_together
+      end
+      i += 1
+      senc += 1
+    end
+    senc -= 1
+
+    i = 1; j = o; k = 0; mr = nil
+    loop do
+      break if senc < 0
+      loop do
+        break if (classes_p[k] == i) || (classes_p[k] == -i)
+        k += 1; j = NextEntry(j, depth, lt_value, c_style, &query)
+      end
+      if j.nil? # TODO: FIXME and remove
+        log.warn "classes_p: #{classes_p.inspect}"
+        log.warn "classes_p k: #{k}, i: #{i}"
+        log.warn "FIXME: Too many entries in classes_p"
+        break
+      end
+      if !j.list_together.nil? || !lt_value.nil?
+        if j.list_together == mr
+          # Omit_FL2
+          i += 1
+          next
+        end
+        k2 = NextEntry(j, depth, lt_value, c_style, &query)
+        if k2.nil? || k2.list_together != j.list_together
+          # Omit_WL2
+
+          if WriteBeforeEntry(j, depth, -senc, c_style, wlf_indent) == 1
+            # Omit_FL2
+            i += 1
+            senc -= 1
+            next
+          end
+
+          if sizes_p[i] == 1
+            if (c_style & NOARTICLE_BIT) != 0 then print j.name
+            else
+              if (c_style & DEFART_BIT) != 0 then print the(j) else print a(j) end
+            end
+          else
+            PrefaceByArticle(j, 1, sizes_p[i]) if (c_style & DEFART_BIT) != 0
+            print number(sizes_p[i]) + " "
+            PrintOrRun(j, :plural, 1)
+          end
+
+          if sizes_p[i] > 1 && j.hasnt?(:pluralname)
+            give j, :pluralname
+            WriteAfterEntry(j, depth, stack_pointer,
+                            c_style, lt_value,
+                            listing_together,
+                            listing_size)
+            take j, :pluralname
+          else
+            WriteAfterEntry(j, depth, stack_pointer,
+                            c_style, lt_value,
+                            listing_together,
+                            listing_size)
+          end
+
+          # Omit_EL2
+
+          if (c_style & ENGLISH_BIT) != 0
+            print AND__TX if senc == 1
+            print COMMA__TX if senc > 1
+          end
+
+          # Omit_FL2
+
+          i += 1; senc -= 1
+          next
+        end
+
+        k2 = ZRegion(j.list_together)
+        if [2, 3].include?(k2)
+          q = j; listing_size = 1; l = k; m = i
+          loop do
+            break unless m < n && q.list_together == j.list_together
+            m += 1
+            loop do
+              break unless (classes_p[l] != m) && (classes_p[l] != -m)
+              l += 1; q = NextEntry(q, depth, lt_value, c_style, &query)
+            end
+            listing_size += 1 if q.list_together == j.list_together
+          end
+          # print " [" + listing_size.to_s + "] "
+          if listing_size == 1
+            # Omit_WL2
+
+            if WriteBeforeEntry(j, depth, -senc, c_style, wlf_indent) == 1
+              # Omit_FL2
+              i += 1; senc -= 1
+              next
+            end
+
+            if sizes_p[i] == 1
+              if (c_style & NOARTICLE_BIT) != 0 then print j.name
+              else
+                if (c_style & DEFART_BIT) != 0 then print the(j) else print a(j) end
+              end
+            else
+              PrefaceByArticle(j, 1, sizes_p[i]) if (c_style & DEFART_BIT) != 0
+              print number(sizes_p[i]) + " "
+              PrintOrRun(j, :plural, 1)
+            end
+
+            if sizes_p[i] > 1 && j.hasnt?(:pluralname)
+              give j, :pluralname
+              WriteAfterEntry(j, depth, stack_pointer,
+                              c_style, lt_value,
+                              listing_together,
+                              listing_size)
+              take j, :pluralname
+            else
+              WriteAfterEntry(j, depth, stack_pointer,
+                              c_style, lt_value,
+                              listing_together,
+                              listing_size)
+            end
+
+            # Omit_EL2
+
+            if (c_style & ENGLISH_BIT) != 0
+              print AND__TX if senc == 1
+              print COMMA__TX if senc > 1
+            end
+
+            # Omit_FL2
+
+            i += 1; senc -= 1
+          end
+
+          Print__Spaces(2 * (depth + wlf_indent)) if (c_style & INDENT_BIT) != 0
+
+          if k2 == 3
+            q = 0
+            listing_size.times { |l2| q += sizes_p[l2 + i] }
+            EnglishNumber(q); print " "
+            print j.list_together
+            print " (" if (c_style & ENGLISH_BIT) != 0
+            println ":" if (c_style & INDENT_BIT) != 0
+          end
+          q = c_style
+          if k2 != 3
+            @inventory_stage = 1
+            @parser_one = j; @parser_two = depth + wlf_indent
+            if RunRoutines(j, :list_together) == 1
+              # Omit__Sublist2
+
+              new_line if (q & NEWLINE_BIT) != 0 && (c_style & NEWLINE_BIT) == 0
+              c_style = q
+              mr = j.list_together
+
+              # Omit_EL2
+
+              if (c_style & ENGLISH_BIT) != 0
+                print AND__TX if senc == 1
+                print COMMA__TX if senc > 1
+              end
+
+              i += 1; senc -= 1
+              next
+            end
+          end
+
+          # if defined? TARGET_ZCODE
+          #   push lt_value; push listing_together; push listing_size;
+          # else # TARGET_GLULX
+          #   copy lt_value, sp; copy listing_together, sp; copy listing_size, sp
+          # end
+          # # defined? TARGET_GLULX
+
+          # @lt_value = j.list_together; @listing_together = j; @wlf_indent += 1
+          WriteListR(j, depth, stack_pointer,
+                     c_style, lt_value = j.list_together,
+                     listing_together = j, listing_size,
+                     wlf_indent + 1, &query)
+          # ; @wlf_indent -= 1
+
+          # if defined? TARGET_ZCODE
+          #   pull listing_size; pull listing_together; pull lt_value
+          # else # TARGET_GLULX
+          #   copy sp, listing_size
+          #   copy sp, listing_together
+          #   copy sp, lt_value
+          # end
+          # # TARGET_ZCODE
+
+          if k2 == 3
+            print ")" if (q & ENGLISH_BIT) != 0
+          else
+            @inventory_stage = 2
+            @parser_one = j; @parser_two = depth + wlf_indent
+            RunRoutines(j, :list_together)
+          end
+
+          # label Omit__Sublist2
+
+          new_line if (q & NEWLINE_BIT) != 0 && (c_style & NEWLINE_BIT) == 0
+          c_style = q
+          mr = j.list_together
+
+          # Omit_EL2
+
+          if (c_style & ENGLISH_BIT) != 0
+            print AND__TX if senc == 1
+            print COMMA__TX if senc > 1
+          end
+
+          i += 1; senc -= 1
+          next
+        end
+      end
+      # if !j.list_together.nil? || !lt_value.nil?
+
+      # label Omit_WL2
+
+      if WriteBeforeEntry(j, depth, -senc, c_style, wlf_indent) == 1
+        # Omit_FL2
+        i += 1; senc -= 1
+        next
+      end
+
+      if sizes_p[i] == 1
+        if (c_style & NOARTICLE_BIT) != 0 then print j.name
+        else
+          if (c_style & DEFART_BIT) != 0 then print the(j) else print a(j) end
+        end
+      else
+        PrefaceByArticle(j, 1, sizes_p[i]) if (c_style & DEFART_BIT) != 0
+        print number(sizes_p[i]) + " "
+        PrintOrRun(j, :plural, 1)
+      end
+
+      if sizes_p[i] > 1 && j.hasnt?(:pluralname)
+        give j, :pluralname
+        WriteAfterEntry(j, depth, stack_pointer,
+                        c_style, lt_value,
+                        listing_together,
+                        listing_size)
+        take j, :pluralname
+      else
+        WriteAfterEntry(j, depth, stack_pointer,
+                        c_style, lt_value,
+                        listing_together,
+                        listing_size)
+      end
+
+      # label Omit_EL2
+
+      if (c_style & ENGLISH_BIT) != 0
+        print AND__TX if senc == 1
+        print COMMA__TX if senc > 1
+      end
+
+      # label Omit_FL2
+
+      i += 1; senc -= 1
+    end
+    # loop
+    return true
+  end
+  # def WriteListR
+
+  def EconomyVersion(o, j, depth, senc, stack_pointer = 0,
+                     c_style = @c_style, lt_value = @lt_value,
+                     listing_together = @listing_together,
+                     listing_size = @listing_size,
+                     wlf_indent = @wlf_indent, &query)
+    n = j; i = 1; j = o
+    loop do
+      break unless i <= n
+      if !j.list_together.nil? || (!lt_value.nil? &&
+        [2, 3].include?(ZRegion(j.list_together)) && j.list_together == mr)
+        senc -= 1
+      end
+      mr = j.list_together
+      j = NextEntry(j, depth, lt_value, c_style, &query)
+      i += 1; senc += 1
+    end
+
+    i = 1; j = o; mr = nil
+    loop do
+      break unless i <= senc
+      if !j.list_together.nil? || !lt_value.nil?
+        if j.list_together == mr
+          # Omit_FL
+          j = NextEntry(j, depth, lt_value, c_style, &query)
+          next
+        end
+        k = NextEntry(j, depth, lt_value, c_style, &query)
+        if k.nil? || (k.list_together != j.list_together)
+          # Omit_WL
+
+          if WriteBeforeEntry(j, depth, i - senc, c_style, wlf_indent) == 1
+            # Omit_FL
+            j = NextEntry(j, depth, lt_value, c_style, &query)
+            i += 1
+            next
+          end
+
+          if (c_style & NOARTICLE_BIT) != 0 then print j.name
+          else
+            if (c_style & DEFART_BIT) != 0 then print the(j) else print a(j) end
+          end
+          WriteAfterEntry(j, depth, stack_pointer,
+                          c_style, lt_value,
+                          listing_together,
+                          listing_size)
+
+          # label Omit_EL
+
+          if (c_style & ENGLISH_BIT) != 0
+            print AND__TX if i == (senc - 1)
+            print COMMA__TX if i < (senc - 1)
+          end
+
+          # label Omit_FL
+
+          j = NextEntry(j, depth, lt_value, c_style, &query)
+          i += 1
+          next
+        end
+
+        k = ZRegion(j.list_together)
+        if [2, 3].include?(k)
+          Print__Spaces(2 * (depth + wlf_indent)) if (c_style & INDENT_BIT) != 0
+          if k == 3
+            q = j; l = 0
+            loop do
+              q = NextEntry(q, depth, lt_value, c_style, &query); l += 1
+              break if q.nil? || q.list_together != j.list_together
+            end
+            EnglishNumber(l); print " "
+            print j.list_together
+            print " (" if (c_style & ENGLISH_BIT) != 0
+            print ":\n" if (c_style & INDENT_BIT) != 0
+          end
+          q = c_style
+          if k != 3
+            @inventory_stage = 1
+            @parser_one = j; @parser_two = depth + wlf_indent
+            if RunRoutines(j, :list_together) == 1
+              # Omit__Sublist
+
+              new_line if (q & NEWLINE_BIT) != 0 && (c_style & NEWLINE_BIT) == 0
+              c_style = q
+              mr = j.list_together
+
+              # Omit_EL
+
+              if (c_style & ENGLISH_BIT) != 0
+                print AND__TX if i == (senc - 1)
+                print COMMA__TX if i < (senc - 1)
+              end
+
+              # Omit_FL
+
+              j = NextEntry(j, depth, lt_value, c_style, &query)
+              i += 1
+              next
+            end
+          end
+
+          # if defined? TARGET_ZCODE
+          #   push lt_value; push listing_together; push listing_size
+          # else # defined? TARGET_GLULX
+          #   copy lt_value, sp; copy listing_together, sp; copy listing_size, sp
+          # end
+          # # TARGET_ZCODE
+
+          # lt_value = j.list_together; listing_together = j; wlf_indent += 1
+          WriteListR(j, depth, stack_pointer,
+                     c_style, lt_value = j.list_together,
+                     listing_together = j, listing_size,
+                     wlf_indent + 1, &query)
+          # ; @wlf_indent -= 1
+
+          # if defined? TARGET_ZCODE
+          #   pull listing_size; pull listing_together; pull lt_value
+          # else # defined? TARGET_GLULX
+          #   copy sp, listing_size; copy sp, listing_together; copy sp, lt_value
+          # end
+          # # TARGET_ZCODE
+
+          if k == 3
+            print ")" if (q & ENGLISH_BIT) != 0
+          else
+            @inventory_stage = 2
+            @parser_one = j; @parser_two = depth + wlf_indent
+            RunRoutines(j, :list_together)
+          end
+
+          # label Omit__Sublist
+
+          new_line if (q & NEWLINE_BIT) != 0 && (c_style & NEWLINE_BIT) == 0
+          c_style = q
+          mr = j.list_together
+
+          # Omit_EL
+
+          if (c_style & ENGLISH_BIT) != 0
+            print AND__TX if i == (senc - 1)
+            print COMMA__TX if i < (senc - 1)
+          end
+
+          # Omit_FL
+
+          j = NextEntry(j, depth, lt_value, c_style, &query)
+          i += 1
+          next
+        end
+        # if [2, 3].include?(k)
+      end
+      # if !j.list_together.nil? || !lt_value.nil?
+
+      # label Omit_WL
+
+      if WriteBeforeEntry(j, depth, i - senc, c_style, wlf_indent) == 1
+        # Omit_FL
+        j = NextEntry(j, depth, lt_value, c_style, &query)
+        i += 1
+        next
+      end
+
+      if (c_style & NOARTICLE_BIT) != 0 then print j.name
+      else
+        if (c_style & DEFART_BIT) != 0 then print the(j) else print a(j) end
+      end
+      WriteAfterEntry(j, depth, stack_pointer,
+                      c_style, lt_value,
+                      listing_together,
+                      listing_size)
+
+      # label Omit_EL
+
+      if (c_style & ENGLISH_BIT) != 0
+        print AND__TX if i == (senc - 1)
+        print COMMA__TX if i < (senc - 1)
+      end
+
+      # label Omit_FL
+
+      j = NextEntry(j, depth, lt_value, c_style, &query)
+      i += 1
+    end
+    # loop do break unless i <= senc
+  end
+  # end EconomyVersion (WriteListR)
+
+  def WriteBeforeEntry(o, depth, sentencepos, c_style = @c_style, wlf_indent = 0)
+    flag = false
+
+    @inventory_stage = 1
+    Print__Spaces(2 * (depth + wlf_indent)) if (c_style & INDENT_BIT) != 0
+    if o.respond_to?(:invent) && (c_style & (PARTINV_BIT | FULLINV_BIT)) != 0  # This line changed
+      flag = PrintOrRun(o, :invent, 1)
+      if flag
+        if (c_style & ENGLISH_BIT) == 1
+          print AND__TX if sentencepos == -1
+          print COMMA__TX if sentencepos < -1
+        end
+        new_line if (c_style & NEWLINE_BIT) == 1
+      end
+    end
+    flag
+  end
+
+  def WriteAfterEntry(o, depth, stack_p,
+                      c_style = @c_style, _lt_value = @lt_value,
+                      _listing_together = @listing_together,
+                      _listing_size = @listing_size, &query)
+    recurse_flag = false
+    parenth_flag = false
+    eldest_child = nil
+    child_count = 0
+    combo = nil
+    j = false
+
+    @inventory_stage = 2
+    if (c_style & PARTINV_BIT) == 1
+      # Begin the Inform6 Ruby Port addition
+      if o.respond_to?(:invent) && RunRoutines(o, :invent)
+        return true if (c_style & NEWLINE_BIT) == 0
+        print ""
+        return
+      end
+      # End the Inform6 Ruby Port addition
+
+      combo = 0
+      combo += 1 if o.has?(:light) && @location.hasnt?(:light)
+      combo += 2 if o.has?(:container) && o.hasnt?(:open)
+      if o.has?(:container) && (o.has?(:open) || o.has?(:transparent))
+        o.objectloop do |i|
+          if i.hasnt?(:concealed) && i.hasnt?(:scenery)
+            j = true; break
+          end
+        end
+        combo += 4 if j.nil?
+      end
+      L__M(:ListMiscellany, combo, o) if combo > 0
+    end
+    # end of PARTINV_BIT processing
+
+    if (c_style & FULLINV_BIT) != 0
+      if o.respond_to?(:invent) && RunRoutines(o, :invent)
+        return true if (c_style & NEWLINE_BIT) == 0
+        print ""
+        return
+      end
+
+      if o.has?(:light) && o.has?(:worn) then L__M(:ListMiscellany, 8, o); parenth_flag = true
+      else
+        if o.has?(:light) then L__M(:ListMiscellany, 9, o);  parenth_flag = true end
+        if o.has?(:worn)  then L__M(:ListMiscellany, 10, o); parenth_flag = true end
+      end
+
+      if o.has? :container
+        if o.has? :openable
+          if parenth_flag then print AND__TX
+          else L__M(:ListMiscellany, 11, o)
+          end
+          if o.has? :open
+            if child(o) then L__M(:ListMiscellany, 12, o)
+            else             L__M(:ListMiscellany, 13, o)
+            end
+          else
+            if o.has?(:lockable) && o.has?(:locked) then L__M(:ListMiscellany, 15, o)
+            else                                         L__M(:ListMiscellany, 14, o)
+            end
+          end
+          parenth_flag = true
+        else
+          if child(o) == 0 && o.has?(:transparent)
+            if parenth_flag then L__M(:ListMiscellany, 16, o)
+            else                 L__M(:ListMiscellany, 17, o)
+            end
+          end
+        end
+      end
+
+      print ")" if parenth_flag
+    end
+    # end of FULLINV_BIT processing
+
+    if (c_style & CONCEAL_BIT) != 0
+      child_count = 0
+      o.objectloop do |p|
+        if p.hasnt?(:concealed) && p.hasnt?(:scenery) then child_count += 1; eldest_child = p; end
+      end
+    else
+      child_count = children(o); eldest_child = child(o)
+    end
+
+    if child_count != 0 && (c_style & ALWAYS_BIT) != 0
+      L__M(:ListMiscellany, 18, o) if (c_style & ENGLISH_BIT) != 0
+      recurse_flag = true
+    end
+
+    if child_count != 0 && (c_style & RECURSE_BIT) != 0
+      if o.has? :supporter
+        if (c_style & ENGLISH_BIT) != 0
+          if (c_style & TERSE_BIT) != 0 then L__M(:ListMiscellany, 19, o)
+          else                               L__M(:ListMiscellany, 20, o)
+          end
+          if o.has? :animate then print WHOM__TX
+          else                    print WHICH__TX
+          end
+        end
+        recurse_flag = true
+      end
+      if o.has?(:container) && (o.has?(:open) || o.has?(:transparent))
+        if (c_style & ENGLISH_BIT) != 0
+          if (c_style & TERSE_BIT) != 0 then L__M(:ListMiscellany, 21, o)
+          else                               L__M(:ListMiscellany, 22, o)
+          end
+          if o.has? :animate then print WHOM__TX
+          else                    print WHICH__TX
+          end
+        end
+        recurse_flag = true
+      end
+    end
+
+    if recurse_flag && (c_style & ENGLISH_BIT) != 0
+      if child_count > 1 || (eldest_child && eldest_child.has?(:pluralname)) then print ARE2__TX
+      else                                                                        print IS2__TX
+      end
+    end
+
+    new_line if (c_style & NEWLINE_BIT) != 0
+
+    return unless recurse_flag
+
+    o = child(o)
+    # if defined? TARGET_ZCODE
+    #   push lt_value; @push listing_together; @push listing_size
+    # else # defined? TARGET_GLULX
+    #   copy lt_value, sp; copy listing_together, sp; copy listing_size, sp
+    # end
+    # # TARGET_ZCODE
+
+    # @lt_value = 0; @listing_together = 0; @listing_size = 0
+    WriteListR(o, depth + 1, stack_p,
+               c_style, lt_value = nil,
+               listing_together = nil, listing_size = 0, &query)
+    # if defined? TARGET_ZCODE
+    #   pull listing_size; pull listing_together; pull lt_value
+    # else # defined? TARGET_GLULX
+    #   copy sp, listing_size; copy sp, listing_together; copy sp, lt_value
+    # end
+    # # TARGET_ZCODE
+    print ")" if (c_style & TERSE_BIT) != 0
+  end
+  # def WriteAfterEntry
+
+# ----------------------------------------------------------------------------
+#   A cunning routine (which could have been a daemon, but isn't, for the
+#   sake of efficiency) to move objects which could be in many rooms about
+#   so that the player never catches one not in place
+# ----------------------------------------------------------------------------
+
+  def MoveFloatingObjects
+    return if @location.nil? || @location == @player
+    flag = false
+    objectloop do |i|
+      address = i.&(:found_in)
+      if !address.nil? && i.hasnt?(:absent) && !IndirectlyContains(player, i)
+        if ZRegion(address) == 2
+          if !i.&(:found_in).nil? then move i, @location
+          else                         remove i
+          end
+        else
+          i.&(:found_in).each do |m|
+            if m == @location || m.in?(@location)
+              move i, @location if i.notin? @location
+              flag = true
+            end
+          end
+          remove i if flag == false && !parent(i).nil?
+        end
+      end
+    end
+  end
+
+# ----------------------------------------------------------------------------
+#   Two little routines for moving the player safely.
+# ----------------------------------------------------------------------------
+
+  def PlayerTo(newplace, flag = 0)
+    move @player, newplace
+    loop do
+      parent_newplace = parent(newplace)
+      break if parent_newplace.nil?
+      newplace = parent_newplace
+    end
+    @location = newplace
+    @real_location = @location; MoveFloatingObjects()
+    AdjustLight(true)
+    _invoke :Look if flag == 0
+    if flag == 1 then NoteArrival(); ScoreArrival(); end
+    LookSub(true) if flag == 2
+  end
+
+  def MovePlayer(direc); _invoke :Go, direc; _invoke :Look; end
+
+# ----------------------------------------------------------------------------
+#   The handy YesOrNo routine, and some "meta" verbs
+# ----------------------------------------------------------------------------
+
+  # TODO: Figure out how this could work in a non-blocking IO system. FIXME
+  # The read method would have to create an evented future promise or
+  # something. That seems like it would cause this code to block on the
+  # read command, and avoiding such blocking behavior was the entire point
+  # of using Netty.
+  def YesOrNo
+    loop do
+      @input = Inform::Runtime.instance.read
+      DrawStatusLine() if !location.nil? && !parent(@player).nil?
+      j = @input
+      unless @input.empty? # at least one word entered
+        i = @input.split.first
+        return true if [YES1__WD, YES2__WD, YES3__WD].include?(i)
+        return false if [NO1__WD, NO2__WD, NO3__WD].include?(i)
+      end
+      L__M(:Quit, 1); print "> "
+    end
+  end
+
+  # TODO: How could this work in a non-blocking IO system? FIXME
+  def QuitSub
+    L__M(:Quit, 2)
+    quit if YesOrNo()
+  end
+
+  def NotifyOnSub;  notify_mode = 1; L__M(:NotifyOn);  end
+  def NotifyOffSub; notify_mode = 0; L__M(:NotifyOff); end
+
+  def Places1Sub
+    j = 0
+    k = 0
+    L__M(:Places, 1)
+    objectloop { |i| j += 1 if i.has?(:visited) }
+    objectloop do |i|
+      if i.has? :visited
+        print i.name; k += 1
+        if k == j then L__M(:Places, 2); return; end
+        if k == j - 1 then print AND__TX
+        else               print COMMA__TX
+        end
+      end
+    end
+  end
+
+  # def Objects1Sub
+  #   j = 0
+  #   L__M(:Objects, 1)
+  #   objectloop do |i|
+  #     if i.has? :moved
+  #       f = 1; print the(i); j = parent(i)
+  #       unless j.nil?
+  #         if j == player
+  #           if i.has?(:worn) L__M(:Objects, 3)
+  #           else             L__M(:Objects, 4)
+  #           end
+  #           new_line
+  #           break
+  #         end
+  #         if j.has?(:animate) then L__M(:Objects, 5); new_line; break; end
+  #         if j.has?(:visited) then L__M(:Objects, 6, j); new_line; break; end
+  #         if j.has?(:container) then L__M(:Objects, 8, j); new_line; break; end
+  #         if j.has?(:supporter) then L__M(:Objects, 9, j); new_line; break; end
+  #         if j.has?(:enterable) then L__M(:Objects, 7, j); new_line; break; end
+  #       end
+  #     end
+  #     L__M(:Objects, 10)
+  #     new_line
+  #   end
+  #   if (f == 0) L__M(##Objects, 2);
+  # end
+
+  # See: metaverbs.rb
+
+# ----------------------------------------------------------------------------
+#   The scoring system
+# ----------------------------------------------------------------------------
+
+  # See: metaverbs.rb
+
+# ----------------------------------------------------------------------------
+#   Real verbs start here: Inventory
+# ----------------------------------------------------------------------------
+
+  def InvWideSub
+    @inventory_style = ENGLISH_BIT + RECURSE_BIT + FULLINV_BIT
+    invoke :Inv
+  end
+
+  def InvTallSub
+    @inventory_style = NEWLINE_BIT + RECURSE_BIT + INDENT_BIT + FULLINV_BIT
+    invoke :Inv
+  end
+
+  def InvSub
+    return L__M(:Inv, 1) unless child(@player)
+    return InvTallSub() if @inventory_style == 0
+
+    L__M(:Inv, 2)
+    if (@inventory_style & NEWLINE_BIT) != 0 then L__M(:Inv, 3) else print " " end
+
+    WriteListFrom(child(@player), @inventory_style, 1)
+    L__M(:Inv, 4) if (@inventory_style & ENGLISH_BIT) != 0
+
+    unless defined? MANUAL_PRONOUNS
+      @player.objectloop { |x| PronounNotice(x) }
+    end
+
+    AfterRoutines()
+  end
+
+# ----------------------------------------------------------------------------
+#   The object tree and determining the possibility of moves
+# ----------------------------------------------------------------------------
+
+  def CommonAncestor(o1, o2)
+    # Find the nearest object indirectly containing o1 and o2,
+    # or return nil if there is no common ancestor.
+    i = o1
+    loop do
+      break if i.nil?
+      j = o2
+      loop do
+        break if j.nil?
+        return i if j == i
+        j = j.parent
+      end
+      i = i.parent
+    end
+    return nil
+  end
+
+  def IndirectlyContains(o1, o2)
+    return true if o1 == o2
+    # Does o1 indirectly contain o2?  (Same as testing if their common ancestor is o1.)
+    return o1.descendants.include?(o2) # TODO: FIXME
+  end
+
+  def ObjectScopedBySomething(item)
+    i = item; return false unless i
+    Inform::Object.each do |j|
+      next unless j.respond_to?(:add_to_scope)
+      return j if j.add_to_scope.include?(j)
+    end
+    return false
+  end
+
+  def ObjectIsUntouchable(item, flag1 = nil, flag2 = nil, persona = nil)
+    # Determine if there's any barrier preventing the player from moving
+    # things to "item".  Return false if no barrier; otherwise print a
+    # suitable message and return true.
+    # If flag1 is set, do not print any message.
+    # If flag2 is set, also apply Take/Remove restrictions.
+    # If persona is set, use that rather than the player.
+
+    flag1 = @player if flag1.nil?
+    flag2 = @player if flag2.nil?
+    persona = @player if persona.nil?
+
+    # If the item has been added to scope by something, it's first necessary
+    # for that something to be touchable.
+
+    ancestor = CommonAncestor(persona, item)
+    if ancestor.nil?
+      ancestor = item
+      loop do
+        break unless ancestor && (i = ObjectScopedBySomething(ancestor)).nil?
+        ancestor = parent(ancestor)
+      end
+      unless i.nil?
+        return false
+        # return false if ObjectIsUntouchable(i, flag1, flag2) # TODO: FIXME
+        # An item immediately added to scope
+      end
+    else
+
+      # First, a barrier between the persona and the ancestor.  The persona
+      # can only be in a sequence of enterable objects, and only closed
+      # containers form a barrier.
+
+      if persona != ancestor
+        i = parent(persona)
+        loop do
+          break unless i != ancestor
+          if i.has?(:container) && i.hasnt?(:open)
+            return true if flag1
+            return L__M(:Take, 9, i)
+          end
+          i = parent(i)
+        end
+      end
+
+      # Second, a barrier between the item and the ancestor.  The item can
+      # be carried by someone, part of a piece of machinery, in or on top
+      # of something and so on.
+
+      if item != ancestor
+        i = parent(item)
+        loop do
+          break unless !i.nil? && i != ancestor
+          if flag2 && i.hasnt?(:container, :supporter) # && i.hasnt?(:supporter)
+            if i.has?(:animate)
+              return true if flag1
+              return L__M(:Take, 6, i)
+            end
+            if i.has?(:transparent)
+              return true if flag1
+              return L__M(:Take, 7, i)
+            end
+            return true if flag1
+            return L__M(:Take, 8, item)
+          end
+          if !i.nil? && i.has?(:container) && i.hasnt?(:open)
+            return true if flag1
+            return L__M(:Take, 9, i)
+          end
+          i = parent(i)
+        end
+      end
+    end
+    # if ancestor.nil?
+
+    return false
+  end
+  # def ObjectIsUntouchable
+
+  def AttemptToTakeObject(item)
+    # Try to transfer the given item to the player: return false
+    # if successful, true if unsuccessful, printing a suitable message
+    # in the latter case.
+    # People cannot ordinarily be taken.
+    if item == @player then println L__M(:Take, 2); return true; end
+    if item.has? :animate then println L__M(:Take, 3, item); return true; end
+
+    ancestor = CommonAncestor(@player, item)
+
+    if ancestor.nil?
+      i = ObjectScopedBySomething(item)
+      ancestor = CommonAncestor(@player, i) if i
+    end
+
+    # Is the player indirectly inside the item?
+    return L__M(:Take, 4, item) if ancestor == item
+
+    # Does the player already directly contain the item?
+    return L__M(:Take, 5, item) if item.in? @player
+
+    # Can the player touch the item, or is there (e.g.) a closed container
+    # in the way?
+    return true if ObjectIsUntouchable(item, false, true)
+
+    # The item is now known to be accessible.
+
+    # Consult the immediate possessor of the item, if it's in a container
+    # which the player is not in.
+
+    i = parent(item)
+    if i != ancestor && i.hasany?(:container, :supporter)
+      after_recipient = i
+      k = @action; @action = :LetGo
+      j = RunRoutines(i, :before)
+      @action = k
+      return true if j
+    end
+
+    if item.has? :scenery then println L__M(:Take, 10, item); return true; end
+    if item.has? :static then println L__M(:Take, 11, item); return true; end
+
+    # The item is now known to be available for taking.  Is the player
+    # carrying too much?  If so, possibly juggle items into the rucksack
+    # to make room.
+
+    k = 0; @player.objectloop { |j2| k += 1 if j2.hasnt? :worn }
+
+    if ValueOrRun(@player, :capacity) < k
+      # TODO: FIXME
+      # return L__M(:Take, 12) if SACK_OBJECT.nil?
+      #
+      # if SACK_OBJECT.parent != @player
+      #   return L__M(:Take, 12)
+      # end
+      # j = nil
+      # @player.objectloop { |k|
+      #   if k != SACK_OBJECT && k.hasnt?(:worn) && k.hasnt?(:light); j = k; end
+      # }
+      #
+      # if !j.nil?
+      #   L__M(:Take, 13, j)
+      #   @keep_silent = true; Insert j, SACK_OBJECT; keep_silent = false
+      #   return true if !j < SACK_OBJECT
+      # end
+      #
+      # return L__M(:Take, 12)
+    end
+
+    # Transfer the item.
+
+    @player.publish L__M(:Take, 15, noun)
+    move item, @player
+
+    # Send "after" message to the object letting go of the item, if any.
+
+    unless after_recipient.nil?
+      k = @action; @action = :LetGo
+      j = RunRoutines(after_recipient, :after)
+      @action = k
+      return true if j
+    end
+    return false
+  end
+
+# ----------------------------------------------------------------------------
+#   Object movement verbs
+# ----------------------------------------------------------------------------
+
+  def TakeSub
+    i = parent(noun)
+    if noun.notin?(@player) || !@onotheld_mode
+      return true if AttemptToTakeObject(noun)
+    end
+    return true if AfterRoutines()
+    @notheld_mode = @onotheld_mode
+    return true if @notheld_mode || @keep_silent
+    L__M(:Take, 1)
+  end
+
+  def RemoveSub
+    i = parent(noun)
+    return L__M(:Remove, 1, noun) if i.has?(:container) && i.hasnt?(:open)
+    return L__M(:Remove, 2, noun) if i != second
+    return L__M(:Take, 6, i) if i.has? :animate
+    return true if AttemptToTakeObject(noun)
+    @action = :Remove; return true if AfterRoutines()
+    @action = :Take;   return true if AfterRoutines()
+    return true if @keep_silent
+    second = i if second.nil? || i == @location  # TODO: FIXME
+    return L__M(:Remove, 3, noun)
+  end
+
+  def DropSub
+    return L__M(:PutOn, 4) if noun == @player
+    return L__M(:Drop, 1, noun) if noun.in? @player.parent
+    return L__M(:Drop, 2, noun) if noun.notin? @player
+    if noun.has? :worn
+      L__M(:Drop, 3, noun)
+      disrobe noun
+      return true if noun.in?(@player) && noun.has?(:worn)
+    end
+    move noun, @player.parent
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:Drop, 5, noun)
+    return L__M(:Drop, 4, noun)
+  end
+
+  def PutOnSub
+    @receive_action = :PutOn
+    # return drop noun end if second == $d_obj || @player.in?(second) # TODO: FIXME
+    return invoke(:Drop, noun) if second == $d_obj || @player.in?(second)
+    return L__M(:Drop, 1, noun) if parent(noun) == second
+    return L__M(:PutOn, 1, noun) if parent(noun) != @player
+
+    ancestor = CommonAncestor(noun, second)
+    return L__M(:PutOn, 2, noun) if ancestor == noun
+    return if ObjectIsUntouchable(second)
+
+    if second != ancestor
+      @action = :Receive
+      if RunRoutines(second, :before) then @action = :PutOn; return; end
+      @action = :PutOn
+    end
+    return L__M(:PutOn, 3, second) if second.hasnt? :supporter
+    return L__M(:PutOn, 4) if ancestor == @player
+    if noun.has? :worn
+      L__M(:PutOn, 5, noun); disrobe noun; return if noun.has? :worn
+    end
+
+    if children(second) >= ValueOrRun(second, :capacity)
+      return L__M(:PutOn, 6, second)
+    end
+
+    move noun, second
+
+    return if AfterRoutines()
+
+    if second != ancestor
+      @action = :Receive
+      if RunRoutines(second, :after) then @action = :PutOn; return true; end
+      @action = :PutOn
+    end
+    return if @keep_silent
+    @player.publish L__M(:PutOn, 9, noun)
+    return L__M(:PutOn, 7) if @multiflag
+    L__M(:PutOn, 8, noun)
+  end
+
+  def InsertSub
+    @receive_action = :Insert
+    return drop noun if second == $d_obj || @player.in?(second)
+    return L__M(:Drop, 1, noun) if noun.parent == second
+    return L__M(:Insert, 1, noun) if noun.parent != @player
+
+    ancestor = CommonAncestor(noun, second)
+    return L__M(:Insert, 5, noun) if ancestor == noun
+    return if ObjectIsUntouchable(second)
+
+    if second != ancestor
+      @action = :Receive
+      if RunRoutines(second, :before) then @action = :Insert; return true; end
+      @action = :Insert
+      if second.has?(:container) && second.hasnt?(:open)
+        return L__M(:Insert, 3, second)
+      end
+    end
+    return L__M(:Insert, 2, second) if second.hasnt? :container
+
+    if noun.has? :worn
+      L__M(:Insert, 6, noun); disrobe noun; return if noun.has? :worn
+    end
+
+    if children(second) >= ValueOrRun(second, :capacity)
+      return L__M(:Insert, 7, second)
+    end
+
+    move noun, second
+
+    return true if AfterRoutines()
+
+    if second != ancestor
+      @action = :Receive
+      if RunRoutines(second, :after) then @action = :Insert; return true; end
+      @action = :Insert
+    end
+    return true if @keep_silent
+    @player.publish L__M(:Insert, 10, noun)
+    return L__M(:Insert, 8, noun) if @multiflag
+    L__M(:Insert, 9, noun)
+  end
+
+# ----------------------------------------------------------------------------
+#   Empties and transfers are routed through the actions above
+# ----------------------------------------------------------------------------
+
+  def TransferSub
+    return if noun.notin?(@player) && AttemptToTakeObject(noun)
+    invoke :PutOn, noun, second if second.has? :supporter
+    invoke :Drop, noun if second == $d_obj
+    invoke :Insert, noun, second
+  end
+
+  def EmptySub; @second = $d_obj; EmptyTSub(); end
+
+  def EmptyTSub
+    return L__M(:EmptyT, 4) if noun == second
+    return if ObjectIsUntouchable(noun)
+    return L__M(:EmptyT, 1, noun) if noun.hasnt? :container
+    return L__M(:EmptyT, 2, noun) if noun.hasnt? :open
+    if second != $d_obj # && second != parent(@player)
+      if second.hasnt? :supporter
+        return L__M(:EmptyT, 1, second) if second.hasnt? :container
+        return L__M(:EmptyT, 2, second) if second.hasnt? :open
+      end
+    end
+    i = child(noun); k = children(noun)
+    return L__M(:EmptyT, 3, noun) unless i
+    loop do
+      break if i.nil?
+      j = i.sibling
+      flag = false
+      flag = true if ObjectIsUntouchable(noun)
+      flag = true if noun.hasnt? :container
+      flag = true if noun.hasnt? :open
+      if second != $d_obj
+        if second.hasnt? :supporter
+          flag = true if second.hasnt? :container
+          flag = true if second.hasnt? :open
+        end
+      end
+      flag = true if k == 0
+      k -= 1
+      break if flag
+      print i + ": " unless @keep_silent
+      _invoke :Transfer, i, second
+      i = j
+    end
+  end
+
+# ----------------------------------------------------------------------------
+#   Gifts
+# ----------------------------------------------------------------------------
+
+  def GiveSub
+    return L__M(:Give, 1, noun) if parent(noun) != @player
+    if second == @player
+      @player.publish A(player) + " juggles " + a(noun) + " for a second or two."
+      return L__M(:Give, 2, noun)
+    end
+    return false if RunLife(second, :Give)
+    L__M(:Give, 3, second)
+  end
+
+  def GiveRSub; _invoke :Give, second, noun; end
+
+  def ShowSub
+    return L__M(:Show, 1, noun) if parent(noun) != @player
+    _invoke :Examine, noun if second == @player
+    return false if RunLife(second, :Show)
+    L__M(:Show, 2, second)
+  end
+
+  def ShowRSub; _invoke :Show, second, noun; end
+
+# ----------------------------------------------------------------------------
+#   Travelling around verbs
+# ----------------------------------------------------------------------------
+
+  def EnterSub
+    # return go noun if noun.in?(Compass) || noun.has?(:door) # TODO: FIXME
+    return invoke(:Go, noun) if noun.in?(Compass) || noun.has?(:door)
+
+    return L__M(:Enter, 1, noun) if @player.in? noun
+    return L__M(:Enter, 2, noun) if noun.hasnt? :enterable
+    return L__M(:Enter, 3, noun) if noun.has?(:container) && noun.hasnt?(:open)
+
+    if parent(@player) != parent(noun)
+      ancestor = CommonAncestor(@player, noun)
+      return L__M(:Enter, 4, noun) if ancestor == @player || ancestor.nil?
+      loop do
+        break if @player.in?(ancestor)
+        j = parent(@player)
+        k = @keep_silent
+        if parent(j) != ancestor || noun != ancestor
+          L__M(:Enter, 6, j)
+          @keep_silent = true
+        end
+        _invoke :Exit
+        @keep_silent = k
+        return if @player.in?(j)
+      end
+      return if @player.in?(noun)
+      if noun.notin?(ancestor)
+        j = parent(noun)
+        loop do
+          break if parent(j) == ancestor
+          j = parent(j)
+        end
+        L__M(:Enter, 7, j)
+        _invoke :Enter, j
+        return if @player.notin?(j)
+        return invoke(:Enter, noun)
+      end
+    end
+
+    move @player, noun
+    return true if AfterRoutines()
+    return true if @keep_silent
+    Locale(noun)
+    @player.publish L__M(:Enter, 8, noun)
+    L__M(:Enter, 5, noun)
+  end
+
+  def GetOffSub
+    _invoke :Exit if parent(@player) == noun
+    L__M(:GetOff, 1, noun)
+  end
+
+  def ExitSub
+    parent_obj = parent(@player)
+    return L__M(:Exit, 4, noun) if !noun.nil? && noun != parent_obj
+    if parent_obj == @location || (@location == thedark && parent_obj == @real_location)
+      if @location.&(:out_to) || (@location == thedark && @real_location.&(:out_to))
+        invoke :Go, $out_obj
+      end
+      return L__M(:Exit, 1)
+    end
+    return L__M(:Exit, 2, parent_obj) if parent_obj.has?(:container) && parent_obj.hasnt?(:open)
+
+    move @player, parent(parent_obj)
+    stand @player
+
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:Exit, 5, parent_obj)
+    L__M(:Exit, 3, parent_obj)
+    LookSub(true)
+  end
+
+  def VagueGoSub; L__M(:VagueGo); end
+
+  def GoInSub; go $in_obj; end
+
+  def GoSub
+    i = @player.parent
+    return RunTimeError(10) if i.nil?
+    RunRoutines(@player, :before) # Attempt to allow for route recollection TODO: Evaluate if necessary
+
+    # first, check if any PushDir object is touchable
+    return if !second.nil? && !second.in?(Compass) && ObjectIsUntouchable(second)
+
+    old_loc = @location
+    movewith = nil
+    if (@location != thedark && i != @location) || (@location == thedark && i != @real_location)
+      j = @location
+      @location = @real_location if @location == thedark
+      k = RunRoutines(i, :before); @location = j if k != 3
+      if k
+        movewith = i; i = i.parent
+      else
+        L__M(:Go,1,i) unless k
+        return true
+      end
+    end
+
+    return L__M(:Go, 6, noun) if noun.door_dir.nil?
+
+    thedir = noun.door_dir
+
+    j = i.&(thedir)
+    return true if j == true
+    if j && j.is_a?(String) then print j.to_s; new_line; return false; end
+
+    unless j
+      if i.respond_to?(:cant_go) && i.cant_go != CANTGO__TX then PrintOrRun(i, :cant_go)
+      else L__M(:Go,2)
+      end
+      return false
+    end
+
+    if j.has? :door
+      return L__M(:Go, 2) if j.has? :concealed
+      if j.hasnt? :open
+        return L__M(:Go, 3, j) if noun == $u_obj
+        return L__M(:Go, 4, j) if noun == $d_obj
+        return L__M(:Go, 5, j)
+      end
+      k = RunRoutines(j,:door_to)
+      if k == false then return L__M(:Go, 6, j) end
+      if k == true  then return true end
+      j = k
+    end
+
+    orig_loc = @real_location
+    @player.publish L__M(:Go, 7, noun) unless @keep_silent
+
+    if movewith.nil? then move @player, j else move movewith, j end
+
+    light_adjusted @player
+
+    # Special addition for ensuring location is never forgotten after player logout.
+    @player.link :location, j
+    @player.descendants.each do |o|
+      o.link :location, j if o.linked? :location
+    end
+    movewith.link :location, j if !movewith.nil? && movewith.linked?(:location)
+
+    @location = j; MoveFloatingObjects();
+    if OffersLight(j)
+      @location = j; @real_location = j; @lightflag = true
+    else
+      if old_loc == thedark
+        DarkToDark()
+        return true if @deadflag
+      end
+      @real_location = j
+      @location = thedark; @lightflag = false
+    end
+
+    @player.publish L__M(:Go, 8, ArrivalDir(j, orig_loc)) unless @keep_silent
+
+    return true if AfterRoutines()
+    return true if @keep_silent
+    LookSub(true)
+  end
+
+  def ArrivalDir(dest, source = @real_location)
+    link = dest.links.find { |l| l.to == source }
+    return nil if link.nil?
+    # TODO: Doesn't work for door objects FIXME
+    direc = Compass.find { |dir| dir.door_dir == link.name.to_sym }
+  end
+
+# ----------------------------------------------------------------------------
+#   Describing the world.  SayWhatsOn(object) does just that (producing
+#   no text if nothing except possibly "scenery" and "concealed" items are).
+#   Locale(object) runs through the "tail end" of a Look-style room
+#   description for the contents of the object, printing up suitable
+#   descriptions as it goes.
+# ----------------------------------------------------------------------------
+
+  def SayWhatsOn(descon)
+    return false if descon == parent(@player)
+    f = descon.any? { |j| j.hasnt?(:concealed) && j.hasnt?(:scenery) }
+    return false unless f
+    println L__M(:Look, 4, descon)
+  end
+
+  def NotSupportingThePlayer(o)
+    i = parent(@player)
+    loop do
+      break if i.nil? || i == @visibility_ceiling
+      return false if i == o
+      i = parent(i)
+      return true if !i.nil? && i.hasnt?(:supporter)
+    end
+    true
+  end
+
+  def Locale(descin, text1 = nil, text2 = nil, flag = false)
+    descin.each { |o| take o, :workflag }
+    k = 0
+    n = 0
+    descin.each do |obj|
+      # Only doing this because the player may no longer be concealed if
+      # the player is to be visible to other players.
+      next if obj == @player || obj.has?(:concealed)
+
+      next unless obj.hasnt?(:concealed) && NotSupportingThePlayer(obj)
+      unless defined? MANUAL_PRONOUNS
+        PronounNotice(obj)
+      end
+
+      give obj, :workflag
+      k += 1
+      property = :initial; f2 = 0
+
+      if obj.hasnt? :scenery
+        if (obj.has?(:door) || obj.has?(:container)) && obj.has?(:open) && obj.respond_to?(:when_open)
+          property = :when_open; f2 = 1
+        elsif (obj.has?(:door) || obj.has?(:container)) && obj.hasnt?(:open) && obj.respond_to?(:when_closed)
+          property = :when_closed; f2 = 1
+        elsif obj.has?(:switchable) && obj.has?(:on) && obj.respond_to?(:when_on)
+          property = :when_on; f2 = 1
+        elsif obj.has?(:switchable) && obj.hasnt?(:on) && obj.respond_to?(:when_off)
+          property = :when_off; f2 = 1
+        end
+
+        if obj.hasnt?(:moved) || obj.respond_to?(:describe) || f2 == 1
+          if obj.respond_to?(:describe) && RunRoutines(obj, :describe)
+            flag = true
+            take obj, :workflag; k -= 1
+          else
+            j = obj.&property
+            unless j.nil?
+              new_line
+              PrintOrRun(obj, property)
+              flag = true
+              take obj, :workflag; k -= 1
+              SayWhatsOn(obj) if obj.has?(:supporter) && !child(obj).nil?
+            end
+          end
+        end
+      elsif obj.has?(:supporter) && !child(obj).nil?
+        SayWhatsOn(obj)
+      end
+    end
+    # descin.each do
+
+    return 0 if k == 0
+
+    if !text1.nil? && !text1.empty?
+      new_line
+      text1 = text2 if flag
+      print text1 + " "
+      WriteListFrom(child(descin), ENGLISH_BIT + RECURSE_BIT + PARTINV_BIT +
+                                   TERSE_BIT + CONCEAL_BIT + WORKFLAG_BIT)
+      return k + j
+    end
+
+    if flag then println L__M(:Look, 5, descin)
+    else         println L__M(:Look, 6, descin)
+    end
+  end
+
+# ----------------------------------------------------------------------------
+#   Looking.  LookSub(true) is allowed to abbreviate long descriptions, but
+#     LookSub(false) (which is what happens when the Look action is generated)
+#     isn't.  (Except that these are over-ridden by the player-set lookmode.)
+# ----------------------------------------------------------------------------
+
+  def LMode1Sub; @lookmode = 1; print Story; L__M(:LMode1); end  # Brief
+
+  def LMode2Sub; @lookmode = 2; print Story; L__M(:LMode2); end  # Verbose
+
+  def LMode3Sub; @lookmode = 3; print Story; L__M(:LMode3); end  # Superbrief
+
+  def ScoreArrival
+    # unless @player.visited.include?(@location)
+    #   @player.visited.push @location
+    #   if @location.has? :scored
+    #     score = score + ROOM_SCORE
+    #     places_score = places_score + ROOM_SCORE
+    #   end
+    # end
+  end
+
+  def NoteArrival
+    if @location == thedark
+      @lastdesc = thedark
+      return
+    end
+    return if @location == @lastdesc
+    PrintOrRun(@location, :initial) if @location.respond_to? :initial
+    descin = @location
+    NewRoom()
+    @lastdesc = descin
+  end
+
+  def FindVisibilityLevels
+    @visibility_levels = 1
+    @visibility_ceiling = parent(@player)
+    loop do
+      break unless parent(@visibility_ceiling) &&
+       (@visibility_ceiling.hasnt?(:container) || @visibility_ceiling.hasany?(:open, :transparent))
+      @visibility_ceiling = parent(@visibility_ceiling)
+      @visibility_levels += 1
+    end
+    @visibility_levels
+  end
+
+  def LookSub(allow_abbrev = nil)
+    allow_abbrev = false if allow_abbrev.nil?
+    return RunTimeError(10) if parent(@player).nil?
+
+    if OffersLight(@real_location)
+      @location = @real_location; @lightflag = true
+    else
+      @location = thedark; @lightflag = false
+    end
+
+    if @location == thedark
+      @visibility_levels = 0
+      @visibility_ceiling = thedark
+      NoteArrival()
+    else
+      @visibility_levels = FindVisibilityLevels()
+      if @visibility_ceiling == @location
+        NoteArrival()
+        if @visibility_ceiling != @location
+          # TODO: Remove or figure this out.
+          log.warn "Not sure why this would ever happen"
+          return "The visibility ceiling is no longer the same as the " +
+            "location. This is probably a very serious error."
+        end
+      end
+    end
+
+    # Printing the top line: e.g.
+    # Octagonal Room (on the table) (as Frodo)
+    new_line
+    style :bold
+    color :yellow
+    if @visibility_levels == 0
+      print DARKNESS__TX
+    else
+      if @visibility_ceiling != @location then print The(@visibility_ceiling)
+      else print name(@visibility_ceiling)
+      end
+    end
+    uncolor :yellow
+    unstyle :bold
+
+    j = 1
+    i = @player.parent
+    loop do
+      break unless j < @visibility_levels
+      if i.has?(:supporter)
+        L__M(:Look, 1, i)
+      else
+        L__M(:Look, 2, i)
+      end
+      j += 1
+      i = i.parent
+    end
+
+    L__M(:Look, 3, @player) if @print_player_flag
+    L__M(:Look, 9, @player) if @player.respond_to?(:builder?) && @player.builder?
+    new_line
+
+    # TODO: FIXME
+    # if @location.outside?
+    #   # PrintOrRun(region, :description) if @player.prefers? :verbose_regions
+    #   # PrintOrRun(area,   :description) if @player.prefers? :verbose_areas
+    # end
+
+    # The room description (if visible)
+
+    if @lookmode < 3 && @visibility_ceiling == @location
+      if allow_abbrev == false || @lookmode == 2 || !@player.visited.include?(@location)
+        if @location.respond_to? :describe
+          RunRoutines(@location, :describe)
+        else
+          if @location.respond_to?(:description)
+            PrintOrRun(@location, :description)
+          else
+            RunTimeError(11, @location)
+          end
+        end
+      end
+    end
+
+    nl_flag = true if @visibility_ceiling == @location
+
+    if @visibility_levels == 0
+      Locale(thedark)
+    else
+      i = @player
+      j = @visibility_levels
+      loop do
+        break unless j > 0
+        give i, :workflag
+        i = parent(i)
+        j -= 1
+      end
+
+      j = @visibility_levels
+      loop do
+        break unless j > 0
+        k = 0
+        i = @player
+        loop do
+          break unless k < j
+          i = parent(i)
+          k += 1
+        end
+        if i.respond_to? :inside_description
+          if nl_flag
+            new_line
+          else
+            nl_flag = true
+          end
+          PrintOrRun(i, :inside_description)
+        end
+        nl_flag = true if Locale(i)
+        j -= 1
+      end
+    end
+
+    LookRoutine()
+    ScoreArrival()
+
+    @action = :Look
+    return true if AfterRoutines()
+    false
+  end
+
+  def ExamineSub
+    return L__M(:Examine, 1) if @location == thedark
+    unless @keep_silent
+      if noun.has? :animate
+        @action = :LookAt
+        if noun.in?(@player)
+          @player.publish A(@player) + " looks at " + hisorher(@player, noun) + "."
+        elsif noun != @player
+          @player.publish A(@player) + " looks over at " + a(noun) + "."
+        end
+      else
+        if noun.in?(@player)
+          @player.publish A(@player) + " examines " + hisorher(@player, noun) + "."
+        else
+          @player.publish A(@player) + " examines " + a(noun) + "."
+        end
+      end
+    end
+    i = noun.description
+    # if noun.values[:description].nil? && noun.properties[:description].nil? && noun.&(:description).nil?
+    if i.nil?
+      return _invoke :Search, noun if noun.has? :container
+      if noun.has? :switchable then L__M(:Examine, 3, noun); return false; end
+      return L__M(:Examine, 2, noun)
+    end
+    PrintOrRun(noun, :description)
+    L__M(:Examine, 3, noun) if noun.has? :switchable
+    return true if AfterRoutines()
+  end
+
+  def LookUnderSub
+    return L__M(:LookUnder, 1) if @location == thedark
+    @player.publish L__M(:LookUnder, 3, noun)
+    L__M(:LookUnder, 2)
+  end
+
+  def VisibleContents(o)
+    o ? o.count { |i| i != @player && i.hasnt?(:concealed, :scenery) } : 0
+  end
+
+  def SearchSub
+    return L__M(:Search, 1, noun) if @location == thedark
+    return if ObjectIsUntouchable(noun)
+    f = VisibleContents(noun)
+    if noun.has? :supporter
+      @player.publish L__M(:Search, 8, noun) unless @keep_silent
+      return L__M(:Search, 2, noun) if f == 0
+      return L__M(:Search, 3, noun)
+    end
+    return L__M(:Search, 4, noun) if noun.hasnt? :container
+    return L__M(:Search, 5, noun) if noun.hasnt?(:transparent) && noun.hasnt?(:open)
+    return true if AfterRoutines()
+
+    @player.publish L__M(:Search, 8, noun) unless @keep_silent
+    return L__M(:Search, 6, noun) if f == 0
+    L__M(:Search, 7, noun)
+  end
+
+# ----------------------------------------------------------------------------
+#   Verbs which change the state of objects without moving them
+# ----------------------------------------------------------------------------
+
+  def UnlockSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Unlock, 1, noun) if noun.hasnt? :lockable
+    return L__M(:Unlock, 2, noun) if noun.hasnt? :locked
+    return L__M(:Unlock, 3, second) if noun.&(:with_key) != second
+    take noun, :locked
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:Unlock, 5, noun)
+    L__M(:Unlock, 4, noun)
+  end
+
+  def LockSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Lock, 1, noun) if noun.hasnt? :lockable
+    return L__M(:Lock, 2, noun) if noun.has? :locked
+    return L__M(:Lock, 3, noun) if noun.has? :open
+    return L__M(:Lock, 4, second) if noun.&(:with_key) != second
+    give noun, :locked
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:Lock, 6, noun)
+    L__M(:Lock, 5, noun)
+  end
+
+  def SwitchonSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:SwitchOn, 1, noun) if noun.hasnt? :switchable
+    return L__M(:SwitchOn, 2, noun) if noun.has? :on
+    give noun, :on
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:SwitchOn, 4, noun)
+    L__M(:SwitchOn, 3, noun)
+  end
+
+  def SwitchoffSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:SwitchOff, 1, noun) if noun.hasnt? :switchable
+    return L__M(:SwitchOff, 2, noun) if noun.hasnt? :on
+    take noun, :on
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:SwitchOff, 4, noun)
+    L__M(:SwitchOff, 3, noun)
+  end
+
+  def OpenSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Open, 1, noun) if noun.hasnt? :openable
+    return L__M(:Open, 2, noun) if noun.has? :locked
+    return L__M(:Open, 3, noun) if noun.has? :open
+    give noun, :open
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:Open, 6, noun)
+    if noun.has?(:container) && noun.hasnt?(:transparent) &&
+       @location != thedark &&
+       VisibleContents(noun) != 0 && IndirectlyContains(noun, @player)
+      return L__M(:Open, 4, noun)
+    end
+    L__M(:Open,5,noun)
+  end
+
+  def CloseSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Close, 1, noun) if noun.hasnt? :openable
+    return L__M(:Close, 2, noun) if noun.hasnt? :open
+    take noun, :open
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:Close, 4, noun)
+    L__M(:Close, 3, noun)
+  end
+
+  def DisrobeSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Disrobe, 1, noun) if noun.hasnt? :worn
+    take noun, :worn
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:Disrobe, 3, noun)
+    L__M(:Disrobe, 2, noun)
+  end
+
+  def WearSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Wear, 1, noun) if noun.hasnt? :clothing
+    return L__M(:Wear, 2, noun) if noun.parent != @player
+    return L__M(:Wear, 3, noun) if noun.has? :worn
+    give noun, :worn
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:Wear, 5, noun)
+    L__M(:Wear, 4, noun)
+  end
+
+  def EatSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Eat, 1, noun) if noun.hasnt? :edible
+    if noun.has? :worn
+      L__M(:Drop, 3, noun)
+      _invoke :Disrobe, noun
+      return true if noun.has?(:worn) && noun.in?(@player)
+    end
+    noun.destroy
+    return true if AfterRoutines()
+    return true if @keep_silent
+    @player.publish L__M(:Eat, 3, noun)
+    L__M(:Eat, 2, noun)
+  end
+
+# ----------------------------------------------------------------------------
+#   Verbs which are really just stubs (anything which happens for these
+#   actions must happen in before rules)
+# ----------------------------------------------------------------------------
+
+  def AllowPushDir
+    return L__M(:PushDir, 2, noun) if parent(second) != Compass
+    return L__M(:PushDir, 3, noun) if [$u_obj, $d_obj].include?(second)
+    AfterRoutines(); i = noun; move i, @player
+    invoke :Go, second
+    if @location == thedark then move i, @real_location
+    else                         move i, @location
+    end
+  end
+
+  def AnswerSub
+    return false if !second.nil? && RunLife(second, :Answer)
+    L__M(:Answer, 1, noun)
+  end
+
+  def AskSub
+    return false if RunLife(noun, :Ask)
+    L__M(:Ask, 1, noun)
+  end
+
+  def AskForSub
+    inv if noun == @player
+    L__M(:Order, 1, noun)
+  end
+
+  def AskToSub
+    return false if RunLife(noun, :AskTo)
+    L__M(:Order, 1, noun)
+  end
+
+  def AttackSub
+    return if ObjectIsUntouchable(noun)
+    return false if noun.has?(:animate) && RunLife(noun, :Attack)
+    L__M(:Attack, 1, noun)
+  end
+
+  def BlowSub; L__M(:Blow, 1, noun); end
+
+  def BurnSub; L__M(:Burn, 1, noun); end
+
+  def BuySub; L__M(:Buy, 1, noun); end
+
+  def ClimbSub; L__M(:Climb, 1, noun); end
+
+  def ConsultSub; L__M(:Consult, 1, noun); end
+
+  def CutSub; L__M(:Cut, 1, noun); end
+
+  def DigSub; L__M(:Dig, 1, noun); end
+
+  def DrinkSub; L__M(:Drink, 1, noun); end
+
+  def FillSub; L__M(:Fill, 1, noun); end
+
+  def JumpSub; L__M(:Jump, 1, noun); end
+
+  def JumpOverSub; L__M(:JumpOver, 1, noun); end
+
+  def KissSub
+    return if ObjectIsUntouchable(noun)
+    return false if RunLife(noun, :Kiss)
+    return L__M(:Touch, 3, noun) if noun == @player
+    # TODO: Publish a visible message
+    L__M(:Kiss, 1, noun)
+  end
+
+  def ListenSub; L__M(:Listen, 1, noun); end
+
+  def MildSub; L__M(:Mild, 1, noun); end
+
+  def NoSub; L__M(:No); end
+
+  def PraySub; L__M(:Pray, 1, noun); end
+
+  def PullSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Pull, 1, noun) if noun.has? :static
+    return L__M(:Pull, 2, noun) if noun.has? :scenery
+    return L__M(:Pull, 4, noun) if noun.has? :animate
+    return true if AfterRoutines()
+    # TODO: Publish a visible message
+    L__M(:Pull, 3, noun)
+  end
+
+  def PushSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Push, 1, noun) if noun.has? :static
+    return L__M(:Push, 2, noun) if noun.has? :scenery
+    return L__M(:Push, 4, noun) if noun.has? :animate
+    return true if AfterRoutines()
+    # TODO: Publish a visible message
+    L__M(:Push, 3, noun)
+  end
+
+  def PushDirSub
+    return "You'll have to stand up first." if @player.hasany? :sitting, :kneeling, :prone
+    L__M(:PushDir, 1, noun)
+  end
+
+  def RubSub; @player.publish L__M(:Rub, 2, noun); L__M(:Rub, 1, noun); end
+
+  def SetSub; L__M(:Set, 1, noun); end
+
+  def SetToSub; L__M(:SetTo, 1, noun); end
+
+  def SingSub; @player.publish L__M(:Sing, 2, noun); L__M(:Sing, 1, noun); end
+
+  def SleepSub; @player.publish L__M(:Sleep, 2, noun); L__M(:Sleep, 1, noun); end
+
+  def SmellSub; @player.publish L__M(:Smell, 2, noun); L__M(:Smell, 1, noun); end
+
+  def SorrySub; @player.publish L__M(:Sorry, 2, noun); L__M(:Sorry, 1, noun); end
+
+  def SqueezeSub
+    return if ObjectIsUntouchable(noun)
+    if noun.has? :animate then return L__M(:Squeeze, 1, noun) end
+    return true if AfterRoutines()
+    L__M(:Squeeze, 2, noun)
+  end
+
+  def StrongSub; L__M(:Strong, 1, noun); end
+
+  def SwimSub; L__M(:Swim, 1, noun); end
+
+  def SwingSub; L__M(:Swing, 1, noun); end
+
+  def TasteSub; L__M(:Taste, 1, noun); end
+
+  def TellSub
+    return L__M(:Tell, 1, noun) if noun == @player
+    return false if RunLife(noun, :Tell)
+    L__M(:Tell, 2, noun)
+  end
+
+  def ThinkSub
+    @player.publish L__M(:Think, 2, noun)
+    L__M(:Think, 1, noun)
+  end
+
+  def ThrowAtSub
+    return if ObjectIsUntouchable(noun)
+    unless second.nil?
+      @action = :ThrownAt
+      if RunRoutines(second, :before) then @action = :ThrowAt; return true; end
+      @action = :ThrowAt
+    end
+    if noun.has? :worn
+      L__M(:Drop, 3, noun)
+      disrobe noun
+      return true if noun.has?(:worn) && noun.in?(@player)
+    end
+    unless second.nil?
+      return L__M(:ThrowAt, 1) if second.hasnt? :animate
+      return false if RunLife(second, :ThrowAt)
+    end
+    L__M(:ThrowAt, 2, noun)
+  end
+
+  def TieSub; L__M(:Tie,1,noun); end
+
+  def TouchSub
+    return L__M(:Touch, 3, noun) if noun == @player
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Touch, 1, noun) if noun.has? :animate
+    @player.publish L__M(:Touch,4,noun)
+    L__M(:Touch,2,noun)
+  end
+
+  def TurnSub
+    return if ObjectIsUntouchable(noun)
+    return L__M(:Turn, 1, noun) if noun.has? :static
+    return L__M(:Turn, 2, noun) if noun.has? :scenery
+    return L__M(:Turn, 4, noun) if noun.has? :animate
+    L__M(:Turn, 3, noun)
+  end
+
+  def WaitSub
+    @player.publish L__M(:Wait, 2, noun)
+    return true if AfterRoutines()
+    L__M(:Wait, 1, noun)
+  end
+
+  def WakeSub; L__M(:Wake, 1, noun); end
+
+  def WakeOtherSub
+    return if ObjectIsUntouchable(noun)
+    return false if RunLife(noun, :WakeOther)
+    L__M(:WakeOther, 1, noun)
+  end
+
+  def WaveSub
+    return L__M(:Wave, 1, noun) if !noun.nil? && (noun.has?(:clothing, :worn) || noun.notin?(@player))
+    @player.publish L__M(:Wave, 3, noun)
+    L__M(:Wave, 2, noun)
+  end
+
+  def WaveHandsSub
+    if noun
+      @player.publish L__M(:WaveHands, 4, noun)
+      L__M(:WaveHands, 3, noun)
+    else
+      @player.publish L__M(:WaveHands, 2, noun)
+      L__M(:WaveHands, 1, noun)
+    end
+  end
+
+  def YesSub; L__M(:Yes); end
+
+# ----------------------------------------------------------------------------
+#   Debugging verbs
+# ----------------------------------------------------------------------------
+
+  def XTestMove(obj, dest)
+    if obj.is_a?(InformLibrary) || obj == LibraryMessages || obj.is_a?(Inform::System::Object)
+      println "[Can't move #{obj.name}: it's a system object.]"
+      return true
+    end
+    loop do
+      break if dest.nil?
+      println "[Can't move #{obj.name}: it would contain itself.]" if dest == obj
+      dest = parent(dest)
+    end
+    false
+  end
+
+  def XAbstractSub
+    return if XTestMove(noun, second)
+    move noun, second
+    "[Abstracted.]"
+  end
+
+  def XPurloinSub
+    return if XTestMove(noun, player)
+    move noun, player; give noun, :moved; take noun, :concealed
+    "[Purloined.]"
+  end
+
+  def XObj(obj, f = 0)
+    if parent(obj) then print a(obj) else print obj end
+    print " (#{obj.id}) "
+    print "(in #{parent(obj)} #{parent(obj).id})" if f == 1 && parent(obj)
+    new_line
+    return true if child(obj).nil?
+    if obj.is_a?(Class)
+      WriteListFrom(child(obj), NEWLINE_BIT + INDENT_BIT + ALWAYS_BIT + NOARTICLE_BIT, 1)
+    else
+      WriteListFrom(child(obj), NEWLINE_BIT + INDENT_BIT + ALWAYS_BIT + FULLINV_BIT, 1)
+    end
+    new_line
+  end
+
+  def XTreeSub
+    raise Parser::VerbUnrecognized unless @player.builder?
+    return XObj(noun, 1) unless noun.nil?
+    objectloop { |i|
+      XObj(i) if i.object? && parent(i).nil?
+    }
+  end
+
+  def GotoSub
+    raise Parser::VerbUnrecognized unless @player.builder?
+    log.debug "<Goto noun> #=> #{noun}"
+    if !noun.is_a?(Inform::Object)
+      "[Not a safe place.]"
+    elsif noun != @player
+      PlayerTo(noun)
+    else
+      "Cannot go to there."
+    end
+  end
+
+  def GonearSub
+    raise Parser::VerbUnrecognized unless @player.builder?
+    x = noun
+    loop do
+      break if parent(x).nil?
+      x = parent(x)
+    end
+    PlayerTo(x)
+  end
+
+  def Print_ScL(obj); println (@x_scope_count += 1) + ": " + a(obj) + " (" + obj.id + ")"; end
+
+  def ScopeSub
+    raise Parser::VerbUnrecognized unless @player.admin?
+    @x_scope_count = 0
+    LoopOverScope(method(:Print_ScL), noun)
+    "Nothing is in scope." if @x_scope_count == 0
+  end
+
+# ----------------------------------------------------------------------------
+#   Finally: the mechanism for library text (the text is in the language defn)
+# ----------------------------------------------------------------------------
+
+  # def L__M(act, n, x1)
+  #   s = @sw__var
+  #   @sw__var = act
+  #   n = 1 if n == 0
+  #   L___M(n,x1)
+  # ensure
+  #   @sw__var = s
+  # end
+
+  # def L___M(n, x1)
+  #   s = @action
+  #   lm_n = n
+  #   lm_o = x1
+  #   @action = @sw__var
+  #   unless RunRoutines(LibraryMessages, :before).nil? then @action = s; return false end
+  #   unless LibraryExtensions.RunWhile(:ext_messages, nil).nil? then @action = s; return false end
+  #   @action = s
+  #   LanguageLM(n, x1)
+  # end
+end
+# module Verbs
+end
+# module Inform
+
+# rubocop: enable Lint/UselessAssignment
+
+# The Inform module
+module Inform
+  # The Parser module
+  module Parser
+    include Inform::Verbs
+  end
+end
+
+# ==============================================================================