Complete Roguelike Tutorial, using python+libtcod, part 12 code

From RogueBasin
(Difference between revisions)
Jump to: navigation, search
 
(3 intermediate revisions by 3 users not shown)
Line 1: Line 1:
 
<center><table border="0" cellpadding="10" cellspacing="0" style="background:#F0E68C"><tr><td><center>
 
<center><table border="0" cellpadding="10" cellspacing="0" style="background:#F0E68C"><tr><td><center>
This is part of the '''code''' for a series of tutorials; the main page can be found [[Complete Roguelike Tutorial, using python+libtcod|here]].
+
This is part of a series of tutorials; the main page can be found [[Complete Roguelike Tutorial, using python+libtcod|here]].
 +
 
 +
The tutorial uses libtcod version 1.6.0 and above.
 +
 
 +
If you choose to use 1.5.1, you can find the old version [http://www.roguebasin.com/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod,_part_12_code&oldid=42401 here].<br/>
 +
If you choose to use 1.5.0, you can find the old version [http://roguebasin.roguelikedevelopment.org/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod,_part_12_code&oldid=29863 here].
 
</center></td></tr></table></center>
 
</center></td></tr></table></center>
 +
  
 
== Monster and item progression ==
 
== Monster and item progression ==
Line 9: Line 15:
 
# libtcod python tutorial
 
# libtcod python tutorial
 
#
 
#
 
+
 
import libtcodpy as libtcod
 
import libtcodpy as libtcod
 
import math
 
import math
 
import textwrap
 
import textwrap
 
import shelve
 
import shelve
 
+
 
#actual size of the window
 
#actual size of the window
 
SCREEN_WIDTH = 80
 
SCREEN_WIDTH = 80
 
SCREEN_HEIGHT = 50
 
SCREEN_HEIGHT = 50
 
+
 
#size of the map
 
#size of the map
 
MAP_WIDTH = 80
 
MAP_WIDTH = 80
 
MAP_HEIGHT = 43
 
MAP_HEIGHT = 43
 
+
 
#sizes and coordinates relevant for the GUI
 
#sizes and coordinates relevant for the GUI
 
BAR_WIDTH = 20
 
BAR_WIDTH = 20
Line 33: Line 39:
 
CHARACTER_SCREEN_WIDTH = 30
 
CHARACTER_SCREEN_WIDTH = 30
 
LEVEL_SCREEN_WIDTH = 40
 
LEVEL_SCREEN_WIDTH = 40
 
+
 
#parameters for dungeon generator
 
#parameters for dungeon generator
 
ROOM_MAX_SIZE = 10
 
ROOM_MAX_SIZE = 10
 
ROOM_MIN_SIZE = 6
 
ROOM_MIN_SIZE = 6
 
MAX_ROOMS = 30
 
MAX_ROOMS = 30
 
+
 
#spell values
 
#spell values
 
HEAL_AMOUNT = 40
 
HEAL_AMOUNT = 40
Line 47: Line 53:
 
FIREBALL_RADIUS = 3
 
FIREBALL_RADIUS = 3
 
FIREBALL_DAMAGE = 25
 
FIREBALL_DAMAGE = 25
 
+
 
#experience and level-ups
 
#experience and level-ups
 
LEVEL_UP_BASE = 200
 
LEVEL_UP_BASE = 200
Line 56: Line 62:
 
FOV_LIGHT_WALLS = True  #light walls or not
 
FOV_LIGHT_WALLS = True  #light walls or not
 
TORCH_RADIUS = 10
 
TORCH_RADIUS = 10
 
+
 
LIMIT_FPS = 20  #20 frames-per-second maximum
 
LIMIT_FPS = 20  #20 frames-per-second maximum
 
+
 
+
 
color_dark_wall = libtcod.Color(0, 0, 100)
 
color_dark_wall = libtcod.Color(0, 0, 100)
 
color_light_wall = libtcod.Color(130, 110, 50)
 
color_light_wall = libtcod.Color(130, 110, 50)
 
color_dark_ground = libtcod.Color(50, 50, 150)
 
color_dark_ground = libtcod.Color(50, 50, 150)
 
color_light_ground = libtcod.Color(200, 180, 50)
 
color_light_ground = libtcod.Color(200, 180, 50)
 
+
 
+
 
class Tile:
 
class Tile:
 
     #a tile of the map and its properties
 
     #a tile of the map and its properties
 
     def __init__(self, blocked, block_sight = None):
 
     def __init__(self, blocked, block_sight = None):
 
         self.blocked = blocked
 
         self.blocked = blocked
       
+
 
         #all tiles start unexplored
 
         #all tiles start unexplored
 
         self.explored = False
 
         self.explored = False
       
+
 
         #by default, if a tile is blocked, it also blocks sight
 
         #by default, if a tile is blocked, it also blocks sight
 
         if block_sight is None: block_sight = blocked
 
         if block_sight is None: block_sight = blocked
 
         self.block_sight = block_sight
 
         self.block_sight = block_sight
 
+
 
class Rect:
 
class Rect:
 
     #a rectangle on the map. used to characterize a room.
 
     #a rectangle on the map. used to characterize a room.
Line 85: Line 91:
 
         self.x2 = x + w
 
         self.x2 = x + w
 
         self.y2 = y + h
 
         self.y2 = y + h
   
+
 
     def center(self):
 
     def center(self):
 
         center_x = (self.x1 + self.x2) / 2
 
         center_x = (self.x1 + self.x2) / 2
 
         center_y = (self.y1 + self.y2) / 2
 
         center_y = (self.y1 + self.y2) / 2
 
         return (center_x, center_y)
 
         return (center_x, center_y)
   
+
 
     def intersect(self, other):
 
     def intersect(self, other):
 
         #returns true if this rectangle intersects with another one
 
         #returns true if this rectangle intersects with another one
 
         return (self.x1 <= other.x2 and self.x2 >= other.x1 and
 
         return (self.x1 <= other.x2 and self.x2 >= other.x1 and
 
                 self.y1 <= other.y2 and self.y2 >= other.y1)
 
                 self.y1 <= other.y2 and self.y2 >= other.y1)
 
+
 
class Object:
 
class Object:
 
     #this is a generic object: the player, a monster, an item, the stairs...
 
     #this is a generic object: the player, a monster, an item, the stairs...
Line 110: Line 116:
 
         if self.fighter:  #let the fighter component know who owns it
 
         if self.fighter:  #let the fighter component know who owns it
 
             self.fighter.owner = self
 
             self.fighter.owner = self
       
+
 
         self.ai = ai
 
         self.ai = ai
 
         if self.ai:  #let the AI component know who owns it
 
         if self.ai:  #let the AI component know who owns it
 
             self.ai.owner = self
 
             self.ai.owner = self
       
+
 
         self.item = item
 
         self.item = item
 
         if self.item:  #let the Item component know who owns it
 
         if self.item:  #let the Item component know who owns it
 
             self.item.owner = self
 
             self.item.owner = self
   
+
 
     def move(self, dx, dy):
 
     def move(self, dx, dy):
 
         #move by the given amount, if the destination is not blocked
 
         #move by the given amount, if the destination is not blocked
Line 124: Line 130:
 
             self.x += dx
 
             self.x += dx
 
             self.y += dy
 
             self.y += dy
   
+
 
     def move_towards(self, target_x, target_y):
 
     def move_towards(self, target_x, target_y):
 
         #vector from this object to the target, and distance
 
         #vector from this object to the target, and distance
Line 130: Line 136:
 
         dy = target_y - self.y
 
         dy = target_y - self.y
 
         distance = math.sqrt(dx ** 2 + dy ** 2)
 
         distance = math.sqrt(dx ** 2 + dy ** 2)
       
+
 
         #normalize it to length 1 (preserving direction), then round it and
 
         #normalize it to length 1 (preserving direction), then round it and
 
         #convert to integer so the movement is restricted to the map grid
 
         #convert to integer so the movement is restricted to the map grid
Line 136: Line 142:
 
         dy = int(round(dy / distance))
 
         dy = int(round(dy / distance))
 
         self.move(dx, dy)
 
         self.move(dx, dy)
   
+
 
     def distance_to(self, other):
 
     def distance_to(self, other):
 
         #return the distance to another object
 
         #return the distance to another object
Line 142: Line 148:
 
         dy = other.y - self.y
 
         dy = other.y - self.y
 
         return math.sqrt(dx ** 2 + dy ** 2)
 
         return math.sqrt(dx ** 2 + dy ** 2)
   
+
 
     def distance(self, x, y):
 
     def distance(self, x, y):
 
         #return the distance to some coordinates
 
         #return the distance to some coordinates
 
         return math.sqrt((x - self.x) ** 2 + (y - self.y) ** 2)
 
         return math.sqrt((x - self.x) ** 2 + (y - self.y) ** 2)
   
+
 
     def send_to_back(self):
 
     def send_to_back(self):
 
         #make this object be drawn first, so all others appear above it if they're in the same tile.
 
         #make this object be drawn first, so all others appear above it if they're in the same tile.
Line 152: Line 158:
 
         objects.remove(self)
 
         objects.remove(self)
 
         objects.insert(0, self)
 
         objects.insert(0, self)
   
+
 
     def draw(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
 
         #only show if it's visible to the player; or it's set to "always visible" and on an explored tile
Line 158: Line 164:
 
             (self.always_visible and map[self.x][self.y].explored)):
 
             (self.always_visible and map[self.x][self.y].explored)):
 
             #set the color and then draw the character that represents this object at its position
 
             #set the color and then draw the character that represents this object at its position
             libtcod.console_set_foreground_color(con, self.color)
+
             libtcod.console_set_default_foreground(con, self.color)
 
             libtcod.console_put_char(con, self.x, self.y, self.char, libtcod.BKGND_NONE)
 
             libtcod.console_put_char(con, self.x, self.y, self.char, libtcod.BKGND_NONE)
   
+
 
     def clear(self):
 
     def clear(self):
 
         #erase the character that represents this object
 
         #erase the character that represents this object
 
         libtcod.console_put_char(con, self.x, self.y, ' ', libtcod.BKGND_NONE)
 
         libtcod.console_put_char(con, self.x, self.y, ' ', libtcod.BKGND_NONE)
 
+
 
+
 
class Fighter:
 
class Fighter:
 
     #combat-related properties and methods (monster, player, NPC).
 
     #combat-related properties and methods (monster, player, NPC).
Line 175: Line 181:
 
         self.xp = xp
 
         self.xp = xp
 
         self.death_function = death_function
 
         self.death_function = death_function
   
+
 
     def attack(self, target):
 
     def attack(self, target):
 
         #a simple formula for attack damage
 
         #a simple formula for attack damage
 
         damage = self.power - target.fighter.defense
 
         damage = self.power - target.fighter.defense
       
+
 
         if damage > 0:
 
         if damage > 0:
 
             #make the target take some damage
 
             #make the target take some damage
Line 186: Line 192:
 
         else:
 
         else:
 
             message(self.owner.name.capitalize() + ' attacks ' + target.name + ' but it has no effect!')
 
             message(self.owner.name.capitalize() + ' attacks ' + target.name + ' but it has no effect!')
   
+
 
     def take_damage(self, damage):
 
     def take_damage(self, damage):
 
         #apply damage if possible
 
         #apply damage if possible
 
         if damage > 0:
 
         if damage > 0:
 
             self.hp -= damage
 
             self.hp -= damage
           
+
 
             #check for death. if there's a death function, call it
 
             #check for death. if there's a death function, call it
 
             if self.hp <= 0:
 
             if self.hp <= 0:
Line 197: Line 203:
 
                 if function is not None:
 
                 if function is not None:
 
                     function(self.owner)
 
                     function(self.owner)
               
+
 
 
                 if self.owner != player:  #yield experience to the player
 
                 if self.owner != player:  #yield experience to the player
 
                     player.fighter.xp += self.xp
 
                     player.fighter.xp += self.xp
   
+
 
     def heal(self, amount):
 
     def heal(self, amount):
 
         #heal by the given amount, without going over the maximum
 
         #heal by the given amount, without going over the maximum
Line 213: Line 219:
 
         monster = self.owner
 
         monster = self.owner
 
         if libtcod.map_is_in_fov(fov_map, monster.x, monster.y):
 
         if libtcod.map_is_in_fov(fov_map, monster.x, monster.y):
           
+
 
             #move towards player if far away
 
             #move towards player if far away
 
             if monster.distance_to(player) >= 2:
 
             if monster.distance_to(player) >= 2:
 
                 monster.move_towards(player.x, player.y)
 
                 monster.move_towards(player.x, player.y)
               
+
 
             #close enough, attack! (if the player is still alive.)
 
             #close enough, attack! (if the player is still alive.)
 
             elif player.fighter.hp > 0:
 
             elif player.fighter.hp > 0:
Line 227: Line 233:
 
         self.old_ai = old_ai
 
         self.old_ai = old_ai
 
         self.num_turns = num_turns
 
         self.num_turns = num_turns
   
+
 
     def take_turn(self):
 
     def take_turn(self):
 
         if self.num_turns > 0:  #still confused...
 
         if self.num_turns > 0:  #still confused...
Line 233: Line 239:
 
             self.owner.move(libtcod.random_get_int(0, -1, 1), libtcod.random_get_int(0, -1, 1))
 
             self.owner.move(libtcod.random_get_int(0, -1, 1), libtcod.random_get_int(0, -1, 1))
 
             self.num_turns -= 1
 
             self.num_turns -= 1
           
+
 
         else:  #restore the previous AI (this one will be deleted because it's not referenced anymore)
 
         else:  #restore the previous AI (this one will be deleted because it's not referenced anymore)
 
             self.owner.ai = self.old_ai
 
             self.owner.ai = self.old_ai
Line 243: Line 249:
 
     def __init__(self, use_function=None):
 
     def __init__(self, use_function=None):
 
         self.use_function = use_function
 
         self.use_function = use_function
   
+
 
     def pick_up(self):
 
     def pick_up(self):
 
         #add to the player's inventory and remove from the map
 
         #add to the player's inventory and remove from the map
Line 252: Line 258:
 
             objects.remove(self.owner)
 
             objects.remove(self.owner)
 
             message('You picked up a ' + self.owner.name + '!', libtcod.green)
 
             message('You picked up a ' + self.owner.name + '!', libtcod.green)
       
+
 
     def drop(self):
 
     def drop(self):
 
         #add to the map and remove from the player's inventory. also, place it at the player's coordinates
 
         #add to the map and remove from the player's inventory. also, place it at the player's coordinates
Line 260: Line 266:
 
         self.owner.y = player.y
 
         self.owner.y = player.y
 
         message('You dropped a ' + self.owner.name + '.', libtcod.yellow)
 
         message('You dropped a ' + self.owner.name + '.', libtcod.yellow)
   
+
 
     def use(self):
 
     def use(self):
 
         #just call the "use_function" if it is defined
 
         #just call the "use_function" if it is defined
Line 268: Line 274:
 
             if self.use_function() != 'cancelled':
 
             if self.use_function() != 'cancelled':
 
                 inventory.remove(self.owner)  #destroy after use, unless it was cancelled for some reason
 
                 inventory.remove(self.owner)  #destroy after use, unless it was cancelled for some reason
 
+
 
def is_blocked(x, y):
 
def is_blocked(x, y):
 
     #first test the map tile
 
     #first test the map tile
 
     if map[x][y].blocked:
 
     if map[x][y].blocked:
 
         return True
 
         return True
   
+
 
     #now check for any blocking objects
 
     #now check for any blocking objects
 
     for object in objects:
 
     for object in objects:
 
         if object.blocks and object.x == x and object.y == y:
 
         if object.blocks and object.x == x and object.y == y:
 
             return True
 
             return True
   
+
 
     return False
 
     return False
 
+
 
def create_room(room):
 
def create_room(room):
 
     global map
 
     global map
Line 288: Line 294:
 
             map[x][y].blocked = False
 
             map[x][y].blocked = False
 
             map[x][y].block_sight = False
 
             map[x][y].block_sight = False
 
+
 
def create_h_tunnel(x1, x2, y):
 
def create_h_tunnel(x1, x2, y):
 
     global map
 
     global map
Line 295: Line 301:
 
         map[x][y].blocked = False
 
         map[x][y].blocked = False
 
         map[x][y].block_sight = False
 
         map[x][y].block_sight = False
 
+
 
def create_v_tunnel(y1, y2, x):
 
def create_v_tunnel(y1, y2, x):
 
     global map
 
     global map
Line 302: Line 308:
 
         map[x][y].blocked = False
 
         map[x][y].blocked = False
 
         map[x][y].block_sight = False
 
         map[x][y].block_sight = False
 
+
 
def make_map():
 
def make_map():
 
     global map, objects, stairs
 
     global map, objects, stairs
   
+
 
     #the list of objects with just the player
 
     #the list of objects with just the player
 
     objects = [player]
 
     objects = [player]
   
+
 
     #fill map with "blocked" tiles
 
     #fill map with "blocked" tiles
 
     map = [[ Tile(True)
 
     map = [[ Tile(True)
 
         for y in range(MAP_HEIGHT) ]
 
         for y in range(MAP_HEIGHT) ]
 
             for x in range(MAP_WIDTH) ]
 
             for x in range(MAP_WIDTH) ]
 
+
 
     rooms = []
 
     rooms = []
 
     num_rooms = 0
 
     num_rooms = 0
   
+
 
     for r in range(MAX_ROOMS):
 
     for r in range(MAX_ROOMS):
 
         #random width and height
 
         #random width and height
Line 324: Line 330:
 
         x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1)
 
         x = libtcod.random_get_int(0, 0, MAP_WIDTH - w - 1)
 
         y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1)
 
         y = libtcod.random_get_int(0, 0, MAP_HEIGHT - h - 1)
       
