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

From RogueBasin
(Difference between revisions)
Jump to: navigation, search
 
(7 intermediate revisions by 4 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_2_code&oldid=30246 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_2_code&oldid=29860 here].
 
</center></td></tr></table></center>
 
</center></td></tr></table></center>
  
== The Map ==
+
 
<pre>
+
== Generalizing ==
 +
 
 +
<div style="background-color: #EEEEEE; border-style: dotted"><syntaxhighlight lang="python">
 
import libtcodpy as libtcod
 
import libtcodpy as libtcod
  
Line 10: Line 17:
 
SCREEN_WIDTH = 80
 
SCREEN_WIDTH = 80
 
SCREEN_HEIGHT = 50
 
SCREEN_HEIGHT = 50
 
#size of the map
 
MAP_WIDTH = 80
 
MAP_HEIGHT = 45
 
  
 
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_ground = libtcod.Color(50, 50, 150)
 
 
 
class Tile:
 
    #a tile of the map and its properties
 
    def __init__(self, blocked, block_sight = None):
 
        self.blocked = blocked
 
       
 
        #by default, if a tile is blocked, it also blocks sight
 
        if block_sight is None: block_sight = blocked
 
        self.block_sight = block_sight
 
  
 
class Object:
 
class Object:
Line 41: Line 31:
 
      
 
      
 
     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 not map[self.x + dx][self.y + dy].blocked:
+
         self.x += dx
            self.x += dx
+
        self.y += dy
            self.y += dy
+
 
      
 
      
 
     def draw(self):
 
     def draw(self):
 
         #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(0, self.color)
