Tomorrow Engine

AI/Tools programmer


The Tomorrow Engine is a custom engine made in the second year of my study at the Breda University of Applied Sciences. The Tomorrow engine is an engine made specifically for an online player versus player card game. It has a database to store the cards, a tool called "The HUB" in which you can customize certain parts of the game, it supports LUA scripting for card behavior and it has PS4 support. We had 16 weeks to make the engine, after which we had 8 weeks to make a game using our custom engine. The game that we made with the Tomorrow Engine is called Reptoads.

Project information
Development time: 24 weeks
Made in: Tommorrow Engine (Custom engine)
Team size: 11
Platform Support: Windows & PS4
My contributions
Asynchronous Utility based AI (more information here)
Card balancing tool that uses the AI (more information here)
Gameplay logic (more information here)

Languages


Supported platforms


More Detailed information


AI

For this project I wrote a Utility based AI which picked the best card that it could play based on certain circumstances such as its health, armor, amount of cards and the stats of its opponent. The utility functions for each variable could be set by designers through our HUB tool and then I would load them out of a Json file.

While developing the engine and testing the AI, I figured out that the AI was becomming quite slow as more and more gameplay functions would be added since some of those were quite heavy tasks (like getting a particular card out of every possible card). And while this is not necessarily a bad thing if it happens just once, the way the AI works is by trying out every possible combination of cards. At that point in development the player was able to pick 4 cards at once, so that combined with the posibility of having a maximum of 8 cards in your hand makes for quite some simulations.

Because of this I decided to make the AI asynchronous using std::async() to run every simulation on a seperate thread since these simulations are completely seperate tasks that do not write to the same variables. This sped up the AI a lot in a short amount of time.

Feel free to check out the code using the buttons on the right, these link to the ".h" and ".cpp" files of the AISystem in our github repository of Reptoads/Tomorrow Engine.


AI Balancing tool

When we started to work on Reptoads, the design team decided that they did not want the AI as an opponent. Because of this we decided that I would modify the AI to be used as a balancing tool which could be used to see how good the cards are, to test the game and to gather all kinds of data from game simulations where I would make bots play against eachother.

To make this work, I keep track of as much information as possible while the AI is playing against eachother. At the end, I then write all this data to a Json file. Another teammate made a tool that would read this file and put it in a more readable format in a google sheet. (We decided to have this conversion where the Json file would store everything, and the google sheet would be a more readable version with only the information design wanted to have)

Feel free to check out the code using the buttons on the right, these link to the ".h" and ".cpp" files of the AISystem in our github repository of Reptoads/Tomorrow Engine.


Gameplay Logic

During this project I also worked on some gameplay logic for our game, here I will go into more detail on the gameplay logic that I wrote for the server side, client side can be found here.

We had two kinds of logic, the first one was our core gameplay logic which would be used throughout the game. The other kind are the gameplay functions that we exposed to LUA. Those LUA functions could then be used by designers or gameplay programmers in their scripts. Those LUA functions make use of the core gameplay functions.

Feel free to check out some of the code using the buttons on the right, these link to the "MatchHelper.cpp", which is the file with the core gameplay logic as well as the "LuaBindingFunc.cpp" for the functions that we exposed to LUA.