# a tile of the map and its properties

def __init__(self, blocked, block_sight=None):

self.blocked = blocked

# all tiles start unexplored

self.explored = False

# by default, if a tile is blocked, it also blocks sight

if block_sight is None:

block_sight = blocked

# a rectangle on the map. used to characterize a room.

def __init__(self, x, y, w, h):

self.x1 = x

self.y1 = y

self.x2 = x + w

self.y2 = y + h

def center(self):

center_x = (self.x1 + self.x2) / 2

center_y = (self.y1 + self.y2) / 2

return (center_x, center_y)

def intersect(self, other):

# returns true if this rectangle intersects with another one

return (self.x1 <= other.x2 and self.x2 >= other.x1 and

# this is a generic object: the player, a monster, an item, the stairs...

# it's always represented by a character on screen.

def __init__(self, x, y, char, name, color, blocks=False, always_visible=False, fighter=None, ai=None, item=None,

equipment=None):

self.x = x

self.y = y

self.char = char

self.name = name

self.color = color

self.blocks = blocks

self.always_visible = always_visible

self.fighter = fighter

self.stopped = False

if self.fighter: # let the fighter component know who owns it

self.fighter.owner = self

self.ai = ai

if self.ai: # let the AI component know who owns it

self.ai.owner = self

self.item = item

if self.item: # let the Item component know who owns it

self.item.owner = self

self.equipment = equipment

if self.equipment: # let the Equipment component know who owns it

self.equipment.owner = self

# there must be an Item component for the Equipment component to work properly

self.item = Item()

self.item.owner = self

def move(self, dx, dy):

# move by the given amount, if the destination is not blocked

if not is_blocked(self.x + dx, self.y + dy):

self.x += dx

self.y += dy

self.stopped = False

else:

self.stopped = True

def move_towards(self, target_x, target_y):

# vector from this object to the target, and distance

dx = target_x - self.x

dy = target_y - self.y

distance = math.sqrt(dx ** 2 + dy ** 2)

# normalize it to length 1 (preserving direction), then round it and

# convert to integer so the movement is restricted to the map grid

dx = int(round(dx / distance))

dy = int(round(dy / distance))

self.move(dx, dy)

def distance_to(self, other):

dx = other.x - self.x

dy = other.y - self.y

return math.sqrt(dx ** 2 + dy ** 2)

def distance(self, x, y):

return math.sqrt((x - self.x) ** 2 + (y - self.y) ** 2)

def send_to_back(self):

# make this object be drawn first, so all others appear above it if they're in the same tile.

global objects

objects.remove(self)

objects.insert(0, self)

def draw(self):

# only show if it's visible to the player; or it's set to "always visible" and on an explored tile

if (libtcod.map_is_in_fov(fov_map, self.x, self.y) or

(self.always_visible and map[self.x][self.y].explored)):

libtcod.console_set_default_foreground(con, self.color)

libtcod.console_put_char(con, self.x, self.y, self.char, libtcod.BKGND_NONE)

def clear(self):

# erase the character that represents this object

# combat-related properties and methods (monster, player, NPC).

def __init__(self, hp, defense, power, xp, death_function=None):

self.base_max_hp = hp

self.hp = hp

self.base_defense = defense

self.base_power = power

self.xp = xp

self.death_function = death_function

@property

def power(self): # return actual power, by summing up the bonuses from all equipped items

bonus = sum(equipment.power_bonus for equipment in get_all_equipped(self.owner))

return self.base_power + bonus

@property

def defense(self): # return actual defense, by summing up the bonuses from all equipped items

bonus = sum(equipment.defense_bonus for equipment in get_all_equipped(self.owner))

return self.base_defense + bonus

@property

def max_hp(self): # return actual max_hp, by summing up the bonuses from all equipped items

bonus = sum(equipment.max_hp_bonus for equipment in get_all_equipped(self.owner))

return self.base_max_hp + bonus

def attack(self, target):

# a simple formula for attack damage

damage = self.power - target.fighter.defense

# make the target take some damage

mess = self.owner.name.capitalize() + ' attacks ' + target.name + ' for ' + str(damage) + ' hit points.'

message(mess)

event_logging(mess)

target.fighter.take_damage(damage)

def take_damage(self, damage):

# apply damage if possible

if damage > 0:

self.hp -= damage

# check for death. if there's a death function, call it

if self.hp <= 0:

function = self.death_function

if function is not None:

function(self.owner)

if self.owner != player: # yield experience to the player

player.fighter.xp += self.xp

def heal(self, amount):

# heal by the given amount, without going over the maximum

# AI for a basic monster.

def take_turn(self):

# a basic monster takes its turn. if you can see it, it can see you

monster = self.owner

if libtcod.map_is_in_fov(fov_map, monster.x, monster.y):

# move towards player if far away

if monster.distance_to(player) >= 2:

monster.move_towards(player.x, player.y)

# close enough, attack! (if the player is still alive.)

elif player.fighter.hp > 0:

# an item that can be picked up and used.

def __init__(self, use_function=None):

self.use_function = use_function

def pick_up(self):

# add to the player's inventory and remove from the map

if len(inventory) >= 5:

mes = 'Your inventory is full, cannot pick up ' + self.owner.name + '.'

message(mes, libtcod.red)

event_logging(mes)

else:

inventory.append(self.owner)

objects.remove(self.owner)

mes = ' You picked up a ' + self.owner.name + '!'

message(mes, libtcod.green)

event_logging(mes)

# special case: automatically equip, if the corresponding equipment slot is unused

equipment = self.owner.equipment

if equipment and get_equipped_in_slot(equipment.slot) is None:

equipment.equip()

def drop(self):

# special case: if the object has the Equipment component, dequip it before dropping

if self.owner.equipment:

self.owner.equipment.dequip()

# add to the map and remove from the player's inventory. also, place it at the player's coordinates

objects.append(self.owner)

inventory.remove(self.owner)

self.owner.x = player.x

self.owner.y = player.y

mes = 'You dropped a ' + self.owner.name + '.'

message(mes, libtcod.yellow)

event_logging(mes)

def use(self):

# special case: if the object has the Equipment component, the "use" action is to equip/dequip

if self.owner.equipment:

self.owner.equipment.toggle_equip()

return

# just call the "use_function" if it is defined

if self.use_function is None:

message('The ' + self.owner.name + ' cannot be used.')

else:

if self.use_function() != 'cancelled':

# an object that can be equipped, yielding bonuses. automatically adds the Item component.

def __init__(self, slot, power_bonus=0, defense_bonus=0, max_hp_bonus=0):

self.power_bonus = power_bonus

self.defense_bonus = defense_bonus

self.max_hp_bonus = max_hp_bonus

self.slot = slot

self.is_equipped = False

def toggle_equip(self): # toggle equip/dequip status

if self.is_equipped:

self.dequip()

else:

self.equip()

def equip(self):

# if the slot is already being used, dequip whatever is there first

old_equipment = get_equipped_in_slot(self.slot)

if old_equipment is not None:

old_equipment.dequip()

# equip object and show a message about it

self.is_equipped = True

mes = 'Equipped ' + self.owner.name + ' on ' + self.slot + '.'

message(mes, libtcod.light_green)

event_logging(mes)

def dequip(self):

# dequip object and show a message about it

if not self.is_equipped:

return

self.is_equipped = False

mes = 'Dequipped ' + self.owner.name + ' from ' + self.slot + '.'

message(mes, libtcod.light_yellow)

for obj in inventory:

if obj.equipment and obj.equipment.slot == slot and obj.equipment.is_equipped:

return obj.equipment

if obj == player:

equipped_list = []

for item in inventory:

if item.equipment and item.equipment.is_equipped:

equipped_list.append(item.equipment)

return equipped_list

else:

# first test the map tile

if map[x][y].blocked:

return True

# now check for any blocking objects

for object in objects:

if object.blocks and object.x == x and object.y == y:

return True

global map

# go through the tiles in the rectangle and make them passable

for x in range(room.x1 + 1, room.x2):

for y in range(room.y1 + 1, room.y2):

map[x][y].blocked = False

global map

# horizontal tunnel. min() and max() are used in case x1>x2

for x in range(min(x1, x2), max(x1, x2) + 1):

map[x][y].blocked = False

global map

# vertical tunnel

for y in range(min(y1, y2), max(y1, y2) + 1):

map[x][y].blocked = False

global map, objects, stairs

# the list of objects with just the player

objects = [player]

# fill map with "blocked" tiles

map = [[Tile(True)

for y in range(MAP_HEIGHT)]

for x in range(MAP_WIDTH)]

rooms = []

num_rooms = 0

for r in range(MAX_ROOMS):

# random width and height

w = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE)

