docs/index.rst

 Welcome to PyCommandCenter's documentation!
 ===========================================
 
-This is a Python module for implementing bots for Starcraft II.
+This is a Python library based on the CommandCenter bot for implementing bots 
+for Starcraft II.
+
+If you are looking on how to get started, take a look at :ref:`Getting started 
+<gettingstarted>`.
+
+If you want to make changes to either this documentation or the library itself, please read the :ref:`Contributors guide <contributing>`.
+
+If you are looking for something specific, you can either check the 
+:ref:`modindex` or use the search feature on the left.
+
+If you want to know about a certain topic, check the table of contents below
+this paragraph.
+
+Table of contents
+-----------------
 
 .. toctree::
    :maxdepth: 2
-   :caption: Contents:
 
+   gettingstarted
+   PyCommandCenter<_autosummary/commandcenter>
+   Coordinator<_autosummary/commandcenter.Coordinator>
+   helpers
+   idabot
    unit
-   managers
-   
-Short overview
-==============
+   types
+   coordinates
+   constants
+   replays
+   idareplayobserver
+   replayunit
 
 .. autosummary::
    :toctree: _autosummary
+   :hidden:
+
+   commandcenter
+   commandcenter.Coordinator 	
 
-   library
-   library.PLAYER_SELF
-   library.PLAYER_ENEMY
-   library.PLAYER_NEUTRAL
-   library.PLAYER_ALLY
-   library.ABILITY_ID 	
-   library.BUFF_ID 	
-   library.BaseLocation 	
-   library.BuildingPlacer 	
-   library.Color 	
-   library.Coordinator 	
-   library.Difficulty 	
-   library.IDABot 	
-   library.MapTools 	
-   library.PlayerSetup 	
-   library.Point2D 	
-   library.Point2DI 	
-   library.Race 	
-   library.TechTree 	
-   library.TypeData 	
-   library.UNIT_TYPEID 	
-   library.UPGRADE_ID 	
-   library.Unit 	
-   library.UnitType 	
-   library.UnitTypeID
-
-Indices and tables
-==================
-
-* :ref:`genindex`
-* :ref:`modindex`
-* :ref:`search`

docs/managers.rst

-Managers
-========
-
-The original CommandCenter bot uses managers to do everything, having managers 
-manage workers, building, controlling military etc. In this API we have removed 
-all the control related managers and only kept the managers related to helping 
-process input information, leaving the decision-making to the user of the API.
-
-Here is a full list of all managers:
-
-* :class:`library.BaseLocationManager`
-* :class:`library.TechTree`
-
-The rest of this page contains the descriptions of each manager.
-
-.. TODO: How should we access the managers? Should we let the students create them themselves or should we give it to them via inhertiance
-
-BaseLocationManager
--------------------
-
-.. class:: library.BaseLocationManager
-
-   .. attribute:: library.BaseLocationManager.base_locations
-
-      A list of all :class:`library.BaseLocation` on the current map
-
-   .. attribute:: library.BaseLocationManager.starting_base_locations
-
-      A list of all :class:`library.BaseLocation` on the current map which a player
-      started at, indexed by Player constant
-
-   .. automethod:: library.BaseLocationManager.get_occupied_base_locations
-
-   .. automethod:: library.BaseLocationManager.get_player_starting_base_location
-
-   .. automethod:: library.BaseLocationManager.get_next_expansion
-
-.. class:: library.BaseLocation
-
-   Closely related to BaseLocationManager. This is the datastructure used by
-   the BaseLocationManager to keep track of all base locations and related
-   information.
-
-   .. attribute:: library.BaseLocation.position
-
-      The position of the center of the BaseLocation, defined as a :class:`library.Point2D`.
-
-   .. attribute:: library.BaseLocation.depot_position
-
-      A suitable position for building a town hall, defined as a :class:`library.Point2DI`.
-
-TechTree
---------
-
-.. class:: library.TechTree
-
-   This class contains all information about units and what is required to
-   build a certain unit and what builds it. It only has one method, which is
-   used to look-up unit types properties:
-
-   .. method:: get_data(argument) -> library.TypeData
-
-      Argument is either an instance of the class :class:`library.UnitType` or
-      an instance of the class :class:`library.CCUpgrade`, depending on what
-      information is wanted.
-
-.. autoclass:: library.TypeData
-   :members:
-
-.. TODO: Not all members have docstrings attached to them
-
-MapTools
---------
-
-.. autoclass:: library.MapTools
-   :members:
-

docs/replays.rst

