#@+others

#@+node:peckj.20130917090235.2655: *5* __init__

def __init__(self, x, y, char, name, color, blocks=False, always_visible=False, player=None, fighter=None, actor=None, ai=None, item=None, equipment=None):

self.blocks = blocks

self.name = name

self.x = x

self.y = y

self.char = char

self.color = color

self.always_visible = always_visible

self.fighter = fighter

if self.fighter:

self.fighter.owner = self

self.ai = ai

if self.ai:

self.ai.owner = self

self.item = item

if self.item:

self.item.owner = self

self.equipment = equipment

if self.equipment:

self.equipment.owner = self

self.item = Item()

self.item.owner = self

self.player = player

if self.player:

self.player.owner = self

self.actor = actor

if self.actor:

self.actor.owner = self

#@+node:peckj.20130917090235.2656: *5* move

def move(self, dx, dy):

newx = self.x + dx

newy = self.y + dy

if not is_blocked(newx, newy):

self.x = newx

self.y = newy

#@+node:peckj.20130918082920.2690: *5* move_towards

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 and convert to an integer

dx = int(round(dx/distance))

dy = int(round(dy/distance))

self.move(dx, dy)

#@+node:peckj.20130918082920.2691: *5* distance_to

def distance_to(self, other):

# return the distance to another object

dx = other.x - self.x

dy = other.y - self.y

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

#@+node:peckj.20130918082920.2728: *5* distance

def distance(self, x, y):

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

#@+node:peckj.20130918082920.2696: *5* send_to_back

def send_to_back(self):

global objects

objects.remove(self)

objects.insert(0, self)

#@+node:peckj.20130917090235.2657: *5* draw

def draw(self):

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)

#@+node:peckj.20130917090235.2658: *5* clear

def clear(self):

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

#@+others

#@+node:peckj.20130918082920.2689: *7* take_turn

def take_turn(self):

monster = self.owner

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

if monster.distance_to(player) >= 2:

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

elif player.fighter.hp > 0:

monster.fighter.attack(player)

#@+others

#@+node:peckj.20130918082920.2725: *7* __init__

def __init__(self, old_ai, num_turns=CONFUSE_NUM_TURNS):

self.old_ai = old_ai

self.num_turns = num_turns

#@+node:peckj.20130918082920.2724: *7* take_turn

def take_turn(self):

if self.num_turns > 0:

self.owner.move(libtcod.random_get_int(0, -1, 1), libtcod.random_get_int(0, -1, 1))

self.num_turns -= 1

else:

self.owner.ai = self.old_ai

message('The ' + self.owner.name + ' is no longer confused!', libtcod.red)

#@+others

#@+node:peckj.20130920123421.3478: *6* __init__

def __init__(self, level=0):

self.level = level

#@+node:peckj.20130920123421.3480: *6* check_level_up

def check_level_up(self):

level_up_xp = LEVEL_UP_BASE + self.level * LEVEL_UP_FACTOR

if self.owner.fighter.xp >= level_up_xp:

self.level_up()

#@+node:peckj.20130920123421.3481: *6* level_up

def level_up(self):

level_up_xp = LEVEL_UP_BASE + self.level * LEVEL_UP_FACTOR

self.level += 1

self.owner.fighter.xp -= level_up_xp

message('Your battle skills grow stronger! You reached level ' + str(self.level) + '!', libtcod.yellow)

choice = None

while choice == None:

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

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

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

