Slimes and Ooze

In modern RPGs, there are few monsters as iconic as the humble ooze. Enjoying a recent surge in popularity thanks to That Time I got Reincarnated as a Slime, a light-novel and anime of the same name, and their inclusion in dozens of popular titles, slimes have never been more prominent RPG and mainstream culture.

 On a recent project, I’ve had the odd privilege to journey down the short rabbit hole of the ooze’s origins. It was a fun journey learning about the myth, history, and culture behind oozes, but the best journeys are shared. I hope you will enjoy The History of Slimes as much as I have enjoyed researching it.

What is a Slime?

The ooze or “slime” (used interchangeably) is usually a weak monster in RPGs. It is characterized by an amorphous, ooze-like form, and is generally of low or non-existent intelligence. It almost exclusively attacks by ingesting its target, swiping with tentacles, or (rarely) using magic.

Slimes are unique in that they do not derive from classical mythologies. They are recent phenomenon in storytelling and one that’s gaining traction at a surprising rate. Before we uncover their origins, let’s take a journey backward through time.

Slimes in Popular culture

Slimes are prolific in popular culture among the RPG crowd. They are featured in dozens of games, including the ever popular titles:

Dragon Quest 

Dungeons and Dragons

Minecraft

Mother Series

Final Fantasy

Not to mention, anime, manga, sci-fi, and fantasy novels.

The modern tradition of dewdrop, almost amicable slimes in RPGs dates back over three decades to the release of Dragon Quest in 1986, where it was so beloved that it became the series’ mascot. 

In all likelihood, Dragon Quest borrowed the idea of slimes from other RPGs such as “Wizardry: Proving Grounds of the Mad Overlord” (1981) which was a part of a wave of RPGs inspired by the famous “pen and paper” rpg called “Dungeons and Dragons”.

In 1977, the original Monster Manual hit store shelves and in it was one of the most iconic creatures of Dungeons and Dragons: the “Gelatinous Cube.”

Gary Gygax included this cube-shaped monster was mostly a joke: a transparent cube that fit perfectly into the 5x5x5 hallways of the grid-paper dungeons, travelling along and sweeping up anything in its path. It was a magical, monstrous Roomba, before Roombas even existed.

But Gary Gygax did not conceive of oozes in a vacuum, he had a little help to come up with the idea.

Slimes in Movies

There is no more iconic slime movie than the “The Blob“ a 1958 cult sci-fi horror classic, The Blob tells the story of a mysterious thing that falls from the sky and begins devouring everything it can find. As it eats, it grows. Then a group of plucky and unfortunate youths stumble into its feeding ground while on vacation.

At a runtime of 86 minutes, and with special effects that solidify its place as sci-fi cult classic, it’s well worth a watch.

But even Hollywood wasn’t original enough to invent the idea of a slime monster out of thin air.

Slimes in Sci-Fi

Before the cinema, slimes had a far more literary legacy in science-fiction.

One of the most iconic and disturbing representations of slimes was the Shoggoth from H.P. Lovecraft’s mythos. The Shoggoth first appeared in publication in 1929 and is a disturbing monster with the ability to shift its form, imitate speech, and wield its large strength to crush enemies. Perhaps unique about the Shoggoth, was that it was the first time slimes were presented as beings of higher intelligence than humanity.

Despite being a truly terrifying iteration of the slime, the shoggoth is far from its origins.

As early as 1926, we see the slime appearing as villainous monster in The Malignant Entity, published in the renown pulp magazine Amazing Stories. 

During the early 1900s, the slime made a slew of appearance across pulp magazines. In 1923, it even made it to the front cover of Wierd Talesin the story “The Ooze.”

But the earliest recorded usage of slime as an antagonist seems to be in The Odyle a short story published by Charles Edmond Walk in 1907 in The Blue Book magazine.

It’s a story about a scientist who brings life to cells that start growing and just don’t stop. 

At last we arrive at the origins of the humble slime: the amoeba. 

Born in the early 1900s out of an intersection of rapidly growing medical knowledge and human fear of medical science, the humble slime is the embodiment of human hubris gone awry. It is the crystallization of the fear that we have waded too deep into the unknown waters where only gods and darker things dwell and that we have used that forbidden knowledge to make the device of our own undoing.

At least, that’s what the slime was and what it would still be, had not Gary Gygax and pulp movies from the 1950s taken an otherwise intensely threatening concept and transformed it into the humorous, lovable slime we all know today.

Notably, the slime still appears in its amoebic form in many space sci-fi iterations, including the popular turn-based strategy game series Masters of Orion and an episode of the original Stark Trek series: The Immunity Syndrome.