+.. _replays:
+
+Replays
+=======
+This page will describe two different techniques for handling replays. The
+first technique parses the information saved in the replay file. The second
+uses the information in the replay file to actually replay the game. The
+different techniques have certain advantages and disadvantages. The main
+one is that the reader is a lot faster while replaying the game provides
+a lot more information.
+
+
+
+SC2Reader
+---------
+SC2Reader_ is a library that can be used to implement the first technique.
+
+Here is a short example that uses SC2Reader to extract the build order.
+
+
+.. _SC2Reader: https://github.com/ggtracker/sc2reader
+
+.. code-block:: python
+
+    import sc2reader
+    import json
+    from sc2reader.factories import SC2Factory
+
+    # The path to the replays
+    PATH = "../Replays"
+
+    def main():
+        # Creates a generator of all the replays in the dictionary
+        replays = sc2reader.load_replays(PATH, load_level=3)
+        games = []
+        # Loops through every relay
+        for replay in replays:
+            building_order = []
+            if is_terran_vs_terran(replay):
+                # Loops through every event
+                for event in replay.events:
+                    # Check if the event is that a building is crated
+                    if type(event) == sc2reader.events.tracker.UnitInitEvent:
+                        if event.unit.name not in building_order:
+                            building_order.append(event.unit.name)
+                games.append(building_order)
+        return games
+
+
+    def is_terran_vs_terran(replay):
+        try:
+            return sc2reader.constants.LOCALIZED_RACES[replay.players[0].play_race] == "Terran" \
+               and sc2reader.constants.LOCALIZED_RACES[replay.players[1].play_race] == "Terran"
+        except(KeyError):
+            return False
+
+    if __name__ == '__main__':
+        games = main()
+        text = json.dumps(games)
+        print("Res: " + text)
+
+
+SC2Reader has good documation_ that also describe what information
+could be found. `What is in a Replay`_ and Events_ gives a good idea
+if the information you want could be collected with SC2Reader.
+
+.. _documation: https://sc2reader.readthedocs.io/en/latest/index.html
+.. _What is in a Replay: https://sc2reader.readthedocs.io/en/latest/articles/whatsinareplay.html
+.. _Events: https://sc2reader.readthedocs.io/en/latest/events/index.html
+
+ReplayObserver
+--------------
+This is the second technique it is much like using a bot but with the difference
+that no action can be preform just observations.
+
+
+.. code-block:: python
+
+    from commandcenter import *
+
+
+    class MyObserver(ReplayObserver):
+        def __init__(self):
+            ReplayObserver.__init__(self)
+
+        def on_game_start(self):
+            ReplayObserver.on_game_start(self)
+
+        def on_step(self):
+            ReplayObserver.on_step(self)
+
+
+    def main():
+
+        coordinator = Coordinator(r"D:/StarCraft II/Versions/Base<version>/SC2_x64.exe")
+        if coordinator.load_replay_list("D:/Replays/"):
+            observer = MyObserver()
+            coordinator.add_replay_observer(observer)
+            while coordinator.update():
+                pass
+        else:
+            print("No replays found")
+
+
+    if __name__ == "__main__":
+        main()
+
+.. toctree::

docs/replayunit.rst

+ReplayUnit
+==========
+
+.. autoclass:: commandcenter.ReplayUnit
+
+   Properties:
+
+   .. autoattribute:: buffs
+   .. autoattribute:: build_percentage
+   .. autoattribute:: energy
+   .. autoattribute:: facing
+   .. autoattribute:: hit_points
+   .. autoattribute:: max_hit_points
+   .. autoattribute:: id
+   .. autoattribute:: is_alive
+   .. autoattribute:: is_blip
+   .. autoattribute:: is_being_constructed
+   .. autoattribute:: is_burrowed
+   .. autoattribute:: is_cloaked
+   .. autoattribute:: is_completed
+   .. autoattribute:: is_flying
+   .. autoattribute:: is_idle
+   .. autoattribute:: is_powered
+   .. autoattribute:: is_training
+   .. autoattribute:: is_valid
+   .. autoattribute:: ReplayUnit.player
+   .. autoattribute:: position
+   .. autoattribute:: current_ability_id
+   .. autoattribute:: progress
+   .. autoattribute:: radius
+   .. autoattribute:: shields
+   .. autoattribute:: tile_position
+   .. autoattribute:: unit_type
+   .. autoattribute:: weapon_cooldown
+   .. autoattribute:: is_carrying_minerals
+
+
+.. toctree::
\ No newline at end of file

docs/types.rst

+Types
+=====
+
+For a full list of all unit types see the enum :class:`commandcenter.UNIT_TYPEID`.
+For more information about a certain unit type, the wrapper class :class:`commandcenter.UnitType` can be used.
+
+For a full list of all abilities and upgrades, see :class:`commandcenter.ABILITY_ID`, :class:`commandcenter.UPGRADE_ID` and :class:`commandcenter.EFFECT_ID` respectively. Note that these does not have any
+wrapper classes for them.
+
+If any of the ID's doesn't respond with the game. Before contacting the labassistent, check the game version and the compatibility through Liquipedia. Some ID's might be left after a patch and is not available in the game anymore.
+
+UnitType
+--------
+
+.. autoclass:: commandcenter.UnitType
+   :members:
+   :undoc-members:
+   :special-members: __init__
+
+UNIT_TYPEID
+-----------
+
+.. dropdown:: UNIT_TYPEID Enum (click to expand)
+
+   .. autoclass:: commandcenter.UNIT_TYPEID
+      :members:
+      :undoc-members:
+
+ABILITY_ID
+----------
+
+.. dropdown:: ABILITY_ID Enum (click to expand)
+
+   .. autoclass:: commandcenter.ABILITY_ID 	
+      :members:
+      :undoc-members:
+
+UPGRADE_ID
+----------
+
+.. dropdown:: UPGRADE_ID Enum (click to expand)
+
+   .. autoclass:: commandcenter.UPGRADE_ID 	
+      :members:
+      :undoc-members:
+
+EFFECT_ID
+----------
+EffectID is for things like ravager bile, or fungal or even a scan.
+
+.. dropdown:: EFFECT_ID Enum (click to expand)
+
+   .. autoclass:: commandcenter.EFFECT_ID 	
+      :members:
+      :undoc-members:
+
+.. toctree::

docs/unit.rst

 Unit
 ====
 
-.. class:: library.Unit
+.. autoclass:: commandcenter.Unit
 
