GeneralsZeroHour/GeneralsMD/Code/GameEngine/Include/Common/Module.h

/*
**	Command & Conquer Generals Zero Hour(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	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 3 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 <http://www.gnu.org/licenses/>.
*/

////////////////////////////////////////////////////////////////////////////////
//																																						//
//  (c) 2001-2003 Electronic Arts Inc.																				//
//																																						//
////////////////////////////////////////////////////////////////////////////////

// FILE: Module.h /////////////////////////////////////////////////////////////////////////////////
// Author: Colin Day, September 2001
// Desc:	 Object and drawable modules and actions.  These are simply just class
//				 instances that we can assign to objects, drawables, and things to contain
//				 data and code for specific events, or just to hold data
///////////////////////////////////////////////////////////////////////////////////////////////////

#pragma once

#ifndef __MODULE_H_
#define __MODULE_H_

// INCLUDES ///////////////////////////////////////////////////////////////////////////////////////
#include "Common/INI.h"
#include "Common/GameMemory.h"
#include "Common/NameKeyGenerator.h"
#include "Common/Snapshot.h"

// FORWARD REFERENCES /////////////////////////////////////////////////////////////////////////////
enum TimeOfDay;
enum StaticGameLODLevel;
class Drawable;
class Object;
class Player;
class Thing;
class W3DModelDrawModuleData;	// ugh, hack (srj)
class W3DTreeDrawModuleData; // ugh, hack (srj)
struct FieldParse;

// TYPES //////////////////////////////////////////////////////////////////////////////////////////

//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
enum ModuleType 
{
	MODULETYPE_BEHAVIOR = 0,

	//
	// drawable module types - you should *NOT* remove drawable module types, we write
	// modules into save game files in buckets of module types ... if you do remove one
	// here you will have to update the xfer code for a drawable.
	//
	// ALSO note that new drawable module types should go at the end of the existing drawable modules
	//
	MODULETYPE_DRAW = 1,
	MODULETYPE_CLIENT_UPDATE = 2,
	// put new drawable module types here

	NUM_MODULE_TYPES,  // keep this last!

	FIRST_DRAWABLE_MODULE_TYPE = MODULETYPE_DRAW,
	LAST_DRAWABLE_MODULE_TYPE = MODULETYPE_CLIENT_UPDATE,
	NUM_DRAWABLE_MODULE_TYPES = (LAST_DRAWABLE_MODULE_TYPE - FIRST_DRAWABLE_MODULE_TYPE + 1)

};

//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
enum ModuleInterfaceType 
{
	MODULEINTERFACE_UPDATE					= 0x00000001,
	MODULEINTERFACE_DIE							= 0x00000002,
	MODULEINTERFACE_DAMAGE					= 0x00000004,
	MODULEINTERFACE_CREATE					= 0x00000008,
	MODULEINTERFACE_COLLIDE					= 0x00000010,
	MODULEINTERFACE_BODY						= 0x00000020,
	MODULEINTERFACE_CONTAIN					= 0x00000040,
	MODULEINTERFACE_UPGRADE					= 0x00000080,
	MODULEINTERFACE_SPECIAL_POWER		= 0x00000100,
	MODULEINTERFACE_DESTROY					= 0x00000200,
	MODULEINTERFACE_DRAW						= 0x00000400,
	MODULEINTERFACE_CLIENT_UPDATE		= 0x00000800
};

//-------------------------------------------------------------------------------------------------
/** Base class for data-read-from-INI for modules. */
//-------------------------------------------------------------------------------------------------
/// @todo srj -- make ModuleData be MemoryPool based
class ModuleData : public Snapshot
{
public:
	ModuleData() { }
	virtual ~ModuleData() { }

	void setModuleTagNameKey( NameKeyType key ) { m_moduleTagNameKey = key; }
	NameKeyType getModuleTagNameKey() const { return m_moduleTagNameKey; }

	virtual Bool isAiModuleData() const { return false; }
	
	// ugh, hack
	virtual const W3DModelDrawModuleData* getAsW3DModelDrawModuleData() const { return NULL; }
	// ugh, hack
	virtual const W3DTreeDrawModuleData* getAsW3DTreeDrawModuleData() const { return NULL; }
	virtual StaticGameLODLevel getMinimumRequiredGameLOD() const { return (StaticGameLODLevel)0;}

	static void buildFieldParse(MultiIniFieldParse& p) 
	{
		// nothing
	}

public:
	virtual void crc( Xfer *xfer ) {}
	virtual void xfer( Xfer *xfer ) {}
	virtual void loadPostProcess( void ) {}

private:
	NameKeyType m_moduleTagNameKey;		///< module tag key, unique among all modules for an object instance
};

