The past month's seen some complications, so I've been coding rather than writing updates, but the game jam is over now. Unfortunately, I did not finish the gameplay coding. Said complications tightened the schedule too much to achieve my design plan and I was unwilling to compromise my personal goal for the project: generating world maps that wouldn't look out of place in a Tolkien-style fantasy book.
Still haven't been updating this blog, but I'm still doing game jams and working on various side projects (like Cove). The latest is the Big Awful Jam being hosted by the Something Awful Forums. It's a one month online jam for teams of 1-4 people based on a particular theme. This time around, the theme is "Games for Grandpa."
My project's angle is to alter the role of the protagonist in a typical fantasy RPG or roguelike. Most games are built around the youthful hero going on a quest to save the world. What about a game built around the wise old sage who gives quests to heroes? It's not a completely new idea - I'm sure that I've read about games that do this sort of switch-up - but it should be interesting nonetheless. So instead of wandering around slaying monsters and exploring dungeons, you go around studying, advising, and telling tales to motivate and guide would-be adventurers in the right direction to save the world. The goal will be to guide various artifacts of power into good heroic hands before the return of the eeeeeevil dark lord (whose existence no one else believes in until too late, of course).
So that's the concept: a Gandalf-sim. Next is figuring out the framework: what player actions are available, what NPC actors to simulate, and what sort of world generation to surround them all.
I’ve been lax in updating this blog in real time over the
past few months, so it’s catch-up time now that the holidays have arrived (and
now that someone might actually read it).
First up: Cove!
Early development began with experiments on different ways to turn a blocky grid of cell data (so far simple true/false flags as to
whether each cell was solid) into a semi-smooth mesh. Some experiments were more successful than
others, but I did arrive at a point that I was reasonably happy with for mesh generation. What I struggled with for quite a while was
finding a lighting system that I was content with, since the built-in Unity
vertex lighting simply did not want to cooperate with a mesh like this (eventually I had to de-link each triangle to get the automatic lighting to treat it nicely). Further, I hadn't even begun to do real cell data generation algorithms. Here are some screenshots from back then:
Debug objects showing cell locations:
Steps in night/day lighting effects:
Testing noise on a slope.
Testing alongside Unity water - kinda neat, but not the right style:
That's as far as it got; Cove’s been sitting in stasis for a few months now because
I started participating in game jams (both in person and
online). Between jam projects and
various life events, I’ve not found the mental energy to return to Cove. It's not dead, but it’ll probably sit in the
background for a while because some of
the jam projects feel like they have more immediate potential. More on those jam games next.
Cove (temporary working title) is meant to be an exploration
game that will allow players to interact without mechanics of conflict. Players will explore an ever-shifting
algorithmic world which only lasts as long as a player is present. Along the way, they will discover McGuffins
(again, just a temporary term) which can then be placed to prevent that small
area from changing. Players can thus
share locations that they consider interesting or pleasing, slowly building a
stable world out of algorithmic chaos.
The landscape is intended to be both an aesthetic experience
and to offer algorithmic movement puzzles. Cove will not be a game of pressure; players will
not be threatened by failure states (death or similar) and the main constraining
resource will simply be time spent playing.
That said, not all terrain configurations will be equally quick to traverse. While falling or drowning will not be lethal
concerns in Cove, gravity and basic physics will still be a factor in movement. Cliffs, waterways, broken terrain, and dense
forests – all will consume more time, and demand more roundabout routes, to
traverse than flat plains (which will be uncommon due to its inherent simplicity). In theory, once a player encounters an
interesting spatial puzzle (or easy pathway to another stable area) that player
can then “lock” the location into permanence via McGuffin to share the
Each game world will be saved as a file which can then be
loaded for play, either locally for solo play or on a server for multiple
players to explore simultaneously. The
game will generate, in real time, terrain chunks around the players’ locations
(probably drawing on the players’ computers for at least some of the
calculations, otherwise scaling would probably be a nightmare). This terrain will stay in place as long as
the players are within a certain distance, at which point the chunks will be
deleted. The exception is McGuffins; the
chunks around them will be locked in place and saved, and while they may need
to be de-instantiated (we’ll see about performance) they’ll simply be re-created
from the saved data when a player approaches again.
That’s it - aside from the technical meat of terrain
generation. The mechanics described
above form a framework within which I can explore algorithmic world generation. I’ve previously done infinite real-time terrain-generating
tech (albeit not in a multiplayer game), so that’s not what’s most interesting
about this project. The terrain algorithms
themselves, and ways to render and display them, are what most interest me. This project began from thinking about
different methods for forming algorithmic terrain, so I’ll have a lot more to
say about that as this project gets underway. Such posts will hopefully
make up the bulk of this blog for a while.