-   An instance of the class Unit represents one unit in the game. The units are 
-   not limited to moveable units, but every entity which is not part of the 
-   background is a unit. For example, the minerals and geysers are units as 
-   well as all buildings.
-
-   For all possible types of units see the enum :class:`library.UNIT_TYPEID`. 
-   Some types of objects are almost the same, for example there are many types 
-   of mineral deposits, but all of them are mineable. This is one of the 
-   motivations behind the :class:`library.UnitType` which aims to to make the 
-   list of types more manageable. The UnitType can be accessed by the 
-   :any:`Unit.unit_type` property.
-
-   It is possible to use Unit as keys in a dictionary, which might be helpful
-   for bookkeeping.
 
    Properties:
 
+   .. autoattribute:: buffs
    .. autoattribute:: build_percentage
    .. autoattribute:: energy
+   .. autoattribute:: facing
+   .. autoattribute:: has_target
    .. autoattribute:: hit_points 
+   .. autoattribute:: max_hit_points
+   .. autoattribute:: max_shields
+   .. autoattribute:: max_energy
    .. autoattribute:: id 
    .. autoattribute:: is_alive 
+   .. autoattribute:: is_blip
    .. autoattribute:: is_being_constructed 
    .. autoattribute:: is_burrowed 
    .. autoattribute:: is_cloaked 
    .. autoattribute:: is_completed 
-   .. autoattribute:: is_constructing 
    .. autoattribute:: is_flying 
    .. autoattribute:: is_idle 
    .. autoattribute:: is_powered 
    .. autoattribute:: is_training 
    .. autoattribute:: is_valid 
-   .. attribute:: Unit.player 
-
-      .. TODO: Add page about PLAYER_* constants
+   .. autoattribute:: player 
    .. autoattribute:: position 
+   .. autoattribute:: current_ability_id
+   .. autoattribute:: progress
+   .. autoattribute:: progression_list
+   .. autoattribute:: radius
    .. autoattribute:: shields 
    .. autoattribute:: tile_position 
    .. autoattribute:: unit_type 
    .. autoattribute:: weapon_cooldown 
+   .. autoattribute:: is_carrying_minerals
+   .. autoattribute:: is_carrying_gas
+   .. autoattribute:: target
+   .. autoattribute:: gas_left_in_refinery
+   .. autoattribute:: minerals_left_in_mineralfield
+   .. autoattribute:: owner
 
    Methods:
 
+   .. automethod:: ability
+   .. automethod:: is_constructing
    .. automethod:: stop
    .. automethod:: attack_unit
    .. automethod:: attack_move
-   .. method:: Unit.move(self, point)
-
-      Move the unit to the given point, the point being an instance of either 
-      :class:`library.Point2D` or :class:`library.Point2DI`.
+   .. automethod:: Unit.move(self, point)
    .. automethod:: right_click
    .. automethod:: repair
    .. automethod:: build
-   .. TODO: Maybe should I put the limits of build here, and when to use build_target
    .. automethod:: build_target
    .. automethod:: train
+   .. automethod:: research
    .. automethod:: morph
-   
+   .. automethod:: hold_position
+   .. automethod:: patrol
+   .. automethod:: stop_dance
 
+      
+.. toctree::
\ No newline at end of file

cpp-sc2 @ f8bbf67b

+Subproject commit f8bbf67bb3284bdf8f82544b464f4692f4f451ce

json @ 7bfc406d

+Subproject commit 7bfc406ded0434c438dd22139a8baa97f2ffa90e

pybind11 @ 35ff42b5

-Subproject commit ed07e49236d937fd4ae98d0b0cb58a962cd269a6
+Subproject commit 35ff42b56e9d34d9a944266eb25f2c899dbdfed7

s2client-api @ d9ba0a33

-Subproject commit d9ba0a33d6ce9d233c2a4ee988360c188fbe9dbf

sc2-gamedata @ a82b9aee

+Subproject commit a82b9aeed5be23149e3f79b31793bdc29bab3923

sc2-techtree @ c92eaf8d

+Subproject commit c92eaf8d8cee8bda4a19f95d81b43d65f23174a9

python-api-src/CMakeLists.txt

 include_directories(SYSTEM
-    ${PROJECT_SOURCE_DIR}/lib/s2client-api/include
-    ${PROJECT_SOURCE_DIR}/lib/s2client-api/contrib/protobuf/src
-    ${PROJECT_BINARY_DIR}/lib/s2client-api/generated
+    ${PROJECT_SOURCE_DIR}/lib/cpp-sc2/include
+    ${PROJECT_SOURCE_DIR}/lib/cpp-sc2/contrib/protobuf/src
+    ${PROJECT_BINARY_DIR}/lib/cpp-sc2/generated
+    ${PROJECT_SOURCE_DIR}/lib/json/include
 )
 
 # All the source files for the bot.
@@ -9,14 +10,14 @@ file(GLOB BOT_SOURCES "../src/*.cpp" "../src/*.h" "../src/*.hpp")
 
 file(GLOB LIBRARY_SOURCES "*.cpp" "*.h")
 
-link_directories(${PROJECT_BINARY_DIR}/s2client-api/bin)
+link_directories(${PROJECT_BINARY_DIR}/cpp-sc2/bin)
 
 # Enable compilation of the SC2 version of the bot code
 # TODO: Remove all remaining BW code
 add_definitions(-DSC2API)
 
 # Create the executable.
