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
296
Generals/Code/GameEngine/Include/Common/Radar.h
Normal file
296
Generals/Code/GameEngine/Include/Common/Radar.h
Normal file
|
|
@ -0,0 +1,296 @@
|
|||
/*
|
||||
** 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: Radar.h //////////////////////////////////////////////////////////////////////////////////
|
||||
// Author: Colin Day, January 2002
|
||||
// Desc: Logical radar implementation
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#pragma once
|
||||
|
||||
#ifndef __RADAR_H_
|
||||
#define __RADAR_H_
|
||||
|
||||
// INCLUDES ///////////////////////////////////////////////////////////////////////////////////////
|
||||
#include "Lib/BaseType.h"
|
||||
#include "Common/SubsystemInterface.h"
|
||||
#include "Common/GameMemory.h"
|
||||
#include "GameClient/Display.h" // for ShroudLevel
|
||||
#include "GameClient/Color.h"
|
||||
|
||||
// FORWARD REFERENCES /////////////////////////////////////////////////////////////////////////////
|
||||
class GameWindow;
|
||||
class Object;
|
||||
class Player;
|
||||
class TerrainLogic;
|
||||
|
||||
// GLOBAL /////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// the following is used for the resolution of the radar "cells" ... this is how accurate
|
||||
// the radar is and also reflects directly the size of the image we build ... which with
|
||||
// WW3D must be a square power of two as well
|
||||
//
|
||||
enum
|
||||
{
|
||||
RADAR_CELL_WIDTH = 128, // radar created at this horz resolution
|
||||
RADAR_CELL_HEIGHT = 128 // radar created at this vert resolution
|
||||
};
|
||||
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
/** These event types determine the colors radar events happen in to make it easier for us
|
||||
* to play events with a consistent color scheme */
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
enum RadarEventType
|
||||
{
|
||||
RADAR_EVENT_INVALID = 0,
|
||||
RADAR_EVENT_CONSTRUCTION,
|
||||
RADAR_EVENT_UPGRADE,
|
||||
RADAR_EVENT_UNDER_ATTACK,
|
||||
RADAR_EVENT_INFORMATION,
|
||||
RADAR_EVENT_BEACON_PULSE,
|
||||
RADAR_EVENT_INFILTRATION, //for defection, hijacking, hacking, carbombing, and other sneaks
|
||||
RADAR_EVENT_BATTLE_PLAN,
|
||||
RADAR_EVENT_STEALTH_DISCOVERED, // we discovered a stealth unit
|
||||
RADAR_EVENT_STEALTH_NEUTRALIZED, // our stealth unit has been revealed
|
||||
RADAR_EVENT_FAKE, //Internally creates a radar event, but doesn't notify the player (unit lost
|
||||
//for example, so we can use the spacebar to jump to the event).
|
||||
|
||||
RADAR_EVENT_NUM_EVENTS // keep this last
|
||||
|
||||
};
|
||||
|
||||
// PROTOTYPES /////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
/** Radar objects are objects that are on the radar, go figure :) */
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
class RadarObject : public MemoryPoolObject,
|
||||
public Snapshot
|
||||
{
|
||||
|
||||
MEMORY_POOL_GLUE_WITH_USERLOOKUP_CREATE( RadarObject, "RadarObject" )
|
||||
|
||||
public:
|
||||
|
||||
RadarObject( void );
|
||||
// destructor prototype defined by memory pool glue
|
||||
|
||||
// color management
|
||||
void setColor( Color c ) { m_color = c; }
|
||||
inline Color getColor( void ) const { return m_color; }
|
||||
|
||||
inline void friend_setObject( Object *obj ) { m_object = obj; }
|
||||
inline Object *friend_getObject( void ) { return m_object; }
|
||||
inline const Object *friend_getObject( void ) const { return m_object; }
|
||||
|
||||
inline void friend_setNext( RadarObject *next ) { m_next = next; }
|
||||
inline RadarObject *friend_getNext( void ) { return m_next; }
|
||||
inline const RadarObject *friend_getNext( void ) const { return m_next; }
|
||||
|
||||
Bool isTemporarilyHidden() const;
|
||||
|
||||
protected:
|
||||
|
||||
// snapshot methods
|
||||
virtual void crc( Xfer *xfer );
|
||||
virtual void xfer( Xfer *xfer );
|
||||
virtual void loadPostProcess( void );
|
||||
|
||||
Object *m_object; ///< the object
|
||||
RadarObject *m_next; ///< next radar object
|
||||
Color m_color; ///< color to draw for this object on the radar
|
||||
|
||||
};
|
||||
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
/** Radar priorities. Keep this in sync with the priority names list below */
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
enum RadarPriorityType
|
||||
{
|
||||
RADAR_PRIORITY_INVALID, // a priority that has not been set (in general it won't show up on the radar)
|
||||
RADAR_PRIORITY_NOT_ON_RADAR, // object specifically forbidden from being on the radar
|
||||
RADAR_PRIORITY_STRUCTURE, // structure level drawing priority
|
||||
RADAR_PRIORITY_UNIT, // unit level drawing priority
|
||||
RADAR_PRIORITY_LOCAL_UNIT_ONLY, // unit priority, but only on the radar if controlled by the local player
|
||||
|
||||
RADAR_PRIORITY_NUM_PRIORITIES // keep this last
|
||||
};
|
||||
#ifdef DEFINE_RADAR_PRIORITY_NAMES
|
||||
static const char *RadarPriorityNames[] =
|
||||
{
|
||||
"INVALID", // a priority that has not been set (in general it won't show up on the radar)
|
||||
"NOT_ON_RADAR", // object specifically forbidden from being on the radar
|
||||
"STRUCTURE", // structure level drawing priority
|
||||
"UNIT", // unit level drawing priority
|
||||
"LOCAL_UNIT_ONLY", // unit priority, but only on the radar if controlled by the local player
|
||||
|
||||
NULL // keep this last
|
||||
};
|
||||
#endif // DEFINE_RADAR_PRIOTITY_NAMES
|
||||
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
/** Interface for the radar */
|
||||
//-------------------------------------------------------------------------------------------------
|
||||
class Radar : public Snapshot,
|
||||
public SubsystemInterface
|
||||
{
|
||||
|
||||
public:
|
||||
|
||||
Radar( void );
|
||||
virtual ~Radar( void );
|
||||
|
||||
virtual void init( void ) { } ///< subsystem initialization
|
||||
virtual void reset( void ); ///< subsystem reset
|
||||
virtual void update( void ); ///< subsystem per frame update
|
||||
|
||||
// is the game window parameter the radar window
|
||||
Bool isRadarWindow( GameWindow *window ) { return (m_radarWindow == window) && (m_radarWindow != NULL); }
|
||||
|
||||
Bool radarToWorld( const ICoord2D *radar, Coord3D *world ); ///< radar point to world point on terrain
|
||||
Bool worldToRadar( const Coord3D *world, ICoord2D *radar ); ///< translate world point to radar (x,y)
|
||||
Bool localPixelToRadar( const ICoord2D *pixel, ICoord2D *radar ); ///< translate pixel (with UL of radar being (0,0)) to logical radar coords
|
||||
Bool screenPixelToWorld( const ICoord2D *pixel, Coord3D *world ); ///< translate pixel (with UL of the screen being (0,0)) to world position in the world
|
||||
Object *objectUnderRadarPixel( const ICoord2D *pixel ); ///< return the object (if any) represented by the pixel coords passed in
|
||||
void findDrawPositions( Int startX, Int startY, Int width, Int height,
|
||||
ICoord2D *ul, ICoord2D *lr ); ///< make translation for screen area of radar square to scaled aspect ratio preserving points inside the radar area
|
||||
|
||||
// priority inquiry
|
||||
Bool isPriorityVisible( RadarPriorityType priority ) const; ///< is the priority passed in a "visible" one on the radar
|
||||
|
||||
// radar events
|
||||
void createEvent( const Coord3D *world, RadarEventType type, Real secondsToLive = 4.0f ); ///< create radar event at location in world
|
||||
void createPlayerEvent( Player *player, const Coord3D *world, RadarEventType type, Real secondsToLive = 4.0f ); ///< create radar event using player colors
|
||||
|
||||
Bool getLastEventLoc( Coord3D *eventPos ); ///< get last event loc (if any)
|
||||
void tryUnderAttackEvent( const Object *obj ); ///< try to make an "under attack" event if it's the proper time
|
||||
void tryInfiltrationEvent( const Object *obj ); ///< try to make an "infiltration" event if it's the proper time
|
||||
Bool tryEvent( RadarEventType event, const Coord3D *pos ); ///< try to make a "stealth" event
|
||||
|
||||
// adding and removing objects from the radar
|
||||
void addObject( Object *obj ); ///< add object to radar
|
||||
void removeObject( Object *obj ); ///< remove object from radar
|
||||
void examineObject( Object *obj ); ///< re-examine object and resort if needed
|
||||
|
||||
// radar options
|
||||
void hide( Bool hide ) { m_radarHidden = hide; } ///< hide/unhide the radar
|
||||
Bool isRadarHidden( void ) { return m_radarHidden; } ///< is radar hidden
|
||||
// other radar option methods here like the ability to show a certain
|
||||
// team, show buildings, show units at all, etc
|
||||
|
||||
// forcing the radar on/off regardless of player situation
|
||||
void forceOn( Bool force ) { m_radarForceOn = force; } ///< force the radar to be on
|
||||
Bool isRadarForced( void ) { return m_radarForceOn; } ///< is radar forced on?
|
||||
|
||||
/// refresh the water values for the radar
|
||||
virtual void refreshTerrain( TerrainLogic *terrain );
|
||||
|
||||
/// queue a refresh of the terran at the next available time
|
||||
virtual void queueTerrainRefresh( void );
|
||||
|
||||
virtual void newMap( TerrainLogic *terrain ); ///< reset radar for new map
|
||||
|
||||
virtual void draw( Int pixelX, Int pixelY, Int width, Int height ) = 0; ///< draw the radar
|
||||
|
||||
/// empty the entire shroud
|
||||
virtual void clearShroud() = 0;
|
||||
|
||||
/// set the shroud level at shroud cell x,y
|
||||
virtual void setShroudLevel( Int x, Int y, CellShroudStatus setting ) = 0;
|
||||
|
||||
protected:
|
||||
|
||||
// snapshot methods
|
||||
virtual void crc( Xfer *xfer );
|
||||
virtual void xfer( Xfer *xfer );
|
||||
virtual void loadPostProcess( void );
|
||||
|
||||
/// internal method for creating a radar event with specific colors
|
||||
void internalCreateEvent( const Coord3D *world, RadarEventType type, Real secondsToLive,
|
||||
const RGBAColorInt *color1, const RGBAColorInt *color2 );
|
||||
|
||||
void deleteListResources( void ); ///< delete list radar resources used
|
||||
Bool deleteFromList( Object *obj, RadarObject **list ); ///< try to remove object from specific list
|
||||
|
||||
inline Real getTerrainAverageZ() const { return m_terrainAverageZ; }
|
||||
inline Real getWaterAverageZ() const { return m_waterAverageZ; }
|
||||
inline const RadarObject* getObjectList() const { return m_objectList; }
|
||||
inline const RadarObject* getLocalObjectList() const { return m_localObjectList; }
|
||||
|
||||
void clearAllEvents( void ); ///< remove all radar events in progress
|
||||
|
||||
// search the object list for an object that maps to the given logical radar coords
|
||||
Object *searchListForRadarLocationMatch( RadarObject *listHead, ICoord2D *radarMatch );
|
||||
|
||||
Bool m_radarHidden; ///< true when radar is not visible
|
||||
Bool m_radarForceOn; ///< true when radar is forced to be on
|
||||
RadarObject *m_objectList; ///< list of objects in the radar
|
||||
RadarObject *m_localObjectList; /** list of objects for the local player, sorted
|
||||
* in exactly the same priority as the regular
|
||||
* object list for all other objects */
|
||||
|
||||
Real m_terrainAverageZ; ///< average Z for terrain samples
|
||||
Real m_waterAverageZ; ///< average Z for water samples
|
||||
|
||||
//
|
||||
// when dealing with world sampling we will sample at these intervals so that
|
||||
// the whole map can be accounted for within our RADAR_CELL_WIDTH and
|
||||
// RADAR_CELL_HEIGHT resolutions
|
||||
//
|
||||
Real m_xSample;
|
||||
Real m_ySample;
|
||||
|
||||
enum { MAX_RADAR_EVENTS = 64 };
|
||||
struct RadarEvent
|
||||
{
|
||||
RadarEventType type; ///< type of this radar event
|
||||
Bool active; ///< TRUE when event is "active", otherwise it's just historical information in the event array to look through
|
||||
UnsignedInt createFrame; ///< frame event was created on
|
||||
UnsignedInt dieFrame; ///< frame the event will go away on
|
||||
UnsignedInt fadeFrame; ///< start fading out on this frame
|
||||
RGBAColorInt color1; ///< color 1 for drawing
|
||||
RGBAColorInt color2; ///< color 2 for drawing
|
||||
Coord3D worldLoc; ///< location of event in the world
|
||||
ICoord2D radarLoc; ///< 2D radar location of the event
|
||||
Bool soundPlayed; ///< TRUE when we have played the radar sound for this
|
||||
};
|
||||
RadarEvent m_event[ MAX_RADAR_EVENTS ];///< our radar events
|
||||
Int m_nextFreeRadarEvent; ///< index into m_event for where to store the next event
|
||||
Int m_lastRadarEvent; ///< index of the most recent radar event
|
||||
|
||||
GameWindow *m_radarWindow; ///< window we display the radar in
|
||||
|
||||
Region3D m_mapExtent; ///< extents of the current map
|
||||
|
||||
UnsignedInt m_queueTerrainRefreshFrame; ///< frame we requested the last terrain refresh on
|
||||
|
||||
};
|
||||
|
||||
// EXTERNALS //////////////////////////////////////////////////////////////////////////////////////
|
||||
extern Radar *TheRadar; ///< the radar singleton extern
|
||||
|
||||
#endif // __RADAR_H_
|
||||
|
||||
|
||||
|
||||
Reference in a new issue