Merge pull request #33 from OpenVicProject/terrain-types

Terrain types

6 files changed, 469 insertions, 123 deletions

diff --git a/src/openvic-simulation/map/Map.cpp b/src/openvic-simulation/map/Map.cpp
index 6cafb57..e29f104 100644
--- a/src/openvic-simulation/map/Map.cpp
+++ b/src/openvic-simulation/map/Map.cpp
@@ -4,6 +4,7 @@
 #include <unordered_set>
 
 #include "openvic-simulation/economy/Good.hpp"
+#include "openvic-simulation/utility/BMP.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
 using namespace OpenVic;
@@ -182,116 +183,6 @@ Province const* Map::get_selected_province() const {
 	return get_province_by_index(get_selected_province_index());
 }
 
-static colour_t colour_at(uint8_t const* colour_data, int32_t idx) {
-	idx *= 3;
-	return (colour_data[idx] << 16) | (colour_data[idx + 1] << 8) | colour_data[idx + 2];
-}
-
-bool Map::generate_province_shape_image(size_t new_width, size_t new_height, uint8_t const* colour_data,
-	uint8_t const* terrain_data, terrain_variant_map_t const& terrain_variant_map, bool detailed_errors) {
-	if (!province_shape_image.empty()) {
-		Logger::error("Province index image has already been generated!");
-		return false;
-	}
-	if (!provinces.is_locked()) {
-		Logger::error("Province index image cannot be generated until after provinces are locked!");
-		return false;
-	}
-	if (new_width < 1 || new_height < 1) {
-		Logger::error("Invalid province image dimensions: ", new_width, "x", new_height);
-		return false;
-	}
-	if (colour_data == nullptr) {
-		Logger::error("Province colour data pointer is null!");
-		return false;
-	}
-	if (terrain_data == nullptr) {
-		Logger::error("Province terrain data pointer is null!");
-		return false;
-	}
-	width = new_width;
-	height = new_height;
-	province_shape_image.resize(width * height);
-
-	std::vector<bool> province_checklist(provinces.size());
-	bool ret = true;
-	std::unordered_set<colour_t> unrecognised_province_colours, unrecognised_terrain_colours;
-
-	for (int32_t y = 0; y < height; ++y) {
-		for (int32_t x = 0; x < width; ++x) {
-			const int32_t idx = x + y * width;
-
-			const colour_t terrain_colour = colour_at(terrain_data, idx);
-			const terrain_variant_map_t::const_iterator it = terrain_variant_map.find(terrain_colour);
-			if (it != terrain_variant_map.end()) province_shape_image[idx].terrain = it->second;
-			else {
-				if (unrecognised_terrain_colours.find(terrain_colour) == unrecognised_terrain_colours.end()) {
-					unrecognised_terrain_colours.insert(terrain_colour);
-					if (detailed_errors) {
-						Logger::warning("Unrecognised terrain colour ", colour_to_hex_string(terrain_colour),
-							" at (", x, ", ", y, ")");
-					}
-				}
-				province_shape_image[idx].terrain = 0;
-			}
-
-			const colour_t province_colour = colour_at(colour_data, idx);
-			if (x > 0) {
-				const int32_t jdx = idx - 1;
-				if (colour_at(colour_data, jdx) == province_colour) {
-					province_shape_image[idx].index = province_shape_image[jdx].index;
-					continue;
-				}
-			}
-			if (y > 0) {
-				const int32_t jdx = idx - width;
-				if (colour_at(colour_data, jdx) == province_colour) {
-					province_shape_image[idx].index = province_shape_image[jdx].index;
-					continue;
-				}
-			}
-			const Province::index_t index = get_index_from_colour(province_colour);
-			if (index != Province::NULL_INDEX) {
-				province_checklist[index - 1] = true;
-				province_shape_image[idx].index = index;
-				continue;
-			}
-			if (unrecognised_province_colours.find(province_colour) == unrecognised_province_colours.end()) {
-				unrecognised_province_colours.insert(province_colour);
-				if (detailed_errors) {
-					Logger::warning("Unrecognised province colour ", colour_to_hex_string(province_colour),
-						" at (", x, ", ", y, ")");
-				}
-			}
-			province_shape_image[idx].index = Province::NULL_INDEX;
-		}
-	}
-	if (!unrecognised_province_colours.empty()) {
-		Logger::warning("Province image contains ", unrecognised_province_colours.size(), " unrecognised province colours");
-	}
-	if (!unrecognised_terrain_colours.empty()) {
-		Logger::warning("Terrain image contains ", unrecognised_terrain_colours.size(), " unrecognised terrain colours");
-	}
-
-	size_t missing = 0;
-	for (size_t idx = 0; idx < province_checklist.size(); ++idx) {
-		if (!province_checklist[idx]) {
-			if (detailed_errors) {
-				Logger::error("Province missing from shape image: ", provinces.get_item_by_index(idx)->to_string());
-			}
-			missing++;
-		}
-	}
-	if (missing > 0) {
-		Logger::error("Province image is missing ", missing, " province colours");
-		ret = false;
-	}
-
-	ret &= _generate_province_adjacencies();
-
-	return ret;
-}
-
 size_t Map::get_width() const {
 	return width;
 }
