def check_encounter(self, hunter, hazards=None):
"""
Determines whether the hunter has stepped into a cave containing a bat colony. The bat colony will lift the
hunter and deposit him/her into another cave of the colony's choosing (not necessarily an adjoining cave since
bats fly). Since this is an equivalent to the hunter entering a new cave, we call that method on the hunter
:param hunter: the hunter object
:param hazards: listing of game hazards (needed here)
:return: listing of status messages indicating the confrontation with the bats and the outcome of being
ferried to another cave.
"""
messages = []
if hunter.cave.id == self.cave.id:
hunter_cave_id_options = [
item for item in list(range(1, 21)) if item != self.cave.id
]
new_cave_id = random.choice(hunter_cave_id_options)
messages.extend([
StatusMessage(
'INFO', self.hazard_type,
"You've stumbled into a bat colony. "
"Some of the bats are carrying you into another cave!")
])
updated_status, _ = hunter.enter(new_cave_id,
hazards,
via_bat=True)
messages.extend(updated_status)
return messages
def __init__(self, cavern_system, cave_id):
super().__init__(cavern_system, cave_id)
self.hazard_type = 'BAT_COLONY'
self.hazard_perimeter = Hazard_Perimeter([
StatusMessage('WARNING', self.hazard_type,
"You hear the flapping of wings")
], self.cave.neighboring_caves)
def killed(self):
"""
Kills the hunter. That unfortunate fact is conveyed in the status message returned.
:return: list of a single status message indicating the demise of the hunter.
"""
self.alive = False
return [
StatusMessage('TERMINAL', 'GENERAL', "You've been killed. Sorry.")
]
def killed(self):
"""
Indicates whether the Wumpus has been killed.
:return: list containing the status message that the Wumpus has been slain.
"""
self.alive = False
return [
StatusMessage('TERMINAL', self.hazard_type,
"You have slain the wumpus!")
]
def awakened(self):
"""
Indicates that the Wumpus has been awakened.
:return: list containing the status message that the Wumpus is awake and moving.
"""
self.asleep = False
return [
StatusMessage('INFO', self.hazard_type,
"Wumpus is awake and stiring!")
]
def __init__(self, template_string):
"""
:param str template_string: string containing template variables
and template escape statements to execute
"""
self._extractor = LineExtractor(template_string)
self._message = StatusMessage(self._extractor)
self._executor = Executor()
self._expander = Expander(self._executor, self._message)
self._command = None # Command being processed
self._define_variable_statements = []
def establish_hazard_perimeter(self):
"""
The Wumpus hazard permeter extends as far as two caves removed from the Wumpus' location.
"""
surrounding_caves = [
self.cavern_system.get_cave(cave_id)
for cave_id in self.cave.neighboring_caves
]
surrounding_cave_ids = list(
itertools.chain(
*[cave.neighboring_caves for cave in surrounding_caves]))
surrounding_cave_ids.extend(self.cave.neighboring_caves)
self.hazard_perimeter = Hazard_Perimeter([
StatusMessage('WARNING', self.hazard_type,
"You smell a wumpus (ick!)")
], set(surrounding_cave_ids))
def start_up(self, hazards):
"""
Only called when the game is being initialized. The hunter will not be placed with any hazards to begin with
(that wouldn't be sporting) but the hunter may be close to one or more hazards in nearby caves. The initial
cavern map will show the cave the hunter starts in along with the three adjoining caves.
:param hazards: list of game hazards
:return: list of status messages
"""
messages = [
StatusMessage('INFO', 'GENERAL',
f"You are starting in cave {self.cave.id}")
]
warnings = self.check_for_hazards(hazards)
self.notebook.note_position(self.cave, warnings)
messages.extend(warnings)
return messages
def check_encounter(self, hunter, hazards=None):
"""
Determines whether the hunter has succumbed to this deadly hazard. Kill of the hunter and report such if that
is the case.
:param hunter: the hunter object
:param hazards: lising of game hazards (not relevant here)
:return: list of status messages possibly noting the demise of the hunter.
"""
messages = []
if hunter.cave.id == self.cave.id:
messages.extend([
StatusMessage('TERMINAL', self.hazard_type,
"You fell into a bottomless pit!")
])
messages.extend(hunter.killed())
return messages
def check_encounter(self, hunter, hazards=None):
"""
If the hunter stumbles into the cave containing the Wumpus, the Wumpus will awake if not already awake, and
eat the hunter.
:param hunter: the hunter object
:param hazards: list of game hazards - not relevant for a Wumpus encounter
:return: the status messages indicating the hunter's sad end.
"""
messages = []
if hunter.cave.id == self.cave.id:
if self.asleep:
messages.extend(self.awakened())
messages.extend([
StatusMessage(
'TERMINAL', self.hazard_type,
"Uh oh! You and the wumpus are occupying the same cave now."
)
])
messages.extend(hunter.killed())
return messages
def enter(self, cave_id, hazards, via_bat=False):
"""
Hunter enters a cave. It is possible that the hunter was moved by a bat if the hunter had stumbled into
a bad colony.
:param hazards: list of game hazards
:param cave_id: id of cave into which hunter enters (or is dropped)
:param via_bat: true if the hunter was dropped into the cave via a bat and false otherwise
:return: a tuple containing the game state and errors if any. The error is a server side validation of the
choice of cave to enter.
"""
status = []
errors = []
# The hunter may only enter a cave adjoining the one s/he came from unless transported via a bat.
if cave_id in self.cave.neighboring_caves or via_bat:
# Identify the new cave
self.cave = self.cavern_system.get_cave(cave_id)
# Provide informational messages appropriate to the circumstance.
if via_bat:
status.extend([
StatusMessage(
'INFO', 'BAT_COLONY',
f"You are being dropped into cave {cave_id}")
])
else:
status.extend([
StatusMessage('INFO', 'GENERAL',
f"You are moving into cave {cave_id}")
])
status.extend([StatusMessage('INFO', 'GENERAL', f"{self}")])
wumpus = [
hazard for hazard in hazards if hazard.hazard_type == 'WUMPUS'
][0]
wumpus.move()
# Check to see if any hazards are encountered in this cave. Which, in most cases, will result in the
# demise of the hunter.
dangers = self.check_for_encounters(hazards)
status.extend(dangers)
# Determine whether the hunter encountered a bat colony. That doesn't preclude the hunter being
# deceased since the wumpus map also be resident in the same cave.
encountered_bat_colony = [
danger for danger in dangers if danger.source == 'BAT_COLONY'
]
# If the hunter remains alive and s/he wasn't ferried off by bats after entering the cave, check to see
# if any hazards are proximate to this cave and note the discoveries in the notebook.
if self.alive and not encountered_bat_colony:
warnings = self.check_for_hazards(hazards)
status.extend(warnings)
self.notebook.note_position(self.cave, warnings,
not wumpus.asleep)
# In the unlikely event that the user called the ajax post directly with an invalid cave id selection.
else:
errors.append(
"The cave you specified does not adjoin the one you are in.")
return status, errors
def shoot(self, cave_id, hazards):
"""
The hunter is shooting an arrow into the provided cave id. The will either kill the wumpus or cause the wumpus
to awaken and move about in search of the hunter.
:param cave_id: the id of the cave the hunter is shooting into
:param hazards: lising of the game's hazards
:return: a tuple containing a list of status messages and a list of error messages, if any errors are found.
"""
messages = []
errors = []
# Orientation message for the hunter (although s/he did not move)
messages.extend([StatusMessage('INFO', 'GENERAL', f"{self}")])
# Must have an arrow left to shoot in the first place.
if self.quiver > 0:
# Get the Wumpus object from the hazard list. This is the only hazard of possible concern here since
# the Wumpus is the only hazard that can move about.
wumpus = [
hazard for hazard in hazards if hazard.hazard_type == 'WUMPUS'
][0]
# Spend the arrow and provide a message to that effect
self.quiver -= 1
messages.extend([
StatusMessage(
'INFO', 'GENERAL',
f"You've shot an arrow into {cave_id}. "
f"You have {self.quiver} arrows remaining.")
])
# The wumpus may react to the shot in one of two ways. It either dies or it wakes up (if not already
# awake) and starts hunting the hunter
messages.extend(wumpus.react_to_shot(cave_id))
# If the wumpus is still alive, the wumpus will get a turn at finding the hunter
if wumpus.alive:
# Since the Wumpus is still alive, exhausting one's supply of arrows is really a death sentence.
if self.quiver == 0:
messages.extend([
StatusMessage(
'WARNING', 'GENERAL',
"You have no arrows left. All you can do is avoid the wumpus."
)
])
# This actually caused the Wumpus to move only if the Wumpus if awake. Wumpus's do not walk in their
# sleep.
wumpus.move()
# Check to see if the wumpus has entered this cave, which will result in the demise of the hunter.
dangers = self.check_for_encounters([wumpus])
messages.extend(dangers)
# If the hunter remains alive, check to see if the wumpus is now proximate to this cave and note
# that finding in the notebook.
if self.alive:
warnings = self.check_for_hazards(hazards)
messages.extend(warnings)
self.notebook.note_position(self.cave, warnings,
not wumpus.asleep)
else:
messages.extend([
StatusMessage(
'WARNING', 'GENERAL',
"You have no arrows left. All you can do is avoid the wumpus."
)
])
return messages, errors
def setUp(self):
self.extractor = LineExtractor("")
self.message = StatusMessage(self.extractor)
self.expander = Expander(Executor(), self.message)
def __init__(self, cavern_system, cave_id):
super().__init__(cavern_system, cave_id)
self.hazard_type = 'BOTTOMLESS_PIT'
self.hazard_perimeter = Hazard_Perimeter(
[StatusMessage('WARNING', self.hazard_type, "You feel a draft")],
self.cave.neighboring_caves)
def setUp(self):
self.extractor = LineExtractor("")
self.message = StatusMessage(self.extractor)