Class: InformLibrary

Inherits:

Inform::Ephemeral::Object

Object
Inform::Ephemeral::Object
InformLibrary

show all

Includes:: Inform::Parser

Defined in:: lib/inform/parserm.h.rb

Overview

The InformLibrary class. Inform 6 defines this as an Object.

Constant Summary

Constants included from Inform::Parser

Constants included from Inform::Verbs

Inform::Verbs::LibraryMessages, Inform::Verbs::MAKE__TS, Inform::Verbs::TASK_DONE, Inform::Verbs::TASK_SCORES

Constants included from Inform::English

Instance Attribute Summary collapse

#player ⇒ Object

Returns the value of attribute player.

Instance Method Summary collapse

#ActionPrimitive(a = @action) ⇒ Object
#AdvanceWorldClock ⇒ Object
#AfterGameOver ⇒ Object (also: #RRQL)
#AfterRoutines ⇒ Object
#BeforeRoutines(_a = @action) ⇒ Object
#begin_action(a, n, s, source) ⇒ Object
#end_turn_sequence ⇒ Object

def parse.
#inflib ⇒ Object
#inform(text) ⇒ Object
#Initialise ⇒ Object
#initialize ⇒ InformLibrary constructor

A new instance of InformLibrary.
#LoopOverScope(routine, act) ⇒ Object
#NoteObjectAcquisitions ⇒ Object
#OBIT_HEAD ⇒ Object
#parse(s) ⇒ Object
#parse_input ⇒ Object
#play ⇒ Object
#playing ⇒ Object
#PrintOrRun(obj, prop, flag = 0) ⇒ Object
#PrintOrRunVar(var, flag) ⇒ Object
#R_Process(a, i, j) ⇒ Object
#resume ⇒ Object
#RRQPL ⇒ Object
#RunEachTurnProperties ⇒ Object
#RunLife(a, j) ⇒ Object
#RunRoutines(obj, prop) ⇒ Object
#RunTimersAndDaemons ⇒ Object
#state ⇒ Object
#state=(state) ⇒ Object
#stop ⇒ Object
#TestScope(obj, act) ⇒ Object

—————————————————————————-.
#ValueOrRun(obj, prop) ⇒ Object
#ZRegion(z) ⇒ Object

Constructor Details

#initialize ⇒ `InformLibrary`

Returns a new instance of InformLibrary.

# File 'lib/inform/parserm.h.rb', line 4990

def initialize
  super('(Inform Library)')
  has :proper
  initialize_state
  self
end

Instance Attribute Details

#player ⇒ `Object`

Returns the value of attribute player.



4988
4989
4990

# File 'lib/inform/parserm.h.rb', line 4988

def player
  @player
end

Instance Method Details

#ActionPrimitive(a = @action) ⇒ `Object`



5470
5471
5472

# File 'lib/inform/parserm.h.rb', line 5470

def ActionPrimitive(a = @action)
  indirect(a)
end

#AdvanceWorldClock ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5417

def AdvanceWorldClock
  return unless defined? SINGLE_PLAYER
  @turns += 1
  if !@the_time.nil?
    if @time_rate >= 0 then @the_time = @the_time + @time_rate
    else
      @time_step -= 1
      if @time_step == 0
        @the_time += 1
        @time_step = -@time_rate
      end
    end
    @the_time = @the_time % 1440
  end
end

#AfterGameOver ⇒ `Object` Also known as: RRQL

# File 'lib/inform/parserm.h.rb', line 5479

def AfterGameOver
  return unless defined? SINGLE_PLAYER
  prompt
  @temp_global = 0
  i = @parse[1]
  if [QUIT1__WD, QUIT2__WD].include?(i)
    quit
  end
  if i == RESTART__WD
    restart
  end
  if i == RESTORE__WD
    RestoreSub()
    return RRQPL()
  end
  if [FULLSCORE1__WD, FULLSCORE2__WD].include?(i) && TASKS_PROVIDED == 0
    new_line; FullScoreSub()
    return RRQPL()
  end
  if @deadflag == 2 && i == AMUSING__WD && AMUSING_PROVIDED == 0
    new_line; Amusing()
    return RRQPL()
  end
  L__M(:Miscellany, 8)
  return RRQL()
