The next incremental version of Worldbuilder is now out. No huge changes to planet generation itself, but the user interface has received some significant improvements in terms of usability. Some of this stuff is really standard, and sort of feel bad that it wasn’t already in early versions, so I apologize that it took this long to become available. But the program continues to get polished up, a little here, a little there, so I hope your experience will keep getting better.
As always, a demo is available for download, and the full product can be purchased from the store page. (Once purchased, you’ll continue to have free access to future updates.) If you have already purchased Worldbuilder, the downloads can be found here. (more…)
Today brings a new version of Worldbuilder! The primary focus has been on the presentation of the planets. Much work has gone into getting away from being limited by a low-resolution triangle mesh during rendering, and instead doing far more on a per-pixel level. It has also made it significantly easier to add lighting and to handle a wider variety of map projections.
A demo is available for download, and the full product can be purchased from the store page. (Once purchased, you’ll continue to have free access to future updates.) If you have already purchased Worldbuilder, the downloads can be found here. (more…)
So as to not leave you with only the dryest of dry content, I shall also whimsically include a distance field that was produced from a randomly generated tectonic plate. Black indicates regions that are outside of the tectonic plate, and the grays of increasing intensity specify the distance of each pixel to the nearest edge of the tectonic plate. The closer to white a pixel gets, the further it is from the nearest border. There’s a lot I’ll be able to do with this information!
You can see a couple more pictures related to distance fields and planet rendering in my recent tweet.
As I mentioned earlier this month, I’ve been encouraged by the interest in my planet generator experiment. In particular, I was surprised and excited by the wide diversity of interest outside of strict gaming and game development circles. This interest led a friend to suggest the possibility of developing a fully functional professional tool based on the experiment that had been predominantly intended for use in a strategy game.
After recovering from this month’s Ludum Dare game jam, followed by research, planning, and some early development, it appears that I’m definitely proceeding with this project. In terms of determining core features and priorities, I’m taking fantasy/sci-fi authors as my primary target audience, to aid them in their worldbuilding efforts. But the intention is that the software will be quite engaging for worldbuilders and map aficionados in general, as well as for those interested in procedural generation. (more…)
Tl;dr: If numerical determinism is important for your application, never use a PRNG to generate more than one function parameter at a time.
I just got bit by C++’s unfortunate underspecificity regarding the order of evaluation of function parameters. I was working on adapting a procedural generation algorithm (based loosely on my planet generator code) from floating point numbers to fixed point numbers. The goal was to ensure that regardless of compiler, OS, or CPU architecture, the same code would generate the same planet, if starting from the same pseudo-random number seed and using the same generation parameters. Despite IEEE 754 being an extensively designed and very mature standard, in practice there are more than enough other variables at play to make floating point unreliable from machine to machine if exact replication is required. Just search for “floating point determinism” for plenty of examples.
Quite obnoxiously, but not unexpectedly, the results with the new fixed point code were substantially different from the floating point results. Not completely different; I could tell that some steps were behaving nearly identically, which proved that most of my fixed point code was functioning correctly. Tracking down the source of the discrepancy was harder. Was my implementation of a cross product backwards, leading to blatantly wrong vectors? Or was it something more subtle, such as a chaotic variable tipping just enough across its threshold to lead to radically different behavior? (more…)
A lot of different steps go into generating the planet, utilizing a variety of algorithms and techniques. They’re not perfect, and some of them are in fact quite finicky, requiring a lot of cautious tweaking of parameters and behaviors. Some of them are bad enough to make me cringe. But they work. At least well enough to make some pretty pictures, and some planets with enough variety that they might be a half decent foundation for some strategy mechanics. So in case anyone might be able to glean some useful ideas from my work, allow me to delve into some of the details (and include tons of colorful pictures along the way). (more…)
Ludum Dare is over, and my entry, Symptomatic, can be viewed here. (If you want to judge the entry on the Ludum Dare site, you can find it here.) The non-competition jammers are probably wrapping up their 72-hour game jam entries as I type, but having done the 48-hour competition, I’ve had the luxury of relaxing for a full 24 hour already. Time to look back and reflect. (more…)
More than halfway through the competition, and I can only now finally interact with the program. I guess I’ve gotten to the point where I’ve made the toy. And I’ll admit, it’s kinda fund just doodling around with the path. A little confusing at times, though; it isn’t the most intuitive interface. Ah well.
Now to add in the disease and symptoms, in order to give the player some information to go off of, in order to guess at the actual channel arrangements.
I now have a notion of a game world, consisting of both the actual state of cells and their channel arrangements, as well as the player’s guessed arrangements. (Not that there’s yet any interface to let the player guess.) Here’s the latest screenshot; click for a full-size version.
To be honest, I’m surprised that there aren’t too many small cycles. Pure randomness already does a decent job of generating long meandering paths. I was worried that I might need to massage the random data some to get it into a more useful form, but I might be able to work with this as is.
As indicated in my previous post, I’m currently going for a game loosely inspired by Minesweeper and SpaceChem. So I have routes that an object will follow, as in SpaceChem, and these routes will be hidden by default, but the player will guess what they are based on other information, as in Minesweeper.
Colors don’t mean anything, but are just to help distinguish overlapping paths. I might remove them if I find that a single color or style is still sufficiently clear. Adding borders along the channel edges might be enough.
This was just rendering. Next step will be to get an actual concept of the game world created, and then determine my input model. After that, it’ll be time to introduce a pathogen.
Residential, commercial, and industrial zones along a few roads.
Two and a half weeks ago I found myself in a bit of a difficult situation. I was satisfied for the time being with the knowledge I had gained from my pathfinding experiments, and there had recently been some good discussion on Simtropolis regarding traffic simulations. I was left with the question, “What next?” It was a more difficult question than I had anticipated.
After flailing around for a few days, I decided two weeks ago to force myself to do some project planning; I obviously needed the guidance. I had to go through a few stages that I’ll describe below before I had any kind of actionable plan, but what I eventually ended up with was a three week plan. By the end of the three weeks I hoped to have a city builder prototype with what I considered incredibly primitive implementations of the most core elements of what I currently envision as the end product.
Project planning in software development (and other fields, I am sure) is notoriously difficult and unreliable. I’m sure people often question its value. When I came up with my three week plan, I noted on Twitter that it would probably be completely inaccurate by the time the three weeks were up. But even if that were true, it had real value because it gave me a place to start; it gave me traction when I had been spinning my wheels. I am now about half way through that plan, and things are going well. (more…)
Over the past week, I’ve been working on a traffic simulation prototype in order gauge the feasibility of various levels of simulation detail, given typical computation and memory limits of a consumer computer. I’ve made some progress on getting an initial unoptimized representation of the data structures needed, and visualizing the results of basic pathfinding.
But as is usual for me, although my first attempt at writing the A* algorithm for this particular data representation doesn’t violate any legalities of following the graph edges, it most definitely does not reliably find an optimal path, as the image here demonstrates. Three quick right turns would be sufficient, but nope, it has to go through an intersection, make a left turn at another intersection, then a couple of right turns, go back through the intersection where it turned left, through the first intersection that it originally passed, right by its starting point, a final intersection right turn, and then it arrives at its destination. Brilliant!
You can examine some other silly paths on the prototype page. Now to find out what’s causing this absurdity.
After recovering from Ludum Dare, I resumed work on my 4X space strategy prototypes. In particular, I wanted to rework the interface before continuing with mechanics, switching to a two-panel layout, with an overall galaxy map in one panel, and then a details panel for whatever object is selected in the galaxy map. I also chose to have some fun with higher quality graphics, using some of the knowledge I gained during Ludum Dare, and made with the assistance of POV-Ray. Prototype #3 was the result. (more…)
Ludum Dare #28 has concluded, and our official version has been completed. You can head over to the Ludum Dare entry page to rate it. I didn’t get as far as I would have liked, but the important stuff made it in. Hearts, a gun, sound effects, music, a loading screen, and a couple more levels.
The music takes up a bit of space, so for convenience, this game comes in three variants:
Artist mockup. Alas, my “game engine”, if you can call it that, isn’t yet up to the task of fully reproducing this.
Our entry for Ludum Dare #28 reached a proper playable state today, and I’ve had the chance to integrate graphics from Joshua. Gone is my functional but primitive stick figure. Say hello to Mr. Blue Hair and Magenta Undies!
This is the ninth version so far. All versions have been preserved, and can be viewed on my Ludum Dare #28 page.
Jumping to the left. The arrow through the stomach is painful, but it points the way forward.
Ludum Dare #28 is underway, and so is my entry. My collaborator Joshua Skelton (@JoshuaSkelly, artist for Delver) is hard at work cooking up a visual theme. In the meantime, I have a few very ugly early versions available to peek at, as well as a prototype I did earlier in the day as preparation and practice. Check them and future versions out here.
We’ve decided to do a platformer. I know it’s been done to death, but I actually have never written one, so I thought it would be a fun exercise. So far I have gravity, the ability to fall onto and stand on a platform, running left and right, friction on the platform, jumping, manually falling through a platform, and the special mechanic for Ludum Dare’s theme (“you only get one”): A one-time only ability to invert the behavior of platforms. Blue platforms behave one way, and red platforms a different way. Using the invert ability will instantly swap colors and behaviors of all platforms in a level. (more…)
Hard-coded universe. The red faction can no longer see the Beta star system.
I was finally able to get the (first) rewrite of the space strategy prototype to a presentable stage. Which currently just means that you can give movement orders, end your turn, find out what you discovered, and continue doing so to your heart’s content. (Your heart will become contented very quickly, I have no doubt. It’s a tiny galaxy.)