Complete Roguelike Tutorial, using python+libtcod
Jump to navigation
Jump to search
Hi there!
|
Title: My First RL!
A general framework / guideline for the tutorial follows. It's already broken out into a few sections, with a small description for each, but it's by no means set in stone.
Some code for the first parts is available at the end.
Graphics
Single torch, fog-of-war (so it feels like you're actually exploring)
Levels
BSP generated dungeons so we can just use what libtcod already has. Town level and shop a bit too much?
The code includes a simple algorithm, it's just a sequence of rooms, each one connected to the next through a tunnel. The overlaps make it look more complex than may be apparent at first though.
Stats
HP/Attack/Defense, for both the player and every monster. (I'm sure this is one of those areas where a beginner would love to tinker and it's pretty easy to add other stats.)
Items
Additive HP/Attack/Defense modifiers when worn. A string determines its class. Can equip one item of every class (weapon, armor, helmet...). Item screen with drop and use options (use equips/dequips stuff). (Should be relatively easy in python at least, where list support is awesome.)
Combat
Damage = Attack - Defense, or something. Would be cool to have a special graphical effect tied to wands and staffs (which would just be weapons with different names).
AI
Cast ray to player, if unblocked move towards, if near it, attack.
Following is the code I (Jotaf) came up with, for the above first two parts. Since the first part shouldn't know anything about map generation, it could be replaced by a fixed map, like in the libtcod demo.
#!/usr/bin/python
#
# libtcod python tutorial
#
import libtcodpy as libtcod
# Import Psyco if available
try:
import psyco
psyco.full()
except ImportError:
pass
#actual size of the window
SCREEN_WIDTH = 80
SCREEN_HEIGHT = 50
#size of the map
MAP_WIDTH = 80
MAP_HEIGHT = 45
#parameters for dungeon generator
ROOM_MAX_SIZE = 10
ROOM_MIN_SIZE = 6
MAX_ROOMS = 30
TORCH_RADIUS = 10
SQUARED_TORCH_RADIUS = TORCH_RADIUS * TORCH_RADIUS
FOV_ALGO = 0 #default FOV algorithm
FOV_LIGHT_WALLS = True #light walls or not
LIMIT_FPS = 20 #20 frames-per-second maximum
fov_dark_wall = libtcod.Color(0, 0, 100)
fov_light_wall = libtcod.Color(130, 110, 50)
fov_dark_ground = libtcod.Color(50, 50, 150)
fov_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, color):
self.x = x
self.y = y
self.char = char
self.color = color
def move(self, dx, dy):
#move by the given amount, if the destination is not blocked
if not map[self.y + dy][self.x + dx].blocked:
self.x += dx
self.y += dy
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_foreground_color(console, self.color)
libtcod.console_put_char(console, self.x, self.y, self.char, libtcod.BKGND_NONE)
def clear(self):
#erase the character that represents this object
libtcod.console_put_char(console, self.x, self.y, ' ', libtcod.BKGND_NONE)
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[y][x].blocked = False
map[y][x].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[y][x].blocked = False
map[y][x].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[y][x].blocked = False
map[y][x].block_sight = False
def make_map():
global map, player, stairs
#fill map with "blocked" tiles
map = [[ Tile(True)
for x in range(MAP_WIDTH) ]
for y in range(MAP_HEIGHT) ]
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
continue
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)
#finally, append the new room to the list
rooms.append(new_room)
num_rooms += 1
#after that, place the stairs at the last room
stairs.x = new_x
stairs.y = new_y
def render_all(key):
global fov_map, fov_dark_wall, fov_light_wall
global fov_dark_ground, fov_light_ground
global fov_recompute
#draw all objects in the list
for object in objects:
object.draw()
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[y][x].block_sight
if not visible:
#if it's not visible right now, the player can only see it if it's explored
if map[y][x].explored:
if wall:
libtcod.console_set_back(console, x, y, fov_dark_wall, libtcod.BKGND_SET)
else:
libtcod.console_set_back(console, x, y, fov_dark_ground, libtcod.BKGND_SET)
else:
#it's visible
if wall:
libtcod.console_set_back(console, x, y, fov_light_wall, libtcod.BKGND_SET )
else:
libtcod.console_set_back(console, x, y, fov_light_ground, libtcod.BKGND_SET )
#since it's visible, explore it
map[y][x].explored = True
def handle_key(key):
global fov_recompute
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 True #exit game
#movement keys
elif libtcod.console_is_key_pressed(libtcod.KEY_UP):
player.move(0, -1)
fov_recompute = True
elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
player.move(0, 1)
fov_recompute = True
elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
player.move(-1, 0)
fov_recompute = True
elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
player.move(1, 0)
fov_recompute = True
#############################################
# Initialization & Main Loop
#############################################
libtcod.console_set_custom_font('celtic_garamond_10x10_gs_tc.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
console = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
libtcod.sys_set_fps(LIMIT_FPS)
#create object representing the player (location doesn't matter, make_map will set it appropriately)
player = Object(0, 0, '@', libtcod.black)
#create object representing the stairs
stairs = Object(0, 0, '<', libtcod.white)
#the list of objects with those two
objects = [player, stairs]
#generate map (at this point it's not drawn to the screen)
make_map()
#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[y][x].blocked, not map[y][x].block_sight)
#start with a blank console
libtcod.console_clear(console)
fov_recompute = True
credits_end = False
while not libtcod.console_is_window_closed():
#erase all objects at their old locations, before they move
for object in objects:
object.clear()
#handle keys and exit game if needed
key = libtcod.console_check_for_keypress()
exit = handle_key(key)
if exit:
break
#render the screen
render_all(key)
libtcod.console_blit(console,
0, 0, MAP_WIDTH, MAP_HEIGHT,
0, 0, 0, 255)
# render credits at the bottom
if not credits_end:
credits_end = libtcod.console_credits_render(0, MAP_HEIGHT, 0)
# render stats
libtcod.console_set_foreground_color(None, libtcod.grey)
libtcod.console_print_right(None, 79, 46, libtcod.BKGND_NONE,
'last frame : %3d ms (%3d fps)' %
(int(libtcod.sys_get_last_frame_length() *
1000.0), libtcod.sys_get_fps()))
libtcod.console_print_right(None, 79, 47, libtcod.BKGND_NONE,
'elapsed : %8d ms %4.2fs' %
(libtcod.sys_elapsed_milli(),
libtcod.sys_elapsed_seconds()))
#victory screen!
if player.x == stairs.x and player.y == stairs.y:
libtcod.console_clear(0)
libtcod.console_set_foreground_color(None, libtcod.white)
libtcod.console_print_center(None, SCREEN_WIDTH/2, SCREEN_HEIGHT/2, libtcod.BKGND_NONE,
'Victory is Yours!!')
libtcod.console_flush()