def player_add_xp(self, xp):
leveled_up = self.player.level.add_xp(xp)
message = Message('You gain {0} experience points.'.format(xp))
if leveled_up:
level = self.player.level.current_level
text = 'Your battle skills grow stronger! You reached level {0}'.format(
level) + '!'
logger.info('Player reached level {}'.format(level))
message = Message(text, UISettings.yellow)
return leveled_up, message
def kill_entity(self, dead_entity):
player_dead = False
message = Message('{0} is dead!'.format(dead_entity.name.capitalize()),
UISettings.orange)
logger.info('{} is dead.'.format(dead_entity.name))
if dead_entity == self.player:
player_dead = True
message = Message('You died!', UISettings.red)
dead_entity.make_dead()
return message, player_dead
def entry_point(events, context):
messages_to_send = events['messages_to_send']
logger.info(f"Running profile with {messages_to_send} messages")
messages_list = [Message() for each in range(0, messages_to_send)]
if events['sqs'].upper() == "TRUE" and messages_to_send <= 10:
broadcast_messages_sqs(messages_list)
if events['kinesis'].upper() == "TRUE":
broadcast_messages_kinesis(messages_list)
logger.info("Invocation complete, ending")
def test_combine_message_and_history_that_doesnt_intersect(self):
line_history = ["hello" + " " * 3 for _ in xrange(1, 9)]
msg = Message("yo\n" * 29 + "yo", "first", (50, 11))
screen_height = 50
result = combineHistoryAndMessage(msg.message, 11, line_history,
screen_height)
expectedResult = "yo\n" + 28 * (IN_WIDTH * " " +
"yo\n") + " " * IN_WIDTH + "yo"
self.assertEqual(result, expectedResult)
def player_pickup(self):
message = Message('There is nothing here to pick up.',
UISettings.yellow)
pickup_results = {'message': message}
item = find(lambda e: e.item and self.player.overlap(e), self.entities)
if item:
pickup_results.update(self.player.inventory.add_item(item))
if pickup_results.get('item_added'):
logger.info('Player picks up {}'.format(item.name))
self.entities.remove(item)
return [pickup_results]
def test_combine_message_and_history_that_covers_the_screen(self):
line_history = [
str(i) + (" " * (IN_WIDTH - len(str(i)))) for i in xrange(1, 100)
]
msg = Message("yo\n" * 29 + "yo", "first", (50, 11))
screen_height = 50
result = combineHistoryAndMessage(msg.message, 11, line_history,
screen_height)
expectedResult = "yo\n" + (
(" " * IN_WIDTH) + "yo\n") * 28 + (" " * IN_WIDTH) + "yo"
self.assertEqual(result, expectedResult)
def heal(*args, **kwargs):
entity = args[0]
amount = kwargs.get('amount')
if entity.fighter.hp == entity.fighter.max_hp:
consumed = False
text, color = 'You are already at full health', UISettings.yellow
else:
entity.fighter.heal(amount)
consumed = True
text, color = 'Your wounds start to feel better!', UISettings.green
return [{'consumed': consumed, 'message': Message(text, color)}]
def player_toggle_equip(self, equip):
messages = []
equip_results = self.player.equipment.toggle_equip(equip)
for equip_result in equip_results:
for action in ['equipped', 'dequipped']:
item = equip_result.get(action)
if item:
messages.append(
Message('You {0} the {1}'.format(action, item.name)))
logger.info('Player {} the {}'.format(action, item.name))
return messages
def attack(self, target):
results = []
damage = self.power - target.fighter.defense
text = '{0} attacks {1} but does no damage.'.format(
self.owner.name.capitalize(), target.name)
if damage > 0:
text = '{0} attacks {1} for {2} hit points.'.format(
self.owner.name.capitalize(), target.name, str(damage))
results.extend(target.fighter.take_damage(damage))
logger.info(text)
results.append({'message': Message(text)})
return results
def test_combine_message_and_history_that_intersects(self):
line_history = [
"hello" + (IN_WIDTH - len("hello")) * " " for _ in xrange(0, 15)
]
msg = Message("yo\n" * 29 + "yo", "first", (50, 11))
screen_height = 50
result = combineHistoryAndMessage(msg.message, 11, line_history,
screen_height)
expectedResult = "yo\n" + ("hello" + " " *
(IN_WIDTH - len("hello")) + "yo\n") * 4 + (
" " * IN_WIDTH +
"yo\n") * 24 + " " * IN_WIDTH + "yo"
self.assertEqual(result, expectedResult)
async def send(self, connection: StreamWriter,
message: Message) -> NoReturn:
async with self.connection_lock:
try:
connection.write(message.serialize())
await connection.drain()
except ConnectionResetError or ConnectionAbortedError as _:
print('connection closed')
pass
except Exception as e:
print('random error', e)
print(message)
pass
def player_go_downstairs(self):
recompute = False
text = 'There are no stairs here.'
color = UISettings.yellow
stairs_entity = find(lambda e: e.stairs and self.player.overlap(e),
self.entities)
if stairs_entity:
recompute = True
text = 'You take a moment to rest, and recover your strength.'
logger.info('Player goes downstairs: ({}, {})'.format(
self.player.x, self.player.y))
color = UISettings.light_violet
self.next_floor()
return [{'message': Message(text, color)}], recompute
def player_level_up(self, level_up):
if level_up == 'hp':
self.player.fighter.base_max_hp += 20
self.player.fighter.hp += 20
ability = 'health'
elif level_up == 'str':
self.player.fighter.base_power += 1
ability = 'power'
elif level_up == 'def':
self.player.fighter.base_defense += 1
ability = 'defense'
message = Message('Your {0} became stronger!'.format(ability),
UISettings.green)
logger.info('Player improves ' + ability)
return [{'message': message}]
def test_creates_message(self):
new_message = Message("hello", "111", (0, 0))
self.assertEqual(new_message.message, ["hello"])
self.assertEqual(new_message.id, "111", (0, 0))
def test_deletes_message(self):
new_message = Message("hello", "111", (0, 0))
self.assertEqual(new_message.deleteMessage, [" "])
def test_delete_message_with_new_lines2(self):
new_message = Message("hel\n", "111", (0, 0))
self.assertEqual(new_message.deleteMessage, [" "])
def test_creates_message_with_new_lines(self):
new_message = Message(first_message_no_tabs, "111", (50, 20))
self.assertEqual(new_message.message, first_message)
def test_delete_message_with_new_lines_in_middle_of_screen(self):
new_message = Message("hello\nhiiii\nyooooo\n", "111", (51, 50))
self.assertEqual(new_message.deleteMessage,
[" ", " ", " "])
def test_x_and_Y(self):
new_message = Message("hello\nhiiii\nyooooo\n", "111", (51, 50))
self.assertEqual(new_message.x, 51)
self.assertEqual(new_message.y, 50)