end

#AfterRoutines ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5563

def AfterRoutines
  @scope_reason = scope_reason = REACT_AFTER_REASON; @parser_one = nil
  SearchScope(ScopeCeiling(@player), @player, nil, scope_reason); @scope_reason = PARSING_REASON
  return true if @parser_one
  return true if !@location.nil? && RunRoutines(@location, :after)
  return true if @inp1.object? && RunRoutines(@inp1, :after)
  return GamePostRoutine()
end

#BeforeRoutines(_a = @action) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5551

def BeforeRoutines(_a = @action)
  return true if GamePreRoutine()
  return true if RunRoutines(@player, @orders)
  @scope_reason = scope_reason = REACT_BEFORE_REASON; @parser_one = nil
  SearchScope(ScopeCeiling(@player), @player, scope_reason)
  @scope_reason = PARSING_REASON
  return true if @parser_one
  return true if !@location.nil? && RunRoutines(@location, :before)
  return true if @inp1.object? && RunRoutines(@inp1, :before)
  false
end

#begin_action(a, n, s, source) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5371

def begin_action(a, n, s, source)
  sa = @action; sn = @noun; ss = @second
  @action = a; @noun = @inp1 = n; @second = @inp2 = s
  if defined?(DEBUG)
    TraceAction(source, a) if (@debug_flag & 2) != 0
  end
  @source = 0

  if defined?(DEBUG) && @parser_trace >= 10
    println "Beginning #{@action}(noun=#{@noun}, second=#{@second})..."
  end # DEBUG

  contextualize
  if (!@verb.nil? && @verb.meta?) || BeforeRoutines(a) == false
    rv = ActionPrimitive(a)
  end
  return rv
ensure
  @action = sa; @noun = sn; @second = ss
end

#end_turn_sequence ⇒ `Object`

def parse

# File 'lib/inform/parserm.h.rb', line 5357

def end_turn_sequence
  AdvanceWorldClock()
  return if deadflag
  RunTimersAndDaemons()
  return if deadflag
  RunEachTurnProperties()
  return if deadflag
  TimePasses()
  return if deadflag
  AdjustLight()
  return if deadflag
  NoteObjectAcquisitions()
end

#inflib ⇒ `Object`

4999	# File 'lib/inform/parserm.h.rb', line 4999 def inflib; self; end

#inform(text) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5074

def inform(text)
  @buffer = text
  if respond_to?(:session) && !session.nil? && session.valid_state?(self)
    return session.update self
  end
  :playing
end

#Initialise ⇒ `Object`

4997	# File 'lib/inform/parserm.h.rb', line 4997 def Initialise; true; end

#LoopOverScope(routine, act) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5540

def LoopOverScope(routine, act)
  p1 = @parser_one; sr = @scope_reason; a = @actor; al = @actors_location
  @parser_one = routine;
  if act.nil? then @actor = act else @actor = player end
  @actors_location = ScopeCeiling(@actor)
  @scope_reason = scope_reason = LOOPOVERSCOPE_REASON
  SearchScope(@actors_location, @actor, scope_reason)
ensure
  @parser_one = p1; @scope_reason = sr; @actor = a; @actors_location = al
end

#NoteObjectAcquisitions ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5513

def NoteObjectAcquisitions
  return unless defined? SINGLE_PLAYER
  player.objectloop.each do |i|
    if i.hasnt?(:moved)
      give i, :moved
      if i.has?(:scored)
        self.score = self.score + OBJECT_SCORE
        self.things_score = self.things_score + OBJECT_SCORE
      end
    end
  end
end

#OBIT_HEAD ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5392