h = libtcod.random_get_int(0, ROOM_MIN_SIZE, ROOM_MAX_SIZE)

# random position without going out of the boundaries of the map

x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1)

y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1)

# "Rect" class makes rectangles easier to work with

new_room = Rect(x, y, w, h)

# run through the other rooms and see if they intersect with this one

failed = False

for other_room in rooms:

if new_room.intersect(other_room):

failed = True

break

if not failed:

# this means there are no intersections, so this room is valid

# "paint" it to the map's tiles

create_room(new_room)

# center coordinates of new room, will be useful later

(new_x, new_y) = new_room.center()

if num_rooms == 0:

# this is the first room, where the player starts at

player.x = new_x

player.y = new_y

else:

# all rooms after the first:

# connect it to the previous room with a tunnel

# center coordinates of previous room

(prev_x, prev_y) = rooms[num_rooms - 1].center()

# draw a coin (random number that is either 0 or 1)

if libtcod.random_get_int(0, 0, 1) == 1:

# first move horizontally, then vertically

create_h_tunnel(prev_x, new_x, prev_y)

create_v_tunnel(prev_y, new_y, new_x)

else:

# first move vertically, then horizontally

create_v_tunnel(prev_y, new_y, prev_x)

create_h_tunnel(prev_x, new_x, new_y)

