Devlog 11: Progress, Remembering Things, Animations

First of all, a little update on our progress. It’s been a while since the last devlog post, and even longer since we had some real progress to report on. But, finally things are moving forward again!

We now have the first three rooms roughly laid out, and moved on to refining the puzzles and interactions! Also, we have a working title! We’re calling it Pancakes for now.

As usual, here’s a few things I’ve learned along the way.

Making the Game Remember Things (with Popochiu)

Sometimes we want the game to remember things. You know, in saved games, and also when exiting and entering a room again. If you move an object, explore other places and then come back, you expect the object to be where you left it, in its moved position.

Now this might sound trivial, and to somebody with some coding experience this might indeed be so. For me this was a bit of a challenge.
If you’re in a similar situation, here’s how it works:

First of all make sure to add all the variables you need to your Popochiu prop, in my case I wanted to store two things:

var has_moved := false
var stored_x_pos := 0.0

The first variable is to remember if the thing has moved or not, the second stores its position. One thing I was doing wrong was writing var has_moved = false, but I’ve just learned that you need to add that extra “:” so Godot does not get confused.

Even better would have been to write:

var has_moved : bool = false
var stored_x_pos : float = 0.0

In this case you’re telling Godot what kind of variable you are storing, avoiding any type of confusion.

I have scripts that move the prop around and set the has_moved variable to true once it was moved.

Now the next thing is that you want the prop to be moved to the correct position when entering the room.

This we can do inside the room’s _on_room_entered() function, in the room’s main script, i.e. in the root node script. The Popochiu dock gives you quick access to this script (it’s the little scroll icon).

Anyway, here’s the code:

if R.get_prop("PropName").has_moved == true:
  R.get_prop("PropName").position.x = R.get_prop("PropName").stored_x_pos 

basically I first check if the prop has moved or not, and if it has, I apply the new position (which we can safely assume is its most recent position before we left the room). The reason I check if it has moved or not is because we are only storing the position when the object moves, so until it does so the variable will be undefined. Also, I needed that variable anyway.

And another thing I’ve learned: When addressing a prop (a scene within a scene) you need to refer to its “script name”, not the name in the outliner, which might be different

As you can see each object gets both a “script name” and a “description in Popochiu, and these can be different.

Controlling Multiple Props at the Same Time

Popochiu has a whole bunch of handy commands, that make your life easier. You can for example get quick access to a prop by using:

R.get_prop("PropName")

This can be useful to do all sorts of things, like for example hiding a prop, storing/reading its variables, or moving it around like we have seen above.

You can also do stuff with all the props using get_props()

But what if you want to control large amounts of props but not all of them? Let’s say you have 40 props in a room and want to disable half of them? In that case you can use Godot’s groups. Basically you assign all the nodes to a group (called “GroupName” in my script example below). To do so you select a node in the scene outline, then in the inspector, go to the “Node” tab, select the “Groups” sub-tab.

Unfortunately there does not seem to be a way to assign multiple nodes to a group at the same time (but let me know if I’m missing something here!)

Anyway, once you have your groups set up you can use this code to disable them:

var objects = get_tree().get_nodes_in_group("GroupName")
for prop in objects:
   prop.input_pickable = false

Of course, you could do all sorts of other things, this is just an example.

Animating in Godot

This is something I had been wanting to test for some time, but somehow never got around doing so. Godot has basic 2D rigging capabilities and I wanted to see if these would be enough for me.

So far I have been animating everything in Blender and importing/playing the animations via sprite sheets. While this lets me use a very powerful software like Blender, it makes the workflow a bit cumbersome and adds a lot of image data to the game. It would be much better to have a couple of rigs right inside Godot that I can animate.

As usual, there’s pros and cons. Here’s my initial impression:

Pro

• You can do everything right inside Godot, which makes iterating on things easier.
• It’s easier to see how the animation fits inside the scene.
• You can quickly make variations of an animation.
• In theory, it should make the game smaller.
• Speed changes are fluid, since they don’t depend on already rendered frames.
• It’s native 2D rigging, which makes animating a bit easier than in a 3D software like Blender.

Cons

• Rigging is pretty basic. It’s just bones and weight painting.
• You basically have to draw your mesh (which you will use for weight painting) by hand.
• There’s no “controllers” or “constraints”, only bones. Although you can use scripting to work around that I guess.
• The UI is a bit clunky and sometimes buggy.
• Of course there’s no equivalent of Grease Pencil, but who said you can’t mix and match rigs and sprite sheets?

I’m still trying to figure this out, so I’ll probably report back once I’ve done a few animations.