def OBIT_HEAD
  print "\n\n    "
  style :bold
  color :black_on_white
  bgcolor :white
  print "***"
  L__M(:Miscellany, 3) if deadflag == true
  L__M(:Miscellany, 4) if deadflag == 2
  if deadflag != false && deadflag != true && deadflag != 2
    print " "
    DeathMessage()
    print " "
  end
  print "***";
  unbgcolor :white
  uncolor :black_on_white
  unstyle :bold
  if defined? NO_SCORE
    print "\n\n"
  else
    print "\n\n\n"
  end # defined? NO_SCORE
  false
end

#parse(s) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5086

def parse(s)
  @input = s

  # If the line was blank, get a fresh line

  return L__M(:Miscellany, 10) if @input.empty?

  @results = [nil, 0, nil, nil]; @meta = false

  2.times do # NotHeld
  catch :ReParse do
  # The Parser writes its results into @results and @meta,
  # a flag indicating a "meta-verb".  This can only be set for
  # commands by the player, not for orders to others.

  parse_input # inputobjs is now just results

  return if deadflag && !@meta
  end
  # ReParse

  @action = @results[0]

  # --------------------------------------------------------------

  # Reverse "give fred biscuit" into "give biscuit to fred"

  # Convert "P, tell me about X" to "ask P about X"

  if @action == :Tell && noun == @player && @actor != @player
    @noun = @actor; @actor = @player; @action = :Ask
  end

  # Convert "ask P for X" to "P, give X to me"

  # if @action == :AskFor && @results.first != @player && @actor == @player
  #   @actor = @results.first; @results[2] = @results[3]
  #   @results[3] = @player; action = :Give
  # end

  # For old, obsolete code: special_word contains the topic word
  # in conversation

  if @action == :Ask || @action == :Tell || @action == :Answer
    @special_word = @special_number1
  end

  #  --------------------------------------------------------------

  @multiflag = false; @onotheld_mode = @notheld_mode; @notheld_mode = false
  # For implicit taking and multiple object detection

  # label :begin__action do
  @inp1 = nil; @inp2 = nil; i = @results[1]
  @inp1 = @results[2] if i >= 1
  @inp2 = @results[3] if i >= 2

  # inp1 and inp2 hold: object numbers, or 0 for "multiple object",
  # or 1 for "a number or dictionary address"

  if @inp1 == 1 then @noun = @special_number1 else @noun = @inp1 end
  if @inp2 == 1
    if @inp1 == 1 then @second = @special_number2
    else               @second = @special_number1
    end
  else @second = @inp2
  end

  #  --------------------------------------------------------------

  # TODO: FIXME
  # act_requester = nil
  #
  # if @actor != @player
  #
  # # The player's "orders" property can refuse to allow conversation
  # # here, by returning true.  If not, the order is sent to the
  # # other person's "orders" property.  If that also returns false,
  # # then: if it was a misunderstood command anyway, it is converted
  # # to an Answer action (thus "floyd, grrr" ends up as
  # # "say grrr to floyd").  If it was a good command, it is finally
  # # offered to the Order: part of the other person's "life"
  # # property, the old-fashioned way of dealing with conversation.
  #
  #   j = RunRoutines(@player, :orders)
  #   unless j
  #     j = RunRoutines(@actor, :orders)
  #     unless j
  #       if action == :NotUnderstood
  #         @results[3] = @actor; @actor = @player; @action = :Answer
  #         #jump begin__action
  #       end
  #       if RunLife(@actor, :Order) == 0; L__M(:Order, 1, @actor); end
  #     end
  #   end
  #   return # jump turn__end
  # end

  # --------------------------------------------------------------
  # Generate the action...

  if (i == 0) ||
     (i == 1 && @inp1 != 0) ||
     (i == 2 && @inp1 != 0 && @inp2 != 0) ||
     (i == @parameters && @inp1 != 0 && @inp2 != 0)
    result = self.begin_action(@action, @noun, @second, 0)
    # jump turn__end
  else

  # ...unless a multiple object must be substituted.  First:
  # (a) check the multiple list isn't empty;
  # (b) warn the player if it has been cut short because too long;
  # (c) generate a sequence of actions from the list
  #     (stopping in the event of death or movement away).

  @multiflag = true
  if @multiple_object.empty?
    return L__M(:Miscellany, 2)
    # jump late__error
  end
  if @toomany_flag
    @toomany_flag = false
    print L__M(:Miscellany, 1)
  end
  i = @location
  for l in @multiple_object
    return if deadflag
    return L__M(:Miscellany, 51) if @location != i
    PronounNotice(l)
    @second = @results[3]
    print "#{l}: "
    if @inp1 == 0
      @inp1 = l; zmsnp self.begin_action(@action, l, @second, 0); @inp1 = 0
    else
      @inp2 = l; zmsnp self.begin_action(@action, @noun, l, 0); @inp2 = 0
    end
  end
  end

  # --------------------------------------------------------------

  # label :turn__end do

  # No time passes if either (i) the verb was meta, or
  # (ii) we've only had the implicit take before the "real"
  # action to follow.
  if @notheld_mode
    NoteObjectAcquisitions()
    println(result, should_prompt: false)
    return true if result == false
    next
  end
  return result if @meta
  if defined? SINGLE_PLAYER
  self.end_turn_sequence() unless deadflag
  end
  println(result) if result.is_a?(String)
  # return result if defined? result
  return true
  end
  # 2.times do # NotHeld