-pybind11_add_module(library library.cpp library.h ${BOT_SOURCES} ${LIBRARY_SOURCES})
-target_link_libraries(library PRIVATE
+pybind11_add_module(commandcenter library.cpp library.h ${BOT_SOURCES} ${LIBRARY_SOURCES})
+target_link_libraries(commandcenter PRIVATE
     sc2api sc2lib sc2utils sc2protocol libprotobuf
 )

python-api-src/lib_base_location.cpp

@@ -5,21 +5,27 @@ namespace py = pybind11;
 void define_base_location(py::module & m)
 {
     py::class_<BaseLocation>(m, "BaseLocation")
-        .def_property_readonly("geysers", &BaseLocation::getGeysers)
-        .def_property_readonly("minerals", &BaseLocation::getMinerals)
-        .def_property_readonly("is_start_location", &BaseLocation::isStartLocation)
-        .def_property_readonly("depot_position", &BaseLocation::getDepotPosition)
-        .def_property_readonly("position", &BaseLocation::getPosition)
+        .def_property_readonly("geysers", &BaseLocation::getGeysers, "List of geysers at base location (List of units).")
+        .def_property_readonly("minerals", &BaseLocation::getMinerals, "List of mineral fields at base location (List of unit). Also returns the empty mineral fields.")
+        .def("is_start_location", &BaseLocation::isStartLocation, "True if the base location is a start location, False otherwise.")
+        .def_property_readonly("depot_position", &BaseLocation::getDepotPosition, "A suitable position for building a town hall (Command Center, Hatchery or Nexus), defined as a :class:`library.Point2DI`.")
+        .def_property_readonly("position", &BaseLocation::getPosition, "The position of the center of the BaseLocation, defined as a :class:`commandcenter.Point2D`.")
         .def("get_ground_distance", py::overload_cast<const CCPosition &>(&BaseLocation::getGroundDistance, py::const_))
-        .def("get_ground_distance", py::overload_cast<const CCTilePosition &>(&BaseLocation::getGroundDistance, py::const_))
-        .def("is_occupied_by_player", &BaseLocation::isOccupiedByPlayer)
-        .def("is_player_start_location", &BaseLocation::isPlayerStartLocation)
-        .def("contains_position", &BaseLocation::containsPosition);
+        .def("get_ground_distance", py::overload_cast<const CCTilePosition &>(&BaseLocation::getGroundDistance, py::const_), "Returns the ground distance between the provided position and the base location. Note that this uses a BFS approach and may overshoot a bit.")
+        .def("is_occupied_by_player", &BaseLocation::isOccupiedByPlayer, "player constant"_a, "If the baselocation is occupied by the provided player. See :ref:`playerconstants` for more information.")
+        .def("is_player_start_location", &BaseLocation::isPlayerStartLocation, "player_constant"_a, "If the baselocation is the start location of the provided player. See :ref:`playerconstants` for more information.")
+        .def("contains_position", &BaseLocation::containsPosition, "If the baselocation contains the provided :class:`commandcenter.Point2D` position.")
+        .doc() = R"(
+        Represents a base location on the map. A base location is a location on the map where a player can build a base. It contains information about the resources available at the location, the position of the location, and other information.
+        )";
 
     py::class_<BaseLocationManager>(m, "BaseLocationManager")
-        .def_property_readonly("base_locations", &BaseLocationManager::getBaseLocations, py::return_value_policy::reference)
-        .def_property_readonly("starting_base_locations", &BaseLocationManager::getStartingBaseLocations, py::return_value_policy::reference)
-        .def("get_occupied_base_locations", &BaseLocationManager::getOccupiedBaseLocations, py::return_value_policy::reference, "player_constant"_a)
-        .def("get_player_starting_base_location", &BaseLocationManager::getPlayerStartingBaseLocation, py::return_value_policy::copy, "player_constant"_a)
-        .def("get_next_expansion", &BaseLocationManager::getNextExpansion, py::return_value_policy::copy, "player_constant"_a);
+        .def_property_readonly("base_locations", &BaseLocationManager::getBaseLocations, py::return_value_policy::reference, "A list of all :class:`commandcenter.BaseLocation` on the current map.")
+        .def_property_readonly("starting_base_locations", &BaseLocationManager::getStartingBaseLocations, py::return_value_policy::reference, "A list of all :class:`commandcenter.BaseLocation` on the current map which a player started at, indexed by Player constant(see :ref:`playerconstants`).")
+        .def("get_occupied_base_locations", &BaseLocationManager::getOccupiedBaseLocations, py::return_value_policy::reference, "player_constant"_a, "Returns a list of all :class:`commandcenter.BaseLocation` that are occupied by the provided :ref:`playerconstants`.")
+        .def("get_player_starting_base_location", &BaseLocationManager::getPlayerStartingBaseLocation, py::return_value_policy::copy, "player_constant"_a, "Returns the :class:`commandcenter.BaseLocation` that provided :ref:`playerconstants` started at.")
+        .def("get_next_expansion", &BaseLocationManager::getNextExpansion, py::return_value_policy::copy, "player_constant"_a, "Returns the :class:`commandcenter.BaseLocation` that is closest to the startlocation of provided :ref:`playerconstants` that is possible to expand to.")
+        .doc() = R"(
+        As the name implies this class helps you manage the base locations on the map. 
+        )";
 }
\ No newline at end of file

python-api-src/lib_building_placer.cpp