Unique to the space sci-fi version of the slime (amoeba) is that it is almost always large enough to engulf entire ships and sometimes even pose a threat to planets. It always represents an unending hunger and primitive, malevolent intelligence, such that negotiation is never an option.

Conclusion

The humble slime has enjoyed many interpretations during its short life. From the small, but dangerous amoeba, to adorable animated dew-drops, to dungeon cleaning roombas, the slime has been it all.

Outside of space sci-fi and space fantasy, the modern slime enjoys a whimsical feel due to the representation of the slime in 1950s cinema culture, and then again in the pen and paper game “Dungeons and Dragons” which enshrined its position as an iconic and somewhat silly monster.

How will slimes be in the future?

It’s hard to say, but there is a growing slime presence in modern media which, in the past, has lead to exploration and even humanization of mythic creatures, and the humble slime is no exception. Look for representations of slime that push the boundaries between humanity and ooze in a lovable and relatable way.

Happy sliming to you all!

  Do you have additional information about the history of ooze as a monster? Do you have a link to an online-readable version of The Odyle? If so, please leave a comment below.

If you watch any of the manifold streams of D&D and other role playing games, it may seem pretty easy to get into character.

They just do it and it looks so easy.

But as you play you find it’s a bit harder than it seems: scenes rarely play out as cinematically as they do in the podcasts, opportunities to roleplay come so suddenly and go so fast, the scenarios you find your character in are rarely the shining moments of triumph you expected, etc…

Let’s face it, getting into character can be tough, especially if you’re new to the genre. Video games and books provide you with characters with well defined personalities, often developed by an entire writing team. In comparison, most roleplay feels a little … flat. 

And that’s OK! It takes years to become good at roleplaying and improv and even veterans need practice sometimes.

One of the best ways to “warm up” is to try to get into character: imagine how your character would act in a variety of situations to get a good feel for their personality. That way, whenever an unexpected situation crops up during the session, you already know, intuitively, how your character would act.

Ask yourself the following questions:

A day in the life.

Your character is at an inn, waiting for someone: what do they do while they wait?

Your character is running an errand, it was supposed to take 20 minutes, but they’ve been in line for an hour now. Someone cuts in front of them in line. How do they react?

When arriving at the front of the line, the clerk is extremely bureaucratic and dispassionately informs your character that the paperwork has been filled out wrong and she will not be able to help. How does your character react?

Your character just failed a task given them by a friend or relative. You know the task was important to them: how does your character handle the failure? How do they break the news to their friends/relatives/lovers etc…?

  Your character has fallen gravely ill and is bed-ridden for weeks.

What do they do during this time? Visitors are scarce, how do they handle the long, lonely hours? Who comes to visit them the most?

How do they handle facing their own mortality, knowing that each day may be their last and they may die in bed?

  Your character comes into an enormous fortune that cannot be spent on magic items, potions, scrolls, or equipment.

What do they buy? Do they spend like there’s no tomorrow?

Do they try to start a business or invest the money? Do they write a will?

Are they ‘showy’ with their money? Are they generous or miserly?

  Your character is lost in the wilderness for weeks.

Suddenly they come upon a stranger only to discover that stranger is also lost and has no meaningful survival skills; they may even be a liability.

Does your character stick it out with the lost-soul? Do they try to rob them? Do they try strike out on their own to increase their chances of survival?

After some time with this lost-soul, your character begins to suspect that they are hiding a secret and that they came out into the wilderness with a purpose. How does your character react to their intuition? Do they interrogate the lost-soul? Do they mind their own business?

  What is your character’s biggest blind-spot?

All people have flaws that they cannot or choose not to perceive, what is your character’s biggest personality flaw? Can you think of two example scenarios that display this flaw?

What is the one thing your character desires most in the world: is it love, friends, money, redemption, power, or revenge?

At what point would they be willing to sacrifice their friends to get it? At what point would they be willing to sacrifice their money, love, power, or chance at redemption to gain the object of their desire?

    For additional warm-up exercises try to place your character into real life situations of disappointment, frustration, or awkwardness. How a person reacts to these situations speaks volumes about their general personality and will help you to get a holistic view of your character.

The better you know how your character reacts in these circumstances, the easier it will be for you roleplay them in the impromptu flow of the game session.

    0If you enjoyed this article, you may also like 5 D&D Character Ideas and the Paragon of Luck [D&D 5e Build].

This is part 4 of a 4 article series on some useful techniques for making a RenPy game. We’ll show you how to implement a simple inventory system and build an intelligent menu for a shop/vending machine that reacts and responds appropriately to player inventory and stats.