# add some contents to this room, such as monsters

place_objects(new_room)

# finally, append the new room to the list

rooms.append(new_room)

num_rooms += 1

# create stairs at the center of the last room

stairs = Object(new_x, new_y, '<', 'stairs', libtcod.white, always_visible=True)

objects.append(stairs)

# the dice will land on some number between 1 and the sum of the chances

dice = libtcod.random_get_int(0, 1, sum(chances))

# go through all chances, keeping the sum so far

running_sum = 0

choice = 0

for w in chances:

running_sum += w

# see if the dice landed in the part that corresponds to this choice

if dice <= running_sum:

return choice

# choose one option from dictionary of chances, returning its key

chances = chances_dict.values()

strings = chances_dict.keys()

# returns a value that depends on level. the table specifies what value occurs after each level, default is 0.

for (value, level) in reversed(table):

if dungeon_level >= level:

return value

# this is where we decide the chance of each monster or item appearing.

# maximum number of monsters per room

max_monsters = from_dungeon_level([[2, 1], [3, 4], [5, 6]])

# chance of each monster

monster_chances = {}

monster_chances['snow'] = 80

monster_chances['eight'] = 40

# maximum number of items per room

max_items = from_dungeon_level([[1, 1], [2, 4]])

# chance of each item (by default they have a chance of 0 at level 1, which then goes up)

item_chances = {}

item_chances['heal'] = 35 # healing potion always shows up, even if all other items have 0 chance

item_chances['sword'] = from_dungeon_level([[5, 4]])

item_chances['shield'] = from_dungeon_level([[15, 8]])

# choose random number of monsters

num_monsters = libtcod.random_get_int(0, 0, max_monsters)

for i in range(num_monsters):

# choose random spot for this monster

x = libtcod.random_get_int(0, room.x1 + 1, room.x2 - 1)

y = libtcod.random_get_int(0, room.y1 + 1, room.y2 - 1)

# only place it if the tile is not blocked

if not is_blocked(x, y):

choice = random_choice(monster_chances)

if choice == 'eight':

fighter_component = Fighter(hp=3, defense=0, power=2, xp=50, death_function=monster_death)

ai_component = BasicMonster()

monster = Object(x, y, '8', 'The Hateful Eight', libtcod.desaturated_green,

blocks=True, fighter=fighter_component, ai=ai_component)

elif choice == 'snow':

fighter_component = Fighter(hp=8, defense=2, power=5, xp=100, death_function=monster_death)

ai_component = BasicMonster()

monster = Object(x, y, '*', 'Frightful Snowflake', libtcod.darker_green,

blocks=True, fighter=fighter_component, ai=ai_component)

objects.append(monster)

# choose random number of items

num_items = libtcod.random_get_int(0, 0, max_items)

for i in range(num_items):

# choose random spot for this item

x = libtcod.random_get_int(0, room.x1 + 1, room.x2 - 1)

