scottkit 0.0.0

data/notes/Definition.scottfree-1.14

@@ -0,0 +1,142 @@
+Game
+
+A game consists of a header of 14 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
+12	Unknown
+
+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.
+
+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	Parameter
+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
+18	Object not in initial room
+19	CurrentCounter = <arg>
+
+Actions
+
+0	Does nothing
+1-51	Print message 0-50. Some drivers add a space some add a newline.
+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 <arg> put in room <arg>
+63	Game over. 
+64	Describe room
+65	Score
+66	Inventory
+67	BitFlag 0 is set	
+68	BitFlag 0 is cleared
+69	Refill lamp (?)
+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 with next line (the next line starts verb 0 noun 0)
+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
+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 51-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/adventureland-maze

@@ -0,0 +1,20 @@
+Location	Marker		Exits
+				N	S	E	W	U	D
+-------------------------------------------------------------------------------
+Cavern				N/A	N/A	N/A	N/A	N/A	SIGN
+SIGN		sign		WU	NEWU	NEWU	--	--	WU
+NEWU				SIGN	--	WU	SIGN	WU	--
+WU				--	--	--	SCRATCH	SIGN	--
+SCRATCH		scratchings	ARROW	SIGN	WU	SUD	SUD	ARROW
+SUD				--	ARROW	--	--	SCRATCH	ARROW
+ARROW		arrow, *rug*	ARROW	SIGN	SIGN	NEWU	SCRATCH	LAVA
+LAVA		lava, *net*	--	--	--	--	ARROW	--
+
+From cavern to lava:
+d
+d
+w
+d
+get rug
+d
+get net

data/notes/continue-action

@@ -0,0 +1,51 @@
+How the "continue" action works.  By inspection of Adventureland,
+there is only one instance of it there:
+
+	action DRO WAT when carried bottle and at room1 {
+	  print "Sizzle..."
+	  continue
+	  swap bottle bottle1
+	}
+
+	occur when here FIRESTONE {
+	  swap now FIRESTONE
+	}
+
+This is illuminating.  First, continue doesn't have to be the last
+instruction in an action: so it doesn't mean "proceed with the next
+action", it means "note that when you're done with this action that
+you may continue to the next".  Second, note that the second action
+has a condition which must be met, so the continue also doesn't mean
+"actually do the next action", but "evaluate whether the next action
+should be done".  (That's why the continue is used here: the second
+set of instructions should be executed only if the second condition is
+true as well as the first.)  The probability associated with follow-on
+actions is ignored, though (and is probably always zero, to prevent
+those actions firing in other circumstances).
+
+Because conditions are still checked for actions reached by continue,
+we can not fold actions linked by continue into a single long action
+with multiple instructions, as tempting as that sounds.
+
+--
+
+More: it's apparent from Voodoo Castle that a continue action means
+not just to attempt the next action, but ALL subsequent actions that
+have verb and noun both equal to zero.  Here is the decompilation of
+the code for examining the Count:
+
+	action LOO COF when here Coffin1
+		print "A sign here says:"
+		print "Count Cristo's been CURSED! [...]"
+		continue
+		print "There's a man here"
+
+	occur 0% when !exists foot
+		print "He's wearing a rabbit's foot"
+
+	occur 0% when !exists ring
+		print "Wearing a sapphire ring"
+
+At the start of the game, the rabbit's foot exists (elsewhere) and the
+ring does not, so the first occur does not fire but the second does.
+

data/test/test_canonicalise.rb