+
         libtcod.console_set_default_foreground(con, self.color)
         libtcod.console_put_char(0, 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(0, self.x, self.y, ' ', libtcod.BKGND_NONE)
+
         libtcod.console_put_char(con, self.x, self.y, ' ', libtcod.BKGND_NONE)
  
  
 
def make_map():
 
    global map
 
   
 
    #fill map with "unblocked" tiles
 
    map = [[ Tile(False)
 
        for y in range(MAP_HEIGHT) ]
 
            for x in range(MAP_WIDTH) ]
 
   
 
    #place two pillars to test the map
 
    map[30][22].blocked = True
 
    map[30][22].block_sight = True
 
    map[50][22].blocked = True
 
    map[50][22].block_sight = True
 
 
 
def render_all():
 
    global color_light_wall
 
    global color_light_ground
 
 
    #draw all objects in the list
 
    for object in objects:
 
        object.draw()
 
   
 
    #go through all tiles, and set their background color
 
    for y in range(MAP_HEIGHT):
 
        for x in range(MAP_WIDTH):
 
            wall = map[x][y].block_sight
 
            if wall:
 
                libtcod.console_set_back(0, x, y, color_dark_wall, libtcod.BKGND_SET )
 
            else:
 
                libtcod.console_set_back(0, x, y, color_dark_ground, libtcod.BKGND_SET )
 
   
 
 
def handle_keys():
 
def handle_keys():
     key = libtcod.console_check_for_keypress()  #real-time
+
     #key = libtcod.console_check_for_keypress()  #real-time
     #key = libtcod.console_wait_for_keypress(True)  #turn-based
+
     key = libtcod.console_wait_for_keypress(True)  #turn-based
 
      
 
      
 
     if key.vk == libtcod.KEY_ENTER and key.lalt:
 
     if key.vk == libtcod.KEY_ENTER and key.lalt:
Line 121: Line 77:
 
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
 
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
 
libtcod.sys_set_fps(LIMIT_FPS)
 
libtcod.sys_set_fps(LIMIT_FPS)
 +
con = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
  
 
#create object representing the player
 
#create object representing the player
Line 131: Line 88:
 
objects = [npc, player]
 
objects = [npc, player]
  
#generate map (at this point it's not drawn to the screen)
 
make_map()
 
 
 
#first_time = True  #for turn-based games
 
  
 
while not libtcod.console_is_window_closed():
 
while not libtcod.console_is_window_closed():
 +
   
 +
    #draw all objects in the list
 +
    for object in objects:
 +
        object.draw()
 +
   
 +
    #blit the contents of "con" to the root console and present it
 +
    libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
 +
    libtcod.console_flush()
  
 
     #erase all objects at their old locations, before they move
 
     #erase all objects at their old locations, before they move
Line 144: Line 104:
 
      
 
      
 
     #handle keys and exit game if needed
 
     #handle keys and exit game if needed
    #if not first_time:  #for turn-based games
 
 
     exit = handle_keys()
 
     exit = handle_keys()
 
     if exit:
 
     if exit:
 
         break
 
         break
    #first_time = False  #for turn-based games
+
</syntaxhighlight></div>
   
+
    #render the screen
+
    render_all()
+
   
+
    libtcod.console_flush()
+
</pre>
+
  
  
== Field of View (FOV) ==
+
== The Map ==
<pre>
+
 
 +
<div style="background-color: #EEEEEE; border-style: dotted"><syntaxhighlight lang="python">
 
import libtcodpy as libtcod
 
import libtcodpy as libtcod
  
Line 168: Line 122:
 
MAP_WIDTH = 80
 
MAP_WIDTH = 80
 
MAP_HEIGHT = 45
 
MAP_HEIGHT = 45
 
 
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
 
LIMIT_FPS = 20  #20 frames-per-second maximum
Line 178: Line 127:
  
 
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_dark_ground = libtcod.Color(50, 50, 150)
 
color_dark_ground = libtcod.Color(50, 50, 150)
color_light_ground = libtcod.Color(200, 180, 50)
 
  
  
Line 208: Line 155:
 
      
 
      
 
     def draw(self):
 
     def draw(self):
         #only show if it's visible to the player
+
         #set the color and then draw the character that represents this object at its position
        if libtcod.map_is_in_fov(fov_map, self.x, self.y):
+
        libtcod.console_set_default_foreground(con, self.color)
            #set the color and then draw the character that represents this object at its position
+
        libtcod.console_put_char(con, self.x, self.y, self.char, libtcod.BKGND_NONE)
            libtcod.console_set_foreground_color(0, self.color)
+
            libtcod.console_put_char(0, 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(0, self.x, self.y, ' ', libtcod.BKGND_NONE)
+
         libtcod.console_put_char(con, self.x, self.y, ' ', libtcod.BKGND_NONE)
  
  
Line 236: Line 181:
  
 
def render_all():
 
def render_all():
     global fov_map, color_dark_wall, color_light_wall
+
     global color_light_wall
     global color_dark_ground, color_light_ground
+
     global color_light_ground
    global fov_recompute
+
 
+
    #draw all objects in the list
+
    for object in objects:
+
        object.draw()
+
 
      
 
      
     if fov_recompute:
+
     #go through all tiles, and set their background color
        #recompute FOV if needed (the player moved or something)
+
    for y in range(MAP_HEIGHT):
        fov_recompute = False
+
        for x in range(MAP_WIDTH):
        libtcod.map_compute_fov(fov_map, player.x, player.y, TORCH_RADIUS, FOV_LIGHT_WALLS, FOV_ALGO)
+
            wall = map[x][y].block_sight
 
+
            if wall:
        #go through all tiles, and set their background color according to the FOV
+
                libtcod.console_set_char_background(con, x, y, color_dark_wall, libtcod.BKGND_SET )
        for y in range(MAP_HEIGHT):
+
            else:
            for x in range(MAP_WIDTH):
+
                libtcod.console_set_char_background(con, x, y, color_dark_ground, libtcod.BKGND_SET )
                visible = libtcod.map_is_in_fov(fov_map, x, y)
+
                wall = map[x][y].block_sight
+
                if not visible:
+
                    #it's out of the player's FOV
+
                    if wall:
+
                        libtcod.console_set_back(0, x, y, color_dark_wall, libtcod.BKGND_SET)
+
                    else:
+
                        libtcod.console_set_back(0, x, y, color_dark_ground, libtcod.BKGND_SET)
+
                else:
+
                    #it's visible
+
                    if wall:
+
                        libtcod.console_set_back(0, x, y, color_light_wall, libtcod.BKGND_SET )
+
                    else:
+
                        libtcod.console_set_back(0, x, y, color_light_ground, libtcod.BKGND_SET )
+
   
+
def handle_keys():
+
    global fov_recompute
+
   
+
    key = libtcod.console_check_for_keypress()  #real-time
+
    #key = libtcod.console_wait_for_keypress(True)  #turn-based
+
   
+
    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('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)
+
 
+
#create object representing the player
+
player = Object(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, '@', libtcod.white)
+
 
+
#create an NPC
+
npc = Object(SCREEN_WIDTH/2 - 5, SCREEN_HEIGHT/2, '@', libtcod.yellow)
+
 
+
#the list of objects with those two
+
objects = [npc, player]
+
 
+
#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[x][y].blocked, not map[x][y].block_sight)
+
 
+
 
+
fov_recompute = True
+
#first_time = True  #for turn-based games
+
 
+
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
+
    #if not first_time:  #for turn-based games
+
    exit = handle_keys()
+
    if exit:
+
        break
+
    #first_time = False  #for turn-based games
+
   
+
    #render the screen
+
    render_all()
+
   
+
    libtcod.console_flush()
+
</pre>
+
 
+
 
+
== Dungeon building blocks ==
+
<pre>
+
 
+
import libtcodpy as libtcod
+
 
+
#actual size of the window
+
SCREEN_WIDTH = 80
+
SCREEN_HEIGHT = 50
+
 
+
#size of the map
+
MAP_WIDTH = 80
+
MAP_HEIGHT = 45
+
 
+
 
+
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
+
       
+
        #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
+
 
+
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.x + dx][self.y + dy].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(0, self.color)
+
            libtcod.console_put_char(0, self.x, self.y, self.char, libtcod.BKGND_NONE)
+
   
+
    def clear(self):
+
        #erase the character that represents this object
+
        libtcod.console_put_char(0, 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[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
+
   
+
    #fill map with "blocked" tiles
+
    map = [[ Tile(True)
+
        for y in range(MAP_HEIGHT) ]
+
            for x in range(MAP_WIDTH) ]
+
   
+
    #create two rooms
+
    room1 = Rect(20, 15, 10, 15)
+
    room2 = Rect(50, 15, 10, 15)
+
    create_room(room1)
+
    create_room(room2)
+
   
+
    #connect them with a tunnel
+
    create_h_tunnel(25, 55, 23)
+
   
+
    #place the player inside the first room
+
    player.x = 25
+
    player.y = 23
+
 
+
 
+
def render_all():
+
    global fov_map, color_dark_wall, color_light_wall
+
    global color_dark_ground, color_light_ground
+
    global fov_recompute
+
  
 
     #draw all objects in the list
 
     #draw all objects in the list
Line 473: Line 197:
 
         object.draw()
 
         object.draw()
 
      
 
      
     if fov_recompute:
+
     #blit the contents of "con" to the root console
        #recompute FOV if needed (the player moved or something)
+
    libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
        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:
+
                    #it's out of the player's FOV
+
                    if wall:
+
                        libtcod.console_set_back(0, x, y, color_dark_wall, libtcod.BKGND_SET)
+
                    else:
+
                        libtcod.console_set_back(0, x, y, color_dark_ground, libtcod.BKGND_SET)
+
                else:
+
                    #it's visible
+
                    if wall:
+
                        libtcod.console_set_back(0, x, y, color_light_wall, libtcod.BKGND_SET )
+
                    else:
+
                        libtcod.console_set_back(0, x, y, color_light_ground, libtcod.BKGND_SET )
+
 
      
 
      
 
def handle_keys():
 
def handle_keys():
     global fov_recompute
+
     #key = libtcod.console_check_for_keypress()  #real-time
   
+
     key = libtcod.console_wait_for_keypress(True)  #turn-based
    key = libtcod.console_check_for_keypress()  #real-time
+
     #key = libtcod.console_wait_for_keypress(True)  #turn-based
+
 
      
 
      
 
     if key.vk == libtcod.KEY_ENTER and key.lalt:
 
     if key.vk == libtcod.KEY_ENTER and key.lalt:
Line 510: Line 212:
 
      
 
      
 
     #movement keys
 
     #movement keys
     elif libtcod.console_is_key_pressed(libtcod.KEY_UP):
+
     if libtcod.console_is_key_pressed(libtcod.KEY_UP):
 
         player.move(0, -1)
 
         player.move(0, -1)
        fov_recompute = True
 
 
          
 
          
 
     elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
 
     elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
 
         player.move(0, 1)
 
         player.move(0, 1)
        fov_recompute = True
 
 
          
 
          
 
     elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
 
     elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
 
         player.move(-1, 0)
 
         player.move(-1, 0)
        fov_recompute = True
 
 
          
 
          
 
     elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
 
     elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
 
         player.move(1, 0)
 
         player.move(1, 0)
        fov_recompute = True
 
  
  
Line 534: Line 232:
 
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
 
libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
 
libtcod.sys_set_fps(LIMIT_FPS)
 
libtcod.sys_set_fps(LIMIT_FPS)
 +
con = libtcod.console_new(SCREEN_WIDTH, SCREEN_HEIGHT)
  
 
#create object representing the player
 
#create object representing the player
Line 547: Line 246:
 
make_map()
 
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[x][y].blocked, not map[x][y].block_sight)
 
 
 
fov_recompute = True
 
#first_time = True  #for turn-based games
 
  
 
while not libtcod.console_is_window_closed():
 
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
 
    #if not first_time:  #for turn-based games
 
    exit = handle_keys()
 
    if exit:
 
        break
 
    #first_time = False  #for turn-based games
 
 
      
 
      
 
     #render the screen
 
     #render the screen
Line 574: Line 253:
 
      
 
      
 
     libtcod.console_flush()
 
     libtcod.console_flush()
</pre>
 
 
 
== Dungeon generator ==
 
<pre>
 
 
import libtcodpy as libtcod
 
 
#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
 
 
 
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
 
       
 
        #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.x + dx][self.y + dy].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(0, self.color)
 
            libtcod.console_put_char(0, self.x, self.y, self.char, libtcod.BKGND_NONE)
 
   
 
    def clear(self):
 
        #erase the character that represents this object
 
        libtcod.console_put_char(0, 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[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, 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)
 
           
 
            #finally, append the new room to the list
 
            rooms.append(new_room)
 
            num_rooms += 1
 
 
 
def render_all():
 
    global fov_map, color_dark_wall, color_light_wall
 
    global color_dark_ground, color_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[x][y].block_sight
 
                if not visible:
 
                    #it's out of the player's FOV
 
                    if wall:
 
                        libtcod.console_set_back(0, x, y, color_dark_wall, libtcod.BKGND_SET)
 
                    else:
 
                        libtcod.console_set_back(0, x, y, color_dark_ground, libtcod.BKGND_SET)
 
                else:
 
                    #it's visible
 
                    if wall:
 
                        libtcod.console_set_back(0, x, y, color_light_wall, libtcod.BKGND_SET )
 
                    else:
 
                        libtcod.console_set_back(0, x, y, color_light_ground, libtcod.BKGND_SET )
 
   
 
def handle_keys():
 
    global fov_recompute
 
   
 
    key = libtcod.console_check_for_keypress()  #real-time
 
    #key = libtcod.console_wait_for_keypress(True)  #turn-based
 
   
 
    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('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)
 
 
#create object representing the player
 
player = Object(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, '@', libtcod.white)
 
 
#create an NPC
 
npc = Object(SCREEN_WIDTH/2 - 5, SCREEN_HEIGHT/2, '@', libtcod.yellow)
 
 
#the list of objects with those two
 
objects = [npc, player]
 
 
#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[x][y].blocked, not map[x][y].block_sight)
 
 
 
fov_recompute = True
 
#first_time = True  #for turn-based games
 
 
while not libtcod.console_is_window_closed():
 
  
 
     #erase all objects at their old locations, before they move
 
     #erase all objects at their old locations, before they move
Line 850: Line 259:
 
      
 
      
 
     #handle keys and exit game if needed
 
     #handle keys and exit game if needed
    #if not first_time:  #for turn-based games
 
 
     exit = handle_keys()
 
     exit = handle_keys()
 
     if exit:
 
     if exit:
 
         break
 
         break
    #first_time = False  #for turn-based games
+
</syntaxhighlight></div>
   
+
    #render the screen
+
    render_all()
+
   
+
    libtcod.console_flush()
+
</pre>
+
  
 
+
[[Category:Developing]]
== Exploration ==
+
<pre>
+
 
+
import libtcodpy as libtcod
+
 
+
#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
+
 
+
 
+
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, 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.x + dx][self.y + dy].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(0, self.color)
+
            libtcod.console_put_char(0, self.x, self.y, self.char, libtcod.BKGND_NONE)
+
   
+
    def clear(self):
+
        #erase the character that represents this object
+
        libtcod.console_put_char(0, 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[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, 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)
+
           
+
            #finally, append the new room to the list
+
            rooms.append(new_room)
+
            num_rooms += 1
+
 
+
 
+
def render_all():
+
    global fov_map, color_dark_wall, color_light_wall
+
    global color_dark_ground, color_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[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_back(0, x, y, color_dark_wall, libtcod.BKGND_SET)
+
                        else:
+
                            libtcod.console_set_back(0, x, y, color_dark_ground, libtcod.BKGND_SET)
+
                else:
+
                    #it's visible
+
                    if wall:
+
                        libtcod.console_set_back(0, x, y, color_light_wall, libtcod.BKGND_SET )
+
                    else:
+
                        libtcod.console_set_back(0, x, y, color_light_ground, libtcod.BKGND_SET )
+
                    #since it's visible, explore it
+
                    map[x][y].explored = True
+
   
+
def handle_keys():
+
    global fov_recompute
+
   
+
    key = libtcod.console_check_for_keypress()  #real-time
+
    #key = libtcod.console_wait_for_keypress(True)  #turn-based
+
   
+
    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('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)
+
 
+
#create object representing the player
+
player = Object(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, '@', libtcod.white)
+
 
+
#create an NPC
+
npc = Object(SCREEN_WIDTH/2 - 5, SCREEN_HEIGHT/2, '@', libtcod.yellow)
+
 
+
#the list of objects with those two
+
objects = [npc, player]
+
 
+
#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[x][y].blocked, not map[x][y].block_sight)
+
 
+
 
+
fov_recompute = True
+
#first_time = True  #for turn-based games
+
 
+
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
+
    #if not first_time:  #for turn-based games
+
    exit = handle_keys()
+
    if exit:
+
        break
+
    #first_time = False  #for turn-based games
+
   
+
    #render the screen
+
    render_all()
+
   
+
    libtcod.console_flush()
+
</pre>
+

Latest revision as of 04:49, 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] Generalizing

import libtcodpy as libtcod
 
#actual size of the window
SCREEN_WIDTH = 80
SCREEN_HEIGHT = 50
 
LIMIT_FPS = 20  #20 frames-per-second maximum
 
 
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
        self.x += dx
        self.y += dy
 
    def draw(self):
        #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)
 
 
def handle_keys():
    #key = libtcod.console_check_for_keypress()  #real-time
    key = libtcod.console_wait_for_keypress(True)  #turn-based
 
    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
    if libtcod.console_is_key_pressed(libtcod.KEY_UP):
        player.move(0, -1)
 
    elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
        player.move(0, 1)
 
    elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
        player.move(-1, 0)
 
    elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
        player.move(1, 0)
 
 
#############################################
# Initialization & Main Loop
#############################################
 
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(SCREEN_WIDTH, SCREEN_HEIGHT)
 
#create object representing the player
player = Object(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, '@', libtcod.white)
 
#create an NPC
npc = Object(SCREEN_WIDTH/2 - 5, SCREEN_HEIGHT/2, '@', libtcod.yellow)
 
#the list of objects with those two
objects = [npc, player]
 
 
while not libtcod.console_is_window_closed():
 
    #draw all objects in the list
    for object in objects:
        object.draw()
 
    #blit the contents of "con" to the root console and present it
    libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
    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
    exit = handle_keys()
    if exit:
        break


[edit] The Map

import libtcodpy as libtcod
 
#actual size of the window
SCREEN_WIDTH = 80
SCREEN_HEIGHT = 50
 
#size of the map
MAP_WIDTH = 80
MAP_HEIGHT = 45
 
LIMIT_FPS = 20  #20 frames-per-second maximum
 
 
color_dark_wall = libtcod.Color(0, 0, 100)
color_dark_ground = libtcod.Color(50, 50, 150)
 
 
class Tile:
    #a tile of the map and its properties
    def __init__(self, blocked, block_sight = None):
        self.blocked = blocked
 
        #by default, if a tile is blocked, it also blocks sight
        if block_sight is None: block_sight = blocked
        self.block_sight = block_sight
 
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.x + dx][self.y + dy].blocked:
            self.x += dx
            self.y += dy
 
    def draw(self):
        #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)
 
 
 
def make_map():
    global map
 
    #fill map with "unblocked" tiles
    map = [[ Tile(False)
        for y in range(MAP_HEIGHT) ]
            for x in range(MAP_WIDTH) ]
 
    #place two pillars to test the map
    map[30][22].blocked = True
    map[30][22].block_sight = True
    map[50][22].blocked = True
    map[50][22].block_sight = True
 
 
def render_all():
    global color_light_wall
    global color_light_ground
 
    #go through all tiles, and set their background color
    for y in range(MAP_HEIGHT):
        for x in range(MAP_WIDTH):
            wall = map[x][y].block_sight
            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 )
 
    #draw all objects in the list
    for object in objects:
        object.draw()
 
    #blit the contents of "con" to the root console
    libtcod.console_blit(con, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0)
 
def handle_keys():
    #key = libtcod.console_check_for_keypress()  #real-time
    key = libtcod.console_wait_for_keypress(True)  #turn-based
 
    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
    if libtcod.console_is_key_pressed(libtcod.KEY_UP):
        player.move(0, -1)
 
    elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
        player.move(0, 1)
 
    elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
        player.move(-1, 0)
 
    elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
        player.move(1, 0)
 
 
#############################################
# Initialization & Main Loop
#############################################
 
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(SCREEN_WIDTH, SCREEN_HEIGHT)
 
#create object representing the player
player = Object(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, '@', libtcod.white)
 
#create an NPC
npc = Object(SCREEN_WIDTH/2 - 5, SCREEN_HEIGHT/2, '@', libtcod.yellow)
 
#the list of objects with those two
objects = [npc, player]
 
#generate map (at this point it's not drawn to the screen)
make_map()
 
 
while not libtcod.console_is_window_closed():
 
    #render the screen
    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
    exit = handle_keys()
    if exit:
        break
Personal tools