~widelands-dev/widelands/trunk

/*

 * Copyright (C) 2002-2025 by the Widelands Development Team

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, see <https://www.gnu.org/licenses/>.

 *

 */

#ifndef WL_LOGIC_MAP_OBJECTS_TRIBES_TRIBE_DESCR_H

#define WL_LOGIC_MAP_OBJECTS_TRIBES_TRIBE_DESCR_H

#include <memory>

#include "base/macros.h"

#include "graphic/animation/animation.h"

#include "graphic/toolbar_imageset.h"

#include "logic/map_objects/descriptions.h"

#include "logic/map_objects/immovable.h"

#include "logic/map_objects/tribes/building.h"

#include "logic/map_objects/tribes/road_textures.h"

#include "logic/map_objects/tribes/tribe_basic_info.h"

#include "logic/map_objects/tribes/ware_descr.h"

#include "logic/map_objects/tribes/worker.h"

#include "logic/map_objects/world/resource_description.h"

#include "logic/widelands.h"

namespace Widelands {

/*

 * Resource indicators:

 * A ResourceIndicatorSet maps the resource name to a ResourceIndicatorList.

 * A ResourceIndicatorList maps resource amounts to the DescriptionIndex of an immovable this player

 * uses.

 * Special case: The ResourceIndicatorList mapped to "" contains resis that will be used in

 * locations

 * without resources. If it has several entries, result is arbitrary.

 */

using ResourceIndicatorList = std::map<uint32_t, DescriptionIndex>;

using ResourceIndicatorSet = std::map<std::string, ResourceIndicatorList>;

/*

Tribes

------

Every player chooses a tribe. A tribe has distinct properties such as the

buildings it can build and the associated graphics.

Two players can choose the same tribe.

*/

class TribeDescr {

public:

	TribeDescr(const Widelands::TribeBasicInfo& info,

	           Descriptions& descriptions,

	           const LuaTable& table,

	           const LuaTable* scenario_table = nullptr);

	[[nodiscard]] const std::string& name() const;

	[[nodiscard]] const std::string& descname() const;

	[[nodiscard]] size_t get_nrwares() const;

	[[nodiscard]] size_t get_nrworkers() const;

	[[nodiscard]] const std::set<DescriptionIndex>& buildings() const;

	[[nodiscard]] const std::set<DescriptionIndex>& wares() const;

	[[nodiscard]] const std::set<DescriptionIndex>& workers() const;

	[[nodiscard]] const std::set<DescriptionIndex>& immovables() const;

	[[nodiscard]] const ResourceIndicatorSet& resource_indicators() const;

	std::set<DescriptionIndex>& mutable_wares();

	std::set<DescriptionIndex>& mutable_workers();

	std::set<DescriptionIndex>& mutable_buildings();

	std::set<DescriptionIndex>& mutable_immovables();

	[[nodiscard]] bool has_building(const DescriptionIndex& index) const;

	[[nodiscard]] bool has_ware(const DescriptionIndex& index) const;

	[[nodiscard]] bool has_worker(const DescriptionIndex& index) const;

	[[nodiscard]] bool has_immovable(const DescriptionIndex& index) const;

	// A ware is a construction material if it appears in a building's buildcost or enhancement cost

	[[nodiscard]] bool is_construction_material(const DescriptionIndex& ware_index) const;

	[[nodiscard]] DescriptionIndex building_index(const std::string& buildingname) const;

	[[nodiscard]] DescriptionIndex immovable_index(const std::string& immovablename) const;

	[[nodiscard]] DescriptionIndex ware_index(const std::string& warename) const;

	[[nodiscard]] DescriptionIndex worker_index(const std::string& workername) const;

	/// Return the given building or die trying

	[[nodiscard]] DescriptionIndex safe_building_index(const std::string& buildingname) const;

	/// Return the given ware or die trying

	[[nodiscard]] DescriptionIndex safe_ware_index(const std::string& warename) const;

	/// Return the given worker or die trying

	[[nodiscard]] DescriptionIndex safe_worker_index(const std::string& workername) const;

	[[nodiscard]] BuildingDescr const* get_building_descr(const DescriptionIndex& index) const;

	[[nodiscard]] ImmovableDescr const* get_immovable_descr(const DescriptionIndex& index) const;

	[[nodiscard]] WareDescr const* get_ware_descr(const DescriptionIndex& index) const;