@@ -0,0 +1,94 @@
+require 'test/unit'
+require 'scottkit/game'
+require 'stringio'
+require_relative 'withio'
+
+# The idea here is that we can start with a source file and compile it
+# once.  Decompiling the result will of course yield a different
+# source file (for example, comments will be discarded) but
+# recompiling the decompiled source should yield identical output to
+# that generated by the initial compilation.
+
+class TestCanonicalise < Test::Unit::TestCase #:nodoc:
+  def test_1canonicalise_tutorials
+    1.upto(7) { |i| canonicalise("tutorial/t#{i}.sck", :source) }
+  end
+
+  def test_2canonicalise_crystal
+    canonicalise("crystal/crystal.sck", :source)
+  end
+    
+  def test_3canonicalise_adams
+    %w{
+      adv01
+      adv02
+      adv03
+      adv04
+      adv05
+      adv06
+      adv07
+      adv08
+      adv09
+      adv10
+      adv11
+      adv12
+      adv13
+      adv14a
+      *adv14b
+      quest1
+      quest2
+      sampler1
+    }.each do |x|
+      options = {}
+      if x[0] == "*"
+        x[0] = ""
+        options[:bug_tolerant] = true
+      end
+      canonicalise("adams/#{x}.dat", :object, options) 
+    end
+  end
+
+  def canonicalise(name, type, options = {})
+    #puts "#{name}: options=#{options}"
+    filename = "data/#{name}"
+
+    if !File::readable?(filename)
+      if self.respond_to? :skip
+        skip "no game file #{filename}"
+      else
+        # Crappy older version of Test::Unit
+        puts "skipping '#{name}' because no filename"
+      end
+      return
+    end
+
+    if type == :source
+      source1 = IO.read(filename)
+    else
+      object0 = IO.read(filename)
+      source1 = decompile(object0, options)
+    end
+    object1 = compile(source1, options)
+    source2 = decompile(object1, options)
+    object2 = compile(source2, options)
+    assert_equal(object2, object1)
+  end
+
+  def compile(source, options)
+    game = ScottKit::Game.new(options)
+    f = StringIO.new
+    withIO(nil, f) do
+      game.compile_to_stdout(nil, StringIO.new(source)) or
+        raise "couldn't compile"
+    end
+    f.string
+  end
+
+  def decompile(object, options)
+    game = ScottKit::Game.new(options)
+    game.load(object)
+    f = StringIO.new()
+    game.decompile(f)
+    f.string
+  end
+end

data/test/test_compile.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require 'scottkit/game'
+require 'stringio'
+require_relative 'withio'
+
+class TestCompile < Test::Unit::TestCase #:nodoc:
+  EXPECTED = [
+              # Token,      Lexeme
+              [ :room ],
+              [ :symbol,    "chamber" ],
+              [ :symbol,    "square chamber" ],
+              [ :exit ],
+              [ :direction, "east" ],
+              [ :symbol,    "dungeon" ],
+              [ :room ],
+              [ :symbol,    "dungeon" ],
+              [ :symbol,    "gloomy dungeon" ],
+              [ :exit ],
+              [ :direction, "west" ],
+              [ :symbol,    "chamber" ],
+              [ :eof ],
+             ];
+
+  def test_lexer
+    game = ScottKit::Game.new({})
+    lexer = ScottKit::Game::Compiler::Lexer.new(game, "data/tutorial/t1.sck")
+    EXPECTED.each do |x| token, lexeme = *x
+      got = lexer.lex
+      assert_equal(token, got)
+      assert_equal(lexeme, lexer.lexeme) if lexeme
+    end
+  end
+
+  def test_parser
+    game = ScottKit::Game.new({})
+    # It's a clumsy API, but then we're peeking where we're not invited
+    compiler = ScottKit::Game::Compiler.new(game, "data/tutorial/t6.sck")
+    tree = compiler.parse
+    got = tree.pretty_inspect
+    expected = File.read("data/test/t6.pretty-print")
+    # Remove hex object addresses from pretty-printed trees
+    assert_equal(got.gsub(/0x\h+/, ""), expected.gsub(/0x\h+/, ""))
+  end
+
+  def test_code_generator
+    game = ScottKit::Game.new({})
+    f = StringIO.new
+    withIO(nil, f) do
+      game.compile_to_stdout("data/test/crystal.sck") or
+        raise "couldn't compile crystal.sck"
+    end
+    assert_equal(f.string, File.read("data/test/crystal.sao"))
+  end
+end

