C++ Starter Algo

community/c++-algo/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required (VERSION 2.6)
+project (StarterAlgo)
+
+set(out_dir ${CMAKE_SOURCE_DIR}/algo-target)
+set(CMAKE_CXX_STANDARD 11)
+
+# First for the generic no-config case (e.g. with mingw)
+set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${out_dir} )
+set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${out_dir}/lib )
+set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${out_dir}/lib )
+# Second, for multi-config builds (e.g. msvc)
+foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} )
+    string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG )
+    set( CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${out_dir} )
+    set( CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${out_dir}/lib )
+    set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${out_dir}/lib )
+endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES )
+
+set(HEADERS
+    src/algoStrategy.h
+    src/algoStrategy.cpp
+    src/source.cpp
+)
+
+add_executable(StarterAlgo ${HEADERS})
+
+target_include_directories (StarterAlgo PRIVATE ${CMAKE_SOURCE_DIR}/include/)
+
+add_subdirectory(${CMAKE_SOURCE_DIR}/include/json11/)
+add_subdirectory(${CMAKE_SOURCE_DIR}/include/GameLib/)
+
+target_link_libraries(StarterAlgo json11 GameLib)

community/c++-algo/README.md

@@ -0,0 +1,119 @@
+# Starter Algo C++
+
+#### NOTE: This project is currently being developed, and is NOT supported by C1's servers yet.
+This means you currently cannot upload this algo to their servers, it will not work.
+However, if you have a linux OS it is possible compile and upload your compiled version and have it run.
+This compilation will not work in the playground.
+
+### Directory Overview
+
+```
+community/c++-algo
+│
+├───algo-target
+│       run.ps1
+│       run.sh
+│
+├───build
+│
+├───documentation
+│
+├───include
+│   ├───GameLib
+│   │   │
+│   │   └───src
+│   │           algoCore.cpp
+│   │           algoCore.h
+│   │           customExceptions.h
+│   │           enums.h
+│   │           gameMap.cpp
+│   │           gameMap.h
+│   │           gameState.cpp
+│   │           gameState.h
+│   │           navigation.cpp
+│   │           navigation.h
+│   │           structs.h
+│   │           unit.cpp
+│   │           unit.h
+│   │           util.cpp
+│   │           util.h
+│   │
+│   └───json11
+│
+└───src
+        algoStrategy.cpp
+        algoStrategy.h
+        source.cpp
+```
+
+
+### Creating an algo
+
+For starters, simply modify the `src/algoStrategy.cpp` files. You will be mostly using functions in the `GameState` class.
+
+The `GameState` provides fast and convenient access to the game board, and the ability to perform actions, such as placing a 
+unit, which will mutate the `GameState` game state, as well as record that action. The GameState can then be used to submit your changes to the engine.
+
+**The standard output is used to communicate with the game engine, and must not be printed to.**
+For this reason, debugging must be done with the standard error. The standard error messages are 
+available on the playground. As an abstraction over this logic, the `Util` method `debugWrite()` prints to the standard error stream.
+
+This project is intentionally modeled after the python-algo to make it familiar to those who are either new to programming in C++ or have been coding with terminal for a while.
+
+### Build script
+
+Since compiling will be different for every user, this is a CMake project to build for multiple enviornments.
+This means for whatever enviornemnt you are using, you will need to install CMake (found [here](https://cmake.org/download/)).
+In order to compile your algo, create a `build` directory under the `C1GamesStarterKit` directory and then run `cmake`.
+Thus, the steps to setup a completely new enviornment would be (in terminal or cmd):
+```
+C1GamesStarterKit\community\c++-algo> mkdir build
+C1GamesStarterKit\community\c++-algo> cd build
+C1GamesStarterKit\community\c++-algo\build> cmake ..
+```
+(the commands are only after the `>`).
+
+This will create a project depending on what system you have avalible.
+For example, if you have Visual Studio, it will generate a .sln project inside of `build` and you can then open
+the project and build it.
+If you are running linux, or something that supports makefiles, then while in the `build` directory you simply run:
+```
+make
+```
+
+In all cases, the target for your executable is inside `c++-algo\algo-target`.
+
+Thus, to run a local game, you would give it the directory `community\c++-algo\algo-target`.
+
+Building this project has been tested using:
+- Visual Studio 2017
+- Ubuntu 16.04.5 LTS
+- Ubuntu 18.04.1 LTS
+- MacOS Mojave
+
+### Documentation
+
+Documentation for this starter-kit can be generated using doxygen. The general steps to do so and explanation for their accepted style can be found on [their website](http://www.doxygen.nl/index.html). However, the steps that we took were:
+
+1. Install doxygen (found on their website).
+2. Create folder to generate the documentation (`mkdir dox`) and go to it (`cd dox`).
+3. Generate the config for doxygen (`doxygen -g dox-config`).
+4. Modify the following options found in the dox-config file:
+	- EXTRACT_ALL = YES
+	- INPUT = ../ (or the path to the c++-algo code)
+	- RECURSIVE = YES
+	- JAVADOC_AUTOBRIEF = YES
+	- EXCLUDE_PATTERNS = \*/build/* + \*/json11/*
+	- USE_MDFILE_AS_MAINPAGE = ../README.md (or path to this README)
+	- STRIP_FROM_PATH (set it equal to the path up to and not including the C1GamesStarterKit) (eg C:/Users/.../)
+
+5. Run doxygen (`doxygen dox-config`).
+
+You can modify the output style further by specifying an html header/footer and css style (see [doxygen documentation](http://www.doxygen.nl/manual/customize.html).
+
+### Contributing
+
+This is a community made and supported algo. If you'd like to contribute a new feature
+just reach out to me (@Isaac) on the [C1 forums](https://forum.c1games.com/) or submit a pull request with your changes.
+
+Feel free to submit a Pull Request for any bugs or new features, but please try and follow the style of the rest of the project.

community/c++-algo/algo-target/run.ps1

@@ -0,0 +1,4 @@
+$scriptPath = Split-Path -parent $PSCommandPath;
+$algoPath = "$scriptPath\StarterAlgo.exe"
+
+Invoke-Expression $algoPath

community/c++-algo/algo-target/run.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+"$DIR/StarterAlgo"

community/c++-algo/include/GameLib/CMakeLists.txt

@@ -0,0 +1,26 @@
+cmake_minimum_required (VERSION 2.6)
+project (GameLib)
+
+set(HEADERS
+    src/customExceptions.h
+    src/structs.h
+    src/enums.h
+    src/util.h
+    src/util.cpp
+    src/algoCore.h
+    src/algoCore.cpp
+    src/gameState.h
+    src/gameState.cpp
+    src/gameMap.h
+    src/gameMap.cpp
+    src/unit.h
+    src/unit.cpp
+    src/navigation.h
+    src/navigation.cpp
+)
+
+add_library(GameLib ${HEADERS})
+
+target_include_directories (GameLib PRIVATE ${CMAKE_SOURCE_DIR}/include/)
+
+target_link_libraries(GameLib json11)

community/c++-algo/include/GameLib/README.md

@@ -0,0 +1,8 @@
+### GameLib Library
+
+This is a small, simple library to make interfacing with the Terminal engine easier.
+It is very heavily modeled after the `python-algo` gamelib project.
+
+It contains classes to make it easier to submit your turns and get the information from the terminal engine.
+
+It also contains a `GameState` class which contains functions to allow you to create theoretical game states and to test strategies before you submit them to the engine. This includes things like pathfinding and predicting future resources.

community/c++-algo/include/GameLib/src/algoCore.cpp

@@ -0,0 +1,115 @@
+/*
+Description: The default object to override for your strategy.
+Last Modified: 08 Apr 2019
+Author: Isaac Draper
+*/
+
+#include "algoCore.h"
+
+namespace terminal {
+
+    using json11::Json;
+
+    /// Basic constructor for algoCore.
+    AlgoCore::AlgoCore() {
+        endOfGame = false;
+    }
+
+    /// A function that runs at the start of every game.
+    /// Override this to perform initial setup at the start of the game, based on the configuration.
+    /// @param configuration A Json object containing information about the game.
+    void AlgoCore::onGameStart(Json configuration) {
+        config = configuration;
+    }
+
+    /// Called when the engine expects input from the algo.
+    /// It is called every turn and is passed a Json object containing
+    /// the current game state, which can be used to initialize a new gameState object.
+    /// @param gameState A Json object containing the current game state.
+    void AlgoCore::onTurn(Json gameState) {
+        AlgoCore::submitDefaultTurn();
+    }
+
+    /// Submits a turn that does nothing.
+    void AlgoCore::submitDefaultTurn() const {
+        Util::sendCommand("[]");
+        Util::sendCommand("[]");
+    }
+
+    /// Starts the main loop of the program.
+    /// This will continue until it gets the end of state signal from the engine.
+    /// If there is some error, it will never exit since it will continue
+    /// to wait until it recieves input from the engine.
+    /// If this happens it must be killed manually.
+    void AlgoCore::start() {
+        Util::debugWrite("Starting C++ Starter Algo");
+
+        while (true) {
+            try {
+                Json gameState = Util::getCommand();
+
+                if (gameState["turnInfo"] == nullptr) {
+                    // Here we know it is the first turn, and the gameState object
+                    // is information about the game, not an actual game state.
+                    // Thus, we run the setup for the game.
+
+                    onGameStart(gameState);
+                }
+                else {
+                    int stateType = gameState["turnInfo"].array_items().at(0).int_value();
+
+                    // We now make decisions based on what turn state it is.
+                    switch (stateType) {
+                        case 0: {
+                            // This is when the engine expects to recieve what we are
+                            // building for this turn.
+                            // So we run the onTurn function.
+
+                            onTurn(gameState);
+                            break;
+                        }
+                        case 1: {
+                            // This is a single frame from the engine.
+                            // If you want to get information from the game every frame,
+                            // you can create function to do that here.
+
+                            break;
+                        }
+                        case 2: {
+                            // This indicates that the game has ended.
+                            // Since break simply takes us out of the switch,
+                            // we use a variable to quite the while loop.
+
+                            Util::debugWrite("GOT END OF STATE");
+                            endOfGame = true;
+                            break;
+                        }
+                        default: {
+                            // This means we got an unexpected string.
+                            // This technically should never happen since it would
+                            // be caught by the Json parser.
+
+                            Util::debugWrite("Unexpected state recieved: " + std::to_string(stateType));
+                            break;
+                        }
+                    }
+
+                    if (endOfGame) {
+                        break;
+                    }
+                }
+            }
+            catch (UtilException e) {
+                Util::debugWrite(e.what());
+                continue;
+            }
+        }
+    }
+
+    /// This returns a string representation of the AlgoCore object.
+    /// @return A string to represent this object.
+    std::string AlgoCore::toString() const {
+        return "AlgoCore";
+    }
+
+}

community/c++-algo/include/GameLib/src/algoCore.h

@@ -0,0 +1,54 @@
+/*
+Description: This contains the core components necessary for an algo to run.
+Last Modified: 08 Apr 2019
+Author: Isaac Draper
+*/
+
+#ifndef ALGO_CORE_H
+#define ALGO_CORE_H
+
+#include <iostream>
+#include <string>
+
+#include "json11/json11.hpp"
+#include "customExceptions.h"
+#include "util.h"
+
+namespace terminal {
+
+    using json11::Json;
+
+    /// This is the super class to contain the basic essentials.
+    /// You should inherit from this class when developing your strategy.
+    class AlgoCore {
+    public:
+        // Functions
+        AlgoCore();
+        virtual void start();
+        virtual std::string toString() const;
+
+    protected:
+        // Functions
+        virtual void onGameStart(Json configuration);
+        virtual void onTurn(Json gameState);
+        void submitDefaultTurn() const;
+
+        // Members
+        Json config; ///< Holds information about the game.
+
+    private:
+        // Members
+        bool endOfGame; ///< Keeps track of whether the game has ended.
+
+    };
+
+    /// This sends a representation of the AlgoCore object to a stream.
+    /// @return The stream passed to the function.
+    inline std::ostream& operator<<(std::ostream& os, AlgoCore const& algoCore) {
+        os << algoCore.toString();
+        return os;
+    }
+
+}
+
+#endif