y = libtcod.random_get_int(0, room.y1 + 1, room.y2 - 1)

# only place it if the tile is not blocked

if not is_blocked(x, y):

choice = random_choice(item_chances)

if choice == 'heal':

# create a healing potion

item_component = Item(use_function=cast_heal)

item = Object(x, y, '!', 'healing potion', libtcod.violet, item=item_component)

elif choice == 'sword':

# create a sword

equipment_component = Equipment(slot='right hand', power_bonus=3)

item = Object(x, y, '/', 'sword', libtcod.sky, equipment=equipment_component)

elif choice == 'shield':

# create a shield

equipment_component = Equipment(slot='left hand', defense_bonus=1)

item = Object(x, y, '[', 'shield', libtcod.darker_orange, equipment=equipment_component)

objects.append(item)

item.send_to_back() # items appear below other objects

# render a bar (HP, experience, etc). first calculate the width of the bar

bar_width = int(float(value) / maximum * total_width)

# render the background first

libtcod.console_set_default_background(panel, back_color)

libtcod.console_rect(panel, x, y, total_width, 1, False, libtcod.BKGND_SCREEN)

# now render the bar on top

libtcod.console_set_default_background(panel, bar_color)

if bar_width > 0:

libtcod.console_rect(panel, x, y, bar_width, 1, False, libtcod.BKGND_SCREEN)

# finally, some centered text with the values

libtcod.console_set_default_foreground(panel, libtcod.white)

libtcod.console_print_ex(panel, x + total_width / 2, y, libtcod.BKGND_NONE, libtcod.CENTER,

global fov_map, color_dark_wall, color_light_wall

global color_dark_ground, color_light_ground

global fov_recompute

if fov_recompute:

# recompute FOV if needed (the player moved or something)

fov_recompute = False

libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO)

# go through all tiles, and set their background color according to the FOV

for y in range(MAP_HEIGHT):

for x in range(MAP_WIDTH):

visible = libtcod.map_is_in_fov(fov_map, x, y)

wall = map[x][y].block_sight

if not visible:

# if it's not visible right now, the player can only see it if it's explored

if map[x][y].explored:

if wall:

libtcod.console_set_char_background(con, x, y, color_dark_wall, libtcod.BKGND_SET)

else:

libtcod.console_set_char_background(con, x, y, color_dark_ground, libtcod.BKGND_SET)

else:

# it's visible

if wall:

libtcod.console_set_char_background(con, x, y, color_light_wall, libtcod.BKGND_SET)

else:

libtcod.console_set_char_background(con, x, y, color_light_ground, libtcod.BKGND_SET)

# since it's visible, explore it

map[x][y].explored = True

# draw all objects in the list, except the player. we want it to

# always appear over all other objects! so it's drawn later.

for object in objects:

if object != player:

object.draw()

player.draw()

# blit the contents of "con" to the root console

libtcod.console_blit(con, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, 0, 0)

# prepare to render the GUI panel

libtcod.console_set_default_background(panel, libtcod.black)

libtcod.console_clear(panel)

# print the game messages, one line at a time

y = 1

for (line, color) in game_msgs:

libtcod.console_set_default_foreground(panel, color)

libtcod.console_print_ex(panel, MSG_X, y, libtcod.BKGND_NONE, libtcod.LEFT, line)

y += 1

# show the player's stats

render_bar(1, 1, BAR_WIDTH, 'HP', player.fighter.hp, player.fighter.max_hp,

libtcod.light_red, libtcod.darker_red)

libtcod.console_print_ex(panel, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT, 'Dungeon level ' + str(dungeon_level))

# display names of objects under the mouse

libtcod.console_set_default_foreground(panel, libtcod.light_gray)

# blit the contents of "panel" to the root console

# split the message if necessary, among multiple lines

new_msg_lines = textwrap.wrap(new_msg, MSG_WIDTH)

for line in new_msg_lines:

# if the buffer is full, remove the first line to make room for the new one

if len(game_msgs) == MSG_HEIGHT:

del game_msgs[0]

# add the new line as a tuple, with the text and the color

global fov_recompute

# the coordinates the player is moving to/attacking

x = player.x + dx

y = player.y + dy

# try to find an attackable object there

target = None

for object in objects:

if object != player and object.fighter and object.x == x and object.y == y:

target = object

break

# attack if target found, move otherwise

if target is not None:

player.fighter.attack(target)