data/test/test_decompile.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require 'scottkit/game'
+require 'stringio'
+
+class TestDecompile < Test::Unit::TestCase #:nodoc:
+  def test_decompile_crystal
+    game = ScottKit::Game.new({})
+    game.load(IO.read("data/test/crystal.sao"))
+    f = StringIO.new()
+    game.decompile(f)
+    assert_equal(f.string, File.read("data/test/crystal.decompile"))
+  end
+end

data/test/test_play.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'scottkit/game'
+require 'stringio'
+require_relative 'withio'
+
+class TestPlay < Test::Unit::TestCase #:nodoc:
+  def test_play_tutorial7; play("t7"); end
+  def test_play_crystal; play("crystal"); end
+
+  def play(name)
+    game = ScottKit::Game.new({ :read_file =>
+                                "data/test/#{name}.solution",
+                                :random_seed => 12368, :no_wait => true })
+    game.load(IO.read("data/test/#{name}.sao"))
+    f = StringIO.new
+    withIO(nil, f) { game.play }
+    expected = File.read("data/test/#{name}.transcript")
+    assert_equal(expected, f.string)
+  end
+end

data/test/test_playadams.rb

@@ -0,0 +1,36 @@
+require 'test/unit'
+require 'scottkit/game'
+require 'stringio'
+require 'digest/md5'
+require_relative 'withio'
+
+class TestPlayAdams < Test::Unit::TestCase #:nodoc:
+  def test_play_adams
+    %w{01 02 04}.each do |num|
+      play("adv#{num}")
+    end
+  end
+
+  def play(name)
+    gamefile = "data/adams/#{name}.dat"
+
+    if(File::readable?(gamefile))
+      game = ScottKit::Game.new({ :read_file =>
+                                  "data/test/adams/#{name}.solution",
+                                  :random_seed => 12368, :no_wait => true })
+      game.load(IO.read gamefile)
+      f = StringIO.new
+      withIO(nil, f) { game.play }
+      digest = Digest::MD5.hexdigest(f.string)
+      expected = File.read("data/test/adams/#{name}.transcript.md5").chomp
+      assert_equal(expected, digest)
+    else
+      if self.respond_to? :skip
+        skip "no game file #{gamefile}"
+      else
+        # Crappy older version of Test::Unit
+        puts "skipping '#{name}' because no gamefile"
+      end
+    end
+  end
+end

data/test/test_save.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'scottkit/game'
+require 'stringio'
+require_relative 'withio'
+
+class TestSave < Test::Unit::TestCase #:nodoc:
+  # Can't use a setup() method here as the two test-cases need the
+  # games to be initialised with different options.
+
+  def test_save_crystal
+    game = ScottKit::Game.new({ :random_seed => 12368, :echo_input => true })
+    game.load(IO.read("data/test/crystal.sao"))
+    withIO(File.new("data/test/crystal.save-script"), 
+           File.new("/dev/null", "w")) do
+      game.play()
+    end
+    assert_equal(File.read("TMP"), File.read("data/test/crystal.save-file"))
+    File.unlink "TMP"
+  end
+
+  def test_resave_crystal
+    game = ScottKit::Game.new({ :random_seed => 12368, :echo_input => true,
+        :restore_file => "data/test/crystal.save-file" })
+    game.load(IO.read("data/test/crystal.sao"))
+    withIO(StringIO.new("save game\nTMP"), File.new("/dev/null", "w")) do
+      game.play()
+    end
+    assert_equal(File.read("TMP"), File.read("data/test/crystal.save-file"))
+    File.unlink "TMP"
+  end
+end

data/test/withio.rb

@@ -0,0 +1,15 @@
+# Provides a utility method withIO() used by several test-cases.  Runs
+# the specified block with stdin and stdout replumbed to the provided
+# file-handles; the old values of stdin and stdout are passed to the
+# block, in case they should be needed.
+
+def withIO(newin, newout)
+  old_STDIN = $stdin
+  old_STDOUT = $stdout
+  $stdin = newin
+  $stdout = newout
+  yield old_STDIN, old_STDOUT
+ensure
+  $stdin = old_STDIN
+  $stdout = old_STDOUT
+end

