scottkit 0.0.0

data/lib/scottkit/play.rb

@@ -0,0 +1,474 @@
+module ScottKit
+  class Game
+    private
+
+    # Returns 1 if the game was won, 0 otherwise
+    def play
+      @finished = nil
+      @items.each { |x| x.loc = x.startloc }
+      @flags = Array.new(NFLAGS) { false } # weird way to set a default
+      @counters = Array.new(NFLAGS) { 0 }
+      @saved_rooms = Array.new(NFLAGS) { 0 }
+      @counter = 0
+      @saved_room = 0
+      @loc = defined?(@startloc) ? @startloc : 1
+      @lampleft = defined?(@lamptime) ? @lamptime : 0
+      dark_flag = false
+
+      puts "ScottKit, a Scott Adams game toolkit in Ruby."
+      puts "Release 1.0, (C) 2010 Mike Taylor <mike@miketaylor.org.uk>"
+      puts "Distributed under the GNU software license"
+
+      if file = options[:restore_file]
+        restore(file)
+        puts "Restored saved game #{file}"
+      end
+
+      if seed = options[:random_seed]
+        puts "Setting random seed #{seed}"
+        srand(seed)
+      end
+
+      @fh = nil
+      if file = options[:read_file]
+        @fh = File.new(file)
+        raise "#$0: can't read input file '#{file}': #$!" if !@fh
+      end
+
+      look
+      while true
+        run_matching_actions(0, 0)
+        return @finished != 0 if @finished
+        print "Tell me what to do ? "
+        if !(line = gets)
+          puts
+          break
+        end
+        words = line.chomp.split
+        execute_command(words[0], words[1])
+        if items.size > ITEM_LAMP &&
+            items[ITEM_LAMP].loc != ROOM_NOWHERE && @lampleft > 0
+          @lampleft -= 1
+          if @lampleft == 0
+            puts "Your light has run out"
+            @flags[FLAG_LAMPDEAD] = true
+          end
+        end
+      end
+      0
+    end
+
+    # Get a line from @fh if defined, otherwise $stdin
+    def gets
+      line = nil
+      if (@fh)
+        line = @fh.gets
+        @fh = nil if !line
+      end
+      line = $stdin.gets if !line
+      return nil if !line
+      puts line if @fh || options[:echo_input]
+      line
+    end
+
+    # Returns index of word in list, or nil if not in vocab
+    # Word may be undefined, in which case 0 is returned
+    def findword(word, list)
+      return 0 if !word
+      word = (word || "").upcase[0, @wordlen]
+      list.each.with_index do |junk, index|
+        target = list[index].upcase
+        if word == target[0, @wordlen]
+          return index
+        elsif target[0] == "*" && word == target[1, @wordlen+1]
+          while list[index][0] == "*"
+            index -= 1
+          end
+          return index
+        end
+      end
+      return nil
+    end
+
+    def execute_command(verb, noun)
+      if (options[:wizard_mode] && verb)
+        if wizard_command(verb, noun)
+          return
+        end
+      end
+
+      verb = "inventory" if verb == "i"
+      verb = "look" if verb == "l"
+      @noun = noun
+      vindex = findword(verb, verbs)
+      nindex = findword(noun, nouns)
+      if !vindex && !noun
+        if tmp = findword(verb, nouns) || findword(verb, %w{XXX n s e w u d})
+          vindex, nindex = VERB_GO, tmp
+        end
+      end
+
+      if !vindex || !nindex
+        puts "You use word(s) I don't know!"
+        return
+      end
+
+      dputs :show_parse, "vindex=#{vindex}, nindex=#{nindex}"
+      case run_matching_actions(vindex, nindex)
+      when :success then return
+      when :failconds then recognised_command = true
+      when :nomatch then recognised_command = false
+      end
+
+      # Automatic GO
+      1.upto 6 do |i|
+        if vindex == VERB_GO && nindex == i
+          puts "Dangerous to move in the dark!" if is_dark
+          newloc = @rooms[@loc].exits[i-1]
+          if newloc != 0
+            @loc = newloc
+            look
+            # When moving from a light place to a dark one or vice
+            # versa, this look should not happen, because we'll get a
+            # correct version of the display after to flag gets set.
+            # I'm not sure what can be done about this.  ### Think
+          elsif is_dark
+            puts "I fell down and broke my neck."
+            finished(0)
+          else
+            puts "I can't go in that direction."
+          end
+          return
+        end
+      end
+
+      # Automatic GET/DROP
+      if (vindex == VERB_GET)
+        return autoget(nindex)
+      elsif (vindex == VERB_DROP)
+        return autodrop(nindex)
+      end
+
+      if (recognised_command)
+        puts "I can't do that yet."
+      else
+        puts "I don't understand your command."
+      end
+    end
+
+    def run_matching_actions(vindex, nindex)
+      recognised_command = false
+      @actions.each_index do |i|
+        action = @actions[i]
+        if vindex == action.verb &&
+            (vindex == 0 || (nindex == action.noun || action.noun == 0))
+          recognised_command = true
+          case action.execute(vindex == 0)
+          when :failconds
+            # Do nothing
+          when :success
+            return :success if vindex != 0
+          when :continue
+            while true
+              action = @actions[i += 1]
+              break if !action || action.verb != 0 || action.noun != 0
+              action.execute(false)
+            end
+            return :success if vindex != 0
+          end
+        end
+      end
+      return recognised_command ? :failconds : :nomatch
+    end
+
+    def wizard_command(verb, noun)
+      optnames = {
+        "c" => :show_conditions,
+        "i"  => :show_instructions,
+        "r"  => :show_random,
+        "p"  => :show_parse,
+      }
+
+      if verb.upcase == "#SG" # superget
+        i = Integer(noun)
+        if (i < 0 || i > @items.count)
+          puts "#{i} out of range 0..#{@items.count}"
+        else
+          @items[i].loc = ROOM_CARRIED
+          puts "Supergot #{@items[i].desc}"
+        end
+      elsif verb.upcase == "#GO" # teleport
+        i = Integer(noun)
+        if (i < 0 || i > @rooms.count)
+          puts "#{i} out of range 0..#{@rooms.count}"
+        else
+          @loc = i
+          look
+        end
+      elsif verb.upcase == "#WHERE" # find an item
+        i = Integer(noun)
+        if (i < 0 || i > @items.count)
+          puts "#{i} out of range 0..#{@items.count}"
+        else
+          item = @items[i]
+          loc = item.loc
+          puts "#Item #{i} (#{item.desc}) at room #{loc} (#{rooms[loc].desc})"
+        end
+      elsif verb.upcase == "#SET"
+        if (sym = optnames[noun])
+          @options[sym] = true
+        else
+          puts "Option '#{noun}' unknown"
+        end
+      elsif verb.upcase == "#CLEAR"
+        if (sym = optnames[noun])
+          @options[sym] = false
+        else
+          puts "Option '#{noun}' unknown"
+        end
+      else
+        return false
+      end
+      true
+    end
+
+    def autoget(nindex)
+      return puts "What ?" if nindex == 0
+      noun = @nouns[nindex].upcase[0, @wordlen]
+      if !(item = @items.find { |x| x.name == noun && x.loc == @loc })
+         puts "It's beyond my power to do that."
+      elsif ncarried == @maxload
+        puts "I've too much to carry!"
+      else
+        item.loc = ROOM_CARRIED
+        puts "O.K."
+      end
+    end
+
+    def autodrop(nindex)
+      return puts "What ?" if nindex == 0
+      noun = @nouns[nindex].upcase[0, @wordlen]
+      if !(item = @items.find { |x| x.name == noun && x.loc == ROOM_CARRIED })
+        puts "It's beyond my power to do that."
+      else
+        item.loc = @loc
+        puts "O.K."
+      end
+    end
+
+    def look #:nodoc:
+      puts
+      if is_dark
+        return print "I can't see. It is too dark!\n\n"
+      end
+
+      room = @rooms[@loc]
+      s = room.desc
+      if s =~ /^\*/
+        puts s.sub(/^\*/, "")
+      else
+        puts "I'm in a #{s}"
+      end
+      if (room.exits.find { |x| x != 0 })
+        print "Obvious exits: "
+        puts room.exits.each.with_index.map { |x, i| [ i, x ] }.
+          select { |x| x[1] != 0 }.
+          map { |x| dirname(x[0]).capitalize }.join(", ") + "."
+      end
+      if @items.find { |x| x.loc == @loc }
+        print "I can also see: "
+        puts @items.select { |x| x.loc == @loc }.
+          map { |x| x.desc.gsub('`', '"') }.join(", ")
+      end
+      puts
+    end
+
+    def inventory #:nodoc:
+      puts "I'm carrying:"
+      carried = items.select { |x| x.loc == ROOM_CARRIED }.map { |x| x.desc }
+      puts((carried.size == 0 ? "Nothing" : carried.join(" - ")) + ".")
+    end
+
+    def score #:nodoc:
+      count = @items.select { |item|
+        item.desc[0] == "*" && item.loc == @treasury
+      }.count
+      print "I've stored #{count} treasures.  "
+      puts "On a scale of 0 to 100, that rates #{100*count/@ntreasures}."
+      if (count == @ntreasures)
+        puts "Well done."
+        finished(1)
+      end
+    end
+
+    def prompt_and_save #:nodoc:
+      print "Filename: "
+      name = gets || return
+      name.chomp!
+      save(name)
+    end
+
+    def finished(win) #:nodoc:
+      puts "The game is now over."
+      sleep 2 if !options[:no_wait]
+      @finished = win
+    end
+
+    def ncarried #:nodoc:
+      items.select { |x| x.loc == ROOM_CARRIED }.size
+    end
+
+    def is_dark
+      return dark_flag if @items.size <= ITEM_LAMP
+      loc = @items[ITEM_LAMP].loc
+      #puts "dark_flag=#{dark_flag}, lamp(#{ITEM_LAMP}) at #{loc}"
+      dark_flag && loc != ROOM_CARRIED && loc != @loc
+    end
+
+    public :play # Must be visible to driver program
+    public :prompt_and_save, :look, :score, :ncarried, :inventory, :finished # Invoked from Instruction.execute()
+
+
+    class Condition
+      def evaluate
+        loc = @game.loc
+        item = @game.items[@value]
+        case @cond
+        when  0 then raise "unexpected condition code 0"
+        when  1 then item.loc == ROOM_CARRIED
+        when  2 then item.loc == loc
+        when  3 then item.loc == ROOM_CARRIED || item.loc == loc
+        when  4 then loc == @value
+        when  5 then item.loc != loc
+        when  6 then item.loc != ROOM_CARRIED
+        when  7 then loc != @value
+        when  8 then @game.flags[@value]
+        when  9 then !@game.flags[@value]
+        when 10 then @game.ncarried != 0
+        when 11 then @game.ncarried == 0
+        when 12 then item.loc != ROOM_CARRIED && item.loc != loc
+        when 13 then item.loc != ROOM_NOWHERE
+        when 14 then item.loc == ROOM_NOWHERE
+        when 15 then @game.counter <= @value
+        when 16 then @game.counter > @value
+        when 17 then item.loc == item.startloc
+        when 18 then item.loc != item.startloc
+          # From the description, it seems that perhaps "moved" should
+          # be true if the object has EVER been moved; but the ScottFree
+          # code implements it as I have done here.
+        when 19 then @game.counter == @value
+        else raise "unimplemented condition code #@cond"
+        end
+      end
+    end
+
+
+    class Instruction
+      # Returns true iff interpreter should continue to next action
+      def execute(args)
+        @game.dputs :show_instructions,
+          "      executing #{self.render(args.clone)}"
+        if (@op == 0)
+          return false # shouldn't happen
+        elsif (@op <= 51)
+          puts @game.messages[@op].gsub('`', '"')
+          return false
+        elsif (@op >= 102)
+          puts @game.messages[@op-50].gsub('`', '"')
+          return false
+        else case @op
+        when 52 then
+          if @game.ncarried == @game.maxload
+            puts "I've too much to carry!"
+          else
+            @game.items[args.shift].loc = ROOM_CARRIED
+            puts "O.K."
+          end
+        when 53 then @game.items[args.shift].loc = @game.loc
+        when 54 then @game.loc = args.shift
+        when 55 then @game.items[args.shift].loc = ROOM_NOWHERE
+        when 56 then @game.dark_flag = true
+        when 57 then @game.dark_flag = false
+        when 58 then @game.flags[args.shift] = true
+        when 59 then @game.items[args.shift].loc = ROOM_NOWHERE
+        when 60 then @game.flags[args.shift] = false
+        when 61 then
+          puts "I am dead."; @game.dark_flag = false;
+          @game.loc = @game.rooms.size-1; @game.look
+        when 62 then i = args.shift; @game.items[i].loc = args.shift
+        when 63 then @game.finished(0)
+        when 64 then @game.look
+        when 65 then @game.score
+        when 66 then @game.inventory
+        when 67 then @game.flags[0] = true
+        when 68 then @game.flags[0] = false
+        when 69 then
+          @game.items[ITEM_LAMP].loc = ROOM_CARRIED
+          @game.lampleft = @game.lamptime
+          @game.flags[FLAG_LAMPDEAD] = false
+        when 70 then # do nothing
+        when 71 then @game.prompt_and_save
+        when 72 then
+          item1 = @game.items[args.shift]
+          item2 = @game.items[args.shift]
+          item1.loc, item2.loc = item2.loc, item1.loc
+        when 73 then return true
+        when 74 then @game.items[args.shift].loc = ROOM_CARRIED
+        when 75 then i1 = args.shift; i2 = args.shift
+          @game.items[i1].loc = @game.items[i2].loc
+        when 76 then @game.look
+        when 77 then @game.counter -= 1
+        when 78 then print @game.counter, " "
+        when 79 then @game.counter = args.shift
+        when 80 then @game.loc, @game.saved_room = @game.saved_room, @game.loc
+        when 81 then which = args.shift
+          @game.counter, @game.counters[which] =
+            @game.counters[which], @game.counter
+        when 82 then @game.counter += args.shift
+        when 83 then @game.counter -= args.shift
+        #84 print_noun unused in Adventureland/Pirate
+        when 85 then puts @game.noun
+        when 86 then puts
+        when 87 then which = args.shift
+          @game.loc, @game.saved_rooms[which] =
+            @game.saved_rooms[which], @game.loc
+        #87 swap_specific_room unused in Adventureland/Pirate
+        when 88 then sleep 2 if !@game.options[:no_wait]
+        #88 wait unused in Adventureland/Pirate
+        #89 draw unused in Adventureland/Pirate
+        else raise "unimplemented instruction code #@op"
+        end
+        end
+        return false
+      end
+    end
+
+
+    class Action
+      def execute(test_chance)
+        all_conds_true = @conds.map { |x| t = x.evaluate
+          @game.dputs(:show_conditions, "  #{x.render()} -> #{t}"); t }.
+          reduce(true) { |acc, val| acc && val }
+        @game.dputs :show_conditions, "    #{all_conds_true}"
+        return :failconds if !all_conds_true
+
+        if (test_chance && @verb == 0) # It's an occurrence and may be random
+          dice = Integer(rand()*100)
+          if dice >= @noun
+            @game.dputs :show_random, "    #{dice} >= #{@noun}% -> nop"
+            return :success
+          else
+            @game.dputs :show_random, "    #{dice} < #{@noun}%"
+          end
+        end
+
+        args = @args.clone
+        seen_continue = @instructions.reduce(false) do |acc, x|
+          tmp = x.execute(args)
+          acc || tmp
+        end
+        seen_continue ? :continue : :success
+      end
+    end
+  end
+end

