docs/idabot.rst

+IDABot
+======
+
+.. autoclass:: commandcenter.IDABot
+
+   See :ref:`this page <gettingstarted>` for how to properly
+   inherit from IDABot.
+
+   Instances of managers:
+
+   .. autoattribute:: base_location_manager
+   .. autoattribute:: tech_tree
+   .. autoattribute:: map_tools
+   .. autoattribute:: building_placer
+
+   Inherited methods:
+
+   .. method:: IDABot.on_game_start(self)
+
+      This method is run when the game starts. See :ref:`gettingstarted` 
+      for an example.
+
+   .. method:: IDABot.on_step(self)
+
+      This method is run on every tick of the game, when you inherit it you
+      have to call the parent's on_step method in order to make it work (see
+      :ref:`gettingstarted`).
+   
+   .. method:: IDABot.on_game_end(self)
+
+      This method is run whenever the match ends. 
+
+   Methods:
+
+   .. automethod:: get_all_units
+   .. automethod:: get_my_units
+   .. automethod:: get_player_race
+   .. automethod:: send_chat
+   .. automethod:: has_creep
+   .. automethod:: move_camera
+   .. automethod:: save_replay
+
+   .. method:: IDABot.ability_for_upgrade(self, UpgradeID)
+
+      Ability that researches this upgrade
+
+      Example: If we send in UPGRADE_ID.BANSHEECLOAK, it will return
+      ABILITY_ID.RESEARCH_BANSHEECLOAKINGFIELD. In this case,
+      the unit of scv has the ability for this. You can then use the
+      unit.ability(AbilityID) on the scv for creating the upgrade.
+
+   .. automethod:: upgrade_mineral_cost
+   .. automethod:: upgrade_gas_cost
+   .. automethod:: upgrade_research_time
+   .. automethod:: effect_radius
+
+   Attributes:
+
+   .. autoattribute:: minerals
+   .. autoattribute:: gas
+   .. autoattribute:: current_supply
+   .. autoattribute:: max_supply
+   .. autoattribute:: current_frame
+   .. autoattribute:: start_location
+   ,, autoattribute:: start_locations
+
+Debug
+-----
+.. class:: commandcenter.IDABot
+
+   When developing AI-methods or when simply having a problem.
+   The debug-methods are a great tool for speeding up the process.
+
+   .. automethod:: debug_create_unit
+   .. automethod:: debug_kill_unit
+   .. automethod:: IDABot.debug_show_map(self)
+   .. automethod:: IDABot.debug_fast_build(self)
+   .. automethod:: debug_enemy_control
+   .. automethod:: debug_fast_build
+   .. automethod:: debug_ignore_food
+   .. automethod:: debug_ignore_resource_cost
+   .. automethod:: debug_give_all_resources
+   .. automethod:: debug_god_mode
+   .. automethod:: debug_ignore_mineral
+   .. automethod:: debug_no_cooldowns
+   .. automethod:: debug_give_all_tech
+   .. automethod:: debug_give_all_upgrades
+   .. automethod:: debug_set_score
+   .. automethod:: debug_end_game
+
+   .. method:: IDABot.debug_set_energy(self, Float, Unit)
+
+      Set the amount (Float) of energy to the :class:`commandcenter.Unit`
+      The maximum depends on the unit maxenergy.
+      Note: This is not in percent of the unit energy.
+      Same goes for life and shields.
+
+   .. automethod:: debug_set_life
+
+   .. automethod:: debug_set_shields
+
+
+.. toctree::

docs/idareplayobserver.rst

+IDAReplayObserver
+=================
+
+.. class:: commandcenter.IDAReplayObserver
+
+   This is a class for following a replay.
+
+   Inherited methods:
+
+   .. method:: on_game_start(self)
+
+      This method is called when a replay has started, when you inherit it you have to
+      call the parent's on_game_start method in order to make it work (see
+      :ref:`replays`).
+
+   .. method:: on_step(self)
+
+      This method is called on every tick of the replay, when you inherit it you
+      have to call the parent's on_step method in order to make it work (see
+      :ref:`replays`).
+
+   .. method:: on_game_end(self)
+
+      This method is called when the replay has ended, when you inherit it you have to
+      call the parent's on_game_start method in order to make it work (see
+      :ref:`replays`).
+
+   .. method:: on_unit_created(self)
+
+      This method is called when the an unit is created, that includes when an unit leaves a refinery. This only works if replay perspective is not set to 0.
+
+   .. method:: on_unit_destroyed(self)
+
+      This unit is called when a unit is destroyed.
+
+   Methods:
+
+   .. method:: get_all_units(self) -> List[commandcenter.ReplayUnit]
+
+      Retrieves a list of all visible units.
+
+   .. method:: get_player_race(self, player_id) -> commandcenter.Race
+
+      Returns the player's race.
+
+
+
+.. toctree::

docs/index.rst

+Welcome to PyCommandCenter's documentation!
+===========================================
+
+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
+
+   gettingstarted
+   PyCommandCenter<_autosummary/commandcenter>
+   Coordinator<_autosummary/commandcenter.Coordinator>
+   helpers
+   idabot
+   unit
+   types
+   coordinates
+   constants
+   replays
+   idareplayobserver
+   replayunit
+
+.. autosummary::
+   :toctree: _autosummary
+   :hidden:
+
+   commandcenter
+   commandcenter.Coordinator 	
+

docs/make.bat

+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+set SPHINXPROJ=PyCommandCenter
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd

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
+====
+
+.. autoclass:: commandcenter.Unit
+
+
+   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_flying 
+   .. autoattribute:: is_idle 
+   .. autoattribute:: is_powered 
+   .. autoattribute:: is_training 
+   .. autoattribute:: is_valid 
+   .. 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
+   .. automethod:: Unit.move(self, point)
+   .. automethod:: right_click
+   .. automethod:: repair
+   .. automethod:: build
+   .. 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("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)
-        .def("get_player_starting_base_location", &BaseLocationManager::getPlayerStartingBaseLocation, py::return_value_policy::copy)
-        .def("get_next_expansion", &BaseLocationManager::getNextExpansion, py::return_value_policy::copy);
+        .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)
-        .def_property_readonly("height", &MapTools::height)
+        .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)
-        .def("draw_text_screen", &MapTools::drawTextScreen);
+        .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) {