	[[nodiscard]] WorkerDescr const* get_worker_descr(const DescriptionIndex& index) const;

	[[nodiscard]] DescriptionIndex builder() const;

	[[nodiscard]] DescriptionIndex geologist() const;

	[[nodiscard]] DescriptionIndex scouts_house() const;

	[[nodiscard]] DescriptionIndex soldier() const;

	[[nodiscard]] DescriptionIndex ship() const;

	[[nodiscard]] DescriptionIndex ferry() const;

	[[nodiscard]] DescriptionIndex port() const;

	[[nodiscard]] const std::vector<DescriptionIndex>& carriers() const {

		return carriers_;

	}

	[[nodiscard]] const std::vector<DescriptionIndex>& trainingsites() const;

	[[nodiscard]] const std::vector<DescriptionIndex>& worker_types_without_cost() const;

	[[nodiscard]] uint32_t frontier_animation() const;

	[[nodiscard]] uint32_t flag_animation() const;

	[[nodiscard]] uint32_t pinned_note_animation() const;

	[[nodiscard]] uint32_t bridge_animation(uint8_t dir, bool busy) const;

	// Bridge height in pixels at 1x scale, for drawing bobs walking over a bridge

	[[nodiscard]] uint32_t bridge_height() const;

	// The road textures used for drawing roads and waterways.

	[[nodiscard]] const RoadTextures& road_textures() const;

	DescriptionIndex get_resource_indicator(const ResourceDescription* res,

	                                        ResourceAmount amount) const;

	// Returns the initalization at 'index' (which must not be out of bounds).

	[[nodiscard]] const Widelands::TribeBasicInfo::Initialization&

	initialization(const uint8_t index) const {

		return basic_info_.initializations.at(index);

	}

	[[nodiscard]] const Widelands::TribeBasicInfo& basic_info() const {

		return basic_info_;

	}

	using WaresOrder = std::vector<std::vector<Widelands::DescriptionIndex>>;

	[[nodiscard]] const WaresOrder& wares_order() const {

		return wares_order_;

	}

	WaresOrder& mutable_wares_order() {

		return wares_order_;

	}

	[[nodiscard]] const WaresOrder& workers_order() const {

		return workers_order_;

	}

	WaresOrder& mutable_workers_order() {

		return workers_order_;

	}

	[[nodiscard]] bool uses_resource(const std::string& name) const {

		return used_resources_.count(name) != 0u;

	}

	// Warning: Do not use pointer arithmetics in logic code!

	[[nodiscard]] const std::set<const BuildingDescr*>& buildings_built_over_immovables() const {

		return buildings_built_over_immovables_;

	}

	[[nodiscard]] const std::vector<std::pair<std::string, int>>& collectors_points_table() const {

		return collectors_points_table_;

	}

	[[nodiscard]] const std::vector<std::string>& get_warehouse_names() const {

		return warehouse_names_;

	}

	[[nodiscard]] const std::string& get_productionsite_worker_missing_string() const {

		return productionsite_worker_missing_;

	}

	[[nodiscard]] const std::string& get_productionsite_worker_coming_string() const {

		return productionsite_worker_coming_;

	}

	[[nodiscard]] const std::string& get_productionsite_workers_missing_string() const {

		return productionsite_workers_missing_;

	}

	[[nodiscard]] const std::string& get_productionsite_workers_coming_string() const {

		return productionsite_workers_coming_;

	}

	[[nodiscard]] const std::string& get_productionsite_experienced_worker_missing_string() const {

		return productionsite_experienced_worker_missing_;

	}

	[[nodiscard]] const std::string& get_productionsite_experienced_workers_missing_string() const {

		return productionsite_experienced_workers_missing_;

	}

	enum class CapacityStringIndex { kLacking = 0, kFull = 1, kOutAndLacking = 2, kOut = 3 };

	// Return the translated format string for case `index` and plural form according to

	// `number_to_format`

	[[nodiscard]] std::string get_soldiers_format_string(CapacityStringIndex index,

	                                                     int number_to_format) const;

	// The custom toolbar imageset if any. Can be nullptr.

	[[nodiscard]] ToolbarImageset* toolbar_image_set() const;

	[[nodiscard]] const std::map<std::string /* key */, std::string /* building */>&

	fastplace_defaults() const {

		return fastplace_defaults_;

	}

