Initial commit of Command & Conquer Generals and Command & Conquer Generals Zero Hour source code.
This commit is contained in:
LFeenanEA
parent
2e338c00cb
commit
3d0ee53a05
6072 changed files with 2283311 additions and 0 deletions
320
Generals/Code/GameEngine/Include/Common/Module.h
Normal file
320
Generals/Code/GameEngine/Include/Common/Module.h
Normal file
|
|
@ -0,0 +1,320 @@
|
|||
/*
|
||||
** Command & Conquer Generals(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)
|
||||
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; }
|
||||
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 ) { }
|
||||
|
||||
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_
|
||||
|
||||
Reference in a new issue