Working with Python - Introductory Level

Let's write the customary "Hello, world!" program in Python. It's only a single line of code, but it's a start.

Let's get started with the basic structure of a Python program.

Strings, integers, booleans and floats.

You can put variables almost anywhere you want in a Python file, but where you put them matters. Let's talk about scope.

Let's figure out how to capture user input.

Let's get started on making decisions based on what a user types in, and give the player the option of showing a help screen and quitting the game (or playing again).

Let's have a look at Python's comparison operators and logical operators. We'll be using them a lot, so a brief overview seems appropriate.

Let's make sure that we sanitize whatever the user types, and let's finish up printing our help information.

Let's spice things up a bit by adding colour to our application, and figuring out how to clear the screen before the game starts.

Classes are incredibly useful, and we'll be using them throughout the remainder of this course. Let's explore them a bit.

We need something to keep track of the player as he or she progresses through the game, so let's create a Player class to take care of this for us.

We need somewhere to store information about every room in the game, so let's create a Room class to take care of this.

Let's define a Game class that will hold the current player, the room that the player is currently in, and all other important game related information.

Let's get started using our Player, Room, and Game classes in our adventure game.

Tuples are like lists: they are one of Python's four data structures which allow us to store more than one thing in a variable. Let's use tuples to help provide more realistic descriptions for our game.

Let's get started with allowing players to navigate around the dungeon.

Like lists and tuples, dictionaries are data structures in Python that let us store more than one thing in a variable. Unlike lists and tuples, though, dictionaries allow us to store things using key-value pairs. Let's see how they work.

We have a lot of items in our armory.py file, so let's put some in our rooms, to give the player something to find. Let's also decide if a room should have a monster or not.

An overview of the Python list data type, and adding an attribute to the Player class to keep track of inventory.

Let's get started with the logic of allowing players to pick items up.

Let's finish up the code for picking an item up, and removing it from the room once we've done so.

Let's write a simple function that allows the player to print out the contents of the current inventory.

Right now, room descriptions are displayed every time we enter a command. That's no good, so let's clean our code up a bit.

Let's implement the functionality that allows the player to drop an item, and while we're at it, let's learn about the "try/except" functionality in Python, which is similar to "try/catch" in other languages.

We can now let players find items, drop items, and show the current inventory, so let's allow them to equip, or use, weapons, armor, and shields.

Let's show the player what items from their inventory that they have equipped, and let's consider how to solve one problem that we have in the game. Plus, I give you a bit of a challenge.

Here's how I solved the challenge.

Players can now find items, pick up items, use items, and drop items, and view the inventory. The last step is to let them "unequip," or stop using items. Let's take care of that.

Let's implement the "status" command, so players can see how well they are doing in the game.

A brief overview of how combat is going to work in our adventure game.

Let's get started with combat by letting the player run away when they encounter a monster.

Let's begin with the combat logic by determining who gets to attack first.

Let's get the initial code in place for the player's turn during combat.

Now it's the monster's turn, so let's implement the logic for this part of the fight.

If the player is doing badly in the fight, they should have the chance to run away. Let's write that logic.

Once a fight is over, the player should get feedback, one way or the other, and if the monster lost, we need to make sure that the monster is taken out of the game. Let's take care of that.

Combat should be harder (or easier) depending on what armour, weapons, or shield the player has, and depending how strong the monster is. Let's adjust our math accordingly.

Let's allow the player to rest in order to regain health.

Let's have a look at what the final map will look like.

We need to make some changes to the Game class to tell it about the map. Let's do that.

Player's should not be allowed to move "outside" of the map. In order to prevent that, we need to keep track of where the player is, and check that against the current map's dimensions. Let's do that.

Syntax errors are easy to spot, since your editor typically points them out to you. Logic errors are tougher. Here is a challenge that focuses on logic errors.

Here's how I solved the challenge.

Let's try out our code and modify it so that it keeps track of the player's current position on the map.

Let's take advantage of the attribute "visited" that we added to the Player class in order to keep track of where the player has been on the map.

Let's get started implementing the "map" command to show a map to the player.

Let's make the map show us useful information.

Let's finish up our map command by adding some lines at the top and bottom, and adding a legend.

Let's give our player an easy way to see how things are going by using the blessings package to add a status bar at the top of the screen.

Here's how I solved the challenge.

There are only a few things left to take care of in the game; let's write the last bit of code.