rescue RepeatedOrder
  return L__M(:Miscellany, REPEATED_ORDER)
rescue NothingToRepeat
  return L__M(:Miscellany, NOTHING_TO_REPEAT)
rescue InanimateAddressee
  return L__M(:Miscellany, CANT_TALK, noun)
rescue SpeechImpediment
  return L__M(:Miscellany, SPEECH_THERAPY)
rescue CannotUnderstandSentence
  return L__M(:Miscellany, CANNOT_UNDERSTAND)
rescue PartiallyUnderstood
  L__M(:Miscellany, PARTIALLY_UNDERSTOOD)
  @pattern = @pattern2.dup
  @pcount = @pcount2
  PrintCommand(0)
  return L__M(:Miscellany, 56)
rescue NumberUnrecognized
  return L__M(:Miscellany, NUMBER_UNRECOGNIZED)
rescue CantSeeError
  @oops_from = @saved_oops
  return L__M(:Miscellany, CANT_SEE)
rescue TooLittle
  return L__M(:Miscellany, TOOLITTLE)
rescue NotHeld
  @oops_from = @saved_oops
  return L__M(:Miscellany, NOT_HELD)
rescue UnexpectedMultiple
  return L__M(:Miscellany, NO_MULTIPLES)
rescue MultipleMultiples
  return L__M(:Miscellany, MULITPLES_ONLY_ONCE)
rescue Vague
  return L__M(:Miscellany, VAGUE)
rescue ExceptedUnnecessarily
  return L__M(:Miscellany, EXCEPTED_UNECESSARILY)
rescue AnimateExpected
  return L__M(:Miscellany, ANIMATE_EXPECTED)
rescue VerbUnrecognized
  return L__M(:Miscellany, UNRECOGNIZED)
rescue SceneryIsIrrelevant
  return L__M(:Miscellany, SCENERY_IS_IRRELEVANT)
rescue ItGone
  if @pronoun_obj then L__M(:Miscellany, 40)
  else                 L__M(:Miscellany, 35)
  end
rescue JunkAfter
  return L__M(:Miscellany, 41)
rescue TooFew
  return L__M(:Miscellany, TOOFEW, number)
rescue NothingMatched
  if @results[0] == :Remove && results[3].object?
    @noun = results[3] # ensure valid for messages
    if noun.has?(:animate)                            then L__M(:Take, 6, noun)
    elsif noun.hasnt?(:container, :supporter)         then L__M(:Insert, 2, noun)
    elsif noun.has?(:container) && noun.hasnt?(:open) then L__M(:Take, 9, noun)
    elsif noun.empty?                                 then L__M(:Search, 6, noun)
    else @results[0] = nil
    end
  end
  if @results[0] != :Remove
    if @multi_wanted == 100 then L__M(:Miscellany, 43)
    else                         L__M(:Miscellany, 44)
    end
  end
