#! /ufs/guido/bin/sgi/python

# Module 'adv' -- text-oriented adventure game.


# Name a constant that may once appear in the language...

def return_nil(): return
nil = return_nil()


# Copy of string.split() (to avoid loading all of string.py)

whitespace = ' \t\n'
def split(s):
	res = []
	i, n = 0, len(s)
	while i < n:
		while i < n and s[i] in whitespace: i = i+1
		if i = n: break
		j = i
		while j < n and s[j] not in whitespace: j = j+1
		res.append(s[i:j])
		i = j
	return res


# Constants to name directions

N = 'north'
S = 'south'
W = 'west'
E = 'east'
U = 'up'
D = 'down'
NW = 'nw'
NE = 'ne'
SW = 'sw'
SE = 'se'


# Constants to name other commands

INVENT = 'invent'
LOOK = 'look'
BACK = 'back'
HELP = 'help'
GET = 'get'
PUT = 'put'


# Aliases recognized by the parser

alias = {}
alias['n'] = N
alias['s'] = S
alias['e'] = E
alias['w'] = W
alias['u'] = U
alias['d'] = D
alias['i'] = INVENT
alias['l'] = LOOK
alias['b'] = BACK
alias['take'] = GET
alias['drop'] = PUT


# Normalize a command, in place: truncate words to 6 chars, and expand aliases.

def normalize(cmd):
	for i in range(len(cmd)):
		word = cmd[i][:6]
		if alias.has_key(word):
			word = alias[word]
		cmd[i] = word


# The Object class describes objects that the player can carry around.

class Object():
	def init(this, name):
		this.name = name
		return this
	def describe(this):
		print 'A', this.name + '.'
	def get(this, (player, room)):
		del room.objects[this.name]
		player.objects[this.name] = this
	def put(this, (player, room)):
		del player.objects[this.name]
		room.objects[this.name] = this


# The Player class embodies first person control.

class Player():
	# Set initial state, except current room.
	def init(self, initial_room):
		self.blind = 0
		self.here = initial_room
		self.prev = nil
		self.objects = {}
		return self
	# Read and execute commands forever.
	def play(self):
		self.here.casualdescribe()
		while 1:
			self.move()
	# Read and execute one command.
	def move(self):
		next = self.here.parser()
		if next and next <> self.here:
			self.prev = self.here
			self.here = next
			if not self.blind:
				self.here.casualdescribe()
	# Print inventory.
	def inventory(self):
		if not self.objects:
			print 'You aren\'t carrying anything.'
			return
		print 'You are carrying:'
		for key in self.objects.keys():
			self.objects[key].describe()
	# Go back to previous room.
	def back(self):
		if self.prev: return self.prev
		print 'You can\'t go back now.'
	# Get an object from the room.
	def get(self, name):
		if self.here.objects.has_key(name):
			self.here.objects[name].get(self, self.here)
		else:
			print 'I see no', name, 'here.'
	# Put an object in the room.
	def put(self, name):
		if self.objects.has_key(name):
			self.objects[name].put(self, self.here)
		else:
			print 'You have no', name, 'with you.'


# The Room class describes a generic room.
# Rooms with special properties are defined by derived classes
# that override certain operations.