data/notes/Definition

@@ -0,0 +1,147 @@
+Game
+
+A game consists of a header of 12 values each apparently 16 bit
+
+0	Unknown
+1	Number of items
+2	Number of actions
+3	Number of Nouns and Verbs (one list is padded)
+4	Number of rooms
+5	Maximum a player can carry
+6	Starting Room
+7	Total Treasures (*)
+8	Word Length (only seen 3,4 or 5)
+9	Time light source lasts. This counts down every time item 9 is
+	in game. Brian Howarths games allow -1 for never run down. When
+	it runs out the light item (9) is dumped in room 0 and a look
+	done. Messages vary between interpreters and include things
+	like 'Your light is flickering and dying' as well as 
+	'Light runs out in %d turns'.
+10	Number of Messages
+11	Room you must put treasure in to score points. Not all games use
+	the treasure system for scoring
+
+All the number of something values are the last item to be read counting
+from 0. Thus 3 messages, means messages 0, 1, 2 and 3.
+
+(*) This can be calculated in game. What happens if the number is wrong
+I don't know. I've found no games that it occurs in.
+
+A game has 16 (maybe more) binary flags, and 8 (maybe more counters). A few
+later games seem to have 2 (maybe more) values to store location numbers in
+temporarily - eg Yoho spell in Claymorgue.  Flag 15 indicates whether
+it is dark, and flag 16 seems to get set when the lamp runs out.  No
+other flag has an intrinsic meaning.
+
+Following the header is a list of game actions. Each is of the form
+
+150*verb+noun
+5 repeats of condition+20*value
+150*action1+action2
+150*action3+action4
+
+Conditions
+
+0	<arg> is a parameter to one of the following actions
+1	Item <arg> carried
+2	Item <arg> in room with player
+3	Item <arg> carried or in room with player
+4	In room <arg>
+5	Item <arg> not in room with player
+6	Item <arg> not carried
+7	Not in room <arg>
+8	BitFlag <arg> is set. 
+9	BitFlag <arg> is cleared
+10	Something carried	(arg unused)
+11	Nothing carried		(arg unused)
+12	Item <arg> not carried nor in room with player
+13	Item <arg> is in game		[not in room 0]
+14	Item <arg> is not in game	[in room 0]
+15	CurrentCounter <= <arg>
+16	CurrentCounter > <arg>
+17	Object still in initial room (arg unused)
+18	Object not in initial room (arg unused)
+19	CurrentCounter = <arg>
+
+Actions.  <arg>s are taken from the values provided by
+pseudo-conditionals with op-code 0 in the same action.
+
+0	Does nothing
+1-51	Print message 1-51. Some drivers add a space some add a newline.
+        It does not seem to be possible to print message 0
+52	Get item <arg>. Checks if you can carry it first
+53	Drops item <arg>
+54	Moves to room <arg>
+55	Item <arg> is removed from the game (put in room 0)
+56	The darkness flag is set
+57	The darkness flag is cleared
+58	Bitflag <arg> is set
+59	The same as 55 (it seems - I'm cautious about this)
+60	BitFlag <arg> is cleared
+61	Death. Dark flag cleared, player moved to last room
+62	Item <arg1> put in room <arg2>
+63	Game over. 
+64	Describe room
+65	Score
+66	Inventory
+67	BitFlag 0 is set	
+68	BitFlag 0 is cleared
+69	Refill lamp (reset its time to live) and put it in player's inventory
+70	Screen is cleared. This varies by driver from no effect upwards
+71	Saves the game. Choices of filename etc depend on the driver alone.
+72	Swap item <arg1> and item <arg2> locations
+73	Continue: when finished with the current action, proceed to
+	attempt all subsequent actions that have both noun and verb
+	equal to 0 (subject to their conditions being satisfied).
+74	Take item <arg> - no check is done too see if it can be carried.
+75	Put item <arg1> with item <arg2> - Not certain seems to do this
+	from examination of Claymorgue
+76	Look (same as 64 ?? - check)
+77	Decrement current counter. Will not go below 0
+78	Print current counter value. Some drivers only cope with 0-99
+	apparently
+79	Set current counter value to <arg>
+80	Swap location with current location-swap flag
+81	Select a counter. Current counter is swapped with backup counter
+	<arg>
+82	Add <arg> to current counter
+83	Subtract <arg> from current counter
+84	Echo noun player typed without CR
+85	Echo the noun the player typed
+86	CR
+87	Swap current location value with backup location-swap value <arg>
+88	Wait 2 seconds
+89      SAGA - draw picture <n> (actually <n+number of rooms>, as each
+	Look() draws picture <room number> automatically)
+	Older spectrum driver - crashes
+	Spectrum Seas of Blood - seems to start Fighting Fantasy combat mode
+90-101  Unused
+102+	Print message 52-99
+
+
+This is followed by the words with verbs and nouns interleaved. A word with
+a * at the beginning is a synonym for the word above.
+Verb 1 is GO, verb 10 is GET, verb 18 is DROP (always).
+Nouns 1-6 are directions.
+
+This is followed by the rooms. Each room is 6 exits (north south east west
+up down) followed by a text string.
+
+Then come the messages, stored as a list of strings.
+
+Next come the items in the format item text then location. Item text may
+end with /TEXT/. This text is not printed but means that an automatic
+get/drop will be done for 'GET/DROP TEXT' on this item. Item names beginning
+with '*' are treasures. The '*' is printed. If you put all treasures in the
+treasure room (in the header) and 'SCORE' the game finishes with a well done
+message. Item location -1 is the inventory (255 on C64 and Spectrum tape
+games) and 0 means not in play in every game I've looked at. The lamp (always
+object 9) behaviour supports this belief.
+
+A set of strings follow this. In order they match to each line of verb/noun
+actions, and are comments. The Spectrum and C64 tape system where the
+database is compiled into the program has no comments.
+
+Finally three values follow which are version, adventure number and an
+unknown magic number. 
+

data/notes/Definition.saved-game

@@ -0,0 +1,9 @@
+ScottFree saved-game format, determined from source and a sample:
+
+counter0 roomsaved0
+...
+counter15 roomsaved15
+bitflags(as bigendian number) dark(redundant) loc counter savedroom lightleft
+item0.location
+...
+itemNitems.location