The other articles are listed below:

Stats/Inventory system

Dynamic menus and dialog based off

Stats

Event Triggers

Recursive menus that continue until all options are exhausted

Theme music

Credits

Scrolling Credits in RenPy

In my first RenPy project, scrolling credits was undoubtedly the most difficult problem I faced.

Googling it lead me to a very verbose and seemingly complex, but powerful solution in of about 40 lines of code.

Unfortunately, after playing around with the proposed solution I didn’t get it to work and, being in a time crunch, decided to develop my own technique which uses just 4 lines of code in total.

You can see this in action in the credits for my RenPy tutorial game Dwarf Arte Online (android, PC).

Step 1 – Grab an Image Editor

The first thing I did was open up an image editor, my preferred weapon of choice is the free and powerful GIMP.

I created a credits image with a transparent background, adding the text to the image exactly where and how I wanted it displayed.

This had the added benefit of allowing me the option of embedding images and stylistic designs into my credits, though I ran out of time to do so.

Step 2 – A Few Lines of Code

Once I had my credits image saved in the images folder of my RenPy project, I simply had to create a credits label with the following four lines of codecode under it.

label credits: $ credits_speed = 25 scene black show credits_image at Move((0.5, 1.0), (0.5, -1.0), credits_speed, xanchor=0.5, yanchor=0) with Pause(credits_speed+10)

That’s it!

First we set a convenience variable called “credits_speed” which will be the time in seconds that it takes our credits to scroll.

Then we turn the scene black.

Then we load in our credits image (called “credits_image”) in the center, but just below the screen. Our credits begin automatically scrolling up once we reach this line of code.

Lastly, we tell RenPy to wait for 10 seconds after the credits have scrolled.

While you don’t need to make the Pause that long, the Pause prevents PenPy from moving further down our script file, so it needs to be at least as long as credits_speed or you will cut your credits off in the middle! 

Conclusion

This is a quick, easy, and reliable technique for producing good looking and highly customized scrolling credits in RenPy.

The inclusion of credits as images has no impact on performance and gives the creator total control over the presentation. 

Found a better technique? Let me know in the comments below!

    Looking for more RenPy tips? Want to find good, royalty free music for your games? Looking for quality, royalty free art for your games?

Find all this and more in the Friendly Neighborhood Newsletter.

See you soon!

This is part 2 of a 4 article series on some useful techniques for making a RenPy game. We’ll show you how to implement a simple inventory system and build an intelligent menu for a shop/vending machine that reacts and responds appropriately to player inventory and stats.

The other articles are listed below, links will be added as the articles come out.

Stats/Inventory system

Dynamic menus and dialog based off

Stats

Event Triggers

Recursive menus that continue until all options are exhausted

Theme music

Scrolling credits

Building a Dynamic Menu

At it’s core, building a dynamic starts with a simple “if” statement after a menu choice. i.e.

label vending_machine: menu: "A reshing beverage" if money.level >= 1: "You purchase the bevage, it looks delicious." $money.dec() $beverage = resource(1) "You don't have enough money" if money.level < 1: "You walk away sadly." "Maybe you should get a job?"

Different options will be displayed if the player has certain items or stats (in this case, ‘money’), or if certain flags have been triggered in the game. 

  But what if we want to enhance this menu so that our vending machine/shop has an manageable inventory?

There’s multiple ways to do this: we’ll start with the simple solution that should work for 90% of projects out there and then more into a more advanced solution that is powerful and infinitely extensible, but somewhat more complex.

A Simple Method for Shop Inventory

To give the vending machine its own inventory we first need to use some Python to declare what the vending machine can sell:

$ vending_inventory = ['sword','pizza','potion']

 Now we just need to modify our menu options so that only items not purchased yet show up in the menu:

label vending_machine: menu: "A sword, you're not really sure why it's in the vending machine." if 'sword' in vending_inventory: $vending_inventory.remove('sword') "The sword clanks out of the vending machine." "A pizza...it has pineapple on it." if 'pizza' in vending_inventory: $vending_inventory.remove('pizza') "The machine yields the pizza. Hopefully you won't regret this." "A potion, it might be too strong for you to handle." if 'potion' in vending_inventory: $vending_inventory.remove('potion') "The potion rolls out of the vending machine. Cherry flavored, alright!" "It seems to be empty.You bought everything!" if len(vending_inventory)==0: jump some_other_menu

As each option is ‘purchased’ by the player, it disappears from the menu. When the menu is empty a special option to leave the vending machine is shown.

This allows us to re-use the same menu each time the player visits the vending machine.

