~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_MAP_OBJECT_H

#define WL_LOGIC_MAP_OBJECTS_MAP_OBJECT_H

#include <atomic>

#include "base/macros.h"

#include "commands/command.h"

#include "graphic/animation/animation.h"

#include "graphic/animation/diranimations.h"

#include "graphic/color.h"

#include "graphic/image.h"

#include "logic/map_objects/info_to_draw.h"

#include "logic/map_objects/map_object_type.h"

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

#include "logic/widelands.h"

#include "notifications/signal.h"

#include "scripting/lua_table.h"

class RenderTarget;

namespace Widelands {

class MapObject;

class Player;

/**

 * Base class for descriptions of worker, files and so on. This must just

 * link them together

 */

class MapObjectDescr {

public:

	using AttributeIndex = uint32_t;

	using Attributes = std::vector<AttributeIndex>;

	enum class OwnerType { kWorld, kTribe };

	MapObjectDescr(MapObjectType init_type,

	               const std::string& init_name,

	               const std::string& init_descname);

	MapObjectDescr(MapObjectType init_type,

	               const std::string& init_name,

	               const std::string& init_descname,

	               const LuaTable& table);

	virtual ~MapObjectDescr();

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

		return name_;

	}

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

		return descname_;

	}

	// Type of the MapObjectDescr.

	[[nodiscard]] MapObjectType type() const {

		return type_;

	}

	virtual uint32_t get_animation(const std::string& animname, const MapObject* mo) const;

	[[nodiscard]] uint32_t main_animation() const;

	[[nodiscard]] std::string get_animation_name(uint32_t) const;  ///< needed for save, debug

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

	/// Preload animation graphics at default scale

	void load_graphics() const;

	/// Returns the image for the first frame of the idle animation if the MapObject has animations,

	/// nullptr otherwise

	const Image* representative_image(const RGBColor* player_color = nullptr) const;

	/// Returns the menu image if the MapObject has one, nullptr otherwise

	[[nodiscard]] const Image* icon() const;

	/// Returns the image fileneme for the menu image if the MapObject has one, is empty otherwise

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

	[[nodiscard]] bool has_attribute(AttributeIndex) const;

	[[nodiscard]] const MapObjectDescr::Attributes& attributes() const;

	static AttributeIndex get_attribute_id(const std::string& name, bool add_if_not_exists = false);

	/// Sets a tribe-specific ware or immovable helptext for this MapObject

	void set_helptexts(const std::string& tribename,

	                   std::map<std::string, std::string> localized_helptext);

	/// Gets the tribe-specific ware or immovable helptext for the given tribe. Fails if it doesn't

	/// exist.

	[[nodiscard]] const std::map<std::string, std::string>&

	get_helptexts(const std::string& tribename) const;

	/// Returns whether a tribe-specific helptext exists for the given tribe

	[[nodiscard]] bool has_helptext(const std::string& tribename) const;

protected:

	// Add attributes to the attribute list

	void add_attributes(const std::vector<std::string>& attribs);

	void add_attribute(AttributeIndex attr);

	/// Sets the directional animations in 'anims' with the animations

	/// '<basename>_(ne|e|se|sw|w|nw)'.

	void assign_directional_animation(DirAnimations* anims, const std::string& basename) const;

private:

	void add_animations(const LuaTable& table,

	                    const std::string& animation_directory,

	                    Animation::Type anim_type);

	/// Throws an exception if the MapObjectDescr has no representative image

	void check_representative_image() const;

	using Anims = std::map<std::string, uint32_t>;

	static std::map<std::string, AttributeIndex> attribute_names_;

	Attributes attribute_ids_;

	const MapObjectType type_;    /// Subclasses pick from the enum above

	std::string const name_;      /// The name for internal reference

	std::string const descname_;  /// A localized Descriptive name

	/// Tribe-specific helptexts. Format: <tribename, <category, localized_text>>

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

	Anims anims_;

	std::string icon_filename_;  // Filename for the menu icon

	DISALLOW_COPY_AND_ASSIGN(MapObjectDescr);

};

/**

 * \par Notes on MapObject

 *

 * MapObject is the base class for everything that can be on the map:

 * buildings, animals, decorations, etc... most of the time, however, you'll

 * deal with one of the derived classes, BaseImmovable or Bob.

 *

 * Every MapObject has a unique serial number. This serial number is used as

 * key in the ObjectManager map, and in the safe ObjectPointer.

 *

 * Unless you're perfectly sure about when an object can be destroyed you

 * should use an ObjectPointer or, better yet, the type safe OPtr template.

 * This is not necessary when the relationship and lifetime between objects

 * is well-defined, such as in the relationship between Building and Flag.

 *

 * MapObjects can also have attributes. They are mainly useful for finding

 * objects of a given type (e.g. trees) within a certain radius.

 *

 * \warning DO NOT allocate/free MapObjects directly. Use the appropriate

 * type-dependent create() function for creation, and call die() for removal.

 *

 * \note Convenient creation functions are defined in class Game.

 *

 * When you do create a new object yourself (i.e. when you're implementing one

 * of the create() functions), you need to allocate the object using new,

 * potentially set it up by calling basic functions like set_position(), etc.

 * and then call init(). After that, the object is supposed to

 * be fully created.

 */

