eranimo/terranova

Web-based world generator

TerraNova

World generator in Typescript.

Live Demo

http://terranova.kaelan.org/ (requires Chrome 70+, or Firefox with SharedArrayBuffers enabled)

Build status:

Install

• npm run dev: starts webpack dev server
• npm run build: builds for production

Releasing

Currently, all commits to master will automatically release to production. Versions are used to track incompatible changes and warn the user when their saved games or worlds are obsolete. These warnings are based on the package.json version.

When to release

• When the world generator is changed
• When the game code is changed

How to release

We use release-it to handle releases. This is configured to update the npm package version (we don't publish to npm) and push git tags, which are available on Github.

e.g.: npx release-it minor

terranova's Issues

Utility AI

Something like https://github.com/exane/utility-ai

Migration

Migration occurs when neighboring cells have more unused carrying capacity than the cell a pop occupies, the rate should be related to the difference

Housing

• Pops require housing
• Buildings provide housing
• If there is a deficit of housing, more will be built.

Sending entity updates to the render thread

Background

• passing data between the two threads:
  • game thread: game.worker.ts - handles simulation, game loop
  • render thread: (i.e. main thread) GameManager.ts - renders React UI, map renderer
• data is sent to the render thread using:
  • "shared memory" - SharedArrayBuffers (population map mode uses this)
    • this is hugely performant for very fast updates and anything that can be expressed in 2D
  • "data passing" - observables, passed via postMessage-style events I called "channels". Render thread only receives updates to observables they subscribe to, not all of them. Components that listen to these should unsubscribe from the channel after they unmount.
    • this is less memory efficient but it's far easier to use
• ObservableDict allows you to observe both a specific key or the entire dict itself.

Problem

• This above is kinda clunky and primitive, since what we really want is an "entity system" that can:
  • have references to each other (game cell -> pop for instance)
  • easily send updates to the render thread
  • work with the game loop
  • use as little memory as possible

Proposal

• Entities have an ID and a type.
• Entities have an ObservableDict called data whose values can be anything JSON serializable, or special types which we define, one of which is a Reference object to another Entity (more will probably be added later)

Open questions

• Should entities have references, or should a "manager" class hold the references?
• Is the above proposal too memory inefficient?
• should attributes be defined as observables that belong to an entity, which is simply an ID number in a lookup table? (this is called an entity-attribute system). This might be more flexible, and better allow for references.
• How should the entity updates be sent?

Related

• https://en.wikipedia.org/wiki/Entity%E2%80%93attribute%E2%80%93value_model

Carrying Capacity

Every cell has a carrying capacity, dictated by stuff(climate, biome), each food production method has a certain multiplier on that carrying capacity(tbd)
The advantage of foraging is that it has 0 infrastructure requirements, other methods require more infrastructure but can produce higher multipliers of carrying capacity

add warning about missing browser support

In FF the app breaks when SharedArrayBuffer's are not enabled

Entity Component System

Save / Load game based on ECS, on init make models based on entities.

Production

Food

• Food is a resource.
• Pops use a set amount of food per day. This amount is dependent on the pop type.
• Pops produce a set amount of food per day. This amount is dependent on the pop type, the biome of the cell, the terrain of the cell.

Pops

Population units can exist on each cell. Each cell has a certain amount of each pop type.

Pop types and base production:

• Foragers
  • produces 1 unit of food
  • produces 1 unit of wood
• Farmers
  • produces 2 units of food
• Laborers
  • produces 2 units of wood
• Nobles
  • can't produce jack shit

Farmers need farm buildings.

Buildings

Each cell has a certain amount of each building type. Buildings have different effects.

Building types:

• House

Resources

Each cell has a certain amount of each resource type.

Resource types:

• Food
• Wood
• Stone

Farmers

Assuming there is adequate food and housing farmers will construct farms which allow them to produce food, otherwise they will become foragers, foragers should construct a small amount of farms that will serve as the initial farms for farmers(this can be justified either as experimental agriculture or the slow process of land clearing and environment modification that is enacted by foragers)