ROMVLVS Development Blog @romvlvsgame-blog - Tumblr Blog

Imgur: The most awesome images on the Internet.

Yeah the GIF takes a while to load, but at least you get a sense of what the engine is capabe of at the moment. I use Numpy to handle all the low level storing of data which is pretty fast - even at this size, I haven't had any scaling issues so far.

ROMVLVS engine philosophy

In short, I aim for ROMVLVS to be some sort of SimCity++, taking you from prehistoric to modern times while also invoking some Civ-like concepts such as research and warfare.

ROMVLVS, like the original SimCity, leans heavily on the idea of cellular automata. Basically, simple rules governing the contents of tiles lead to very complex behaviour.

The original concept popularized by Conway is very binary (either life exists on a tile or not); SimCity made use of difference equations in order to increase or decrease the quantity of e.g. population on a tile. This is the same in ROMVLVS. A simplified set of equations might look like this (x and y are quantities to be increased/decreased, t is time, t+1 is the time at the next turn):

x(t+1) = x(t) + C1 * x(t) + C2 * y(t) y(t+1) = y(t) + C3 * x(t) + C4 * y(t)

In SimCity you were free to build wherever you wanted, as long as you had enough money to do so. The existing infrastructure generates taxes, which fills the city coffers.

In ROMVLVS, there is no money. Or, at least, not centralized. If you don't have resources available in a specific tile to build something, you can't build it, even though it's available on other tiles.

So how do resources spread around? This is where dispersion comes in place. Think of an inflatable pool in your back yard. When you pierce it, it will empty out in rapid pace, flooding its surroundings. The more time goes by, the more dispersed the water is, eventually flooding your entire garden with a thin layer of water.

In ROMVLVS, dispersion works as follows: if you have a farm producing 1 unit of food per turn, a small percentage of that (say 10%) gets dispersed to the four surrounding tiles. Your farm will be left with 0.9 units while its neighbors get 0.025 units each. Those neighboring tiles will disperse 10% of 0.025 to their neighbors in the next turn.

In order to keep infinitisemally small amounts of resources spreading around the map, there's a dispersion threshold.

At the beginning of a game, you start with a Settlement and 5 people (all living in the Settlement). The Settlement produces Culture (quite an abstract resource) which starts spreading outward over time. The difference equation governing the growth of people is such that Culture is a positive factor - i.e.:

Humans = Humans + CULTURE_FACTOR * Culture

Now, resources like Food have also a similar positive influence whereas proximity to enemies, extreme temperatures etc. will negatively impact human growth.

This basically describes the ROMVLVS engine. The trick is to balance out all the different resources: adjusting growth and dispersement parameters, adding buildings that modify growth even further, and adding resources that counterbalance other resources. So far, only Culture, Humans, Food and Wood are "active" resources that can be altered; I've thought about adding things like Disease, Fear, Stone, Bronze, Meat, Fruit, etc. etc.

Hope you enjoyed this behind-the-scenes look!

#romvlvs #engine #mathematics #philosophy #algorithms

Imgur: The most awesome images on the Internet.

New in ROMVLVS: farms. The food they produce increases the population significantly. Here's a GIF to show you how it works!

#romvlvs

Imgur: The most awesome images on the Internet.

I hate Tumblr!

ROMVLVS v0.0.4 release

After a hiatus of almost 2 years, I picked up the slack and made some long-needed updates and fixes.

The game can be downloaded here: https://drive.google.com/open?id=0BzJPRrTQDddjUC1tSnVUSTdUblk

Notable changes: * Game doesn't break when you hit an unrecognized key * Changed appearance (10x10 pixel tiles were very tiny) * Changed game engine - added "culture" layer which is generated by humans and allows for spreading of your civilization, up to a point

How to install: Please see previous post on how to run it (basically, extract contents of .tar.gz archive, then double click the "run" file - execute directly or from terminal is fine)

It's still for Linux only (specifically, it was developed and tested in Lubuntu 16.04 at 2880x1800 pixels)

Quick walkthrough: http://imgur.com/a/BG1bF

You might have to move your cursor around to find the piece of land that's visible to you.

Hope you like it - and please send me feedback if you have any!

Cheers - Captain Henessey

ROMVLVS v0.0.3 release

Hey!

Thanks very much for checking out this first playable release of ROMVLVS, a simulator game!

It's currently in alpha stage (v0.0.3) so lots of bugs have to be ironed out and features added. If you see a bug or think of a feature, don't hesitate to contact me!

To run in Linux:

Download the following file: https://drive.google.com/file/d/0BzJPRrTQDddjOVJxbWI4ek9uR0k/view?usp=sharing

Unzip downloaded file

Double click 'run' in the directory of the unzipped files

In the popup that appears, click 'Execute'

To exit the game, This was tested successfully in Lubuntu, it might work for other Linux distros as well.

As of now, no other operating systems are supported.

Introduction

ROMVLVS is a civilization simulation game, merging the low level modularity of SimCity with the high level strategy of games like Civilization. There are no centralized elements: you don't found a city, a city emerges from large populations.

Each tile roughly represents an area of 10x10m.

There are no explicit game objectives. Population grows automatically at the end of every turn but will level off quite soon unless you build buildings.

Game mechanics

Population on a tile grows when it's nearby water. It levels off if there are too many people on a tile.

