Code for Initiative

You’re ready to roll (pun intended), so let’s learn some Python basics! Code for Initiative!

We’ll be learning about data types, functions, formatting strings, importing functions, and more. By the end of this tutorial, you should be able to roll a digital d20 and adding a modifier for a character.

“Types” in Python

Data in Python can fall into a number of different categories. “Type” refers to how that data can be classified. Some of these types include:

• Strings
• Numbers
• Lists
• Dictionaries
• Booleans

We will worry about lists, dictionaries, and booleans later, but to roll for initiative we will need to utilize the Number and String data types.

Numbers are exactly what they sound like, but within the number category, we will mostly make use of the integer type, or “int.” Integers can be positive or negative. They will also always be whole numbers.

The text after the “print” statement in “initiative.py” in quotations is what’s known as a String in Python. Strings are simply a sequence of characters.  Strings can be enclosed in either single quotes or double quotes, but it’s more common to use double quotations for strings in Python.

Using a string in a “print” statement is helpful, but it can also be useful to store strings and other data to solve more complex problems.

Variables

Variables allow us to store information and provide a label to that information. In Python, declaring a variable requires putting a variable name followed by an “=” and the data you wish to store. For example, if we wanted to store the string “We’re rolling for initiative!” we could do the following:

initiative = "We're rolling for initiative!"

We now have a string saved in the variable called “initiative.” The variable name can be just about anything you want it to be, but generally, your variables should be simple and descriptive. Variables can store just about anything you could want, so in addition to storing a string, let’s make a variable to store an integer.

Let’s fudge the dice for now and say that we rolled a natural 20 and save it to a variable called “roll”.

initiative = "We're rolling for initiative!"

roll = 20

print initiative
print roll

When we use variables, we can simply use the variable name rather than re-typing the data every time we wanted to access it. When you run the code, your output should look something like this:

Rolling natural 20’s every time would be great, but we want to simulate actual dice rolls. We can quickly achieve this by utilizing the Python Standard Library. The Standard Library contains modules  which provide well-tested resources to accomplish some of the most common tasks programmers encounter.  Let’s learn how to import the “random” module to generate random numbers.

Importing

Before we import, we should read a little bit of the documentation of the “random” module. It’s a good idea to read documentation when using code that you didn’t write yourself. It will help you get used to Python as well as giving you a more complete understanding of what you’re using. After looking in the random documentation, it seems that a method called random.randint(a, b) can help us by returning a random integer, where “a” is the lowest number possible and “b” is the highest number possible.

To use random.randint we first need to import the random module at the top of the file.

import random

Rolling the d20

Let’s overwrite our previous fudged roll by inputting the range found on a d20 into random.randint in the “roll” variable.

roll = random.randint(1,20)

This code will not work without importing the random module first. Always be sure to import your modules at the top of your file. Now, our code looks like this:

import random

initiative = "We're rolling for initiative!"

roll = random.randint(1,20)

print initiative
print roll

If we run the script a few times, we will see different rolls!

Python Operators

Operators are the way that you can adjust or assign values in Python. You have already been exposed to one operator. When we created the “initiative” and “roll” variables, we used the equal sign to assign the values. As such, the equal sign is known as an assignment operator. Python has a number of different types of operators, including arithmetic operators….all of that just to say: Python can do some math for you!

Much of the math in TTRPGs will be addition and subtraction. The operators are exactly what you’re expect, “+” and “-“.  You can also use “*” for multiplication and “/” for division, but let’s start with adding a modifier to initiative.

Let’s assume our character has a +3 initiative modifier. First, let’s assign that value to a variable named “modifier” and then add that to the d20 roll.

import random

initiative = "We're rolling for initiative!"

roll = random.randint(1,20)

modifier = 3

print initiative
print roll + modifier

If you run the code, the results won’t look much different than the previous version. Let’s make some changes to show the value of the roll, the modifier, and the total roll.

String Substitutions and Formatting

If we wanted to print an integer and a string, we would have to perform those operations separately unless we converted the integer to a string. We can accomplish this in a few ways.

We could try converting the integers to strings using the str() function. This is how that might look for the d20 roll:

roll = str(random.randint(1,20))

However, if we wanted to print a statement, it would usually be easier to use the .format() method on a string to insert variables and values into strings. So, assuming a roll of 18 with the same modifier of 3, if we wanted to have a statement that said, “You rolled 18 with a modifier of 3 for an initiative roll of 21.” we could write the following:

import random

initiative = "We're rolling for initiative!"

roll = random.randint(1,20)

modifier = 3

total = roll + modifier 

print initiative
print "You rolled {} with a modifier of {} for an initiative roll of {}.".format(roll, modifier, total)

Note that we added a new variable, “total,” to add the roll and modifier variables. From there, we created a print statement followed by our string. The string we wrote contains curly braces in the three places where we want to substitute data. After the string, we added .format() with the variables we wanted to insert in the statement in the order in which they appeared. If you run this script, you should see something like this:

Defining Functions

If you have certain tasks that need to be repeated, you can set those tasks up in a function so that they can be duplicated with new input and will behave in a consistent way.

First, we define functions using the “def” keyword. The information to be passed into the function are known as “parameters” when they are in the function definition and “arguments” when the function is called with actual values.  To return a value you will need to add a “return” statement followed by the information you would like the function to output. A function for an initiative roll might look something like this:

def initiative_roll(character, modifier):

    roll = random.randint(1,20)

    total = roll + modifier 

    return "{} rolled {} with a modifier of {} for an initiative roll of {}.".format(character, roll, modifier, total)

The parameters of the function allow for a character’s name to be inserted as well as the initiative modifier. Within the function, we have reusable code for rolling the d20, adding that roll to the modifier, then creating a string saying what the character rolled, their modifier, and the total. Now, let’s see the function in action!

Calling Functions

The “initiative_roll” function can be used to print the statement or store it in a variable. Let’s look at how that looks. First, to print an initiative roll for a character named “Arthur” with a modifier of 2, we would write the following:

print initiative_roll("Arthur", 2)

As an alternative, we could assign the result of the function call to a variable and then print that variable:

arthur_roll = initiative_roll("Arthur", 2)

print arthur_roll

Either way, the result should look something like this when you run the script:

So, if we wanted to roll initiative for multiple characters, we could print the call to the function for each of the characters. Here is the current state of the script:

import random

def initiative_roll(character, modifier):

    roll = random.randint(1,20)

    total = roll + modifier 

    return "{} rolled {} with a modifier of {} for an initiative roll of {}.".format(character, roll, modifier, total)

print initiative_roll("Arthur", 2)
print initiative_roll("Liana", -1)
print initiative_roll("Sybil", 0)

If we run the script, the output will look something like this: