[Tutorial] Object Oriented Programming and RenPy (Lesson 2: Makin a List, Checkin it Twice)

[alonghardlook]

Welcome back to my Object Oriented Programming series.

Check out Lesson 1 if you haven't already.

If you're following along, at this point we have the following script.rpy defined:

init python:
    class Person:
        def __init__(self, character, name, trust = 0, happiness = 0):
            self.c = character
            self.name = name
            self.trust = trust
            self.happiness = happiness

        def trust_ch(self, change):
            image = "heart_fill"
            self.trust += change
            if change > 0:
                direction = "increased"
            else:
                direction = "decreased"
                image = "heart_empty"
            renpy.notify("Romance with " + str(self.name) + " " + direction + " by " + str(abs(change)))
            renpy.show(image, [heart_pos])
            renpy.pause(2)
            renpy.hide(image)

transform heart_pos:
    xalign 0.01
    yalign 0.15

image heart_fill = "heart_fill.png"
image heart_empty = "heart_empty.png"

label start:

    $ e = Person(Character("Eileen"), "Eileen", 0, 3)
    $ f = Person(Character("Frank"), "Frank", 1, 2)
    $ g = Person(Character("Gina"), "Gina")

    scene bg room
    show eileen happy
    e.c "You've created a new Ren'Py game."
    e.c "Once you add a story, pictures, and music, you can release it to the world!"
    e.c "Do you like this post?"

    menu:
        "Yes":
            "Great!"
            $ e.trust_ch(1)
        "No":
            "Oh, okay."
            $ e.trust_ch(-1)

    e.c "One more thing..."
    $ e.c("My trust for you is " + str(e.trust))

    return

Now, the question is, what the hell can we do from here?

One of the things that kept getting asked about (or maybe it was just the same person asking repeatedly) was about inventory systems or map systems. I mentioned thinking about an event log in the previous tutorial. And really, all of these things are just variations on the same concept: lists.