'Agility (+1 defense, from ' + str(self.owner.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:

player.fighter.base_defense += 1

#@+others

#@+node:peckj.20130918082920.2687: *6* __init__

def __init__(self, hp, energy, hd=4, ed=4, hp_recovery=5, energy_recovery=5,

defense=0, power=0, magic_resistance=0, magic=0, xp=0, death_function=None):

# hp

self.base_max_hp = hp

self.hp = hp

# energy

self.base_max_energy = energy

self.energy = energy

# hit/energy dice

self.hd = hd

self.ed = ed

# recoveries

self.base_hp_recovery = hp_recovery

self.base_energy_recovery = energy_recovery

# combat stuff - physical

self.base_defense = defense

self.base_power = power

# combat stuff - magical

self.base_magic_resistance = magic_resistance

self.base_magic = magic

# other

self.xp = xp

self.death_function = death_function

#@+node:peckj.20130918082920.2692: *6* take_damage

def take_damage(self, damage):

if damage > 0:

self.hp -= damage

if self.hp <= 0:

function = self.death_function

if function is not None:

function(self.owner)

if self.owner != player:

player.fighter.xp += self.xp

#@+node:peckj.20130918082920.2693: *6* attack

def attack(self, target):

damage = self.power - target.fighter.defense

if damage > 0:

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

target.fighter.take_damage(damage)

else:

message(self.owner.name.capitalize() + ' attacks ' + target.name + ' but it has no effect!')

#@+node:peckj.20130918082920.2712: *6* heal

def heal(self, amount):

self.hp += amount

if self.hp > self.max_hp:

self.hp = self.max_hp

#@+node:peckj.20130925095856.4431: *6* properties

#@+node:peckj.20130919090559.2754: *7* max_hp

@property

def max_hp(self):

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

return self.base_max_hp + bonus

#@+node:peckj.20130925095856.4435: *7* max_energy

@property

def max_energy(self):

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

return self.base_max_energy + bonus

#@+node:peckj.20130919090559.2751: *7* power

@property

def power(self):

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

return self.base_power + bonus

#@+node:peckj.20130919090559.2753: *7* defense

@property

def defense(self):

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

return self.base_defense + bonus

#@+node:peckj.20130925095856.4432: *7* magic

@property

def magic(self):

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

return self.base_magic + bonus

#@+node:peckj.20130925095856.4433: *7* magic_resistance

@property

def magic_resistance(self):

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

return self.base_magic_resistance + bonus

#@+node:peckj.20130925095856.4434: *7* hp_recovery

@property

def hp_recovery(self):

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

return self.base_hp_recovery + bonus

#@+node:peckj.20130925095856.4437: *7* energy_recovery

@property

def energy_recovery(self):

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

return self.base_energy_recovery + bonus

#@+others

#@+node:peckj.20130920123421.3488: *6* __init__

def __init__(self, speed=0, act_function=None, active=True, time=1):

self.speed = speed

self.active = active

self.time = time

self.act_function = act_function

#@+node:peckj.20130920123421.3489: *6* act

def act(self):

function = self.act_function

#print 'acting'

#print 'scheduler.ticks: %s' % scheduler.ticks

if function is None or not self.active:

#print 'Inactive'

return True # prevent lockups forever

if function is not None:

result = function(self.owner)

if result:

my_ticks = MAX_SCHEDULER_TICKS - self.speed

self.time = scheduler.ticks + my_ticks

#print "new time: %s" % self.time

return result

#@+node:peckj.20130920123421.3492: *6* __cmp__

#@+at

# def __cmp__(self, other):

# if self.time < other.time:

# return -1

# elif self.time == other.time:

# return 0

# else:

# return 1

#@@c

#@+others

#@+node:peckj.20130918082920.2707: *6* __init__

def __init__(self, use_function=None):

self.use_function = use_function

#@+node:peckj.20130918082920.2703: *6* pick_up

def pick_up(self):

if len(inventory) >= 26:

message('Your inventory is full, cannot pick up ' + self.owner.name + '.', libtcod.red)

else:

inventory.append(self.owner)

objects.remove(self.owner)

message('You picked up a ' + self.owner.name + '!', libtcod.green)

equipment = self.owner.equipment

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

equipment.equip()

#@+node:peckj.20130918082920.2731: *6* drop

def drop(self):

objects.append(self.owner)

inventory.remove(self.owner)

self.owner.x = player.x

self.owner.y = player.y

message('You dropped a ' + self.owner.name + '.', libtcod.yellow)

if self.owner.equipment:

self.owner.equipment.dequip()

#@+node:peckj.20130918082920.2710: *6* use

def use(self):

if self.owner.equipment:

self.owner.equipment.toggle_equip()

return

if self.use_function is None:

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

else:

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

inventory.remove(self.owner)

#@+others

#@+node:peckj.20130919090559.2746: *6* __init__

def __init__(self, slot, power_bonus=0, defense_bonus=0, max_hp_bonus=0, max_energy_bonus=0,

magic_bonus=0, magic_resistance_bonus=0, hp_recovery_bonus=0, energy_recovery_bonus=0):

self.power_bonus = power_bonus

self.defense_bonus = defense_bonus

self.max_hp_bonus = max_hp_bonus

self.max_energy_bonus = max_energy_bonus

self.magic_bonus = magic_bonus

self.magic_resistance_bonus = magic_resistance_bonus

self.hp_recovery_bonus = hp_recovery_bonus

self.energy_recovery_bonus = energy_recovery_bonus

self.slot = slot

self.is_equipped = False

#@+node:peckj.20130919090559.2747: *6* toggle_equip

def toggle_equip(self):

if self.is_equipped:

self.dequip()

else:

self.equip()

#@+node:peckj.20130919090559.2748: *6* equip

def equip(self):

old_equipment = get_equipped_in_slot(self.slot)

if old_equipment is not None:

old_equipment.dequip()

self.is_equipped = True

message('Equipped ' + self.owner.name + ' on ' + self.slot + '.', libtcod.light_green)

#@+node:peckj.20130919090559.2749: *6* dequip

def dequip(self):

if not self.is_equipped: return

self.is_equipped = False

message('Dequipped ' + self.owner.name + ' from ' + self.slot + '.', libtcod.light_yellow)

#@+others

#@+node:peckj.20130917090235.2660: *5* __init__

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

self.explored = False

self.blocked = blocked

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

if block_sight is None: block_sight = blocked

self.block_sight = block_sight

#@+others

#@+node:peckj.20130917090235.2670: *5* __init__

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

self.x1 = x

self.y1 = y

self.x2 = x + w

self.y2 = y + h

#@+node:peckj.20130917090235.2675: *5* center

def center(self):

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

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

return (center_x, center_y)

#@+node:peckj.20130917090235.2676: *5* intersect

def intersect(self, other):

#returns true if this rectangle intersects with another one

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

self.y1 <= other.y2 and self.y2 >= other.y1)

