Verisimilitude In Triggerfish Drill Sergeant: Part 3

See the previous entries: part 2 and part 1.

Putting the Water in Underwater

In part 2 of this verisimilitude series, I discussed two ways of increasing the feeling of an underwater setting. These were:

  • bubbles floating in the background
  • small fish swimming around in the background.

To improve this further, we’d like to have some other sort of anchor for the setting. There’s two obvious choices:

  • the sea floor
  • near the surface of the water.

The sea floor certainly offers up many possibilities, including coral and other creatures.  For a game that’s more action-focused and really wants vibrant background details, this could be an excellent choice. However, this would require a lot of extra modelling and texturing. You can see a little bit that I’ve done here for one of my cut-scenes:


The main issue is that the more specific you make your environment, the more easily it becomes repetitive. If players are staring at the same background “skybox” the whole game, they’re going to notice it.  You’d need to model many different such environments. Leaving a more abstract environment, as I will do, helps to avoid that a little bit, as you can sketch the general idea, while leaving some things to the player’s imagination.

So, it’s time to show the surface of the water!

Beneath the Surface

To show the water surface, we need to figure out four things: geometry, texturing, shading, and animating.


This one’s easy, right?  Just put a flat, (essentially) infinite plane above the parade grounds area and let the camera perspective do the work. I could have done this, and simply repeated the u-v coordinates on an appropriate scale (since my water effect will be achieved by a texture).

Instead, I opted to go with a finite plane with no repeated u-v coordinates, and I use raytracing from the camera to get a consistent size no matter what the size of the level is. I fade out the effect as it gets further from the camera to simulate a horizon. Here it is, untextured:



Next, I need a texture that will simulate the effect of light hitting the top of water. Fortunately, Perlin noise provides a great base for this. Using the excellent Substance Designer, I used Perlin noise as a base, and warped it with a smaller-scale noise to create interested detail. The rest was just changing levels appropriately.


One big advantage of Substance Designer is the ability to generate textures at runtime using the CPU, thus easily animating textures.  By animating the base Perlin noise, this is what I get:




Now I just need to add that texture to the plane I have above. The reason that it’s greyscale is that I’ll be using an Additive Particle shader, to give the appearance of light. Adding it on, here’s what we get:


Great! With the perspective combined with the texture, we have a plausible water surface above us, fading off into the horizon.

Let There Be Light

Another important visual indicator of being underwater are shafts of light filtering through from the surface above.  We’re going to approach this effect in a similar way to the water surface effect. We’ll use a flat, vertical plane placed in the background of our scene, using an additive particle effect to simulate the light shafts. We’ll texture and animate in the same way — and again, use Perlin noise as a base.


The Final Effect

The .gif compression doesn’t do it full justice, but you can get the idea:underwater-light-full-animated

Verisimilitude in Triggerfish Drill Sergeant: Part 2

For part 1, check here.

Verisimilitude In a Tile-Based World

Triggerfish Drill Sergeant is fundamentally a tile-based puzzle game.  The gameplay revolves around fish moving around a square grid of tiles, depending on the type of fish and type of tile.

The puzzle part of the game, therefore, is fairly formal and rigid. But how can we offset this to help the game feel more organic?


In a previous post, I touched on the basic movement of my two main game pieces: fish and tiles. Instead of sitting in place, they float around a little bit, to give a better impression of floating underwater, like this:

Fish and Parade Ground Tiles Floating Around


In the above, I’ve only got a solid blue background to indicate the world that the level resides in.  But what’s beyond it, in the distance? For above-ground games, I could use cubemaps in the form of a skybox to show what’s happening “off at infinity”. However, for an underwater game I’d have to create a sort of “sea-floor-box”, and deal with the horizon. There’s no really handy resources for this sort of thing, and I’m not sure it would be worth the effort to get the right amount of detail. Too much detail and it becomes distracting; too little, and it becomes unbelievable.

My solution: create a background of bubbles. It still gives something in the background for the player to look at, while also behaving in a manner that directly conveys the mechanics of an underwater world as they rise to the top.

Bubbles floating around to form the background.
Bubbles floating around to form the background.

The motion and randomness of this otherwise fairly straightforward particle effect is what really helps to sell things.


Things are looking good, but I want to add another element to help the scene feel alive. What better way to do this than with … things that are alive?

I introduced little small fish that swim randomly past the foreground and background. This adds a nice random motion and further helps to place the scene under water. It also adds a nice breadth to the scene, with fish behind the level as well as in front of it.

Small fish swimming around in foreground and background.
Small fish swimming around in foreground and background.

As a bonus, these are the same fish that set up the parade grounds to its initial configuration, so I get a little consistency throughout my world.

Time To Think

In a turn-based game where the player may be spending some time to think, I think that having some movement in the background is important. This way the player isn’t staring at a static screen until they try to do something. It definitely helped Triggerfish Drill Sergeant to feel like a more complete game.

Triggerfish Drill Sergeant Beta

It’s Beta Time!

It’s been a long process to get here, and I’ve learned a lot. I’m proud to say that Triggerfish Drill Sergeant has hit beta, which means that most of the major work has been done! Now it’s a matter of testing, and smoothing out any rough edges that show up.

Beta Testers

