Method generateMap

game/state/rules/battle/battlemap.cpp:578–914

} // namespace

bool BattleMap::generateMap(std::vector<sp<BattleMapSector>> &sec_map, Vec3<int> &size,
                            GameState &state, GenerationSize genSize)
{
	// Vanilla had vertical stacking of sectors planned, but not implemented. I will implement both
	// algorithms because I think that would be great to have. We could make it an extended game
	// option in the future.
	bool allow_vertical_stacking = true;

	// This switch will allow larger maps, +2 in size, which vanilla never did I think, and which is
	// required for some vertical stacking maps to actually spawn because they contain too many
	// mandatory sectors to fit into battle size even when enlarged by 1 on the smaller side
	bool allow_very_large_maps = true;

	// This switch allows maps to spawn only one of the mandatory sectors instead of
	// every single one
	// This provides for vertical stacking maps to be possible without huge sizes, but may
	// theoretically produce maps with no way to the upper layers
	// In practice, however, every vertical-stacking map's sector with more than one vertical chunk
	// I seen provides access to the second level
	// So that should never be a problem
	bool require_only_largest_mandatory_sector = true;

	// Vanilla had some rules that shrunk or extended maps based on squad size.
	// For example, 28SLUMS has max_y_size = 2, but often spawns a single block, because it's 9
	// layers high, big enough to fit everything.
	// OTOH, 14ACNORM has 2x2 max size, but often spawns 3x2 because it's only 2 layers high, and
	// 2nd layer is just air (high ceiling)
	// As we do not know them yet, I will generate maps in 3 modes for now: small, normal, big
	// Small being a -1 on the larger side and Big being +1 or +2 on a random side.
	// +2 is required for some maps with vertical stacking to fit all the mandatory sectors
	// For now, this is random, in the future, this will be tied to the amount of troops
	int size_mod =
	    genSize == GenerationSize::Small ? -1 : (genSize == GenerationSize::Normal ? 0 : 1);
	if (genSize == GenerationSize::VeryLarge)
	{
		if (allow_very_large_maps)
		{
			size_mod++;
		}
		else
		{
			LogWarning("Cannot generate a map %s with gen size %d since generating large maps is "
			           "disabled",
			           id, (int)genSize);
			return false;
		}
	}
	// Vertical stacking is also randomized, and disabled if the map does not allow it
	allow_vertical_stacking =
	    allow_vertical_stacking && max_battle_size.z > 1 && randBool(state.rng);
	// This switch is only relevant if we're vertically stacking
	require_only_largest_mandatory_sector =
	    require_only_largest_mandatory_sector && allow_vertical_stacking;
	// However, there are maps that have too many mandatory sectors
	// For these maps, we must set this switch, otherwise it's not possible to create a map!
	if (!require_only_largest_mandatory_sector)
	{
		int remainingMapSize = max_battle_size.x * max_battle_size.y * max_battle_size.z;