+
 
         #"Rect" class makes rectangles easier to work with
 
         #"Rect" class makes rectangles easier to work with
 
         new_room = Rect(x, y, w, h)
 
         new_room = Rect(x, y, w, h)
       
+
 
         #run through the other rooms and see if they intersect with this one
 
         #run through the other rooms and see if they intersect with this one
 
         failed = False
 
         failed = False
Line 334: Line 340:
 
                 failed = True
 
                 failed = True
 
                 break
 
                 break
       
+
 
         if not failed:
 
         if not failed:
 
             #this means there are no intersections, so this room is valid
 
             #this means there are no intersections, so this room is valid
           
+
 
             #"paint" it to the map's tiles
 
             #"paint" it to the map's tiles
 
             create_room(new_room)
 
             create_room(new_room)
           
+
 
            #add some contents to this room, such as monsters
+
            place_objects(new_room)
+
           
+
 
             #center coordinates of new room, will be useful later
 
             #center coordinates of new room, will be useful later
 
             (new_x, new_y) = new_room.center()
 
             (new_x, new_y) = new_room.center()
           
+
 
             if num_rooms == 0:
 
             if num_rooms == 0:
 
                 #this is the first room, where the player starts at
 
                 #this is the first room, where the player starts at
Line 354: Line 357:
 
                 #all rooms after the first:
 
                 #all rooms after the first:
 
                 #connect it to the previous room with a tunnel
 
                 #connect it to the previous room with a tunnel
               
+
 
                 #center coordinates of previous room
 
                 #center coordinates of previous room
 
                 (prev_x, prev_y) = rooms[num_rooms-1].center()
 
                 (prev_x, prev_y) = rooms[num_rooms-1].center()
               
+
 
                 #draw a coin (random number that is either 0 or 1)
 
                 #draw a coin (random number that is either 0 or 1)
 
                 if libtcod.random_get_int(0, 0, 1) == 1:
 
                 if libtcod.random_get_int(0, 0, 1) == 1:
Line 367: Line 370:
 
                     create_v_tunnel(prev_y, new_y, prev_x)
 
                     create_v_tunnel(prev_y, new_y, prev_x)
 
                     create_h_tunnel(prev_x, new_x, new_y)
 
                     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
 
             #finally, append the new room to the list
 
             rooms.append(new_room)
 
             rooms.append(new_room)
 
             num_rooms += 1
 
             num_rooms += 1
   