@@ -5,10 +5,16 @@ namespace py = pybind11;
 void define_building_placer(py::module & m)
 {
     py::class_<BuildingPlacer>(m, "BuildingPlacer")
-        .def("can_build_here", &BuildingPlacer::canBuildHere, "x"_a, "y"_a, "unit_type"_a)
-        .def("can_build_here_with_spaces", &BuildingPlacer::canBuildHereWithSpace, "x"_a, "y"_a, "unit_type"_a, "build_distance"_a)
-        .def("get_build_location_near", &BuildingPlacer::getBuildLocationNear, "point2di"_a, "unit_type"_a, "build_distance"_a)
-        .def("reserve_tiles", &BuildingPlacer::reserveTiles, "x"_a, "y"_a, "width"_a, "height"_a)
-        .def("free_tiles", &BuildingPlacer::freeTiles, "x"_a, "y"_a, "width"_a, "height"_a)
-        .def("get_refinery_position", &BuildingPlacer::getRefineryPosition);
+        .def("can_build_here", &BuildingPlacer::canBuildHere, "x"_a, "y"_a, "unit_type"_a, "Returns if the provided unit_type it possible to be built at the location. Note: This function uses the width and height of the unit_type and this is not correct for add-ons. So to check addons please use can_build_here_with_size with a hardcoded size instead.")
+		.def("can_build_here_with_size", &BuildingPlacer::canBuildHereWithSize, "x"_a, "y"_a, "width"_a, "height"_a, "Checks if it is possible to build something with the provided width and height at the provided coordinates. Note: False if the it overlaps with a base location.")
+        .def("can_build_here_with_spaces", &BuildingPlacer::canBuildHereWithSpace, "Creates a square with the help of x, y, distance_to_building and the size of the unit_type. Good approach if we plan to later construct an add-on. Note: Does not reserve those extra tiles given by distance_to_building for the future. Note: This function uses the width and height of the unit_type and this is not correct for add-ons. So to check add-ons use can_build_here_with_size with a hardcoded size instead.", "x"_a, "y"_a, "unit_type"_a, "distance_to_building"_a)
+        .def("get_build_location_near", &BuildingPlacer::getBuildLocationNear, "The search_count represents how many building we should check (nearby buildings, instead of i < size, we can switch size to search_count). distance_to_building is the distance to the closest building.", "point2di"_a, "unit_type"_a, "distance_to_building"_a = 2, "search_count"_a = 1000)
+        .def("reserve_tiles", &BuildingPlacer::reserveTiles, "Reserves tiles, which makes it impossible to build at the position given by x and y.", "x"_a, "y"_a, "width"_a, "height"_a)
+        .def("free_tiles", &BuildingPlacer::freeTiles,"Free the tile (x, y) from reservation.", "x"_a, "y"_a, "width"_a, "height"_a)
+        .doc() = R"(
+        This class is useful for placing all buildings, except refineries and town halls (Command Centers, Hacheries and Nexus).
+
+        If you want to place a town hall, take a look at attribute `depot_location` of :class:`commandcenter.BaseLocation`.
+        If you want to place a refinery, take a look at attribute `geysers` of :class:`commandcenter.BaseLocation` and the method build_target of :class:`commandcenter.Unit`.
+        )";
 }
\ No newline at end of file

python-api-src/lib_color.cpp

+#include "library.h"
+
+namespace py = pybind11;
+
+void define_color(py::module & m)
+{
+    py::class_<sc2::Color> color(m, "Color");
+    color.def(py::init<>());
+    color.def(py::init<int, int, int>(), "r"_a, "g"_a, "b"_a);
+    color.def_readwrite("r", &sc2::Color::r, "Red");
+    color.def_readwrite("g", &sc2::Color::g, "Green");
+    color.def_readwrite("b", &sc2::Color::b, "Blue");
+    color.def("__repr__", [](const sc2::Color & c) { return "<Color (" + std::to_string(c.r) + ", " + std::to_string(c.g) + ", " + std::to_string(c.b) + ")>"; });
+    color.attr("WHITE") = sc2::Colors::White;
+    color.attr("RED") = sc2::Colors::Red;
+    color.attr("GREEN") = sc2::Colors::Green;
+    color.attr("YELLOW") = sc2::Colors::Yellow;
+    color.attr("BLUE") = sc2::Colors::Blue;
+    color.attr("TEAL") = sc2::Colors::Teal;
+    color.attr("PURPLE") = sc2::Colors::Purple;
+    color.attr("BLACK") = sc2::Colors::Black;
+    color.attr("GRAY") = sc2::Colors::Gray;
+    color.doc() = R"(
+        Represents a color in RGB format. The color is represented by three integers, each ranging from 0 to 255. The color can be created by providing the red, green and blue values. The class also contains some predefined colors.
+    )";
+}
\ No newline at end of file

python-api-src/lib_map_tools.cpp

@@ -4,49 +4,70 @@ namespace py = pybind11;
 
 void define_map_tools(py::module & m)
 {
+    py::class_<DistanceMap>(m, "DistanceMap")
+        .def("computer_distance_map", &DistanceMap::computeDistanceMap, "bot"_a, "start_tile"_a)
+        .def("get_distance", py::overload_cast<const CCTilePosition &>(&DistanceMap::getDistance, py::const_), "position"_a)
+        .def("get_distance", py::overload_cast<const CCPosition &>(&DistanceMap::getDistance, py::const_), "position"_a)
+        .def("get_sorted_tiles", &DistanceMap::getSortedTiles)
+        .def("get_start_tile", &DistanceMap::getStartTile)
+        .def("draw", &DistanceMap::draw, "bot"_a)
+        .doc() = R"(
+            This class is used to calculate the distance between two points on the map. 
+            The distance is calculated using a BFS algorithm. Keep in mind that it can overshoot the distance a bit. 
+        )";
+
     const CCColor white{ 255, 255, 255 };
     py::class_<MapTools>(m, "MapTools")
-        .def_property_readonly("width", &MapTools::width, "The width of the map")
-        .def_property_readonly("height", &MapTools::height, "The height of the map")
+        .def_property_readonly("width", &MapTools::width, "The width of the map.")
+        .def_property_readonly("height", &MapTools::height, "The height of the map.")
+		.def_property_readonly("map_name", &MapTools::name, "The name of the map.")
         //.def("terrainHeight", &MapTools::terrainHeight, py::const_)
