def check_position_to_move(self):
non_moving_positions = [x for x in positions if x is not 'standing']
if set(self.position) & set(non_moving_positions):
events.game_event('''{} struggles to move.'''.format(self.name[0]))
return False
else:
return True
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
if not character.check_position_to_move():
return
if world.tile_exists(x=self.character.location_x + 1,
y=self.character.location_y,
area=self.character.area):
if character.room.shop_filled == True:
if character.room.shop.in_shop == True:
character.room.shop.exit_shop()
old_room = self.character.room.room_number
self.character.move_east()
self.update_room(old_room_number=old_room,
new_room_number=self.character.room.room_number)
self.update_status(character.get_status())
return
else:
events.game_event(
"You cannot find a way to move in that direction.")
return
def melee_attack_character(self, character):
attack_strength = calculate_attack_strength(self, self.weapon)
defense_strength = calculate_defense_strength(
character=character, weapon=character.get_dominant_hand_inv())
attack_factor = calculate_attack_factor(self.weapon, character.armor)
att_random = random.randint(0, 100)
att_end_roll = end_roll(attack=attack_strength,
defense=defense_strength,
attack_factor=attack_factor,
random=att_random)
result = None
death_text = None
if att_end_roll <= 100:
result = """\
{} evades the attack.\
""".format(character.name)
else:
att_damage = get_damage(att_end_roll, self.weapon, character.armor)
character.health = character.health - att_damage
death_text = character.is_killed()
result = """\
{} damages {} by {}.
{}\
""".format(self.name, character.name, att_damage, death_text)
events.game_event("""\
{} attacks {}!
STR {} - DEF {} + AF {} + D100 ROLL {} = {}
{}
\
""".format(self.name, character.name, attack_strength, defense_strength,
attack_factor, att_random, att_end_roll, result))
return character
def check_position_to_move(self):
non_moving_positions = [x for x in positions if x is not 'standing']
if set([self.position]) & set(non_moving_positions):
events.game_event('''You cannot move. You are {}.'''.format(self.position))
return False
else:
return True
def check_round_time(self):
with lock:
round_time = False
if time.time() < self.rt_end:
events.game_event("Remaining round time: " + str(round(self.rt_end - time.time())) + " sec...")
round_time = True
return round_time
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
events.game_event('''
Edged Weapons Base: {}
Edged Weapons: {} ({}) Armor: {} ({})
Blunt Weapons: {} ({}) Shield: {} ({})
Polearm Weapons: {} ({}) Dodging: {} ({})
Thrown Weapons: {} ({}) Physical Fitness: {} ({})
Ranged Weapons: {} ({}) Perception: {} ({})
'''.format(
character.skills_base['edged_weapons'],
character.skills['edged_weapons'],
character.skills_bonus['edged_weapons'], character.skills['armor'],
character.skills_bonus['armor'], character.skills['blunt_weapons'],
character.skills_bonus['blunt_weapons'],
character.skills['shield'], character.skills_bonus['shield'],
character.skills['polearm_weapons'],
character.skills_bonus['polearm_weapons'],
character.skills['dodging'], character.skills_bonus['dodging'],
character.skills['thrown_weapons'],
character.skills_bonus['thrown_weapons'],
character.skills['physical_fitness'],
character.skills_bonus['physical_fitness'],
character.skills['ranged_weapons'],
character.skills_bonus['ranged_weapons'],
character.skills['perception'],
character.skills_bonus['perception']))
def save(self,):
save_data = self.__getstate__()
character_name = "{}_{}.p".format(self.first_name, self.last_name)
path_save = pathlib.Path.cwd() / 'Profiles' / character_name
pickle.dump(save_data, open(file=path_save.absolute().as_posix(), mode='wb'))
events.game_event(game_event_text="Progress saved.")
return
def skin_corpse(self):
if self.skin == None:
events.game_event("You cannot skin {}".format(self.name))
else:
events.game_event("You skin {} to yield {}.".format(self.name, all_items_categories['skin'][self.skin]['name']))
self.room.add_item(items.create_item(item_category='skin', item_name=self.skin))
return
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
elif not kwargs['direct_object']:
events.game_event("What are you trying to give?")
return
elif character.get_dominant_hand_inv() is None:
events.game_event(
"You don't seem to be holding that item in your hand.")
return
elif not set(character.get_dominant_hand_inv().handle) & set(
kwargs['direct_object']):
events.game_event(
"You don't seem to be holding that item in your hand.")
return
elif not kwargs['indirect_object']:
events.game_event("To whom do you want to give?")
return
else:
for npc in character.room.npcs:
if {npc.first_name.lower()} & set(kwargs['indirect_object']):
if npc.give_item(character.get_dominant_hand_inv()):
character.set_dominant_hand_inv(item=None)
character.print_status()
return
else:
return
events.game_event("That didn't seem to work.")
return
def __init__(self, enemy_name: str, target: object, room: object, location_x: int, location_y: int, area: str, **kwargs):
super(Enemy, self).__init__()
self._enemy_data = self.get_enemy_by_name(enemy_name)
self._name = self._enemy_data['name']
self._description = self._enemy_data['description']
self._handle = self._enemy_data['handle']
self._adjectives = self._enemy_data['adjectives']
self._category = self._enemy_data['category']
self._level = self._enemy_data['level']
self._health = self._enemy_data['health']
self._health_max = self._enemy_data['health_max']
self._attack_strength_base = self._enemy_data['attack_strength_base']
self._defense_strength_base = self._enemy_data['defense_strength_base']
self._position = self._enemy_data['position']
self._stance = self._enemy_data['stance']
self._text_entrance = self._enemy_data['text']['entrance_text']
self._text_move_in = self._enemy_data['text']['move_in_text']
self._text_move_out = self._enemy_data['text']['move_out_text']
self._text_engage = self._enemy_data['text']['engage_text']
self._text_death = self._enemy_data['text']['death_text']
self._round_time_engage = self._enemy_data['round_time']['engage']
self._round_time_attack = self._enemy_data['round_time']['attack']
self._round_time_move = self._enemy_data['round_time']['move']
self._corpse = self._enemy_data['corpse']
self._armor = {}
for category in self._enemy_data['armor']:
for item in self._enemy_data['armor'][category]:
self._armor[category] = items.create_item('armor', item_name=item)
self._weapon = self._enemy_data['weapon']
self.spawn_location = self._enemy_data['spawn_location']
self.location_x = location_x
self.location_y = location_y
self.area = area
self.room = room
self.target = target
if self.room == target.room:
for line in textwrap.wrap(self._enemy_data['entrance_text'], 80):
events.game_event(line)
self._right_hand_inv = self._enemy_data['right_hand']
self._left_hand_inv = self._enemy_data['left_hand']
experience_level = math.floor(experience_points_base * math.pow(self.level, experience_growth))
experience_next_level = math.floor(experience_points_base * math.pow(self.level + 1, experience_growth))
enemies_at_level = math.floor(enemy_level_base * math.pow(self.level,enemy_growth))
self.experience = int((experience_next_level - experience_level) / enemies_at_level * random.uniform(0.9,1.1))
def move(self, dx, dy):
self.room.remove_enemy(self)
if self.room == self.target.room:
events.game_event(self.text_move_out)
self.location_x += dx
self.location_y += dy
self.room = world.tile_exists(x=self.location_x, y=self.location_y, area=self.area)
self.room.add_enemy(self)
if self.room == self.target.room:
events.game_event(self.text_move_in)
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if not kwargs['direct_object']:
events.game_event("What do you want to target?")
return
else:
character.target = kwargs['direct_object']
events.game_event("You are now targeting {}".format(
self.target[0]))
return
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
events.game_event('''
Name: {} {}
Gender: {}
Race: {}
Profession: {}
Level: {}
'''.format(character.first_name, character.last_name,
character.gender, character.race, character.profession,
character.level))
def give_item(self, item):
# if item.handle[0] != "hide":
# print('''\
# {} takes one look at {} and says, "What is this? What do you expect me to do with this?" {} shakes {} head and
# walks away from your offer.\
# '''.format(self.first_name, item.name, self.object_pronoun, self.possessive_pronoun))
# else:
# if not self.character.check_quest(quest=self.quests['the_first_quest']):
events.game_event("""\
Gander looks you up and down. "Did someone tell you to come to me? No? Then I can't help you unfortunately."\
""")
return
def ask_about(self, object):
# if set(object) & {"job", "task"}:
# if not self.character.check_quest(quest=self.quests['the_first_quest']):
# print("""\
# Gander looks you up and down. "Did someone tell you to come to me? No? Then I can't help you unfortunately."\
# """)
# return
# self.quest01_step1()
# else:
events.game_event("""\
Gander glances quickly at you and raises an eyebrow. "I'm not sure what you're talking about."\
""")
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.get_dominant_hand_inv():
right_hand = "You have {} in your {} hand.".format(
character.get_dominant_hand_inv().name, character.dominance)
else:
right_hand = "Your right hand is empty."
if character.get_non_dominant_hand_inv():
left_hand = "You have {} in your {} hand.".format(
character.get_non_dominant_hand_inv().name,
character.non_dominance)
else:
left_hand = "Your left hand is empty."
inventory_clothing = [
x.name for x in character.inventory if x.category == 'clothing'
]
if len(inventory_clothing) > 1:
inventory_clothing = "You are wearing {} and {}.".format(
', '.join(inventory_clothing[:-1]), inventory_clothing[-1])
elif len(inventory_clothing) == 1:
inventory_clothing = "You are wearing {}.".format(
inventory_clothing[0])
else:
inventory_clothing = "You are wearing nothing."
inventory_armor = []
for category in character.armor:
inventory_armor.append(character.armor[category])
if len(inventory_armor) > 1:
inventory_armor = "You are also wearing {} and {}.".format(
character.object_pronoun, ', '.join(inventory_armor[:-1]),
inventory_armor[-1])
elif len(inventory_armor) == 1:
inventory_armor = "You are also wearing {}.".format(
inventory_armor[0].name)
else:
inventory_armor = "You are also wearing no armor.".format(
character.object_pronoun)
wealth = "You have {} gulden.".format(character.money)
events.game_event('''\
{}
{}
{}
{}
{}
\
'''.format(
right_hand, left_hand, wrapper.fill(inventory_clothing),
wrapper.fill(inventory_armor), wrapper.fill(wealth)))
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
if not character.check_position_to_move():
return
if not kwargs['direct_object']:
events.game_event("Go where?")
return
for room_object in character.room.objects:
if set(room_object.handle) & set(kwargs['direct_object']):
events.game_event("You move toward {}.".format(
room_object.name))
room_object.go_object(character=character)
return
for room_item in character.room.items:
if set(room_item.handle) & set(kwargs['direct_object']):
events.game_event("You move toward {}.".format(room_item.name))
return
for room_npc in character.room.npcs:
if set(room_npc.handle) & set(kwargs['direct_object']):
events.game_event("You move toward {}.".format(room_npc.name))
return
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
elif not kwargs['direct_object']:
events.game_event(
"I'm sorry, I could not understand what you wanted.")
return
elif character.get_dominant_hand_inv() is None:
events.game_event("You do not have that item in your hand")
return
elif not set(character.get_dominant_hand_inv().handle) & set(
kwargs['direct_object']):
events.game_event("You do not have that item in your right hand.")
return
else:
character.room.items.append(character.get_dominant_hand_inv())
events.game_event("You drop " +
character.get_dominant_hand_inv().name)
character.set_dominant_hand_inv(item=None)
character.print_status()
return
def do_action(action_input, character=None):
action_history.insert(0, action_input)
if not character:
events.game_event(
game_event_text=
"No character loaded. You will need to create a new character or load an existing character."
)
return
if len(action_input) == 0:
events.game_event("")
return
kwargs = command_parser.parser(action_input)
return DoActions.do_action(kwargs['action_verb'], character,
**kwargs).action_result
def __init__(self, character, **kwargs):
if character.check_round_time():
return
if character.is_dead():
return
if not character.check_position_to_move():
return
if character.room.is_shop == False:
events.game_event(
"You can't seem to find a way to order anything here.")
return
if character.room.shop_filled == False:
events.game_event("You will need to ORDER first.")
return
if character.room.shop.in_shop == False:
events.game_event(
"You have exited the shop. You will need to ORDER again.")
return
if character.get_dominant_hand_inv() is not None:
events.game_event("You will need to empty your right hand first.")
return
character.set_dominant_hand_inv(
character.room.shop.buy_item(number=kwargs['number_1']))
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
elif not kwargs['direct_object']:
events.game_event("What is it you are trying to sell?")
return
for npc in character.room.npcs:
if set(npc.handle) & {kwargs['indirect_object']}:
npc.sell_item(item=character.get_dominant_hand_inv())
return
else:
events.game_event("Who are you trying to sell to?")
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
if character.position == 'sitting':
events.game_event('You seem to already be sitting.')
character.print_status()
return
else:
character.position = 'sitting'
events.game_event('You move yourself to a sitting position.')
character.print_status()
return
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
if character.position == 'lying':
events.game_event('You seem to already be lying down.')
character.print_status()
return
else:
character.position = 'lying'
events.game_event('You lower yourself to the ground and lie down.')
character.print_status()
return
def melee_attack_enemy(self, target):
attack_strength = calculate_attack_strength(self,
self.get_dominant_hand_inv())
defense_strength = calculate_defense_strength(character=target,
weapon=target.weapon)
attack_factor = calculate_attack_factor(self.get_dominant_hand_inv(),
target.armor)
att_random = random.randint(0, 100)
att_end_roll = end_roll(attack=attack_strength,
defense=defense_strength,
attack_factor=attack_factor,
random=att_random)
round_time = self.set_round_time(3)
result = None
if att_end_roll <= 100:
result = """\
{} evades the attack.
Round time: {} seconds
""".format(target.name, round_time)
else:
att_damage = get_damage(att_end_roll, self.get_dominant_hand_inv(),
target.armor)
target.health = target.health - att_damage
if target.is_killed():
death_text = target.text_death
target.replace_with_corpse()
self.experience += int(
target.experience *
get_exerience_modifier(self.level, target.level))
else:
death_text = ""
result = """\
{} damages {} by {}.
Round time: {} seconds
{}\
""".format(self.name, target.name, att_damage, round_time,
death_text)
events.game_event("""\
{} attacks {}!
STR {} - DEF {} + AF {} + D100 ROLL {} = {}
{}\
""".format(self.name, target.name, attack_strength, defense_strength,
attack_factor, att_random, att_end_roll, result))
self.check_level_up()
return target
def run(self):
if self.room == self.target.room:
events.game_event(self.text_move_in)
while self.health > 0:
if self.health <= 0:
break
elif (self.room == self.target.room) and (self.target.health > 0):
events.game_event(self.text_engage)
time.sleep(self.round_time_engage)
if (self.room == self.target.room) and (self.target.health > 0) and (self.is_alive):
combat.melee_attack_character(self, self.target)
time.sleep(self.round_time_attack)
else:
available_actions = self.room.adjacent_moves_enemy(area=self.area)
action = random.choice(available_actions)
action_method = getattr(self, action.method.__name__)
action_method()
time.sleep(self.round_time_move)
return
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
if not character.check_position_to_move():
return
if world.tile_exists(x=self.character.location_x - 1,
y=self.character.location_y,
area=self.character.area):
if character.room.shop_filled == True:
if character.room.shop.in_shop == True:
character.room.shop.exit_shop()
self.character.move_west()
character.print_status()
else:
events.game_event(
"You cannot find a way to move in that direction.")
def level_up(self):
self.level += 1
for stat in self.stats:
self.stats[stat] = self.stats[stat] + 1 / (self.stats[stat] / int(profession_stats_growth_file.loc[self.profession][stat]))
if self.stats[stat] > 100:
self.stats[stat] = 100
self.stats_bonus[stat] = ((self.stats[stat] - available_stat_points / 8) / 2 + int(race_stats_file.loc[self.race][stat]))
skills.level_up_skill_points()
self.health = int(math.floor((self.stats['strength'] + self.stats['constitution']) / 10))
self.health_max = int(math.floor((self.stats['strength'] + self.stats['constitution']) / 10))
self.attack_strength_base = int(round(self.stats_bonus['strength'],0))
self.defense_strength_evade_base = int(round(self.stats_bonus['agility'] + self.stats_bonus['intellect'] / 4 + self.skills['dodging'],0))
self.defense_strength_block_base = int(round(self.stats_bonus['strength'] / 4 + self.stats_bonus['dexterity'] /4,0))
self.defense_strength_parry_base = int(round(self.stats_bonus['strength'] / 4 + self.stats_bonus['dexterity'] / 4,0))
events.game_event("Ding! You are now level {}!".format(self.level))
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
events.game_event('''
Name: {} {}
Level: {}
Strength: {} ({}) Intellect: {} ({})
Constitution: {} ({}) Wisdom: {} ({})
Dexterity: {} ({}) Logic: {} ({})
Agility: {} ({}) Spirit: {} ({})
'''.format(
character.first_name, character.last_name, character.level,
character.stats['strength'], character.stats_bonus['strength'],
character.stats['intellect'], character.stats_bonus['intellect'],
character.stats['constitution'],
character.stats_bonus['constitution'], character.stats['wisdom'],
character.stats_bonus['wisdom'], character.stats['dexterity'],
character.stats_bonus['dexterity'], character.stats['logic'],
character.stats_bonus['logic'], character.stats['agility'],
character.stats_bonus['agility'], character.stats['spirit'],
character.stats_bonus['spirit']))
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
elif not kwargs['direct_object']:
events.game_event("What are you trying to skin?")
return
else:
for object in character.room.objects:
if set(object.handle) & set(kwargs['direct_object']):
object.skin_corpse()
return
for item in character.room.items:
if set(item.handle) & set(kwargs['direct_object']):
events.game_event(
"You can seem to find any way to skin {}.".format(
item.name))
return
for npc in character.room.npcs:
if set(npc.handle) & set(kwargs['direct_object']):
events.game_event(
"You approach {}, but think better of it.".format(
npc.name))
return
def __init__(self, character, **kwargs):
DoActions.__init__(self, character, **kwargs)
if character.check_round_time():
return
if character.is_dead():
return
if kwargs['direct_object']:
character.target = kwargs['direct_object']
if not character.target:
events.game_event(
"Who are you going to attack? You do not have a target.")
return
else:
for npc in character.room.npcs:
if set(npc.handle) & set(character.target):
events.game_event(
"{} will probably not appreciate that.".format(
npc.name))
return
enemy_found = False
for enemy in character.room.enemies:
if set(enemy.handle) & set(character.target):
enemy_found = True
combat.melee_attack_enemy(character, enemy)
return
if not enemy_found:
events.game_event("{} is not around here.".format(
kwargs['direct_object']))
return