rescue AskScope
  # log.error "AskScope should have never gotten here"
  # return false # Should never be caught
  @scope_stage = 3
  if indirect(@scope_error) == false
    @best_etype = @nextbest_etype
    raise @best_etype
  end
rescue IncompleteSentence => e
  ambiguity = e
  return Incomplete(ambiguity)
rescue Ambiguous => e
  ambiguity = e
  return WhichOne(ambiguity)
rescue NoSuchObject
  return L__M(:Miscellany, NO_OBJECT)
rescue CycleError
  return L__M(:Miscellany, TREE_ERROR)
rescue NoVerbRoutine, NotImplemented
  return "Sorry, that action is not yet implemented."
rescue NoMethodError => e
  log.error "Error parsing user command: #{e.class}: #{e}"
  e.backtrace.each { |t| log.error t }
  log.error "Parser was #{self.identity}"
  log.error "Input was: #{@input}"
  log.error "Actor was: #{@actor}"
  log.error "Action was: #{@action}"
  return "Sorry, something went wrong."
rescue TypeError => e
  log.error "Error parsing user command: #{e.class}: #{e}"
  e.backtrace.each { |t| log.error t }
  log.error "Parser was #{self.identity}"
  log.error "Input was: #{@input}"
  log.error "Actor was: #{@actor}"
  log.error "Action was: #{@action}"
  return "Sorry, something went wrong."
rescue StandardError => e
  log.error "Error parsing user command: #{e.class}: #{e}"
  e.backtrace.each { |t| log.error t }
  log.error "Parser was #{self.identity}"
  log.error "Input was: #{@input}"
  log.error "Actor was: #{@actor}"
  log.error "Action was: #{@action}"
  return "Sorry, something went seriously wrong."
end

#parse_input ⇒ `Object`



5082
5083
5084

# File 'lib/inform/parserm.h.rb', line 5082

def parse_input
  return Parser__parse()
end

#play ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5010

def play
  @real_location = thedark
  @player = selfobj; @actor = @player
  selfobj.capacity = MAX_CARRIED # ### change?

  new_line
  LibraryExtensions.RunAll(:ext_initialise)
  j = Initialise()
  println j if j.is_a?(String)
  move @player, @location
  light_adjusted @player

  @location = @location.parent until @location.parent.nil?
  @real_location = @location
  @actor = @player # resync, because player may have been changed in initialise()
  Banner() if j != 2
  @lightflag = OffersLight(@player.parent)
  if @lightflag == false
    @real_location = @location
    @location = @thedark
  end
  OBIT_HEAD() if deadflag
  @player.mute if deadflag
  invoke :Look
  deadflag ? :death : :playing
end

#playing ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5037

def playing
  @player.unmute if @player.respond_to?(:unmute) && !deadflag
  enqueue(command: @buffer.dup)

  unless deadflag
    return session.state if respond_to?(:session) && !session.nil?
    return __method__
  end

  AfterLife() if deadflag != 2
  return very__late__error if deadflag == 0

  OBIT_HEAD()
  ScoreSub()
  DisplayStatus()
  AfterGameOver()
  log.debug "#{@player} is entering the death state" # TODO: Remove
  :death
end

#PrintOrRun(obj, prop, flag = 0) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5592

def PrintOrRun(obj, prop, flag = 0)
  si = obj.inflib; obj.inflib = inflib
  return RunRoutines(obj, prop) if obj.properties.include?(prop)
  if obj.respond_to?(prop) && !obj.method(prop).nil?
    result = obj.send(prop)
    if result.is_a?(Class) || result.nil? || obj.linked?(prop)
      return RunTimeError(2, obj, prop)
    elsif result.is_a?(String)
      print result.to_s
      new_line if flag == 0
      return true
    else
      return result
    end
  elsif obj.linked?(prop)
    return RunTimeError(2, obj, prop)
  end
ensure
  obj.inflib = si
end

#PrintOrRunVar(var, flag) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5613