One of the most important jobs left is playtesting, to make sure the game gives a smooth experience with a proper difficulty curve. That’s where you can come in! If you’d like to be a beta tester for Triggerfish Drill Sergeant, just send me an email or enter your email address below.

Your Name

Your Email

I'd like to participate in the beta testing!

And, of course, here’s the trailer:

2D vs. 3D Game Development for Indie Developers

An Explosion of Art Assets

There’s a lot of wisdom in making smart choices to minimize development time. Choosing not to go overboard on your art assets is one such choice.

For this reason, 2D games are quite popular among indie developers. A good artist making sprite or vector graphics can do the necessary world building, made easier thanks to the fixed perspective.

3D Game Development

For many programmers, producing this art can be a struggle, as it is for me. This is one of the reasons I chose to make 3D assets in Triggerfish Drill Sergeant. There are several upsides here:

  • I don’t need to draw anything with a particular perspective – the 3D rendering does that all for me.
  • A single object can be looked at from any angle or perspective without needing new art content.
  • The process of rendering can be divided into three well defined stages: modeling, texturing, and shading.

The last point is what makes this all possible for me: I have the 3D visualization skills to do modeling, and texturing is far more manageable than drawing. There are many good-enough shaders out there, but extra tweaks can be added here.

Going Through the Process

I’ve been using Blender for my modeling. I’m nowhere close to creating something extremely detailed, but I’ve been able to create models without feeling like I was receiving diminishing returns.

Blender snapshot.
Snapshot of in-progress Blender usage.

Texturing is mostly done procedurally using random patterns, as for the fish bumps or scales.

Closeup of in-progress fish scales, created procedurally.
Closeup of in-progress fish scales, created procedurally.

That’s just a brief overview of my experiences so far; stay tuned for more details to come in the future.

Both fish and tiles floating.

Verisimilitude And Polish

What’s new this week?

Although the game mechanics of Triggerfish Drill Sergeant remain mostly nailed down, a lot of work is being done to polish the game and create an intuitive, believable world.


Verisimilitude is the word that captures what we’re aiming for: a world that feels real and self-consistent. It doesn’t need to behave realistically; rather, it enables suspension of disbelief. High fantasy worlds comprise a great example: orcs, elves, dwarves and magic rings are totally unrealistic; however, people understand what they are and expect that they behave in certain ways. The high fantasy framework has achieved a high degree of cultural permeation.

There is no such specific set of expectations for something like Triggerfish Drill Sergeant. Rather, there are two general connections we want players to make.

  1. The concept of drill sergeants: having absolute control over troops, and ensuring they’re able to stay in formations.
  2. The mechanics of an underwater world: how objects would look, move, and behave in an underwater environment.

The first is a connection to the game mechanics, which we’ll analyze in detail another time. For now, I’ll focus on the second: how to make things feel like they’re underwater?

Fish Under the Sea

I started with just a textured model for our triggerfish. It looks fine, but if it’s stationary, it just doesn’t feel alive.

Stationary triggerfish

Of course, holding stationary while under the sea isn’t always possible. To fix this, I added a fair amount of bobbing around the fish’s desired location.

Fish bobbing.

Already this is a big improvement in verisimilitude, and it didn’t take much!

In the Background

The other important change I’ve made concerns the background tiles that make up the impromptu ‘parade ground’ for the triggerfish. When first made long ago, they started off simply:



However, this didn’t really fit in with the underwater theme. We went for the concept of fish netting for the inside of the tiles, which fits the theme and also allows a little of the background to peek through.

Stationary netting.


The frame still emphasizes the square tile and the netting’s color and pattern can help to distinguish different types of tiles.

Putting it all together

Let’s put the fish and the tiles together. Notice the fish wiggling that was added, to convey the motion of slowly swimming. As a side note, this is achieved in fact by a vertex shader, not by model animation!

Two fish floating above two tiles.


It looks good, but the stationary tiles don’t look like they’re underwater. Let’s make them float around a little but, but it should be a little more random than the fish.

Both fish and tiles floating for better verisimilitude.


And there we have it! It’s a start, but already we’ve got a much better impression that these are real objects floating underwater. After all, that’s the goal of increasing the verisimilitude of this underwater world!

Tutorials and Teaching

“Show, don’t tell” is a maxim that applies not only to writing, but to games, as well. Increasingly, games are integrating their tutorials into the gameplay, so players will naturally learn the nuances of the game as they come across the different elements.

For genres like platforming, action, or RTS, where the basics of interaction are a fundamental part of the genre, such an approach can work quite well.

But what about a game like Triggerfish Drill Sergeant, where the structure of your basic actions doesn’t closely resemble other genre standards? In creating tutorials this week, I’ve tried to follow a “show-and-tell” strategy to help players understand what they’re supposed to be doing during the game.

To do this, I’ve tried to guide players through basic actions in the tutorials. The show is that players will still be taking all the actions themselves, as they would during game action. The tell involves a (hopefully minimal) set of written instructions to tell them (a) what they’re trying to do, and (b) how to do it.

Early feedback is that both (a) and (b) are necessary in my case. So, I’ve tried to keep the tutorials quick, so that they don’t take longer than the “initial exploration” tutorials in the aforementioned genres would.

I hope that they’ve worked out! For those who want to give them a try, they’ve been added to the Alpha Demo, which is available for Unity Webplayer here.