05-01. RPG inventory

Typically in a role playing game, a player can add and remove items from their inventory.

An inventory is essentially what the player is carrying with them in the game.

This programme demonstrates how we can store a set of items in a data structure called a list, which is an alternative to having lots of variables.

We'll start with our boilerplate code with one exception.

The commands for using lists are in a library called system collections Generic.

So we need to say that we're using that in this programme in addition to using the usual system commands.

Let's start by defining the player inventory.

The player will have two items to begin with, a, sword and a shield.

Unlike a variable that can only hold one value at a time, a list can hold multiple values, all with the same identifier.

So to define a list, we use the data type list and inside chevrons we say what type of list it is.

In this case a list of strings.

So string, then the identifier or name of the list that will be inventory.

Now this will be assigned to be a new list of strings.

It's possible to state how many strings or elements we want our list to begin with.

And this would be enclosed in brackets.

But we won't do this.

So just open and close them.

But then assign two new elements, sword and shield.

These are strings, so they're enclosed in quotes, separated with a comma and curly brackets.

Curly brackets.

And the data are optional, but since we know we want to add them to the player's inventory, we might as well do that when we define the list.

A list can have any number of elements inside the computer.

These elements have been assigned a number automatically.

Sword is number or index 0 and shield is number or index 1.

The indexes start at 0, which can be confusing at first, but we also saw this with string formatting arguments in the SaveTheChange programme.

This programme is never going to end unless the user closes it.

So while true is a way to write an infinite loop, since true will always be true, we then want the player to choose one of the available actions using the inventory.

So we'll write a subprogram called chooseaction to do that, passing it the inventory.

Let's write that subprogram now.

Static void chooseaction.

Taking in the list of inventory items, we could have used a global list instead.

A handy prompt will tell the user, how many items are in their inventory.

Or put another way, how many elements are in the list.

The count method tells us how many items are in the list.

So that's perfect.

Now we need to prompt the user to choose an action they want to perform.

The string action becomes the input from the keyboard.

As there are four possible options, it would be best to use a switch case here.

Switch action.

But we could have used an if and an else instead.

In the case that the user, entered add, call the subprogram additem, to the inventory.

We'll write that in a moment.

In the case the user entered drop, we'll call the subprogram dropitem.

In the case that the user entered, look.

Call the subprogram look.

In the case that the user entered, search, Call the subprogram search.

Then output a blank line just to make it look nicer on the screen when it loops back around for the next action.

As our programmes are getting bigger, we begin to see the benefit of subprograms to make the code easier to break down, read and follow.

Ok, let's define what happens when the player adds an item.

Static void add item, taking in the list of strings, that is the inventory in brackets.

First, we'll ask the player what they want to add to their inventory.

And for simplicity, assume they can add anything that is stored in the variable item.

To add that to the inventory list, we use a method called Add inventory, add and then the data.

So in brackets item, that will add whatever the user entered at the keyboard to the end of the list and it will automatically be given a number or index by the computer.

Let's tell the player the item was added by outputting a simple message.

It doesn't really matter which order we write these subprograms, but let's do the dropping of items next, as it's the opposite to adding static void dropitem passing in the inventory list.

Again, ask the player which item they want to drop and store that in the variable called item.

Now we need to see if that item is in our list to be able to drop it.

So if inventory contains item inside the computer, it's performing a linear search by looking at each element in turn to see if the one that we're looking for is there.

If the result of that search is true, we can remove the item from the list by using the remove method, inventory, remove and then the data in brackets item.

The remove method does not remove all the matching elements, just the first one that it finds in the list starting from index zero.

If you wanted to remove all of the items that matched, you could use remove all instead.

Otherwise, else tell the player that they don't have that item.

The subprogram for searching is then pretty much the same code.

The difference is that if the item is found in the list, we don't want to remove it.

So we can quickly write that code.

Now, static void search with the inventory, a prompt, an input and a check.

If the item is in the list, then two relevant messages depending on the outcome of that check.

Finally, we can write the look subprogram.

This will allow the player to ask what have I got?

In inventory slot two, for example, we can see how internal indexes become useful.

Start with defining the subprogram and then ask the user, which inventory slot they want to look at.

We'll store this in an integer variable identified as slot.

Indexes are numbers, so we need to cast this input to an integer.

Now, if the slot they chose is less than the number of items in the list, that's great, but we need to check that to prevent an error.

Let's output what's in the chosen index.

Inventory, square bracket, slot, that's the index square bracket and then complete the sentence.

So what we get as an output would be you have a sword.

In slot one, we learned that a specific index can be referred to by using square brackets after the name of the list.

We used the slot variable here because we didn't know which slot the user was going to choose.

But we could also use a number instead of a variable inside the square brackets if we knew which index we wanted.

Otherwise.

Else the user must have chosen an invalid slot because the index is greater than or equal to the size of the list.

Remember, the first item is at index zero, not one.

That's our programme written.

Let's give it a run, try a few options and see what happens.

sa.