Hey everyone! I hope you enjoy this little sneak-peak at how we create our mobs. Since the last blog-entry we made a lot of progress, and even have a shiny new steam-page, so be sure to check it out:
Before I became a developer myself I always wondered how video game creatures were made. With this blog post I hope to shed some light on the steps involved to create lively, responsive mobs.
In Weaving Tides the whole world is made of cloth and most of the time you fly over woven ground. By diving through the surface you do not only switch sides but also create a ribbon stitch - our core gameplay mechanic.
These initial conditions are the base for some very interesting and unusual mobs that inhabit this world.
Gamedesign & Prototyping
One of the first mobs players will encounter is a simple, dog-like creature that follows very specific rules:
- only walk in a straight line between two points
- on collision with an obstacle or other creature: turn around
- on collision with player: bite!
- on collision with a hole: switch surface side
Now that the rules are defined, we can start prototyping. For this kind of work we use a Unity plugin called Playmaker. You can imagine Playmaker as a visual way of writing code.
In Playmaker everything revolves around states & transitions: If we think about our little dog-creature, which states would make sense? How could their transitions work? Here you can see my notes on this particular question:
- Wander (our dog patrols between two points)
- Attack (hit the player!)
- Turn (hit an obstacle or other mob)
- SwapSide (fell into a hole)
- Stitched (got stitched!)
- Hurt (got dashed!)
Transitions are really important not only for gameplay but also for responsiveness: what happens if the dog is stitched and shortly after gets dashed through? Can I stitch the dog during its surface swap or during its attack?
As a rule of thumb we like to enable as much interaction as possible: if you do something there should always be some kind of response - action and reaction. If nothing happens when you clearly did everything right, it can feel like a bug.
This is how the prototype looks inside of Unity - it's a little bit more complex than the initial setup on paper but the basic idea remains the same:
Animating states & transitions
Although it's fun watching these blocks slide around it is time to create our real mobs! At this stage we usually have concept art that we can use as guideline for the next steps. Here is a short overview of the workflow:
Bite & Anticipation
This is a good example for transition animations: if the dog collides with the player it does not instantly attack but rather wiggle with its tail first. It's important that the wiggle animation is loopable, so we can easily adjust timing & speed at later stages inside Unity.
Furthermore our eyes are trained to be attracted by fast moving objects, because in nature it could mean danger. So its a good idea to use fast motion for our bite & anticipation animations.
If our dog gets stitched to the ground, this animation will be played. This is a good place to mention another thing we have to keep in mind: the fixed camera angle. Most of the time you will see the mobs from a certain distance and angle, so the shape should be easy to read under these circumstances.
This special "flip" animation will only trigger if you manage to turn over the dog by diving into it from below. It will then stay in this state for a few seconds or change the state if it gets stitched or dashed.
Integration into Unity
Last but not least we need to hook up all transitions & events with their corresponding animation inside Unity. This can be a very time-consuming task because every character is different, and there are many values to tweak. The process itself looks similar to what we did with Playmaker earlier:
Here you can see the final result in action:
Thanks for reading! Let me know if there is something you would like to see covered in future blog posts.