Programming Team

Our Programming Team is responsible for turning concepts into working game features and ensuring those features work as intended. If you are reading this thread, you have likely decided to dedicate your talents as a programmer to the programming team for the ambitious project that is Thrive! If so, then welcome aboard! This thread is designed to best ease you and other new programmers into the process of developing the game, and providing you with all the relevant information you need.

Overview


Team lead(s): moopli, jjonj/crovea

Forum category: http://forum.revolutionarygamesstudio.com/c/programming

Types of work: Scripting, engine programming, interface programming, etc.

Programmers are the most valuable team members, since without them the game wouldn't exist. The Programming Team is responsible for scripting and engine work, as well as aiding other teams (particularly the Graphics Team) when adding assets to the game. Thrive is coded in C++ and Lua.

Our code base can be found on GitHub. Anyone is free to fork the repository and make changes to their own versions, but all contributions to the master must be done with permission from a veteran programmer. Minor changes can be made on the master branch, but larger features or fixes should take place on separate branches, which can be merged with the master via a pull request. Assets are stored on a SVN server (see below). Other programmers will be on hand to help you get to grips with the code, but reading some of the links below first will help.

Current Tasks


The programming team is always a hub of activity, and here are some of the big tasks on the plate for the team at the moment. Take your pick of what interests you.

Bacteria

Bacteria will be a big part of the Microbe Stage. Some of a cell's organelles will come from assimilation of free-roaming bacteria. These are small AI entities with only simple processes and no evolution mechanics. Sub-tasks within this feature include creating bacteria models, programming their AI, programming their processes and programming their interactions with other species. All these aspects will need to be designed by theorists beforehand.

Options menu

Creating a basic options menu within the game for adjusting video settings, audio settings and others. Currently does not need to involve things like difficulty options or use a polished GUI, since the entire GUI will be rewritten at a later point.

Overhauling the reproduction and health systems

At the moment, cells start with a predefined amount of health, and each organelle they add adds a certain amount of health on top of that. Cells reproduce by producing a fictional compound called reproductase. Although it may not appear like it, these two systems are intrinsically linked in their design, and will be dramatically overhauled to create a realistic system where cells reproduce by growing and reproducing their organelles, and using the compounds they consume to repair damage they take to themselves.

Agent system (Link needed)

Currently, agents are discrete particles that are produced and ejected by cells. Agents should be created differently to how they are now, with several varieties and randomization with some player intervention. First the mechanics need to be ironed out and made intuitive for the player (while taking the CPA simulation into consideration), then the system should be programmed into the game with some sort of basic GUI to accompany it.

Refactoring the engine to remove lag (Link needed)

Cells experience quite a lot of stuttering while swimming through the environment. Making changes to the engine code and moving some code from Lua to C++ should help alleviate this problem and create smooth gameplay.

New UI

The current user interface was a big step up from what was there before, but still has some problems with clunkiness, irregular shapes, taking up too much space, and lacking certain buttons for current or upcoming features.

Improved AI (Link needed)

We will need some general improvements to the AI, potentially incorporating genetic algorithms.

Dynamic membrane

The current membrane is static, but gives the impression of fluidity by having some predefined set of rippling. However, we ultimately want a fully dynamic membrane; one that responds to the pressures of the surrounding environment, and can also stretch and warp in response to the cell's movements and to engulf other cells.

This list isn't fixed. If you can think of a feature you'd like to start working on that we didn't mention just let us know. There are also innumerable ideas you could try to prototype if you wanted.

Online Resources


GitHub

https://github.com/Revolutionary-Games/Thrive

As explained above, this is the primary resource for Thrive's programmers. It hosts our official releases alongside the two resources listed below. Our main programmers will gladly help you set up a development environment to work with it effectively.

GitHub README

https://github.com/Revolutionary-Games/Thrive/blob/master/README.md

The most important information for script authors, C++ programmers and asset creators. Read this before starting any programming work.

GitHub Style Guide

https://github.com/Revolutionary-Games/Thrive/blob/23ff280f7dff1cdc84e38e4e3f6d69ccfb41aa26/doc/style_guide.dox

Covers the programming guidelines for code within our repository. Should also be read thoroughly before contributing.

SVN Repository

http://assets.revolutionarygamesstudio.com/

Stores all the game's assets. Here is a guide to installing Tortoise SVN (steps six and seven). Once you've created an SVN folder on your machine, you can right click to update (giving you changes made by everyone else since you last updated) and commit (adding your changes to the master SVN for others to receive).

Prototypes on GitHub

https://github.com/Revolutionary-Games/thrive-prototypes

An offshoot from our main GitHub repository where programmers and theorists can create prototypes for specific features or later stages. See the README first.

Tutorials


GUI Tutorial

http://thrivegame.wikidot.com/gui-tutorial

For interface programmers, this tutorial will outline the basics of Lua scripting within the CEGUI framework.

FAQ


How do I join the Programming Team?

See Application Process.

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License