-        .def("draw_line", py::overload_cast<const CCPosition &, const CCPosition &, const CCColor &>(&MapTools::drawLine, py::const_), py::arg("start"), py::arg("stop"), py::arg("color"))
-        //.def("draw_line", py::overload_cast<CCPositionType, CCPositionType, CCPositionType, CCPositionType, const CCColor &>(&MapTools::drawLine, py::const_)); // TODO: Default argument??
-        .def("draw_box", py::overload_cast<const CCPosition &, const CCPosition &, const CCColor &>(&MapTools::drawBox, py::const_), py::arg("top_left"), py::arg("bottom_right"), py::arg("color"))
-        .def("draw_circle", py::overload_cast<const CCPosition &, CCPositionType, const CCColor &>(&MapTools::drawCircle, py::const_), py::arg("center"), py::arg("radius"), py::arg("color"))
-        .def("draw_text", &MapTools::drawText, "position"_a, "text"_a, "color"_a)
-        .def("draw_text_screen", &MapTools::drawTextScreen, "percentage_x"_a, "percentage_y"_a, "text"_a, "color"_a);
+        .def("terrainHeight", &MapTools::terrainHeightFromCoord, "x"_a, "y"_a)
+        .def("draw_line", py::overload_cast<const CCPosition &, const CCPosition &, const CCColor &>(&MapTools::drawLine, py::const_), py::arg("start"), py::arg("stop"), py::arg("color") = sc2::Colors::White, "Draws a line with the given color between to two points.")
+        .def("draw_tile", py::overload_cast<const CCTilePosition &, const CCColor &>(&MapTools::drawTile, py::const_), py::arg("tile"), py::arg("color") = sc2::Colors::White, "Draws an outline with the given color to the given tile.")
+		.def("draw_box", py::overload_cast<const CCPosition &, const CCPosition &, const CCColor &>(&MapTools::drawBox, py::const_), py::arg("top_left"), py::arg("bottom_right"), py::arg("color") = sc2::Colors::White, "Draws a box with the given color from the top left corner to the botom right.")
+        .def("draw_circle", py::overload_cast<const CCPosition &, CCPositionType, const CCColor &>(&MapTools::drawCircle, py::const_), py::arg("center"), py::arg("radius"), py::arg("color") = sc2::Colors::White, "Draws a circle with the given color with the provided point as center and the float as radius.")
+		.def("draw_resource_sphere", &MapTools::drawResourceSphere, py::arg("center"), py::arg("radius"), py::arg("color") = sc2::Colors::White, "Draws a 3D sphere with the given color with the provided point as center and the float as radius.")
+        .def("draw_text", &MapTools::drawText, "position"_a, "text"_a, "color"_a = sc2::Colors::White)
+        .def("draw_text_screen", &MapTools::drawTextScreen, "percentage_x"_a, "percentage_y"_a, "text"_a, "color"_a = sc2::Colors::White)
+        .def("is_valid_tile", py::overload_cast<int, int>(&MapTools::isValidTile, py::const_), "x"_a, "y"_a, "Checks whether the position is valid for the map.")
+        .def("is_valid_tile", py::overload_cast<const CCTilePosition &>(&MapTools::isValidTile, py::const_), "point_2di"_a, "Checks whether the tile is valid for the map.")
+        .def("is_valid_position", py::overload_cast<const CCPosition &>(&MapTools::isValidPosition, py::const_), "point_2d"_a, "Checks whether the position is valid for the map.")
+        .def("is_powered", &MapTools::isPowered, "x"_a, "y"_a)
+        .def("is_explored", py::overload_cast<int, int>(&MapTools::isExplored, py::const_), "x"_a, "y"_a, "Returns whether the coordinates has been explored or not.")
+        .def("is_explored", py::overload_cast<const CCPosition &>(&MapTools::isExplored, py::const_), "point2d"_a, "Returns whether the coordinate has been explored or not.")
+        .def("is_explored", py::overload_cast<const CCTilePosition &>(&MapTools::isExplored, py::const_), "point2di"_a, "Returns whether the tile has been explored or not.")
+        .def("is_connected", py::overload_cast<int, int, int, int>(&MapTools::isConnected, py::const_), "x1"_a, "y1"_a, "x2"_a, "y2"_a, "Returns whether the coordinates are connected.")
+        .def("is_connected", py::overload_cast<const CCTilePosition &, const CCTilePosition &>(&MapTools::isConnected, py::const_), "from"_a, "to"_a, "Returns whether the tiles are connected.")
+        .def("is_connected", py::overload_cast<const CCPosition &, const CCPosition &>(&MapTools::isConnected, py::const_), "from"_a, "to"_a, "Returns whether the positions are of two connected tiles.")
+        .def("is_walkable", py::overload_cast<int, int>(&MapTools::isWalkable, py::const_), "x"_a, "y"_a, "Returns whether the coordinates is walkable.")
+        .def("is_walkable", py::overload_cast<const CCTilePosition &>(&MapTools::isWalkable, py::const_), "point2di"_a, "Returns whether the tile is walkable.")
+        .def("is_buildable", py::overload_cast<int, int>(&MapTools::isBuildable, py::const_), "x"_a, "y"_a, "Returns whether it is possible to build at the provided coordinate.")
+        .def("is_buildable", py::overload_cast<const CCTilePosition &>(&MapTools::isBuildable, py::const_), "point2di"_a, "Returns whether it is possible to build on tile.")
+        .def("is_visible", &MapTools::isVisible, "x"_a, "y"_a, "Returns whether the location identified by the coordinates is visible.")
+        .def("can_build_type_at_position", &MapTools::canBuildTypeAtPosition, "x"_a, "y"_a, "unit_type"_a, "Returns whether it is possible to build the provided unittype at the location.")
+        .def("is_depot_buildable_tile", &MapTools::isDepotBuildableTile, "x"_a, "y"_a, "Returns whether it is possbile to build a depot at the position.")
+        .def("get_ground_distance", &MapTools::getGroundDistance, "Returns the ground distance between the two points. Note that this uses a BFS approach and may overshoot a bit. The function will also do the calculations with integers resulting in that sometimes when close to a wall it might return -1 even though a path is available.", "from"_a, "to"_a)
+        .def("get_distance_map", py::overload_cast<const CCTilePosition &>(&MapTools::getDistanceMap, py::const_), "point2di"_a)
+        .def("get_distance_map", py::overload_cast<const CCPosition &>(&MapTools::getDistanceMap, py::const_), "point2d"_a)
+        .def("get_closest_tiles_to", &MapTools::getClosestTilesTo, "Returns a list of positions, where the first position is the closest and the last is the farthest.", "point2di"_a)
+        .def("get_least_recently_seen_tile", &MapTools::getLeastRecentlySeenTile, "Returns the tile for which the most time has passed since it was last visible.")
+        .doc() = R"(
+            This class contains two types of methods:
+
+            * Methods for drawing information to the screen
+            * Methods for extracting information about the map
 