+
 
     #create stairs at the center of the last room
 
     #create stairs at the center of the last room
 
     stairs = Object(new_x, new_y, '<', 'stairs', libtcod.white, always_visible=True)
 
     stairs = Object(new_x, new_y, '<', 'stairs', libtcod.white, always_visible=True)
 
     objects.append(stairs)
 
     objects.append(stairs)
      
+
     stairs.send_to_back()  #so it's drawn below the monsters
 +
 
 
def random_choice_index(chances):  #choose one option from list of chances, returning its index
 
def random_choice_index(chances):  #choose one option from list of chances, returning its index
 
     #the dice will land on some number between 1 and the sum of the chances
 
     #the dice will land on some number between 1 and the sum of the chances
 
     dice = libtcod.random_get_int(0, 1, sum(chances))
 
     dice = libtcod.random_get_int(0, 1, sum(chances))
   
+
 
     #go through all chances, keeping the sum so far
 
     #go through all chances, keeping the sum so far
 
     running_sum = 0
 
     running_sum = 0
Line 385: Line 392:
 
     for w in chances:
 
     for w in chances:
 
         running_sum += w
 
         running_sum += w
       
+
 
         #see if the dice landed in the part that corresponds to this choice
 
         #see if the dice landed in the part that corresponds to this choice
 
         if dice <= running_sum:
 
         if dice <= running_sum:
 
             return choice
 
             return choice
 
         choice += 1
 
         choice += 1
 
+
 
def random_choice(chances_dict):
 
def random_choice(chances_dict):
 
     #choose one option from dictionary of chances, returning its key
 
     #choose one option from dictionary of chances, returning its key
 
     chances = chances_dict.values()
 
     chances = chances_dict.values()
 
     strings = chances_dict.keys()
 
     strings = chances_dict.keys()
 
+
 
     return strings[random_choice_index(chances)]
 
     return strings[random_choice_index(chances)]
 
+
 
def from_dungeon_level(table):
 
def from_dungeon_level(table):
 
     #returns a value that depends on level. the table specifies what value occurs after each level, default is 0.
 
     #returns a value that depends on level. the table specifies what value occurs after each level, default is 0.
Line 404: Line 411:
 
             return value
 
             return value
 
     return 0
 
     return 0
 
+
 
def place_objects(room):
 
def place_objects(room):
 
     #this is where we decide the chance of each monster or item appearing.
 
     #this is where we decide the chance of each monster or item appearing.
 
+
 
     #maximum number of monsters per room
 
     #maximum number of monsters per room
 
     max_monsters = from_dungeon_level([[2, 1], [3, 4], [5, 6]])
 
     max_monsters = from_dungeon_level([[2, 1], [3, 4], [5, 6]])
 
+
 
     #chance of each monster
 
     #chance of each monster
 
     monster_chances = {}
 
     monster_chances = {}
 
     monster_chances['orc'] = 80  #orc always shows up, even if all other monsters have 0 chance
 
     monster_chances['orc'] = 80  #orc always shows up, even if all other monsters have 0 chance
 
     monster_chances['troll'] = from_dungeon_level([[15, 3], [30, 5], [60, 7]])
 
     monster_chances['troll'] = from_dungeon_level([[15, 3], [30, 5], [60, 7]])
 
+
 
     #maximum number of items per room
 
     #maximum number of items per room
 
     max_items = from_dungeon_level([[1, 1], [2, 4]])
 
     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)
 
     #chance of each item (by default they have a chance of 0 at level 1, which then goes up)
 
     item_chances = {}
 
     item_chances = {}
Line 425: Line 432:
 
     item_chances['fireball'] =  from_dungeon_level([[25, 6]])
 
     item_chances['fireball'] =  from_dungeon_level([[25, 6]])
 
     item_chances['confuse'] =  from_dungeon_level([[10, 2]])
 
     item_chances['confuse'] =  from_dungeon_level([[10, 2]])
 
+
 
+
 
     #choose random number of monsters
 
     #choose random number of monsters
 
     num_monsters = libtcod.random_get_int(0, 0, max_monsters)
 
     num_monsters = libtcod.random_get_int(0, 0, max_monsters)
   
+
 
     for i in range(num_monsters):
 
     for i in range(num_monsters):
 
         #choose random spot for this monster
 
         #choose random spot for this monster
 
         x = libtcod.random_get_int(0, room.x1+1, room.x2-1)
 
         x = libtcod.random_get_int(0, room.x1+1, room.x2-1)
 
         y = libtcod.random_get_int(0, room.y1+1, room.y2-1)
 
         y = libtcod.random_get_int(0, room.y1+1, room.y2-1)
       
+
 
 
         #only place it if the tile is not blocked
 
         #only place it if the tile is not blocked
 
         if not is_blocked(x, y):
 
         if not is_blocked(x, y):
Line 442: Line 449:
 
                 fighter_component = Fighter(hp=20, defense=0, power=4, xp=35, death_function=monster_death)
 
                 fighter_component = Fighter(hp=20, defense=0, power=4, xp=35, death_function=monster_death)
 
                 ai_component = BasicMonster()
 
                 ai_component = BasicMonster()
               
+
 
                 monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green,
 
                 monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green,
 
                     blocks=True, fighter=fighter_component, ai=ai_component)
 
                     blocks=True, fighter=fighter_component, ai=ai_component)
               
+
 
             elif choice == 'troll':
 
             elif choice == 'troll':
 
                 #create a troll
 
                 #create a troll
 
                 fighter_component = Fighter(hp=30, defense=2, power=8, xp=100, death_function=monster_death)
 
                 fighter_component = Fighter(hp=30, defense=2, power=8, xp=100, death_function=monster_death)
 
                 ai_component = BasicMonster()
 
                 ai_component = BasicMonster()
               
+
 
                 monster = Object(x, y, 'T', 'troll', libtcod.darker_green,
 
                 monster = Object(x, y, 'T', 'troll', libtcod.darker_green,
 
                     blocks=True, fighter=fighter_component, ai=ai_component)
 
                     blocks=True, fighter=fighter_component, ai=ai_component)
           
+
 
             objects.append(monster)
 
             objects.append(monster)
   
+
 
     #choose random number of items
 
     #choose random number of items
 
     num_items = libtcod.random_get_int(0, 0, max_items)
 
     num_items = libtcod.random_get_int(0, 0, max_items)
   
+
 
     for i in range(num_items):
 
     for i in range(num_items):
 
         #choose random spot for this item
 
         #choose random spot for this item
 
         x = libtcod.random_get_int(0, room.x1+1, room.x2-1)
 
         x = libtcod.random_get_int(0, room.x1+1, room.x2-1)
 
         y = libtcod.random_get_int(0, room.y1+1, room.y2-1)
 
         y = libtcod.random_get_int(0, room.y1+1, room.y2-1)
       
+
 
         #only place it if the tile is not blocked
 
         #only place it if the tile is not blocked
 
         if not is_blocked(x, y):
 
         if not is_blocked(x, y):
Line 471: Line 478:
 
                 item_component = Item(use_function=cast_heal)
 
                 item_component = Item(use_function=cast_heal)
 
                 item = Object(x, y, '!', 'healing potion', libtcod.violet, item=item_component)
 
                 item = Object(x, y, '!', 'healing potion', libtcod.violet, item=item_component)
               
+
 
             elif choice == 'lightning':
 
             elif choice == 'lightning':
 
                 #create a lightning bolt scroll
 
                 #create a lightning bolt scroll
 
                 item_component = Item(use_function=cast_lightning)
 
                 item_component = Item(use_function=cast_lightning)
 
                 item = Object(x, y, '#', 'scroll of lightning bolt', libtcod.light_yellow, item=item_component)
 
                 item = Object(x, y, '#', 'scroll of lightning bolt', libtcod.light_yellow, item=item_component)
               
+
 
             elif choice == 'fireball':
 
             elif choice == 'fireball':
 
                 #create a fireball scroll
 
                 #create a fireball scroll
 
                 item_component = Item(use_function=cast_fireball)
 
                 item_component = Item(use_function=cast_fireball)
 
                 item = Object(x, y, '#', 'scroll of fireball', libtcod.light_yellow, item=item_component)
 
                 item = Object(x, y, '#', 'scroll of fireball', libtcod.light_yellow, item=item_component)
               
+
 
             elif choice == 'confuse':
 
             elif choice == 'confuse':
 
                 #create a confuse scroll
 
                 #create a confuse scroll
 
                 item_component = Item(use_function=cast_confuse)
 
                 item_component = Item(use_function=cast_confuse)
 
                 item = Object(x, y, '#', 'scroll of confusion', libtcod.light_yellow, item=item_component)
 
                 item = Object(x, y, '#', 'scroll of confusion', libtcod.light_yellow, item=item_component)
           
+
 
             objects.append(item)
 
             objects.append(item)
 
             item.send_to_back()  #items appear below other objects
 
             item.send_to_back()  #items appear below other objects
Line 495: Line 502:
 
     #render a bar (HP, experience, etc). first calculate the width of the bar
 
     #render a bar (HP, experience, etc). first calculate the width of the bar
 
     bar_width = int(float(value) / maximum * total_width)
 
     bar_width = int(float(value) / maximum * total_width)
   
+
 
     #render the background first
 
     #render the background first
     libtcod.console_set_background_color(panel, back_color)
+
     libtcod.console_set_default_background(panel, back_color)
     libtcod.console_rect(panel, x, y, total_width, 1, False)
+
     libtcod.console_rect(panel, x, y, total_width, 1, False, libtcod.BKGND_SCREEN)
   
+
 
     #now render the bar on top
 
     #now render the bar on top
     libtcod.console_set_background_color(panel, bar_color)
+
     libtcod.console_set_default_background(panel, bar_color)
 
     if bar_width > 0:
 
     if bar_width > 0:
         libtcod.console_rect(panel, x, y, bar_width, 1, False)
+
         libtcod.console_rect(panel, x, y, bar_width, 1, False, libtcod.BKGND_SCREEN)
   
+
 
     #finally, some centered text with the values
 
     #finally, some centered text with the values
     libtcod.console_set_foreground_color(panel, libtcod.white)