#@+others

#@+node:peckj.20130920123421.3485: *5* __init__

def __init__(self, schedule={}, ticks=-1L):

self.schedule = schedule

self.ticks = ticks

#@+node:peckj.20130920123421.3490: *5* tick

def tick(self):

actors = []

while actors == []:

actors = self.schedule.pop(self.ticks, [])

self.ticks += 1

#print self.ticks

#print actors

for a in actors:

r = a.act()

while not r:

r = a.act()

self.push(a)

#@+node:peckj.20130920123421.3491: *5* push

def push(self, actor):

self.schedule.setdefault(actor.time, []).append(actor)

global map, objects, stairs

objects = [player]

# fill map with unblocked tiles

map = [[ Tile(True) for y in range(MAP_HEIGHT) ] for x in range(MAP_WIDTH) ]

# dungeon generation

rooms = []

num_rooms = 0

for r in range(MAX_ROOMS):

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

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

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

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

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

# intersection test

failed = False

for other_room in rooms:

if new_room.intersect(other_room):

failed = True

break

if not failed:

create_room(new_room)

place_objects(new_room)

(new_x, new_y) = new_room.center()

if num_rooms == 0: # first room

player.x = new_x

player.y = new_y

else: # all other rooms

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

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

create_h_tunnel(prev_x, new_x, prev_y)

create_v_tunnel(prev_y, new_y, new_x)

else:

create_v_tunnel(prev_y, new_y, prev_x)

create_h_tunnel(prev_x, new_x, new_y)

rooms.append(new_room)

num_rooms += 1

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

objects.append(stairs)

global map

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

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

map[x][y].blocked = False

global map

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

map[x][y].blocked = False

# set up the object placer

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

monster_chances = {}

monster_chances['orc'] = 80

monster_chances['troll'] = from_dungeon_level([[15, 2], [30, 5], [60, 7]])

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

item_chances = {}

item_chances['heal'] = 35

item_chances['lightning'] = from_dungeon_level([[25, 4]])

item_chances['fireball'] = from_dungeon_level([[25, 6]])

item_chances['confuse'] = from_dungeon_level([[10, 2]])

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)

if not is_blocked(x, y):

choice = random_choice(monster_chances)

if choice == 'orc':

#create an orc

fighter_component = Fighter(hp=20, defense=0, power=4, xp=35, death_function=monster_death)

ai_component = BasicMonster()

actor_component = Actor(speed=2, act_function=monster_take_action)

monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green, blocks=True, fighter=fighter_component, ai=ai_component, actor=actor_component)

elif choice == 'troll':

#create a troll

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

ai_component = BasicMonster()

actor_component = Actor(speed=5, act_function=monster_take_action)

monster = Object(x, y, 'T', 'troll', libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component, actor=actor_component)

objects.append(monster)

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

for i in range(num_items):

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

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

if not is_blocked(x, y):

choice = random_choice(item_chances)

if choice == 'heal':

item_component = Item(use_function=cast_heal)

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

elif choice == 'lightning':

item_component = Item(use_function=cast_lightning)

item = Object(x, y, '#', 'scroll of lightning bolt', libtcod.light_yellow, item=item_component, always_visible=True)

elif choice == 'fireball':

item_component = Item(use_function=cast_fireball)

item = Object(x, y, '#', 'scroll of fireball', libtcod.light_yellow, item=item_component, always_visible=True)

elif choice == 'confuse':

item_component = Item(use_function=cast_confuse)

item = Object(x, y, '#', 'scroll of confusion', libtcod.light_yellow, item=item_component, always_visible=True)

elif choice == 'sword':

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

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

elif choice == 'shield':

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

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

objects.append(item)

global fov_recompute, fov_map

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)

for object in objects:

if object != player:

object.draw()

player.draw()

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 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:

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)

map[x][y].explored = True

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

libtcod.console_set_default_background(panel, libtcod.black)

libtcod.console_clear(panel)

render_bar(1, 1, BAR_WIDTH, 'HP', player.fighter.hp, player.fighter.max_hp, libtcod.light_red, libtcod.darker_red)

y = 1

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

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

libtcod.console_set_default_foreground(panel, libtcod.light_gray)

libtcod.console_print_ex(panel, 1, 0, libtcod.BKGND_NONE, libtcod.LEFT, get_names_under_mouse())

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

libtcod.console_set_default_background(panel, back_color)

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

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)

libtcod.console_set_default_foreground(panel, libtcod.white)

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

new_msg_lines = textwrap.wrap(new_msg, MSG_WIDTH)

for line in new_msg_lines:

if len(game_msgs) == MSG_HEIGHT:

del game_msgs[0]

if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options.')

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

if header == '':

header_height = 0

height = len(options) + header_height

window = libtcod.console_new(width, height)

libtcod.console_set_default_foreground(window, libtcod.white)

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

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

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)

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())

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

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

if len(inventory) == 0:

options = ['Inventory is empty.']

else:

#options = [item.name for item in inventory]

options = []

for item in inventory:

text = item.name

if item.equipment and item.equipment.is_equipped:

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

options.append(text)

index = menu(header, options, INVENTORY_WIDTH)

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

img = libtcod.image_load('menu_background1.png')

while not libtcod.console_is_window_closed():

libtcod.image_blit_2x(img, 0, 0, 0)

libtcod.console_set_default_foreground(0, libtcod.light_yellow)

libtcod.console_print_ex(0, SCREEN_WIDTH/2, SCREEN_HEIGHT/2-4, libtcod.BKGND_NONE, libtcod.CENTER, 'TOMBS OF THE ANCIENT KINGS')

libtcod.console_print_ex(0, SCREEN_WIDTH/2, SCREEN_HEIGHT-2, libtcod.BKGND_NONE, libtcod.CENTER, 'By Jake Peck (following Jotaf\'s tutorial)')

choice = menu('', ['Play a new game', 'Continue last game', 'Quit'], 24)

if choice == 0:

new_game()

play_game()

elif choice == 1:

try:

load_game()

except Exception as e:

msgbox('\n No saved game to load.\n', 24)

#print e

continue

play_game()

elif choice == 2:

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

message('You are already at full health.', libtcod.red)

return 'cancelled'

message('Your wounds start to feel better!', libtcod.light_violet)

monster = closest_monster(LIGHTNING_RANGE)

if monster is None:

message('No enemy is close enough to strike.', libtcod.red)

return 'cancelled'

message('A lightning bold strikes the ' + monster.name + ' with a loud thunder! The damage is ' + str(LIGHTNING_DAMAGE) + ' hit points.', libtcod.light_blue)

message('Left-click an enemy to confuse it, or right-click to cancel.', libtcod.light_cyan)

