def main():
"""
Main function of the game, transforms user's input into player's movement and plot changes.
Returns: Nothing
"""
message, message_type, name = "", "no_type", ""
show_inventory = False
show_legend = True
is_running = True
global boards
game_introduction()
player = create_player()
while is_running:
util.clear_screen()
board = engine.create_board(boards[player["current_board"]], player)
ui.display_board(board, boards[player["current_board"]]["name"],
player, quests, show_inventory, show_legend, legend,
message)
engine.validate_answer(name, player, boards, message_type)
key = util.key_pressed()
board = engine.remove_player_from_board(board, player)
player, show_inventory, show_legend, is_running, boards = react_to_pressed_key(
key, board, boards, player, show_inventory, show_legend,
is_running)
message, message_type, name = engine.plot_development(
player, boards, board)
is_running = engine.check_health_is_zero_or_below(player, is_running)
def outro(board, player):
engine.put_player_on_board(board, player)
engine.put_enemy_on_board(board, Enemies.king)
play_outro(board, Enemies.king)
display_mode = 13
level = True
while level:
display_mode += 1
if display_mode == 15:
display_mode = 10
util.clear_screen()
print('\n\n')
ui.display_board(board, display_mode, Enemies.king)
print('\n\n\n')
key = util.key_pressed()
# MAIN CONTROL
if key == 'q':
levels.quit_game()
elif key == "d":
player.move_right(board)
elif key == "s":
player.move_down(board)
elif key == "w":
player.move_up(board)
elif key == "a":
player.move_left(board)
elif key == "t" and player.pos_x == 8 and player.pos_y == 16:
print_message(['YOU', 'DID', 'IT!!! :)'])
elif key == "i":
print_character(player, " character")
def play_game():
board = engine.create_board(BOARD_WIDTH, BOARD_HEIGHT)
player = create_player()
wolf = create_wolf()
ham = create_ham()
list_of_movement_wolf = movement_wolf(wolf, board)
is_running = True
prev_field_data = None
while is_running:
key = key_pressed()
if key == 'q':
is_running = False
else:
player, prev_field_data, ham = change_player_positions(
player, key, ham)
board, prev_field_data = colision(board, player, prev_field_data,
wolf, ham)
board = engine.put_player_on_board(board, player, prev_field_data)
wolf = change_wolf_positions(wolf, board, ham,
list_of_movement_wolf)
board = engine.put_wolf_on_board(board, wolf)
board = engine.put_ham_on_board(board, ham)
ui.display_board(board)
z = ham["status"]
print(f"HAPE = {hp} Mana = {mana} Potion = {pot} HamStat = {z}")
def main():
util.clear_screen()
player = create_player()
player_inv = create_player_inventory()
sword = create_sword()
monster = create_monster()
engine.get_player_stats(player)
util.clear_screen()
is_running = True
while is_running:
board1 = engine.create_board(gate1=(16, 29), gate2=(16, 0))
everyone_in_room1 = [sword, monster,
player] # player should be the last one(!)
coordinates_who_is_alive = collect_coordinates_who_is_alive(
everyone_in_room1)
# print(coordinates_who_is_alive) # This line is for test phase(!)
engine.put_everyone_on_board(board1, coordinates_who_is_alive)
ui.display_player_info_and_control_info(player)
ui.display_board(board1)
key = util.key_pressed()
if key == 'q':
is_running = False
elif key == 'I':
x = ""
while x == "":
ui.display_inv(player_inv)
x = util.key_pressed()
else:
engine.refresh_player_coord(key, player, player_inv, board1,
everyone_in_room1)
util.clear_screen()
def process_game(level, player):
enemies = create_enemies(level)
items = create_items(level)
is_running = True
while is_running:
board = engine.create_board(BOARD_WIDTH, BOARD_HEIGHT)
engine.put_player_on_board(board, player)
engine.put_objects_on_board(board, items)
engine.put_enemies_on_board(board, enemies)
ui.display_board(board)
ui.display_attributes(player, level)
key = util.key_pressed()
if key == 'q':
is_running = False
elif key == 's' or key == "w" or key == 'a' or key == 'd':
handle_exit(player, level, key)
move_if_valid(key, player, board)
handle_meets(enemies, player)
if not is_player_alive(player):
print("Sorry, you died.")
is_running = False
handle_meets_with_items(items, player)
move_enemies(enemies, player)
elif key == 'c':
player["health"] += 10000
else:
continue
def level_three_start(player, enemies_list, file_name):
# Creating objects and items
item_one = items.create_banana(1, 14)
item_two = items.create_grape(73, 6)
item_three = items.create_sword(9, 14)
# Creating interactions
objects_one = [player, item_one]
objects_two = [player, item_two]
objects_three = [player, item_three]
is_running = True
ui.display_board(engine.create_board("Messages/message_lvl3.txt"))
time.sleep(3)
while is_running:
key = key_pressed()
clear_screen()
if key == 'q':
assert False
board = engine.create_board(file_name)
player = engine.player_coordinates_change(key, player, board)
board = engine.put_player_on_board(board, player)
if player['x'] == 77 and player['y'] == 14:
player['level'] = 4
is_running = False
for index in range(len(enemies_list)):
enemy = enemies_list[index]
if enemy['HP'] > 0:
enemy = engine.enemy_movement(board, enemy)
board = engine.put_enemies_on_board(board, enemy)
fight = engine.enemy_board_interaction(board, enemy, player)
player = fight[0]
enemy = fight[1]
enemies_list[index] = enemy
if item_one['on_board'] == 1:
board = engine.put_items_on_board(board, item_one)
player = objects_one[0]
item_one = objects_one[1]
objects_one = engine.item_board_interaction(board, item_one, player)
if item_two['on_board'] == 1:
board = engine.put_items_on_board(board, item_two)
player = objects_two[0]
item_two = objects_two[1]
objects_two = engine.item_board_interaction(board, item_two, player)
if item_three['on_board'] == 1:
board = engine.put_items_on_board(board, item_three)
player = objects_three[0]
item_three = objects_three[1]
objects_three = engine.item_board_interaction(board, item_three, player)
if player['HP'] <= 0:
return player
ui.display_board(board)
ui.display_inventory(player)
return player
def main(name, race, hero_class):
clear_screen()
player = create_player(name, race, hero_class)
# board = engine.create_board(BOARD_WIDTH, BOARD_HEIGHT)
board = engine.read_map('map.txt')
board = engine.put_player_on_board(board, player, map_elements)
hero = list_stats(player['stats'], player)
ui.display_board(board, hero)
play_game(player, board)
ui.about_authors()
# end_game.end_game(end = None)
restart_game()
def main():
player = create_player()
is_running = True
while is_running:
key = key_pressed()
if key == 'q':
is_running = False
if key == 'z':
clear_screen()
else:
board = engine.create_board(BOARD_WIDTH, BOARD_HEIGHT)
board = engine.put_player_on_board(board, player)
ui.display_board(board)
def boss(player):
while True:
ui.display_board(create_board("messages/message_boss.txt"))
time.sleep(3)
key = helpers.key_pressed()
if key == "s":
amount_of_numbers = 4
message = ['', 'HEY', '', 'I\'M GOING TO KILL YOU', '',
'YOU HAVE TO GUESS ALL {} NUMBERS'.format(amount_of_numbers), '', '']
ui.print_boss(message)
band_of_numbers = 64 // amount_of_numbers
lives = int(player['HP']/10)
guessed_numbers = []
numbers_list = [random.randint(1, band_of_numbers) for number in range(amount_of_numbers)]
guessed_numbers = main_game(numbers_list, band_of_numbers, lives, guessed_numbers)
if numbers_list == guessed_numbers:
player['level'] = 5
if numbers_list != guessed_numbers:
player['HP'] = 0
return player
def main():
for song in playlist:
player = vlc.MediaPlayer(song)
player.play()
player = create_player()
player_stats = lore.start_lore()
board = engine.create_board()
util.clear_screen()
for i in range(3):
board = engine.create_board()
monsters_alive = [] # store the still alive monster ids
floorsize = enemy.pick_valid_places(board)
max_monsters = enemy.max_monster_on_map(floorsize)
enemys = enemy.pick_monster(enemy.monsters_dict, enemy.hero_dict,
max_monsters)
enemy.monster_placement(floorsize, enemys, board, monsters_alive)
engine.put_player_on_board(board, player, monsters_alive,
enemy.monsters_dict, floorsize,
player_stats)
ui.display_board(board)
util.clear_screen()
final_choreography()
def main():
player = create_player()
board = engine.create_board(BOARD_WIDTH, BOARD_HEIGHT)
ui.display_board(board, player)
util.clear_screen()
is_running = True
while is_running:
engine.put_player_on_board(board, player)
ui.display_board(board, player)
key = util.key_pressed().lower()
engine.clear_player_previous_position(board, player[ROW], player[COL])
row = player[ROW]
col = player[COL]
if key == 'q':
is_running = False
elif key == 'd':
#move right
if engine.can_player_move(player, board, row, col + 1):
player[COL] += 1
elif key == 'a':
#move left
if engine.can_player_move(player, board, row, col - 1):
player[COL] -= 1
elif key == 'w':
#move up
if engine.can_player_move(player, board, row - 1, col):
player[ROW] -= 1
elif key == 's':
#move down
if engine.can_player_move(player, board, row + 1, col):
player[ROW] += 1
else:
pass
player, board = engine.check_if_change_board(player, board)
util.clear_screen()
def main():
util.clear_screen()
player = database_player.create_player()
board_list = database_boards.create_boards()
current_board = board_list['1']
npc_dictionary = {}
is_running = True
npc = None
while is_running:
x, y = player['position']
future_x = x
future_y = y
print('Current Howling Forest Region: ',
extras.board_level_info(board_list, current_board))
extras.how_is_the_hp(player)
extras.print_player_stats(player)
if npc:
extras.how_is_the_npc_hp(npc)
if engine.fight_is_over:
npc = None
database_player.put_player_on_board(current_board, player)
ui.display_board(current_board)
key = util.key_pressed()
if key == 'q':
is_running = False
elif key == 'w':
future_x = x - 1
elif key == 's':
future_x = x + 1
elif key == 'a':
future_y = y - 1
elif key == 'd':
future_y = y + 1
elif key == 'i':
print(player['inventory'])
util.press_any_key()
elif key == 'h':
extras.help()
util.press_any_key()
elif key == 'k':
item = database_items.small_hp_potion
engine.use_item_from_inventory(player, item)
elif key == 'l':
item = database_items.small_hp_potion
engine.use_item_from_inventory(player, item)
else:
pass
engine.remove_player_from_board(current_board, player)
database_player
# moves the player to the next/previous board(s) if has the teleportation orb // put items to inv
if engine.can_move_player_to(current_board, player, future_x,
future_y):
engine.idle_hp_regeneration(player, future_x, future_y)
if database_boards.is_cell_exit(current_board, future_x, future_y):
if engine.player_has_item(player,
database_items.teleportation_orb):
for key in board_list:
if current_board[future_x][future_y] == key:
current_board = board_list[key]
break
if future_y == 0:
player[
'position'] = future_x, future_y + database_boards.BOARD_WIDTH - 2
else:
player[
'position'] = future_x, future_y - database_boards.BOARD_WIDTH + 2
database_player.put_player_on_board(current_board, player)
else:
print(
'You need to find the teleportation orb first... (#)')
util.press_any_key()
else:
engine.move_player_to(player, future_x, future_y)
if current_board[future_x][
future_y] in database_items.item_database:
item = database_items.item_database[current_board[future_x]
[future_y]]
if item['type'] == 'sword':
engine.choose_weapon_to_use(player, item)
elif item['type'] == 'shield':
engine.choose_shield_to_use(player, item)
elif item['type'] == 'upgrade':
engine.add_upgrade_to_stats(player, item)
else:
engine.put_item_into_the_inv(player, item)
elif engine.is_occupied_by_npc(current_board, future_x, future_y):
npc_key = extras.encode_location(board_list, current_board,
future_x, future_y)
if npc_key in npc_dictionary:
npc = npc_dictionary[npc_key]
else:
npc = database_npc.npc_database[current_board[future_x]
[future_y]].copy()
npc_dictionary[npc_key] = npc
extras.how_is_the_npc_hp(npc)
engine.player_vs_npc(player, npc, future_x, future_y)
if player['hp'] == 0:
is_running = False
util.clear_screen()
def play_outro(board, enemy):
util.clear_screen()
print('\n\n')
ui.display_board(board, 9, enemy)
time.sleep(1)
for index in range(3):
util.clear_screen()
board[8][17] = ' '
print('\n\n')
ui.display_board(board, 9, enemy)
time.sleep(0.5)
util.clear_screen()
board[8][17] = '👁 '
print('\n\n')
ui.display_board(board, 9, enemy)
time.sleep(0.7)
util.clear_screen()
board[8][17] = ' '
print('\n\n')
ui.display_board(board, 9, enemy)
time.sleep(1.4)
board[8][17] = '🤴🏼'
timer = [0.7, 0.4, 0.2, 0.1, 0.1, 0.1]
for wait in timer:
for index in range(5):
display_mode = int('1' + str(index))
util.clear_screen()
print('\n\n')
ui.display_board(board, display_mode, enemy)
time.sleep(wait)
time.sleep(1.5)
messages = [['Cr', 'ea', 'te', 'd ', 'by', ': '], ['So', 'mo', 'sk', 'öv', 'i ', 'Be', 'nc', 'e ', '& '], ['Hu', 'be', 'r ', 'Ge', 'rg', 'ő '],
[' '], ['Sp', 'ec', 'ia', 'l ', 'Th', 'an', 'ks', ' t', 'o ', 'Co', 'de', 'Co', 'ol']]
for row, message in enumerate(messages):
for index, char in enumerate(message):
x_pos = int('1' + str(row))
board[x_pos][index + 2] = char
util.clear_screen()
print('\n\n')
ui.display_board(board, 14, enemy)
time.sleep(0.2)
time.sleep(1)
return board
def main():
# initial level
level = 'BOARD_1'
# initial key
key = ''
menu_start.run()
ui.print_message('\n\n\n LEVEL %s \n\n\n' % (level[-1]))
time.sleep(1.0)
util.clear_screen()
pass_key_input = False
while level != 'WIN' and level != 'QUIT' and level != 'LOSE':
util.clear_screen()
pass_key_input = False
view.print_table(players.data_to_print(dictionaries.player))
# Set up board
global BOARD_1
global BOARD_2
global BOARD_3
# global items_u_will_use
# global coordonate_of_items_that_u_will_use
# player = create_player()
BOARD_1 = engine.create_board()
BOARD_2 = engine.create_board()
BOARD_3 = engine.create_board()
BOARD_1, items_u_will_use_1, coordonate_of_items_that_u_will_use_1 = engine.create_final_board(BOARD_1, little_boss_1)
BOARD_2, items_u_will_use_2, coordonate_of_items_that_u_will_use_2 = engine.create_final_board(BOARD_2, little_boss_2)
BOARD_3, items_u_will_use_3, coordonate_of_items_that_u_will_use_3 = engine.create_final_board(BOARD_3, boss)
BOARD_1 = engine.create_board()
BOARD_2 = engine.create_board()
BOARD_3 = engine.create_board()
util.clear_screen()
is_running = True
while is_running:
print()
print("U entered first level")
print()
items_u_will_use_1, coordonate_of_items_that_u_will_use_1 = engine.items_and_coordonates_that_u_can_use(BOARD_1)
(BOARD_1, items_u_will_use, coordonate_of_items_that_u_will_use_1) = engine.create_final_board(BOARD_1, little_boss_1)
(BOARD_1, items_u_will_use_1, coordonate_of_items_that_u_will_use_1) = engine.put_player_on_board(BOARD_1, little_boss_1)
engine.move_something_and_gate(BOARD_1, player, little_boss_1, gate_1)
if player['player_life'] > 0:
print()
print("U entered second level")
print()
items_u_will_use_2, coordonate_of_items_that_u_will_use_2 = engine.items_and_coordonates_that_u_can_use(BOARD_2)
(BOARD_2, items_u_will_use_2, coordonate_of_items_that_u_will_use_2) = engine.create_final_board(BOARD_2, little_boss_2)
engine.move_something_and_gate(BOARD_2, player, little_boss_2, gate_2)
if player['player_life'] > 0:
print()
print("U entered the third level")
print()
items_u_will_use_3, coordonate_of_items_that_u_will_use_3 = engine.items_and_coordonates_that_u_can_use(BOARD_3)
(BOARD_3, items_u_will_use_3, coordonate_of_items_that_u_will_use_3) = engine.create_final_board(BOARD_3, boss)
engine.move_something_and_gate(BOARD_3, player, boss, gate_3)
# ui.display_board(board)
key = util.key_pressed()
if key == 'q':
is_running = False
# elif key == 'i':
# print(inventory)
is_running = False
# util.clear_screen()
print(key)
# break
# ui.display_board(board)
key = util.key_pressed()
# if key == 'q':
# is_running = False
# elif key == 'i':
# print(inventory)
# util.clear_screen()
print(key)
# Display essential info
ui.print_player_essential_atributes(dictionaries.player)
# Display board
ui.display_board(board)
# Message panel intoduction (always displayed)
ui.print_message(' MESSAGE PANEL \n' + 17 * '-' + '\n')
# Interaction whit items
# Display inventory
if key == 'i':
ui.print_message('This is your inventory content: ')
ui.print_table(dictionaries.inventory)
# Interaction with other characters
# Insert secret code
if key == "c":
engine.use_secret_code(dictionaries.player, dictionaries.others, level, dictionaries.codes)
# Gate and level change handling
# if engine.player_enters_gate() != level:
# util.clear_screen()
# level = engine.player_enters_gate()
if level == 'BOARD_2' or level == 'BOARD_3':
dictionaries.player['position_y'] = 15
dictionaries.player['position_x'] = 3
if level == 'WIN':
pass_key_input = True
pass
else:
ui.print_message('\n\n\n LEVEL %s \n\n\n' % (level[-1]))
time.sleep(1.0)
util.clear_screen()
pass_key_input = True
# Player input
if pass_key_input is False:
key = util.key_pressed()
# Movement
if pass_key_input is False:
pass
# engine.movement()
# Check if quit
if key == 'q':
quit_assertion = ''
while quit_assertion != 'y' and quit_assertion != 'n':
util.clear_screen()
print('Are you sure you want to quit? ( Y / N )')
quit_assertion = util.key_pressed()
if quit_assertion == 'y':
level = 'QUIT'
elif quit_assertion == 'n':
pass
else:
pass
if dictionaries.player['player_life'] == 0:
level = 'LOSE'
if level == 'WIN':
util.clear_screen()
ui.display_board(board)
print(text2art("VICTORY!", font='block', chr_ignore=True))
elif level == 'LOSE':
util.clear_screen()
ui.display_board(board)
print(text2art("GAME OVER!", font='block', chr_ignore=True))
time.sleep(10.7)
print('\n\n\n Goodbye, see you soon!')
time.sleep(1.0)
def main():
MUSIC_FILE = "Cookie Monster Sings C is for Cookie.wav"
mixer.init()
mixer.music.load(MUSIC_FILE)
mixer.music.play()
view.print_images(data_manager.read_file_record('ascii-art.txt'))
view.start_descriptions()
# initial level
level = 'BOARD_1'
# initial key
key = ''
menu_start.run()
ui.print_message('\n\n\n LEVEL %s \n\n\n' % (level[-1]))
time.sleep(1.0)
util.clear_screen()
pass_key_input = False
while level != 'WIN' and level != 'QUIT' and level != 'LOSE':
util.clear_screen()
pass_key_input = False
view.print_table(players.data_to_print(dictionaries.player))
# Set up board
board = engine.create_board(dictionaries.BOARD[level])
board = engine.put_other_on_board(board, dictionaries.others, level)
board = engine.put_item_on_board(board, dictionaries.items, level)
board = engine.put_player_on_board(board, dictionaries.player)
# Display essential info
ui.print_player_essential_atributes(dictionaries.player)
# Display board
ui.display_board(board)
# Message panel intoduction (always displayed)
ui.print_message(' MESSAGE PANEL \n' + 17 * '-' + '\n')
# Interaction whit items
engine.item_vs_player(dictionaries.inventory, dictionaries.items,
dictionaries.player, level, dictionaries.items)
# Display inventory
if key == 'i':
ui.print_message('This is your inventory content: ')
ui.print_table(dictionaries.inventory)
# Display statistics
if key == "p":
engine.show_statistics(dictionaries.player)
# Interaction with other characters
if engine.player_meets_other(dictionaries.others, dictionaries.player,
level, board) != False:
other = engine.player_meets_other(dictionaries.others,
dictionaries.player, level,
board)
if dictionaries.others[other]['other_type'] == 'enemy':
engine.fight(dictionaries.player, dictionaries.others, other,
dictionaries.inventory, dictionaries.items)
elif dictionaries.others[other]['other_type'] == 'quiz':
engine.player_vs_other_quiz(
dictionaries.player, other, dictionaries.others,
dictionaries.inventory,
dictionaries.others[other]['questions'])
# Insert secret code
if key == "c":
engine.use_secret_code(dictionaries.player, dictionaries.others,
level, dictionaries.codes)
# Gate and level change handling
if engine.player_enters_gate(
level, dictionaries.BOARD, dictionaries.player, key,
dictionaries.inventory, dictionaries.others) != level:
util.clear_screen()
level = engine.player_enters_gate(level, dictionaries.BOARD,
dictionaries.player, key,
dictionaries.inventory,
dictionaries.others)
if level == 'BOARD_2' or level == 'BOARD_3':
dictionaries.player['position_y'] = 15
dictionaries.player['position_x'] = 3
if level == 'WIN':
pass_key_input = True
pass
else:
ui.print_message('\n\n\n LEVEL %s \n\n\n' % (level[-1]))
time.sleep(1.0)
util.clear_screen()
pass_key_input = True
# Player input
if pass_key_input == False:
key = util.key_pressed()
# Movement
if pass_key_input == False:
engine.movement(board, dictionaries.player, key,
dictionaries.others)
# Check if quit
if key == 'q':
quit_assertion = ''
while quit_assertion != 'y' and quit_assertion != 'n':
util.clear_screen()
print('Are you sure you want to quit? ( Y / N )')
quit_assertion = util.key_pressed()
if quit_assertion == 'y':
level = 'QUIT'
elif quit_assertion == 'n':
pass
else:
pass
if dictionaries.player['player_life'] == 0:
level = 'LOSE'
if level == 'WIN':
util.clear_screen()
ui.display_board(board)
print(text2art("VICTORY!", font='block', chr_ignore=True))
elif level == 'LOSE':
util.clear_screen()
ui.display_board(board)
print(text2art("GAME OVER!", font='block', chr_ignore=True))
time.sleep(10.7)
ui.authors_presentation()
players.add_results(players.count_points(), "results.txt")
print('\n\n\n Goodbye, see you soon!')
time.sleep(1.0)
with Image.open("cookiemonster.jpg") as img:
img.show()
player['x'] = 1
player['y'] = 1
while player['level'] == 4 and player['HP'] > 0:
clear_screen()
player = engine.boss(player)
if player['HP'] == 0:
clear_screen()
ui.display_board(engine.create_board("Messages/restart.txt"))
key = key_pressed()
if key == "n":
return player
if key == "y":
player['HP'] = 100
return player
if __name__ == '__main__':
while True:
clear_screen()
start_screen.main()
clear_screen()
player = main()
clear_screen()
t_end = time.time() + 5
if player['level'] == 5:
ui.display_board(engine.create_board("Messages/win.txt"))
time.sleep(5)
if player['level'] != 5:
ui.display_board(engine.create_board("Messages/lose.txt"))
time.sleep(5)
def play_game(player, board):
win_game = False
ui.display_dialog_window(
"You are a Hero. Leading a wasteful life, you are running out of money. Fortunately, you have\nheard that in the nearby village of Codecools Gate, residents will generously pay for getting\nrid of the rat plague, so you decided to quickly hit the road to anticipate the competitors.\n\nRiding the village on your musk deer, you hear the screams of a villager.\n\nPress 'C' to continue."
)
while True:
key = key_pressed().lower()
if key == "c":
clear_screen()
hero = list_stats(player['stats'], player)
ui.display_board(board, hero)
ui.display_dialog_window(
"To interact with NPC('!', '?'), doors ('/'), chests('$') and monsters ('*', 'G', 'N', 'S') just go to their place.\n\nTo check your inventory press 'I'.\n\nTo quit game, press 'Q'.\n\nMove your character with keys: 'W', 'A', 'S', 'D'."
) #
while True:
key = key_pressed().lower()
# board = engine.create_board(BOARD_WIDTH, BOARD_HEIGHT)
last_position = [player['y'], player['x']]
# hero_statistics = player["stats"]
hero = list_stats(player['stats'],
player) # Create a list of hero stats
items = player['items']
if key == 'q':
break
elif key == 'i':
clear_screen()
while True:
ui.display_items(items)
key = key_pressed().lower()
if key == 'q':
break
else:
clear_screen()
elif key == 'z':
clear_screen()
elif key.lower() in 'wsad':
# TOTALY NEW
changing_position = change_position(
CONTROL_DICT[key], player, board)
player['Map'] = changing_position[2]['Map']
map_elements.insert(0, changing_position[0])
win_game = changing_position[5]
if changing_position[1] != False:
board = changing_position[1]
player['x'] = changing_position[2]['x']
player['y'] = changing_position[2]['y']
# player['stats'] = changing_position[2]['stats']
elif changing_position[3] != False:
player = changing_position[2]
ui.display_dialog_window(
'You recieve a new item! Open inventory to check what is it'
)
# print(player)
key_pressed()
elif changing_position[4] != False:
player["Kills"] += 1
player['stats'] = check_level(player)
board = engine.put_player_on_board(board, player,
map_elements,
last_position)
# TOTALY NEW
clear_screen()
if player['stats']['HP'] <= 0:
end = end_game.end_game(
'die'
) # the 'end' depends from the life of Necromancer-rat
key_pressed()
points = int(player['Kills']) * 1000
save_highscore.save_result(player['name'], points,
player['race'], player['class'])
# clear_screen()
break
elif win_game != False:
end_game.end_game('win')
key_pressed()
points = int(player['Kills']) * 1000
save_highscore.save_result(player['name'], points,
player['race'], player['class'])
break
ui.display_board(board, hero)
break
import grid
import ui
#import curses
#note that I chose this instead of import *,
#that way anytime a function is called we know what module it is from
#Clear screen
#curses.initscr()
#Initialize the board:
board, grid_size, squaresize = ui.initialize_game()
#Play
players = [1,2]
no_winner = True
while(no_winner):
for player in players:
ui.display_board(board,squaresize)
dir, number = ui.move(player,board)
grid.evolve(board,dir,number,player)
if grid.is_winner(board,player):
winner = player
ui.display_board(board,squaresize)
no_winner = False
break
elif not grid.check_all_moves(board):
#stalemate
no_winner = False
for i in range(5):
print "Stalemate :( :( :( :( :( :( :( :( :("
break
def main():
player = create_player()
board = engine.create_board(BOARD_WIDTH, BOARD_HEIGHT)
util.clear_screen()
level = 1
inventory = {
"Pierogi": 5,
"Bigos": 5,
"Złom": 5,
"Sliptape": 5,
"Ropa": 5,
"Działko": 5
}
if level == 1:
# import text from ASCII file
title = ui.get_ascii("./ascii_files/poland_can_into_space.txt")
# displays ASCII file with color defined by number
ui.display_ascii(title, font_colors=[34], spacing=5)
input(" ")
os.system('cls')
print("\n\n")
txt = "Rok 2030. Trwa wyścig światowych mocarstw o każdy kawłek lądu. Pewnej nocy na niebie pojawia się tajemnicza anomalia... "
ui.print_text(txt, font_color=33)
# import text from ASCII file
anomaly = ui.get_ascii("./ascii_files/saturn.txt")
# displays ASCII file with color defined by number
ui.display_ascii(anomaly, font_colors=[35], spacing=5)
input(" ")
os.system('cls')
# import text from ASCII file
im = ui.get_ascii("./ascii_files/roz1.txt")
# displays ASCII file with color defined by number
ui.display_ascii(im, font_colors=[31], spacing=1)
input(" ")
os.system('cls')
txt = ('''
Po Twojej głowie wędruje wyłącznie jedna myśl. To jest mój czas. Muszę polecieć i zbadać tajemniczą anomalię.
Postanawiasz przerobić swojego Golfa 1.9 TDI pieszczotliwie nazywanego Gulfem na statek kosmiczny i niezwłocznie wyruszyć w drogę.'''
)
ui.print_text(txt, font_color=33)
input(" ")
os.system('cls')
mum_house = engine.generate_game_board_1(board)
is_running = True
while is_running:
x = player['player_x_position']
y = player['player_y_position']
engine.add_to_inventory(player, mum_house, inventory)
temporary_board = deepcopy(mum_house)
engine.put_player_on_board(temporary_board, player)
ui.display_board(temporary_board)
engine.display_players_card(inventory)
# print(f"Player position: ({x},{y})")
key = util.key_pressed()
if key == 'q':
is_running = False
else:
engine.player_moves(key, mum_house, player)
util.clear_screen()
pass_condition = engine.chceck_inventory(inventory, level)
if engine.exit_board(level, player) == True:
if pass_condition == True:
is_running = False
level = 2
else:
is_running = True
if level == 2:
txt = (
'''Wyszedłeś na miasto. Uzupełnij zasoby, zdobądź paliwo, osłony i działa do statku.'''
)
ui.print_text(txt, font_color=33)
input(" ")
os.system('cls')
city = engine.generate_game_board_2(board)
is_running = True
while is_running:
x = player['player_x_position']
y = player['player_y_position']
engine.add_to_inventory(player, city, inventory)
temporary_board = deepcopy(city)
engine.put_player_on_board(temporary_board, player)
ui.display_board(temporary_board)
engine.display_players_card(inventory)
# print(f"Player position: ({x},{y})")
key = util.key_pressed()
if key == 'q':
is_running = False
else:
engine.player_moves(key, city, player)
util.clear_screen()
inventory = engine.exchange_of_goods(player, inventory)
engine.ferdek(player)
inventory = engine.get_blasters(player, inventory)
pass_condition = engine.chceck_inventory(inventory, level)
if engine.exit_board(level, player) == True:
if pass_condition == True:
engine.going_to_the_moon()
level = 3
is_running = False
elif engine.exit_board(level, player) == False:
is_running = True
if level == 3:
player['player_x_position'] = PLAYER_START_X
player['player_y_position'] = PLAYER_START_Y
board = engine.create_board(21, 15)
util.clear_screen()
board_level_2 = engine.maze_generator(board)
engine.put_quizzes(board_level_2)
engine.put_memes(board_level_2)
is_running = True
level_2 = True
while is_running:
engine.level_2_start()
while level_2:
engine.quiz_function(board_level_2, player)
engine.meme_function(board_level_2, player)
temporary_board = deepcopy(board_level_2)
engine.put_player_on_board(temporary_board, player)
engine.display_maze_status(player)
ui.display_maze(temporary_board, player)
key = util.key_pressed()
if key == 'q':
is_running = False
else:
engine.player_moves(key, temporary_board, player)
util.clear_screen()
level_4 = player['player_*']
if level_4 > 7:
level = 4
is_running = False
level_2 = False
if level == 4:
txt = (
"Po latach podrózy i licznych przeszkodach na horyzoncie ukazuje się anomalia. Aby do niej dotrzeć musisz zmierzyć się z obcymi..."
)
ui.print_text(txt, font_color=33)
input()
os.system("cls||clear")
level_3 = True
player['player_x_position'] = PLAYER_START_X
player['player_y_position'] = PLAYER_START_Y
board_level_3 = engine.create_board(BOARD_WIDTH_lvl3,
BOARD_HEIGHT_lvl3)
im = ui.get_ascii(
"./ascii_files/battle.txt") #import text from ASCII file
ui.display_ascii(
im, font_colors=[31],
spacing=1) #displays ASCII file with color defined by number
input()
os.system('cls')
counter = 0
engine.intro_lvl3()
while level_3:
counter += 1
temporary_board = deepcopy(board_level_3)
engine.put_player_on_board(temporary_board, player)
level_3 = engine.play_level3(temporary_board, player, counter)
if level_3:
ui.display_board(temporary_board)
is_running = False
util.clear_screen()
level = 5
if level == 5:
engine.end_game()
def main():
inventory_enabled = False
hint_enabled = False
intro()
current_question = engine.questions_generator(0)
q_index = 0
player = Player(ui.get_input('Choose a name for your character: '),
FIRST_MAP_START_X, FIRST_MAP_START_Y, PLAYER_ICON,
PLAYER_HP)
is_running = True
board = data_manager.create_map_from_file('map_one')
board[FIRST_MAP_START_Y][FIRST_MAP_START_X] = player.icon
ui.display_board(board)
print(player)
player.display_hp()
'''engine.save_highscore(player)'''
while is_running:
key = key_pressed()
if key == 'q':
is_running = False
if key == 'z':
clear_screen()
if key == 'i':
if not inventory_enabled:
player.display_hp()
ui.show_inventory(player, board)
inventory_enabled = True
hint_enabled = False
else:
ui.display_board(board)
print(player)
inventory_enabled = False
if key == 'k':
if not hint_enabled:
ui.display_board(board)
print(player)
player.display_hp()
player.show_hint()
hint_enabled = True
inventory_enabled = False
else:
ui.display_board(board)
print(player)
hint_enabled = False
if key == 'u':
player.use_potion()
ui.display_board(board)
print(player)
player.display_hp()
if inventory_enabled:
ui.show_inventory(player, board)
if key in ['w', 'a', 's', 'd']:
player.message = ''
board, current_question, q_index = engine.put_player_on_board(
board, player, key, player.current_map, current_question,
q_index)
ui.display_board(board)
print(player)
player.display_hp()
player.show_message()
if inventory_enabled:
ui.show_inventory(player, board)
if player.hp <= 0:
is_running = False
boss.display_screen('lose.txt')
def print_level(board, message, player, print_method, top, lit_range=0):
print(" ┌─────────────────────────────────────────────────────────────────────────────────────────────┐")
print(' │' + TextFormat.Bold + top.center(93) + TextFormat.RESET_ALL + '│')
print(" └─────────────────────────────────────────────────────────────────────────────────────────────┘ ")
ui.display_board(board, print_method, player, lit_range)
print(' ☯︎ ' + message)
def main():
pygame.mixer.init()
engine.sound(engine._songs[0])
level = 1
game_window = ui.create_new_game_window(ui.SCREEN_WIDTH, ui.SCREEN_HEIGHT)
player = create_player()
board = engine.create_board(level)
# PRINT INTRO MENU SCREEN (AND QUIT GAME IF USER CHOOSE SO)
if introduction_screen.intro_menu_select(game_window) == -1:
return 0
# VARIABLES TO HOLD KEYBOARD AND MOUSE INPUT
key = libtcod.Key()
mouse = libtcod.Mouse()
libtcod.console_clear(game_window)
try:
if level == 1:
engine.sound(engine._songs[2])
while not libtcod.console_is_window_closed():
# WAIT FOR INPUT
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS, key, mouse)
# DISPLAY BOARD + PLAYER ON BOARD
ui.display_board(board, game_window)
ui.display_bar(player, game_window, board)
engine.put_player_on_board(game_window, ui.SCREEN_WIDTH,
ui.SCREEN_HEIGHT, board, player)
# GATHER KEY INPUT
action = handle_keys(key)
move = action.get(
'move') # nazwy - do przeczytania np. should_move, is_exit
go_to_inventory = action.get('go_to_inventory')
fullscreen = action.get('fullscreen')
exit = action.get('exit')
# HANDLE USER INPUT
if player["hps"] == 0:
ui.final_screen(game_window, 'loose')
if move:
dx, dy = move
player = engine.verify_move_is_possible(
dx, dy, board, player, level, monsters.monsters_overview())
footsteps_sound = pygame.mixer.Sound("walk.wav")
footsteps_sound.set_volume(0.2)
footsteps_sound.play(maxtime=1000)
if engine.is_next_level(player["position"]["x"],
player["position"]["y"], board,
ui.EXIT_SYMBOL):
level += 1
board = engine.create_board(level)
player['position']['x'] = player_def.PLAYER_START_X
player['position']['y'] = player_def.PLAYER_START_Y
player['lvl'] += 1
player['experience'] += level * 15
player['strenght'] += level * 15
if go_to_inventory:
ui.display_inventory(player, game_window)
if fullscreen:
libtcod.console_set_fullscreen(
not libtcod.console_is_fullscreen())
if exit:
return True
except IndexError:
print('You went out of board bounds, please start the game again')
def main(player, board):
global word_used
board_with_player = engine.put_player_on_board(board, player)
clear_screen(40)
ui.display_board(board_with_player, player)
print(f"\n\tPLAYER X:{player['x']} Y:{player['y']}")
key = key_pressed()
around_player = 2
# collisions check
no_obstacle_on_up = board[player["y"]-around_player][player["x"]] in PASSABLE and board[player["y"]-around_player][player["x"]+1] in PASSABLE
no_obstacle_on_down = board[player["y"] + around_player][player["x"]] in PASSABLE and board[player["y"] + around_player][player["x"]+1] in PASSABLE
no_obstacle_on_left = board[player["y"]][player["x"]-around_player] in PASSABLE and board[player["y"]+1][player["x"]-around_player] in PASSABLE
no_obstacle_on_right = board[player["y"]][player["x"]+around_player] in PASSABLE and board[player["y"]+1][player["x"]+around_player] in PASSABLE
no_obstacle_on_leftUP = board[player["y"]-around_player][player["x"]-around_player] in PASSABLE
no_obstacle_on_rightUP = board[player["y"]-around_player][player["x"]+around_player] in PASSABLE
no_obstacle_on_leftDOWN = board[player["y"] + around_player][player["x"]-around_player] in PASSABLE
no_obstacle_on_rightDOWN = board[player["y"] + around_player][player["x"]+around_player] in PASSABLE
# move keys pressed
move_keys = sum(KEY_BINDINGS_MOVE.values(),[])
if key in move_keys:
# vertical movement
if key in KEY_BINDINGS_MOVE["up"] and no_obstacle_on_up:
player["y"] -= 1
elif key in KEY_BINDINGS_MOVE["down"] and no_obstacle_on_down:
player["y"] += 1
# horiontal movement
elif key in KEY_BINDINGS_MOVE["left"] and no_obstacle_on_left:
player["x"] -= 1
elif key in KEY_BINDINGS_MOVE["right"] and no_obstacle_on_right:
player["x"] += 1
# diagonal movement
elif key in KEY_BINDINGS_MOVE["leftUP"] and no_obstacle_on_leftUP:
player["x"] -= 1
player["y"] -= 1
elif key in KEY_BINDINGS_MOVE["rightUP"] and no_obstacle_on_rightUP:
player["x"] += 1
player["y"] -= 1
elif key in KEY_BINDINGS_MOVE["leftDOWN"] and no_obstacle_on_leftDOWN:
player["x"] -= 1
player["y"] += 1
elif key in KEY_BINDINGS_MOVE["rightDOWN"] and no_obstacle_on_rightDOWN:
player["x"] += 1
player["y"] += 1
# item collisions
if board[player["y"]][player["x"]] in PICKUPS or board[player["y"]][player["x"]+1] in PICKUPS:
board[player["y"]][player["x"]-1] = " "
board[player["y"]][player["x"]] = " "
board[player["y"]][player["x"]+1] = " "
fight_result = False
# enemy collision
if board[player["y"]][player["x"]] in ENEMIES["small"]["icon"] or board[player["y"]][player["x"]+1] in ENEMIES["small"]["icon"]:
fight_result = enemies.fight_with_monsters_small(player)
if board[player["y"]][player["x"]] in ENEMIES["big"]["icon"] or board[player["y"]][player["x"]+1] in ENEMIES["big"]["icon"]:
fight_result = enemies.fight_with_monsters_large(player)
if fight_result:
board[player["y"]][player["x"]-1] = " "
board[player["y"]][player["x"]] = "†"
board[player["y"]][player["x"]+1] = " "
ui.player_say(board_with_player, player, "Another one bites the dust!")
key_pressed()
# key binded options
elif key in KEY_BINDINGS["overlay"]: # OVERLAY TEST
ui.show_overlay(board_with_player)
clear_screen()
ui.display_board(board_with_player, player)
input()
elif key in KEY_BINDINGS["customize"]:
engine.customize_character(player)
elif key in KEY_BINDINGS["logo"]:
ui.show_logo_animation(LOGO)
elif key in KEY_BINDINGS["story"]:
ui.show_story()
elif key in KEY_BINDINGS["verbal_attack"]:
word_used, board = ui.verbal_attack(board_with_player, board, player, word_used)
key_pressed()
elif key in KEY_BINDINGS["generator"]:
engine.generate_new_map(board, player)
elif key in KEY_BINDINGS["clear"]:
clear_screen(0)
elif key in KEY_BINDINGS["inventory"]:
ui.display_inv()
print("1.Heal", "2.Regen", "~~~Enter to Exit")
option = input()
if option == "1":
if "HP Potion" in ui.inv:
player["HP"] += 4 + player["intelligence"]
# If current HP >= maxHP currentHP=MaxHP
if player["HP"] >= player["max_hp"]:
player["HP"] = player["max_hp"]
ui.inv.remove("HP Potion")
else:
print("No potions")
pass
if option == "2":
if "Mana Potion" in ui.inv:
player["MP"] += 10 + player["intelligence"]
ui.inv.remove("Mana Potion")
else:
print("No potions")
if option == "3":
#pass
player["experience"] += 100 # Cheat
player["HP"] = 10
stats.level_up(player)
elif key in KEY_BINDINGS["stats"]:
stats.display_advenced_stats(player) # Display stats like attack dmg
enemies.fight_with_monsters_small(player)
pass
elif key in KEY_BINDINGS["exit"]:
return
stats.small_monster_hp = 10
stats.large_monster_hp = 20
main(player, board)
def main():
global player
player = create_player()
while player['level'] == 1 and player['HP'] > 0:
try:
file_name = 'Levels/lvl1.txt'
enemies_list = enemies.create_enemies_list(file_name)
player = level_one_start(player, enemies_list, file_name)
except AssertionError:
break
if player["HP"] <= 0:
clear_screen()
ui.display_board(engine.create_board("Messages/restart.txt"))
key = key_pressed()
if key == "n":
return player
if key == "y":
player["HP"] = 50
player['x'] = 1
player['y'] = 1
while player['level'] == 2 and player["HP"] > 0:
try:
file_name = 'Levels/lvl2.txt'
enemies_list = enemies.create_enemies_list(file_name)
player = level_two_start(player, enemies_list, file_name)
except AssertionError:
break
if player["HP"] <= 0:
clear_screen()
ui.display_board(engine.create_board("Messages/restart.txt"))
if key == "n":
return player
if key == "y":
player["HP"] = 50
player['x'] = 1
player['y'] = 1
while player['level'] == 3 and player['HP'] > 0:
try:
file_name = 'Levels/lvl3.txt'
enemies_list = enemies.create_enemies_list(file_name)
player = level_three_start(player, enemies_list, file_name)
except AssertionError:
break
if player["HP"] <= 0:
clear_screen()
ui.display_board(engine.create_board("Messages/restart.txt"))
key = key_pressed()
if key == "n":
return player
if key == "y":
player["HP"] = 50
player['x'] = 1
player['y'] = 1
while player['level'] == 4 and player['HP'] > 0:
clear_screen()
player = engine.boss(player)
if player['HP'] == 0:
clear_screen()
ui.display_board(engine.create_board("Messages/restart.txt"))
key = key_pressed()
if key == "n":
return player
if key == "y":
player['HP'] = 100
return player
def level_one_start(player, enemies_list, file_name):
# Creating objects and items
item_one = items.create_apple(10, 1)
item_two = items.create_banana(23, 6)
item_three = items.create_knife(15, 14)
item_four = items.create_shoes(63, 5)
item_five = items.create_apple(35, 27)
item_six = items.create_banana(77, 2)
# Creating interactions
objects_one = [player, item_one]
objects_two = [player, item_two]
objects_three = [player, item_three]
objects_four = [player, item_four]
objects_five = [player, item_five]
objects_six = [player, item_six]
is_running = True
ui.display_board(engine.create_board("Messages/message_lvl1.txt"))
time.sleep(1)
while is_running:
key = key_pressed()
clear_screen()
if key == 'q':
assert False
board = engine.create_board(file_name)
lift = player['capacity']
lift_list = lift.split("/")
engine.put_gate(board, player)
if int(lift_list[0]) < 100:
player = engine.player_coordinates_change(key, player, board)
board = engine.put_player_on_board(board, player)
if player['x'] == 77 and player['y'] == 28:
player['level'] = 2
is_running = False
for index in range(len(enemies_list)):
enemy = enemies_list[index]
if enemy['HP'] > 0:
enemy = engine.enemy_movement(board, enemy)
board = engine.put_enemies_on_board(board, enemy)
fight = engine.enemy_board_interaction(board, enemy, player)
player = fight[0]
enemy = fight[1]
enemies_list[index] = enemy
if item_one['on_board'] == 1:
board = engine.put_items_on_board(board, item_one)
player = objects_one[0]
item_one = objects_one[1]
objects_one = engine.item_board_interaction(board, item_one, player)
if item_two['on_board'] == 1:
board = engine.put_items_on_board(board, item_two)
player = objects_two[0]
item_two = objects_two[1]
objects_two = engine.item_board_interaction(board, item_two, player)
if item_three['on_board'] == 1:
board = engine.put_items_on_board(board, item_three)
player = objects_three[0]
item_three = objects_three[1]
objects_three = engine.item_board_interaction(board, item_three, player)
if item_four['on_board'] == 1:
board = engine.put_items_on_board(board, item_four)
player = objects_four[0]
item_four = objects_four[1]
objects_four = engine.item_board_interaction(board, item_four, player)
if item_five['on_board'] == 1:
board = engine.put_items_on_board(board, item_five)
player = objects_five[0]
item_five = objects_five[1]
objects_five = engine.item_board_interaction(board, item_five, player)
if item_six['on_board'] == 1:
board = engine.put_items_on_board(board, item_six)
player = objects_six[0]
item_six = objects_six[1]
objects_six = engine.item_board_interaction(board, item_six, player)
if player['HP'] <= 0:
print("Game over")
return player
engine.put_gate(board, player)
ui.display_board(board)
ui.display_inventory(player)
return player
def start(current_board, player):
print('Current City District Visited: ',
extras.board_level_info(current_board))
extras.how_occupied_belly(player)
database_player.put_player_on_board(current_board, player)
ui.display_board(current_board)
def main():
util.clear_screen()
# player info setup
name = input(f"{first_line}Podaj swoje imię: ")
interaction.characters["hero"]["name"] = name
util.clear_screen()
text = f"{first_line}Witaj przybyszu!\n\tSłyszałem, że zwą Cię {name}.\
\n\n\tDzisiaj Twój chrześniak ma urodziny. Gówniak musi, MUSI dostać świeżaka.\
\n\tRozpieszczony smarkacz..."
open_text(text)
text = f"{first_line}Jak ja nie lubię szczeniaka, \
ale jak mus to mus, w końcu chrześniak."
open_text(text)
text = f"{first_line}Niestety, we wszystkich sklepach z rozjechanym \
robakiem już nie mają naklejek.\
\n\tZostaje Ci zebrać w inny sposób te wszystkie naklejki.\
\n\n\tRuszaj do boju, bo bez tego wstrętnego świeżaka nie uda Ci się wbić \
na imprezę.\
\n\tW końcu 8. urodziny to nie przelewki!"
open_text(text, 20)
text = f"{first_line}Przygotuj się na ciężkie boje, bo te wszystkie moherowe berety,\
\n\tJanusze oraz cała gimbaza nie dadzą Ci ich za darmo.\
\n\n\tAle najbardziej musisz uważać na strażników miejskich \
(cholerne pasożyty, nawet piwa nie można się napić) i Madki.\
\n\tZ nimi to już nie przelewki.\
\n\n\tNa szczęście pracownicy biedronki są zawsze po Twojej stronie, \
w końcu kończyli razem z Tobą studia."
open_text(text, 20)
text = f"{first_line}A więc ruszaj do boju, bo PICCOLO i 0,5l \
wody gazowanej już się dla Ciebie chłodzą!"
open_text(text, 5)
open_text("", 5, True)
# level 1
board = engine.create_board(BOARD_WIDTH, BOARD_HEIGHT)
engine.get_spawn_pos(board, player)
util.clear_screen()
engine.put_friends_on_board(board, engine.friend_list)
engine.put_enemies_on_board(board, engine.enemy_list)
engine.next_level_pass(board, player)
is_running = True
while is_running:
engine.put_player_on_board(board, player)
ui.display_stats()
ui.display_board(board)
key = util.key_pressed()
if key == "q":
exit_game = ""
while exit_game not in ["Y", "N"]:
util.clear_screen()
print(f"{first_line}Czy na pewno chcesz wyjść z gry? Y/N")
exit_game = util.key_pressed().upper()
if exit_game == "Y":
is_running = False
else:
# movement
level_change = engine.movement(key, player, board)
if level_change:
can_he_pass = engine.levels_generator(level_change)
if can_he_pass:
board = engine.create_board(BOARD_WIDTH, BOARD_HEIGHT)
engine.get_spawn_pos(board, player)
engine.next_level_pass(board, player, can_he_pass)
engine.put_friends_on_board(board, engine.friend_list)
engine.put_enemies_on_board(board, engine.enemy_list,
can_he_pass)
util.clear_screen()
engine.mobs_movement(board, engine.mobs_on_board, player)
engine.mobs_movement(board, engine.friends_on_board, player)
def player_is_going_throug_map(maps_names, world, player_initial_position,
user_name, player_dict, player_inventory):
player_current_position = [
player_initial_position[0], player_initial_position[1]
]
enemy_dict_1 = {'name': 'Elf', 'stats': {'att': 10, 'HP': 100}}
enemy_dict_2 = {'name': 'Knight', 'stats': {'att': 45, 'HP': 130}}
enemy_dict_3 = {'name': 'Orc', 'stats': {'att': 80, 'HP': 160}}
enemy_dict_4 = {'boss': {'att': 110, 'HP': 200}}
if world == 1:
enemy_dict = enemy_dict_1
if world == 2:
enemy_dict = enemy_dict_2
if world == 3:
enemy_dict = enemy_dict_3
final_board = create_board(maps_names[world - 1])
put_player_on_board(final_board, player_dict, player_initial_position)
items_list = create_item_list()
while True:
util.clear_screen()
ui.display_board(final_board)
ui.display_stats(player_dict)
ui.display_inventory(player_inventory)
key_pressed = util.key_pressed()
effect_of_key_pressed = effect_of_key(final_board,
player_current_position,
key_pressed)
if effect_of_key_pressed == 'move':
lower_HP(player_dict)
move_player_on_board(key_pressed, final_board, player_dict,
player_current_position)
update_curr_player_posit(player_current_position, key_pressed)
elif effect_of_key_pressed == 'blocked':
continue
elif effect_of_key_pressed == 'food':
higher_HP(player_dict)
move_player_on_board(key_pressed, final_board, player_dict,
player_current_position)
update_curr_player_posit(player_current_position, key_pressed)
elif effect_of_key_pressed == 'item':
#pick random item from item list
###dopisane Roman
picked_item = draw_item(items_list)
add_to_inventory(player_inventory, items_list, picked_item)
update_player_stats(player_dict, items_list, picked_item)
#add to inventory
#update stats ```ROMAN DZIAŁA NAD TYM```
move_player_on_board(key_pressed, final_board, player_dict,
player_current_position)
update_curr_player_posit(player_current_position, key_pressed)
elif effect_of_key_pressed == 'enemy':
# go to fight ``` ADAM TO ZROBI ```
move_player_on_board(key_pressed, final_board, player_dict,
player_current_position)
update_curr_player_posit(player_current_position, key_pressed)
enemy_encounter(player_dict, player_inventory, enemy_dict)
os.system('pause')
os.system('color 07')
enemy_dict_1 = {'name': 'Elf', 'stats': {'att': 10, 'HP': 100}}
enemy_dict_2 = {'name': 'Knight', 'stats': {'att': 45, 'HP': 130}}
enemy_dict_3 = {'name': 'Orc', 'stats': {'att': 80, 'HP': 160}}
enemy_dict_4 = {'boss': {'att': 110, 'HP': 200}}
if world == 1:
enemy_dict = enemy_dict_1
if world == 2:
enemy_dict = enemy_dict_2
if world == 3:
enemy_dict = enemy_dict_3
#return True or False#w zależności czy wygrasz czy przegrasz walkę
elif effect_of_key_pressed == 'gate':
return True
elif effect_of_key_pressed == 'boss_encounter':
enemy_dict = enemy_dict_4
enemy_encounter(player_dict, player_inventory, enemy_dict)
return False
def main():
inventory = {}
player_characteristics = engine.player_characteristics()
level_one_board = engine.level_one()
level_two_board = engine.level_two()
level_three_board = engine.level_three()
# boss_level_board_1 = engine.boss_level_1()
util.clear_screen()
# loop condition
is_running = True
# first position on level one
player = engine.create_player(3, 1)
# level one loop
while is_running:
engine.put_player_on_board(level_one_board, player)
ui.display_board(level_one_board)
ui.print_characteristics(player_characteristics)
key = util.key_pressed()
engine.player_movement(level_one_board, player, key)
engine.player_inventory(level_one_board, player, inventory)
if level_one_board[player['PLAYER_height']][player['PLAYER_width']] == colored('/', 'yellow'):
util.clear_screen()
break
if key == 'q':
is_running = False
while key == 'i':
util.clear_screen()
ui.display_board(level_one_board)
ui.print_inventory(inventory)
key = util.key_pressed()
util.clear_screen()
util.clear_screen()
# first position on level two
player = engine.create_player(3, 1)
# level two loop
while is_running:
engine.put_player_on_board(level_two_board, player)
ui.display_board(level_two_board)
ui.print_characteristics(player_characteristics)
key = util.key_pressed()
engine.player_movement(level_two_board, player, key)
engine.player_inventory(level_two_board, player, inventory)
if level_two_board[player['PLAYER_height']][player['PLAYER_width']] == colored('/', 'yellow'):
util.clear_screen()
break
if key == 'q':
is_running = False
while key == 'i':
util.clear_screen()
ui.display_board(level_two_board)
ui.print_inventory(inventory)
key = util.key_pressed()
util.clear_screen()
util.clear_screen()
# first position on level three
player = engine.create_player(2, 1)
# level three loop
while is_running:
engine.put_player_on_board(level_three_board, player)
ui.display_board(level_three_board)
ui.print_characteristics(player_characteristics)
key = util.key_pressed()
engine.player_movement(level_three_board, player, key)
engine.player_inventory(level_three_board, player, inventory)
if level_three_board[player['PLAYER_height']][player['PLAYER_width']] == colored('/', 'yellow'):
util.clear_screen()
break
if key == 'q':
is_running = False
while key == 'i':
util.clear_screen()
ui.display_board(level_three_board)
ui.print_inventory(inventory)
key = util.key_pressed()
util.clear_screen()
util.clear_screen()
# first position on boss level
player = engine.create_player(3, 1)
# boss level loop
while is_running:
boss_level_board = engine.boss_level()
engine.put_player_on_board(boss_level_board, player)
ui.display_board(boss_level_board)
ui.print_characteristics(player_characteristics)
key = util.key_pressed()
engine.player_movement_boss_level(boss_level_board, player, key)
engine.player_inventory(boss_level_board, player, inventory)
if boss_level_board[player['PLAYER_height']][player['PLAYER_width']] == colored('/', 'yellow'):
util.clear_screen()
break
if key == 'q':
is_running = False
while key == 'i':
util.clear_screen()
ui.display_board(boss_level_board)
ui.print_inventory(inventory)
key = util.key_pressed()
util.clear_screen()
util.clear_screen()