+
     libtcod.console_set_default_foreground(panel, libtcod.white)
     libtcod.console_print_center(panel, x + total_width / 2, y, libtcod.BKGND_NONE,
+
     libtcod.console_print_ex(panel, x + total_width / 2, y, libtcod.BKGND_NONE, libtcod.CENTER,
 
         name + ': ' + str(value) + '/' + str(maximum))
 
         name + ': ' + str(value) + '/' + str(maximum))
 
+
 
def get_names_under_mouse():
 
def get_names_under_mouse():
 +
    global mouse
 +
 
     #return a string with the names of all objects under the mouse
 
     #return a string with the names of all objects under the mouse
    mouse = libtcod.mouse_get_status()
 
 
     (x, y) = (mouse.cx, mouse.cy)
 
     (x, y) = (mouse.cx, mouse.cy)
   
+
 
     #create a list with the names of all objects at the mouse's coordinates and in FOV
 
     #create a list with the names of all objects at the mouse's coordinates and in FOV
 
     names = [obj.name for obj in objects
 
     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)]
 
         if obj.x == x and obj.y == y and libtcod.map_is_in_fov(fov_map, obj.x, obj.y)]
   
+
 
     names = ', '.join(names)  #join the names, separated by commas
 
     names = ', '.join(names)  #join the names, separated by commas
 
     return names.capitalize()
 
     return names.capitalize()
 
+
 
def render_all():
 
def render_all():
 
     global fov_map, color_dark_wall, color_light_wall
 
     global fov_map, color_dark_wall, color_light_wall
 
     global color_dark_ground, color_light_ground
 
     global color_dark_ground, color_light_ground
 
     global fov_recompute
 
     global fov_recompute
   
+
 
     if fov_recompute:
 
     if fov_recompute:
 
         #recompute FOV if needed (the player moved or something)
 
         #recompute FOV if needed (the player moved or something)
 
         fov_recompute = False
 
         fov_recompute = False
 
         libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO)
 
         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
 
         #go through all tiles, and set their background color according to the FOV
 
         for y in range(MAP_HEIGHT):
 
         for y in range(MAP_HEIGHT):
Line 541: Line 549:
 
                     if map[x][y].explored:
 
                     if map[x][y].explored:
 
                         if wall:
 
                         if wall:
                             libtcod.console_set_back(con, x, y, color_dark_wall, libtcod.BKGND_SET)
+
                             libtcod.console_set_char_background(con, x, y, color_dark_wall, libtcod.BKGND_SET)
 
                         else:
 
                         else:
                             libtcod.console_set_back(con, x, y, color_dark_ground, libtcod.BKGND_SET)
+
                             libtcod.console_set_char_background(con, x, y, color_dark_ground, libtcod.BKGND_SET)
 
                 else:
 
                 else:
 
                     #it's visible
 
                     #it's visible
 
                     if wall:
 
                     if wall:
                         libtcod.console_set_back(con, x, y, color_light_wall, libtcod.BKGND_SET )
+
                         libtcod.console_set_char_background(con, x, y, color_light_wall, libtcod.BKGND_SET )
 
                     else:
 
                     else:
                         libtcod.console_set_back(con, x, y, color_light_ground, libtcod.BKGND_SET )
+
                         libtcod.console_set_char_background(con, x, y, color_light_ground, libtcod.BKGND_SET )
 
                     #since it's visible, explore it
 
                     #since it's visible, explore it
 
                     map[x][y].explored = True
 
                     map[x][y].explored = True
 
+
 
     #draw all objects in the list, except the player. we want it to
 
     #draw all objects in the list, except the player. we want it to
 
     #always appear over all other objects! so it's drawn later.
 
     #always appear over all other objects! so it's drawn later.
Line 559: Line 567:
 
             object.draw()
 
             object.draw()
 
     player.draw()
 
     player.draw()
   
+
 
     #blit the contents of "con" to the root console
 
     #blit the contents of "con" to the root console
 
     libtcod.console_blit(con, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, 0, 0)
 
     libtcod.console_blit(con, 0, 0, MAP_WIDTH, MAP_HEIGHT, 0, 0, 0)
   
+
   
+
 
     #prepare to render the GUI panel
 
     #prepare to render the GUI panel
     libtcod.console_set_background_color(panel, libtcod.black)
+
     libtcod.console_set_default_background(panel, libtcod.black)
 
     libtcod.console_clear(panel)
 
     libtcod.console_clear(panel)
   
+
 
     #print the game messages, one line at a time
 
     #print the game messages, one line at a time
 
     y = 1
 
     y = 1
 
     for (line, color) in game_msgs:
 
     for (line, color) in game_msgs:
         libtcod.console_set_foreground_color(panel, color)
+
         libtcod.console_set_default_foreground(panel, color)
         libtcod.console_print_left(panel, MSG_X, y, libtcod.BKGND_NONE, line)
+
         libtcod.console_print_ex(panel, MSG_X, y, libtcod.BKGND_NONE, libtcod.LEFT, line)
 
         y += 1
 
         y += 1
   
+
 
     #show the player's stats
 
     #show the player's stats
 
     render_bar(1, 1, BAR_WIDTH, 'HP', player.fighter.hp, player.fighter.max_hp,
 
     render_bar(1, 1, BAR_WIDTH, 'HP', player.fighter.hp, player.fighter.max_hp,
 
         libtcod.light_red, libtcod.darker_red)
 
         libtcod.light_red, libtcod.darker_red)
     libtcod.console_print_left(panel, 1, 3, libtcod.BKGND_NONE, 'Dungeon level ' + str(dungeon_level))
+
     libtcod.console_print_ex(panel, 1, 3, libtcod.BKGND_NONE, libtcod.LEFT, 'Dungeon level ' + str(dungeon_level))
   
+
 
     #display names of objects under the mouse
 
     #display names of objects under the mouse
     libtcod.console_set_foreground_color(panel, libtcod.light_gray)
+
     libtcod.console_set_default_foreground(panel, libtcod.light_gray)
     libtcod.console_print_left(panel, 1, 0, libtcod.BKGND_NONE, get_names_under_mouse())
+
     libtcod.console_print_ex(panel, 1, 0, libtcod.BKGND_NONE, libtcod.LEFT, get_names_under_mouse())
   
+
 
     #blit the contents of "panel" to the root console
 
     #blit the contents of "panel" to the root console
 
     libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
 
     libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
   
+
 
+
 
def message(new_msg, color = libtcod.white):
 
def message(new_msg, color = libtcod.white):
 
     #split the message if necessary, among multiple lines
 
     #split the message if necessary, among multiple lines
 
     new_msg_lines = textwrap.wrap(new_msg, MSG_WIDTH)
 
     new_msg_lines = textwrap.wrap(new_msg, MSG_WIDTH)
   
+
 
     for line in new_msg_lines:
 
     for line in new_msg_lines:
 
         #if the buffer is full, remove the first line to make room for the new one
 
         #if the buffer is full, remove the first line to make room for the new one
 
         if len(game_msgs) == MSG_HEIGHT:
 
         if len(game_msgs) == MSG_HEIGHT:
 
             del game_msgs[0]
 
             del game_msgs[0]
       
+
 
         #add the new line as a tuple, with the text and the color
 
         #add the new line as a tuple, with the text and the color
 
         game_msgs.append( (line, color) )
 
         game_msgs.append( (line, color) )
       
+
 
+
 
def player_move_or_attack(dx, dy):
 
def player_move_or_attack(dx, dy):
 
     global fov_recompute
 
     global fov_recompute
   
+
 
     #the coordinates the player is moving to/attacking
 
     #the coordinates the player is moving to/attacking
 
     x = player.x + dx
 
     x = player.x + dx
 
     y = player.y + dy
 
     y = player.y + dy
   
+
 
     #try to find an attackable object there
 
     #try to find an attackable object there
 
     target = None
 
     target = None
Line 614: Line 622:
 
             target = object
 
             target = object
 
             break
 
             break
   
+
 
     #attack if target found, move otherwise
 
     #attack if target found, move otherwise
 
     if target is not None:
 
     if target is not None:
Line 621: Line 629:
 
         player.move(dx, dy)
 
         player.move(dx, dy)
 
         fov_recompute = True
 
         fov_recompute = True
 
+
 
+
 
def menu(header, options, width):
 
def menu(header, options, width):
 
     if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options.')
 
     if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 options.')
   
+
 
     #calculate total height for the header (after auto-wrap) and one line per option
 
     #calculate total height for the header (after auto-wrap) and one line per option
     header_height = libtcod.console_height_left_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
+
     header_height = libtcod.console_get_height_rect(con, 0, 0, width, SCREEN_HEIGHT, header)
 
     if header == '':
 
     if header == '':
 
         header_height = 0
 
         header_height = 0
 
     height = len(options) + header_height
 
     height = len(options) + header_height
   
+
 
     #create an off-screen console that represents the menu's window
 
     #create an off-screen console that represents the menu's window
 
     window = libtcod.console_new(width, height)
 
     window = libtcod.console_new(width, height)
   
+
 
     #print the header, with auto-wrap
 
     #print the header, with auto-wrap
     libtcod.console_set_foreground_color(window, libtcod.white)
+
     libtcod.console_set_default_foreground(window, libtcod.white)
     libtcod.console_print_left_rect(window, 0, 0, width, height, libtcod.BKGND_NONE, header)
+
     libtcod.console_print_rect_ex(window, 0, 0, width, height, libtcod.BKGND_NONE, libtcod.LEFT, header)
   
+
 
     #print all the options
 
     #print all the options
 
     y = header_height
 
     y = header_height
Line 644: Line 652:
 
     for option_text in options:
 
     for option_text in options:
 
         text = '(' + chr(letter_index) + ') ' + option_text
 
         text = '(' + chr(letter_index) + ') ' + option_text
         libtcod.console_print_left(window, 0, y, libtcod.BKGND_NONE, text)
+
         libtcod.console_print_ex(window, 0, y, libtcod.BKGND_NONE, libtcod.LEFT, text)
 
         y += 1
 
         y += 1
 
         letter_index += 1
 
         letter_index += 1
   