@@ -304,6 +195,14 @@ std::vector<Map::shape_pixel_t> const& Map::get_province_shape_image() const {
 	return province_shape_image;
 }
 
+TerrainTypeManager& Map::get_terrain_type_manager() {
+	return terrain_type_manager;
+}
+
+TerrainTypeManager const& Map::get_terrain_type_manager() const {
+	return terrain_type_manager;
+}
+
 bool Map::add_mapmode(const std::string_view identifier, Mapmode::colour_func_t colour_func) {
 	if (identifier.empty()) {
 		Logger::error("Invalid mapmode identifier - empty!");
@@ -443,7 +342,7 @@ bool Map::load_province_definitions(std::vector<LineObject> const& lines) {
 		[this, &ret](LineObject const& line) -> void {
 			const std::string_view identifier = line.get_value_for(0);
 			if (!identifier.empty()) {
-				colour_t colour;
+				colour_t colour = NULL_COLOUR;
 				if (!parse_province_colour(colour,
 					{ line.get_value_for(1), line.get_value_for(2), line.get_value_for(3) }
 				)) {
@@ -504,6 +403,138 @@ bool Map::load_region_file(ast::NodeCPtr root) {
 	return ret;
 }
 
+static constexpr colour_t colour_at(uint8_t const* colour_data, int32_t idx) {
+	/* colour_data is filled with BGR byte triplets - to get pixel idx as a
+	 * single RGB value, multiply idx by 3 to get the index of the corresponding
+	 * triplet, then combine the bytes in reverse order. 
+	 */
+	idx *= 3;
+	return (colour_data[idx + 2] << 16) | (colour_data[idx + 1] << 8) | colour_data[idx];
+}
+
+bool Map::load_map_images(fs::path const& province_path, fs::path const& terrain_path, bool detailed_errors) {
+	if (!provinces.is_locked()) {
+		Logger::error("Province index image cannot be generated until after provinces are locked!");
+		return false;
+	}
+	if (!terrain_type_manager.terrain_type_mappings_are_locked()) {
+		Logger::error("Province index image cannot be generated until after terrain type mappings are locked!");
+		return false;
+	}
+
+	BMP province_bmp;
+	if (!(province_bmp.open(province_path) && province_bmp.read_header() && province_bmp.read_pixel_data())) {
+		Logger::error("Failed to read BMP for compatibility mode province image: ", province_path);
+		return false;
+	}
+	static constexpr uint16_t expected_province_bpp = 24;
+	if (province_bmp.get_bits_per_pixel() != expected_province_bpp) {
+		Logger::error("Invalid province BMP bits per pixel: ", province_bmp.get_bits_per_pixel(), " (expected ", expected_province_bpp, ")");
+		return false;
+	}
+
+	BMP terrain_bmp;
+	if (!(terrain_bmp.open(terrain_path) && terrain_bmp.read_header() && terrain_bmp.read_pixel_data())) {
+		Logger::error("Failed to read BMP for compatibility mode terrain image: ", terrain_path);
+		return false;
+	}
+	static constexpr uint16_t expected_terrain_bpp = 8;
+	if (terrain_bmp.get_bits_per_pixel() != expected_terrain_bpp) {
+		Logger::error("Invalid terrain BMP bits per pixel: ", terrain_bmp.get_bits_per_pixel(), " (expected ", expected_terrain_bpp, ")");
+		return false;
+	}
+
+	if (province_bmp.get_width() != terrain_bmp.get_width() || province_bmp.get_height() != terrain_bmp.get_height()) {
+		Logger::error("Mismatched province and terrain BMP dims: ", province_bmp.get_width(), "x", province_bmp.get_height(), " vs ", terrain_bmp.get_width(), "x", terrain_bmp.get_height());
+		return false;
+	}
+
+	width = province_bmp.get_width();
+	height = province_bmp.get_height();
+	province_shape_image.resize(width * height);
+
+	uint8_t const* province_data = province_bmp.get_pixel_data().data();
+	uint8_t const* terrain_data = terrain_bmp.get_pixel_data().data();
+
+	std::vector<bool> province_checklist(provinces.size());
+	std::vector<distribution_t> terrain_type_pixels_list(provinces.size());
+	bool ret = true;
+	std::unordered_set<colour_t> unrecognised_province_colours;
+
+	for (size_t y = 0; y < height; ++y) {
+		for (size_t x = 0; x < width; ++x) {
+			const size_t idx = x + y * width;
+
+			const colour_t province_colour = colour_at(province_data, idx);
+			if (x > 0) {
+				const size_t jdx = idx - 1;
+				if (colour_at(province_data, jdx) == province_colour) {
+					province_shape_image[idx].index = province_shape_image[jdx].index;
+					goto set_terrain;
+				}
+			}
+			if (y > 0) {
+				const size_t jdx = idx - width;
+				if (colour_at(province_data, jdx) == province_colour) {
+					province_shape_image[idx].index = province_shape_image[jdx].index;
+					goto set_terrain;
+				}
+			}
+			{
+				const Province::index_t index = get_index_from_colour(province_colour);
+				if (index != Province::NULL_INDEX) {
+					province_checklist[index - 1] = true;
+					province_shape_image[idx].index = index;
+					goto set_terrain;
+				}
+			}
+			if (unrecognised_province_colours.find(province_colour) == unrecognised_province_colours.end()) {
+				unrecognised_province_colours.insert(province_colour);
+				if (detailed_errors) {
+					Logger::warning("Unrecognised province colour ", colour_to_hex_string(province_colour),
+						" at (", x, ", ", y, ")");
+				}
+			}
+			province_shape_image[idx].index = Province::NULL_INDEX;
+
+		set_terrain:
+			const TerrainTypeMapping::index_t terrain = terrain_data[idx];
+			TerrainTypeMapping const* mapping = terrain_type_manager.get_terrain_type_mapping_for(terrain);
+			if (mapping != nullptr) {
+				if (province_shape_image[idx].index != Province::NULL_INDEX) {
+					terrain_type_pixels_list[province_shape_image[idx].index - 1][&mapping->get_type()]++;
+				}
+
+				province_shape_image[idx].terrain = mapping->get_has_texture() && terrain < terrain_type_manager.get_terrain_texture_limit() ? terrain + 1 : 0;
+			} else {
+				province_shape_image[idx].terrain = 0;
+			}
+		}
+	}
+
+	if (!unrecognised_province_colours.empty()) {
+		Logger::warning("Province image contains ", unrecognised_province_colours.size(), " unrecognised province colours");
+	}
+
+	size_t missing = 0;
+	for (size_t idx = 0; idx < province_checklist.size(); ++idx) {
+		Province* province = provinces.get_item_by_index(idx);
+		province->_set_terrain_type(reinterpret_cast<TerrainType const*>(get_largest_item(terrain_type_pixels_list[idx]).first));
+		if (!province_checklist[idx]) {
+			if (detailed_errors) {
+				Logger::error("Province missing from shape image: ", province->to_string());
+			}
+			missing++;
+		}
+	}
+	if (missing > 0) {
+		Logger::error("Province image is missing ", missing, " province colours");
+		ret = false;
+	}
+
+	return ret;
+}
+
 /* REQUIREMENTS:
  * MAP-19, MAP-84
  */
@@ -531,3 +562,9 @@ bool Map::_generate_province_adjacencies() {
 
 	return changed;
 }
+
+bool Map::generate_and_load_province_adjacencies(std::vector<ovdl::csv::LineObject> const& additional_adjacencies) {
+	bool ret = _generate_province_adjacencies();
+	// TODO - read additional adjacencies
+	return ret;
+}
diff --git a/src/openvic-simulation/map/Map.hpp b/src/openvic-simulation/map/Map.hpp
index f81b9c1..99c0bce 100644
--- a/src/openvic-simulation/map/Map.hpp
+++ b/src/openvic-simulation/map/Map.hpp
@@ -1,12 +1,15 @@
 #pragma once
 
+#include <filesystem>
 #include <functional>
 
 #include <openvic-dataloader/csv/LineObject.hpp>
 
 #include "openvic-simulation/map/Region.hpp"
+#include "openvic-simulation/map/TerrainType.hpp"
 
 namespace OpenVic {
+	namespace fs = std::filesystem;
 
 	struct Mapmode : HasIdentifier {
 		friend struct Map;
@@ -35,14 +38,12 @@ namespace OpenVic {
 	 * MAP-4
 	 */
 	struct Map {
-		using terrain_t = uint8_t;
-		using terrain_variant_map_t = std::map<colour_t, terrain_t>;
 
 #pragma pack(push, 1)
 		/* Used to represent tightly packed 3-byte integer pixel information. */
 		struct shape_pixel_t {
 			Province::index_t index;
-			terrain_t terrain;
+			TerrainTypeMapping::index_t terrain;
 		};
 #pragma pack(pop)
 	private:
@@ -52,13 +53,14 @@ namespace OpenVic {
 		IdentifierRegistry<Region> regions;
 		IdentifierRegistry<Mapmode> mapmodes;
 		ProvinceSet water_provinces;
+		TerrainTypeManager terrain_type_manager;
 
 		size_t width = 0, height = 0;
 		std::vector<shape_pixel_t> province_shape_image;
 		colour_index_map_t colour_index_map;
+
 		Province::index_t max_provinces = Province::MAX_INDEX;
 		Province::index_t selected_province = Province::NULL_INDEX;
-
 		Pop::pop_size_t highest_province_population, total_map_population;
 
 		Province::index_t get_index_from_colour(colour_t colour) const;
@@ -70,12 +72,10 @@ namespace OpenVic {
 		bool add_province(const std::string_view identifier, colour_t colour);
 		IDENTIFIER_REGISTRY_ACCESSORS(Province, province)
 		IDENTIFIER_REGISTRY_NON_CONST_ACCESSORS(Province, province)
+
 		bool set_water_province(const std::string_view identifier);
 		bool set_water_province_list(std::vector<std::string_view> const& list);
 		void lock_water_provinces();
-		bool add_region(const std::string_view identifier, std::vector<std::string_view> const& province_identifiers);
-		IDENTIFIER_REGISTRY_ACCESSORS(Region, region)
-		IDENTIFIER_REGISTRY_NON_CONST_ACCESSORS(Region, region)
 
 		Province* get_province_by_index(Province::index_t index);
 		Province const* get_province_by_index(Province::index_t index) const;
@@ -86,11 +86,15 @@ namespace OpenVic {
 		Province::index_t get_selected_province_index() const;
 		Province const* get_selected_province() const;
 
-		bool generate_province_shape_image(size_t new_width, size_t new_height, uint8_t const* colour_data,
-			uint8_t const* terrain_data, terrain_variant_map_t const& terrain_variant_map, bool detailed_errors);
 		size_t get_width() const;
 		size_t get_height() const;
 		std::vector<shape_pixel_t> const& get_province_shape_image() const;
+		TerrainTypeManager& get_terrain_type_manager();
+		TerrainTypeManager const& get_terrain_type_manager() const;
+
+		bool add_region(const std::string_view identifier, std::vector<std::string_view> const& province_identifiers);
+		IDENTIFIER_REGISTRY_ACCESSORS(Region, region)
+		IDENTIFIER_REGISTRY_NON_CONST_ACCESSORS(Region, region)
 
 		bool add_mapmode(const std::string_view identifier, Mapmode::colour_func_t colour_func);
 		IDENTIFIER_REGISTRY_ACCESSORS(Mapmode, mapmode)
@@ -111,5 +115,7 @@ namespace OpenVic {
 		bool load_province_definitions(std::vector<ovdl::csv::LineObject> const& lines);
 		bool load_province_positions(BuildingManager const& building_manager, ast::NodeCPtr root);
 		bool load_region_file(ast::NodeCPtr root);
+		bool load_map_images(fs::path const& province_path, fs::path const& terrain_path, bool detailed_errors);
+		bool generate_and_load_province_adjacencies(std::vector<ovdl::csv::LineObject> const& additional_adjacencies);
 	};
 }
diff --git a/src/openvic-simulation/map/Province.cpp b/src/openvic-simulation/map/Province.cpp
index c1e96e9..ef574cf 100644
--- a/src/openvic-simulation/map/Province.cpp
+++ b/src/openvic-simulation/map/Province.cpp
@@ -6,6 +6,8 @@
 #include <iterator>
 #include <sstream>
 
+#include "openvic-simulation/map/TerrainType.hpp"
+
 using namespace OpenVic;
 using namespace OpenVic::NodeTools;
 
@@ -32,6 +34,10 @@ bool Province::get_water() const {
 	return water;
 }
 
+TerrainType const* Province::get_terrain_type() const {
+	return terrain_type;
+}
+
 Province::life_rating_t Province::get_life_rating() const {
 	return life_rating;
 }
@@ -149,7 +155,7 @@ Province::distance_t Province::adjacency_t::get_distance() const {
 	return distance;
 }
 
-Province::flags_t Province::adjacency_t::get_flags() {
+Province::flags_t Province::adjacency_t::get_flags() const {
 	return flags;
 }
 
@@ -175,3 +181,7 @@ bool Province::add_adjacency(Province const* province, distance_t distance, flag
 std::vector<Province::adjacency_t> const& Province::get_adjacencies() const {
 	return adjacencies;
 }
+
+void Province::_set_terrain_type(TerrainType const* type) {
+		terrain_type = type;
+}
diff --git a/src/openvic-simulation/map/Province.hpp b/src/openvic-simulation/map/Province.hpp
index 0a4aa46..6e4ac7e 100644
--- a/src/openvic-simulation/map/Province.hpp
+++ b/src/openvic-simulation/map/Province.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <limits>
+
 #include "openvic-simulation/map/Building.hpp"
 #include "openvic-simulation/pop/Pop.hpp"
 
@@ -7,6 +9,8 @@ namespace OpenVic {
 	struct Map;
 	struct Region;
 	struct Good;
+	struct TerrainType;
+	struct TerrainTypeMapping;
 
 	/* REQUIREMENTS:
 	 * MAP-5, MAP-7, MAP-8, MAP-43, MAP-47
@@ -32,10 +36,10 @@ namespace OpenVic {
 
 		public:
 			distance_t get_distance() const;
-			flags_t get_flags();
+			flags_t get_flags() const;
 		};
 
-		static constexpr index_t NULL_INDEX = 0, MAX_INDEX = (1 << (8 * sizeof(index_t))) - 1;
+		static constexpr index_t NULL_INDEX = 0, MAX_INDEX = std::numeric_limits<index_t>::max();
 
 	private:
 		const index_t index;
@@ -52,6 +56,10 @@ namespace OpenVic {
 
 		std::vector<adjacency_t> adjacencies;
 
+		TerrainType const* terrain_type = nullptr;
+
+		void _set_terrain_type(TerrainType const* type);
+
 		Province(const std::string_view new_identifier, colour_t new_colour, index_t new_index);
 
 	public:
@@ -61,6 +69,7 @@ namespace OpenVic {
 		Region* get_region() const;
 		bool get_has_region() const;
 		bool get_water() const;
+		TerrainType const* get_terrain_type() const;
 		life_rating_t get_life_rating() const;
 		bool load_positions(BuildingManager const& building_manager, ast::NodeCPtr root);
 
diff --git a/src/openvic-simulation/map/TerrainType.cpp b/src/openvic-simulation/map/TerrainType.cpp
new file mode 100644
index 0000000..3134332
--- /dev/null
+++ b/src/openvic-simulation/map/TerrainType.cpp
@@ -0,0 +1,212 @@
+#include "TerrainType.hpp"
+
+#include <limits>
+
+using namespace OpenVic;
+using namespace OpenVic::NodeTools;
+
+TerrainType::TerrainType(const std::string_view new_identifier, colour_t new_colour, ModifierValue&& new_values, bool new_is_water)
+	: HasIdentifierAndColour { new_identifier, new_colour, true, false }, ModifierValue { std::move(new_values) }, is_water { new_is_water } {}
+
+bool TerrainType::get_is_water() const {
+	return is_water;
+}
+
+TerrainTypeMapping::TerrainTypeMapping(const std::string_view new_identifier, TerrainType const& new_type,
+	std::vector<index_t>&& new_terrain_indicies, index_t new_priority, bool new_has_texture)
+	: HasIdentifier { new_identifier }, type { new_type }, terrain_indicies { std::move(new_terrain_indicies) },
+	  priority { new_priority }, has_texture { new_has_texture } {}
+
+TerrainType const& TerrainTypeMapping::get_type() const {
+	return type;
+}
+
+std::vector<TerrainTypeMapping::index_t> const& TerrainTypeMapping::get_terrain_indicies() const {
+	return terrain_indicies;
+}
+
+TerrainTypeMapping::index_t TerrainTypeMapping::get_priority() const {
+	return priority;
+}
+
+bool TerrainTypeMapping::get_has_texture() const {
+	return has_texture;
+}
+
+TerrainTypeManager::TerrainTypeManager() : terrain_types { "terrain types" }, terrain_type_mappings { "terrain type mappings" } {}
+
+bool TerrainTypeManager::add_terrain_type(const std::string_view identifier, colour_t colour, ModifierValue&& values, bool is_water) {
+	if (identifier.empty()) {
+		Logger::error("Invalid terrain type identifier - empty!");
+		return false;
+	}
+	if (colour > MAX_COLOUR_RGB) {
+		Logger::error("Invalid terrain type colour for ", identifier, ": ", colour_to_hex_string(colour));
+		return false;
+	}
+	return terrain_types.add_item({ identifier, colour, std::move(values), is_water });
+}
+
+bool TerrainTypeManager::add_terrain_type_mapping(const std::string_view identifier, TerrainType const* type,
+	std::vector<TerrainTypeMapping::index_t>&& terrain_indicies, TerrainTypeMapping::index_t priority, bool has_texture) {
+	if (!terrain_types.is_locked()) {
+		Logger::error("Cannot register terrain type mappings until terrain types are locked!");
+		return false;
+	}
+	if (identifier.empty()) {
+		Logger::error("Invalid terrain type mapping identifier - empty!");
+		return false;
+	}
+	if (type == nullptr) {
+		Logger::error("Null terrain type for mapping ", identifier);
+		return false;
+	}
+	bool ret = true;
+	for (TerrainTypeMapping::index_t idx : terrain_indicies) {
+		const terrain_type_mappings_map_t::const_iterator it = terrain_type_mappings_map.find(idx);
+		if (it == terrain_type_mappings_map.end()) {
+			terrain_type_mappings_map.emplace(idx, terrain_type_mappings.size());
+		} else {
+			Logger::error("Terrain index ", static_cast<size_t>(idx), " cannot map to ", identifier,
+				" as it already maps to ", terrain_type_mappings.get_item_by_index(it->second));
+			ret = false;
+		}
+	}
+	ret &= terrain_type_mappings.add_item({ identifier, *type, std::move(terrain_indicies), priority, has_texture });
+	return ret;
+}
+
+bool TerrainTypeManager::_load_terrain_type_categories(ModifierManager const& modifier_manager, ast::NodeCPtr root) {
+	const bool ret = expect_dictionary_reserve_length(terrain_types,
+		[this, &modifier_manager](std::string_view type_key, ast::NodeCPtr type_node) -> bool {
+			ModifierValue values;
+			colour_t colour = NULL_COLOUR;
+			bool is_water = false;
+			bool has_colour = false, has_is_water = false;
+			bool ret = modifier_manager.expect_modifier_value(move_variable_callback(values),
+				[&colour, &has_colour, &is_water, &has_is_water](std::string_view key, ast::NodeCPtr value) -> bool {
+					if (key == "color") {
+						if (!has_colour) {
+							has_colour = true;
+							return expect_colour(assign_variable_callback(colour))(value);
+						} else {
+							Logger::error("Duplicate terrain type colour key!");
+							return false;
+						}
+					} else if (key == "is_water") {
+						if (!has_is_water) {
+							has_is_water = true;
+							return expect_bool(assign_variable_callback(is_water))(value);
+						} else {
+							Logger::error("Duplicate terrain type is_water key!");
+							return false;
+						}
+					} else {
+						Logger::error("Invalid terrain type entry key: ", key);
+						return false;
+					}
+				} 
+			)(type_node);
+			if (!has_colour) {
+				Logger::error("Terrain type missing color key: ", type_key);
+				ret = false;
+			}
+			ret &= add_terrain_type(type_key, colour, std::move(values), is_water);
+			return ret;
+		}
+	)(root);
+	terrain_types.lock();
+	return ret;
+}
+
+bool TerrainTypeManager::_load_terrain_type_mapping(std::string_view mapping_key, ast::NodeCPtr mapping_value) {
+	TerrainType const* type = nullptr;
+	std::vector<TerrainTypeMapping::index_t> terrain_indicies;
+	TerrainTypeMapping::index_t priority = 0;
+	bool has_texture = true;
+
+	bool ret = expect_dictionary_keys(
+		"type", ONE_EXACTLY, expect_terrain_type_identifier(assign_variable_callback_pointer(type)),
+		"color", ONE_EXACTLY, expect_list_reserve_length(terrain_indicies, expect_uint(
+			[&terrain_indicies](uint64_t val) -> bool {
+				if (val <= std::numeric_limits<TerrainTypeMapping::index_t>::max()) {
+					TerrainTypeMapping::index_t index = val;
+					if (std::find(terrain_indicies.begin(), terrain_indicies.end(), index) == terrain_indicies.end()) {
+						terrain_indicies.push_back(val);
+						return true;
+					}
+					Logger::error("Repeat terrain type mapping index: ", val);
+					return false;
+				}
+				Logger::error("Index too big for terrain type mapping index: ", val);
+				return false;
+			}
+		)),
+		"priority", ZERO_OR_ONE, expect_uint(assign_variable_callback_uint("terrain type mapping priority", priority)),
+		"has_texture", ZERO_OR_ONE, expect_bool(assign_variable_callback(has_texture))
+	)(mapping_value);
+	if (has_texture) {
+		if (++terrain_texture_count == terrain_texture_limit + 1) {
+			Logger::error("More terrain textures than limit!");
+			ret = false;
+		}
+	}
+	ret &= add_terrain_type_mapping(mapping_key, type, std::move(terrain_indicies), priority, has_texture);
+	return true;
+}
+
+TerrainTypeMapping const* TerrainTypeManager::get_terrain_type_mapping_for(TerrainTypeMapping::index_t idx) const {
+	const terrain_type_mappings_map_t::const_iterator it = terrain_type_mappings_map.find(idx);
+	if (it != terrain_type_mappings_map.end()) {
+		return terrain_type_mappings.get_item_by_index(it->second);
+	}
+	return nullptr;
+}
+
+TerrainTypeMapping::index_t TerrainTypeManager::get_terrain_texture_limit() const {
+	return terrain_texture_limit;
+}
+
+bool TerrainTypeManager::load_terrain_types(ModifierManager const& modifier_manager, ast::NodeCPtr root) {
+	bool terrain = false, categories = false;
+	bool ret = expect_dictionary_and_length(
+		[this](size_t size) -> size_t {
+			terrain_type_mappings.reserve(size - 2);
+			return size;
+		},
+		[this, &terrain, &categories, &modifier_manager](std::string_view key, ast::NodeCPtr value) -> bool {
+			if (key == "terrain") {
+				if (!terrain) {
+					terrain = true;
+					return expect_uint(assign_variable_callback_uint("terrain texture limit", terrain_texture_limit))(value);
+				} else {
+					Logger::error("Duplicate terrain key!");
+					return false;
+				}
+			} else if (key == "categories") {
+				if (!categories) {
+					categories = true;
+					return _load_terrain_type_categories(modifier_manager, value);
+				} else {
+					Logger::error("Duplicate categories key!");
+					return false;
+				}
+			} else if (terrain && categories) {
+				return _load_terrain_type_mapping(key, value);
+			} else {
+				Logger::error("Cannot define terrain type mapping before terrain and categories keys: ", key);
+				return false;
+			}
+		}
+	)(root);
+	if (!terrain) {
+		Logger::error("Missing expected key: \"terrain\"");
+		ret = false;
+	}
+	if (!categories) {
+		Logger::error("Missing expected key: \"categories\"");
+		ret = false;
+	}
+	terrain_type_mappings.lock();
+	return ret;
+}
diff --git a/src/openvic-simulation/map/TerrainType.hpp b/src/openvic-simulation/map/TerrainType.hpp
new file mode 100644
index 0000000..0cc28c2
--- /dev/null
+++ b/src/openvic-simulation/map/TerrainType.hpp
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "openvic-simulation/Modifier.hpp"
+
+namespace OpenVic {
+	struct TerrainTypeManager;
+
+	struct TerrainType : HasIdentifierAndColour, ModifierValue {
+		friend struct TerrainTypeManager;
+
+	private:
+		const bool is_water;
+
+		TerrainType(const std::string_view new_identifier, colour_t new_colour, ModifierValue&& new_values, bool new_is_water);
+
+	public:
+		TerrainType(TerrainType&&) = default;
+
+		bool get_is_water() const;
+	};
+
+	struct TerrainTypeMapping : HasIdentifier {
+		friend struct TerrainTypeManager;
+
+		using index_t = uint8_t;
+
+	private:
+		TerrainType const& type;
+		const std::vector<index_t> terrain_indicies;
+		const index_t priority;
+		const bool has_texture;
+
+		TerrainTypeMapping(const std::string_view new_identifier, TerrainType const& new_type, std::vector<index_t>&& new_terrain_indicies, index_t new_priority, bool new_has_texture);
+
+	public:
+		TerrainTypeMapping(TerrainTypeMapping&&) = default;
+
+		TerrainType const& get_type() const;
+		std::vector<index_t> const& get_terrain_indicies() const;
+		index_t get_priority() const;
+		bool get_has_texture() const;
+	};
+
+	struct TerrainTypeManager {
+	private:
+		using terrain_type_mappings_map_t = std::map<TerrainTypeMapping::index_t, size_t>;
+		IdentifierRegistry<TerrainType> terrain_types;
+		IdentifierRegistry<TerrainTypeMapping> terrain_type_mappings;
+		terrain_type_mappings_map_t terrain_type_mappings_map;
+
+		TerrainTypeMapping::index_t terrain_texture_limit = 0, terrain_texture_count = 0;
+
+		bool _load_terrain_type_categories(ModifierManager const& modifier_manager, ast::NodeCPtr root);
+		bool _load_terrain_type_mapping(std::string_view key, ast::NodeCPtr value);
+
+	public:
+		TerrainTypeManager();
+
+		bool add_terrain_type(const std::string_view identifier, colour_t colour, ModifierValue&& values, bool is_water);
+		IDENTIFIER_REGISTRY_ACCESSORS(TerrainType, terrain_type)
+
+		bool add_terrain_type_mapping(const std::string_view identifier, TerrainType const* type,
+			std::vector<TerrainTypeMapping::index_t>&& terrain_indicies, TerrainTypeMapping::index_t priority, bool has_texture);
+		IDENTIFIER_REGISTRY_ACCESSORS(TerrainTypeMapping, terrain_type_mapping)
+
+		TerrainTypeMapping const* get_terrain_type_mapping_for(TerrainTypeMapping::index_t idx) const;
+
+		TerrainTypeMapping::index_t get_terrain_texture_limit() const;
+
+		bool load_terrain_types(ModifierManager const& modifier_manager, ast::NodeCPtr root);
+	};
+}