-        /*
-        TODO: Left to implement
-        drawBox(CCPositionType x1, CCPositionType y1, CCPositionType x2, CCPositionType y2, const CCColor & color = CCColor(255, 255, 255)) const;
-        drawCircle(CCPositionType x1, CCPositionType x2, CCPositionType radius, const CCColor & color = CCColor(255, 255, 255)) const;
-    
-        isValidTile(int tileX, int tileY) const;
-        isValidTile(const CCTilePosition & tile) const;
-        isValidPosition(const CCPosition & pos) const;
-        isPowered(int tileX, int tileY) const;
-        isExplored(int tileX, int tileY) const;
-        isExplored(const CCPosition & pos) const;
-        isExplored(const CCTilePosition & pos) const;
-        isVisible(int tileX, int tileY) const;
-        canBuildTypeAtPosition(int tileX, int tileY, const UnitType & type) const;
+            First, let us look at the method concerning drawing information to the 
+            screen. Methods with the suffix ``_screen`` takes percentages of the 
+            screens height and width, i.e. values between 0 and 1. Methods without 
+            this suffix uses the same coordinate system as the game, i.e. world 
+            coordinates.
 
-        getDistanceMap(const CCTilePosition & tile) const;
-        getDistanceMap(const CCPosition & tile) const;
-        getGroundDistance(const CCPosition & src, const CCPosition & dest) const;
-        isConnected(int x1, int y1, int x2, int y2) const;
-        isConnected(const CCTilePosition & from, const CCTilePosition & to) const;
-        isConnected(const CCPosition & from, const CCPosition & to) const;
-        isWalkable(int tileX, int tileY) const;
-        isWalkable(const CCTilePosition & tile) const;
-    
-        isBuildable(int tileX, int tileY) const;
-        isBuildable(const CCTilePosition & tile) const;
-        isDepotBuildableTile(int tileX, int tileY) const;
-    
-        getLeastRecentlySeenTile() const;
+            The top three methods below takes in a Point2D, but it's possible to
+            send in x and y as floats instead of Point2D.
 
-        // returns a list of all tiles on the map, sorted by 4-direcitonal walk distance from the given position
-        const std::vector<CCTilePosition> & getClosestTilesTo(const CCTilePosition & pos) const;
-        */
+            There is also methods which are useful for extracting information about the 
+            game map.
+        )";
 }
\ No newline at end of file

python-api-src/lib_point.cpp

@@ -9,14 +9,17 @@ void define_point(py::module & m)
     py::class_<sc2::Point2D>(m, "Point2D", py::dynamic_attr())
         .def(py::init<float, float>())
         .def(py::init())
+		.def(py::init([](const sc2::Point2DI & p) {
+			return sc2::Point2D(p.x, p.y);
+		}))
         .def_readwrite("x", &sc2::Point2D::x)
         .def_readwrite("y", &sc2::Point2D::y)
         .def(py::self += py::self)
         .def(py::self -= py::self)
         .def(py::self *= float())
         .def(py::self /= float())
-        // TODO: These does not compile
-        //.def(py::self == py::self)
+        // These does not compile, but it is not a good idea to compare floats with floats anyway
+        .def(py::self == py::self) // compiles now and this one is needed for __hash__. Outdated comment??
         //.def(py::self != py::self)
         .def(py::self + py::self)
         .def(py::self - py::self)
@@ -24,6 +27,14 @@ void define_point(py::module & m)
         .def(float() * py::self)
         .def(py::self / float())
         .def(float() / py::self)