+
 
     #blit the contents of "window" to the root console
 
     #blit the contents of "window" to the root console
 
     x = SCREEN_WIDTH/2 - width/2
 
     x = SCREEN_WIDTH/2 - width/2
 
     y = SCREEN_HEIGHT/2 - height/2
 
     y = SCREEN_HEIGHT/2 - height/2
 
     libtcod.console_blit(window, 0, 0, width, height, 0, x, y, 1.0, 0.7)
 
     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
 
     #present the root console to the player and wait for a key-press
 
     libtcod.console_flush()
 
     libtcod.console_flush()
 
     key = libtcod.console_wait_for_keypress(True)
 
     key = libtcod.console_wait_for_keypress(True)
   
+
 
     if key.vk == libtcod.KEY_ENTER and key.lalt:  #(special case) Alt+Enter: toggle fullscreen
 
     if key.vk == libtcod.KEY_ENTER and key.lalt:  #(special case) Alt+Enter: toggle fullscreen
 
         libtcod.console_set_fullscreen(not libtcod.console_is_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
 
     #convert the ASCII code to an index; if it corresponds to an option, return it
 
     index = key.c - ord('a')
 
     index = key.c - ord('a')
 
     if index >= 0 and index < len(options): return index
 
     if index >= 0 and index < len(options): return index
 
     return None
 
     return None
 
+
 
def inventory_menu(header):
 
def inventory_menu(header):
 
     #show a menu with each item of the inventory as an option
 
     #show a menu with each item of the inventory as an option
Line 671: Line 679:
 
     else:
 
     else:
 
         options = [item.name for item in inventory]
 
         options = [item.name for item in inventory]
   
+
 
     index = menu(header, options, INVENTORY_WIDTH)
 
     index = menu(header, options, INVENTORY_WIDTH)
   
+
 
     #if an item was chosen, return it
 
     #if an item was chosen, return it
 
     if index is None or len(inventory) == 0: return None
 
     if index is None or len(inventory) == 0: return None
 
     return inventory[index].item
 
     return inventory[index].item
 
+
 
def msgbox(text, width=50):
 
def msgbox(text, width=50):
 
     menu(text, [], width)  #use menu() as a sort of "message box"
 
     menu(text, [], width)  #use menu() as a sort of "message box"
  
 
def handle_keys():
 
def handle_keys():
     key = libtcod.console_check_for_keypress(libtcod.KEY_PRESSED)
+
     global key;
   
+
 
     if key.vk == libtcod.KEY_ENTER and key.lalt:
 
     if key.vk == libtcod.KEY_ENTER and key.lalt:
 
         #Alt+Enter: toggle fullscreen
 
         #Alt+Enter: toggle fullscreen
 
         libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
 
         libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
       
+
 
     elif key.vk == libtcod.KEY_ESCAPE:
 
     elif key.vk == libtcod.KEY_ESCAPE:
 
         return 'exit'  #exit game
 
         return 'exit'  #exit game
   
+
 
     if game_state == 'playing':
 
     if game_state == 'playing':
 
         #movement keys
 
         #movement keys
         if key.vk in [libtcod.KEY_UP, libtcod.KEY_KP8]:
+
         if key.vk == libtcod.KEY_UP or key.vk == libtcod.KEY_KP8:
 
             player_move_or_attack(0, -1)
 
             player_move_or_attack(0, -1)
           
+
         elif key.vk == libtcod.KEY_DOWN or key.vk == libtcod.KEY_KP2:
         elif key.vk in [libtcod.KEY_DOWN, libtcod.KEY_KP2]:
+
 
             player_move_or_attack(0, 1)
 
             player_move_or_attack(0, 1)
           
+
         elif key.vk == libtcod.KEY_LEFT or key.vk == libtcod.KEY_KP4:
         elif key.vk in [libtcod.KEY_LEFT, libtcod.KEY_KP4]:
+
 
             player_move_or_attack(-1, 0)
 
             player_move_or_attack(-1, 0)
           
+
         elif key.vk == libtcod.KEY_RIGHT or key.vk == libtcod.KEY_KP6:
         elif key.vk in [libtcod.KEY_RIGHT, libtcod.KEY_KP6]:
+
 
             player_move_or_attack(1, 0)
 
             player_move_or_attack(1, 0)
 
+
         elif key.vk == libtcod.KEY_HOME or key.vk == libtcod.KEY_KP7:
         elif key.vk == libtcod.KEY_KP7:
+
 
             player_move_or_attack(-1, -1)
 
             player_move_or_attack(-1, -1)
           
+
         elif key.vk == libtcod.KEY_PAGEUP or key.vk == libtcod.KEY_KP9:
         elif key.vk == libtcod.KEY_KP9:
+
 
             player_move_or_attack(1, -1)
 
             player_move_or_attack(1, -1)
           
+
         elif key.vk == libtcod.KEY_END or key.vk == libtcod.KEY_KP1:
         elif key.vk == libtcod.KEY_KP1:
+
 
             player_move_or_attack(-1, 1)
 
             player_move_or_attack(-1, 1)
           
+
         elif key.vk == libtcod.KEY_PAGEDOWN or key.vk == libtcod.KEY_KP3:
         elif key.vk == libtcod.KEY_KP3:
+
 
             player_move_or_attack(1, 1)
 
             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:
 
         else:
 
             #test for other keys
 
             #test for other keys
 
             key_char = chr(key.c)
 
             key_char = chr(key.c)
           
+
 
             if key_char == 'g':
 
             if key_char == 'g':
 
                 #pick up an item
 
                 #pick up an item
Line 727: Line 729:
 
                         object.item.pick_up()
 
                         object.item.pick_up()
 
                         break
 
                         break
           
+
 
             if key_char == 'i':
 
             if key_char == 'i':
 
                 #show the inventory; if an item is selected, use it
 
                 #show the inventory; if an item is selected, use it
Line 733: Line 735:
 
                 if chosen_item is not None:
 
                 if chosen_item is not None:
 
                     chosen_item.use()
 
                     chosen_item.use()
           
+
 
             if key_char == 'd':
 
             if key_char == 'd':
 
                 #show the inventory; if an item is selected, drop it
 
                 #show the inventory; if an item is selected, drop it
Line 739: Line 741:
 
                 if chosen_item is not None:
 
                 if chosen_item is not None:
 
                     chosen_item.drop()
 
                     chosen_item.drop()
           
+
 
 
             if key_char == 'c':
 
             if key_char == 'c':
 
                 #show character information
 
                 #show character information
Line 746: Line 748:
 
                     '\nExperience to level up: ' + str(level_up_xp) + '\n\nMaximum HP: ' + str(player.fighter.max_hp) +
 
                     '\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)
 
                     '\nAttack: ' + str(player.fighter.power) + '\nDefense: ' + str(player.fighter.defense), CHARACTER_SCREEN_WIDTH)
           
+
 
 
             if key_char == '<':
 
             if key_char == '<':
 
                 #go down stairs, if the player is on them
 
                 #go down stairs, if the player is on them
 
                 if stairs.x == player.x and stairs.y == player.y:
 
                 if stairs.x == player.x and stairs.y == player.y:
 
                     next_level()
 
                     next_level()
           
 
            return 'didnt-take-turn'
 
  
 +
            return 'didnt-take-turn'
 +
 
def check_level_up():
 
def check_level_up():
 
     #see if the player's experience is enough to level-up
 
     #see if the player's experience is enough to level-up
Line 762: Line 764:
 
         player.fighter.xp -= level_up_xp
 
         player.fighter.xp -= level_up_xp
 
         message('Your battle skills grow stronger! You reached level ' + str(player.level) + '!', libtcod.yellow)
 
         message('Your battle skills grow stronger! You reached level ' + str(player.level) + '!', libtcod.yellow)
       
+
 
 
         choice = None
 
         choice = None
 
         while choice == None:  #keep asking until a choice is made
 
         while choice == None:  #keep asking until a choice is made
Line 769: Line 771:
 
                 'Strength (+1 attack, from ' + str(player.fighter.power) + ')',
 
                 'Strength (+1 attack, from ' + str(player.fighter.power) + ')',
 
                 'Agility (+1 defense, from ' + str(player.fighter.defense) + ')'], LEVEL_SCREEN_WIDTH)
 
                 'Agility (+1 defense, from ' + str(player.fighter.defense) + ')'], LEVEL_SCREEN_WIDTH)
       
+
 
         if choice == 0:
 
         if choice == 0:
 
             player.fighter.max_hp += 20
 
             player.fighter.max_hp += 20
Line 783: Line 785:
 
     message('You died!', libtcod.red)
 
     message('You died!', libtcod.red)
 
     game_state = 'dead'
 
     game_state = 'dead'
   
+
 
     #for added effect, transform the player into a corpse!
 
     #for added effect, transform the player into a corpse!
 
     player.char = '%'
 
     player.char = '%'
 
     player.color = libtcod.dark_red
 
     player.color = libtcod.dark_red
 
+
 
def monster_death(monster):
 
def monster_death(monster):
 
     #transform it into a nasty corpse! it doesn't block, can't be
 
     #transform it into a nasty corpse! it doesn't block, can't be
Line 799: Line 801:
 
     monster.name = 'remains of ' + monster.name
 
     monster.name = 'remains of ' + monster.name
 
     monster.send_to_back()
 
     monster.send_to_back()
 
+
 
def target_tile(max_range=None):
 
def target_tile(max_range=None):
 
     #return the position of a tile left-clicked in player's FOV (optionally in a range), or (None,None) if right-clicked.
 
     #return the position of a tile left-clicked in player's FOV (optionally in a range), or (None,None) if right-clicked.
 +
    global key, mouse
 
     while True:
 
     while True:
 
         #render the screen. this erases the inventory and shows the names of objects under the mouse.
 
         #render the screen. this erases the inventory and shows the names of objects under the mouse.
        render_all()
 
 
         libtcod.console_flush()
 
         libtcod.console_flush()
          
+
         libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS|libtcod.EVENT_MOUSE,key,mouse)
        key = libtcod.console_check_for_keypress()
+
         render_all()
         mouse = libtcod.mouse_get_status() #get mouse position and click status
+
 
         (x, y) = (mouse.cx, mouse.cy)
 
         (x, y) = (mouse.cx, mouse.cy)
       