else:

player.move(dx, dy)

if len(options) > 5:

raise ValueError('Cannot have a menu with more than 5 options.')

# calculate total height for the header (after auto-wrap) and one line per option

header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)

if header == '':

header_height = 0

height = len(options) + header_height

# create an off-screen console that represents the menu's window

window = libtcod.console_new(width, height)

# print the header, with auto-wrap

libtcod.console_set_default_foreground(window, libtcod.white)

libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)

# print all the options

y = header_height

letter_index = ord('a')

for option_text in options:

text = '(' + chr(letter_index) + ') ' + option_text

libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)

y += 1

letter_index += 1

# blit the contents of "window" to the root console

x = SCREEN_WIDTH / 2 - width / 2

y = SCREEN_HEIGHT / 2 - height / 2

libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)

# present the root console to the player and wait for a key-press

libtcod.console_flush()

key = libtcod.console_wait_for_keypress(True)

if key.vk == libtcod.KEY_ENTER and key.lalt: # (special case) Alt+Enter: toggle fullscreen

libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen)

# convert the ASCII code to an index; if it corresponds to an option, return it

index = key.c - ord('a')

if index >= 0 and index < len(options):

return index

# show a menu with each item of the inventory as an option

if len(inventory) == 0:

options = ['Inventory is empty.']

else:

options = []

for item in inventory:

text = item.name

# show additional information, in case it's equipped

if item.equipment and item.equipment.is_equipped:

text = text + ' (on ' + item.equipment.slot + ')'

options.append(text)

index = menu(header, options, INVENTORY_WIDTH)

# if an item was chosen, return it

if index is None or len(inventory) == 0 or active == 0:

return None

global key

global prev_key

global prev_step

if key.vk == libtcod.KEY_ESCAPE:

return 'exit' # exit game

if game_state == 'playing':

# movement keys

if key.vk == libtcod.KEY_UP or key.vk == libtcod.KEY_KP8:

current_key = 'up'

if step != prev_step + 1 or current_key != prev_key:

prev_step = step

prev_key = current_key

player_move_or_attack(0, -1)

elif current_key == prev_key and player.stopped:

player_move_or_attack(0, 0)

else:

return 'nothing_happened'

elif key.vk == libtcod.KEY_DOWN or key.vk == libtcod.KEY_KP2:

current_key = 'down'

if step != prev_step + 1 or current_key != prev_key:

prev_step = step

prev_key = current_key

player_move_or_attack(0, 1)

elif current_key == prev_key and player.stopped:

player_move_or_attack(0, 0)

else:

return 'nothing_happened'

elif key.vk == libtcod.KEY_LEFT or key.vk == libtcod.KEY_KP4:

current_key = 'left'

if step != prev_step + 1 or current_key != prev_key:

prev_step = step

prev_key = current_key

player_move_or_attack(-1, 0)

elif current_key == prev_key and player.stopped:

player_move_or_attack(0, 0)

else:

return 'nothing_happened'

elif key.vk == libtcod.KEY_RIGHT or key.vk == libtcod.KEY_KP6:

current_key = 'right'

if step != prev_step + 1 or current_key != prev_key:

prev_step = step

prev_key = current_key

player_move_or_attack(1, 0)

elif current_key == prev_key and player.stopped:

player_move_or_attack(0, 0)

else:

return 'nothing_happened'

else:

# test for other keys

key_char = chr(key.c)

prev_key = 'other'

if key_char == 'g':

# pick up an item

for object in objects: # look for an item in the player's tile

if object.x == player.x and object.y == player.y and object.item:

object.item.pick_up()

break

if key_char == 'i':

# show the inventory; if an item is selected, use it

chosen_item = inventory_menu('Press the key next to an item to use it, or any other to cancel.\n', 1)

if chosen_item is not None:

chosen_item.use()

if key_char == 'r':

# show the inventory; if an item is selected, drop it

chosen_item = inventory_menu('Press the key next to an item to drop it, or any other to cancel.\n', 1)

if chosen_item is not None:

chosen_item.drop()

if key_char == 'c':

# show character information

level_up_xp = LEVEL_UP_BASE + player.level * LEVEL_UP_FACTOR

