mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-27 00:43:00 +12:00
03416d24e1
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
174 lines
8.5 KiB
C++
174 lines
8.5 KiB
C++
//
|
|
// Copyright 2020 Electronic Arts Inc.
|
|
//
|
|
// TiberianDawn.DLL and RedAlert.dll and corresponding source code 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.
|
|
|
|
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
|
|
// in the hope that it will be useful, but with permitted additional restrictions
|
|
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
|
|
// distributed with this program. You should have received a copy of the
|
|
// GNU General Public License along with permitted additional restrictions
|
|
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
|
|
|
|
/* $Header: /CounterStrike/TARGET.H 1 3/03/97 10:25a Joe_bostic $ */
|
|
/***********************************************************************************************
|
|
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
|
|
***********************************************************************************************
|
|
* *
|
|
* Project Name : Command & Conquer *
|
|
* *
|
|
* File Name : TARGET.H *
|
|
* *
|
|
* Programmer : Joe L. Bostic *
|
|
* *
|
|
* Start Date : April 25, 1994 *
|
|
* *
|
|
* Last Update : April 25, 1994 [JLB] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#ifndef TARGET_H
|
|
#define TARGET_H
|
|
|
|
|
|
inline RTTIType Target_Kind(TARGET a)
|
|
{
|
|
return(RTTIType(((TARGET_COMPOSITE &)a).Sub.Exponent));
|
|
}
|
|
|
|
inline unsigned Target_Value(TARGET a)
|
|
{
|
|
return(((TARGET_COMPOSITE &)a).Sub.Mantissa);
|
|
}
|
|
|
|
inline bool Is_Target_Team(TARGET a) {return (Target_Kind(a) == RTTI_TEAM);}
|
|
inline bool Is_Target_TeamType(TARGET a) {return (Target_Kind(a) == RTTI_TEAMTYPE);}
|
|
inline bool Is_Target_Trigger(TARGET a) {return (Target_Kind(a) == RTTI_TRIGGER);}
|
|
inline bool Is_Target_TriggerType(TARGET a) {return (Target_Kind(a) == RTTI_TRIGGERTYPE);}
|
|
inline bool Is_Target_Infantry(TARGET a) {return (Target_Kind(a) == RTTI_INFANTRY);}
|
|
inline bool Is_Target_Bullet(TARGET a) {return (Target_Kind(a) == RTTI_BULLET);}
|
|
inline bool Is_Target_Terrain(TARGET a) {return (Target_Kind(a) == RTTI_TERRAIN);}
|
|
inline bool Is_Target_Cell(TARGET a) {return (Target_Kind(a) == RTTI_CELL);}
|
|
inline bool Is_Target_Unit(TARGET a) {return (Target_Kind(a) == RTTI_UNIT);}
|
|
inline bool Is_Target_Vessel(TARGET a) {return (Target_Kind(a) == RTTI_VESSEL);}
|
|
inline bool Is_Target_Building(TARGET a) {return (Target_Kind(a) == RTTI_BUILDING);}
|
|
inline bool Is_Target_Template(TARGET a) {return (Target_Kind(a) == RTTI_TEMPLATE);}
|
|
inline bool Is_Target_Aircraft(TARGET a) {return (Target_Kind(a) == RTTI_AIRCRAFT);}
|
|
inline bool Is_Target_Animation(TARGET a) {return (Target_Kind(a) == RTTI_ANIM);}
|
|
inline bool Is_Target_Object(TARGET a)
|
|
{
|
|
return (Target_Kind(a) == RTTI_TERRAIN ||
|
|
Target_Kind(a) == RTTI_UNIT ||
|
|
Target_Kind(a) == RTTI_VESSEL ||
|
|
Target_Kind(a) == RTTI_INFANTRY ||
|
|
Target_Kind(a) == RTTI_BUILDING ||
|
|
Target_Kind(a) == RTTI_AIRCRAFT);
|
|
}
|
|
|
|
|
|
TARGET As_Target(CELL cell);
|
|
TARGET As_Target(COORDINATE coord);
|
|
//inline TARGET As_Target(CELL cell) {return (TARGET)(((unsigned)RTTI_CELL << TARGET_MANTISSA) | cell);}
|
|
|
|
class UnitClass;
|
|
class BuildingClass;
|
|
class TechnoClass;
|
|
class TerrainClass;
|
|
class ObjectClass;
|
|
class InfantryClass;
|
|
class BulletClass;
|
|
class TriggerClass;
|
|
class TeamClass;
|
|
class TeamTypeClass;
|
|
class AnimClass;
|
|
class AircraftClass;
|
|
class VesselClass;
|
|
class CellClass;
|
|
class TriggerTypeClass;
|
|
|
|
/*
|
|
** Must not have a constructor since Watcom cannot handle a class that has a constructor if
|
|
** that class object is in a union. Don't use this class for normal purposes. Use the TargetClass
|
|
** instead. The xTargetClass is only used in one module for a special reason -- keep it that way.
|
|
*/
|
|
class xTargetClass
|
|
{
|
|
protected:
|
|
|
|
TARGET_COMPOSITE Target;
|
|
|
|
public:
|
|
|
|
// conversion operator to RTTIType
|
|
operator RTTIType (void) const {return(RTTIType(Target.Sub.Exponent));}
|
|
|
|
// comparison operator
|
|
int operator == (xTargetClass & tgt) {return (tgt.Target.Target==Target.Target ? 1 : 0);}
|
|
|
|
// conversion operator to regular TARGET type
|
|
TARGET As_TARGET(void) const {return(Target.Target);}
|
|
|
|
unsigned Value(void) const {return(Target.Sub.Mantissa);};
|
|
|
|
void Invalidate(void) {Target.Sub.Exponent = RTTI_NONE;Target.Sub.Mantissa = -1;}
|
|
bool Is_Valid(void) const {return (Target.Sub.Exponent != RTTI_NONE);}
|
|
|
|
TARGET As_Target(void) const {return(Target.Target);}
|
|
AbstractTypeClass * As_TypeClass(void) const;
|
|
AbstractClass * As_Abstract(bool check_active = true) const;
|
|
TechnoClass * As_Techno(bool check_active = true) const;
|
|
ObjectClass * As_Object(bool check_active = true) const;
|
|
CellClass * As_Cell(void) const;
|
|
|
|
/*
|
|
** Helper routines to combine testing for, and fetching a pointer to, the
|
|
** type of object indicated.
|
|
*/
|
|
TriggerTypeClass * As_TriggerType(void) const {if (*this == RTTI_TRIGGERTYPE) return((TriggerTypeClass *)As_TypeClass());return(0);}
|
|
TeamTypeClass * As_TeamType(void) const {if (*this == RTTI_TEAMTYPE) return((TeamTypeClass *)As_TypeClass());return(0);}
|
|
TerrainClass * As_Terrain(bool check_active = true) const {if (*this == RTTI_TERRAIN) return((TerrainClass *)As_Abstract(check_active));return(0);}
|
|
BulletClass * As_Bullet(bool check_active = true) const {if (*this == RTTI_BULLET) return((BulletClass *)As_Abstract(check_active));return(0);}
|
|
AnimClass * As_Anim(bool check_active = true) const {if (*this == RTTI_ANIM) return((AnimClass *)As_Abstract(check_active));return(0);}
|
|
TeamClass * As_Team(bool check_active = true) const {if (*this == RTTI_TEAM) return((TeamClass *)As_Abstract(check_active));return(0);}
|
|
InfantryClass * As_Infantry(bool check_active = true) const {if (*this == RTTI_INFANTRY) return((InfantryClass *)As_Techno(check_active));return(0);}
|
|
UnitClass * As_Unit(bool check_active = true) const {if (*this == RTTI_UNIT) return((UnitClass *)As_Techno(check_active));return(0);}
|
|
BuildingClass * As_Building(bool check_active = true) const {if (*this == RTTI_BUILDING) return((BuildingClass *)As_Techno(check_active));return(0);}
|
|
AircraftClass * As_Aircraft(bool check_active = true) const {if (*this == RTTI_AIRCRAFT) return((AircraftClass *)As_Techno(check_active));return(0);}
|
|
VesselClass * As_Vessel(bool check_active = true) const {if (*this == RTTI_VESSEL) return((VesselClass *)As_Techno(check_active));return(0);}
|
|
};
|
|
|
|
/*
|
|
** This class only serves as a wrapper to the xTargetClass. This class must not define any members except
|
|
** for the constructors. This is because the xTargetClass is used in a union and this target object is
|
|
** used as its initializer. If this class had any extra members they would not be properly copied and
|
|
** communicated to the other machines in a network/modem game. Combining this class with xTargetClass would
|
|
** be more efficient, but Watcom doesn't allow class objects that have a constructor to be part of a union [even
|
|
** if the class object has a default constructor!].
|
|
*/
|
|
class TargetClass : public xTargetClass
|
|
{
|
|
public:
|
|
|
|
TargetClass(void) {Invalidate();}
|
|
TargetClass(NoInitClass const &) {}
|
|
TargetClass(RTTIType rtti, int id) {
|
|
Target.Sub.Exponent = rtti;
|
|
Target.Sub.Mantissa = id;
|
|
}
|
|
TargetClass(CELL cell) {
|
|
Target.Sub.Exponent = RTTI_CELL;
|
|
Target.Sub.Mantissa = cell;
|
|
}
|
|
TargetClass(TARGET target);
|
|
TargetClass(AbstractClass const * ptr);
|
|
TargetClass(AbstractTypeClass const * ptr);
|
|
TargetClass(CellClass const * ptr);
|
|
};
|
|
|
|
#endif
|