Commit for assignment5

Author: rjw366

rjw366/adventure/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>adventure</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.python.pydev.pythonNature</nature>
+	</natures>
+</projectDescription>

rjw366/adventure/.pydevproject

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?eclipse-pydev version="1.0"?><pydev_project>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
+</pydev_project>

rjw366/adventure/README.txt

@@ -0,0 +1,86 @@
+This is a faithful port of the “Adventure” game to Python 3 from the
+original 1977 FORTRAN code by Crowther and Woods (it is driven by the
+same ``advent.dat`` file!) that lets you explore Colossal Cave, where
+others have found fortunes in treasure and gold, though it is rumored
+that some who enter are never seen again.  Use your operating
+system command line to run the package::
+
+    $ python adventure.py
+    WELCOME TO ADVENTURE!!  WOULD YOU LIKE INSTRUCTIONS?
+
+    > no
+    YOU ARE STANDING AT THE END OF A ROAD BEFORE A SMALL BRICK BUILDING.
+    AROUND YOU IS A FOREST.  A SMALL STREAM FLOWS OUT OF THE BUILDING AND
+    DOWN A GULLY.
+
+    > east
+    YOU ARE INSIDE A BUILDING, A WELL HOUSE FOR A LARGE SPRING.
+    THERE ARE SOME KEYS ON THE GROUND HERE.
+    THERE IS A SHINY BRASS LAMP NEARBY.
+    THERE IS FOOD HERE.
+    THERE IS A BOTTLE OF WATER HERE.
+
+    > get lamp
+    OK
+
+    > leave
+    YOU'RE AT END OF ROAD AGAIN.
+
+    > south
+    YOU ARE IN A VALLEY IN THE FOREST BESIDE A STREAM TUMBLING ALONG A
+    ROCKY BED.
+
+The original Adventure paid attention to only the first five letters of
+each command, so a long command like ``inventory`` could simply be typed
+as ``inven``.  This package defines a symbol for both versions of every
+long word, so you can type the long or short version as you please.
+
+You can save your game at any time by calling the ``save`` command
+with a filename, and then can resume it later::
+
+    > save advent.save
+    GAME SAVED
+    > quit
+    DO YOU REALLY WANT TO QUIT NOW?
+    > y
+    OK
+
+    $ python -m adventure mygame
+    GAME RESTORED
+    > look
+    SORRY, BUT I AM NOT ALLOWED TO GIVE MORE DETAIL.  I WILL REPEAT THE
+    LONG DESCRIPTION OF YOUR LOCATION.
+    YOU ARE IN A VALLEY IN THE FOREST BESIDE A STREAM TUMBLING ALONG A
+    ROCKY BED.
+
+You can find two complete, working walkthroughs of the game in its
+``tests`` directory, which you can run using the ``discover`` module::
+
+    $ python -m unittest discover
+
+I wrote most of this package over Christmas vacation 2010, to learn more
+about the workings of the game that so enthralled me as a child; the
+project also gave me practice writing Python 3.  I still forget the
+parentheses when writing ``print()`` if I am not paying attention.
+
+For extra authenticity, the output of the Adventure game in this mode is
+typed to your screen at 1200 baud.  You will note that although this
+prints the text faster than you can read it anyway, your experience of
+the game will improve considerably, especially when a move results in a
+surprise.
+
+Why is the game better at 1200 baud?  When a paragraph of text is
+allowed to appear on the screen all at once, your eyes scan the entire
+paragraph for important information, often ruining any surprises before
+you can then settle down and read it from the beginning.  But at 1200
+baud, you wind up reading the text in order as it appears, which unfolds
+the narrative sequentially as the author of Adventure intended.
+
+Changelog
+=========
+
+| 1.3 — 2012 April 27 — installs on Windows; fixed undefined commands
+| 1.2 — 2012 April 5 — restoring saves from command line; 5-letter commands
+| 1.1 — 2011 March 12 — traditional mode; more flexible Python syntax
+| 1.0 — 2011 February 15 — 100% test coverage, feature-complete
+| 0.3 — 2011 January 31 — first public release

rjw366/adventure/TODO.txt

@@ -0,0 +1,3 @@
+
+* Test whether climbing down the dome with the gold nugget breaks your neck.
+* Test dropping into the secret canyon from the direction that gets no dragon.

rjw366/adventure/__init__.py