+
 
 
         if mouse.rbutton_pressed or key.vk == libtcod.KEY_ESCAPE:
 
         if mouse.rbutton_pressed or key.vk == libtcod.KEY_ESCAPE:
 
             return (None, None)  #cancel if the player right-clicked or pressed Escape
 
             return (None, None)  #cancel if the player right-clicked or pressed Escape
       
+
 
 
         #accept the target if the player clicked in FOV, and in case a range is specified, if it's in that range
 
         #accept the target if the player clicked in FOV, and in case a range is specified, if it's in that range
 
         if (mouse.lbutton_pressed and libtcod.map_is_in_fov(fov_map, x, y) and
 
         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)):
 
             (max_range is None or player.distance(x, y) <= max_range)):
 
             return (x, y)
 
             return (x, y)
 
+
 
def target_monster(max_range=None):
 
def target_monster(max_range=None):
 
     #returns a clicked monster inside FOV up to a range, or None if right-clicked
 
     #returns a clicked monster inside FOV up to a range, or None if right-clicked
Line 825: Line 826:
 
         if x is None:  #player cancelled
 
         if x is None:  #player cancelled
 
             return None
 
             return None
       
+
 
         #return the first clicked monster, otherwise continue looping
 
         #return the first clicked monster, otherwise continue looping
 
         for obj in objects:
 
         for obj in objects:
 
             if obj.x == x and obj.y == y and obj.fighter and obj != player:
 
             if obj.x == x and obj.y == y and obj.fighter and obj != player:
 
                 return obj
 
                 return obj
 
+
 
def closest_monster(max_range):
 
def closest_monster(max_range):
 
     #find closest enemy, up to a maximum range, and in the player's FOV
 
     #find closest enemy, up to a maximum range, and in the player's FOV
 
     closest_enemy = None
 
     closest_enemy = None
 
     closest_dist = max_range + 1  #start with (slightly more than) maximum range
 
     closest_dist = max_range + 1  #start with (slightly more than) maximum range
   
+
 
     for object in objects:
 
     for object in objects:
 
         if object.fighter and not object == player and libtcod.map_is_in_fov(fov_map, object.x, object.y):
 
         if object.fighter and not object == player and libtcod.map_is_in_fov(fov_map, object.x, object.y):
Line 844: Line 845:
 
                 closest_dist = dist
 
                 closest_dist = dist
 
     return closest_enemy
 
     return closest_enemy
 
+
 
def cast_heal():
 
def cast_heal():
 
     #heal the player
 
     #heal the player
Line 850: Line 851:
 
         message('You are already at full health.', libtcod.red)
 
         message('You are already at full health.', libtcod.red)
 
         return 'cancelled'
 
         return 'cancelled'
   
+
 
     message('Your wounds start to feel better!', libtcod.light_violet)
 
     message('Your wounds start to feel better!', libtcod.light_violet)
 
     player.fighter.heal(HEAL_AMOUNT)
 
     player.fighter.heal(HEAL_AMOUNT)
 
+
 
def cast_lightning():
 
def cast_lightning():
 
     #find closest enemy (inside a maximum range) and damage it
 
     #find closest enemy (inside a maximum range) and damage it
Line 860: Line 861:
 
         message('No enemy is close enough to strike.', libtcod.red)
 
         message('No enemy is close enough to strike.', libtcod.red)
 
         return 'cancelled'
 
         return 'cancelled'
   
+
 
     #zap it!
 
     #zap it!
 
     message('A lighting bolt strikes the ' + monster.name + ' with a loud thunder! The damage is '
 
     message('A lighting bolt strikes the ' + monster.name + ' with a loud thunder! The damage is '
 
         + str(LIGHTNING_DAMAGE) + ' hit points.', libtcod.light_blue)
 
         + str(LIGHTNING_DAMAGE) + ' hit points.', libtcod.light_blue)
 
     monster.fighter.take_damage(LIGHTNING_DAMAGE)
 
     monster.fighter.take_damage(LIGHTNING_DAMAGE)
   
+
 
def cast_fireball():
 
def cast_fireball():
 
     #ask the player for a target tile to throw a fireball at
 
     #ask the player for a target tile to throw a fireball at
Line 872: Line 873:
 
     if x is None: return 'cancelled'
 
     if x is None: return 'cancelled'
 
     message('The fireball explodes, burning everything within ' + str(FIREBALL_RADIUS) + ' tiles!', libtcod.orange)
 
     message('The fireball explodes, burning everything within ' + str(FIREBALL_RADIUS) + ' tiles!', libtcod.orange)
   
+
 
     for obj in objects:  #damage every fighter in range, including the player
 
     for obj in objects:  #damage every fighter in range, including the player
 
         if obj.distance(x, y) <= FIREBALL_RADIUS and obj.fighter:
 
         if obj.distance(x, y) <= FIREBALL_RADIUS and obj.fighter:
 
             message('The ' + obj.name + ' gets burned for ' + str(FIREBALL_DAMAGE) + ' hit points.', libtcod.orange)
 
             message('The ' + obj.name + ' gets burned for ' + str(FIREBALL_DAMAGE) + ' hit points.', libtcod.orange)
 
             obj.fighter.take_damage(FIREBALL_DAMAGE)
 
             obj.fighter.take_damage(FIREBALL_DAMAGE)
   
+
 
def cast_confuse():
 
def cast_confuse():
 
     #ask the player for a target to confuse
 
     #ask the player for a target to confuse
Line 883: Line 884:
 
     monster = target_monster(CONFUSE_RANGE)
 
     monster = target_monster(CONFUSE_RANGE)
 
     if monster is None: return 'cancelled'
 
     if monster is None: return 'cancelled'
   
+
 
     #replace the monster's AI with a "confused" one; after some turns it will restore the old AI
 
     #replace the monster's AI with a "confused" one; after some turns it will restore the old AI
 
     old_ai = monster.ai
 
     old_ai = monster.ai
Line 889: Line 890:
 
     monster.ai.owner = monster  #tell the new component who owns it
 
     monster.ai.owner = monster  #tell the new component who owns it
 
     message('The eyes of the ' + monster.name + ' look vacant, as he starts to stumble around!', libtcod.light_green)
 
     message('The eyes of the ' + monster.name + ' look vacant, as he starts to stumble around!', libtcod.light_green)
 
+
 
+
 
def save_game():
 
def save_game():
 
     #open a new empty shelve (possibly overwriting an old one) to write the game data
 
     #open a new empty shelve (possibly overwriting an old one) to write the game data
Line 903: Line 903:
 
     file['dungeon_level'] = dungeon_level
 
     file['dungeon_level'] = dungeon_level
 
     file.close()
 
     file.close()
 
+
 
def load_game():
 
def load_game():
 
     #open the previously saved shelve and load the game data
 
     #open the previously saved shelve and load the game data
 
     global map, objects, player, stairs, inventory, game_msgs, game_state, dungeon_level
 
     global map, objects, player, stairs, inventory, game_msgs, game_state, dungeon_level
   
+
 
     file = shelve.open('savegame', 'r')
 
     file = shelve.open('savegame', 'r')
 
     map = file['map']
 
     map = file['map']
Line 918: Line 918:
 
     dungeon_level = file['dungeon_level']
 
     dungeon_level = file['dungeon_level']
 
     file.close()
 
     file.close()
   
+
 
     initialize_fov()
 
     initialize_fov()
 
+
 
def new_game():
 
def new_game():
 
     global player, inventory, game_msgs, game_state, dungeon_level
 
     global player, inventory, game_msgs, game_state, dungeon_level
   
+
 
     #create object representing the player
 
     #create object representing the player
 
     fighter_component = Fighter(hp=100, defense=1, power=4, xp=0, death_function=player_death)
 
     fighter_component = Fighter(hp=100, defense=1, power=4, xp=0, death_function=player_death)
 
     player = Object(0, 0, '@', 'player', libtcod.white, blocks=True, fighter=fighter_component)
 
     player = Object(0, 0, '@', 'player', libtcod.white, blocks=True, fighter=fighter_component)
   
+
 
     player.level = 1
 
     player.level = 1
   
+
 
     #generate map (at this point it's not drawn to the screen)
 
     #generate map (at this point it's not drawn to the screen)
 
     dungeon_level = 1
 
     dungeon_level = 1
 
     make_map()
 
     make_map()
 
     initialize_fov()
 
     initialize_fov()
 
+
 
     game_state = 'playing'
 
     game_state = 'playing'
 
     inventory = []
 
     inventory = []
 
+
 
     #create the list of game messages and their colors, starts empty
 
     #create the list of game messages and their colors, starts empty
 
     game_msgs = []
 
     game_msgs = []
 
+
 
     #a warm welcoming message!
 
     #a warm welcoming message!
 
     message('Welcome stranger! Prepare to perish in the Tombs of the Ancient Kings.', libtcod.red)
 
     message('Welcome stranger! Prepare to perish in the Tombs of the Ancient Kings.', libtcod.red)
 
+
 
def next_level():
 
def next_level():
 
     #advance to the next level
 
     #advance to the next level
Line 949: Line 949:
 
     message('You take a moment to rest, and recover your strength.', libtcod.light_violet)
 
     message('You take a moment to rest, and recover your strength.', libtcod.light_violet)
 
     player.fighter.heal(player.fighter.max_hp / 2)  #heal the player by 50%
 
     player.fighter.heal(player.fighter.max_hp / 2)  #heal the player by 50%
   
+
 
     dungeon_level += 1
 
     dungeon_level += 1
 
     message('After a rare moment of peace, you descend deeper into the heart of the dungeon...', libtcod.red)
 
     message('After a rare moment of peace, you descend deeper into the heart of the dungeon...', libtcod.red)
Line 958: Line 958:
 
     global fov_recompute, fov_map
 
     global fov_recompute, fov_map
 
     fov_recompute = True
 
     fov_recompute = True
   
+
 
     #create the FOV map, according to the generated map
 
     #create the FOV map, according to the generated map
 
     fov_map = libtcod.map_new(MAP_WIDTH, MAP_HEIGHT)
 
     fov_map = libtcod.map_new(MAP_WIDTH, MAP_HEIGHT)
