Difference between revisions of "Complete Roguelike Tutorial, using python+libtcod, part 10 code"
Jump to navigation
Jump to search
Hari Seldon (talk | contribs) |
(Update to libtcod 1.5.1. There's a link at the top to the old version.) |
||
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 the '''code''' for a series of tutorials; the main page can be found [[Complete Roguelike Tutorial, using python+libtcod|here]]. | ||
This part of the tutorial has been converted to use libctod version 1.5.1, but later parts still use 1.5.0. If you wish to follow the complete tutorial, you probably want the old version [http://roguebasin.roguelikedevelopment.org/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod,_part_10_code&oldid=29857 here] | |||
</center></td></tr></table></center> | </center></td></tr></table></center> | ||
Line 9: | Line 11: | ||
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 26: | Line 28: | ||
MSG_HEIGHT = PANEL_HEIGHT - 1 | MSG_HEIGHT = PANEL_HEIGHT - 1 | ||
INVENTORY_WIDTH = 50 | INVENTORY_WIDTH = 50 | ||
#parameters for dungeon generator | #parameters for dungeon generator | ||
ROOM_MAX_SIZE = 10 | ROOM_MAX_SIZE = 10 | ||
Line 33: | Line 35: | ||
MAX_ROOM_MONSTERS = 3 | MAX_ROOM_MONSTERS = 3 | ||
MAX_ROOM_ITEMS = 2 | MAX_ROOM_ITEMS = 2 | ||
#spell values | #spell values | ||
HEAL_AMOUNT = 4 | HEAL_AMOUNT = 4 | ||
Line 42: | Line 44: | ||
FIREBALL_RADIUS = 3 | FIREBALL_RADIUS = 3 | ||
FIREBALL_DAMAGE = 12 | FIREBALL_DAMAGE = 12 | ||
FOV_ALGO = 0 #default FOV algorithm | FOV_ALGO = 0 #default FOV algorithm | ||
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 76: | Line 78: | ||
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 100: | Line 102: | ||
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 114: | Line 116: | ||
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 120: | Line 122: | ||
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 126: | Line 128: | ||
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 132: | Line 134: | ||
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 142: | Line 144: | ||
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 | #only show if it's visible to the player | ||
if libtcod.map_is_in_fov(fov_map, self.x, self.y): | if libtcod.map_is_in_fov(fov_map, self.x, self.y): | ||
#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. | 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 163: | Line 165: | ||
self.power = power | self.power = power | ||
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 174: | Line 176: | ||
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 185: | Line 187: | ||
if function is not None: | if function is not None: | ||
function(self.owner) | function(self.owner) | ||
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 198: | Line 200: | ||
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 212: | Line 214: | ||
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 218: | Line 220: | ||
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 228: | Line 230: | ||
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 237: | Line 239: | ||
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 245: | Line 247: | ||
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 253: | Line 255: | ||
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 273: | Line 275: | ||
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 280: | Line 282: | ||
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 287: | Line 289: | ||
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 | global map, objects | ||
#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 309: | Line 311: | ||
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 319: | Line 321: | ||
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 | #add some contents to this room, such as monsters | ||
place_objects(new_room) | 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 339: | Line 341: | ||
#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 352: | Line 354: | ||
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) | ||
#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 | ||
def place_objects(room): | def place_objects(room): | ||
#choose random number of monsters | #choose random number of monsters | ||
num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_MONSTERS) | num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_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 373: | Line 375: | ||
fighter_component = Fighter(hp=10, defense=0, power=3, death_function=monster_death) | fighter_component = Fighter(hp=10, defense=0, power=3, 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) | ||
Line 380: | Line 382: | ||
fighter_component = Fighter(hp=16, defense=1, power=4, death_function=monster_death) | fighter_component = Fighter(hp=16, defense=1, power=4, 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_ROOM_ITEMS) | num_items = libtcod.random_get_int(0, 0, MAX_ROOM_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 400: | Line 402: | ||
#create a healing potion (70% chance) | #create a healing potion (70% chance) | ||
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 dice < 70+10: | elif dice < 70+10: | ||
#create a lightning bolt scroll (10% chance) | #create a lightning bolt scroll (10% chance) | ||
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 dice < 70+10+10: | elif dice < 70+10+10: | ||
#create a fireball scroll (10% chance) | #create a fireball scroll (10% chance) | ||
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) | ||
else: | else: | ||
#create a confuse scroll (10% chance) | #create a confuse scroll (10% chance) | ||
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 425: | Line 427: | ||
#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. | 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. | 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. | libtcod.console_set_default_foreground(panel, libtcod.white) | ||
libtcod. | 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 | ||
(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 471: | Line 474: | ||
if map[x][y].explored: | if map[x][y].explored: | ||
if wall: | if wall: | ||
libtcod. | libtcod.console_set_char_background(con, x, y, color_dark_wall, libtcod.BKGND_SET) | ||
else: | else: | ||
libtcod. | 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. | libtcod.console_set_char_background(con, x, y, color_light_wall, libtcod.BKGND_SET ) | ||
else: | else: | ||
libtcod. | 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 489: | Line 492: | ||
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. | 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. | libtcod.console_set_default_foreground(panel, color) | ||
libtcod. | 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) | ||
#display names of objects under the mouse | #display names of objects under the mouse | ||
libtcod. | libtcod.console_set_default_foreground(panel, libtcod.light_gray) | ||
libtcod. | 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 543: | Line 546: | ||
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 550: | Line 553: | ||
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. | 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. | libtcod.console_set_default_foreground(window, libtcod.white) | ||
libtcod. | 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 573: | Line 576: | ||
for option_text in options: | for option_text in options: | ||
text = '(' + chr(letter_index) + ') ' + option_text | text = '(' + chr(letter_index) + ') ' + option_text | ||
libtcod. | 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 600: | Line 603: | ||
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 handle_keys(): | def handle_keys(): | ||
key | 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 == libtcod.KEY_UP: | if key.vk == libtcod.KEY_UP: | ||
player_move_or_attack(0, -1) | player_move_or_attack(0, -1) | ||
elif key.vk == libtcod.KEY_DOWN: | elif key.vk == libtcod.KEY_DOWN: | ||
player_move_or_attack(0, 1) | player_move_or_attack(0, 1) | ||
elif key.vk == libtcod.KEY_LEFT: | elif key.vk == libtcod.KEY_LEFT: | ||
player_move_or_attack(-1, 0) | player_move_or_attack(-1, 0) | ||
elif key.vk == libtcod.KEY_RIGHT: | elif key.vk == libtcod.KEY_RIGHT: | ||
player_move_or_attack(1, 0) | player_move_or_attack(1, 0) | ||
Line 636: | Line 636: | ||
#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 643: | Line 643: | ||
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 649: | Line 649: | ||
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 655: | Line 655: | ||
if chosen_item is not None: | if chosen_item is not None: | ||
chosen_item.drop() | chosen_item.drop() | ||
return 'didnt-take-turn' | return 'didnt-take-turn' | ||
def player_death(player): | def player_death(player): | ||
#the game ended! | #the game ended! | ||
Line 663: | Line 663: | ||
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 679: | Line 679: | ||
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. | ||
libtcod.console_flush() | |||
libtcod.sys_check_for_event(libtcod.EVENT_KEY_PRESS|libtcod.EVENT_MOUSE,key,mouse) | |||
render_all() | render_all() | ||
(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 705: | Line 704: | ||
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 724: | Line 723: | ||
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 730: | Line 729: | ||
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 740: | Line 739: | ||
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 752: | Line 751: | ||
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 763: | Line 762: | ||
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 769: | Line 768: | ||
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 781: | Line 779: | ||
file['game_state'] = game_state | file['game_state'] = game_state | ||
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, inventory, game_msgs, game_state | global map, objects, player, inventory, game_msgs, game_state | ||
file = shelve.open('savegame', 'r') | file = shelve.open('savegame', 'r') | ||
map = file['map'] | map = file['map'] | ||
Line 794: | Line 792: | ||
game_state = file['game_state'] | game_state = file['game_state'] | ||
file.close() | file.close() | ||
initialize_fov() | initialize_fov() | ||
def new_game(): | def new_game(): | ||
global player, inventory, game_msgs, game_state | global player, inventory, game_msgs, game_state | ||
#create object representing the player | #create object representing the player | ||
fighter_component = Fighter(hp=30, defense=2, power=5, death_function=player_death) | fighter_component = Fighter(hp=30, defense=2, power=5, 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) | ||
#generate map (at this point it's not drawn to the screen) | #generate map (at this point it's not drawn to the screen) | ||
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 initialize_fov(): | def initialize_fov(): | ||
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 826: | Line 824: | ||
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() | ||
#erase all objects at their old locations, before they move | #erase all objects at their old locations, before they move | ||
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 847: | Line 850: | ||
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 853: | Line 856: | ||
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. | libtcod.console_set_default_foreground(0, libtcod.light_yellow) | ||
libtcod. | libtcod.console_print_ex(0, SCREEN_WIDTH/2, SCREEN_HEIGHT/2-4, libtcod.BKGND_NONE, libtcod.CENTER, | ||
libtcod. | '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 881: | Line 886: | ||
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 887: | Line 892: | ||
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]] |
Revision as of 01:42, 11 November 2012
This is part of the code for a series of tutorials; the main page can be found here. This part of the tutorial has been converted to use libctod version 1.5.1, but later parts still use 1.5.0. If you wish to follow the complete tutorial, you probably want the old version here |
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
#parameters for dungeon generator
ROOM_MAX_SIZE = 10
ROOM_MIN_SIZE = 6
MAX_ROOMS = 30
MAX_ROOM_MONSTERS = 3
MAX_ROOM_ITEMS = 2
#spell values
HEAL_AMOUNT = 4
LIGHTNING_DAMAGE = 20
LIGHTNING_RANGE = 5
CONFUSE_RANGE = 8
CONFUSE_NUM_TURNS = 10
FIREBALL_RADIUS = 3
FIREBALL_DAMAGE = 12
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, 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.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
if libtcod.map_is_in_fov(fov_map, self.x, self.y):
#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, death_function=None):
self.max_hp = hp
self.hp = hp
self.defense = defense
self.power = power
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)
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
#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)
#add some contents to this room, such as monsters
place_objects(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)
#finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
def place_objects(room):
#choose random number of monsters
num_monsters = libtcod.random_get_int(0, 0, MAX_ROOM_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):
if libtcod.random_get_int(0, 0, 100) < 80: #80% chance of getting an orc
#create an orc
fighter_component = Fighter(hp=10, defense=0, power=3, death_function=monster_death)
ai_component = BasicMonster()
monster = Object(x, y, 'o', 'orc', libtcod.desaturated_green,
blocks=True, fighter=fighter_component, ai=ai_component)
else:
#create a troll
fighter_component = Fighter(hp=16, defense=1, power=4, 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_ROOM_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):
dice = libtcod.random_get_int(0, 0, 100)
if dice < 70:
#create a healing potion (70% chance)
item_component = Item(use_function=cast_heal)
item = Object(x, y, '!', 'healing potion', libtcod.violet, item=item_component)
elif dice < 70+10:
#create a lightning bolt scroll (10% chance)
item_component = Item(use_function=cast_lightning)
item = Object(x, y, '#', 'scroll of lightning bolt', libtcod.light_yellow, item=item_component)
elif dice < 70+10+10:
#create a fireball scroll (10% chance)
item_component = Item(use_function=cast_fireball)
item = Object(x, y, '#', 'scroll of fireball', libtcod.light_yellow, item=item_component)
else:
#create a confuse scroll (10% chance)
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
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)
#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 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:
player_move_or_attack(0, -1)
elif key.vk == libtcod.KEY_DOWN:
player_move_or_attack(0, 1)
elif key.vk == libtcod.KEY_LEFT:
player_move_or_attack(-1, 0)
elif key.vk == libtcod.KEY_RIGHT:
player_move_or_attack(1, 0)
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()
return 'didnt-take-turn'
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(monster.name.capitalize() + ' is dead!', 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['inventory'] = inventory
file['game_msgs'] = game_msgs
file['game_state'] = game_state
file.close()
def load_game():
#open the previously saved shelve and load the game data
global map, objects, player, inventory, game_msgs, game_state
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
inventory = file['inventory']
game_msgs = file['game_msgs']
game_state = file['game_state']
file.close()
initialize_fov()
def new_game():
global player, inventory, game_msgs, game_state
#create object representing the player
fighter_component = Fighter(hp=30, defense=2, power=5, death_function=player_death)
player = Object(0, 0, '@', 'player', libtcod.white, blocks=True, fighter=fighter_component)
#generate map (at this point it's not drawn to the screen)
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 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()
#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()