/// If you find a better way to do this that doesn't cost a virtual function

/// or additional member variable, go ahead

#define MO_DESCR(type)                                                                             \

public:                                                                                            \

	const type& descr() const {                                                                     \

		return dynamic_cast<const type&>(*descr_);                                                   \

	}

class MapObject {

	friend struct ObjectManager;

	friend struct ObjectPointer;

	MO_DESCR(MapObjectDescr)

public:

	virtual ~MapObject() = default;

	struct LogSink {

		virtual void log(const std::string& str) = 0;

		virtual ~LogSink() = default;

	};

	virtual void load_finish(EditorGameBase&) {

	}

	virtual void postload(EditorGameBase&) {

	}

	virtual const Image* representative_image() const;

protected:

	explicit MapObject(MapObjectDescr const* descr);

public:

	Serial serial() const {

		return serial_;

	}

	/**

	 * Is called right before the object will be removed from

	 * the game. No connection is handled in this class.

	 *

	 * param serial : the object serial (cannot use param comment as this is a callback)

	 */

	Notifications::Signal<uint32_t /* serial */> removed;

	/**

	 * Attributes are fixed boolean properties of an object.

	 * An object either has a certain attribute or it doesn't.

	 * See the \ref Attribute enume.

	 *

	 * \return whether this object has the given attribute

	 */

	bool has_attribute(uint32_t const attr) const {

		return descr().has_attribute(attr);

	}

	/**

	 * \return the value of the given \ref TrainingAttribute. -1 if this object

	 * doesn't have this kind of attribute.

	 * The default behaviour returns \c -1 for all attributes.

	 */

	virtual int32_t get_training_attribute(TrainingAttribute attr) const;

	void remove(EditorGameBase&);

	virtual void destroy(EditorGameBase&);

	//  The next functions are really only needed in games, not in the editor.

	void schedule_destroy(Game&);

	Time schedule_act(Game&, const Duration& tdelta, uint32_t data = 0);

	virtual void act(Game&, uint32_t data);

	LogSink* get_logsink() {

		return logsink_;

	}

	void set_logsink(LogSink*);

	/// Called when a new logsink is set. Used to give general information.

	virtual void log_general_info(const EditorGameBase&) const;

	Player* get_owner() const {

		return owner_;

	}

	const Player& owner() const;

	// Header bytes to distinguish between data packages for the different

	// MapObject classes. Be careful in changing those, since they are written

	// to files.

	enum {

		HeaderMapObject = 1,

		HeaderImmovable = 2,

		// 3 was battle object.

		// 4 was attack controller.

		HeaderBattle = 5,

		HeaderCritter = 6,

		HeaderWorker = 7,

		HeaderWareInstance = 8,

		HeaderShip = 9,

		HeaderPortDock = 10,

		HeaderShipFleet = 11,

		HeaderFerryFleet = 12,

		HeaderPinnedNote = 13,

		HeaderShipFleetInterface = 14,

		HeaderFerryFleetInterface = 15,

		HeaderNavalInvasionBase = 16,

	};

	/**

	 * Returns whether this immovable was reserved by a worker.

	 */

	bool is_reserved_by_worker() const;

	/**

	 * Change whether this immovable is marked as reserved by a worker.

	 */

	void set_reserved_by_worker(bool reserve);

	/**

	 * Static load functions of derived classes will return a pointer to

	 * a Loader class. The caller needs to call the virtual functions

	 * \ref load for all instances loaded that way, after that call

	 * \ref load_pointers for all instances loaded that way and finally

	 * call \ref load_finish for all instances loaded that way.

	 * Those are the three phases of loading. After the last phase,

	 * all Loader objects should be deleted.

	 */

	struct Loader {

		EditorGameBase* egbase_{nullptr};

		MapObjectLoader* mol_{nullptr};

		MapObject* object_{nullptr};

	protected:

		Loader() = default;

	public:

		virtual ~Loader() = default;

		void init(EditorGameBase& e, MapObjectLoader& m, MapObject& object) {

			egbase_ = &e;

			mol_ = &m;

			object_ = &object;

		}

		[[nodiscard]] EditorGameBase& egbase() const {

			return *egbase_;

		}

		[[nodiscard]] MapObjectLoader& mol() const {

			return *mol_;

		}

		[[nodiscard]] MapObject* get_object() const {

			return object_;

		}

		template <typename T> T& get() {

			return dynamic_cast<T&>(*object_);

		}

	protected:

		void load(FileRead&) const;

	public:

		virtual void load_pointers();

		virtual void load_finish();

	};

	/// This is just a fail-safe guard for the time until we fully transition

	/// to the new MapObject saving system