+		.def("__eq__", 
+			[](const sc2::Point2D & p1, const sc2::Point2D & p2) {
+				return (p1.x == p2.x && p1.y == p2.y); 
+			})
+		.def("__hash__",
+			[](const sc2::Point2D & p) {
+				return py::make_tuple(p.x, p.y).attr("__hash__")();
+			})
         .def("__repr__",
             [](const sc2::Point2D & p) {
                 return "<Point2D: (" + std::to_string(p.x) + ", " + std::to_string(p.y) + ")>";
@@ -35,13 +46,21 @@ void define_point(py::module & m)
 
     py::class_<sc2::Point2DI>(m, "Point2DI", py::dynamic_attr())
         .def(py::init<int, int>())
+		.def(py::init())
+		.def(py::init([](const sc2::Point2D & p) {
+			return sc2::Point2DI(p);
+		}))
         .def_readwrite("x", &sc2::Point2DI::x)
         .def_readwrite("y", &sc2::Point2DI::y)
         .def(py::self == py::self)
         .def(py::self != py::self)
+		.def("__hash__",
+			[](const sc2::Point2DI & p) {
+				return py::make_tuple(p.x, p.y).attr("__hash__")();
+		})
         .def("__repr__",
             [](const sc2::Point2DI & p) {
-                return "<Point2D: (" + std::to_string(p.x) + ", " + std::to_string(p.y) + ")>";
+                return "<Point2DI: (" + std::to_string(p.x) + ", " + std::to_string(p.y) + ")>";
             })
         .def("__str__", 
             [](const sc2::Point2DI & p) {

python-api-src/lib_replay_unit.cpp

+#include "library.h"
+
+namespace py = pybind11;
+
+void define_replay_unit(py::module & m)
+{
+	py::class_<ReplayUnit>(m, "ReplayUnit")
+		.def_property_readonly("id", &ReplayUnit::getID, "The ID of the unit.")
+		.def_property_readonly("unit_type", &ReplayUnit::getType, "The :class:`commandcenter.UnitType` of the unit.")
+		.def_property_readonly("position", &ReplayUnit::getPosition, "The :class:`commandcenter.Point2D` of the unit.")
+		.def_property_readonly("tile_position", &ReplayUnit::getTilePosition, "The :class:`commandcenter.Point2DI` of the unit.")
+		.def_property_readonly("hit_points", &ReplayUnit::getHitPoints, "The hit points of the unit.")
+		.def_property_readonly("shields", &ReplayUnit::getShields, "The shields of the unit.")
+		.def_property_readonly("energy", &ReplayUnit::getEnergy, "The energy of the unit.")
+		.def_property_readonly("player", &ReplayUnit::getPlayer, "Returns the constant corresponding to player which this unit belongs to. See :ref:`playerconstants` for more information.")
+		.def_property_readonly("build_percentage", &ReplayUnit::getBuildPercentage, "The build percentage of the unit.")
+		.def_property_readonly("weapon_cooldown", &ReplayUnit::getWeaponCooldown, "The weapon cooldown of the unit.")
+		.def_property_readonly("is_completed", &ReplayUnit::isCompleted, "Whether the unit is completed, returns build_progress >= 1.")
+		.def_property_readonly("is_being_constructed", &ReplayUnit::isBeingConstructed, "Whether the unit is being constructed, returns build_progress > 0.")
+		.def_property_readonly("is_cloaked", &ReplayUnit::isCloaked, "Whether the unit is cloaked.")
+		.def_property_readonly("is_flying", &ReplayUnit::isFlying, "Whether the unit is flying.")
+		.def_property_readonly("buffs", &ReplayUnit::buffs, "Returns a list of BuffIDs representing the buffs on the unit.")
+		.def_property_readonly("is_alive", &ReplayUnit::isAlive, "Whether the unit is alive.")
+		.def_property_readonly("is_powered", &ReplayUnit::isPowered, "Whether the unit is powered.")
+		.def_property_readonly("is_idle", &ReplayUnit::isIdle, "Whether the unit is idle.")
+		.def_property_readonly("is_burrowed", &ReplayUnit::isBurrowed, "Whether the unit is burrowed.")
+		.def_property_readonly("is_valid", &ReplayUnit::isValid, "Whether the unit is valid.")
+		.def_property_readonly("is_training", &ReplayUnit::isTraining, "Whether the unit is training.")
+		.def_property_readonly("is_blip", &ReplayUnit::isBlip, "Whether the unit is a blip ie a ping on the map.")
+		.def_property_readonly("target", &ReplayUnit::getTarget, "The target of the unit.")
+		.def_property_readonly("has_target", &ReplayUnit::hasTarget, "Whether the unit has a target.")
+		.def_property_readonly("max_hit_points", &ReplayUnit::getMaxHitPoints, "The maximum hit points of the unit.")
+		.def_property_readonly("progress", &ReplayUnit::getProgress, "Returns the progress of currently used ability (-1 if not using ability).")
+		.def_property_readonly("current_ability_id", &ReplayUnit::getCurrentAbilityID, "The AbilityID of currently used ability.")
+		.def_property_readonly("facing", &ReplayUnit::getFacing, "Returns the direction the unit is facing.")
+		.def_property_readonly("radius", &ReplayUnit::getRadius, "The radius of the unit.")
+		.def_property_readonly("is_carrying_minerals", &ReplayUnit::isCarryingMinerals, "Whether the unit is carrying minerals.")
+		.def("__hash__", [](const ReplayUnit & unit) { return std::hash<const sc2::Unit *>{}(unit.getUnitPtr()); })
+		.def(py::self == py::self)
+		.def("__repr__", [](const ReplayUnit & unit) { return "<Unit of type: '" + unit.getType().getName() + "'>"; })
+		.doc() = R"(
+		The ReplayUnit class is used to represent a unit in a replay of a game. 
+		A ReplayUnit is a :class:`commandcenter.Unit` with some limitations.
+   		It provides various properties and methods to access information about the unit, such as its ID, type, position, hit points, energy, and more.
+		It is possible to use ReplayUnit as keys in a dictionary, which might be helpful for bookkeeping.
+		)";
+}