def execute(self):
"""
Uses potion in inventory to heal player.
"""
#Check that potions in inventory
inventory = self._player.getInventory()
potions = ItemSet()
for item in inventory:
if isinstance(item, Potion):
potions.addItem(item)
if potions.count() == 0:
print "%s has no potions." % self._player.getName()
return
#User prompt
print "%s currently has:" % self._player.getName()
for potion in potions:
print "\t%s with %s healing power." % (potion.getName(),
potion.getHealing())
print ""
choice = None
while True:
choice = raw_input("Which potion would you like to use? ")
if potions.containsItemWithName(choice):
break
else:
print "%s does not have that potion." % self._player.getName()
print ""
#Healing mechanics
potionChoice = potions.getItemByName(choice)
healing = potionChoice.getHealing()
preHealedHealth = self._player.getHp()
self._player.heal(healing)
postHealedHealth = self._player.getHp()
healed = postHealedHealth - preHealedHealth
inventory.removeItem(potionChoice)
print "%s was healed by %s! %s's health is now %s." \
% (self._player.getName(), healed, self._player.getName(),
self._player.getHp())
class Space(object):
"""
A given location on the map. Connects with other spaces
to form larger geographic areas.
"""
def __init__(self, name, description, region, battleProbability = 0,
battleBonusDifficulty = 0, items = None, city = None, uniquePlace = None):
"""
Initialize a Space object.
@param name: Name of space.
@param description: Description of space.
@param battleProbability: Probability between [0, 1] that a
random battle will occur between
successive game command executions.
@param battleBonusDifficulty: Probability between [0, 1] that is used
to determine battle bonus difficulty.
This stat results in a percentage
increase over default monster stats and
number for any given space.
For instance, if bonus difficulty is
set to .5, space will spawn 50% more
monsters with 150% base stats.
@keyword items: (Optional) Items found in the space.
May be a reference to a single item or
an ItemSet.
@keyword city: (Optional) City objects in space. May
be a reference to an individual object
or a list.
@keyword uniquePlace: (Optional) Reference to unique places
in space. May be a reference to an
individual object or a list.
"""
self._exits = {Direction.NORTH : None,
Direction.SOUTH : None,
Direction.EAST : None,
Direction.WEST : None}
self._name = name
self._description = description
self._region = region
self._battleProbability = battleProbability
self._battleBonusDifficulty = battleBonusDifficulty
self._items = ItemSet()
self._city = city
self._uniquePlace = uniquePlace
def getName(self):
"""
Returns the name of the space.
@return: Name of the space.
"""
return self._name
def getDescription(self):
"""
Returns description of space.
@return: Description of space.
"""
return self._description
def getRegion(self):
"""
Returns the region of the space.
@return: The region of space.
"""
return self._region
def getItems(self):
"""
Returns a string of times.
@return: Items in Space (as ItemSet).
"""
return self._items
def addItem(self, item):
"""
Adds an item to the space.
@param item: Item to add.
"""
#Special prompt for theOneRing
if item == theOneRing and self._name != "Orodruin":
print "\nYou see some strange men walk by."
return
if isinstance(item, Item):
self._items.addItem(item)
elif isinstance(item, list):
self._items.addItems(item)
else:
errorMsg = "space.AddItem() was given invalid item type."
raise AssertionError(errorMsg)
def removeItem(self, item):
"""
Removes an item from the space.
@param item: Item to remove.
"""
self._items.removeItem(item)
def containsItem(self, item):
"""
Determines if space contains an item.
@param item: Item object to search for.
@return: True if item is contained in
Space, False otherwise.
"""
return self._items.containsItem(item)
def containsItemString(self, string):
"""
Determines if space contains an item.
@param string: The name-string of
the target item.
@return: True if item is contained
in space, False otherwise.
"""
return self._items.containsItemWithName(string)
def getCity(self):
"""
Returns city object/objects.
@return: Reference to cit(ies).
May refer to a single city or list of cities.
"""
return self._city
def getUniquePlace(self):
"""
Returns uniquePlace object(s).
@return: Reference to unique place(s).
May be reference to a single unique
place or a list of unique places.
"""
return self._uniquePlace
def getBattleProbability(self):
"""
Returns probability of a random battle.
@return: The probability that a random
battle occurs.
"""
return self._battleProbability
def getBattleBonusDifficulty(self):
"""
Returns bonus difficulty attribute of space.
@return: The difficulty parameter of space.
"""
return self._battleBonusDifficulty
def createExit(self, direction, space, outgoingOnly = False):
"""
Create an exit to another space. By default, the method creates the
appropriate exit in the second space. (This can be suppressed, however,
using I{outgoingOnly}).
Spaces can have multiple spaces per direction.
@param direction: Direction of exit.
@param space: Adjacent space.
@keyword outgoingOnly: By default, this method creates the appropriate
exit in the second space. Set I{outgoingOnly}
to False to suppress this behaviour.
"""
#Make sure a valid direction has been specified
if not self._isExit(direction):
errorMsg = "Direction not valid: %s" % direction
raise AssertionError(errorMsg)
#Set exit to other space - if a space already exists
if self._exits[direction]:
currentSpace = self._exits[direction]
#If multiple spaces already exist in that direction
if isinstance(self._exits[direction], list):
currentSpace.append(space)
#If a single space exists in that direction
else:
self._exits[direction] = [currentSpace, space]
#If no space already exists
else:
self._exits[direction] = space
#Create exit from other space to this space
if not outgoingOnly:
oppositeDirection = self._oppositeDirection(direction)
#outgoingOnly = True as to not create an infinite loop
space.createExit(oppositeDirection, self, outgoingOnly = True)
def clearExit(self, direction, outgoingOnly, space = None):
"""
Removes an exit to another space. By default, the method removes the
appropriate exit from the second space. (This can be suppressed,
however, using I{outgoingOnly}).
@param direction: Direction of exit.
@keyword outgoingOnly: By default, this method removes the appropriate
exit from the second space. Set I{outgoingOnly}
to False to suppress this behavior.
"""
#Make sure a valid direction has been specified
if not self._isExit(direction):
errorMsg = "Direction not valid: %s" % direction
raise AssertionError(errorMsg)
#If exit has not been set, there is nothing to do
if self._exits[direction] == None:
return
#Create a temporary copy of adjacent space
adjSpace = self._exits[direction]
if isinstance(self._exits[direction], list):
self._exits[direction].remove(space)
else:
self._exits[direction] = None
if not outgoingOnly:
oppositeDirection = self._oppositeDirection(direction)
adjSpace.clearExit(oppositeDirection, True, space = self)
def getExit(self, direction):
"""
Returns a reference to an adjacent space.
Returns None if no space exists in given direction.
@param direction: Direction of adjacent space.
Must be one of the directions defined in
constants.Direction.
@return: Reference to space in given direction.
(Returns None if no exit is defined
for given direction).
"""
space = self._exits[direction]
return space
def getExits(self):
"""
Returns dictionary of direction-space pairs.
@return: Dictionary of direction-space pairs.
"""
return self._exits
def _isExit(self, exit):
"""
Makes sure that a string represents a valid exit.
@param direction: Name of exit.
@return: True if valid exit, False otherwise.
"""
availableExits = self._exits.keys()
if exit not in availableExits:
return False
return True
def _oppositeDirection(self, direction):
"""
Returns the opposite direction. (e.g. North is opposite of South)
@param direction: A direction (from constants.Direction)
@return: Opposite direction (from constants.Direction)
"""
if direction == Direction.NORTH:
return Direction.SOUTH
elif direction == Direction.SOUTH:
return Direction.NORTH
elif direction == Direction.EAST:
return Direction.WEST
elif direction == Direction.WEST:
return Direction.EAST
else:
raise AssertionError("Not a valid direction: %s" % direction)