monster = target_monster(CONFUSE_RANGE)

if monster is None: return 'cancelled'

else:

old_ai = monster.ai

monster.ai = ConfusedMonster(old_ai)

monster.ai.owner = monster

message('Left-click a target tile for the fireball, or right-click to cance.', libtcod.light_cyan)

(x, y) = target_tile()

if x is None: return 'cancelled'

message('The fireball explodes, burning everything within ' + str(FIREBALL_RADIUS) + ' tiles!', libtcod.orange)

for obj in objects:

if obj.distance(x, y) <= FIREBALL_RADIUS and obj.fighter:

message('The ' + obj.name + ' gets burned for ' + str(FIREBALL_DAMAGE) + ' hit points.', libtcod.orange)

monster.actor.active = False

message(monster.name.capitalize() + ' is dead! You gain ' + str(monster.fighter.xp) + ' experience points.', libtcod.orange)

monster.char = '%'

monster.color = libtcod.dark_red

monster.blocks = False

monster.fighter = None

monster.ai = None

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

global game_state

message('You died!', libtcod.red)

game_state = 'dead'

player.char = '%'

player.color = libtcod.dark_red

if map[x][y].blocked:

return True

for object in objects:

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

return True

closest_enemy = None

closest_dist = max_range + 1

for object in objects:

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

dist = player.distance_to(object)

if dist < closest_dist:

closest_enemy = object

closest_dist = dist

global mouse

(x, y) = (mouse.cx, mouse.cy)

names = [obj.name for obj in objects if obj.x == x and obj.y == y and libtcod.map_is_in_fov(fov_map, obj.x, obj.y)]

names = ', '.join(names)

global key, mouse

while True:

libtcod.console_flush()

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

render_all()

(x, y) = (mouse.cx, mouse.cy)

if mouse.lbutton_pressed and libtcod.map_is_in_fov(fov_map, x, y) and (max_range is None or player.distance(x, y) <= max_range):

return (x, y)

if mouse.rbutton_pressed or key.vk == libtcod.KEY_ESCAPE:

while True:

(x, y) = target_tile(max_range)

if x is None:

return None

for obj in objects:

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

global fov_recompute, key

#print 'called handle_keys'

#print 'key = %s' % chr(key.c)

if key.vk == libtcod.KEY_ENTER and key.lalt:

# lalt+enter = fullscreen

libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())

elif key.vk == libtcod.KEY_ESCAPE:

return 'exit' # exit game

if game_state == 'playing-waiting-for-input' or game_state == 'dead':

# movement keys

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

player_move_or_attack(0, -1)

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

player_move_or_attack(0, 1)

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

player_move_or_attack(-1, 0)

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

player_move_or_attack(1, 0)

elif key.vk == libtcod.KEY_HOME or key.vk == libtcod.KEY_KP7:

player_move_or_attack(-1, -1)

elif key.vk == libtcod.KEY_PAGEUP or key.vk == libtcod.KEY_KP9:

player_move_or_attack(1, -1)

elif key.vk == libtcod.KEY_END or key.vk == libtcod.KEY_KP1:

player_move_or_attack(-1, 1)

elif key.vk == libtcod.KEY_PAGEDOWN or key.vk == libtcod.KEY_KP3:

player_move_or_attack(1, 1)

elif key.vk == libtcod.KEY_KP5:

pass #do nothing ie wait for the monster to come to you

else:

# test for other keys

key_char = chr(key.c)

if key_char == 'g':

for object in objects:

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

object.item.pick_up()

break

if key_char == 'i':

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

if chosen_item is not None:

chosen_item.use()

if key_char == 'd':

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

if chosen_item is not None:

chosen_item.drop()

if key_char == '<':

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

next_level()

if key_char == 'c':

level_up_xp = LEVEL_UP_BASE + player.player.level * LEVEL_UP_FACTOR

msgbox('Character Information\n\nLevel: ' + str(player.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)

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.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)

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:

global game_state

#player_action = handle_keys()

#if player_action == 'exit':

# game_state = 'exit'

# return True

if game_state == 'playing':

game_state = 'playing-waiting-for-input'

#print 'game_state (player_take_action): %s' % game_state

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

if dungeon_level >= level:

return value

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

running_sum = 0

choice = 0