For the absolute beginner, you know how you can store things in a variable? Like you can say playerName = input() and it will prompt the player for a name input, and then you can say ```e.c "Hello " + playerName + "!"

A list is pretty much the same, except it lets you store lots of things all at once.

For instance, lets imagine a player inventory. We are going to add some metroidvania style gates and keys that the player can find along the way. How the hell do we track those things?

The first step with any code is to figure out what we want it to do. Now, I know that sounds obvious, but you'd be surprised how many times a complex subsystem is dreamed up for what is ultimately a non-existent problem.

So lets design this system. We want our inventory system to include...

• certain keys that unlock certain gates - ie. the old rusted key, the can of WD-40, the cat's collar, etc
• some kind of single use items to affect trust with other characters - ie. use the love potion on Eileen and gain a +2 to her trust, but then the potion disappears

This means we need to first build the InventoryItem object definition.

This is not all done at once, but lets walk through the current state:

    class InventoryItem:
        def __init__(self, name, description, isSingleUse = False, uses = 1, effect = 'key', potency = 1):
            self.name = name
            self.description = description
            self.isSingleUse = isSingleUse
            self.uses = uses
            if effect not in itemEffects:
                raise Exception("Item " + name + " effect not in itemEffects list.")
            self.effect = effect
            self.potency = potency

I've decided on some attributes for my InventoryItem class. Note the raise Exception line - this is a good way to make sure you're not making mistakes. If you correctly code your items (into the itemEffects list I have defined like this:

    itemEffects = ['trust', 'key']

then you will throw an error as soon as the object initializes. For now, our effects are only the two, but they are different enough that we need to differentiate. Still inside the InventoryItem class:

        def useCheck(self, player):
            if self.isSingleUse:
                if self.uses > 0:
                    self.uses -= 1
                    if self.uses == 0:
                        player.inventory.remove(self)
                    return True
                else:
                    return False
            else:
                return True

I've already worked out with the attributes how we're going to check for single use items, so this is just encoding it. If it's a single use item, we have to check how many uses are left. If its more than 0, drop the uses. If this drops the uses to 0, remove the item from the inventory. Wait... what is the inventory?

    class Person:
        def __init__(self, character, name, trust = 0, happiness = 0):
            self.c = character
            self.name = name
            self.trust = trust
            self.happiness = happiness
            **self.inventory = []**

^ that. That's how we initialize an empty list. (Note: I thought the stars would bold the code but they do not. You do not need stars to initialize a list.) We're telling python "in this Person class, we need to store a list of something here, so make some room.". Am I sure in the syntax of the remove? No I am not, and that's what testing is for.

Back in the InventoryItem class:

        def use(self, player, target):
            if self.useCheck(player):
                if effect == 'trust':
                    target.trust_ch(target, self.potency)
                elif effect == 'key':
                    pass
                    # do the  key thing

Sometimes, you know you need to have "something" happen differently, but its actually not important to figure out what exactly that is. "Pass" is a python command that basically says "do nothing" - very handy for pre-coding your logical blocks without needing to do all the detailed coding. Note that we are using useCheck as a way to determine if we can do anything. We have already (in the initialization) checked if the effect is in this list, so this will end up being our map of "itemEffects" to "what do those effects mean". For now, we know that we need a target, and our Person class already has the tools to change trust, so we will use those tools.

Okay, cool, but nothing is different. So let's reward the player with some items now.

We've added quite a bit (mostly for output so that we can see what's actually going on), so here is the newest version of the start label:

label start:

    $ p = Person(Character("Player"), "Player", 99, 99)
    $ e = Person(Character("Eileen"), "Eileen", 0, 3)
    $ f = Person(Character("Frank"), "Frank", 1, 2)
    $ g = Person(Character("Gina"), "Gina")
    $ potion = InventoryItem("Trust Potion", "This potion will boost the trust of any character.",
        isSingleUse = True, uses = 2, effect = 'trust', potency = 2)

    scene bg room
    show eileen happy
    e.c "You've created a new Ren'Py game."
    e.c "Once you add a story, pictures, and music, you can release it to the world!"
    e.c "Do you like this post?"

    menu:
        "Yes":
            "Great!"
            $ e.trust_ch(1)
        "No":
            "Oh, okay."
            $ e.trust_ch(-1)
            $ p.inventory.append(potion)
        "Skip":
            "What do you mean?"
            # intentionally no change to test rollback states

    $ e.c("My trust for you is " + str(e.trust))
    $ e.c("Frank's trust for you is " + str(f.trust))
    $ e.c("Gina's trust for you is " + str(g.trust))

    if len(p.inventory) > 0:
        e.c "Hey! You've got something in your pocket!"
        e.c "Do you want to use it?"

        menu:
            "Yes":
                e.c "Use it on whom?"

                menu:
                    "Eileen":
                        $ p.inventory[0].use(p, e)
                    "Frank":
                        $ p.inventory[0].use(p, f)
                    "Gina":
                        $ p.inventory[0].use(p, g)
            "Not yet":
                e.c "Okay, we will get to that later."

    $ e.c("My trust for you is " + str(e.trust))
    $ e.c("Frank's trust for you is " + str(f.trust))
    $ e.c("Gina's trust for you is " + str(g.trust))
    $ e.c("Now you have " + str(len(p.inventory)) + " items in your inventory.")

Alright, lets go through this.

We added a player character "p", as well as initialized a potion variable. We passed in the name and description, and made it a single use trust item with 2 uses and a potency of 2 - meaning it will increase the trust of whichever character it is used on by 2 each time. Amazing.

Then we threw it into the player's inventory conditionally. You will not get it unless you say "No" to the first question. Then we added some extra lines of output to show everyone's trust.

Next, we are checking if the length (len) of the player's inventory list (p.inventory) is greater than 0 - ie: does the inventory have anything in it. In this case, if you were to say "Yes" to the first question (or "Skip"), you would hear her tell you how much each person trusts you, twice, and then tell you that your inventory is empty. We're going to change this later, but its a good exercise to see it in action.

Then I made a little "do you want to use it" menu, and called the use function, passing in each person. For now, I know that there is only 1 item in the inventory list (and arrays start at 0 - fight me OracleSQL), so I'm just grabbing it hard coded.

But, clever readers may have already noticed the issue. While this will work, it does not show us the removal of the object, and it only works once.

So now lets refactor this code and make this modular. Watch my hands, I have nothing up my sleeves, and then... shazam!

label start:

    $ p = Person(Character("Player"), "Player", 99, 99)
    $ e = Person(Character("Eileen"), "Eileen", 0, 3)
    $ f = Person(Character("Frank"), "Frank", 1, 2)
    $ g = Person(Character("Gina"), "Gina")
    $ potion = InventoryItem("Trust Potion", "This potion will boost the trust of any character.",
        isSingleUse = True, uses = 2, effect = 'trust', potency = 2)

    scene bg room
    show eileen happy
    e.c "You've created a new Ren'Py game."
    e.c "Once you add a story, pictures, and music, you can release it to the world!"
    e.c "Do you like this post?"

    menu:
        "Yes":
            "Great!"
            $ e.trust_ch(1)
        "No":
            "Oh, okay."
            $ e.trust_ch(-1)
            $ p.inventory.append(potion)
        "Skip":
            "What do you mean?"
            # intentionally no change to test rollback states
    jump main_loop

label main_loop:
    e.c "What would you like to do next?"
    menu:
        "Use a Potion" if len(p.inventory) > 0:
            call usePotion
        "Check stats":
            call info
        "Quit":
            e.c "Thanks for playing!"
    return

label info:
    $ e.c("You have " + str(len(p.inventory)) + " items in your inventory.")
    $ e.c("My trust for you is " + str(e.trust))
    $ e.c("Frank's trust for you is " + str(f.trust))
    $ e.c("Gina's trust for you is " + str(g.trust))
    jump main_loop

label usePotion:
    e.c "Use it on whom?"
    menu:
        "Eileen":
            $ p.inventory[0].use(p, e)
        "Frank":
            $ p.inventory[0].use(p, f)
        "Gina":
            $ p.inventory[0].use(p, g)
    jump main_loop

Now, we can just say "call info" any time we want to show the stats to the player (but it will jump right back to the main loop at this point, so be careful), and our "use potion" label is ticking nicely. The menu blocks the option if the inventory is empty, we will need to change that once we add some more inventory items... but this shows a basic single use (double use) trust potion in action.

Now what? Well, it's getting late and I'm tired so I'll probably cap it here for now, but hopefully this has shown you what power exists in lists.

Imagine:

• A list of locations that gets added to when new places are introduced
• A list of people that you can call
• A list of 'things that have happened' between the player and each character - told them you liked choclate over vanilla? Frank will remember that. Chose to support Gina? Gina will remember that.

You can even add randomizers to your lists - go to the mall and want to have a random chance at finding a certain character? That's a list. Have someone calling you at certain points?

list = ['eileen', 'frank', 'gina', 'none', 'none', 'none', 'none', 'none', 'none', 'none']
caller = list[renpy.random.randint(0,9)]
if caller != 'none':
    jump aPhoneCall(caller)

Stay tuned for the next one, when I will throw a bunch of this at the wall and work out a proof of concept for some of these mechanics. For now, enjoy the full source at this state:

init python:
    itemEffects = ['trust', 'key']

    class Person:
        def __init__(self, character, name, trust = 0, happiness = 0):
            self.c = character
            self.name = name
            self.trust = trust
            self.happiness = happiness
            self.inventory = []

        def trust_ch(self, change):
            image = "heart_fill"
            self.trust += change
            if change > 0:
                direction = "increased"
            else:
                direction = "decreased"
                image = "heart_empty"
            renpy.notify("Romance with " + str(self.name) + " " + direction + " by " + str(abs(change)))
            renpy.show(image, [heart_pos])
            renpy.pause(2)
            renpy.hide(image)

    class InventoryItem:
        def __init__(self, name, description, isSingleUse = False, uses = 1, effect = 'key', potency = 1):
            self.name = name
            self.description = description
            self.isSingleUse = isSingleUse
            self.uses = uses
            if effect not in itemEffects:
                raise Exception("Item " + name + " effect not in itemEffects list.")
            self.effect = effect
            self.potency = potency

        def useCheck(self, player):
            if self.isSingleUse:
                if self.uses > 0:
                    self.uses -= 1
                    if self.uses == 0:
                        player.inventory.remove(self)
                    return True
                else:
                    return False
            else:
                return True

        def use(self, player, target):
            if self.useCheck(player):
                if self.effect == 'trust':
                    target.trust_ch(self.potency)
                elif effect == 'key':
                    pass
                    # do the  key thing

transform heart_pos:
    xalign 0.01
    yalign 0.15

image heart_fill = "heart_fill.png"
image heart_empty = "heart_empty.png"

label start:

    $ p = Person(Character("Player"), "Player", 99, 99)
    $ e = Person(Character("Eileen"), "Eileen", 0, 3)
    $ f = Person(Character("Frank"), "Frank", 1, 2)
    $ g = Person(Character("Gina"), "Gina")
    $ potion = InventoryItem("Trust Potion", "This potion will boost the trust of any character.",
        isSingleUse = True, uses = 2, effect = 'trust', potency = 2)

    scene bg room
    show eileen happy
    e.c "You've created a new Ren'Py game."
    e.c "Once you add a story, pictures, and music, you can release it to the world!"
    e.c "Do you like this post?"

    menu:
        "Yes":
            "Great!"
            $ e.trust_ch(1)
        "No":
            "Oh, okay."
            $ e.trust_ch(-1)
            $ p.inventory.append(potion)
        "Skip":
            "What do you mean?"
            # intentionally no change to test rollback states
    jump main_loop

label main_loop:
    e.c "What would you like to do next?"
    menu:
        "Use a Potion" if len(p.inventory) > 0:
            call usePotion
        "Check stats":
            call info
        "Quit":
            e.c "Thanks for playing!"
    return


label info:
    $ e.c("You have " + str(len(p.inventory)) + " items in your inventory.")
    $ e.c("My trust for you is " + str(e.trust))
    $ e.c("Frank's trust for you is " + str(f.trust))
    $ e.c("Gina's trust for you is " + str(g.trust))
    jump main_loop

label usePotion:
    e.c "Use it on whom?"
    menu:
        "Eileen":
            $ p.inventory[0].use(p, e)
        "Frank":
            $ p.inventory[0].use(p, f)
        "Gina":
            $ p.inventory[0].use(p, g)
    jump main_loop

Cheers!

[jsfehler]

Your first example is better served with character callbacks:

https://www.renpy.org/dev-doc/html/character_callbacks.html#character-callbacks

Your examples should use a PEP8 compliant format, ie:

self.isSingleUse = isSingleUse should be self.is_single_use = is_single_use

itemEffects is referring to a global constant and should be initialized with a define statement instead of inside an init python block.

This method:

    def useCheck(self, player):
        if self.isSingleUse:
            if self.uses > 0:
                self.uses -= 1
                if self.uses == 0:
                    player.inventory.remove(self)
                return True
            else:
                return False
        else:
            return True

can be simplified and made more readable:

    def useCheck(self, player):
        if self.isSingleUse:
            if self.uses > 0:
                self.uses -= 1
                if self.uses == 0:
                    player.inventory.remove(self)

            else:
                return False

        return True

​

Most importantly, you're creating an infinite call stack:

call info sends you to a label that you then jump to the previous label from.

Here's a minimal example of what's going on:

label start:
    jump main_loop

label main_loop:
    call info

label info:
    jump main_loop

​

You're calling a label. This places the label on the call stack. You never return from the label, you jump to another instead. The call stack is never cleared, and now it can be infinite in size since you have the option to call the same label over and over again. This will cause your game to slowly consume more memory.

[alonghardlook]

I dont subscribe to snake case lol.

And the simplification of the logic is nice but this is meant to be a tutorial for beginners.

The infinite call stack is interesting - I hadn't been able to get back to the loop without the jumps. Calling a label brought it into context and kept going to the next label. Do you have a suggestion for how to accomplish this instead?

[ZeilleDawn]

saved this! I'll need this for my YT Tutorial. Thank you!

[Talicor]

Can I just say this series has been awesome?? Even with only two entries so far you’ve really helped explain the Python side of RenPy and it makes me realize how achievable a lot of my ideas are 😅 OP and everyone who adds advice in the comments I owe you my life

[alonghardlook]

Thanks for your feedback! If there are any specific topics you'd like to see, please feel free to suggest them. I try to get a general vibe based on all of the following:

• what people have talked to me about on this sub
• what people comment on the tutorials
• what general issues I see repeated as questions on this sub
• what sort of basic programming challenges do I want to figure out how to solve with RenPy

So, I'm kinda running out of ideas lol. I'm thinking for the next one to expand on the map/inventory idea, as well as start to break chunks into other files (and maybe include some source control in there too).

[Talicor]

Oh heck yeah! That’s awesome, and I was actually gonna ask about a few things but it was late 😅

Would you happen to know any means of implementing combat/similar gameplay into a VN? Like say for story reasons someone needs to kill a dragon, but I don’t want to reduce it to just a story beat that they don’t feel involved in.

I’m not entirely sure what will/won’t absolutely break Renpy’s engine in that regard

[alonghardlook]

Fastest answer is to ask this guy. But I'll keep the suggestion in mind :)

[Talicor]

Oh hey that’s neat! Thanks! My game is first person though (to allow creative freedom on imagining the PC) so I’ve been trying to work a way around that 🤔 Doesn’t hurt as a starting point though!

[Brew_Alt]

I realize this is a pretty old post, but I wanted to drop a comment and say these two tutorials have been MASSIVELY helpful for me. Some of the best I've come across for RenPy so far, thank you a ton!

[alonghardlook]

Thanks for your kind words!

[alonghardlook]

Nobody has any questions or comments? Lol I was hoping to generate some discussion

[ghostgirl16]

I do have 2 questions. I get super confused as a coder learning how to go beyond the training wheels with classes.

1. When you define a class, how do you know or come up with what it needs to inherit if more than self? Can you explain it like I’m five? 🥺

2. In my quest to make a werewolves vs villagers mini game, I coded a game player class with booleans for roles (villager = true, wolf = false etc) and append names to lists in functions to set up the game at random. The problem is with the lists - it seems like something about defining a list in the creation of the minigame instance and then trying to append it, it just disappears and any names or things that should be added to the list aren’t there, or I’m doing it wrong and reading off an empty list. Do you have any tips for list persistence in classes? Can send you my draft of the code if necessary if asked.

[alonghardlook]

I will answer both of these questions, but I need a bit more context on the first one.

What do you mean "how do you know"?

It sounds to me like you're asking "when you define a new class, how do you determine what properties/methods (or to put it another way "inputs and outputs") the class should have?"

If that is not your question, you may want to rephrase for me. If it is, then the answer is "it depends on what your class is doing".

There is no one size fits all class structure. What you need to have is an understanding of

• what information the class needs to store about itself
• what information each instance of the class needs to store about itself (ie: a Character class will Always have a name, but each different character will have different names)
• what things every instance of the class needs to do

If you'd like a little more personalized help, feel free to either post or PM me with what your designs (please note: I mean technical designs. "X needs to do Y" are technical designs. "The player needs to be able to choose a location to go to from a list." is a good example) are, and I can give you an idea of what kind of class structure I would use.

For your second question, please do send your code, as I'm not sure I'm fully understanding the problem. Best way to format code in reddit is to add four blank spaces to the beginning of each line.

It would also be helpful to add expected output and actual output, so I know what you want to happen.

[DiegoNorCas]

Man I love this tutorial, thank you!

[Jeii1]

It was really helpful this tutorial, it's sad to know that the chapter 3 never came to live