2020-05-27 20:16:20 +01:00
|
|
|
//
|
|
|
|
// 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/OBJECT.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 : OBJECT.CPP *
|
|
|
|
* *
|
|
|
|
* Programmer : Joe L. Bostic *
|
|
|
|
* *
|
|
|
|
* Start Date : April 29, 1994 *
|
|
|
|
* *
|
|
|
|
* Last Update : October 6, 1996 [JLB] *
|
|
|
|
* *
|
|
|
|
*---------------------------------------------------------------------------------------------*
|
|
|
|
* Functions: *
|
|
|
|
* ObjectClass::AI -- Handles generic object AI processing. *
|
|
|
|
* ObjectClass::Active_Click_With -- Dispatches action on the object specified. *
|
|
|
|
* ObjectClass::Active_Click_With -- Dispatches action on the specified cell. *
|
|
|
|
* ObjectClass::Attach_Trigger -- Attach specified trigger to object. *
|
|
|
|
* ObjectClass::Can_Demolish -- Queries whether this object can be sold back. *
|
|
|
|
* ObjectClass::Can_Player_Fire -- Can the player give this object an attack mission? *
|
|
|
|
* ObjectClass::Can_Player_Move -- Can the player give this object a movement mission? *
|
|
|
|
* ObjectClass::Can_Repair -- Queries whether this object can be repaired. *
|
|
|
|
* ObjectClass::Catch_Fire -- Called when animation is attached to this object. *
|
|
|
|
* ObjectClass::Center_Coord -- Fetches the center coordinate for the object. *
|
|
|
|
* ObjectClass::Clicked_As_Target -- Triggers target selection animation. *
|
|
|
|
* ObjectClass::Debug_Dump -- Displays status of the object class to the mono monitor. *
|
|
|
|
* ObjectClass::Detach -- Detach the specified target from this object. *
|
|
|
|
* ObjectClass::Detach_All -- Removes the object from all tracking systems. *
|
|
|
|
* ObjectClass::Do_Shimmer -- Shimmers this object if it is cloaked. *
|
|
|
|
* ObjectClass::Docking_Coord -- Fetches the coordinate to dock at this object. *
|
|
|
|
* ObjectClass::Exit_Coord -- Return with the exit coordinate for this object. *
|
|
|
|
* ObjectClass::Exit_Object -- Causes the specified object to leave this object. *
|
|
|
|
* ObjectClass::Fire_Coord -- Fetches the coordinate a projectile will launch from. *
|
|
|
|
* ObjectClass::Fire_Out -- Informs object that attached animation has finished. *
|
|
|
|
* ObjectClass::Get_Mission -- Fetches the current mission of this object. *
|
|
|
|
* ObjectClass::Get_Ownable -- Fetches the house owner legality options for this object. *
|
|
|
|
* ObjectClass::Hidden -- Called when this object becomes hidden from the player. *
|
|
|
|
* ObjectClass::In_Range -- Determines if the coordinate is within weapon range. *
|
|
|
|
* ObjectClass::In_Which_Layer -- Fetches what layer this object is located in. *
|
|
|
|
* ObjectClass::Init -- Initializes the basic object system. *
|
|
|
|
* ObjectClass::Limbo -- Brings the object into a state of limbo. *
|
|
|
|
* ObjectClass::Look -- Called when this object needs to reveal terrain. *
|
|
|
|
* ObjectClass::Mark -- Handles basic marking logic. *
|
|
|
|
* ObjectClass::Mark_For_Redraw -- Marks object and system for redraw. *
|
|
|
|
* ObjectClass::Move -- Moves (by force) the object in the desired direction. *
|
|
|
|
* ObjectClass::Name -- Fetches the identification name of this object. *
|
|
|
|
* ObjectClass::ObjectClass -- Default constructor for objects. *
|
|
|
|
* ObjectClass::Paradrop -- Unlimbos object in paradrop mode. *
|
|
|
|
* ObjectClass::Passive_Click_With -- Right mouse button click process. *
|
|
|
|
* ObjectClass::Receive_Message -- Processes an incoming radio message. *
|
|
|
|
* ObjectClass::Record_The_Kill -- Records this object as killed by the specified object. *
|
|
|
|
* ObjectClass::Render -- Displays the object onto the map. *
|
|
|
|
* ObjectClass::Render_Coord -- Fetches the coordinate to draw this object at. *
|
|
|
|
* ObjectClass::Repair -- Handles object repair control. *
|
|
|
|
* ObjectClass::Revealed -- Reveals this object to the house specified. *
|
|
|
|
* ObjectClass::Scatter -- Tries to scatter this object. *
|
|
|
|
* ObjectClass::Select -- Try to make this object the "selected" object. *
|
|
|
|
* ObjectClass::Sell_Back -- Sells the object -- if possible. *
|
|
|
|
* ObjectClass::Sort_Y -- Returns the coordinate used for display order sorting. *
|
|
|
|
* ObjectClass::Take_Damage -- Applies damage to the object. *
|
|
|
|
* ObjectClass::Target_Coord -- Fetches the coordinate if this object is a target. *
|
|
|
|
* ObjectClass::Unlimbo -- Brings the object into the game system. *
|
|
|
|
* ObjectClass::Unselect -- This will un-select the object if it was selected. *
|
|
|
|
* ObjectClass::Value -- Fetches the target value of this object. *
|
|
|
|
* ObjectClass::Weapon_Range -- Returns the weapon range for the weapon specified. *
|
|
|
|
* ObjectClass::What_Action -- Determines what action to perform on specified object. *
|
|
|
|
* ObjectClass::What_Action -- Returns with the action to perform for this object. *
|
|
|
|
* ObjectTypeClass::Cost_Of -- Returns the cost to buy this unit. *
|
|
|
|
* ObjectTypeClass::Dimensions -- Gets the dimensions of the object in pixels. *
|
|
|
|
* ObjectTypeClass::Get_Cameo_Data -- Fetches pointer to cameo data for this object type. *
|
|
|
|
* ObjectTypeClass::Max_Pips -- Fetches the maximum pips allowed for this object. *
|
|
|
|
* ObjectTypeClass::ObjectTypeClass -- Normal constructor for object type class objects. *
|
|
|
|
* ObjectTypeClass::Occupy_List -- Returns with simple occupation list for object. *
|
|
|
|
* ObjectTypeClass::One_Time -- Handles one time processing for object types. *
|
|
|
|
* ObjectTypeClass::Overlap_List -- Returns a pointer to a simple overlap list. *
|
|
|
|
* ObjectTypeClass::Time_To_Build -- Fetches the time to construct this object. *
|
|
|
|
* ObjectTypeClass::Who_Can_Build_Me -- Determine what building can build this object type. *
|
|
|
|
* ObjectTypeClass::Who_Can_Build_Me -- Finds the factory building that can build this object*
|
|
|
|
* ObjectClass::Get_Image_Data -- Fetches the image data to use for this object. *
|
|
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
|
|
|
|
#include "function.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Selected objects have a special marking box around them. This is the shapes that are
|
|
|
|
** used for this purpose.
|
|
|
|
*/
|
|
|
|
void const * ObjectTypeClass::SelectShapes = 0;
|
|
|
|
|
|
|
|
void const * ObjectTypeClass::PipShapes = 0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::ObjectClass -- Default constructor for objects. *
|
|
|
|
* *
|
|
|
|
* This is the default constructor for objects. It is called as an inherent part of the *
|
|
|
|
* construction process for all the normal game objects instantiated. It serves merely to *
|
|
|
|
* initialize the object values to a common (default) state. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: Objects always start in a state of limbo. They must be Unlimbo()ed before they *
|
|
|
|
* can be used. *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/24/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
ObjectClass::ObjectClass(RTTIType rtti, int id) :
|
|
|
|
AbstractClass(rtti, id),
|
|
|
|
IsDown(false),
|
|
|
|
IsToDamage(false),
|
|
|
|
IsToDisplay(false),
|
|
|
|
IsInLimbo(true),
|
|
|
|
IsSelected(false),
|
|
|
|
IsAnimAttached(false),
|
|
|
|
IsFalling(false),
|
|
|
|
Riser(0),
|
|
|
|
Next(0),
|
|
|
|
Trigger(NULL),
|
|
|
|
Strength(255),
|
|
|
|
IsSelectedMask(0) // Mask showing who has selected this object
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Get_Image_Data -- Fetches the image data to use for this object. *
|
|
|
|
* *
|
|
|
|
* This routine will return with a pointer to the image data that should be used when *
|
|
|
|
* this object is drawn. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with a pointer to the shape data for this object. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 08/06/1996 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void const * ObjectClass::Get_Image_Data(void) const
|
|
|
|
{
|
|
|
|
return(Class_Of().Get_Image_Data());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Name -- Fetches the identification name of this object. *
|
|
|
|
* *
|
|
|
|
* This routine will return a pointer to the identifier name for this object. This name *
|
|
|
|
* is usually short and is used in the INI files to identify this object. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with a pointer to the text identifier name of this object. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/29/1996 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
char const * ObjectClass::Name(void) const
|
|
|
|
{
|
|
|
|
return(Class_Of().Name());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Exit_Coord -- Return with the exit coordinate for this object. *
|
|
|
|
* *
|
|
|
|
* Ths exit coordinate is the location that a piggy back or newly produced object will *
|
|
|
|
* appear at when it exits this object. Transports and factory buildings will utilize this *
|
|
|
|
* routine. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the coordinate that an object will appear at when exiting this *
|
|
|
|
* object. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/29/1996 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
COORDINATE ObjectClass::Exit_Coord(void) const
|
|
|
|
{
|
|
|
|
return(Center_Coord());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::AI -- Handles generic object AI processing. *
|
|
|
|
* *
|
|
|
|
* This routine is used to handle the AI processing that occurs for all object types. *
|
|
|
|
* Typically, this isn't much, but there is the concept of falling that all objects can *
|
|
|
|
* be subjected to (e.g., grenades). *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 02/07/1996 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::AI(void)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Falling logic is handled here.
|
|
|
|
*/
|
|
|
|
if (IsFalling) {
|
|
|
|
LayerType layer = In_Which_Layer();
|
|
|
|
|
|
|
|
Height += Riser;
|
|
|
|
if (Height <= 0) {
|
|
|
|
Height = 0;
|
|
|
|
IsFalling = false;
|
|
|
|
Per_Cell_Process(PCP_END);
|
|
|
|
|
|
|
|
Shorten_Attached_Anims(this);
|
|
|
|
}
|
|
|
|
if (IsAnimAttached) {
|
|
|
|
Riser -= 1;
|
|
|
|
Riser = max(Riser, -3);
|
|
|
|
} else {
|
|
|
|
Riser -= Rule.Gravity;
|
|
|
|
// Riser -= GRAVITY;
|
|
|
|
Riser = max(Riser, -100);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (layer != In_Which_Layer()) {
|
|
|
|
Map.Remove(this, layer);
|
|
|
|
Map.Submit(this, In_Which_Layer());
|
|
|
|
|
|
|
|
if (Class_Of().IsFootprint) {
|
|
|
|
if (In_Which_Layer() == LAYER_GROUND) {
|
|
|
|
Map.Place_Down(Coord_Cell(Center_Coord()), this);
|
|
|
|
} else {
|
|
|
|
Map.Pick_Up(Coord_Cell(Center_Coord()), this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::What_Action -- Determines what action to perform on specified object. *
|
|
|
|
* *
|
|
|
|
* This routine will return that action that this object could perform if the mouse were *
|
|
|
|
* clicked over the object specified. *
|
|
|
|
* *
|
|
|
|
* INPUT: object -- Pointer to the object to check this object against when determining *
|
|
|
|
* the action to perform. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: It returns that action that will be performed if the mouse were clicked over the *
|
|
|
|
* object. Since non-derived objects cannot do anything, and cannot even be *
|
|
|
|
* instantiated, this routine will always return ACTION_NONE. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/19/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
ActionType ObjectClass::What_Action(ObjectClass const *) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(ACTION_NONE);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::What_Action -- Returns with the action to perform for this object. *
|
|
|
|
* *
|
|
|
|
* This routine is called when information on a potential action if the mouse were clicked *
|
|
|
|
* on the cell specified. This routine merely serves as a virtual placeholder so that *
|
|
|
|
* object types that can actually perform some action will override this routine to provide *
|
|
|
|
* true functionality. *
|
|
|
|
* *
|
|
|
|
* INPUT: cell -- The cell that the mouse is over and might be clicked on. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the action that this object would try to perform if the mouse were *
|
|
|
|
* clicked. Since objects at this level have no ability to do anything, this routine *
|
|
|
|
* will always returns ACTION_NONE unless it is overridden. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 08/13/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
ActionType ObjectClass::What_Action(CELL) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(ACTION_NONE);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::In_Which_Layer -- Fetches what layer this object is located in. *
|
|
|
|
* *
|
|
|
|
* The default layer for object location is the LAYER_GROUND. Aircraft will override this *
|
|
|
|
* routine and make adjustments as necessary according to the aircraft's altitude. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the layer that this object is located in. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 08/13/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
LayerType ObjectClass::In_Which_Layer(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
if (Height < (FLIGHT_LEVEL - (FLIGHT_LEVEL/3))) {
|
|
|
|
return(LAYER_GROUND);
|
|
|
|
}
|
|
|
|
return(LAYER_TOP);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Get_Ownable -- Fetches the house owner legality options for this object. *
|
|
|
|
* *
|
|
|
|
* This routine will return the ownable bits for this object. Objects at this level can't *
|
|
|
|
* really be owned by anyone, but return the full spectrum of legality just to be safe. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the ownable flags (as a combined bitfield) for this object. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 08/13/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
int ObjectClass::Get_Ownable(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(HOUSEF_ALLIES | HOUSEF_SOVIET | HOUSEF_OTHERS);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Can_Repair -- Queries whether this object can be repaired. *
|
|
|
|
* *
|
|
|
|
* Most objects cannot be repaired. This routine defaults to returning "false", but is *
|
|
|
|
* overridden by derived functions defined by object types that can support repair. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Can this object be repaired? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 08/13/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Can_Repair(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Can_Demolish -- Queries whether this object can be sold back. *
|
|
|
|
* *
|
|
|
|
* This routine is used to determine if this object can be sold. Most objects cannot be *
|
|
|
|
* but for those objects that can, this routine will be overridden as necessary. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Can this object be sold back? Typically, the answer is no. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 08/13/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Can_Demolish(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool ObjectClass::Can_Demolish_Unit(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-09-16 18:03:04 +01:00
|
|
|
bool ObjectClass::Can_Capture(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-27 20:16:20 +01:00
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Can_Player_Fire -- Can the player give this object an attack mission? *
|
|
|
|
* *
|
|
|
|
* This routine is used to determine if attacking is an option under player control with *
|
|
|
|
* respect to this unit. This routine will be overridden as necessary for those objects *
|
|
|
|
* that have the ability to attack. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Can this object be given an attack order by the player? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 08/13/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Can_Player_Fire(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Can_Player_Move -- Can the player give this object a movement mission? *
|
|
|
|
* *
|
|
|
|
* This routine is used to determine if the player has the ability to command this object *
|
|
|
|
* with a movement mission. This routine will be overridden as necessary to support this *
|
|
|
|
* ability. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Can this object be given a movement mission by the player? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 08/13/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Can_Player_Move(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Target_Coord -- Fetches the coordinate if this object is a target. *
|
|
|
|
* *
|
|
|
|
* When the coordinate to use when firing at this object is needed, this routine will *
|
|
|
|
* provide it. Normal objects just use the center of the object for this, but there are *
|
|
|
|
* some more sophisticated objects that are not fired upon the center. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the coordinate to fire at if this object is a target. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 08/13/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
COORDINATE ObjectClass::Target_Coord(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(Coord_Add(XY_Coord(0, -Height), Center_Coord()));
|
|
|
|
// return(Center_Coord());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Center_Coord -- Fetches the center coordinate for the object. *
|
|
|
|
* *
|
|
|
|
* This routine will return the center coordinate for the object. The center coordinate is *
|
|
|
|
* typically the coordinate recorded in the object structure. Exceptions to this include *
|
|
|
|
* the trees and other terrain elements. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns the coordinate that is considered the center point of this object. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
COORDINATE ObjectClass::Center_Coord(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(Coord);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Render_Coord -- Fetches the coordinate to draw this object at. *
|
|
|
|
* *
|
|
|
|
* This routine will return the coordinate to base the drawing of this object's graphic *
|
|
|
|
* at. This is adjusted according to the nature of the graphic associated with this *
|
|
|
|
* object. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns the coordinate to draw the graphic of this object at. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
COORDINATE ObjectClass::Render_Coord(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(Center_Coord());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Docking_Coord -- Fetches the coordinate to dock at this object. *
|
|
|
|
* *
|
|
|
|
* This routine returns the coordinate that a potential docking object should home in on. *
|
|
|
|
* Typically, this the center of the object, but in certain cases it is adjusted off center *
|
|
|
|
* according to the object type. An example of this would be the airfield. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the coordinate that a docking object should head for. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
COORDINATE ObjectClass::Docking_Coord(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(Center_Coord());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Sort_Y -- Returns the coordinate used for display order sorting. *
|
|
|
|
* *
|
|
|
|
* This routine will return the value to be used for object sorting. The sorting ensures *
|
|
|
|
* that the object are rendered from a top to bottom order. Certain object use a sorting *
|
|
|
|
* value different from their center coordinate. This is true if the object "touches the *
|
|
|
|
* ground" at a point that is different from the object's center point. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the value to use as the Y sorting value. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
COORDINATE ObjectClass::Sort_Y(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(Coord);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Fire_Coord -- Fetches the coordinate a projectile will launch from. *
|
|
|
|
* *
|
|
|
|
* For those objects that fire, the coordinate that the projectile it launches will appear *
|
|
|
|
* at the location specified by the return value from this function. *
|
|
|
|
* *
|
|
|
|
* INPUT: which -- Which weapon to consider when determining fire coordinate? *
|
|
|
|
* 0: primary weapon *
|
|
|
|
* 1: secondary weapon *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the coordinate that a launched projectile will appear at if this *
|
|
|
|
* object were to fire the weapon specified. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
2020-08-06 17:44:54 +01:00
|
|
|
FireDataType ObjectClass::Fire_Data(int which) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return{Fire_Coord(which),0};
|
|
|
|
}
|
|
|
|
|
2020-05-27 20:16:20 +01:00
|
|
|
COORDINATE ObjectClass::Fire_Coord(int ) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(Coord);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Record_The_Kill -- Records this object as killed by the specified object. *
|
|
|
|
* *
|
|
|
|
* This routine is called when this object is killed. If the source of the death is known, *
|
|
|
|
* then a pointer to the responsible object is provided as a parameter. *
|
|
|
|
* *
|
|
|
|
* INPUT: source -- Pointer to the cause of this unit's death. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Record_The_Kill(TechnoClass * )
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Do_Shimmer -- Shimmers this object if it is cloaked. *
|
|
|
|
* *
|
|
|
|
* When an object is cloaked, there are several conditions that would cause it to shimmer *
|
|
|
|
* and thus reveal itself. When such a condition arrises, this function is called. If the *
|
|
|
|
* object is cloaked, then it will shimmer. At this derivation level, cloaking is *
|
|
|
|
* undefined. Objects that can cloak will override this function as necessary. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Do_Shimmer(void)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Exit_Object -- Causes the specified object to leave this object. *
|
|
|
|
* *
|
|
|
|
* This routine is called, typically, by a transport building type that requires an object *
|
|
|
|
* to leave it. This routine will place the object at a suitable location or return *
|
|
|
|
* a value indicating why not. *
|
|
|
|
* *
|
|
|
|
* INPUT: object -- Pointer to the object that wishes to leave this object. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns the success value of the attempt: *
|
|
|
|
* 0: Object could not be placed -- ever *
|
|
|
|
* 1: Object placement is temporarily delayed -- try again later. *
|
|
|
|
* 2: Object placement proceeded normally *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
int ObjectClass::Exit_Object(TechnoClass *)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Hidden -- Called when this object becomes hidden from the player. *
|
|
|
|
* *
|
|
|
|
* This routine is called when the object becomes hidden from the player. It can result in *
|
|
|
|
* lost targeting and tracking abilities with respect to the hidden object. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Hidden(void)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Look -- Called when this object needs to reveal terrain. *
|
|
|
|
* *
|
|
|
|
* This routine is called when the object needs to look around the terrain. For player *
|
|
|
|
* owned objects, the terrain is revealed. For non-player objects, not effect occurs. *
|
|
|
|
* *
|
|
|
|
* INPUT: incremental -- If true, then the looking algorithm will only examine the edges *
|
|
|
|
* of the sight range. This is more efficient and work well if the *
|
|
|
|
* object has only moved one cell since the last time it has performed *
|
|
|
|
* the look operation. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: This can be a time consuming operation. Call only when necessary. *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Look(bool )
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Active_Click_With -- Dispatches action on the object specified. *
|
|
|
|
* *
|
|
|
|
* This routine is called when this object is selected and the mouse was clicked on the *
|
|
|
|
* tactical map. An action is required from the object. The object that the mouse was *
|
|
|
|
* over and the tentative action to perform are provided as parameters. *
|
|
|
|
* *
|
|
|
|
* INPUT: action -- The requested action to perform with the object specified. *
|
|
|
|
* *
|
|
|
|
* object -- The object that the action should be performed on. This object is *
|
|
|
|
* what the mouse was over when the click occurred. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Active_Click_With(ActionType , ObjectClass *)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Active_Click_With -- Dispatches action on the specified cell. *
|
|
|
|
* *
|
|
|
|
* This routine will dispatch the action requested upon the cell specified. It is called *
|
|
|
|
* when the mouse is clicked over a cell while this object is selected. *
|
|
|
|
* *
|
|
|
|
* INPUT: action -- The action to perform. *
|
|
|
|
* *
|
|
|
|
* cell -- The location (cell) to perform this action upon. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Active_Click_With(ActionType , CELL )
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Clicked_As_Target -- Triggers target selection animation. *
|
|
|
|
* *
|
|
|
|
* This routine is called when this object is the target of some player click action. *
|
|
|
|
* For more sophisticated object, this will trigger the object to begin flashing a few *
|
|
|
|
* times. At this level, no action is performed. *
|
|
|
|
* *
|
|
|
|
* INPUT: flashes -- The requested number of times to flash this object. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Clicked_As_Target(HousesType house, int) // 2019/09/20 JAS - Added record of who clicked on the object
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::In_Range -- Determines if the coordinate is within weapon range. *
|
|
|
|
* *
|
|
|
|
* This routine will determine if the specified coordinate is within weapon range. *
|
|
|
|
* *
|
|
|
|
* INPUT: coord -- The coordinate to check to see if it is within weapon range. *
|
|
|
|
* *
|
|
|
|
* which -- The weapon to check against. *
|
|
|
|
* 0: primary weapon *
|
|
|
|
* 1: secondary weapon *
|
|
|
|
* *
|
|
|
|
* OUTPUT: bool; Is the specified coordinate within weapon range for the weapon type *
|
|
|
|
* specified? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::In_Range(COORDINATE , int) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Weapon_Range -- Returns the weapon range for the weapon specified. *
|
|
|
|
* *
|
|
|
|
* This routine will return the weapon range according to the type of weapon specified. *
|
|
|
|
* *
|
|
|
|
* INPUT: which -- The weapon to fetch the range from. *
|
|
|
|
* 0: primary weapon *
|
|
|
|
* 1: secondary weapon *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the range (in leptons) of the weapon specified. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
int ObjectClass::Weapon_Range(int) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Scatter -- Tries to scatter this object. *
|
|
|
|
* *
|
|
|
|
* This routine is used when the object should scatter from its current location. It *
|
|
|
|
* applies to units that have the ability to move. *
|
|
|
|
* *
|
|
|
|
* INPUT: coord -- The source of the threat that is causing the scatter. *
|
|
|
|
* *
|
|
|
|
* forced-- Whether this scatter attempt is serious and scattering should occur *
|
|
|
|
* regardless of what is doing now. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: This may or may not cause the object to scatter. It is merely a request to the *
|
|
|
|
* object that it would be good if it were to scatter. *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Scatter(COORDINATE , bool, bool)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Catch_Fire -- Called when animation is attached to this object. *
|
|
|
|
* *
|
|
|
|
* This routine is called when an animation is attached to this object. It might be a *
|
|
|
|
* fire animation (hence the name), but it might also be smoke or any other animation *
|
|
|
|
* as well. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: bool; Was the object caught on fire by this routine? Actually, this is really *
|
|
|
|
* the answer to this question; "Is this animation attaching to this object *
|
|
|
|
* that doesn't already have an animation attached?" *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/21/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Catch_Fire(void)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Fire_Out -- Informs object that attached animation has finished. *
|
|
|
|
* *
|
|
|
|
* This routine is called if there is an attached animation on this object and that *
|
|
|
|
* animation has finished. Typically, this is necessary for when trees are on fire. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/24/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Fire_Out(void)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Value -- Fetches the target value of this object. *
|
|
|
|
* *
|
|
|
|
* This routine will return the target value of this object. The higher the number, the *
|
|
|
|
* better the object will be as a target. This routine is called when searching for *
|
|
|
|
* targets. Generic objects have no target potential, and this routine returns zero to *
|
|
|
|
* reflect that. Other object types will override this routine to return the appropriate *
|
|
|
|
* target value. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the value of this object as a target. Higher values mean better *
|
|
|
|
* target. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/24/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
int ObjectClass::Value(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Get_Mission -- Fetches the current mission of this object. *
|
|
|
|
* *
|
|
|
|
* Generic objects don't have a mission, so this routine will just return MISSION_NONE. *
|
|
|
|
* However, techno objects do have a mission and this routine is overloaded to handle *
|
|
|
|
* those objects in order to return the correct mission value. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the current mission being followed by this object. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/24/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
MissionType ObjectClass::Get_Mission(void) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(MISSION_NONE);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Repair -- Handles object repair control. *
|
|
|
|
* *
|
|
|
|
* This routine will control object repair mode. At the object level, no repair is *
|
|
|
|
* possible, so it is expected that any object that can repair will override this function *
|
|
|
|
* as necessary. *
|
|
|
|
* *
|
|
|
|
* INPUT: control -- The repair control parameter. *
|
|
|
|
* 0 = turn repair off *
|
|
|
|
* 1 = turn repair on *
|
|
|
|
* -1 = toggle repair state *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/24/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Repair(int )
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Sell_Back -- Sells the object -- if possible. *
|
|
|
|
* *
|
|
|
|
* This routine is called to sell back the object. Override this routine for the more *
|
|
|
|
* sophisticated objects that can actually be sold back. Normal objects can't be sold and *
|
|
|
|
* this routine does nothing as a consequence. *
|
|
|
|
* *
|
|
|
|
* INPUT: control -- How to control the sell state of this object. *
|
|
|
|
* 0 = stop selling. *
|
|
|
|
* 1 = start selling. *
|
|
|
|
* -1 = toggle selling state. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/19/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Sell_Back(int )
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Move -- Moves (by force) the object in the desired direction. *
|
|
|
|
* *
|
|
|
|
* This routine will instantly move the object one cell in the specified direction. It *
|
|
|
|
* moves the object by force. This is typically ONLY used by the scenario editor *
|
|
|
|
* process. *
|
|
|
|
* *
|
|
|
|
* INPUT: facing -- The direction to move the object. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: Naturally, this can cause illegal placement situations -- use with caution. *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 06/19/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Move(FacingType facing)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
COORDINATE coord;
|
|
|
|
|
|
|
|
Mark(MARK_UP);
|
|
|
|
coord = Adjacent_Cell(Coord, facing);
|
|
|
|
if (Can_Enter_Cell(Coord_Cell(coord)) == MOVE_OK) {
|
|
|
|
Coord = coord;
|
|
|
|
}
|
|
|
|
Mark(MARK_DOWN);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Object selection list is switched with player context for GlyphX. ST - 4/17/2019 9:42AM
|
|
|
|
extern void Logic_Switch_Player_Context(ObjectClass *object);
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Unselect -- This will un-select the object if it was selected. *
|
|
|
|
* *
|
|
|
|
* This routine brings a currently selected object into an unselected state. This is *
|
|
|
|
* needed when another object becomes selected as well as if the object is destroyed. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 06/19/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Unselect(void)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
//if (IsSelected) {
|
|
|
|
// Updated to function for multiplayer - 6/26/2019 JAS
|
|
|
|
if (Is_Selected_By_Player()) {
|
|
|
|
|
|
|
|
if (In_Which_Layer() == LAYER_GROUND) Mark(MARK_OVERLAP_UP);
|
|
|
|
|
|
|
|
IsSelected = false;
|
|
|
|
|
|
|
|
// Updated to function for multiplayer - 6/26/2019 JAS
|
|
|
|
Set_Unselected_By_Player();
|
|
|
|
|
|
|
|
if (In_Which_Layer() == LAYER_GROUND) Mark(MARK_OVERLAP_DOWN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Unselect_All_Players -- This will un-select the object if it was selected *
|
|
|
|
* from all players *
|
|
|
|
* *
|
|
|
|
* This routine brings a currently selected object into an unselected state for all players.*
|
|
|
|
* This is needed when the object is destroyed. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 06/25/2019 JAS : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Unselect_All_Players(void)
|
|
|
|
{
|
|
|
|
CurrentObject.Delete_All(this);
|
|
|
|
|
|
|
|
if (In_Which_Layer() == LAYER_GROUND) {
|
|
|
|
Mark(MARK_OVERLAP_UP);
|
|
|
|
}
|
|
|
|
|
|
|
|
IsSelected = false;
|
|
|
|
IsSelectedMask = 0;
|
|
|
|
|
|
|
|
if (In_Which_Layer() == LAYER_GROUND) {
|
|
|
|
Mark(MARK_OVERLAP_DOWN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Unselect_All_Players_Except_Owner -- This will un-select the object if it was *
|
|
|
|
* selected for all players except for the object's owner *
|
|
|
|
* *
|
|
|
|
* This routine brings a currently selected object into an unselected state for all players.*
|
|
|
|
* This is needed when the object cloaks. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 06/28/2019 JAS : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Unselect_All_Players_Except_Owner(void)
|
|
|
|
{
|
|
|
|
CurrentObject.Delete_All_Except(this, Owner());
|
|
|
|
|
|
|
|
if (In_Which_Layer() == LAYER_GROUND) {
|
|
|
|
Mark(MARK_OVERLAP_UP);
|
|
|
|
}
|
|
|
|
|
|
|
|
int owner_mask = 1 << Owner();
|
|
|
|
if (IsSelectedMask & owner_mask)
|
|
|
|
{
|
|
|
|
IsSelected = true;
|
|
|
|
IsSelectedMask = owner_mask;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
IsSelected = false;
|
|
|
|
IsSelectedMask = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (In_Which_Layer() == LAYER_GROUND) {
|
|
|
|
Mark(MARK_OVERLAP_DOWN);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Select -- Try to make this object the "selected" object. *
|
|
|
|
* *
|
|
|
|
* This routine is used to make this object into the one that is "selected". A selected *
|
|
|
|
* object usually displays a floating bar graph and is available to be given orders from *
|
|
|
|
* the player's I/O. *
|
|
|
|
* *
|
|
|
|
* INPUT: allow_mixed -- Allow a mix of player and non-player controlled units? *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 06/19/1994 JLB : Created. *
|
|
|
|
* 06/12/1995 JLB : Cannot select a loaner object. *
|
|
|
|
* 07/23/1995 JLB : Adds to head or tail depending on leader type flag. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Select(bool allow_mixed)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
//if (!Debug_Map && (IsSelected || !Class_Of().IsSelectable)) {
|
|
|
|
// return(false);
|
|
|
|
//}
|
|
|
|
// Updated to function for multiplayer - 6/26/2019 JAS
|
|
|
|
if (!Debug_Map && (Is_Selected_By_Player() || !Class_Of().IsSelectable)) {
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Debug_Map && Can_Player_Move() && Is_Techno() && ((TechnoClass *)this)->IsALoaner) {
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Don't allow selection if the object is still in the air.
|
|
|
|
*/
|
|
|
|
if (Height > 0 && (What_Am_I() == RTTI_UNIT || What_Am_I() == RTTI_VESSEL || What_Am_I() == RTTI_INFANTRY)) {
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Don't allow selection of object when in building placement mode.
|
|
|
|
*/
|
|
|
|
if (Map.PendingObject) {
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!allow_mixed) {
|
|
|
|
/*
|
|
|
|
** If selecting an object of a different house than the player's, make sure that
|
|
|
|
** the entire selection list is cleared.
|
|
|
|
*/
|
|
|
|
for (int i = 0; i < CurrentObject.Count(); i++) {
|
|
|
|
HouseClass * tryhptr = HouseClass::As_Pointer(Owner());
|
|
|
|
HouseClass * oldhptr = HouseClass::As_Pointer(CurrentObject[i]->Owner());
|
|
|
|
// if (Owner() != CurrentObject[0]->Owner() || CurrentObject[0]->Owner() != PlayerPtr->Class->House) {
|
|
|
|
if (oldhptr->IsPlayerControl != tryhptr->IsPlayerControl) {
|
|
|
|
Unselect_All();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (In_Which_Layer() == LAYER_GROUND) Mark(MARK_OVERLAP_UP);
|
|
|
|
|
|
|
|
//IsSelected = true;
|
|
|
|
// Updated to function for multiplayer - 6/26/2019 JAS
|
|
|
|
Set_Selected_By_Player();
|
|
|
|
|
|
|
|
if (In_Which_Layer() == LAYER_GROUND) Mark(MARK_OVERLAP_DOWN);
|
|
|
|
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Render -- Displays the object onto the map. *
|
|
|
|
* *
|
|
|
|
* This routine will determine the location of the object and if it is roughly on the *
|
|
|
|
* visible screen, it will display it. Not displaying objects that are not on the screen *
|
|
|
|
* will save valuable time. *
|
|
|
|
* *
|
|
|
|
* INPUT: bool; Should the render be forced regardless of whether the object is flagged to *
|
|
|
|
* be redrawn? *
|
|
|
|
* *
|
|
|
|
* OUTPUT: bool; Was the draw code called for this object? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 06/19/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Render(bool forced) const
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
int x, y;
|
|
|
|
COORDINATE coord = Render_Coord();
|
|
|
|
CELL cell = Coord_Cell(coord);
|
|
|
|
|
|
|
|
if (Debug_Map || Debug_Unshroud || ((forced || IsToDisplay) && IsDown && !IsInLimbo)) {
|
|
|
|
const_cast<ObjectClass*>(this)->IsToDisplay = false; // added const_cast ST - 5/9/2019
|
|
|
|
|
|
|
|
if (Map.Coord_To_Pixel(coord, x, y)) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Draw the object itself
|
|
|
|
*/
|
|
|
|
Draw_It(x, y, WINDOW_TACTICAL);
|
|
|
|
|
|
|
|
#ifdef SCENARIO_EDITOR
|
|
|
|
/*
|
|
|
|
** Draw the trigger attached to the object. Draw_It is window-
|
|
|
|
** relative, so add the window's x-coord to 'x'.
|
|
|
|
*/
|
|
|
|
if (Debug_Map && Trigger.Is_Valid()) {
|
|
|
|
Fancy_Text_Print(Trigger->Class->IniName,
|
|
|
|
x + (WinX), y,
|
|
|
|
&ColorRemaps[PCOLOR_RED], TBLACK,
|
|
|
|
TPF_CENTER | TPF_NOSHADOW | TPF_6POINT);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CHEAT_KEYS
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Debug_Dump -- Displays status of the object class to the mono monitor. *
|
|
|
|
* *
|
|
|
|
* This routine is used to display the current status of the object class to the mono *
|
|
|
|
* monitor. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 06/02/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Debug_Dump(MonoClass * mono) const
|
|
|
|
{
|
|
|
|
mono->Set_Cursor(1, 1);mono->Printf("%-18.18s", Text_String(Full_Name()));
|
|
|
|
if (Next != NULL) {
|
|
|
|
mono->Set_Cursor(20, 5);mono->Printf("%08X", Next->As_Target());
|
|
|
|
}
|
|
|
|
if (Trigger.Is_Valid()) {
|
|
|
|
mono->Text_Print(Trigger->Class->IniName, 11, 3);
|
|
|
|
}
|
|
|
|
mono->Set_Cursor(34, 1);mono->Printf("%3d", Strength);
|
|
|
|
|
|
|
|
mono->Fill_Attrib(1, 13, 12, 1, IsDown ? MonoClass::INVERSE : MonoClass::NORMAL);
|
|
|
|
mono->Fill_Attrib(1, 14, 12, 1, IsToDamage ? MonoClass::INVERSE : MonoClass::NORMAL);
|
|
|
|
mono->Fill_Attrib(1, 15, 12, 1, IsToDisplay ? MonoClass::INVERSE : MonoClass::NORMAL);
|
|
|
|
mono->Fill_Attrib(1, 16, 12, 1, IsInLimbo ? MonoClass::INVERSE : MonoClass::NORMAL);
|
|
|
|
// Updated to function for multiplayer - 6/26/2019 JAS
|
|
|
|
mono->Fill_Attrib(1, 17, 12, 1, Is_Selected_By_Player() ? MonoClass::INVERSE : MonoClass::NORMAL);
|
|
|
|
mono->Fill_Attrib(14, 13, 12, 1, IsAnimAttached ? MonoClass::INVERSE : MonoClass::NORMAL);
|
|
|
|
mono->Set_Cursor(23, 14);mono->Printf("%d", Riser);
|
|
|
|
mono->Fill_Attrib(14, 12, 14, 1, IsFalling ? MonoClass::INVERSE : MonoClass::NORMAL);
|
|
|
|
|
|
|
|
AbstractClass::Debug_Dump(mono);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Mark_For_Redraw -- Marks object and system for redraw. *
|
|
|
|
* *
|
|
|
|
* This routine will mark the object and inform the display system *
|
|
|
|
* that appropriate rendering is needed. Whenever it is determined *
|
|
|
|
* that an object needs to be redrawn, call this routine. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: This is a subordinate function to the function Mark(). If an object needs to *
|
|
|
|
* be redrawn it is probably better to call the function Mark(MARK_CHANGE) rather *
|
|
|
|
* than this function. This function does not inform the map system that *
|
|
|
|
* overlapping objects are to be redrawn and thus unless you are really sure that *
|
|
|
|
* this routine should be called, don't. *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 05/08/1994 JLB : Created. *
|
|
|
|
* 12/23/1994 JLB : Flags map and flags unit only. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Mark_For_Redraw(void)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
if (!IsToDisplay) {
|
|
|
|
IsToDisplay = true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
** This tells the map rendering logic to "go through the motions" and call the
|
|
|
|
** rendering function. In the rendering function, it will sort out what gets
|
|
|
|
** rendered and what doesn't.
|
|
|
|
*/
|
|
|
|
Map.Flag_To_Redraw(false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Limbo -- Brings the object into a state of limbo. *
|
|
|
|
* *
|
|
|
|
* An object brought into a state of limbo by this routine can be safely deleted. This *
|
|
|
|
* routine will remove the object from all game lists and tracking systems. It is called *
|
|
|
|
* prior to deleting the object or placing the object "on ice". *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: bool; Was the object successfully placed in limbo? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/24/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Limbo(void)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
if (GameActive && !IsInLimbo) {
|
|
|
|
|
|
|
|
//Unselect();
|
|
|
|
// Updated to function for multiplayer - 6/26/2019 JAS
|
|
|
|
Unselect_All_Players();
|
|
|
|
|
|
|
|
Detach_All();
|
|
|
|
Mark(MARK_UP);
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Remove the object from the appropriate display list.
|
|
|
|
*/
|
|
|
|
Map.Remove(this, In_Which_Layer());
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Remove the object from the logic processing list.
|
|
|
|
*/
|
|
|
|
if (Class_Of().IsSentient) {
|
|
|
|
Logic.Delete(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
Hidden();
|
|
|
|
IsInLimbo = true;
|
|
|
|
IsToDisplay = false;
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Unlimbo -- Brings the object into the game system. *
|
|
|
|
* *
|
|
|
|
* This routine will place the object into the game tracking and display systems. It is *
|
|
|
|
* called as a consequence of creating the object. Every game object must be unlimboed at *
|
|
|
|
* some point. *
|
|
|
|
* *
|
|
|
|
* INPUT: coord -- The coordinate to place the object into the game system. *
|
|
|
|
* *
|
|
|
|
* dir (optional) -- initial facing direction for this object *
|
|
|
|
* *
|
|
|
|
* OUTPUT: bool; Was the game object successfully unlimboed? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/24/1994 JLB : Created. *
|
|
|
|
* 12/23/1994 JLB : Sets object strength. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Unlimbo(COORDINATE coord, DirType )
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
if (GameActive && IsInLimbo && !IsDown) {
|
|
|
|
if (ScenarioInit || Can_Enter_Cell(Coord_Cell(coord), FACING_NONE) == MOVE_OK) {
|
|
|
|
IsInLimbo = false;
|
|
|
|
IsToDisplay = false;
|
|
|
|
Coord = Class_Of().Coord_Fixup(coord);
|
|
|
|
|
|
|
|
if (Mark(MARK_DOWN)) {
|
|
|
|
if (IsActive) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Add the object to the appropriate map layer. This layer is used
|
|
|
|
** for rendering purposes.
|
|
|
|
*/
|
|
|
|
if (In_Which_Layer() != LAYER_NONE) {
|
|
|
|
Map.Submit(this, In_Which_Layer());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Class_Of().IsSentient) {
|
|
|
|
Logic.Submit(this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Detach -- Detach the specified target from this object. *
|
|
|
|
* *
|
|
|
|
* This routine is called when the object (as specified) is to be removed from the game *
|
|
|
|
* engine and thus, all references to it must be severed. Typically, the only thing *
|
|
|
|
* checked for at this level is the attached trigger. *
|
|
|
|
* *
|
|
|
|
* INPUT: target -- The target that will be removed from the game system. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/29/1996 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Detach(TARGET target, bool )
|
|
|
|
{
|
|
|
|
if (Trigger.Is_Valid() && Is_Target_Trigger(target) && Trigger->As_Target() == target) {
|
|
|
|
Attach_Trigger(NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Detach_All -- Removes the object from all tracking systems. *
|
|
|
|
* *
|
|
|
|
* This routine will take the object and see that it is removed from all miscellaneous *
|
|
|
|
* tracking systems in the game. This operation is vital when deleting an object. It is *
|
|
|
|
* necessary so that when the object is removed from the game, existing game objects won't *
|
|
|
|
* be referencing a now invalid game object. This typically affects the targeting *
|
|
|
|
* and navigation computers of other game objects. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/24/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Detach_All(bool all)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Unselect this object if it was selected.
|
|
|
|
*/
|
|
|
|
//if (all || Owner() != PlayerPtr->Class->House) {
|
|
|
|
// Unselect();
|
|
|
|
//}
|
|
|
|
|
|
|
|
//Added some error handling incase there was an issue removing the object - JAS 6/28/2019
|
|
|
|
if (all) {
|
|
|
|
//Unselect();
|
|
|
|
// Updated to function for multiplayer - 6/28/2019 JAS
|
|
|
|
Unselect_All_Players();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Unselect_All_Players_Except_Owner();
|
|
|
|
}
|
|
|
|
//End of change - JAS 6/28/2019
|
|
|
|
|
|
|
|
Map.Detach(this);
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Remove from targeting computers.
|
|
|
|
*/
|
|
|
|
Detach_This_From_All(As_Target(), all);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Receive_Message -- Processes an incoming radio message. *
|
|
|
|
* *
|
|
|
|
* Any radio message received that applies to objects in general are handled by this *
|
|
|
|
* routine. Typically, this is the "redraw" message, which occurs when another object is *
|
|
|
|
* loading or unloading and thus overlapping. *
|
|
|
|
* *
|
|
|
|
* INPUT: message -- The message received. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the appropriate radio response. If the message was recognized, then *
|
|
|
|
* RADIO_ROGER is returned, otherwise, just RADIO_STATIC is returned. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 09/24/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
RadioMessageType ObjectClass::Receive_Message(RadioClass *, RadioMessageType message, long & )
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
switch (message) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
** This message serves as a rendering convenience. It lets the system
|
|
|
|
** know that there might be a visual conflict and the unit in radio
|
|
|
|
** contact should be redrawn. This typically occurs when a vehicle
|
|
|
|
** is being unloaded from a hover lander.
|
|
|
|
*/
|
|
|
|
case RADIO_REDRAW:
|
|
|
|
Mark(MARK_CHANGE);
|
|
|
|
return(RADIO_ROGER);
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return(RADIO_STATIC);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Take_Damage -- Applies damage to the object. *
|
|
|
|
* *
|
|
|
|
* This routine applies damage to the object according to the damage parameters. It handles *
|
|
|
|
* reducing the strength of the object and also returns the result of that damage. The *
|
|
|
|
* result value can be examined to determine if the object was destroyed, greatly damaged, *
|
|
|
|
* or other results. *
|
|
|
|
* *
|
|
|
|
* INPUT: damage -- Reference to the damage number to apply. This number will be adjusted *
|
|
|
|
* according to defensive armor and distance. Examine this value after *
|
|
|
|
* the call to determine the actual amount of damage applied. *
|
|
|
|
* *
|
|
|
|
* distance -- The distance (in leptons) from the center of the damage causing *
|
|
|
|
* explosion to the object itself. *
|
|
|
|
* *
|
|
|
|
* warhead -- The warhead type that is causing the damage. *
|
|
|
|
* *
|
|
|
|
* source -- The perpetrator of this damage. *
|
|
|
|
* *
|
|
|
|
* forced -- Is the damage forced upon the object regardless of whether it *
|
|
|
|
* is normally immune? *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns the ResultType that indicates what the affect of the damage was. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 11/29/1994 JLB : Created. *
|
|
|
|
* 12/27/1994 JLB : Trigger event processing for attacked or destroyed. *
|
|
|
|
* 01/01/1995 JLB : Reduces damage greatly depending on range. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
ResultType ObjectClass::Take_Damage(int & damage, int distance, WarheadType warhead, TechnoClass * source, bool forced)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
ResultType result = RESULT_NONE;
|
|
|
|
int oldstrength = Strength;
|
|
|
|
|
|
|
|
if (oldstrength && damage != 0 && (forced || !Class_Of().IsImmune)) {
|
|
|
|
int maxstrength = Class_Of().MaxStrength;
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Modify damage based on the warhead type and the armor of the object. This results
|
|
|
|
** in a reduced damage value, but never below 1 damage point. Unless
|
|
|
|
** it's forced damage, in which case we want full damage.
|
|
|
|
*/
|
|
|
|
if (!forced /*&& damage > 0*/) {
|
|
|
|
damage = Modify_Damage(damage, warhead, Class_Of().Armor, distance);
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Special hack to ensure that dogs only do damage to intended victim and no
|
|
|
|
** damage to others.
|
|
|
|
*/
|
|
|
|
if (source && source->What_Am_I() == RTTI_INFANTRY && ((InfantryClass *)source)->Class->IsDog) {
|
|
|
|
if (source->TarCom == As_Target()) {
|
|
|
|
damage = Strength;
|
|
|
|
} else {
|
|
|
|
damage = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (damage == 0) return(RESULT_NONE);
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Are we healing/repairing? If so, add strength, but in
|
|
|
|
** any case, return that no damage was done.
|
|
|
|
*/
|
|
|
|
if (damage < 0) {
|
|
|
|
#ifdef FIXIT_CSII // checked - ajw 9/28/98
|
|
|
|
if (What_Am_I() == RTTI_INFANTRY || What_Am_I() == RTTI_UNIT || What_Am_I() == RTTI_AIRCRAFT) {
|
|
|
|
#else
|
|
|
|
if (What_Am_I() == RTTI_INFANTRY) {
|
|
|
|
#endif
|
|
|
|
Clicked_As_Target(PlayerPtr->Class->House, 7); // 2019/09/20 JAS - Added record of who clicked on the object
|
|
|
|
Strength -= damage;
|
|
|
|
if (Strength > maxstrength) {
|
|
|
|
Strength = maxstrength;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(RESULT_NONE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** At this point, we KNOW that at least light damage has occurred.
|
|
|
|
*/
|
|
|
|
result = RESULT_LIGHT;
|
|
|
|
|
|
|
|
/*
|
|
|
|
** A non-fatal blow has occurred. Check to see if the object transitioned to below
|
|
|
|
** half strength or if it is now down to one hit point.
|
|
|
|
*/
|
|
|
|
if (oldstrength > damage) {
|
|
|
|
|
|
|
|
if (oldstrength >= (maxstrength >> 1) && (oldstrength-damage) < (maxstrength >> 1)) {
|
|
|
|
result = RESULT_HALF;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/*
|
|
|
|
** When an object is damaged to destruction, it will instead stop at one
|
|
|
|
** damage point. This will prolong the damage state as well as
|
|
|
|
** give greater satisfaction when it is finally destroyed.
|
|
|
|
*/
|
|
|
|
damage = oldstrength;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Apply the damage to the object.
|
|
|
|
*/
|
|
|
|
Strength = oldstrength - damage;
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Check to see if the object is majorly damaged or destroyed.
|
|
|
|
*/
|
|
|
|
switch (Strength) {
|
|
|
|
case 0:
|
|
|
|
Record_The_Kill(source);
|
|
|
|
result = RESULT_DESTROYED;
|
|
|
|
if (this->Is_Techno()) {
|
|
|
|
if (this == ::As_Object(((TechnoClass *)this)->House->UnitToTeleport)) ((TechnoClass *)this)->House->UnitToTeleport = 0;
|
|
|
|
}
|
|
|
|
Detach_All();
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
result = RESULT_MAJOR;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Handle any trigger event associated with this object.
|
|
|
|
*/
|
|
|
|
if (source && Trigger.Is_Valid() && result != RESULT_DESTROYED) {
|
|
|
|
Trigger->Spring(TEVENT_ATTACKED, this);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** If any damage was assessed and this object is selected, then flag
|
|
|
|
** the object to be redrawn so that the health bar will be updated.
|
|
|
|
*/
|
|
|
|
//if (result != RESULT_NONE && IsSelected) {
|
|
|
|
// Updated to function for multiplayer - 6/26/2019 JAS
|
|
|
|
if (result != RESULT_NONE && Is_Selected_By_Player()) {
|
|
|
|
Mark(MARK_CHANGE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Return with the result of the damage taken.
|
|
|
|
*/
|
|
|
|
return(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Mark -- Handles basic marking logic. *
|
|
|
|
* *
|
|
|
|
* This routine handles the base logic for marking an object up or down on the map. It *
|
|
|
|
* manages the IsDown flag as well as flagging the object to be redrawn if necessary. *
|
|
|
|
* Whenever an object is to be marked, it should call this base class function first. If *
|
|
|
|
* this function returns true, then the higher level function should proceed with its own *
|
|
|
|
* logic. *
|
|
|
|
* *
|
|
|
|
* INPUT: mark -- The marking method to use for this object. It can be either MARK_DOWN, *
|
|
|
|
* MARK_UP, or MARK_CHANGE. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: bool; Was the object marked successfully? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 01/23/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Mark(MarkType mark)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
if (!IsInLimbo && IsActive) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
** A mark for change is always successful UNLESS the object
|
|
|
|
** is not placed down or has already been flagged as changed
|
|
|
|
** this game frame.
|
|
|
|
*/
|
|
|
|
if (mark == MARK_CHANGE || mark == MARK_CHANGE_REDRAW) {
|
|
|
|
if (IsToDisplay && mark != MARK_CHANGE_REDRAW) return(false);
|
|
|
|
if (IsDown) {
|
|
|
|
Mark_For_Redraw();
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Handle adding or removing the object in the cells' overlap lists
|
|
|
|
*/
|
|
|
|
if (mark == MARK_OVERLAP_UP) {
|
|
|
|
if (IsDown == true) {
|
|
|
|
if (Class_Of().IsFootprint) {
|
|
|
|
Map.Overlap_Up(Coord_Cell(Coord), this);
|
|
|
|
}
|
|
|
|
Mark_For_Redraw();
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (mark == MARK_OVERLAP_DOWN) {
|
|
|
|
if (IsDown == true) {
|
|
|
|
if (Class_Of().IsFootprint) {
|
|
|
|
Map.Overlap_Down(Coord_Cell(Coord), this);
|
|
|
|
}
|
|
|
|
Mark_For_Redraw();
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** It is important to know whether the object is a techno class
|
|
|
|
** or not to see if we have to adjust the regional threat ratings
|
|
|
|
*/
|
|
|
|
int threat = 0;
|
|
|
|
HousesType house = HOUSE_NONE;
|
|
|
|
CELL cell = 0;
|
|
|
|
TechnoClass * tech;
|
|
|
|
if (Is_Techno()) {
|
|
|
|
tech = (TechnoClass *)this;
|
|
|
|
threat = tech->Risk();
|
|
|
|
house = tech->Owner();
|
|
|
|
cell = Coord_Cell(Coord);
|
|
|
|
} else {
|
|
|
|
tech = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Marking down is only successful if the object isn't already
|
|
|
|
** placed down.
|
|
|
|
*/
|
|
|
|
if (mark == MARK_DOWN && !IsDown) {
|
|
|
|
if (tech && Session.Type == GAME_NORMAL && In_Which_Layer() == LAYER_GROUND) {
|
|
|
|
Map[cell].Adjust_Threat(house, threat);
|
|
|
|
}
|
|
|
|
IsDown = true;
|
|
|
|
Mark_For_Redraw();
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Lifting up is only successful if the object isn't already
|
|
|
|
** lifted up from the map.
|
|
|
|
*/
|
|
|
|
if (mark == MARK_UP && IsDown) {
|
|
|
|
if (tech && Session.Type == GAME_NORMAL && In_Which_Layer() == LAYER_GROUND) {
|
|
|
|
Map[cell].Adjust_Threat(house, -threat);
|
|
|
|
}
|
|
|
|
if (Class_Of().IsFootprint) {
|
|
|
|
Map.Overlap_Up(Coord_Cell(Coord), this);
|
|
|
|
}
|
|
|
|
IsDown = false;
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Init -- Initializes the basic object system. *
|
|
|
|
* *
|
|
|
|
* This routine should be called when the basic object system needs to be initialized. This *
|
|
|
|
* occurs when the scenario is about to be loaded. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 01/23/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Init(void)
|
|
|
|
{
|
|
|
|
CurrentObject.Clear_All();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Revealed -- Reveals this object to the house specified. *
|
|
|
|
* *
|
|
|
|
* This routine is called when this object gets revealed to the house specified. *
|
|
|
|
* *
|
|
|
|
* INPUT: house -- Pointer to the house that this object is being revealed to. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Was this object revealed for the first time to this house? Generic objects always *
|
|
|
|
* return true unless an invalid house pointer was specified. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/19/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Revealed(HouseClass * house)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
return(house != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Set_Selected_By_Player -- Set this object as selected by the given player or *
|
|
|
|
* the default player. *
|
|
|
|
* *
|
|
|
|
* INPUT: Player pointer *
|
|
|
|
* *
|
|
|
|
* OUTPUT: *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 6/25/2019 - JAS *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Set_Selected_By_Player(HouseClass *player)
|
|
|
|
{
|
|
|
|
if (!player || !player->Class) {
|
|
|
|
player = PlayerPtr;
|
|
|
|
}
|
|
|
|
|
|
|
|
HousesType house = player->Class->House;
|
|
|
|
if (((TechnoTypeClass const &)Class_Of()).IsLeader) {
|
|
|
|
CurrentObject.Add_Head(house, this);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
CurrentObject.Add(house, this);
|
|
|
|
}
|
|
|
|
|
|
|
|
int shift = (int)house;
|
|
|
|
IsSelectedMask |= (1 << shift);
|
|
|
|
|
|
|
|
if (Session.Type == GAME_NORMAL && player == PlayerPtr) {
|
|
|
|
IsSelected = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Set_Unselected_By_Player -- Set this object as unselected by the given player *
|
|
|
|
* orthe default player. *
|
|
|
|
* *
|
|
|
|
* INPUT: Player pointer *
|
|
|
|
* *
|
|
|
|
* OUTPUT: *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 6/25/2019 - JAS *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectClass::Set_Unselected_By_Player(HouseClass *player)
|
|
|
|
{
|
|
|
|
if (!player || !player->Class) {
|
|
|
|
player = PlayerPtr;
|
|
|
|
}
|
|
|
|
|
|
|
|
HousesType house = player->Class->House;
|
|
|
|
CurrentObject.Delete(house, this);
|
|
|
|
|
|
|
|
int shift = (int)house;
|
|
|
|
IsSelectedMask &= ~(1 << shift);
|
|
|
|
|
|
|
|
if (Session.Type == GAME_NORMAL && player == PlayerPtr) {
|
|
|
|
IsSelected = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Is_Selected_By_Player -- Has this object been selected by the given player *
|
|
|
|
* *
|
|
|
|
* INPUT: Player pointer *
|
|
|
|
* *
|
|
|
|
* OUTPUT: True if selected by that player *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 6/25/2019 - JAS *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Is_Selected_By_Player(HouseClass *player) const
|
|
|
|
{
|
|
|
|
if (player && player->Class) {
|
|
|
|
int shift = (int)player->Class->House;
|
|
|
|
return (IsSelectedMask & (1 << shift)) ? true : false;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
int shift = (int)PlayerPtr->Class->House;
|
|
|
|
return (IsSelectedMask & (1 << shift)) ? true : false;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Paradrop -- Unlimbos object in paradrop mode. *
|
|
|
|
* *
|
|
|
|
* Call this routine as a replacement for Unlimbo() if the object is to be paradropped onto *
|
|
|
|
* the playing field. *
|
|
|
|
* *
|
|
|
|
* INPUT: coord -- The desired landing coordinate to give the dropping unit. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: bool; Was the object successfully unlimboed and has begun paradropping? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: The unit may not be successful in paradropping if the desired destination *
|
|
|
|
* location cannot be occupied by the object. *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 02/07/1996 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Paradrop(COORDINATE coord)
|
|
|
|
{
|
|
|
|
assert(this != 0);
|
|
|
|
assert(IsActive);
|
|
|
|
|
|
|
|
Height = FLIGHT_LEVEL;
|
|
|
|
IsFalling = true;
|
|
|
|
if (Unlimbo(coord, DIR_S)) {
|
|
|
|
AnimClass * anim = NULL;
|
|
|
|
|
|
|
|
if (What_Am_I() == RTTI_BULLET) {
|
|
|
|
anim = new AnimClass(ANIM_PARA_BOMB, Coord_Move(Center_Coord(), DIR_N, 0x0030 + Height));
|
|
|
|
} else {
|
|
|
|
anim = new AnimClass(ANIM_PARACHUTE, Coord_Move(Center_Coord(), DIR_N, 0x0030 + Height));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** If the animation was created, then attach it to this object.
|
|
|
|
*/
|
|
|
|
if (anim != NULL) {
|
|
|
|
anim->Attach_To(this);
|
|
|
|
}
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectClass::Attach_Trigger -- Attach specified trigger to object. *
|
|
|
|
* *
|
|
|
|
* This routine is used to attach the specified trigger to the object. *
|
|
|
|
* *
|
|
|
|
* INPUT: trigger -- Pointer to the trigger to attach. If any existing trigger is desired *
|
|
|
|
* to be detached, then pass NULL to this routine. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: bool; Was the trigger attached? *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 05/06/1996 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
bool ObjectClass::Attach_Trigger(TriggerClass * trigger)
|
|
|
|
{
|
|
|
|
if (Trigger.Is_Valid()) {
|
|
|
|
TriggerClass * tptr = Trigger;
|
|
|
|
tptr->AttachCount--;
|
|
|
|
Trigger = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (trigger) {
|
|
|
|
Trigger = trigger;
|
|
|
|
trigger->AttachCount++;
|
|
|
|
return(true);
|
|
|
|
}
|
|
|
|
return(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// These can't be made inline (for various reasons).
|
|
|
|
short const * ObjectClass::Occupy_List(bool placement) const {return(Class_Of().Occupy_List(placement));};
|
|
|
|
short const * ObjectClass::Overlap_List(bool ) const {return(Class_Of().Overlap_List());};
|
|
|
|
BuildingClass * ObjectClass::Who_Can_Build_Me(bool intheory, bool legal) const {return(Class_Of().Who_Can_Build_Me(intheory, legal, Owner()));};
|
|
|
|
fixed ObjectClass::Health_Ratio(void) const {return(fixed(Strength, Class_Of().MaxStrength));};
|
|
|
|
int ObjectClass::Full_Name(void) const {return Class_Of().Full_Name();};
|
|
|
|
|
|
|
|
|
|
|
|
//**********************************************************************************************
|
|
|
|
// MODULE SEPARATION -- ObjectTypeClass member functions follow.
|
|
|
|
//**********************************************************************************************
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::ObjectTypeClass -- Normal constructor for object type class objects. *
|
|
|
|
* *
|
|
|
|
* This is the base constructor that is used when constructing the object type classes. *
|
|
|
|
* Every tangible game piece type calls this constructor for the ObjectTypeClass. This *
|
|
|
|
* class holds static information that is common to objects in general. *
|
|
|
|
* *
|
|
|
|
* INPUT: see below... *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 03/23/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
ObjectTypeClass::ObjectTypeClass(
|
|
|
|
RTTIType rtti,
|
|
|
|
int id,
|
|
|
|
bool is_sentient,
|
|
|
|
bool is_stealthy,
|
|
|
|
bool is_selectable,
|
|
|
|
bool is_legal_target,
|
|
|
|
bool is_insignificant,
|
|
|
|
bool is_immune,
|
|
|
|
bool is_footprint,
|
|
|
|
int name,
|
|
|
|
char const * ini) :
|
|
|
|
AbstractTypeClass(rtti, id, name, ini),
|
|
|
|
IsCrushable(false),
|
|
|
|
IsStealthy(is_stealthy),
|
|
|
|
IsSelectable(is_selectable),
|
|
|
|
IsLegalTarget(is_legal_target),
|
|
|
|
IsInsignificant(is_insignificant),
|
|
|
|
IsImmune(is_immune),
|
|
|
|
IsSentient(is_sentient),
|
|
|
|
IsFootprint(is_footprint),
|
|
|
|
Armor(ARMOR_NONE),
|
|
|
|
MaxStrength(0),
|
|
|
|
ImageData(0),
|
|
|
|
RadarIcon(0)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
** Init the DimensionData rect. Not sure how this was ever working before without being allocated. It was just trashing
|
|
|
|
** memory later on when the pointer was being dereferenced and written to without being initialized. ST - 8/14/2019 3:15PM
|
|
|
|
*/
|
|
|
|
DimensionData = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::Max_Pips -- Fetches the maximum pips allowed for this object. *
|
|
|
|
* *
|
|
|
|
* This routine will return the maximum number of pips that can be displayed for this *
|
|
|
|
* object. When dealing with generic objects, this value is always zero. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the number of pip boxes (empty or otherwise) to display. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/19/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
int ObjectTypeClass::Max_Pips(void) const
|
|
|
|
{
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::Dimensions -- Gets the dimensions of the object in pixels. *
|
|
|
|
* *
|
|
|
|
* This routine will fetch the dimensions of this object expressed as pixels width and *
|
|
|
|
* pixels height. This information can be used to intelligently update the clipping *
|
|
|
|
* rectangles. *
|
|
|
|
* *
|
|
|
|
* INPUT: width -- Reference to the width variable that will be filled in. *
|
|
|
|
* *
|
|
|
|
* height -- Reference to the height variable that will be filled in. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/19/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectTypeClass::Dimensions(int &width, int &height) const
|
|
|
|
{
|
|
|
|
width = 10;
|
|
|
|
height = 10;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::Cost_Of -- Returns the cost to buy this unit. *
|
|
|
|
* *
|
|
|
|
* This routine will return the cost to purchase this unit. This routine is expected to be *
|
|
|
|
* overridden by the objects that can actually be purchased. All other object types can *
|
|
|
|
* simply return zero since this value won't be used. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns the cost of the object. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/19/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
int ObjectTypeClass::Cost_Of(void) const
|
|
|
|
{
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::Time_To_Build -- Fetches the time to construct this object. *
|
|
|
|
* *
|
|
|
|
* This routine will fetch the time in takes to construct this object. Objects that can *
|
|
|
|
* be constructed will override this routine in order to return a useful value. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with the time units (arbitrary) that it takes to construct this object. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/19/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
2020-06-22 17:43:21 +01:00
|
|
|
int ObjectTypeClass::Time_To_Build(HousesType ) const
|
2020-05-27 20:16:20 +01:00
|
|
|
{
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::Get_Cameo_Data -- Fetches pointer to cameo data for this object type. *
|
|
|
|
* *
|
|
|
|
* This routine will return with the cameo data pointer for this object type. It is *
|
|
|
|
* expected that objects that can appear on the sidebar will override this routine in order *
|
|
|
|
* to provide proper cameo data pointer. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with a pointer to the cameo shape data. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/19/1995 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void const * ObjectTypeClass::Get_Cameo_Data(void) const
|
|
|
|
{
|
|
|
|
return(NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::Occupy_List -- Returns with simple occupation list for object. *
|
|
|
|
* *
|
|
|
|
* This routine returns a pointer to a simple occupation list for this object. Since at *
|
|
|
|
* this tier of the object class chain, the exact shape of the object is indeterminate, *
|
|
|
|
* this function merely returns a single cell occupation list. This actually works for *
|
|
|
|
* most vehicles. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns a pointer to a simple occupation list. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 05/28/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
short const * ObjectTypeClass::Occupy_List(bool) const
|
|
|
|
{
|
|
|
|
static short const _list[] = {0, REFRESH_EOL};
|
|
|
|
return(_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::Overlap_List -- Returns a pointer to a simple overlap list. *
|
|
|
|
* *
|
|
|
|
* This function returns a pointer to an overlap list for the object. An overlap list is *
|
|
|
|
* the offsets from the object's cell to get the cells the imagery overlaps, but is object *
|
|
|
|
* is not considered to occupy. Since at this stage, the overlap information is not *
|
|
|
|
* available, this function merely returns a pointer to an empty list. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns a pointer to the generic overlap list. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 05/28/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
short const * ObjectTypeClass::Overlap_List(void) const
|
|
|
|
{
|
|
|
|
static short const _list[] = {REFRESH_EOL};
|
|
|
|
return(_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::One_Time -- Handles one time processing for object types. *
|
|
|
|
* *
|
|
|
|
* This routine is used to handle the once per game processing required for object types. *
|
|
|
|
* This consists of loading any data and initializing any data tables the game requires. *
|
|
|
|
* *
|
|
|
|
* INPUT: none *
|
|
|
|
* *
|
|
|
|
* OUTPUT: none *
|
|
|
|
* *
|
|
|
|
* WARNINGS: This routine goes to disk. *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 11/01/1994 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
void ObjectTypeClass::One_Time(void)
|
|
|
|
{
|
|
|
|
SelectShapes = MFCD::Retrieve("SELECT.SHP");
|
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
RawFileClass file("PIPS.SHP");
|
|
|
|
if (file.Is_Available()) {
|
|
|
|
PipShapes = Load_Alloc_Data(file);
|
|
|
|
} else {
|
|
|
|
PipShapes = MFCD::Retrieve("PIPS.SHP");
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
PipShapes = MFCD::Retrieve("PIPS.SHP");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************************************
|
|
|
|
* ObjectTypeClass::Who_Can_Build_Me -- Determine what building can build this object type. *
|
|
|
|
* *
|
|
|
|
* This routine will scan through all available factory buildings and determine which *
|
|
|
|
* is capable of building this object type. The scan can be controlled to scan for only *
|
|
|
|
* factory buildings that are free to produce now or those that could produce this *
|
|
|
|
* object type if conditions permit. *
|
|
|
|
* *
|
|
|
|
* INPUT: intheory -- Should the general (when conditions permit) case be examined to see *
|
|
|
|
* if a building could build this object type "in theory" even though it *
|
|
|
|
* might currently be otherwise occupied? *
|
|
|
|
* *
|
|
|
|
* legal -- Check for building prerequisite and technology level rules? Usually *
|
|
|
|
* this would be 'true' for human controlled requests and 'false' for *
|
|
|
|
* the computer. This is because the computer is usually not under *
|
|
|
|
* the normal restrictions that the player is under. *
|
|
|
|
* *
|
|
|
|
* OUTPUT: Returns with a pointer to the building that can produce the object of this *
|
|
|
|
* type. If no suitable factory building could be found, then NULL is returned. *
|
|
|
|
* *
|
|
|
|
* WARNINGS: none *
|
|
|
|
* *
|
|
|
|
* HISTORY: *
|
|
|
|
* 07/29/1996 JLB : Created. *
|
|
|
|
*=============================================================================================*/
|
|
|
|
BuildingClass * ObjectTypeClass::Who_Can_Build_Me(bool intheory, bool legal, HousesType house) const
|
|
|
|
{
|
|
|
|
BuildingClass * anybuilding = NULL;
|
|
|
|
|
|
|
|
if (!intheory && What_Am_I() == RTTI_AIRCRAFTTYPE && ((AircraftTypeClass*)this)->IsFixedWing) {
|
|
|
|
int num_builders = 0, num_fixed_wings = 0;
|
|
|
|
for (int index = 0; index < Buildings.Count(); index++) {
|
|
|
|
BuildingClass * building = Buildings.Ptr(index);
|
|
|
|
assert(building != NULL);
|
|
|
|
|
|
|
|
if ( !building->IsInLimbo &&
|
|
|
|
building->House->Class->House == house &&
|
|
|
|
building->Class->ToBuild == RTTI &&
|
|
|
|
building->Mission != MISSION_DECONSTRUCTION && building->MissionQueue != MISSION_DECONSTRUCTION &&
|
|
|
|
((1L << building->ActLike) & Get_Ownable()) &&
|
|
|
|
(!legal || building->House->Can_Build(this, building->ActLike))) {
|
|
|
|
num_builders++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (int index = 0; index < Aircraft.Count(); index++) {
|
|
|
|
AircraftClass * aircraft = Aircraft.Ptr(index);
|
|
|
|
assert(aircraft != NULL);
|
|
|
|
|
|
|
|
if ( !aircraft->IsInLimbo &&
|
|
|
|
aircraft->House->Class->House == house &&
|
|
|
|
aircraft->Class->IsFixedWing) {
|
|
|
|
num_fixed_wings++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (num_fixed_wings >= num_builders) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int index = 0; index < Buildings.Count(); index++) {
|
|
|
|
BuildingClass * building = Buildings.Ptr(index);
|
|
|
|
assert(building != NULL);
|
|
|
|
|
|
|
|
if ( !building->IsInLimbo &&
|
|
|
|
building->House->Class->House == house &&
|
|
|
|
building->Class->ToBuild == RTTI &&
|
|
|
|
building->Mission != MISSION_DECONSTRUCTION && building->MissionQueue != MISSION_DECONSTRUCTION &&
|
|
|
|
((1L << building->ActLike) & Get_Ownable()) &&
|
|
|
|
(!legal || building->House->Can_Build(this, building->ActLike)) &&
|
|
|
|
(intheory || !building->In_Radio_Contact())) {
|
|
|
|
|
|
|
|
// BG: Hack so only kennels can build dogs, and no other, and barracks can
|
|
|
|
// only build humans and no other.
|
|
|
|
if (What_Am_I() == RTTI_INFANTRYTYPE) {
|
|
|
|
InfantryTypeClass * me = (InfantryTypeClass *)this;
|
|
|
|
if (me->IsDog) {
|
|
|
|
if (*building == STRUCT_KENNEL) {
|
|
|
|
if (building->IsLeader) return(building);
|
|
|
|
anybuilding = building;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (*building != STRUCT_KENNEL) {
|
|
|
|
if (building->IsLeader) return(building);
|
|
|
|
anybuilding = building;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/*
|
|
|
|
** HACK ALERT: Helipads can build aircraft and airstrips can build
|
|
|
|
** fixed wing craft only.
|
|
|
|
*/
|
|
|
|
if (What_Am_I() == RTTI_AIRCRAFTTYPE) {
|
|
|
|
AircraftTypeClass * air = (AircraftTypeClass *)this;
|
|
|
|
if ((*building == STRUCT_HELIPAD && !air->IsFixedWing) || (*building == STRUCT_AIRSTRIP && air->IsFixedWing)) {
|
|
|
|
if (building->IsLeader) return(building);
|
|
|
|
anybuilding = building;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
if (building->IsLeader) return(building);
|
|
|
|
anybuilding = building;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(anybuilding);
|
|
|
|
}
|