Difference between revisions of "Complete Roguelike Tutorial, using python+libtcod"

From RogueBasin
Jump to navigation Jump to search
Line 3: Line 3:




This is a '''work-in-progress collab effort''' by a small group of developers to create a [[Python]]/[[libtcod]] tutorial.
This is a '''work-in-progress collab effort''' by a small group of developers to create a [[Python]]+[[libtcod]] tutorial.
 
 
As you probably guessed, there isn't much to look at right now, for the casual reader, but there will when the whole thing is completed!
</center></td></tr></table></center>
</center></td></tr></table></center>


Line 15: Line 12:
__TOC__
__TOC__


<center><h1>'''Title: My First RL!'''</h1></center>
<center><h1>'''Complete Roguelike Tutorial, using [[Python]]+[[libtcod]]'''</h1></center>


== '''Short introduction''' ==


''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.''
=== Welcome! ===


''Some code for the first parts is available at the end.''
Welcome to this tutorial! As you probably guessed, the goal is to have a one-stop-shop for all the info you need on how to build a good Roguelike from scratch. We hope you find it useful! But first, some quick Q&A.




== '''Graphics''' ==
=== Why Python? ===


Single torch, fog-of-war (so it feels like you're actually exploring)
Anyone familiar with this language will tell you it's fun! This tutorial would probably be much harder without it. We recommend that you install Python 2.6 and go through at least the first parts of the [Python Tutorial|http://docs.python.org/tutorial/]. This tutorial will be much easier if you experimented with the language first. Remember that the [Python Library Reference|http://docs.python.org/library/index.html] is your friend -- the standard library has everything you might need and when programming you should be ready to search it for help on any unknown function you might encounter.




== '''Levels''' ==
=== Why libtcod? ===


<strike>BSP generated dungeons so we can just use what libtcod already has. Town level and shop a bit too much?</strike>
If you haven't seen it in action yet, check out the [features|http://doryen.eptalys.net/libtcod/features/] and [some projects|http://doryen.eptalys.net/libtcod/projects/] where it was used successfully. It's extremely easy to use and has tons of useful functions specific to RLs.


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''' ==
== '''Graphics''' ==


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.)
== Setting it up ==


Ok, now that we got that out of our way let's get our hands dirty! If you haven't yet, [download and install Python 2.6|http://www.python.org/download/]. Other versions may work but then you'd have to smite any incompatibilities (though they shouldn't be too many). Then [download libtcod|http://doryen.eptalys.net/libtcod/download/] and extract it somewhere. If you're on Windows, the choice between the Visual Studio and Mingw version shouldn't matter since we're using Python.


== '''Items''' ==
Now to create your project's folder. Create an empty file with a name of your choice, like ''firstrl.py''. The easiest way to use libtcod is to copy the following files to your project's folder:
* ''libtcodpy.py''
* ''libtcod-mingw.dll'' or ''libtcod-VS.dll'' on Windows, ''libtcod.so'' on Linux
* ''SDL.dll'' on Windows, ''SDLlib.so'' on Linux
* A font from the ''fonts'' folder. We chose ''celtic_garamond_10x10_gs_tc.png''.


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


== '''Levels''' ==


== '''Combat''' ==
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.
 
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.




----
----


<center><h1>'''Missing sections'''</h1></center>


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. It's ready to run, give it a try! Put libtcod in the same folder if it's not added to your python installation, and place the font 'celtic_garamond_10x10_gs_tc.png' there. (Or change the code to use another one.)
Here are some quick guidelines for the next sections. Remember the goal is to create a RL that feels complete, but with minimal fluff so anyone can do it. The sections are not set in stone, they're open to debate and will surely go through many changes.


<pre>
== '''Stats''' ==
#!/usr/bin/python
#
# libtcod python tutorial
#


import libtcodpy as libtcod
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.)


# Import Psyco if available
try:
    import psyco
    psyco.full()
except ImportError:
    pass


#actual size of the window
== '''Items''' ==
SCREEN_WIDTH = 80
SCREEN_HEIGHT = 50


#size of the map
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.)
MAP_WIDTH = 80
MAP_HEIGHT = 45


#parameters for dungeon generator
ROOM_MAX_SIZE = 10
ROOM_MIN_SIZE = 6
MAX_ROOMS = 30


TORCH_RADIUS = 10
== '''Combat''' ==
SQUARED_TORCH_RADIUS = TORCH_RADIUS * TORCH_RADIUS


FOV_ALGO = 0  #default FOV algorithm
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).
FOV_LIGHT_WALLS = True  #light walls or not


LIMIT_FPS = 20  #20 frames-per-second maximum


== '''AI''' ==


fov_dark_wall = libtcod.Color(0, 0, 100)
Cast ray to player, if unblocked move towards, if near it, attack.
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()
</pre>

Revision as of 20:05, 6 December 2009

Hi there!


This is a work-in-progress collab effort by a small group of developers to create a Python+libtcod tutorial.



Complete Roguelike Tutorial, using Python+libtcod

Short introduction

Welcome!

Welcome to this tutorial! As you probably guessed, the goal is to have a one-stop-shop for all the info you need on how to build a good Roguelike from scratch. We hope you find it useful! But first, some quick Q&A.


Why Python?

Anyone familiar with this language will tell you it's fun! This tutorial would probably be much harder without it. We recommend that you install Python 2.6 and go through at least the first parts of the [Python Tutorial|http://docs.python.org/tutorial/]. This tutorial will be much easier if you experimented with the language first. Remember that the [Python Library Reference|http://docs.python.org/library/index.html] is your friend -- the standard library has everything you might need and when programming you should be ready to search it for help on any unknown function you might encounter.


Why libtcod?

If you haven't seen it in action yet, check out the [features|http://doryen.eptalys.net/libtcod/features/] and [some projects|http://doryen.eptalys.net/libtcod/projects/] where it was used successfully. It's extremely easy to use and has tons of useful functions specific to RLs.


Graphics

Setting it up

Ok, now that we got that out of our way let's get our hands dirty! If you haven't yet, [download and install Python 2.6|http://www.python.org/download/]. Other versions may work but then you'd have to smite any incompatibilities (though they shouldn't be too many). Then [download libtcod|http://doryen.eptalys.net/libtcod/download/] and extract it somewhere. If you're on Windows, the choice between the Visual Studio and Mingw version shouldn't matter since we're using Python.

Now to create your project's folder. Create an empty file with a name of your choice, like firstrl.py. The easiest way to use libtcod is to copy the following files to your project's folder:

  • libtcodpy.py
  • libtcod-mingw.dll or libtcod-VS.dll on Windows, libtcod.so on Linux
  • SDL.dll on Windows, SDLlib.so on Linux
  • A font from the fonts folder. We chose celtic_garamond_10x10_gs_tc.png.


Levels

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.


Missing sections

Here are some quick guidelines for the next sections. Remember the goal is to create a RL that feels complete, but with minimal fluff so anyone can do it. The sections are not set in stone, they're open to debate and will surely go through many changes.

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.

Retrieved from "http://roguebasin.com/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod&oldid=19728"