	virtual bool has_new_save_support() {

		return false;

	}

	virtual void save(EditorGameBase&, MapObjectSaver&, FileWrite&);

	// Pure MapObjects cannot be loaded

protected:

	/// Called only when the oject is logically created in the simulation. If

	/// called again, such as when the object is loaded from a savegame, it will

	/// cause bugs.

	virtual bool init(EditorGameBase&);

	virtual void cleanup(EditorGameBase&);

	/// Draws census and statistics on screen

	void do_draw_info(const InfoToDraw& info_to_draw,

	                  const std::string& census,

	                  const std::string& statictics,

	                  const Vector2f& field_on_dst,

	                  float scale,

	                  RenderTarget* dst) const;

	void molog(const Time& gametime, char const* fmt, ...) const PRINTF_FORMAT(3, 4);

	const MapObjectDescr* descr_;

	Serial serial_{0U};

	LogSink* logsink_{nullptr};

	std::atomic<Player*> owner_{nullptr};

	/**

	 * MapObjects like trees are reserved by a worker that is walking

	 * towards them, so that e.g. two lumberjacks don't attempt to

	 * work on the same tree simultaneously or two hunters try to hunt

	 * the same animal.

	 */

	bool reserved_by_worker_{false};

private:

	DISALLOW_COPY_AND_ASSIGN(MapObject);

};

inline int32_t get_reverse_dir(int32_t const dir) {

	return 1 + ((dir - 1) + 3) % 6;

}

/**

 *

 * Keeps the list of all objects currently in the game.

 */

struct ObjectManager {

	using MapObjectMap = std::unordered_map<Serial, MapObject*>;

	ObjectManager() = default;

	~ObjectManager();

	void cleanup(EditorGameBase&);

	MapObject* get_object(Serial const serial) const {

		const MapObjectMap::const_iterator it = objects_.find(serial);

		return it != objects_.end() ? it->second : nullptr;

	}

	void insert(MapObject*);

	void remove(MapObject&);

	/**

	 * When saving the map object, ordere matters. Return a vector of all ids

	 * that are currently available;

	 */

	std::vector<Serial> all_object_serials_ordered() const;

	bool is_cleaning_up() const {

		return is_cleaning_up_;

	}

private:

	Serial lastserial_{0U};

	MapObjectMap objects_;

	bool is_cleaning_up_{false};

	DISALLOW_COPY_AND_ASSIGN(ObjectManager);

};

/**

 * Provides a safe pointer to a MapObject

 * Make sure the MapObject is initialized (has a serial) before using it in ObjectPointer!

 */

struct ObjectPointer {

	// Provide default constructor to shut up cppcheck.

	ObjectPointer() {

		serial_ = 0;

	}

	ObjectPointer(const MapObject* const obj) {  // NOLINT allow implicit conversion

		assert(obj == nullptr || obj->serial_ != 0);

		serial_ = obj != nullptr ? obj->serial_ : 0;

	}

	// can use standard copy constructor and assignment operator

	ObjectPointer& operator=(const MapObject* const obj) {

		assert(obj == nullptr || obj->serial_ != 0);

		serial_ = obj != nullptr ? obj->serial_ : 0;

		return *this;

	}

	[[nodiscard]] bool is_set() const {

		return serial_ != 0u;

	}

	// TODO(unknown): dammit... without an EditorGameBase object, we can't implement a

	// MapObject* operator (would be really nice)

	MapObject* get(const EditorGameBase&);

	[[nodiscard]] MapObject* get(const EditorGameBase& egbase) const;

	bool operator<(const ObjectPointer& other) const {

		return serial_ < other.serial_;

	}

	bool operator==(const ObjectPointer& other) const {

		return serial_ == other.serial_;

	}

	bool operator!=(const ObjectPointer& other) const {

		return serial_ != other.serial_;

	}

	[[nodiscard]] uint32_t serial() const {

		return serial_;

	}

private:

	uint32_t serial_;

};

template <class T> struct OPtr {

	OPtr(T* const obj = nullptr) : m(obj) {  // NOLINT allow implicit conversion

	}

	OPtr& operator=(T* const obj) {

		m = obj;

		return *this;

	}

	[[nodiscard]] bool is_set() const {

		return m.is_set();

	}

	T* get(const EditorGameBase& egbase) {

		return static_cast<T*>(m.get(egbase));

	}

	[[nodiscard]] T* get(const EditorGameBase& egbase) const {

		return static_cast<T*>(m.get(egbase));

	}

	bool operator<(const OPtr<T>& other) const {

		return m < other.m;

	}

	bool operator==(const OPtr<T>& other) const {

		return m == other.m;

	}

	bool operator!=(const OPtr<T>& other) const {

		return m != other.m;

	}

	[[nodiscard]] Serial serial() const {

		return m.serial();

	}

private:

	ObjectPointer m;

};

}  // namespace Widelands

#endif  // end of include guard: WL_LOGIC_MAP_OBJECTS_MAP_OBJECT_H