def PrintOrRunVar(var, flag)
  if var.respond_to?(:name)
    print var.name
  elsif var.is_a?(String)
    print var
    new_line if flag == 0
  elsif var.respond_to?(:call)
    return var.call
  else
    print "(#{var})"
  end
  true
end

#R_Process(a, i, j) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5507

def R_Process(a, i, j)
  s1 = @inp1; s2 = @inp2
  @inp1 = i; @inp2 = j; InformLibrary.begin_action(a, i, j, 1)
  @inp1 = s1; @inp2 = s2
end

#resume ⇒ `Object`



5070
5071
5072

# File 'lib/inform/parserm.h.rb', line 5070

def resume
  send(VerbRoutine(@action))
end

#RRQPL ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5474

def RRQPL
  L__M(:Miscellany, 5)
  AfterGameOver()
end

#RunEachTurnProperties ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5462

def RunEachTurnProperties
  return unless defined? SINGLE_PLAYER
  @scope_reason = scope_reason = EACH_TURN_REASON; @verb_word = nil
  DoScopeAction(@location, scope_reason)
  SearchScope(ScopeCeiling(@player), @player, nil)
  @scope_reason = PARSING_REASON
end

#RunLife(a, j) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5572

def RunLife(a, j)
  if defined?(DEBUG)
  TraceAction(2, j) if @debug_flag & 2 != 0
  end # DEBUG
  sv = @reason_code; @reason_code = j;
  return RunRoutines(a, :life)
ensure
  @reason_code = sv
end

#RunRoutines(obj, prop) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5632

def RunRoutines(obj, prop)
  obj = @real_location if obj == thedark && prop.notin?(:initial, :short_name, :description, :life)
  return false if prop.nil?
  val = obj.&(prop); return val unless val.nil?
  return reacts_to?(obj, prop)
end

#RunTimersAndDaemons ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5433

def RunTimersAndDaemons
  return if !defined?(SINGLE_PLAYER)
  if defined?(DEBUG)
    if (@debug_flag & 4) != 0
      @active_timers.each do |the_timer|
        next if the_timer.nil?
        print name(the_timer & !WORD_HIGHBIT) + ": "
        if (the_timer & WORD_HIGHBIT) != 0 then print "daemon"
        else
          print "timer with " + the_timer.time_left + " turns to go"
        end
        new_line
      end
    end
  end # DEBUG

  @active_timers.each do |the_timer|
    break if deadflag != 0
    next if the_timer.nil?
    if (the_timer & WORD_HIGHBIT) != 0 then RunRoutines(the_timer & !WORD_HIGHBIT, daemon)
    elsif the_timer.time_left == 0
      StopTimer(the_timer)
      RunRoutines(the_timer, time_out)
    else
      the_timer.time_left = the_timer.time_left - 1
    end
  end
end

#state ⇒ `Object`



5001
5002
5003

# File 'lib/inform/parserm.h.rb', line 5001

def state
  @player.|(:game_state, (session ? session.state : :playing))
end

#state=(state) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5005

def state=(state)
  @player.&(:game_state, state)
  session.state = state if session
end

#stop ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5057

def stop
  session.state = session.default unless session.nil?
  if @player.nil?
    log.warn "The player object was missing when stopping the game"
    return
  end
  @player.unsubscribe_all
  InformLibrary.libraries.delete @player.identity
  @player = @player.safe_refresh
  @player.remove if !@player.nil? && @player.is_a?(Character)
  @player = @actor = @selfobj = nil
end

#TestScope(obj, act) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5528

def TestScope(obj, act)
  x = @parser_one; p2 = @parser_two;
  @parser_one = obj; @parser_two = 0; a = @actor; al = @actors_location
  sr = @scope_reason; @scope_reason = scope_reason = TESTSCOPE_REASON
  if act.nil? then @actor = @player else @actor = act end
  @actors_location = ScopeCeiling(actor)
  SearchScope(@actors_location, @actor, scope_reason); @scope_reason = sr; @actor = a
  return x
ensure
  @parser_one = x; @parser_two = p2; @actor = a; @actors_location = al; @scope_reason = sr
