|
|
(95 intermediate revisions by 16 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" width="60%"><tr><td><center> |
| Hi there!
| | <b>This tutorial is for libtcod 1.6.0 and above.</b> |
|
| |
|
| | If you would prefer to do the tutorial for an older version of libtcod, you can get there through one of the links below. Be aware that the only way to get bug fixes, is by upgrading to the latest version. There are no bug fix releases of older versions. |
|
| |
|
| This is a '''work-in-progress collab effort''' by a small group of developers to create a [[Python]]+[[libtcod]] tutorial.
| | For libtcod version 1.5.1, [http://www.roguebasin.com/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod&oldid=42760 here] is the older version of this tutorial.<br/> |
| | | For libtcod version 1.5.0, [http://roguebasin.roguelikedevelopment.org/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod,_part_1&oldid=29855 here] is the older version of this tutorial. |
| It's by no means finished, but the first parts are available now.
| |
| </center></td></tr></table></center> | | </center></td></tr></table></center> |
|
| |
|
| |
| <center><h1>'''Complete Roguelike Tutorial, using [[Python]]+[[libtcod]]'''</h1></center>
| |
|
| |
|
|
| |
|
Line 19: |
Line 16: |
|
| |
|
| 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. | | 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? === | | === 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 [http://docs.python.org/tutorial/ Python Tutorial]. This tutorial will be much easier if you experimented with the language first. Remember that the [http://docs.python.org/library/index.html Python Library Reference] 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.
| | Most people familiar with this language will tell you it's fun! Python aims to be simple but powerful, and very accessible to beginners. This tutorial would probably be much harder without it. We insist that you install/use Python 2.7 and go through at least the first parts of the [http://docs.python.org/tutorial/ Python Tutorial]. This tutorial will be much easier if you've experimented with the language first. Remember that the [http://docs.python.org/library/index.html Python Library Reference] 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. |
|
| |
|
| | <center><table border="0" cellpadding="10" cellspacing="0" style="background:#F0E68C" width="60%"><tr><td><center> |
| | This tutorial is for <b>Python 2 only</b>, and it is strongly recommended you use the latest Python 2.7 release. |
| | |
| | If you choose to use earlier versions of Python 2, you may encounter problems you need to overcome.<br/> |
| | If you choose to use Python 3, be aware this tutorial is not compatible with it and you are on your own. (See "other languages" below.) |
| | </center></td></tr></table></center> |
|
| |
|
| === Why libtcod? === | | === Why libtcod? === |
|
| |
|
| If you haven't seen it in action yet, check out the [http://doryen.eptalys.net/libtcod/features/ features] and [http://doryen.eptalys.net/libtcod/projects/ some projects] where it was used successfully. It's extremely easy to use and has tons of useful functions specific to RLs. | | If you haven't seen it in action yet, check out the [https://bitbucket.org/libtcod/libtcod/wiki/Features features] and [http://roguecentral.org/doryen/projects-2/ some 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, [http://www.python.org/download/ download and install Python 2.6]. Other versions may work but then you'd have to smite any incompatibilities (though they shouldn't be too many). Then [http://doryen.eptalys.net/libtcod/download/ download libtcod] and extract it somewhere. If you're on Windows, choose the Mingw version as at the time of this writing the Visual Studio version of libtcod didn't ship with the Python bindings.
| |
| | |
| 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'' on Windows, ''libtcod.so'' on Linux
| |
| * ''SDL.dll'' on Windows, ''SDLlib.so'' on Linux
| |
| * A font from the ''fonts'' folder. We chose ''arial10x10.png''.
| |
| | |
| === Showing the @ on screen ===
| |
| | |
| This first part will be a bit of a crash-course. The reason is that you need a few lines of boilerplate code that will initialize and handle the basics of a libtcod window. And though there are many options, we won't explain them all or this part will really start to drag out. Fortunately the code involved is not as much as in many other libraries!
| |
| | |
| First we import the library. The name ''libtcodpy'' is a bit funky (sorry Jice!) so we'll rename it to just ''libtcod''.
| |
| <pre>import libtcodpy as libtcod</pre>
| |
| | |
| Then, a couple of important values. It's good practice to define special numbers that might get reused. Many people capitalize them to distinguish from variables that may change.
| |
| <pre>SCREEN_WIDTH = 80
| |
| SCREEN_HEIGHT = 50
| |
| LIMIT_FPS = 20</pre>
| |
| | |
| Now, something libtcod-specific: we're going to use a custom font! It's pretty easy. libtcod comes bundled with a few fonts that are usable right out of the box. Remember however that they can be in different '''formats''', and you'll need to tell it about this. This one is "grayscale" and using the "tcod layout", most fonts are in this format and thus end with ''_gs_tc''. If you wanna use a font with a different layout or make your own, the [http://doryen.eptalys.net/data/libtcod/doc/1.4.2/console/console_set_bitmap_font_size.html docs on the subject] are really informative. You can worry about that at a later time though. Notice that the size of a font is automatically detected.
| |
| <pre>libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)</pre>
| |
| | |
| This is probably the most important call, initializing the window. We're specifying its size, the title (change it now if you want to), and the last parameter tells it if it should be fullscreen or not.
| |
| <pre>libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)</pre>
| |
| | |
| For a real-time roguelike, you wanna limit the speed of the game (frames-per-second or FPS). If you want it to be turn-based, ignore this line.
| |
| <pre>libtcod.sys_set_fps(LIMIT_FPS)</pre>
| |
| | |
| Now the main loop. It will keep running the logic of your game as long as the window is not closed.
| |
| <pre>while not libtcod.console_is_window_closed():</pre>
| |
| | |
| For each iteration we'll want to print something useful to the window. If your game is turn-based each iteration is a turn; if it's real-time, each one is a frame. Here we're setting the text color to be white. [http://doryen.eptalys.net/data/libtcod/doc/1.4.2/color/index.html There's a good list of colors you can use here], along with some info about mixing them and all that. The zero is the console we're printing to, in this case the screen; more on that later.
| |
| <pre> libtcod.console_set_foreground_color(0, libtcod.white)</pre>
| |
| | |
| Don't forget the indentation at the beginning of the line, it's extra-important in Python. '''Make sure you don't mix tabs with spaces for indentation!''' This comes up often if you copy-and-paste code from the net, and you'll see an error telling you something about the indentation (that's a pretty big clue right there!). Choose one option and stick with it. In this tutorial we're using the 4-spaces convention, but tabs are easy to work with in many editors so they're a valid choice too.
| |
| | |
| Now print a string, left-aligned, to the coordinates (1,1). Once more the first zero specifies the console, which is the screen in this case. Can you guess what that string is? No, it doesn't move yet!
| |
| <pre> libtcod.console_print_left(0, 1, 1, libtcod.BKGND_NONE, '@')</pre>
| |
| | |
| At the end of the main loop you'll always need to present the changes to the screen. This is called ''flushing'' the console and is done with the following line.
| |
| <pre> libtcod.console_flush()</pre>
| |
| | |
| Ta-da! You're done. Run that code and give yourself a pat on the back!
| |
| | |
| Here's the complete code so far:
| |
| <pre>
| |
| import libtcodpy as libtcod
| |
| | |
| #actual size of the window
| |
| SCREEN_WIDTH = 80
| |
| SCREEN_HEIGHT = 50
| |
| | |
| LIMIT_FPS = 20 #20 frames-per-second maximum
| |
| | |
| | |
| 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)
| |
| | |
| while not libtcod.console_is_window_closed():
| |
|
| |
| libtcod.console_set_foreground_color(0, libtcod.white)
| |
|
| |
| libtcod.console_print_left(0, 0, 0, libtcod.BKGND_NONE, '@')
| |
|
| |
| libtcod.console_flush()
| |
| </pre>
| |
| | |
| | |
| === Moving around ===
| |
| | |
| That was pretty neat, huh? Now we're going to move around that @ with the keys!
| |
| | |
| First, we need to keep track of the player's position. We'll use these variables for that, and take the opportunity to initialize them to the center of the screen instead of the top-left corner. This can go just before the main loop.
| |
| <pre>playerx = SCREEN_WIDTH/2
| |
| playery = SCREEN_HEIGHT/2</pre>
| |
| | |
| There are functions to check for pressed keys. When that happens, just change the coordinates accordingly. Then, print the @ at those coordinates. We'll make a separate function to handle the keys.
| |
| <pre>def handle_keys():
| |
| global playerx, playery
| |
|
| |
| #movement keys
| |
| if libtcod.console_is_key_pressed(libtcod.KEY_UP):
| |
| playery -= 1
| |
|
| |
| elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
| |
| playery += 1
| |
|
| |
| elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
| |
| playerx -= 1
| |
|
| |
| elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
| |
| playerx += 1</pre>
| |
| | |
| Done! These are the arrow keys, if you want to use other keys here's a [http://doryen.eptalys.net/data/libtcod/doc/1.4.2/console/keycode_t.html reference] (pay attention to the Python-specific notes).
| |
| | |
| While we're at it, why not include keys to toggle fullscreen mode, and exit the game? You can put this at the beginning of the function.
| |
| <pre> key = libtcod.console_check_for_keypress()
| |
|
| |
| 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</pre>
| |
| | |
| Notice a subtle difference here. The ''console_is_key_pressed'' function is useful for real-time games, since it checks if a key is pressed with no delays. ''console_check_for_keypress'', on the other hand, treats the key like it's being typed. So after the first press, it will stop working for a fraction of a second. This is the same behavior you see when you type, otherwise pressing a key would result in you typing 3 or 4 letters! It's useful for all commands except movement, which you usually want to react as soon as possible with no delays, and continue for as long as you press the movement keys.
| |
| | |
| Now here's an important thing: you can use that first line to distinguish between real-time and turn-based gameplay! See, ''console_check_for_keypress'' won't block the game. But if you replace it with this line:
| |
| <pre> key = libtcod.console_wait_for_keypress(True)</pre>
| |
| | |
| Then the game won't go on unless the player presses a key. So effectively you have a turn-based game now.
| |
| | |
| Now, the main loop needs to call this function in order for it to work. If the returned value is True, then we "break" from the main loop, ending the game. The inside of the main loop should now look like this:
| |
| | |
| <pre> #handle keys and exit game if needed
| |
| exit = handle_keys()
| |
| if exit:
| |
| break
| |
|
| |
| libtcod.console_set_foreground_color(0, libtcod.white)
| |
| libtcod.console_print_left(0, playerx, playery, libtcod.BKGND_NONE, '@')
| |
|
| |
| libtcod.console_flush()</pre>
| |
| | |
| One more thing! If you try that, you'll see that moving you leave around a trail of little @'s. That's not what we want! We need to clear the character at the last position before moving to the new one, this can be done by simply printing a space there. Put this just before ''exit = handle_keys()''.
| |
| <pre> libtcod.console_print_left(0, playerx, playery, libtcod.BKGND_NONE, ' ')</pre>
| |
| | |
| A note for those that want a turn-based RL: you'll notice that the @ is not displayed until you press the first key. This is because the game blocks before even printing the first frame! You'll need to add ''first_time = True'' before the main loop, and change the part that calls ''handle_keys'' to:
| |
| | |
| <pre> if not first_time:
| |
| exit = handle_keys()
| |
| if exit:
| |
| break
| |
|
| |
| first_time = False</pre>
| |
| | |
| Here's a rundown of the whole code.
| |
| | |
| <pre>
| |
| import libtcodpy as libtcod
| |
| | |
| #actual size of the window
| |
| SCREEN_WIDTH = 80
| |
| SCREEN_HEIGHT = 50
| |
| | |
| LIMIT_FPS = 20 #20 frames-per-second maximum
| |
| | |
| | |
| def handle_keys():
| |
| global playerx, playery
| |
|
| |
| 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):
| |
| playery -= 1
| |
|
| |
| elif libtcod.console_is_key_pressed(libtcod.KEY_DOWN):
| |
| playery += 1
| |
|
| |
| elif libtcod.console_is_key_pressed(libtcod.KEY_LEFT):
| |
| playerx -= 1
| |
|
| |
| elif libtcod.console_is_key_pressed(libtcod.KEY_RIGHT):
| |
| playerx += 1
| |
| | |
| | |
| #############################################
| |
| # 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)
| |
| | |
| playerx = SCREEN_WIDTH/2
| |
| playery = SCREEN_HEIGHT/2
| |
| | |
| #first_time = True #for turn-based games
| |
| | |
| while not libtcod.console_is_window_closed():
| |
|
| |
| libtcod.console_print_left(0, playerx, playery, libtcod.BKGND_NONE, ' ')
| |
|
| |
| #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
| |
|
| |
| libtcod.console_set_foreground_color(0, libtcod.white)
| |
| libtcod.console_print_left(0, playerx, playery, libtcod.BKGND_NONE, '@')
| |
|
| |
| libtcod.console_flush()
| |
| </pre>
| |
| | |
| | |
| === Generalizing ===
| |
| | |
| Now that we have the @ walking around, it would be a good idea to step back and think a bit about the design. Having variables for the player's coordinates is easy, but it can quickly get out of control when you're defining things such as HP, bonuses, and inventory. We're going to take the opportunity to generalize a bit.
| |
| | |
| Now, there ''can'' be such a thing as over-generalization, but we'll try not to fall in that trap. What we're going to do is define the player as a game ''Object'', by creating that class. It will hold all position and display information (character and color). The neat thing is that the player will just be one instance of the ''Object'' class -- it's general enough that you can re-use it to define items on the floor, monsters, doors, stairs; anything representable by a character on the screen. Here's the class, with the initialization, and three common methods ''move'', ''draw'' and ''clear''. The code for drawing and erasing is the same as the one we used for the player earlier.
| |
| | |
| <pre>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_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)</pre>
| |
| | |
| Now, before the main loop, instead of just setting the player's coordinates, we create it as an actual ''Object''. We also add it to a list, that will hold ''all'' objects that are in the game. While we're at it we'll add a yellow @ that represents a non-playing character, like in an RPG, just to test it out!
| |
| <pre>player = Object(SCREEN_WIDTH/2, SCREEN_HEIGHT/2, '@', libtcod.white)
| |
| npc = Object(SCREEN_WIDTH/2 - 5, SCREEN_HEIGHT/2, '@', libtcod.yellow)
| |
| objects = [npc, player]</pre>
| |
| | |
| We'll have to make a couple of changes now. First, in the ''handle_keys'' function, instead of dealing directly with the player's coordinates, we can use the player's ''move'' method with the appropriate displacement. Later this will come in handy as it can automatically check if the player (or another object) is about to hit a wall. Secondly, the main loop will now clear all objects like this:
| |
| <pre> for object in objects:
| |
| object.clear()</pre>
| |
| | |
| And draw them like this:
| |
| <pre> for object in objects:
| |
| object.draw()</pre>
| |
| | |
| Ok, that's all! A fully generic object system. Later, this class can be modified to have all the special info that items, monsters and all that will require. But we can add that as we go along! Here's the code so far.
| |
| | |
| <pre>
| |
| 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_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 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)
| |
| | |
| #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]
| |
| | |
| | |
| #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
| |
|
| |
| #draw all objects in the list
| |
| for object in objects:
| |
| object.draw()
| |
|
| |
| libtcod.console_flush()
| |
| </pre>
| |
| | |
| | |
| == '''The Dungeon''' ==
| |
| | |
| === The Map ===
| |
| | |
| This part will introduce the map, FOV, and finally a neat dungeon generator! No roguelike is complete without those. We'll start with the map, a two-dimensional array of tiles where all your dungeon adventuring will happen. We'll start by defining its size at the top of the file. It's not quite the same size as the screen, to leave some space for a panel to show up later (where you can show stats and all). We'll try to make this as configurable as possible, this should suffice for now!
| |
| <pre>MAP_WIDTH = 80
| |
| MAP_HEIGHT = 45</pre>
| |
| | |
| Next, the tile colors. For now there are two tile types -- wall and ground. These will be their "dark" colors, which you'll see when they're not in FOV; their "lit" counterparts will be of use later.
| |
| <pre>color_dark_wall = libtcod.Color(0, 0, 100)
| |
| color_dark_ground = libtcod.Color(50, 50, 150)</pre>
| |
| | |
| What sort of info will each tile hold? We'll start simple, with two values that say whether a tile is passable or not, and whether it blocks sight. In this case, it's better to seperate them early, so later you can have see-through but unpassable tiles such as chasms, or passable tiles that block sight for secret passages. They'll be defined in a Tile class, that we'll add to as we go. Believe me, this class will quickly grow to have about a dozen different values for each tile!
| |
| <pre>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</pre>
| |
| | |
| As promised, the map is a two-dimensional array of tiles. The easiest way to do that is to have a list of rows, each row itself being a list of tiles; since there are no native multi-dimensional arrays in Python. We'll build it using a neat trick, [http://docs.python.org/tutorial/datastructures.html#list-comprehensions list comprehensions]. See, the usual way to build lists (from C++ land) is to create an empty list, then iterate with a ''for'' and add elements gradually. The syntax [''element'' for ''index'' in ''range''], where ''index'' and ''range'' are the same as what you'd use in a ''for'', will return a list of ''element''s. With two of those, one for rows and another for tiles in each row, we create the map in one fell swoop! The linked page has a ton of examples on that, and also an example of [http://docs.python.org/tutorial/datastructures.html#nested-list-comprehensions nested list comprehensions] like we're using for the map. Well, that's an awful lot of words for such a tiny piece of code!
| |
| <pre>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) ]</pre>
| |
| | |
| Accessing the tiles is as easy as ''map[x][y]''. Here we add two pillars (blocked tiles) to demonstrate that, and provide a simple test.
| |
| <pre> map[30][22].blocked = True
| |
| map[30][22].block_sight = True
| |
| map[50][22].blocked = True
| |
| map[50][22].block_sight = True<pre>
| |
| | |
| Don't worry, we're already close to a playable version! Since we need to draw both the objects and the map, it now makes sense to put them all under a new function instead of directly in the main loop. Take the object rendering code to a new ''render_all'' function, and in its place in the main loop call this new ''render_all()''.
| |
| <pre>def render_all():
| |
| #draw all objects in the list
| |
| for object in objects:
| |
| object.draw()</pre>
| |
| | |
| Now we can go through all the tiles and draw them to the screen, with the background color of a console character representing the corresponding tile.
| |
| <pre> 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 )</pre>
| |
| | |
| Ok! Don't forget to call ''make_map()'' before the main loop, to set it up before the game begins. You should be able to see the two pillars and walk around the map now! Here's the code so far.
| |
| | |
| <pre>
| |
| #!/usr/bin/python
| |
| #
| |
| # libtcod python tutorial
| |
| #
| |
| | |
| 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
| |
| 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_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 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].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():
| |
| 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)
| |
| | |
| #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()
| |
| | |
| | |
| #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>
| |
| | |
| <center><h1>'''Missing sections'''</h1></center>
| |
| | |
| 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. One important thing to note is that we shouldn't worry about making the absolutely coolest RL ever, it's nice to leave some blanks deliberately for the reader to fill in (things that are simple enough but by not extending them to the fullest potential we're reducing the tutorial size and motivating the reader to want to change something).
| |
| | |
| | |
| == '''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.
| |
| | |
| This section could introduce the map, FOV, and finally the dungeon generator.
| |
|
| |
|
| <pre>
| | If you're using Windows, download either the Win32 or x64 build [https://bitbucket.org/libtcod/libtcod/downloads from bitbucket]. Various samples are prebuilt and included, and can be used to both experiment with the various features and see what is possible. |
| import libtcodpy as libtcod
| |
|
| |
|
| # Import Psyco if available
| | For other platforms, you're going to have to compile them yourself. Maybe someone who owns a MacOS machine might compile builds for the libtcod project? |
| try:
| |
| import psyco
| |
| psyco.full()
| |
| except ImportError:
| |
| pass
| |
|
| |
|
| #actual size of the window
| | === Other languages === |
| SCREEN_WIDTH = 80
| |
| SCREEN_HEIGHT = 50
| |
|
| |
|
| #size of the map
| | There are no known versions of this tutorial for other programming languages than Python, for libtcod 1.6.0. However, you can hop back to [http://www.roguebasin.com/index.php?title=Complete_Roguelike_Tutorial,_using_python%2Blibtcod&oldid=43255 the tutorial for 1.5.1] and find some option there to work from. |
| MAP_WIDTH = 80
| |
| MAP_HEIGHT = 45
| |
|
| |
|
| #parameters for dungeon generator
| | [http://rogueliketutorials.com/ Here] you'll find completed ports, one for Python 3 and libtcod (revising this tutorial "with good coding practices kept in mind from the beginning") and another for Python 3 and TDL, created by [https://www.reddit.com/user/TStand90 /u/TStand90] for r/roguelikedev [https://www.reddit.com/r/roguelikedev/wiki/python_tutorial_series Tutorial Tuesday 2017]. |
| ROOM_MAX_SIZE = 10
| |
| ROOM_MIN_SIZE = 6
| |
| MAX_ROOMS = 30
| |
|
| |
|
| TORCH_RADIUS = 10
| | A separate work-in-progress port of this tutorial for Python 3 and tdl (a pythonic cffi port of libtcod) can be found [http://www.roguebasin.com/index.php?title=Roguelike_Tutorial,_using_python3%2Btdl here]. |
| SQUARED_TORCH_RADIUS = TORCH_RADIUS * TORCH_RADIUS
| |
|
| |
|
| FOV_ALGO = 0 #default FOV algorithm
| | ==Start the tutorial== |
| FOV_LIGHT_WALLS = True #light walls or not
| |
|
| |
|
| LIMIT_FPS = 20 #20 frames-per-second maximum
| | Follow the first link to get started! |
|
| |
|
|
| |
|
| fov_dark_wall = libtcod.Color(0, 0, 100)
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 1|Part 1: Graphics]]''' |
| fov_light_wall = libtcod.Color(130, 110, 50)
| | *: Start your game right away by setting up the screen, printing the stereotypical @ character and moving it around with the arrow keys. |
| fov_dark_ground = libtcod.Color(50, 50, 150)
| |
| fov_light_ground = libtcod.Color(200, 180, 50)
| |
|
| |
|
|
| |
|
| class Tile:
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 2|Part 2: The object and the map]]''' |
| #a tile of the map and its properties
| | *: This introduces two new concepts: the generic object system that will be the basis for the whole game, and a general map object that you'll use to hold your dungeon. |
| 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:
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 3|Part 3: The dungeon]]''' |
| #this is a generic object: the player, a monster, an item, the stairs...
| | *: Learn how to code up a neat little dungeon generator. |
| #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)
| |
|
| |
|
|
| |
|
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 4|Part 4: Field-of-view and exploration]]''' |
| | *: Display the player's field-of-view (FOV) and explore the dungeon gradually (also known as fog-of-war). |
|
| |
|
| 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):
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 5|Part 5: Preparing for combat]]''' |
| global map
| | *: Place some orcs and trolls around the dungeon (they won't stay there for long!). Also, deal with blocking objects and game states, which are important before coding the next part. |
| #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():
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 6|Part 6: Going Berserk!]]''' |
| global map, player, stairs
| | *: Stalking monsters, fights, splatter -- need we say more? |
|
| |
| #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
| |
| 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
| |
|
| |
| #after that, place the stairs at the last room
| |
| stairs.x = new_x
| |
| stairs.y = new_y
| |
|
| |
|
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 7|Part 7: The GUI]]''' |
| | *: A juicy Graphical User Interface with status bars and a colored message log for maximum eye-candy. Also, the infamous "look" command, with a twist: you can use the mouse. |
|
| |
|
| def render_all():
| |
| 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
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 8|Part 8: Items and Inventory]]''' |
| for object in objects:
| | *: The player gets to collect ("borrow") items from the dungeon and use them, with a neat inventory screen. More items added in the next part. |
| 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_keys():
| |
| global fov_recompute
| |
|
| |
| key = libtcod.console_check_for_keypress()
| |
|
| |
| 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
| |
|
| |
|
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 9|Part 9: Spells and ranged combat]]''' |
| | *: The player's strategic choices increase exponentially as we add a few magic scrolls to the mix. Covers damage and mind spells, as well as ranged combat. |
|
| |
|
| #############################################
| |
| # Initialization & Main Loop
| |
| #############################################
| |
|
| |
|
| libtcod.console_set_custom_font('arial10x10.png', libtcod.FONT_TYPE_GREYSCALE | libtcod.FONT_LAYOUT_TCOD)
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 10|Part 10: Main menu and saving]]''' |
| libtcod.console_init_root(SCREEN_WIDTH, SCREEN_HEIGHT, 'python/libtcod tutorial', False)
| | *: A main menu complete with a background image and the ability to save and load the game. |
| 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
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 11|Part 11: Dungeon levels and character progression]]''' |
| stairs = Object(0, 0, '<', libtcod.white)
| | *: Let the player venture deeper into the dungeon and grow stronger, including experience gain, levels and raising stats! |
|
| |
|
| #the list of objects with those two
| |
| objects = [player, stairs]
| |
|
| |
|
| #generate map (at this point it's not drawn to the screen)
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 12|Part 12: Monster and item progression]]''' |
| make_map()
| | *: Deeper dungeon levels become increasingly more difficult! Here we create tools for dealing with chances and making them vary with level. |
|
| |
|
| #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
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, part 13|Part 13: Adventure gear]]''' |
| libtcod.console_clear(console)
| | *: Swords, shields and other equipment can now help the player by granting hefty bonuses. The bonus system can also be used for all kinds of magics and buffs! |
|
| |
|
|
| |
|
| fov_recompute = True
| |
| credits_end = False
| |
|
| |
|
| while not libtcod.console_is_window_closed():
| | ==Extras== |
|
| |
|
| #erase all objects at their old locations, before they move
| | Some stuff that is entirely optional and didn't make it in; check this out if you finished the tutorial and are looking for some modifications and improvements to your game -- some are easy, others are more advanced. |
| for object in objects:
| |
| object.clear()
| |
|
| |
|
| #handle keys and exit game if needed
| |
| exit = handle_keys()
| |
| if exit:
| |
| break
| |
|
| |
| #render the screen
| |
| render_all()
| |
| 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
| | * '''[[Complete Roguelike Tutorial, using Python+libtcod, extras#A neat Python shortcut for Notepad++|A neat Python shortcut for Notepad++]]''' |
| libtcod.console_set_foreground_color(0, libtcod.grey)
| | *: For Notepad++ users, how to set up a shortcut to help you debugging. |
| libtcod.console_print_right(0, 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(0, 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(0, libtcod.white)
| |
| libtcod.console_print_center(0, SCREEN_WIDTH/2, SCREEN_HEIGHT/2, libtcod.BKGND_NONE,
| |
| 'Victory is Yours!!')
| |
|
| |
| libtcod.console_flush()
| |
| </pre>
| |
|
| |
|
| | * '''[[Complete Roguelike Tutorial, using Python+libtcod, extras#Old-school wall and floor tiles|Old-school wall and floor tiles]]''' |
| | *: Using characters in tiles, without getting weird graphical glitches. This is actually very simple. |
|
| |
|
| == '''Stats''' ==
| | * '''[[Complete Roguelike Tutorial, using Python+libtcod, extras#Real-time combat|Real-time combat]]''' |
| | *: A speed system to change the tutorial's turn-based combat to real-time! |
|
| |
|
| 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.)
| | * '''[[Complete Roguelike Tutorial, using Python+libtcod, extras#Mouse-driven Menus|Mouse-driven menus]]''' |
| | *: Add basic mouse support to your menus! |
|
| |
|
| | * '''[[Complete Roguelike Tutorial, using python+libtcod, extras scrolling code|Scrolling maps]]''' |
| | *: Placeholder page for the scrolling map code. Tutorial text will be written soon. |
|
| |
|
| == '''Items''' ==
| | * '''[[Complete Roguelike Tutorial, using Python+libtcod, extras#Creating a Binary|Creating a Binary]]''' |
| | *: Package and deliver your game the nice way! |
|
| |
|
| 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.)
| | * '''[[Complete Roguelike Tutorial, using Python+libtcod, extras#A* Pathfinding|A* Pathfinding]]''' |
| | *: A good pathfinding system |
|
| |
|
| | * '''[[Complete Roguelike Tutorial, using Python+libtcod, extras#Using Graphical Tiles|Using Graphical Tiles]]''' |
| | *: An alternative to solid colors or ASCII graphics |
|
| |
|
| == '''Combat''' ==
| | * '''[[Complete Roguelike Tutorial, using Python+libtcod, extras#BSP Dungeon Generator|BSP Dungeon Generator]]''' |
| | *: Binary Space Partitioning Dungeon Generator |
|
| |
|
| 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).
| | ==Credits== |
|
| |
|
| | Code and tutorial written by João F. Henriques (a.k.a. Jotaf). Thanks go out to George Oliver for helping with the layout, sections rearrangement, and syntax highlighting; Teddy Leach for his text reviews; and all the folks in the libtcod forums for their valuable feedback! |
|
| |
|
| == '''AI''' ==
| | The most active place to discuss this tutorial, or libtcod in general, is the [https://www.reddit.com/r/roguelikedev/ roguelikedev subreddit]. Post if you're stuck, to show your own project, or just to say hi. It's always cool to get some feedback on the tutorial, and hear about other roguelikes in development. Also, past discussions can either be found in the old [http://roguecentral.org/doryen/forum/index.php?board=20.0 libtcod/Python forum] or the old [http://roguecentral.org/doryen/forum/index.php?topic=328.0 forum on this tutorial]. |
|
| |
|
| Cast ray to player, if unblocked move towards, if near it, attack.
| | [[Category: Developing]] |