	// Read helptext from Lua table

	void load_helptexts(MapObjectDescr* descr, const LuaTable& table) const;

	// Make sure that everything is there and that dependencies are calculated.

	// This needs to be called exactly once during postloading.

	void finalize_loading(Descriptions& descriptions);

private:

	// Helper functions for loading everything in the constructor

	void load_frontiers_flags_roads(const LuaTable& table);

	void load_ships(const LuaTable& table, Descriptions& descriptions);

	void load_wares(const LuaTable& table, Descriptions& descriptions);

	void load_immovables(const LuaTable& table, Descriptions& descriptions);

	void load_workers(const LuaTable& table, Descriptions& descriptions);

	void load_buildings(const LuaTable& table, Descriptions& descriptions);

	// Helper function for adding a special worker type (carriers etc.)

	DescriptionIndex add_special_worker(const std::string& workername,

	                                    Descriptions& descriptions) const;

	// Helper function for adding a special building type (port etc.)

	DescriptionIndex add_special_building(const std::string& buildingname,

	                                      Descriptions& descriptions) const;

	// Helper function to calculate trainingsites proportions for the AI

	void calculate_trainingsites_proportions(const Descriptions& descriptions) const;

	void process_productionsites(Descriptions& descriptions);

	const std::string name_;

	const std::string descname_;

	const Descriptions& descriptions_;

	uint32_t frontier_animation_id_{0U};

	uint32_t flag_animation_id_{0U};

	uint32_t pinned_note_animation_id_{0U};

	struct BridgeAnimationIDs {

		uint32_t e;

		uint32_t se;

		uint32_t sw;

	};

	BridgeAnimationIDs bridges_normal_;

	BridgeAnimationIDs bridges_busy_;

	uint32_t bridge_height_;

	// A container of all texture images that can be used for drawing a

	// (normal|busy) road or a waterway. The images are guaranteed to exist.

	RoadTextures road_textures_;

	std::set<DescriptionIndex> buildings_;

	std::set<DescriptionIndex> immovables_;  // The player immovables

	std::set<DescriptionIndex> workers_;

	std::set<DescriptionIndex> wares_;

	std::set<const BuildingDescr*> buildings_built_over_immovables_;

	std::set<std::string> used_resources_;

	ResourceIndicatorSet resource_indicators_;

	// The wares that are used by construction sites

	std::set<DescriptionIndex> construction_materials_;

	// Special units. Some of them are used by the engine, some are only used by the AI.

	DescriptionIndex builder_;                // The builder for this tribe

	std::vector<DescriptionIndex> carriers_;  // The basic and advanced carriers for this tribe

	DescriptionIndex geologist_;              // This tribe's geologist worker

	DescriptionIndex soldier_;                // The soldier that this tribe uses

	DescriptionIndex ship_;                   // The ship that this tribe uses

	DescriptionIndex ferry_;                  // The ferry that this tribe uses

	DescriptionIndex port_;                   // The port that this tribe uses

	DescriptionIndex scouts_house_;           // This tribe's scout's house/hut

	std::vector<DescriptionIndex> worker_types_without_cost_;

	std::vector<DescriptionIndex> trainingsites_;

	// Order and positioning of wares in the warehouse display

	WaresOrder wares_order_;

	WaresOrder workers_order_;

	std::vector<std::pair<std::string, int>> collectors_points_table_;

	std::vector<std::string> warehouse_names_;

	std::string productionsite_worker_missing_;

	std::string productionsite_workers_missing_;

	std::string productionsite_worker_coming_;

	std::string productionsite_workers_coming_;

	std::string productionsite_experienced_worker_missing_;

	std::string productionsite_experienced_workers_missing_;

	std::string soldier_context_;

	std::string soldier_capacity_strings_sg_[4];

	std::string soldier_capacity_strings_pl_[4];

	// An optional custom imageset for the in-game menu toolbar

	std::unique_ptr<ToolbarImageset> toolbar_image_set_;

	std::map<std::string, std::string> fastplace_defaults_;

	Widelands::TribeBasicInfo basic_info_;

	DISALLOW_COPY_AND_ASSIGN(TribeDescr);

};

}  // namespace Widelands

#endif  // end of include guard: WL_LOGIC_MAP_OBJECTS_TRIBES_TRIBE_DESCR_H