end

#ValueOrRun(obj, prop) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5627

def ValueOrRun(obj, prop)
  value = obj.respond_to?(prop) ? obj.send(prop) : RunRoutines(obj, prop)
  return value.number? ? value.to_i : value
end

#ZRegion(z) ⇒ `Object`

# File 'lib/inform/parserm.h.rb', line 5582

def ZRegion(z)
  return 0 if z.nil?
  case z.class # Left over from Inform 5
  # when NilClass then 0
  when Object, Class then 1
  when Symbol then 2
  when String then 3
  end
end

Class: InformLibrary

Overview

Constant Summary

Constants included from Inform::Parser

Constants included from Inform::Verbs

Constants included from Inform::English

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Inform::Parser

Methods included from Inform::Verbs

Methods included from Inform::English

Constructor Details

#initialize ⇒ InformLibrary

Instance Attribute Details

#player ⇒ Object

Instance Method Details

#ActionPrimitive(a = @action) ⇒ Object

#AdvanceWorldClock ⇒ Object

#AfterGameOver ⇒ Object Also known as: RRQL

#AfterRoutines ⇒ Object

#BeforeRoutines(_a = @action) ⇒ Object

#begin_action(a, n, s, source) ⇒ Object

#end_turn_sequence ⇒ Object

#inflib ⇒ Object

#inform(text) ⇒ Object

#Initialise ⇒ Object

#LoopOverScope(routine, act) ⇒ Object

#NoteObjectAcquisitions ⇒ Object

#OBIT_HEAD ⇒ Object

#parse(s) ⇒ Object

#parse_input ⇒ Object

#play ⇒ Object

#playing ⇒ Object

#PrintOrRun(obj, prop, flag = 0) ⇒ Object

#PrintOrRunVar(var, flag) ⇒ Object

#R_Process(a, i, j) ⇒ Object

#resume ⇒ Object

#RRQPL ⇒ Object

#RunEachTurnProperties ⇒ Object

#RunLife(a, j) ⇒ Object

#RunRoutines(obj, prop) ⇒ Object

#RunTimersAndDaemons ⇒ Object

#state ⇒ Object

#state=(state) ⇒ Object

#stop ⇒ Object

#TestScope(obj, act) ⇒ Object

#ValueOrRun(obj, prop) ⇒ Object

#ZRegion(z) ⇒ Object

#initialize ⇒ `InformLibrary`

#player ⇒ `Object`

#ActionPrimitive(a = @action) ⇒ `Object`

#AdvanceWorldClock ⇒ `Object`

#AfterGameOver ⇒ `Object` Also known as: RRQL

#AfterRoutines ⇒ `Object`

#BeforeRoutines(_a = @action) ⇒ `Object`

#begin_action(a, n, s, source) ⇒ `Object`

#end_turn_sequence ⇒ `Object`

#inflib ⇒ `Object`

#inform(text) ⇒ `Object`

#Initialise ⇒ `Object`

#LoopOverScope(routine, act) ⇒ `Object`

#NoteObjectAcquisitions ⇒ `Object`

#OBIT_HEAD ⇒ `Object`

#parse(s) ⇒ `Object`

#parse_input ⇒ `Object`

#play ⇒ `Object`

#playing ⇒ `Object`

#PrintOrRun(obj, prop, flag = 0) ⇒ `Object`

#PrintOrRunVar(var, flag) ⇒ `Object`

#R_Process(a, i, j) ⇒ `Object`

#resume ⇒ `Object`

#RRQPL ⇒ `Object`

#RunEachTurnProperties ⇒ `Object`

#RunLife(a, j) ⇒ `Object`

#RunRoutines(obj, prop) ⇒ `Object`

#RunTimersAndDaemons ⇒ `Object`

#state ⇒ `Object`

#state=(state) ⇒ `Object`

#stop ⇒ `Object`

#TestScope(obj, act) ⇒ `Object`

#ValueOrRun(obj, prop) ⇒ `Object`

#ZRegion(z) ⇒ `Object`