Since the option to leave the vending machine is revealed only when the player has purchased everything, this will force the player to purchase everything before leaving the machine. If you do not want this behavior, simply remove the “if len(vending_inventory)==0” from the last option and the player will be able to walk away at any time.

This method is good for very simple shop/inventory dynamics, but it becomes difficult to maintain. If you put in the code for purchasing items (deducting ‘money’) and adding them to the player inventory, it gets to be rather long and difficult to read.

At that point if you decide to change something, you’re now hunting through lines and lines of messy code just to change it!

If your game is large, this could be exhausting.

A Power Method for Inventory and Stats

We can make our life’s easier in the long run if we’re willing to put in a little bit of work upfront. 

In the last tutorial we declared some Python code at the start of our sript.rpy file. We’re going to do that again, but with some modifications:

###custom python stuff init python:#declare a python black so we can write python code class Player:# a generic class to represent the player def __init__(self): self.stats = {'love':0,'money':0} self.inventory = {'cookie':1} def change_stat(self,stat,modifier): self.stats[stat] = self.stats[stat] + modifier def change_inventory(self,item,amount): if item in self.inventory: self.inventory[item] = self.inventory[item]+amount else: self.inventory[item] = amount player = Player()#a player object class vending_machine(self):#generic vending machine class def __init__(self):#declare default vending machine inventory self.inventory = {'cookie':3,'rusty sword':1} self.costs = {'cookie':1,'rusty sword':5} def player_can_afford(self,item_name): if self.costs[item_name] > player.stats['money']: return false return true def purchase(self,item,amount=1): player.change_stat('money',-self.costs[item_name]) player.change_inventory(item,amount) self.inventory[item] = self.inventory[item] - amount def has(self,item): return self.inventory[item] > 0

This time, we’ve consolidated stats and inventory into a Player class which has 3 methods:

__init__(self): this method set our default stats and inventory for the player in this case, love and money are 0. Fortunately, our player starts with a cookie.

change_stat(self, stat, modifier): this method adjusts a stat by a given amount.

change_inventory(self,item,amount): basically the same as the above method, but modifies inventory instead.

This gives us an intuitive way of interacting with player stats and inventory. i.e.

$player.change_stat('love',2)#add two love $player.change_inventory('used napkin',1)#gain one used napkin

Now we combine this with a vending_machine class which has the following 4 methods:

__init__(self): this method sets the default inventory and cost for a vending machine object. This is useful if you want all vending machines to have the same cost or carry the same inventory.

If not, you can always override the inventory and cost variables for your specific vending machine. If you’re comfortable with Python, you may even modify this method to take inventory and costs as an argument.

player_can_afford(self,item_name): this method gets the cost of the item_name, if it is more than the player’s current money it returns false otherwise it returns true. This will be useful in the next section when we put it together in a dialog menu.

purchase(self,item,amount): this method handles the transaction for us: deducting the items from vending_machine inventory, deducting the cost from the player, and adding the item to inventory.

has(self,item): a simple method that checks if the vending machine is sold out. Useful for cleaner code in dialog menus.

This technique allows us to declare our vending machine inventory and costs in one, single spot at the top of our file, making it trivial to locate and adjust it on the fly while keeping our dialog options uncluttered by cumbersome transaction code.

Putting it together

Now that we’ve created meaningful player and vending_machine classes, let’s put them to use in a smart dialog menu:

$shady_vend = vending_machine()#this is here for convenience, it should be declared in the initial Python block at the top of the file label shady_vending: menu: "Cookie $[shady_vend.costs['cookie']]" if (shady_vend.player_can_afford('cookie') and shady_vend.has('cookie')): "You buy a delicious cookie". shady_vend.purchase('cookie') jump shady_vending "All out of cookies." if not shady_vend.has('cookie'): jump shady_vending "Cookie $[shady_vend.costs['cookie']]" if (shady_vend.has('cookie') and not (shady_vend.player_can_afford('cookie')): "You are too poor to afford this cookie =( jump shady_vending "Rusty Sword $[shady_vend.costs['rusty sword']]" if (shady_vend.player_can_afford('rusty sword') and shady_vend.has('rusty sword')): "You buy a delicious rusty sword." shady_vend.purchase('rusty sword') jump shady_vending "All out of rusty swords." if not shady_vend.has('rusty sword'): jump shady_vending "Rusty Sword $[shady_vend.costs['rusty sword']]" if (shady_vend.has('rusty sword') and not (shady_vend.player_can_afford('rusty sword')): "You are too poor to afford this rusty sword=( jump shady_vending "leave": "This machine's a little shady" jump get_outta_here

