I should write a huge text about how is a great language and is getting better all the time.
Just to dilute the stream of negativity constantly appearing on feeds.

Maybe you should too.

Gosh, I sometimes hate that the LSPs are a thing now. People really like to dunk on and its “toolchain” for LSP deficiencies.

Come on, people, this stuff is barely mature by itself.

And you really can do without it.

Subtleties of animation…
Had to slice the effect sprite into fg/bg parts and put them on different layers. And synchronize everything manually 😓

Extracted tile “proxy” data from Tilesetter projects. Makes maps a little less bland.

Visibility is surprisingly tricky. Lots of implementation options, semantic options and how to combine those :blobcoffee:

Switched to map and contour generation from quad tree cells. Those are now correctly represent terrain transitions, not only passable regions.

The thing is more costly to construct, but the map filling is much faster than sampling each tile corner - less duplicate work and big chunks of uniform terrain are naturally aggregated and can be dispatched as one job.

Out of 1M tiles only ~75k are 1-tile transitions that are processed sequentially (presumably while some bigger jobs are chugging in background).

I had a late night thought that my sparse quad tree structure can be split up into a bunch of functors.

And that is indeed the case:

type SparseQuadTree a = Free Quad (Sparse (Range a))And the scaffold/compact functions are “bring your own algebra” now.

Replace Quad with Binary or Octal and you’d get the matching structure.

Going from a dense (but lazy) scaffold to sparse states that in type:

(a -> Sparse a) -> Free s a -> Free s (Sparse a)And the decider is a simple function that isn’t concerned with structure at all, making it reusable.

Awww yisss! Everything* I wanted feature-wise from this tileset:

  • Map declared in Multicolor SDF (lava is the base layer, everything else is boolean’d together)
  • 4-corner Wang tiles extracted from TileSetter project (no, I didn’t do those 96 tiles by hand) (package pending)
  • Per-tile attributes in the “free” vec4 slot. Here - tile speed (also used for passability).
  • A* path-finding with per-tile travel costs (the truck on the screenshot prefers flat terrain as ridges are slow to crawl).

  • I have unused alternative biome tiles… to spice up the landscape 😏

Reading Wikipedia resulted in a slightly different path-finding algorithm than intended.

Behold: A-A-A-A-A*!

(At least it doesn’t jump straight into lava.)

The floor and lava

(There are some kinky borders. Most likely the fix would end up involving a rewrite of the quad-tree structure or something like that.)

Adventures in the BitIndexLand

With no wang-compatible tileset at hand, the tiles are indices themselves.

All the pieces so far:

  • Dynamic tilemap.
  • A minimap view synced to it (using 1px tile atlas for colors).
  • Draggable viewport.
  • Some animated sprites in world-space.
  • Screen-space (yellow) and tile-space (blue) selection boxes.
  • Status frames for sprites caught in selection.
  • The window is still resizable (tilemap re-center appropriately and minimap sticks to its corner with a small padding).

The first Haskell Tiny Game Jam is now open!

Your mission: make games in 10 lines. github.com/haskell-game/tiny-g and the -game chat room await your entries. Good luck!

Animating all you can eat sprites by cranking just one field in uniform. iGPU chews through 10k jumping things at full FPS while remaining responsible (i.e. not CPU-chocked) up into 100k.

(Dynamically updated tilemap chugging in the background.)

Qoto Mastodon

QOTO: Question Others to Teach Ourselves
An inclusive, Academic Freedom, instance
All cultures welcome.
Hate speech and harassment strictly forbidden.