Population disperses to neighboring tiles when there are more than 5 people on a tile. The game currently works with decimal numbers, make of that what you will. Materials like food and wood distribute in the same manner.

Without buildings, you're essentially growing a hunter-gatherer society. They don't produce excess food or materials and are in touch with nature.

Buildings

The buildings you can build to advance your civilization are: * Farm - creates surplus food. Costs population * Logger - creates surplus wood. Costs population * Settlement - increases population. Costs wood * Wall - does nothing for now, in the future will protect against enemies. Costs wood

Future improvemens

I want to make the following improvements: * Don't disperse materials to an unpopulated tile * Add enemies * Add a toggleable "heatmap" so you can clearly see the distribution of materials * Add roads

Please let me know if you think of any cool features that belong on this list!

(Quick recap: I'm trying to build a Civilization/SimCity crossover, combining the bottom-up fun of SimCity with Civ's top-down joy of conquering the world.)

A long overdue update. I renamed the game from Civpy, which was really just a working title, to ROMVLVS (notice the ancient Latin spelling of the letter 'U').

I also gave up on pixel art (Python/Pyglet) and rebuilt the game around a cool true-color ASCII based engine called libtcod. Fortunately, it's available for Python so I could sorta easily weasel the library into the existing code.

The main reason for this is speed, both in true game speed as well as development speed. I just couldn't get Pyglet to operate fast enough with my limited knowledge of programming, and libtcod gets around that by being precompiled. Also putting pixels in PNGs is very laborous and tiring.

Enter ASCII. For some reason being limited to 256 characters is very liberating. Two games currently are major sources of inspiration: Ultima Ratio Regum and Cogmind (see this excellent post on ASCII-based games by Cogmind's developer).

Both games are roguelikes. I don't like roguelikes that much, especially if they involve fantasy creatures like orcs, dwarves, goblins etcetera. What I like about roguelikes though is that they have a very clear focus on graphical aesthetics.

What you see in this photo is the player map with some tile stats on the side, such as altitude and temperature. These stats are important as they will give you a clue how suitable the tile is for different types of buildings.

In this game there are 5 people living under the '@' character. I haven't built anything yet but at this point there are 2 options: a settlement or a farm.

A settlement provides shelter which helps with population growth in the area. A farm just increases population growth on its own tile.

Both cost wood to build, and the caveat is that you can only use wood from your direct surroundings. So naturally I would need a logging station nearby as an additional building. That one sorta works (I already tried it), but I'm not satisfied with its dynamics. Basically you would need to build swathes of loggers in concentric circles around wherever your city center is, which is not very fun.

I'm working on a Mac, and the problem is that libtcod is only available for Windows and Linux. So for now I'm developing/running this game on a VM Lubuntu instance. I'll try to make the game available for download as soon as I figure out how to bundle it :)

Next I probably need to overhaul the GUI because it's very hard to know wht's going on.

Thanks for reading and stay tuned!

Hi, I'm Captain Hennessey, creator of Civpy.

Civpy is a civilization game, written in Python. It's going to have a flashier name but Civpy will do for now.

I'm also keeping it open source for now, to see where it goes.

Above you see two images. The first is a randomly generated world with a tiny house. This is the initial state of each Civpy game.

The next image shows the same world, only with the house evolved into a small village.

This is what I want to make: a civ game on an expansive map that's very detailed at the same time. Cities aren't just one tile (as was the case in the old Civilization franchise) but are a collection of buildings.

Each tile represents about the same size as a SimCity tile, which is around 1 acre. (So yes, if I want a map to represent an entire planet, we'll need around 1m x 1m tiles---let's park that thought for now)

The map is generated by a randomized algorithm. First it generates an altitude map, based on which other maps are generated (temperature, biomass, etc.)

The idea is that humans naturally start spreading around, but that the rate of spreading is limited by the surroundings: if there's not enough biomass or arable land around, the population capacity per tile is capped. Also, "wilderness" is a factor: if you live on the edge of town, you're more exposed to bad elements like wolves, barbarians etc.

OK, now some background about me and my motivation to make this game.

As we all know, game design involves a lot of hard choices, cursing and drinking. To make things worse, I'm not a good programmer.

Choice #1: Python.

Python is a little slow but there's a lot of useful modules available such as Cocos2d. So basically all of the graphics and interface handling are done by Cocos2d. Later I will try to employ Cython to speed up the game, as well as directly use OpenGL to specifically speed up the graphics (it's painfully slow on big maps and a reason why I can't go beyond 64x64 currently).

Choice #2: Graphics.

The tiles are 16x16 pixels. Yes that resolution hasn't been fashionable since the late '80s but it speeds up art development significantly. The trick is to make each pixel count.

Choice #3: No visible actors.

Most of the game state is stored in a bunch of two-dimensional arrays. You won't see tiny figures running around (at least not for now). I figured it was going to take a lot of effort modeling individual characters (peasants, lumberjacks, smiths whatever) as they go about their business. Instead I chose for a SimCity-like approach, where (for example) population in one tile depends on the amount of food in the surrounding tiles.

Choice #4: No AI.

Maybe later :)

Thanks for reading, I hope to update as much as possible!

Trending Blogs

Recently Viewed Blogs

ROMVLVS Development Blog