This is the (old) C++ implementation of Limit Theory, the Limit Theory Engine (LTE), and the Limit Theory Scripting Language (LTSL), written from 2012 to 2015. While this code is dated compared to the newer C/Lua LT, it is arguably meatier in gameplay implementation.

Although LT was developed for both Windows and Linux (indeed, primarily developed on Linux), I have only resurrected the Windows build. If you would like to get it working on Linux, you're on your own...although it shouldn't be too difficult.

To build Limit Theory, you'll need a few standard developer tools. All of them are available to download for free.

• Python: https://www.python.org/downloads/
• Git: https://git-scm.com/downloads
• Git LFS: https://git-lfs.github.com/
• Visual Studio Community: https://visualstudio.microsoft.com/vs/
• CMake: https://cmake.org/download/

With the above prerequisites installed, open a Git Bash terminal.

First, use cd to change directories to the place where you want to download LT.

• cd ~/Desktop/<path where you want to put the LT source>

Before doing any other git commands, make sure LFS is installed:

• git lfs install

You should see Git LFS initialized or a similar message. Important: if you forget to install and initialize Git LFS, most of the resources will probably be broken, and the whole process will likely fail in strange and mysterious ways. This is a common gotcha with projects that use LFS. Make sure you do the above step!

Now, you can download the repository:

• git clone --recursive https://github.com/JoshParnell/ltheory-old.git ltheory-old

Once you have the repository, the build process proceeds in two steps (as with other CMake builds): generating the build files, and then building. There is a Python script configure.py at the top level of the repository to help you do this easily.

From a terminal in the directory of the checked-out repository, run

• python configure.py

This runs CMake to generate the build files. Then, to compile,

• python configure.py build

This invokes compilation. It will take a while.

If the compilation is successful, you now have bin/launch.exe, which is the main executable. This program launches an LTSL script. The intention was for Limit Theory (and all mods) to be broken into many LTSL scripts, which would then implement the gameplay, using script functions exposed by the underlying engine.

To launch an LTSL script, you can again use the python helper:

• python configure.py run <script_name_without_extension>

All top-level scripts are in the resource/script/App directory. So you can do, for example:

• python configure.py run war

To run the app 'war.lts', which is an AI skirmish test. Many of the apps are broken or incomplete, but some work enough to allow you to fly around in a system.

An example of the entire sequence of commands to run an LTSL app, starting from nothing (but having the prerequisites installed):

Open Git Bash. Each line below is one command, some of which will take a while to complete:

cd ~/Desktop
git lfs install
git clone --recursive https://github.com/JoshParnell/ltheory-old.git ltheory-old
cd ltheory-old
python configure.py
python configure.py build
python configure.py run war