@@ -0,0 +1,46 @@
+"""Offer Adventure at a custom command prompt."""
+
+import argparse
+import os
+import re
+from sys import executable, stdout
+from time import sleep
+from play import load_advent_dat
+from game import Game
+
+BAUD = 1200
+
+def baudout(s):
+    for c in s:
+        sleep(9. / BAUD)  # 8 bits + 1 stop bit @ the given baud rate
+        stdout.write(c)
+        stdout.flush()
+
+def loop():
+    parser = argparse.ArgumentParser(
+        description='Adventure into the Colossal Caves.',
+        prog='{} -m adventure'.format(os.path.basename(executable)))
+    parser.add_argument(
+        'savefile', nargs='?', help='The filename of game you have saved.')
+    args = parser.parse_args()
+
+    if args.savefile is None:
+        game = Game()
+        load_advent_dat(game)
+        game.start()
+        baudout(game.output)
+    else:
+        game = Game.resume(args.savefile)
+        baudout('GAME RESTORED\n')
+
+    while not game.is_finished:
+        line = raw_input('> ')
+        words = re.findall(r'\w+', line)
+        if words:
+            baudout(game.do_command(words))
+
+if __name__ == "__main__":
+    try:
+        loop()
+    except EOFError:
+        pass

rjw366/adventure/advent.dat