Line 964: Line 964:
 
         for x in range(MAP_WIDTH):
 
         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)
 
             libtcod.map_set_properties(fov_map, x, y, not map[x][y].block_sight, not map[x][y].blocked)
   
+
 
     libtcod.console_clear(con)  #unexplored areas start black (which is the default background color)
 
     libtcod.console_clear(con)  #unexplored areas start black (which is the default background color)
   
+
 
def play_game():
 
def play_game():
 +
    global key, mouse
 +
 
     player_action = None
 
     player_action = None
      
+
 +
     mouse = libtcod.Mouse()
 +
    key = libtcod.Key()
 
     while not libtcod.console_is_window_closed():
 
     while not libtcod.console_is_window_closed():
 
         #render the screen
 
         #render the screen
 +
        libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS|libtcod.EVENT_MOUSE,key,mouse)
 
         render_all()
 
         render_all()
       
+
 
         libtcod.console_flush()
 
         libtcod.console_flush()
       
+
 
         #level up if needed
 
         #level up if needed
 
         check_level_up()
 
         check_level_up()
Line 982: Line 987:
 
         for object in objects:
 
         for object in objects:
 
             object.clear()
 
             object.clear()
       
+
 
         #handle keys and exit game if needed
 
         #handle keys and exit game if needed
 
         player_action = handle_keys()
 
         player_action = handle_keys()
Line 988: Line 993:
 
             save_game()
 
             save_game()
 
             break
 
             break
       
+
 
         #let monsters take their turn
 
         #let monsters take their turn
 
         if game_state == 'playing' and player_action != 'didnt-take-turn':
 
         if game_state == 'playing' and player_action != 'didnt-take-turn':
Line 994: Line 999:
 
                 if object.ai:
 
                 if object.ai:
 
                     object.ai.take_turn()
 
                     object.ai.take_turn()
 
+
 
def main_menu():
 
def main_menu():
 
     img = libtcod.image_load('menu_background.png')
 
     img = libtcod.image_load('menu_background.png')
   
+
 
     while not libtcod.console_is_window_closed():
 
     while not libtcod.console_is_window_closed():
 
         #show the background image, at twice the regular console resolution
 
         #show the background image, at twice the regular console resolution
 
         libtcod.image_blit_2x(img, 0, 0, 0)
 
         libtcod.image_blit_2x(img, 0, 0, 0)
       
+
 
         #show the game's title, and some credits!
 
         #show the game's title, and some credits!
         libtcod.console_set_foreground_color(0, libtcod.light_yellow)
+
         libtcod.console_set_default_foreground(0, libtcod.light_yellow)
         libtcod.console_print_center(0, SCREEN_WIDTH/2, SCREEN_HEIGHT/2-4, libtcod.BKGND_NONE, 'TOMBS OF THE ANCIENT KINGS')
+
         libtcod.console_print_ex(0, SCREEN_WIDTH/2, SCREEN_HEIGHT/2-4, libtcod.BKGND_NONE, libtcod.CENTER,
         libtcod.console_print_center(0, SCREEN_WIDTH/2, SCREEN_HEIGHT-2, libtcod.BKGND_NONE, 'By Jotaf')
+
            'TOMBS OF THE ANCIENT KINGS')
       
+
         libtcod.console_print_ex(0, SCREEN_WIDTH/2, SCREEN_HEIGHT-2, libtcod.BKGND_NONE, libtcod.CENTER,
 +
            'By Jotaf')
 +
 
         #show options and wait for the player's choice
 
         #show options and wait for the player's choice
 
         choice = menu('', ['Play a new game', 'Continue last game', 'Quit'], 24)
 
         choice = menu('', ['Play a new game', 'Continue last game', 'Quit'], 24)
       
+
 
         if choice == 0:  #new game
 
         if choice == 0:  #new game
 
             new_game()
 
             new_game()
Line 1,022: Line 1,029:
 
         elif choice == 2:  #quit
 
         elif choice == 2:  #quit
 
             break
 
             break
 
+
 
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
 
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
 
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
 
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
Line 1,028: Line 1,035:
 
con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
 
con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
 
panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
 
panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
 
+
 
main_menu()
 
main_menu()
 
</syntaxhighlight></div>
 
</syntaxhighlight></div>
  
 
[[Category:Developing]]
 
[[Category:Developing]]

Latest revision as of 04:59, 23 September 2016

This is part of a series of tutorials; the main page can be found here.

The tutorial uses libtcod version 1.6.0 and above.

If you choose to use 1.5.1, you can find the old version here.
If you choose to use 1.5.0, you can find the old version here.


[edit] Monster and item progression

#!/usr/bin/python
#
# libtcod python tutorial
#
 
import libtcodpy as libtcod
import math
import textwrap
import shelve
 
#actual size of the window
SCREEN_WIDTH = 80
SCREEN_HEIGHT = 50
 
#size of the map
MAP_WIDTH = 80
MAP_HEIGHT = 43
 
#sizes and coordinates relevant for the GUI
BAR_WIDTH = 20
PANEL_HEIGHT = 7
PANEL_Y = SCREEN_HEIGHT - PANEL_HEIGHT
MSG_X = BAR_WIDTH + 2
MSG_WIDTH = SCREEN_WIDTH - BAR_WIDTH - 2
MSG_HEIGHT = PANEL_HEIGHT - 1
INVENTORY_WIDTH = 50
CHARACTER_SCREEN_WIDTH = 30
LEVEL_SCREEN_WIDTH = 40
 
#parameters for dungeon generator
ROOM_MAX_SIZE = 10
ROOM_MIN_SIZE = 6
MAX_ROOMS = 30
 
#spell values
HEAL_AMOUNT = 40
LIGHTNING_DAMAGE = 40
LIGHTNING_RANGE = 5
CONFUSE_RANGE = 8
CONFUSE_NUM_TURNS = 10
FIREBALL_RADIUS = 3
FIREBALL_DAMAGE = 25
 
#experience and level-ups
LEVEL_UP_BASE = 200
LEVEL_UP_FACTOR = 150
 
 
FOV_ALGO = 0  #default FOV algorithm
FOV_LIGHT_WALLS = True  #light walls or not
TORCH_RADIUS = 10
 
LIMIT_FPS = 20  #20 frames-per-second maximum
 
 
color_dark_wall = libtcod.Color(0, 0, 100)
color_light_wall = libtcod.Color(130, 110, 50)
color_dark_ground = libtcod.Color(50, 50, 150)
color_light_ground = libtcod.Color(200, 180, 50)
 
 
class Tile:
    #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
        self.block_sight = block_sight
 
class Rect:
    #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
                self.y1 <= other.y2 and self.y2 >= other.y1)
 
class Object:
    #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):
        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
        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
 
    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
 
    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):
        #return the distance to another object
        dx = other.x - self.x
        dy = other.y - self.y
        return math.sqrt(dx ** 2 + dy ** 2)
 
    def distance(self, x, y):
        #return the distance to some coordinates
        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)):
            #set the color and then draw the character that represents this object at its position
            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
        libtcod.console_put_char(con, self.x, self.y, ' ', libtcod.BKGND_NONE)
 
 
class Fighter:
    #combat-related properties and methods (monster, player, NPC).
    def __init__(self, hp, defense, power, xp, death_function=None):
        self.max_hp = hp
        self.hp = hp
        self.defense = defense
        self.power = power
        self.xp = xp
        self.death_function = death_function
 
    def attack(self, target):
        #a simple formula for attack damage
        damage = self.power - target.fighter.defense
 
        if damage > 0:
            #make the target take some damage
            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!')
 
    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
        self.hp += amount
        if self.hp > self.max_hp:
            self.hp = self.max_hp
 
class BasicMonster:
    #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:
                monster.fighter.attack(player)
 
class ConfusedMonster:
    #AI for a temporarily confused monster (reverts to previous AI after a while).
    def __init__(self, old_ai, num_turns=CONFUSE_NUM_TURNS):
        self.old_ai = old_ai
        self.num_turns = num_turns
 
    def take_turn(self):
        if self.num_turns > 0:  #still confused...
            #move in a random direction, and decrease the number of turns confused
            self.owner.move(libtcod.random_get_int(0, -1, 1), libtcod.random_get_int(0, -1, 1))
            self.num_turns -= 1
 
        else:  #restore the previous AI (this one will be deleted because it's not referenced anymore)
            self.owner.ai = self.old_ai
            message('The ' + self.owner.name + ' is no longer confused!', libtcod.red)
 
 
class Item:
    #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) >= 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)
 
    def drop(self):
        #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
        message('You dropped a ' + self.owner.name + '.', libtcod.yellow)
 
    def use(self):
        #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':
                inventory.remove(self.owner)  #destroy after use, unless it was cancelled for some reason
 
def is_blocked(x, y):
    #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
 
    return False
 
def create_room(room):
    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
            map[x][y].block_sight = False
 
def create_h_tunnel(x1, x2, y):
    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
        map[x][y].block_sight = False
 
def create_v_tunnel(y1, y2, x):
    global map
    #vertical tunnel
    for y in range(min(y1, y2), max(y1, y2) + 1):
        map[x][y].blocked = False
        map[x][y].block_sight = False
 
def make_map():
    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)
    stairs.send_to_back()  #so it's drawn below the monsters
 
def random_choice_index(chances):  #choose one option from list of chances, returning its index
    #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
        choice += 1
 
def random_choice(chances_dict):
    #choose one option from dictionary of chances, returning its key
    chances = chances_dict.values()
    strings = chances_dict.keys()
 
    return strings[random_choice_index(chances)]
 
def from_dungeon_level(table):
    #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
    return 0
 