data/test/withio_test.rb

@@ -0,0 +1,31 @@
+#!/usr/local/bin/ruby1.9 -w
+
+# Run as: echo Bart Lisa | ./withio_test.rb && echo == && cat /tmp/xcv
+# Expecting the output:
+#	first line is 'Bart Lisa'
+#	saved line 'Eric'
+#	died in withIO: divided by 0
+#	saved line was 'Eric'
+#	==
+#	first line was 'Bart Lisa'
+#	oldout is of class IO
+
+require 'stringio'
+require_relative 'withio'
+
+saved = nil
+begin
+  line = gets
+  puts "first line is '#{line.chomp}'"
+  withIO(StringIO.new("Eric\nthe"), File.new("/tmp/xcv", "w")) do
+    |oldin, oldout|
+    puts "first line was '#{line.chomp}'"
+    puts "oldout is of class #{oldout.class}"
+    saved = gets
+    oldout.puts "saved line '#{saved.chomp}'"
+    puts 1/0
+  end
+rescue Exception => e
+  puts "died in withIO: #{e}"
+end
+puts "saved line was '#{saved.chomp}'"

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: scottkit
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Mike Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-28 00:00:00 +00:00
+default_executable: scottkit
+dependencies: []
+
+description: "TODO: longer description of your gem"
+email: mike@miketaylor.org.uk
+executables: 
+- scottkit
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- GPL-2
+- Makefile
+- README
+- Rakefile
+- VERSION
+- bin/scottkit
+- bin/scottkit.rb
+- data/.gitignore
+- data/adams/.gitignore
+- data/adams/AdamsGames.zip
+- data/adams/Makefile
+- data/crystal/crystal.map
+- data/crystal/crystal.sck
+- data/crystal/crystal.solution
+- data/dan-and-matt.sck
+- data/dan-and-matt.solution
+- data/howarth/.gitignore
+- data/howarth/Makefile
+- data/howarth/mysterious.tar.gz
+- data/test/Makefile
+- data/test/adams/Makefile
+- data/test/adams/adv01.solution
+- data/test/adams/adv01.transcript
+- data/test/adams/adv01.transcript.md5
+- data/test/adams/adv02.solution
+- data/test/adams/adv02.transcript
+- data/test/adams/adv02.transcript.md5
+- data/test/adams/adv04.solution
+- data/test/adams/adv04.transcript
+- data/test/adams/adv04.transcript.md5
+- data/test/crystal.decompile
+- data/test/crystal.sao
+- data/test/crystal.save-file
+- data/test/crystal.save-script
+- data/test/crystal.sck
+- data/test/crystal.solution
+- data/test/crystal.transcript
+- data/test/t6.pretty-print
+- data/test/t7.sao
+- data/test/t7.solution
+- data/test/t7.transcript
+- data/tutorial/t1.sck
+- data/tutorial/t2.sck
+- data/tutorial/t3.sck
+- data/tutorial/t4.sck
+- data/tutorial/t5.sck
+- data/tutorial/t6.sck
+- data/tutorial/t7.sck
+- lib/scottkit/compile.rb
+- lib/scottkit/decompile.rb
+- lib/scottkit/game.rb
+- lib/scottkit/play.rb
+- notes/Definition
+- notes/Definition.saved-game
+- notes/Definition.scottfree-1.14
+- notes/adventureland-maze
+- notes/continue-action
+- test/test_canonicalise.rb
+- test/test_compile.rb
+- test/test_decompile.rb
+- test/test_play.rb
+- test/test_playadams.rb
+- test/test_save.rb
+- test/withio.rb
+- test/withio_test.rb
+has_rdoc: true
+homepage: http://www.miketaylor.org.uk/tech/advent/scottkit/
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: ScottKit is a toolkit for compiling, decompiling and playing adventure games in the Scott Adams format.
+test_files: []
+