class Room():
	# Initialize a featureless room.
	def init(here, name):
		here.seen = 0
		here.name = name
		here.exits = {}
		here.objects = {}
		here.description = []
		return here
	# Add an object to the room.  Used during initialization.
	def add(here, obj):
		here.objects[obj.name] = obj
	# Print a casual description.
	def casualdescribe(here):
		if here.seen:
			print here.name + '.'
			here.listobjects()
			return
		here.seen = 1
		here.describe()
	# Print a full description, including all exits and objects seen.
	def describe(here):
		if not here.description:
			print here.name + '.'
			here.listexits()
		else:
			for line in here.description: print line
		here.listobjects()
	# List exits.
	def listexits(here):
		there = here.exits.keys()
		if there:
			if len(there) = 1:
				print 'There is an exit leading',
			else:
				print 'There are exits leading',
				for name in there[:-2]:
					print name + ',',
				print there[len(there)-2], 'and',
			print there[len(there)-1] + '.'
	# List objects
	def listobjects(here):
		if here.objects:
			print 'I see:'
			for key in here.objects.keys():
				here.objects[key].describe()
	# Default parser.  Returns next room (possibly the same) or nil.
	def parser(here):
		cmd = here.getcmd(here.prompt())
		return here.decide(cmd)
	# Return default prompt string.
	def prompt(here): return '> '
	# Default input routine.  Returns a non-empty list of words.
	def getcmd(here, prompt):
		# Loop until non-empty command gotten
		# EOFError and KeyboardInterrupt may be caught elsewhere
		while 1:
			line = raw_input(prompt)
			cmd = split(line)
			if cmd:
				normalize(cmd)
				return cmd
	# Default decision routine.  Override for room-specific commands.
	def decide(here, cmd):
		key, args = cmd[0], cmd[1:]
		if not args:
			if key = N:		return here.north()
			if key = S:		return here.south()
			if key = E:		return here.east()
			if key = W:		return here.west()
			if key = U:		return here.up()
			if key = D:		return here.down()
			if key = NW:		return here.nw()
			if key = NE:		return here.ne()
			if key = SW:		return here.sw()
			if key = SE:		return here.se()
			if key = LOOK:		return here.look()
			if key = INVENT:	return here.inventory()
			if key = BACK:		return here.back()
			if here.objects.has_key(key):
				print 'What do you want to do with the', key+'?'
			else:
				print 'Huh?'
			return
		if key = GET:
			for arg in args:
				player.get(arg)
			return
		if key = PUT:
			for arg in args:
				player.put(arg)
	# Standard commands.
	def look(here):
		here.describe()
	def inventory(here):
		player.inventory()
	def back(here):
		return player.back()
	# Standard exits.
	def north(here):	return here.take_exit(N)
	def south(here):	return here.take_exit(S)
	def west(here):		return here.take_exit(W)
	def east(here):		return here.take_exit(E)
	def up(here):		return here.take_exit(U)
	def down(here):		return here.take_exit(D)
	def nw(here):		return here.take_exit(NW)
	def ne(here):		return here.take_exit(NE)
	def sw(here):		return here.take_exit(SW)
	def se(here):		return here.take_exit(SE)
	# Subroutine for standard exits.
	def take_exit(here, key):
		if here.exits.has_key(key):
			return here.exits[key]
		print 'You cannot go in that direction.'
		return here


# Create the objects we know about.
# Object names begin with 'o_'.

o_lamp = Object().init('lamp')
o_python = Object().init('python')


# Subroutine to connect two rooms.

def connect(rm1, rm2, dir1, dir2):
	if dir1:
		rm1.exits[dir1] = rm2
	if dir2:
		rm2.exits[dir2] = rm1


# Create the rooms and connect them together.
# Room names begin with 'r_'.

r_front = Room().init('Front of building')
r_initial = r_front
r_front.description = [ \
	'You are standing in front of a large, desolate building.', \
	'Huge neon letters spell "CWI".  The "I" is blinking.', \
	'There are entrances north and west from where you are standing.', \
	]

r_entrance = Room().init('Entrance')
r_entrance.description = [ \
	'You are standing in a small entrance room.', \
	'On the east side is a window to a reception room.', \
	'South is a door leading outside the building.', \
	'North is a large hall.' \
	] 

r_hall_s = Room().init('South of hall')
r_hall_s.description = [ \
	'You are standing at the south side of a very large hall.', \
	'There are doors leading west, southwest, south and southeast,', \
	'and a corridor leads east.', \
	'The hall continues to the north.' \
	]

r_hall_n = Room().init('North of hall')
r_hall_n.description = [ \
	'You are stanting at the north side of a very large hall.', \
	'There are corridors leading west, northwest, northeast,', \
	'an elevator door north, and a door leading outside east.', \
	'There are stairs leading up, and the hall continues to the south.' \
	]

r_reception = Room().init('Reception')

r_mail = Room().init('Mail room')

connect(r_front, r_entrance, N, S)
connect(r_entrance, r_hall_s, N, SW)
connect(r_hall_s, r_hall_n, N, S)
connect(r_hall_s, r_reception, S, N)
connect(r_hall_s, r_mail, SE, N)
connect(r_reception, r_mail, E, W)

r_aud_front = Room().init('Front of Auditorium')
r_aud_back = Room().init('Back of Auditorium')
r_aud_tech = Room().init('Technician\'s room in Auditorium')
r_aud_proj = Room().init('Projection room in Auditorium')

connect(r_aud_front, r_hall_s, E, W)
connect(r_aud_front, r_aud_back, S, N)
connect(r_aud_back, r_aud_proj, SE, N)
connect(r_aud_front, r_aud_tech, W, E)

r_floor1 = Room().init('First floor')
r_floor2 = Room().init('Second floor')
r_floor3 = Room().init('Third floor')

connect(r_hall_n, r_floor1, U, D)
connect(r_floor1, r_floor2, U, D)
connect(r_floor2, r_floor3, U, D)


# Drop objects here and there

r_aud_proj.add(o_python)
r_reception.add(o_lamp)

# Create an uninitialized player object.
# It is initialized by main(), but must be created here (as global)
# since some Room methods reference it.  (Though maybe they shouldn't?)

player = Player()


# Play the game from the beginning.

def main():
	x = player.init(r_initial)
	try:
		player.play()
	except (EOFError, KeyboardInterrupt):
		pass

main()