941 lines
48 KiB
C++
941 lines
48 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.CPP 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.CPP *
|
|
* *
|
|
* Programmer : Joe L. Bostic *
|
|
* *
|
|
* Start Date : September 10, 1993 *
|
|
* *
|
|
* Last Update : July 16, 1996 [JLB] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* As_Aircraft -- Converts the target value into an aircraft pointer. *
|
|
* As_Animation -- Converts target value into animation pointer. *
|
|
* As_Building -- Converts a target value into a building object pointer. *
|
|
* As_Bullet -- Converts the target into a bullet pointer. *
|
|
* As_Cell -- Converts a target value into a cell number. *
|
|
* As_Coord -- Converts a target value into a coordinate value. *
|
|
* As_Infantry -- If the target is infantry, return a pointer to it. *
|
|
* As_Movement_Coord -- Fetches coordinate if trying to move to this target. *
|
|
* As_Object -- Converts a target value into an object pointer. *
|
|
* As_Target -- Converts a cell into a target value. *
|
|
* As_Target -- Converts a coordinate into a target value. *
|
|
* As_Team -- Converts a target number into a team pointer. *
|
|
* As_TeamType -- Converts a target into a team type pointer. *
|
|
* As_Techno -- Converts a target value into a TechnoClass pointer. *
|
|
* As_TechnoType -- Convert the target number into a techno type class pointer. *
|
|
* As_Trigger -- Converts specified target into a trigger pointer. *
|
|
* As_TriggerType -- Convert the specified target into a trigger type. *
|
|
* As_Unit -- Converts a target value into a unit pointer. *
|
|
* As_Vessel -- Converts a target number into a vessel pointer. *
|
|
* TClass::TClass -- Constructor for target from object pointer. *
|
|
* TargetClass::As_Object -- Converts a target into an object pointer. *
|
|
* TargetClass::As_Techno -- Converts a target into a techno object pointer. *
|
|
* Target_Legal -- Determines if the specified target is legal. *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#include "function.h"
|
|
#include "target.h"
|
|
|
|
|
|
TargetClass::TargetClass(TARGET target)
|
|
{
|
|
Target.Target = target;
|
|
}
|
|
|
|
|
|
TargetClass::TargetClass(AbstractClass const * ptr) {
|
|
if (ptr != NULL) {
|
|
Target.Sub.Exponent = ptr->RTTI;
|
|
Target.Sub.Mantissa = ptr->ID;
|
|
} else {
|
|
Target.Sub.Exponent = RTTI_NONE;
|
|
}
|
|
}
|
|
|
|
TargetClass::TargetClass(AbstractTypeClass const * ptr) {
|
|
if (ptr != NULL) {
|
|
Target.Sub.Exponent = ptr->RTTI;
|
|
Target.Sub.Mantissa = ptr->ID;
|
|
} else {
|
|
Target.Sub.Exponent = RTTI_NONE;
|
|
}
|
|
}
|
|
|
|
TargetClass::TargetClass(CellClass const * ptr) {
|
|
if (ptr != NULL) {
|
|
Target.Sub.Exponent = RTTI_CELL;
|
|
Target.Sub.Mantissa = ptr->ID;
|
|
} else {
|
|
Target.Sub.Exponent = RTTI_NONE;
|
|
}
|
|
}
|
|
|
|
CellClass * xTargetClass::As_Cell(void) const
|
|
{
|
|
if (Target.Sub.Exponent == RTTI_CELL) {
|
|
return(&Map[(CELL)Target.Sub.Mantissa]);
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Trigger -- Converts specified target into a trigger pointer. *
|
|
* *
|
|
* This routine will convert the specified target number into a trigger pointer. *
|
|
* *
|
|
* INPUT: target -- The target number to convert. *
|
|
* *
|
|
* OUTPUT: Returns with the trigger pointer that the specified target number represents. If *
|
|
* it doesn't represent a legal trigger object, then NULL is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/08/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
TriggerClass * As_Trigger(TARGET target, bool check_active)
|
|
{
|
|
TriggerClass* trigger = Is_Target_Trigger(target) ? Triggers.Raw_Ptr(Target_Value(target)) : NULL;
|
|
if (check_active && trigger != NULL && !trigger->IsActive) {
|
|
trigger = NULL;
|
|
}
|
|
return(trigger);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Team -- Converts a target number into a team pointer. *
|
|
* *
|
|
* This routine will convert the specified target number into a team pointer. *
|
|
* *
|
|
* INPUT: target -- The target number to convert. *
|
|
* *
|
|
* OUTPUT: Returns with the team object that the specified target number represents. If it *
|
|
* doesn't represent a legal team then NULL is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/08/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
TeamClass * As_Team(TARGET target, bool check_active)
|
|
{
|
|
TeamClass* team = Is_Target_Team(target) ? Teams.Raw_Ptr(Target_Value(target)) : NULL;
|
|
if (check_active && team != NULL && !team->IsActive) {
|
|
team = NULL;
|
|
}
|
|
return(team);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_TeamType -- Converts a target into a team type pointer. *
|
|
* *
|
|
* This routine will convert the specified target number into a team type pointer. *
|
|
* *
|
|
* INPUT: target -- The target number to convert. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the team type represented by the target number. If the *
|
|
* target number doesn't represent a legal team type, then NULL is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/08/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
TeamTypeClass * As_TeamType(TARGET target)
|
|
{
|
|
return(Is_Target_TeamType(target) ? TeamTypes.Raw_Ptr(Target_Value(target)) : NULL);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Animation -- Converts target value into animation pointer. *
|
|
* *
|
|
* This routine will convert the specified target number into an animation pointer. *
|
|
* *
|
|
* INPUT: target -- The target number to convert into an animation pointer. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the legal animation that this target represents. If it *
|
|
* doesn't represent a legal animation, then NULL is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/08/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
AnimClass * As_Animation(TARGET target, bool check_active)
|
|
{
|
|
AnimClass* anim = Is_Target_Animation(target) ? Anims.Raw_Ptr(Target_Value(target)) : NULL;
|
|
if (check_active && anim != NULL && !anim->IsActive) {
|
|
anim = NULL;
|
|
}
|
|
return(anim);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Bullet -- Converts the target into a bullet pointer. *
|
|
* *
|
|
* This routine will convert the specified target number into a bullet pointer. *
|
|
* *
|
|
* INPUT: target -- The target number to convert. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the bullet it specifies. If the target doesn't refer to *
|
|
* a legal bullet, then NULL is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/08/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
BulletClass * As_Bullet(TARGET target, bool check_active)
|
|
{
|
|
BulletClass* bullet = Is_Target_Bullet(target) ? Bullets.Raw_Ptr(Target_Value(target)) : NULL;
|
|
if (check_active && bullet != NULL && !bullet->IsActive) {
|
|
bullet = NULL;
|
|
}
|
|
return(bullet);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Aircraft -- Converts the target value into an aircraft pointer. *
|
|
* *
|
|
* This routine will convert the specified target value into an aircraft object pointer. *
|
|
* *
|
|
* INPUT: target -- The target value to convert. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the aircraft that this target value represents. If the *
|
|
* specified target value doesn't represent an aircraft, then NULL is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 08/27/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
AircraftClass * As_Aircraft(TARGET target, bool check_active)
|
|
{
|
|
AircraftClass* aircraft = Is_Target_Aircraft(target) ? Aircraft.Raw_Ptr(Target_Value(target)) : NULL;
|
|
if (check_active && aircraft != NULL && !aircraft->IsActive) {
|
|
aircraft = NULL;
|
|
}
|
|
return(aircraft);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Techno -- Converts a target value into a TechnoClass pointer. *
|
|
* *
|
|
* This routine will take the target value specified and convert it into a TechnoClass *
|
|
* pointer if the target represents an object that has a TechnoClass. *
|
|
* *
|
|
* INPUT: target -- The target value to convert into a TechnoClass pointer. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the associated object's TechnoClass. If the target *
|
|
* cannot be converted into a TechnoClass pointer, then NULL is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 06/02/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
TechnoClass * As_Techno(TARGET target, bool check_active)
|
|
{
|
|
ObjectClass * obj = As_Object(target, check_active);
|
|
|
|
if (obj && obj->Is_Techno()) {
|
|
return(TechnoClass *)obj;
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Object -- Converts a target value into an object pointer. *
|
|
* *
|
|
* This routine is used to convert the target value specified into an object pointer. If *
|
|
* the target doesn't represent an object or the target value is illegal, then NULL is *
|
|
* returned. *
|
|
* *
|
|
* INPUT: target -- The target value to convert from. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the object it represent, or NULL if not an object. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
ObjectClass * As_Object(TARGET target, bool check_active)
|
|
{
|
|
int val = Target_Value(target);
|
|
ObjectClass * object = NULL;
|
|
switch (Target_Kind(target)) {
|
|
case RTTI_INFANTRY:
|
|
object = Infantry.Raw_Ptr(val);
|
|
break;
|
|
|
|
case RTTI_UNIT:
|
|
object = Units.Raw_Ptr(val);
|
|
break;
|
|
|
|
case RTTI_VESSEL:
|
|
object = Vessels.Raw_Ptr(val);
|
|
break;
|
|
|
|
case RTTI_BUILDING:
|
|
object = Buildings.Raw_Ptr(val);
|
|
break;
|
|
|
|
case RTTI_AIRCRAFT:
|
|
object = Aircraft.Raw_Ptr(val);
|
|
break;
|
|
|
|
case RTTI_TERRAIN:
|
|
object = Terrains.Raw_Ptr(val);
|
|
break;
|
|
|
|
case RTTI_BULLET:
|
|
object = Bullets.Raw_Ptr(val);
|
|
break;
|
|
|
|
case RTTI_ANIM:
|
|
object = Anims.Raw_Ptr(val);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/*
|
|
** Special check to ensure that a target value that references an
|
|
** invalid object will not be converted back into an object pointer.
|
|
** This condition is rare, but could occur in a network game if the
|
|
** object it refers to is destroyed between the time an event message
|
|
** is sent and when it is received.
|
|
*/
|
|
if (check_active && object != NULL && !object->IsActive) {
|
|
object = NULL;
|
|
}
|
|
|
|
return(object);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Unit -- Converts a target value into a unit pointer. *
|
|
* *
|
|
* This routine is used to convert the target value specified into a pointer to a unit *
|
|
* object. *
|
|
* *
|
|
* INPUT: target -- The target value to convert into a unit pointer. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the unit the target value represents or NULL if not *
|
|
* a unit. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
UnitClass * As_Unit(TARGET target, bool check_active)
|
|
{
|
|
UnitClass* unit = Is_Target_Unit(target) ? Units.Raw_Ptr(Target_Value(target)) : NULL;
|
|
if (check_active && unit != NULL && !unit->IsActive) {
|
|
unit = NULL;
|
|
}
|
|
return(unit);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Vessel -- Converts a target number into a vessel pointer. *
|
|
* *
|
|
* Use this routine to conver the specified target number into a pointer to a vessel object *
|
|
* that it represents. *
|
|
* *
|
|
* INPUT: target -- The target number to convert to a vessel pointer. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the vessel object that this target value represents. If *
|
|
* the target number does not represent a vessel, then null is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/16/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
VesselClass * As_Vessel(TARGET target, bool check_active)
|
|
{
|
|
VesselClass* vessel = Is_Target_Vessel(target) ? Vessels.Raw_Ptr(Target_Value(target)) : NULL;
|
|
if (check_active && vessel != NULL && !vessel->IsActive) {
|
|
vessel = NULL;
|
|
}
|
|
return(vessel);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Infantry -- If the target is infantry, return a pointer to it. *
|
|
* *
|
|
* This routine will translate the specified target value into an infantry pointer if the *
|
|
* target actually represents an infantry object. *
|
|
* *
|
|
* INPUT: target -- The target to convert to a pointer. *
|
|
* *
|
|
* OUTPUT: Returns a pointer to the infantry object that this target value represents. If *
|
|
* the target doesn't represent an infantry object, then return NULL. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/17/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
InfantryClass * As_Infantry(TARGET target, bool check_active)
|
|
{
|
|
InfantryClass* infantry = Is_Target_Infantry(target) ? Infantry.Raw_Ptr(Target_Value(target)) : NULL;
|
|
if (check_active && infantry != NULL && !infantry->IsActive) {
|
|
infantry = NULL;
|
|
}
|
|
return(infantry);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Building -- Converts a target value into a building object pointer. *
|
|
* *
|
|
* This routine is used to convert the target value specified into a building pointer. *
|
|
* *
|
|
* INPUT: target -- The target value to convert from. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the building object that the target value represents. *
|
|
* If it doesn't represent a building, then return NULL. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
BuildingClass * As_Building(TARGET target, bool check_active)
|
|
{
|
|
BuildingClass* building = Is_Target_Building(target) ? Buildings.Raw_Ptr(Target_Value(target)) : NULL;
|
|
if (check_active && building != NULL && !building->IsActive) {
|
|
building = NULL;
|
|
}
|
|
return(building);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* Target_Legal -- Determines if the specified target is legal. *
|
|
* *
|
|
* This routine is used to check for the legality of the target value specified. It is *
|
|
* necessary to call this routine if there is doubt about the the legality of the target. *
|
|
* It is possible for the unit that a target value represents to be eliminated and thus *
|
|
* rendering the target value invalid. *
|
|
* *
|
|
* INPUT: target -- The target value to check. *
|
|
* *
|
|
* OUTPUT: bool; Is the target value legal? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool Target_Legal(TARGET target)
|
|
{
|
|
if (target == TARGET_NONE) return(false);
|
|
|
|
ObjectClass * obj = As_Object(target, false);
|
|
if (obj) {
|
|
return(obj->IsActive);
|
|
}
|
|
return(true);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Cell -- Converts a target value into a cell number. *
|
|
* *
|
|
* This routine is used to convert the target value specified, into a cell value. This is *
|
|
* necessary for find path and other procedures that need a cell value. *
|
|
* *
|
|
* INPUT: target -- The target value to convert to a cell value. *
|
|
* *
|
|
* OUTPUT: Returns with the target value expressed as a cell location. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/27/1994 JLB : Created. *
|
|
*=============================================================================================*/
|
|
CELL As_Cell(TARGET target)
|
|
{
|
|
return(Coord_Cell(As_Coord(target)));
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Coord -- Converts a target value into a coordinate value. *
|
|
* *
|
|
* This routine is used to convert the target value specified into a coordinate value. It *
|
|
* is necessary for those procedures that require a coordinate value. *
|
|
* *
|
|
* INPUT: target -- The target value to convert. *
|
|
* *
|
|
* OUTPUT: Returns with the target expressed as a COORDINATE value. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 05/27/1994 JLB : Created. *
|
|
* 11/16/1994 JLB : Simplified. *
|
|
*=============================================================================================*/
|
|
COORDINATE As_Coord(TARGET target)
|
|
{
|
|
if (Target_Legal(target)) {
|
|
/*
|
|
** Cell target values are handled as a special case. The value of the target number is
|
|
** actually the cell index number.
|
|
*/
|
|
if (Is_Target_Cell(target)) {
|
|
int v = Target_Value(target);
|
|
|
|
int x = ((v & 0x0FFF) << 4) + 0x0008;
|
|
int y = (((v>>12) & 0x0FFF) << 4) + 0x0008;
|
|
return(XY_Coord(x, y));
|
|
|
|
// return(Cell_Coord((CELL)Target_Value(target)));
|
|
}
|
|
|
|
/*
|
|
** Normal targets correspond to game objects. Fetch the object pointer and then ask it
|
|
** for the center coordinate. Return the center coordinate as the target's coordinate.
|
|
*/
|
|
ObjectClass * obj = As_Object(target);
|
|
if (obj != NULL) {
|
|
assert(obj->IsActive);
|
|
return(obj->Target_Coord());
|
|
}
|
|
}
|
|
|
|
/*
|
|
** An unrecognized target value results in a null coordinate value.
|
|
*/
|
|
return(0x00000000L);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Movement_Coord -- Fetches coordinate if trying to move to this target. *
|
|
* *
|
|
* This routine will convert the specified target into a coordinate location. This location *
|
|
* is used when moving to the target specified. For cells, this is the center of the cell. *
|
|
* For special buildings that allow docking, it is the center location of the docking *
|
|
* bay. *
|
|
* *
|
|
* INPUT: target -- The target to convert into a coordinate value. *
|
|
* *
|
|
* OUTPUT: Returns with the docking coordinate of the target value specified. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 08/27/1995 JLB : Created. *
|
|
*=============================================================================================*/
|
|
COORDINATE As_Movement_Coord(TARGET target)
|
|
{
|
|
if (Target_Legal(target)) {
|
|
/*
|
|
** Cell target values are handled as a special case. The value of the target number is
|
|
** actually the cell index number.
|
|
*/
|
|
if (Is_Target_Cell(target)) {
|
|
return(Cell_Coord((CELL)Target_Value(target)));
|
|
}
|
|
|
|
/*
|
|
** Normal targets correspond to game objects. Fetch the object pointer and then ask it
|
|
** for the center coordinate. Return the center coordinate as the target's coordinate.
|
|
*/
|
|
ObjectClass * obj = As_Object(target);
|
|
if (obj) {
|
|
return(obj->Docking_Coord());
|
|
}
|
|
}
|
|
|
|
/*
|
|
** An unrecognized target value results in a null coordinate value.
|
|
*/
|
|
return(0x00000000L);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* TargetClass::As_Object -- Converts a target into an object pointer. *
|
|
* *
|
|
* If the target represents an object of some type, then this routine will return a *
|
|
* pointer to the object. Otherwise it will return NULL. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the object that this target represents or NULL if it *
|
|
* doesn't represent a target. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 03/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
AbstractClass * xTargetClass::As_Abstract(bool check_active) const
|
|
{
|
|
AbstractClass* abst = NULL;
|
|
switch ((RTTIType)*this) {
|
|
case RTTI_TEAM:
|
|
abst = Teams.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_BULLET:
|
|
abst = Bullets.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_OVERLAY:
|
|
abst = Overlays.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_SMUDGE:
|
|
abst = Smudges.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_UNIT:
|
|
abst = Units.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_VESSEL:
|
|
abst = Vessels.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_BUILDING:
|
|
abst = Buildings.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_INFANTRY:
|
|
abst = Infantry.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_AIRCRAFT:
|
|
abst = Aircraft.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_TERRAIN:
|
|
abst = Terrains.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_ANIM:
|
|
abst = Anims.Raw_Ptr(Value());
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (check_active && abst != NULL && !abst->IsActive) {
|
|
abst = NULL;
|
|
}
|
|
return(abst);
|
|
}
|
|
|
|
|
|
AbstractTypeClass * xTargetClass::As_TypeClass(void) const
|
|
{
|
|
switch ((RTTIType)*this) {
|
|
case RTTI_TEAMTYPE:
|
|
return(TeamTypes.Raw_Ptr(Value()));
|
|
|
|
case RTTI_TRIGGERTYPE:
|
|
return(TriggerTypes.Raw_Ptr(Value()));
|
|
|
|
case RTTI_BULLETTYPE:
|
|
return((BulletTypeClass *)&BulletTypeClass::As_Reference(BulletType(Value())));
|
|
|
|
case RTTI_OVERLAY:
|
|
return((OverlayTypeClass *)&OverlayTypeClass::As_Reference(OverlayType(Value())));
|
|
|
|
case RTTI_SMUDGE:
|
|
return((SmudgeTypeClass *)&SmudgeTypeClass::As_Reference(SmudgeType(Value())));
|
|
|
|
case RTTI_UNIT:
|
|
return((UnitTypeClass *)&UnitTypeClass::As_Reference(UnitType(Value())));
|
|
|
|
case RTTI_VESSEL:
|
|
return((VesselTypeClass *)&VesselTypeClass::As_Reference(VesselType(Value())));
|
|
|
|
case RTTI_BUILDING:
|
|
return((BuildingTypeClass *)&BuildingTypeClass::As_Reference(StructType(Value())));
|
|
|
|
case RTTI_INFANTRY:
|
|
return((InfantryTypeClass *)&InfantryTypeClass::As_Reference(InfantryType(Value())));
|
|
|
|
case RTTI_AIRCRAFT:
|
|
return((AircraftTypeClass *)&AircraftTypeClass::As_Reference(AircraftType(Value())));
|
|
|
|
case RTTI_TERRAIN:
|
|
return((TerrainTypeClass *)&TerrainTypeClass::As_Reference(TerrainType(Value())));
|
|
|
|
case RTTI_ANIM:
|
|
return((AnimTypeClass *)&AnimTypeClass::As_Reference(AnimType(Value())));
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* TargetClass::As_Techno -- Converts a target into a techno object pointer. *
|
|
* *
|
|
* This routine is used to convert the target object into a pointer to a techno class *
|
|
* object. If the target doesn't specify a techno class object, then NULL is returned. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the techno class object that this target represents or *
|
|
* else it returns NULL. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 03/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
TechnoClass * xTargetClass::As_Techno(bool check_active) const
|
|
{
|
|
TechnoClass* techno = NULL;
|
|
switch ((RTTIType)*this) {
|
|
case RTTI_UNIT:
|
|
techno = Units.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_VESSEL:
|
|
techno = Vessels.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_BUILDING:
|
|
techno = Buildings.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_INFANTRY:
|
|
techno = Infantry.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_AIRCRAFT:
|
|
techno = Aircraft.Raw_Ptr(Value());
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (check_active && techno != NULL && !techno->IsActive) {
|
|
techno = NULL;
|
|
}
|
|
return(techno);
|
|
}
|
|
|
|
|
|
ObjectClass * xTargetClass::As_Object(bool check_active) const
|
|
{
|
|
ObjectClass* object = NULL;
|
|
switch ((RTTIType)*this) {
|
|
case RTTI_TERRAIN:
|
|
object = Terrains.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_SMUDGE:
|
|
object = Smudges.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_OVERLAY:
|
|
object = Overlays.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_BULLET:
|
|
object = Bullets.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_ANIM:
|
|
object = Anims.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_UNIT:
|
|
object = Units.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_VESSEL:
|
|
object = Vessels.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_BUILDING:
|
|
object = Buildings.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_INFANTRY:
|
|
object = Infantry.Raw_Ptr(Value());
|
|
break;
|
|
|
|
case RTTI_AIRCRAFT:
|
|
object = Aircraft.Raw_Ptr(Value());
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (check_active && object != NULL && !object->IsActive) {
|
|
object = NULL;
|
|
}
|
|
return(object);
|
|
}
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Target -- Converts a cell into a target value. *
|
|
* *
|
|
* This routine will convert a cell into a target value. *
|
|
* *
|
|
* INPUT: cell -- The cell number that will be coerced into a target value. *
|
|
* *
|
|
* OUTPUT: Returns with the target value that this cell represents. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 03/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
TARGET As_Target(CELL cell)
|
|
{
|
|
int x = Cell_X(cell);
|
|
int y = Cell_Y(cell);
|
|
|
|
x <<= 4;
|
|
y <<= 4;
|
|
|
|
x += 0x0008;
|
|
y += 0x0008;
|
|
|
|
return(Build_Target(RTTI_CELL, ((y << 12) | x) ));
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_Target -- Converts a coordinate into a target value. *
|
|
* *
|
|
* This routine is used to convert the specified coordinate into a target value. *
|
|
* *
|
|
* INPUT: coord -- The coordinate that is to be converted into a target value. *
|
|
* *
|
|
* OUTPUT: Returns with the target value that represents the coordinate. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 03/05/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
TARGET As_Target(COORDINATE coord)
|
|
{
|
|
int x = Coord_X(coord);
|
|
int y = Coord_Y(coord);
|
|
|
|
x >>= 4;
|
|
y >>= 4;
|
|
|
|
return(Build_Target(RTTI_CELL, ((y << 12) | x) ));
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_TechnoType -- Convert the target number into a techno type class pointer. *
|
|
* *
|
|
* This routine will conver the specified target number into a pointer to the techno *
|
|
* type class that it represents. *
|
|
* *
|
|
* INPUT: target -- The target number to convert. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the TechnoTypeClass object that the target number *
|
|
* represents. If it doesn't represent that kind of object, then NULL is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/16/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
TechnoTypeClass const * As_TechnoType(TARGET target)
|
|
{
|
|
int val = Target_Value(target);
|
|
switch (Target_Kind(target)) {
|
|
case RTTI_INFANTRYTYPE:
|
|
return(&InfantryTypeClass::As_Reference(InfantryType(val)));
|
|
|
|
case RTTI_UNITTYPE:
|
|
return(&UnitTypeClass::As_Reference(UnitType(val)));
|
|
|
|
case RTTI_VESSELTYPE:
|
|
return(&VesselTypeClass::As_Reference(VesselType(val)));
|
|
|
|
case RTTI_AIRCRAFTTYPE:
|
|
return(&AircraftTypeClass::As_Reference(AircraftType(val)));
|
|
|
|
case RTTI_BUILDINGTYPE:
|
|
return(&BuildingTypeClass::As_Reference(StructType(val)));
|
|
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* As_TriggerType -- Convert the specified target into a trigger type. *
|
|
* *
|
|
* This routine will conver the target number into a pointer to the trigger type it *
|
|
* represents. *
|
|
* *
|
|
* INPUT: target -- The target value to convert into a trigger type pointer. *
|
|
* *
|
|
* OUTPUT: Returns with a pointer to the trigger type object that the specified target value *
|
|
* represents. If it doesn't represent a trigger type, then NULL is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 07/16/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
TriggerTypeClass * As_TriggerType(TARGET target)
|
|
{
|
|
if (Target_Kind(target) == RTTI_TRIGGERTYPE) {
|
|
return(TriggerTypes.Raw_Ptr(Target_Value(target)));
|
|
}
|
|
return(NULL);
|
|
} |