Scarlet Engineering - Devlog

Curves of Fun

2026-02-14T00:00:00Z

Notes of Advanced Game Design: A Systems Approach by Michael Sellers.

Charts are made with Python and Matplotlib.

Games need goals. and the journey of achieving the goals needs to be fun.

The Goal

The goal, e.g. dps required, xp required to level up, etc... is usually an exponential function of the level. They make early levels seem attainable and players go through them fast, while later ones seem at first to be so far off numerically as to almost require superhuamn abilities to reach.

By the time the players start reaching these levels, however, they are also gaining astronomical numbers of experience points, so they feel a continuing sense of achievement in both their individual victories (the numeric rewards do not seem paltry) and in their overall number of experience points gained.

Usually we can just straight up copy the OSRS's exp formula:

E(L) = ⌊(1/4) × Σ(x=1 to L−1) ⌊x + 300 × 2^(x/7)⌋⌋,

which is an exponential function with base ~= 1.1041.

The fun is how the player reach the goal

The player's power/efficiency increase is usually a quadratic polynomial. The gap the goal and the efficiency is where the tension comes from: every level gets a bit harder to reach, but the player also gets more powerful. The player is always making progress, but the goal is always just out of reach.

However, if we only have one polynomial, then there's no decision to be made: the player just keeps doing the same thing over and over again, and the game becomes boring.

Sigmoid/hyperbolic scaling functions comes in handy. They create sub-goals. Each progression method(a level up zone, a crafting recipe, skill unlocks, quest tiers, etc...) can be designed to be the most efficient way to progress for a certain range of levels. The gameplay now have rhythm and variety, and the player can choose which method to use based on their preferences.

They're also a powerful tools for narrative design. Mastering a sub-goal (e.g. a crafting recipe) can provides an additonal bonus to the player. QOL, aesthetic,unlock new content, etc... They naturally open new decisions for the player and expand the world.

Maybe there's a grandmaster quest that requires multiple goals to be reached to solve. or the player needs a certain level of crafting to unlock a new area. The new area needs a certain level of combat to survive. Fighting monsters in the new area gives you a rare materials that can be used for more efficient weapon-smithing... etc. They're all interlinked, and the player's decisions on which sub-goal to pursue will affect their overall progression and experience in the game.

Analyzing the curves

The curves are also helpful for seeing the overall balance of the progression of the game.

You can see the pacing of the game, the difficulty spikes, the efficiency of different methods, etc... Is a new sigmoid needed for level 30-50 because there's no meaningful decision to be made in that range? Is the early game too easy because the player can just grind one method for a long time? Are there any bottlenecks that prevent the player from reaching the later levels?

All of these are over-simplifications, of course. Pretty handy tho.

Murderhorn

2026-02-20T00:00:00Z

I'm a big fan of short incremental games with cool narratives. Games like Digseum and 1,000,000 Shrimps are delightful and memorable.

I made a game that's heavily inspried by them. Try it here:

Murderhorn by Poga

Last week I did my first hiking with my wife. During the trip I keep thinking about an old saying: "You cannot speak of ice to a summer insect"(夏蟲不可語冰). How would a mountain feel when there's all these short-lived humans walking on top if it? Probably nothing.

Hence the game. It's deliberately short. Because we're all just summer insects.

Hope you enjoyed it.
Poga

One Shader, One Mesh, One Island

2026-04-10T00:00:00Z

This is one shader on a flat mesh. No hand-painted terrain, no tile maps. Just math. Here's how it works.

Polygon Regions (water, meadow)
        │
        ▼
┌─────────────────┐
│  GPU SDF Baking  │  Each polygon → SubViewport → signed distance field
└────────┬────────┘
         ▼
┌─────────────────┐
│  Pack into RGBA  │  R,G,B = water regions │ A = meadow
└────────┬────────┘
         ▼
┌─────────────────┐
│  Zone Blending   │  SDF distance → smoothstep → ground/meadow/forest
└────────┬────────┘
         ▼
┌─────────────────┐
│  Water Overlay   │  FBM-distorted shoreline → foam/shallow/medium/deep
└────────┬────────┘
         ▼
┌─────────────────┐
│  Tidal Animation │  lerp(low SDF, high SDF, tide) + per-point wobble
└─────────────────┘

It's All SDFs

The trick behind everything is a signed distance field. For every pixel on the ground, we bake a single number: how far is this point from the nearest coastline? Negative means underwater, positive means land.

That one number drives the entire shader — where the water is, where foam appears, how deep the sea gets, where biomes blend.

We bake the SDFs on the GPU at map generation time. Each water region's polygon gets rendered into a SubViewport using a shader that computes the signed distance from every pixel to that polygon's edges. Then we pack up to three regions into the R, G, B channels of a single texture, with meadow distance in the alpha channel. One texture lookup, four distance fields.

Painting the Ground

With the SDF in hand, blending terrain textures is just a smoothstep on the distance. Close to a forest region? Blend in forest texture. Inside a meadow area? Fade to meadow. The transitions are soft and organic — no hard seams, no manual painting.

The SDF does all the spatial reasoning. The shader just asks "how close am I?" and blends accordingly.

The Water

The shoreline is where it gets fun. We layer four zones by depth: foam at the very edge, then shallow water, medium sea, and deep sea. Each has its own texture, its own color variation, and its own shimmer — subtle FBM noise that shifts over time.

But the real trick is that we don't draw the water boundary where the SDF says it is. We distort it with FBM noise first. That's what makes the coastline look organic instead of following the exact polygon edge. The water seeps into coves and pulls back from headlands, like a real shoreline.

Breathing Tides

We actually bake two SDF textures — one for low tide, one for high tide. Each represents a different polygon shape (the high-tide polygon is larger, eating into the land). At runtime, the shader just lerps between the two based on a tide level value.

Each water region has its own tide level, so different coastlines can flood independently. And on top of the global tide, every point on the shoreline gets its own wobble phase from FBM noise. The water doesn't advance as a uniform wall — it laps and breathes unevenly, like waves on a real beach.

Pretty happy with how this turned out. One flat mesh, a couple of baked textures, and a lot of noise functions go a surprisingly long way.