View source for Roguelike Tutorial, using python3+tdl, part 1

<center><table border="0" cellpadding="10" cellspacing="0" style="background:#F0E68C"><tr><td><center>
This is part of a series of tutorials; the main page can be found [[Roguelike Tutorial, using python3+tdl|here]].

The tutorial uses tdl version 3.1.0 and Python 3.5

</center></td></tr></table></center>


__TOC__

<center><h1>'''Graphics'''</h1></center>

== 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 3.5].

* Install the tdl module for python3. 

* In windows:

[http://www.mingw.org/ MinGW] must be on the Windows path for use with pycparser.

<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">python3 -m pip install tdl</syntaxhighlight></div>

* Note: If you're working on a fresh environment or a new PC, don't forget to install the latest Microsoft Visual C++ runtime. If you've made sure that your x32 or x64 version of Python matches both your operating system and the install packages and you're still getting "ImportError: DLL Load Failed" when you try to execute the code, this may be the issue.

As of version 3, tdl now depends on libtcod-cffi. It will be installed automatically by pip.

* In Linux:

If using a Debian or Ubuuntu based distro, install the following dependencies:

<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">apt-get install gcc libsdl2-dev libffi-dev python-dev</syntaxhighlight></div>

If using Fedora, install using the folloowing commands:

<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">dnf install gcc-c++ SDL2-devel libffi-devel python3-devel</syntaxhighlight></div>

If you use a different distro, you'll have to figure out the equivalent packages. Feel free to update this wiki with the relevant information.

Next, install tdl:

<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">pip3 install tdl</syntaxhighlight></div>

Now to create your project's folder. Create an empty file with a name of your choice, like ''firstrl.py''. 
You'll also need a font file in png format. We chose '' arial10x10.png'', which you can download [https://github.com/HexDecimal/python-tdl/blob/master/fonts/libtcod/arial10x10.png here].

More fonts are available [https://github.com/HexDecimal/python-tdl/tree/master/fonts/libtcod here].

== Choice of code editor ==

If you're just starting out with Python, you'll find that many Python coders just use a simple editor and run their scripts from a console to see any debugging output. Most Python coders don't feel the need to use a fancy IDE! On Windows, Notepad++ is an excellent bet; most Linux programmers already have an editor of choice. Almost all editors allow you to configure shortcut keys (like F5 for instance) to quickly run the script you're editing, without having to switch to a console.

[[Complete Roguelike Tutorial, using Python+libtcod, extras#A neat Python shortcut for Notepad++|See this page from the libtcod tutorial]] if you want to set up a Notepad++ shortcut with a couple of nice features for debugging, or if you tried to roll your own and hit the infamous "module not found" error.


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

<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">import tdl</syntaxhighlight></div>


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.


<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">SCREEN_WIDTH = 80
SCREEN_HEIGHT = 50
LIMIT_FPS = 20</syntaxhighlight></div>


Now we're going to use a custom font! It's pretty easy. You can find many choices  [https://github.com/HexDecimal/python-tdl/tree/master/fonts/libtcod here]. 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", which we indicate by setting the parameter ''altLayout=True''. Most fonts are in this format and thus end with ''_gs_tc''. If you want to use a font with a different layout or make your own, the [http://roguecentral.org/doryen/data/libtcod/doc/1.5.1/html2/console_set_custom_font.html?c=false&cpp=false&cs=false&py=true&lua=false docs on the subject] are really informative. <b>If you do switch the font, you may also need to change the "greyscale" and/or the "altLayout" settings to "False."</b> You can worry about that at a later time though. Notice that the size of a font is automatically detected.


<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">tdl.set_font('arial10x10.png', greyscale=True, altLayout=True)
</syntaxhighlight></div>


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.


<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">console = tdl.init(SCREEN_WIDTH, SCREEN_HEIGHT, title="Roguelike", fullscreen=False)</syntaxhighlight></div>


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. (This line will simply have no effect if your game is turn-based.)

<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #D0FFC2"><syntaxhighlight lang="python">tdl.setFPS(LIMIT_FPS)</syntaxhighlight></div>


Now the main loop. It will keep running the logic of your game as long as the window is not closed.


<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">while not tdl.event.is_window_closed():</syntaxhighlight></div>


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. 

Now print a character to the coordinates (1,1). Can you guess what that character is? No, it doesn't move yet! 

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.

<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">    console.draw_char(1, 1, '@', bg=None, fg=(255,255,255))</syntaxhighlight></div>

Here we're setting the text color to be white. In RGB color codes, that's ''255,255,255''  [http://roguecentral.org/doryen/data/libtcod/doc/1.5.1/html2/color.html?c=false&cpp=false&cs=false&py=true&lua=false There's a good list of colors you can use here], along with some info about mixing them and all that. Alternatively, we can use hexidecimal color codes. For white, that would be: ''0xFFFFFF'' (note that there are no quotations around it, since Python will read it as a hexidecimal integer, not a string.)


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.


<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">    tdl.flush()</syntaxhighlight></div>


Ta-da! You're done. Run that code and give yourself a pat on the back!

Note that since we don't have any input handling code, the game may crash on exit (it won't process the OS's requests to close). Oops! Don't worry though, this problem will go away as soon as we add keyboard support.

[[Roguelike Tutorial, using python3+tld, part 1 code#Showing the @ on screen|Here]]'s the complete code so far.

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


<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">playerx = SCREEN_WIDTH//2
playery = SCREEN_HEIGHT//2</syntaxhighlight></div>


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.


<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">def handle_keys():
    global playerx, playery
    
    user_input = tdl.event.key_wait()
    
    #movement keys
    if user_input.key == 'UP':
        playery -= 1

    elif user_input.key == 'DOWN':
        playery += 1

    elif user_input.key == 'LEFT':
        playerx -= 1

    elif user_input.key == 'RIGHT':
        playerx += 1</syntaxhighlight></div>


Done! These are the arrow keys, if you want to use other keys here's a [https://pythonhosted.org/tdl/tdl.event.KeyEvent-class.html#key reference]. Most codes are self-explanatory. KP stands for ''keypad''.  

While we're at it, why not include keys to toggle fullscreen mode, and exit the game? You can put this just above the movement keys.


<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">    if user_input.key == 'ENTER' and user_input.alt:
        #Alt+Enter: toggle fullscreen
        tdl.set_fullscreen(not tdl.get_fullscreen())
 
    elif user_input.key == 'ESCAPE':
        return True  #exit game</syntaxhighlight></div>

From now on, we'll show code for a <span style="background-color: #D0FFC2">'''real-time game'''</span> with a green background, and code for a <span style="background-color: #DFEEFF">'''turn-based game'''</span> with a blue background.

So far, we've been writing a turn-based game. Then the game won't go on unless the player presses a key. So effectively you have a turn-based game now. However, we'll introduce another option at this point. If we comment out the line ''user_input = tdl.event.key_wait()'' and replace it with the following block of code, we'll have a real-time game:

<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #D0FFC2"><syntaxhighlight lang="python">    #realtime
    keypress = False
    for event in tdl.event.get():
        if event.type == 'KEYDOWN':
           user_input = event
           keypress = True
    if not keypress:
        return</syntaxhighlight></div>

This works because ''tdl.event.get()'' won't block the game.

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:

<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">console.draw_char(playerx, playery, '@', bg=None, fg=(255,255,255))

    tdl.flush()

    #handle keys and exit game if needed
    exit_game = handle_keys()
    if exit_game:
        break</syntaxhighlight></div>


The reason why we draw stuff before handling key input is that, in a turn-based game, the first screen is shown before the first key is pressed (otherwise the first screen would be blank).

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_game = handle_keys()''.


<div style="padding: 5px; border: solid 1px #C0C0C0; background-color: #F0F0F0"><syntaxhighlight lang="python">            console.draw_char(playerx, playery, ' ', bg=None)</syntaxhighlight></div>


[[Roguelike Tutorial, using python3+tdl, part 1 code#Moving around|Here]]'s a rundown of the whole code so far.

[[Roguelike Tutorial, using python3+tdl, part 2|Go on to the next part]].

[[Category:Developing]]