Thanks to our convenience code, our smart menu turned out fairly legible: an option is shown if the player can afford it and it is not out of stock. The player can leave the vending machine at any time by choosing the “leave” option.

It will look something like this:

>Cookie $1

>Rusty Sword $5

>leave

Once a player purchases an item, all the inventory and money code is handled generically with the ‘shady_vend.purchase’ method. We then jump the player back to the same menu which will now update with the new inventory.

Next Steps

There’s a lot of potential next steps for this technique. You may want to show the number of items available for purchase in the dialog menu using RenPy’s string substitution [] technique. 

You may want to take it a step farther and create a method that generates the menu option text dynamically based on if it’s sold out or if the player can afford it. Right now we are still using 3 dialog options for each possible eventuality:

In stock, but the player can’t afford it

Out of stock

In stock, and the player can buy it

By adding in another convenience method, it is possible to condense these down to two functions that return the appropriate dialog and call the appropriate code.

  Check out our next RenPy article on using music in your game!

This is part 1 of a 4 article series on some useful techniques for making a RenPy game. We’ll show you how to implement a simple inventory system and build an intelligent menu for a shop/vending machine that reacts and responds appropriately to player inventory and stats.

The other articles are listed below, links will be added as the articles come out.

Stats/Inventory system

Dynamic menus and dialog based off

Stats

Event Triggers

Recursive menus that continue until all options are exhausted

Theme music

Scrolling Credits

Stats and Inventory in RenPy

If you’re reading this article, you’re interested in the fastest, most efficient way to set up stats and/or inventory management in RenPy and how to use stats/inventory to impact the player’s experience and dialog options.

Python

The easiest way to implement S&I (Stats and Inventory) is to simply declare a Python code block at the top of your scritp.rpy file. Here’s an example from the sample RenPy game found here:

# The script of the game goes in this file. ###custom python stuff init python:#declare a python black so we can write python code class resource:#this is a convenience class for handling resources def __init__(self, starting_amount): self.level = starting_amount def dec(self): if self.level > 0: self.level = self.level - 1 def inc(self): self.level = self.level + 1

The init python: block tells RenPy that the following lines will be python code.

I use the concept of a resource in this example which could be currency i.e. 50 gold coins, a stat i.e. 18 HP, 32 Heart, or even a single use item i.e. The Master Key. A resource is simply anything that we need to track if the character has it (or not) and how much they have.

For convenience, we create a resource class that is going to handle how accruable resources behave. In this case we defined three methods for resources.

__init__:

This is a special Python method that handles how the class is instantiated. In this case, that means how we create new resources for our Player Character.

def __init__(self, starting_amount):

We can create a new resource “love” later on using the following code:

love = resource(0)

dec:

This function handles decreasing our resources. We put a simple check in the function to make sure that resource values do not go into the negative.

inc:

This function is used to increase our resource. In this case, I never wanted to increase or decrease by more than one, but if you wanted to, say if the character has a job and has just earned $100 you could use something like this:

def inc(self,amount=1): self.level = self.level + amount

where amount will default to 1 if we do not provide one.

Creating the Resources

When we put it all together, we can now declare new resources in two different ways. 

Inside a Python control block (recommended for stats):

label start: python: love = resource(0) booze = resource(0) money = resource(0)

or inline using RenPy’s $ syntax for single line Python:

$love = resource(0) $booze = resource(0) $money = resource(0)

Making Magic Happen

Our S&I system is all setup and ready to go. It’s time to put in in action.

Thank’s to RenPy’s fantastic support for conditional statements, this turns out to be pretty trivial.

Let’s say we want to show different dialog choices base on a certain resource i.e. money:

label vending_machine: menu: "A reshing beverage" if money.level >= 1: "You purchase the bevage, it looks delicious." $money.dec() $beverage = resource(1) "You don't have enough money" if money.level < 1: "You walk away sadly." "Maybe you should get a job?"

In this example we present the player with two choice menu options: “You don’t have enough money” or “A refreshing beverage”.

If the player has less than 1 money, they will see only the “You don’t have enough money” and then be derided by the game.

If they have at least 1 money, then they will only have the option to choose “A refreshing beverage”. Once they choose it, the player’s money is decreased (by 1) and the player gains a new beverage resource.

  Next Steps

If the player’s going to be purchasing things frequently, consider creating a purchase method that checks to see if the player has enough money. If the items are unique, or there’s no need for the player to have multiple items, consider writing some generic “gatekeeper” code that informs the player they are A) too broke B) already have the item or C) have successfully purchased the item.

In the next tutorial, we’re going to implement an inventory and purchase system for our vending machine that does everything listed above.