//-------------------------------------------------------------------------------------------------
// This macro is to assist in the creation of new modules, contains the common
// things that all module definitions must have in order to work with
// the module creation factory
//-------------------------------------------------------------------------------------------------
#define MAKE_STANDARD_MODULE_MACRO( cls ) \
public: \
	static Module* friend_newModuleInstance( Thing *thing, const ModuleData* moduleData ) { return newInstance( cls )( thing, moduleData ); } \
	virtual NameKeyType getModuleNameKey() const { static NameKeyType nk = NAMEKEY(#cls); return nk; } \
protected: \
	virtual void crc( Xfer *xfer ); \
	virtual void xfer( Xfer *xfer ); \
	virtual void loadPostProcess( void );

// ------------------------------------------------------------------------------------------------
// For the creation of abstract module classes
// ------------------------------------------------------------------------------------------------
#define MAKE_STANDARD_MODULE_MACRO_ABC( cls ) \
protected: \
	virtual void crc( Xfer *xfer ); \
	virtual void xfer( Xfer *xfer ); \
	virtual void loadPostProcess( void );

//-------------------------------------------------------------------------------------------------
// only use this macro for an ABC. for a real class, use MAKE_STANDARD_MODULE_MACRO_WITH_MODULE_DATA.
#define MAKE_STANDARD_MODULE_DATA_MACRO_ABC( cls, clsmd ) \
private: \
	const clsmd* get##clsmd() const { return (clsmd*)getModuleData(); } \
public: \
	static ModuleData* friend_newModuleData(INI* ini) \
	{ \
		clsmd* data = MSGNEW( "AllModuleData" ) clsmd; \
		if (ini) ini->initFromINIMultiProc(data, clsmd::buildFieldParse); \
		return data; \
	}

//-------------------------------------------------------------------------------------------------
#define MAKE_STANDARD_MODULE_MACRO_WITH_MODULE_DATA( cls, clsmd ) \
	MAKE_STANDARD_MODULE_MACRO(cls) \
	MAKE_STANDARD_MODULE_DATA_MACRO_ABC(cls, clsmd)

//-------------------------------------------------------------------------------------------------
/** Common interface for thing modules, we want a single common base class 
	* for all the modules (either object or drawable) so that we can use
	* a single module factory to handle instancing them ... it's just
	* convenient this way */
//-------------------------------------------------------------------------------------------------
class Module : public MemoryPoolObject,
							 public Snapshot
{

	MEMORY_POOL_GLUE_ABC( Module )						///< this abstract class needs memory pool hooks

public:

	Module(const ModuleData* moduleData) : m_moduleData(moduleData) { }
	// virtual destructor prototype defined by MemoryPoolObject

	// this method should NEVER be overridden by user code, only via the MAKE_STANDARD_MODULE_xxx macros!
	// it should also NEVER be called directly; it's only for use by ModuleFactory!
	static ModuleData* friend_newModuleData(INI* ini);

	virtual NameKeyType getModuleNameKey() const = 0;

	inline NameKeyType getModuleTagNameKey() const { return getModuleData()->getModuleTagNameKey(); }

	/** this is called after all the Modules for a given Thing are created; it
		allows Modules to resolve any inter-Module dependencies.
	*/
	virtual void onObjectCreated() { }
	
	/**
		this is called whenever a drawable is bound to the object. 
		drawable is NOT guaranteed to be non-null.
	*/
	virtual void onDrawableBoundToObject() { }

	/// preload any assets we might have for this time of day
	virtual void preloadAssets( TimeOfDay timeOfDay ) { }

	/** onDelete() will be called on all modules contained by an object or drawable before
	the actual deletion of each of those modules happens */
	virtual void onDelete( void ) { }

protected:

	inline const ModuleData* getModuleData() const { return m_moduleData; }

	virtual void crc( Xfer *xfer );
	virtual void xfer( Xfer *xfer );
	virtual void loadPostProcess( void );

private:
	const ModuleData* m_moduleData;

};  // end Module
//-------------------------------------------------------------------------------------------------


//=================================================================================================
//														OBJECT Module interface and modules
//=================================================================================================


//-------------------------------------------------------------------------------------------------
/** Module interface specific for Objects, this is really just to make a clear distinction
	* between modules intended for use in objects and modules intended for use
	* in drawables */
//-------------------------------------------------------------------------------------------------
class ObjectModule : public Module
{

	MEMORY_POOL_GLUE_ABC( ObjectModule )			///< this abstract class needs memory pool hooks

public:

	ObjectModule( Thing *thing, const ModuleData* moduleData );
	// virtual destructor prototype defined by MemoryPoolObject

	virtual void onCapture( Player *oldOwner, Player *newOwner ) { }
	virtual void onDisabledEdge( Bool nowDisabled ) { }

protected:

	inline Object *getObject() { return m_object; }
	inline const Object *getObject() const { return m_object; }

	virtual void crc( Xfer *xfer );
	virtual void xfer( Xfer *xfer );
	virtual void loadPostProcess( void );

private:

	// it shouldn't be legal for subclasses to ever modify this, only to look at it;
	// so, we'll enforce this by making it private and providing a protected access method.
	Object *m_object;													///< the object this module is a part of

};
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------






//=================================================================================================
//													DRAWABLE module interface and modules
//=================================================================================================

//-------------------------------------------------------------------------------------------------
/** Module interface specific for Drawbles, this is really just to make a clear distinction
	* between modules intended for use in objects and modules intended for use
	* in drawables */
//-------------------------------------------------------------------------------------------------
class DrawableModule : public Module
{

	MEMORY_POOL_GLUE_ABC( DrawableModule )		///< this abstract class needs memory pool hooks

public:

	DrawableModule( Thing *thing, const ModuleData* moduleData );
	// virtual destructor prototype defined by MemoryPoolObject

protected:

	inline Drawable *getDrawable() { return m_drawable; }
	inline const Drawable *getDrawable() const { return m_drawable; }

	virtual void crc( Xfer *xfer );
	virtual void xfer( Xfer *xfer );
	virtual void loadPostProcess( void );

private:

	// it shouldn't be legal for subclasses to ever modify this, only to look at it;
	// so, we'll enforce this by making it private and providing a protected access method.
	Drawable *m_drawable;											///< the drawble this module is a part of

};
//-------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------
/** VARIOUS MODULE INTERFACES */
//-------------------------------------------------------------------------------------------------


#endif // __MODULE_H_