@@ -0,0 +1,225 @@
+"""Parse the original PDP ``advent.dat`` file."""
+
+from operator import attrgetter
+from model import Hint, Message, Move, Object, Room, Word
+
+# The Adventure data file knows only the first five characters of each
+# word in the game, so we have to know the full verion of each word.
+
+long_words = { w[:5]: w for w in """upstream downstream forest
+forward continue onward return retreat valley staircase outside building stream
+cobble inward inside surface nowhere passage tunnel canyon awkward
+upward ascend downward descend outdoors barren across debris broken
+examine describe slabroom depression entrance secret bedquilt plover
+oriental cavern reservoir office headlamp lantern pillow velvet fissure tablet
+oyster magazine spelunker dwarves knives rations bottle mirror beanstalk
+stalactite shadow figure drawings pirate dragon message volcano geyser
+machine vending batteries carpet nuggets diamonds silver jewelry treasure
+trident shards pottery emerald platinum pyramid pearl persian spices capture
+release discard mumble unlock nothing extinguish placate travel proceed
+continue explore follow attack strike devour inventory detonate ignite
+blowup peruse shatter disturb suspend sesame opensesame abracadabra
+shazam excavate information""".split() }
+
+class Data(object):
+    def __init__(self):
+        self.rooms = {}
+        self.vocabulary = {}
+        self.objects = {}
+        self.messages = {}
+        self.class_messages = []
+        self.hints = {}
+        self.magic_messages = {}
+
+    def referent(self, word):
+        if word.kind == 'noun':
+            return self.objects[word.n % 1000]
+
+# Helper functions.
+
+def make_object(dictionary, klass, n):
+    if n not in dictionary:
+        dictionary[n] = obj = klass()
+        obj.n = n
+    return dictionary[n]
+
+def expand_tabs(segments):
+    it = iter(segments)
+    line = next(it)
+    for segment in it:
+        spaces = 8 - len(line) % 8
+        line += ' ' * spaces + segment
+    return line
+
+def accumulate_message(dictionary, n, line):
+    dictionary[n] = dictionary.get(n, '') + line + '\n'
+
+# Knowledge of what each section contains.
+
+def section1(data, n, *etc):
+    room = make_object(data.rooms, Room, n)
+    if not etc[0].startswith('>$<'):
+        room.long_description += expand_tabs(etc) + '\n'
+
+def section2(data, n, line):
+    make_object(data.rooms, Room, n).short_description += line + '\n'
+
+def section3(data, x, y, *verbs):
+    last_travel = data._last_travel
+    if last_travel[0] == x and last_travel[1][0] == verbs[0]:
+        verbs = last_travel[1]  # same first verb implies use whole list
+    else:
+        data._last_travel = [x, verbs]
+
+    m, n = divmod(y, 1000)
+    mh, mm = divmod(m, 100)
+
+    if m == 0:
+        condition = (None,)
+    elif 0 < m < 100:
+        condition = ('%', m)
+    elif m == 100:
+        condition = ('not_dwarf',)
+    elif 100 < m <= 200:
+        condition = ('carrying', mm)
+    elif 200 < m <= 300:
+        condition = ('carrying_or_in_room_with', mm)
+    elif 300 < m:
+        condition = ('prop!=', mm, mh - 3)
+
+    if n <= 300:
+        action = make_object(data.rooms, Room, n)
+    elif 300 < n <= 500:
+        action = n  # special computed goto
+    else:
+        action = make_object(data.messages, Message, n - 500)
+
+    move = Move()
+    if len(verbs) == 1 and verbs[0] == 1:
+        move.is_forced = True
+    else:
+        move.verbs = [ make_object(data.vocabulary, Word, verb_n)
+                       for verb_n in verbs if verb_n < 100 ] # skip bad "109"
+    move.condition = condition
+    move.action = action
+    data.rooms[x].travel_table.append(move)
+
+def section4(data, n, text, *etc):
+    text = text.lower()
+    text = long_words.get(text, text)
+    word = make_object(data.vocabulary, Word, n)
+    if word.text is None:  # this is the first word with index "n"
+        word.text = text
+    else:  # there is already a word sitting at "n", so create a synonym
+        original = word
+        word = Word()
+        word.n = n
+        word.text = text
+        original.add_synonym(word)
+    word.kind = ['travel', 'noun', 'verb', 'snappy_comeback'][n // 1000]
+    if word.kind == 'noun':
+        n %= 1000
+        obj = make_object(data.objects, Object, n)
+        obj.names.append(text)
+        obj.is_treasure = (n >= 50)
+        data.objects[text] = obj
+    if text not in data.vocabulary:  # since duplicate names exist
+        data.vocabulary[text] = word
+
+def section5(data, n, *etc):
+    if 1 <= n <= 99:
+        data._object = make_object(data.objects, Object, n)
+        data._object.inventory_message = expand_tabs(etc)
+    else:
+        n /= 100
+        messages = data._object.messages
+        if etc[0].startswith('>$<'):
+            more = ''
+        else:
+            more = expand_tabs(etc) + '\n'
+        messages[n] = messages.get(n, '') + more
+
+def section6(data, n, *etc):
+    message = make_object(data.messages, Message, n)
+    message.text += expand_tabs(etc) + '\n'
+
+def section7(data, n, room_n, *etc):
+    if not room_n:
+        return
+    obj = make_object(data.objects, Object, n)
+    room = make_object(data.rooms, Room, room_n)
+    obj.drop(room)
+    if len(etc):
+        if etc[0] == -1:
+            obj.is_fixed = True
+        else:
+            room2 = make_object(data.rooms, Room, etc[0])
+            obj.rooms.append(room2)  # exists two places, like grate
+    obj.starting_rooms = list(obj.rooms)  # remember where things started
+
+def section8(data, word_n, message_n):
+    if not message_n:
+        return
+    word = make_object(data.vocabulary, Word, word_n + 2000)
+    message = make_object(data.messages, Message, message_n)
+    for word2 in word.synonyms:
+        word2.default_message = message
+
+def section9(data, bit, *nlist):
+    for n in nlist:
+        room = make_object(data.rooms, Room, n)
+        if bit == 0:
+            room.is_light = True
+        elif bit == 1:
+            room.liquid = make_object(data.objects, Object, 22) #oil
+        elif bit == 2:
+            room.liquid = make_object(data.objects, Object, 21) #water
+        elif bit == 3:
+            room.is_forbidden_to_pirate = True
+        else:
+            hint = make_object(data.hints, Hint, bit)
+            hint.rooms.append(room)
+
+def section10(data, score, line, *etc):
+    data.class_messages.append((score, line))
+
+def section11(data, n, turns_needed, penalty, question_n, message_n):
+    hint = make_object(data.hints, Hint, n)
+    hint.turns_needed = turns_needed
+    hint.penalty = penalty
+    hint.question = make_object(data.messages, Message, question_n)
+    hint.message = make_object(data.messages, Message, message_n)
+
+def section12(data, n, line):
+    accumulate_message(data.magic_messages, n, line)
+
+# Process every section of the file in turn.
+
+def parse(data, datafile):
+    """Read the Adventure data file and return a ``Data`` object."""
+    data._last_travel = [0, [0]]  # x and verbs used by section 3
+
+    while True:
+        section_number = int(datafile.readline())
+        if not section_number:  # no further sections
+            break
+        store = globals().get('section%d' % section_number)
+        while True:
+            fields = [ (int(field) if field.lstrip('-').isdigit() else field)
+                       for field in datafile.readline().strip().split('\t') ]
+            if fields[0] == -1:  # end-of-section marker
+                break
+            store(data, *fields)
+
+    del data._last_travel  # state used by section 3
+    del data._object       # state used by section 5
+
+    data.object_list = sorted(set(data.objects.values()), key=attrgetter('n'))
+    #data.room_list = sorted(set(data.rooms.values()), key=attrgetter('n'))
+    for obj in data.object_list:
+        name = obj.names[0]
+        if hasattr(data, name):
+            name = name + '2'  # create identifiers like ROD2, PLANT2
+        setattr(data, name, obj)
+
+    return data