msgbox(

'Character Information\n\nLevel: ' + str(player.level) + '\nExperience: ' + str(player.fighter.xp) +

'\nExperience to level up: ' + str(level_up_xp) + '\n\nMaximum HP: ' + str(player.fighter.max_hp) +

'\nAttack: ' + str(player.fighter.power) + '\nDefense: ' + str(player.fighter.defense),

CHARACTER_SCREEN_WIDTH)

if key_char == '1':

# go down stairs, if the player is on them

if stairs.x == player.x and stairs.y == player.y:

next_level()

# see if the player's experience is enough to level-up

level_up_xp = LEVEL_UP_BASE + player.level * LEVEL_UP_FACTOR

if player.fighter.xp >= level_up_xp:

# it is! level up and ask to raise some stats

player.level += 1

player.fighter.xp -= level_up_xp

mes = 'You reached level ' + str(player.level) + '!'

message(mes, libtcod.yellow)

event_logging(mes)

choice = None

while choice is None: # keep asking until a choice is made

choice = menu('Level up! Choose a stat to raise:\n',

['Constitution (+20 HP, from ' + str(player.fighter.max_hp) + ')',

'Strength (+1 attack, from ' + str(player.fighter.power) + ')',

'Agility (+1 defense, from ' + str(player.fighter.defense) + ')'], LEVEL_SCREEN_WIDTH)

if choice == 0:

player.fighter.base_max_hp += 20

player.fighter.hp += 20

elif choice == 1:

player.fighter.base_power += 1

elif choice == 2:

global game_state

mes = 'You died!'

message(mes, libtcod.red)

event_logging(mes)

game_state = 'dead'

player.char = 'X'

mes = 'The ' + monster.name + ' is dead! You gain ' + str(monster.fighter.xp) + ' experience points.'

message(mes, libtcod.yellow)

event_logging(mes)

monster.char = 'x'

monster.color = libtcod.dark_red

monster.blocks = False

monster.fighter = None

monster.ai = None

monster.name = 'remains of ' + monster.name

# find closest enemy, up to a maximum range, and in the player's FOV

closest_enemy = None

closest_dist = max_range + 1 # start with (slightly more than) maximum range

for object in objects:

if object.fighter and not object == player and libtcod.map_is_in_fov(fov_map, object.x, object.y):

# calculate distance between this object and the player

dist = player.distance_to(object)

if dist < closest_dist: # it's closer, so remember it

closest_enemy = object

closest_dist = dist

# heal the player

if player.fighter.hp == player.fighter.max_hp:

mes = 'You are absolutely healthy'

else:

mes = 'Do you feel bettter?'

message(mes, libtcod.green)

global player, inventory, game_msgs, game_state, dungeon_level

# create object representing the player

fighter_component = Fighter(hp=100, defense=1, power=2, xp=0, death_function=player_death)

player = Object(0, 0, 'O', 'player', libtcod.white, blocks=True, fighter=fighter_component)

player.level = 1

# generate map (at this point it's not drawn to the screen)

dungeon_level = 1

make_map()

initialize_fov()

game_state = 'playing'

inventory = []

# create the list of game messages and their colors, starts empty

game_msgs = []

message('Ready', libtcod.red)

message('Steady', libtcod.yellow)

message('Go!', libtcod.green)

event_logging('The game is coming')

# initial equipment: a dagger

equipment_component = Equipment(slot='right hand', power_bonus=2)

obj = Object(0, 0, '-', 'dagger', libtcod.sky, equipment=equipment_component)

inventory.append(obj)

equipment_component.equip()

global dungeon_level

player.fighter.heal(player.fighter.max_hp)

dungeon_level += 1

mes = "Let's play..."

event_logging(mes)

message(mes, libtcod.red)

make_map()

global fov_recompute, fov_map

fov_recompute = True

fov_map = libtcod.map_new(MAP_WIDTH, MAP_HEIGHT)

for y in range(MAP_HEIGHT):

for x in range(MAP_WIDTH):

libtcod.map_set_properties(fov_map, x, y, not map[x][y].block_sight, not map[x][y].blocked)

global key, mouse

step = 0

global prev_key

prev_key = 'up'

global prev_step

prev_step = 0

mouse = libtcod.Mouse()

key = libtcod.Key()

some_happened = False

while not libtcod.console_is_window_closed():

step += 1

libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS | libtcod.EVENT_MOUSE, key, mouse)

if some_happened:

render_all()

libtcod.console_flush()

check_level_up()

for object in objects:

object.clear()