def place_objects(room):
    #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['orc'] = 80  #orc always shows up, even if all other monsters have 0 chance
    monster_chances['troll'] = from_dungeon_level([[15, 3], [30, 5], [60, 7]])
 
    #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['lightning'] = from_dungeon_level([[25, 4]])
    item_chances['fireball'] =  from_dungeon_level([[25, 6]])
    item_chances['confuse'] =   from_dungeon_level([[10, 2]])
 
 
    #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 == 'orc':
                #create an orc
                fighter_component = Fighter(hp=20, defense=0, power=4, xp=35, death_function=monster_death)
                ai_component = BasicMonster()
 
                monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green,
                    blocks=True, fighter=fighter_component, ai=ai_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()
 
                monster = Object(x, y, 'T', 'troll', 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 == 'lightning':
                #create a lightning bolt scroll
                item_component = Item(use_function=cast_lightning)
                item = Object(x, y, '#', 'scroll of lightning bolt', libtcod.light_yellow, item=item_component)
 
            elif choice == 'fireball':
                #create a fireball scroll
                item_component = Item(use_function=cast_fireball)
                item = Object(x, y, '#', 'scroll of fireball', libtcod.light_yellow, item=item_component)
 
            elif choice == 'confuse':
                #create a confuse scroll
                item_component = Item(use_function=cast_confuse)
                item = Object(x, y, '#', 'scroll of confusion', libtcod.light_yellow, item=item_component)
 
            objects.append(item)
            item.send_to_back()  #items appear below other objects
            item.always_visible = True  #items are visible even out-of-FOV, if in an explored area
 
 
def render_bar(x, y, total_width, name, value, maximum, bar_color, back_color):
    #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,
        name + ': ' + str(value) + '/' + str(maximum))
 
def get_names_under_mouse():
    global mouse
 
    #return a string with the names of all objects under the mouse
    (x, y) = (mouse.cx, mouse.cy)
 
    #create a list with the names of all objects at the mouse's coordinates and in FOV
    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)  #join the names, separated by commas
    return names.capitalize()
 
def render_all():
    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)
    libtcod.console_print_ex(panel, 1, 0, libtcod.BKGND_NONE, libtcod.LEFT, get_names_under_mouse())
 
    #blit the contents of "panel" to the root console
    libtcod.console_blit(panel, 0, 0, SCREEN_WIDTH, PANEL_HEIGHT, 0, 0, PANEL_Y)
 
 
def message(new_msg, color = libtcod.white):
    #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
        game_msgs.append( (line, color) )
 
 
def player_move_or_attack(dx, dy):
    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)
        fov_recompute = True
 
 
def menu(header, options, width):
    if len(options) > 26: raise ValueError('Cannot have a menu with more than 26 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
    return None
 
def inventory_menu(header):
    #show a menu with each item of the inventory as an option
    if len(inventory) == 0:
        options = ['Inventory is empty.']
    else:
        options = [item.name for item in inventory]
 
    index = menu(header, options, INVENTORY_WIDTH)
 
    #if an item was chosen, return it
    if index is None or len(inventory) == 0: return None
    return inventory[index].item
 
def msgbox(text, width=50):
    menu(text, [], width)  #use menu() as a sort of "message box"
 
def handle_keys():
    global key;
 
    if key.vk == libtcod.KEY_ENTER and key.lalt:
        #Alt+Enter: toggle fullscreen
        libtcod.console_set_fullscreen(not libtcod.console_is_fullscreen())
 
    elif 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:
            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':
                #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')
                if chosen_item is not None:
                    chosen_item.use()
 
            if key_char == 'd':
                #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')
                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 == '<':
                #go down stairs, if the player is on them
                if stairs.x == player.x and stairs.y == player.y:
                    next_level()
 
            return 'didnt-take-turn'
 
def check_level_up():
    #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
        message('Your battle skills grow stronger! You reached level ' + str(player.level) + '!', libtcod.yellow)
 
        choice = None
        while choice == 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.max_hp += 20
            player.fighter.hp += 20
        elif choice == 1:
            player.fighter.power += 1
        elif choice == 2:
            player.fighter.defense += 1
 
def player_death(player):
    #the game ended!
    global game_state
    message('You died!', libtcod.red)
    game_state = 'dead'
 
    #for added effect, transform the player into a corpse!
    player.char = '%'
    player.color = libtcod.dark_red
 
def monster_death(monster):
    #transform it into a nasty corpse! it doesn't block, can't be
    #attacked and doesn't move
    message('The ' + monster.name + ' 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
    monster.send_to_back()
 
def target_tile(max_range=None):
    #return the position of a tile left-clicked in player's FOV (optionally in a range), or (None,None) if right-clicked.
    global key, mouse
    while True:
        #render the screen. this erases the inventory and shows the names of objects under the mouse.
        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.rbutton_pressed or key.vk == libtcod.KEY_ESCAPE:
            return (None, None)  #cancel if the player right-clicked or pressed Escape
 
        #accept the target if the player clicked in FOV, and in case a range is specified, if it's in that range
        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)
 
def target_monster(max_range=None):
    #returns a clicked monster inside FOV up to a range, or None if right-clicked
    while True:
        (x, y) = target_tile(max_range)
        if x is None:  #player cancelled
            return None
 
        #return the first clicked monster, otherwise continue looping
        for obj in objects:
            if obj.x == x and obj.y == y and obj.fighter and obj != player:
                return obj
 
def closest_monster(max_range):
    #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
    return closest_enemy
 
def cast_heal():
    #heal the player
    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)
    player.fighter.heal(HEAL_AMOUNT)
 
def cast_lightning():
    #find closest enemy (inside a maximum range) and damage it
    monster = closest_monster(LIGHTNING_RANGE)
    if monster is None:  #no enemy found within maximum range
        message('No enemy is close enough to strike.', libtcod.red)
        return 'cancelled'
 
    #zap it!
    message('A lighting bolt strikes the ' + monster.name + ' with a loud thunder! The damage is '
        + str(LIGHTNING_DAMAGE) + ' hit points.', libtcod.light_blue)
    monster.fighter.take_damage(LIGHTNING_DAMAGE)
 
def cast_fireball():
    #ask the player for a target tile to throw a fireball at
    message('Left-click a target tile for the fireball, or right-click to cancel.', 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:  #damage every fighter in range, including the player
        if obj.distance(x, y) <= FIREBALL_RADIUS and obj.fighter:
            message('The ' + obj.name + ' gets burned for ' + str(FIREBALL_DAMAGE) + ' hit points.', libtcod.orange)
            obj.fighter.take_damage(FIREBALL_DAMAGE)
 
def cast_confuse():
    #ask the player for a target to confuse
    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'
 
    #replace the monster's AI with a "confused" one; after some turns it will restore the old AI
    old_ai = monster.ai
    monster.ai = ConfusedMonster(old_ai)
    monster.ai.owner = monster  #tell the new component who owns it
    message('The eyes of the ' + monster.name + ' look vacant, as he starts to stumble around!', libtcod.light_green)
 
def save_game():
    #open a new empty shelve (possibly overwriting an old one) to write the game data
    file = shelve.open('savegame', 'n')
    file['map'] = map
    file['objects'] = objects
    file['player_index'] = objects.index(player)  #index of player in objects list
    file['stairs_index'] = objects.index(stairs)  #same for the stairs
    file['inventory'] = inventory
    file['game_msgs'] = game_msgs
    file['game_state'] = game_state
    file['dungeon_level'] = dungeon_level
    file.close()
 
def load_game():
    #open the previously saved shelve and load the game data
    global map, objects, player, stairs, inventory, game_msgs, game_state, dungeon_level
 
    file = shelve.open('savegame', 'r')
    map = file['map']
    objects = file['objects']
    player = objects[file['player_index']]  #get index of player in objects list and access it
    stairs = objects[file['stairs_index']]  #same for the stairs
    inventory = file['inventory']
    game_msgs = file['game_msgs']
    game_state = file['game_state']
    dungeon_level = file['dungeon_level']
    file.close()
 
    initialize_fov()
 
def new_game():
    global player, inventory, game_msgs, game_state, dungeon_level
 
    #create object representing the player
    fighter_component = Fighter(hp=100, defense=1, power=4, xp=0, death_function=player_death)
    player = Object(0, 0, '@', '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 = []
 
    #a warm welcoming message!
    message('Welcome stranger! Prepare to perish in the Tombs of the Ancient Kings.', libtcod.red)
 
def next_level():
    #advance to the next level
    global dungeon_level
    message('You take a moment to rest, and recover your strength.', libtcod.light_violet)
    player.fighter.heal(player.fighter.max_hp / 2)  #heal the player by 50%
 
    dungeon_level += 1
    message('After a rare moment of peace, you descend deeper into the heart of the dungeon...', libtcod.red)
    make_map()  #create a fresh new level!
    initialize_fov()
 
def initialize_fov():
    global fov_recompute, fov_map
    fov_recompute = True
 
    #create the FOV map, according to the generated map
    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)
 
    libtcod.console_clear(con)  #unexplored areas start black (which is the default background color)
 
def play_game():
    global key, mouse
 
    player_action = None
 
    mouse = libtcod.Mouse()
    key = libtcod.Key()
    while not libtcod.console_is_window_closed():
        #render the screen
        libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS|libtcod.EVENT_MOUSE,key,mouse)
        render_all()
 
        libtcod.console_flush()
 
        #level up if needed
        check_level_up()
 
        #erase all objects at their old locations, before they move
        for object in objects:
            object.clear()
 
        #handle keys and exit game if needed
        player_action = handle_keys()
        if player_action == 'exit':
            save_game()
            break
 
        #let monsters take their turn
        if game_state == 'playing' and player_action != 'didnt-take-turn':
            for object in objects:
                if object.ai:
                    object.ai.take_turn()
 
def main_menu():
    img = libtcod.image_load('menu_background.png')
 
    while not libtcod.console_is_window_closed():
        #show the background image, at twice the regular console resolution
        libtcod.image_blit_2x(img, 0, 0, 0)
 
        #show the game's title, and some credits!
        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 Jotaf')
 
        #show options and wait for the player's choice
        choice = menu('', ['Play a new game', 'Continue last game', 'Quit'], 24)
 
        if choice == 0:  #new game
            new_game()
            play_game()
        if choice == 1:  #load last game
            try:
                load_game()
            except:
                msgbox('\n No saved game to load.\n', 24)
                continue
            play_game()
        elif choice == 2:  #quit
            break
 
libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
libtcod.sys_set_fps(LIMIT_FPS)
con = libtcod.console_new(MAP_WIDTH, MAP_HEIGHT)
panel = libtcod.console_new(SCREEN_WIDTH, PANEL_HEIGHT)
 
main_menu()
Personal tools