294 lines
7.7 KiB
C++
294 lines
7.7 KiB
C++
|
/*
|
||
|
** Command & Conquer Renegade(tm)
|
||
|
** Copyright 2025 Electronic Arts Inc.
|
||
|
**
|
||
|
** This program is free software: you can redistribute it and/or modify
|
||
|
** it under the terms of the GNU General Public License as published by
|
||
|
** the Free Software Foundation, either version 3 of the License, or
|
||
|
** (at your option) any later version.
|
||
|
**
|
||
|
** This program is distributed in the hope that it will be useful,
|
||
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
** GNU General Public License for more details.
|
||
|
**
|
||
|
** You should have received a copy of the GNU General Public License
|
||
|
** along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
*/
|
||
|
|
||
|
/***********************************************************************************************
|
||
|
*** Confidential - Westwood Studios ***
|
||
|
***********************************************************************************************
|
||
|
* *
|
||
|
* Project Name : Commando *
|
||
|
* *
|
||
|
* $Archive:: /Commando/Code/Combat/cover.cpp $*
|
||
|
* *
|
||
|
* $Author:: Byon_g $*
|
||
|
* *
|
||
|
* $Modtime:: 4/17/01 11:44a $*
|
||
|
* *
|
||
|
* $Revision:: 7 $*
|
||
|
* *
|
||
|
*---------------------------------------------------------------------------------------------*
|
||
|
* Functions: *
|
||
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
||
|
|
||
|
#include "cover.h"
|
||
|
#include "debug.h"
|
||
|
#include "chunkio.h"
|
||
|
#include "saveload.h"
|
||
|
#include "crandom.h"
|
||
|
|
||
|
/*
|
||
|
**
|
||
|
*/
|
||
|
DynamicVectorClass<CoverEntryClass *> CoverManager::CoverPositions;
|
||
|
|
||
|
/*
|
||
|
**
|
||
|
*/
|
||
|
void CoverManager::Init( void )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
void CoverManager::Shutdown( void )
|
||
|
{
|
||
|
Remove_All();
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
**
|
||
|
*/
|
||
|
enum {
|
||
|
CHUNKID_COVER_ENTRY = 524001203,
|
||
|
};
|
||
|
|
||
|
bool CoverManager::Save( ChunkSaveClass & csave )
|
||
|
{
|
||
|
for ( int index = 0; index < CoverPositions.Count(); index++ ) {
|
||
|
csave.Begin_Chunk( CHUNKID_COVER_ENTRY );
|
||
|
CoverPositions[index]->Save( csave );
|
||
|
csave.End_Chunk();
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool CoverManager::Load( ChunkLoadClass & cload )
|
||
|
{
|
||
|
WWASSERT( CoverPositions.Count() == 0 );
|
||
|
|
||
|
while (cload.Open_Chunk()) {
|
||
|
switch(cload.Cur_Chunk_ID()) {
|
||
|
|
||
|
case CHUNKID_COVER_ENTRY:
|
||
|
{
|
||
|
CoverEntryClass * cover = NEW_REF( CoverEntryClass, () );
|
||
|
cover->Load( cload );
|
||
|
Add_Entry( cover );
|
||
|
cover->Release_Ref();
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
default:
|
||
|
Debug_Say(( "Unrecognized CombatSaveLoad chunkID\n" ));
|
||
|
break;
|
||
|
|
||
|
}
|
||
|
cload.Close_Chunk();
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*
|
||
|
**
|
||
|
*/
|
||
|
void CoverManager::Add_Entry( CoverEntryClass * entry )
|
||
|
{
|
||
|
if ( entry != NULL ) {
|
||
|
entry->Add_Ref();
|
||
|
CoverPositions.Add( entry );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CoverManager::Remove_Entry( CoverEntryClass * entry )
|
||
|
{
|
||
|
if ( entry != NULL ) {
|
||
|
CoverPositions.Delete( entry );
|
||
|
entry->Release_Ref();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void CoverManager::Remove_All( void )
|
||
|
{
|
||
|
while ( CoverPositions.Count() ) {
|
||
|
CoverPositions[0]->Release_Ref();
|
||
|
CoverPositions.Delete( 0 );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
**
|
||
|
*/
|
||
|
CoverEntryClass * CoverManager::Request_Cover( const Vector3 & cur_pos, const Vector3 & danger, float max_dist )
|
||
|
{
|
||
|
// Find a cover spot, not in use, within max_dist, that blocks from danger
|
||
|
int best_index = -1;
|
||
|
int best_dist = max_dist;
|
||
|
for ( int index = 0; index < CoverPositions.Count(); index++ ) {
|
||
|
CoverEntryClass * cover = CoverPositions[ index ];
|
||
|
if ( cover->Get_In_Use() ) {
|
||
|
continue; // Already in use
|
||
|
}
|
||
|
Vector3 range_vector = cur_pos - cover->Get_Transform().Get_Translation();
|
||
|
float dist = range_vector.Length();
|
||
|
if ( dist > max_dist ) {
|
||
|
continue; // Too far away
|
||
|
}
|
||
|
|
||
|
if ( !Is_Cover_Safe( cover, danger ) ) {
|
||
|
continue; // Does not provide cover
|
||
|
}
|
||
|
|
||
|
if ( best_dist < dist ) {
|
||
|
continue; // Already ahave a better one
|
||
|
}
|
||
|
|
||
|
if ( best_index != -1 ) {
|
||
|
if ( FreeRandom.Get_Int() & 1 ) {
|
||
|
continue;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
best_index = index;
|
||
|
best_dist = dist;
|
||
|
}
|
||
|
|
||
|
if ( best_index != -1 ) {
|
||
|
// Debug_Say(( "Chose cover # %d\n", best_index ));
|
||
|
CoverPositions[ best_index ]->Set_In_Use( true );
|
||
|
return CoverPositions[best_index];
|
||
|
}
|
||
|
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
void CoverManager::Release_Cover( CoverEntryClass * entry )
|
||
|
{
|
||
|
WWASSERT( entry->Get_In_Use() );
|
||
|
entry->Set_In_Use( false );
|
||
|
}
|
||
|
|
||
|
bool CoverManager::Is_Cover_Safe( CoverEntryClass * cover, const Vector3 & danger )
|
||
|
{
|
||
|
WWASSERT( cover );
|
||
|
|
||
|
Vector3 danger_local;
|
||
|
Matrix3D::Inverse_Transform_Vector( cover->Get_Transform(), danger, &danger_local );
|
||
|
if ( danger_local.X < WWMath::Fabs(danger_local.Y) ) {
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
**
|
||
|
*/
|
||
|
enum {
|
||
|
CHUNKID_VARIABLES = 524001323,
|
||
|
|
||
|
MICROCHUNKID_TRANSFORM = 1,
|
||
|
MICROCHUNKID_CROUCH,
|
||
|
MICROCHUNKID_IN_USE,
|
||
|
MICROCHUNKID_ATTACK_POSITION,
|
||
|
MICROCHUNKID_REMAP_PTR,
|
||
|
};
|
||
|
|
||
|
bool CoverEntryClass::Save( ChunkSaveClass & csave )
|
||
|
{
|
||
|
CoverEntryClass * me = this;
|
||
|
|
||
|
csave.Begin_Chunk( CHUNKID_VARIABLES );
|
||
|
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_TRANSFORM, Transform );
|
||
|
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_CROUCH, Crouch );
|
||
|
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_IN_USE, InUse );
|
||
|
for ( int i = 0; i < AttackPositionList.Count(); i++ ) {
|
||
|
Vector3 pos = AttackPositionList[i];
|
||
|
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_ATTACK_POSITION, pos );
|
||
|
}
|
||
|
WRITE_MICRO_CHUNK( csave, MICROCHUNKID_REMAP_PTR, me );
|
||
|
csave.End_Chunk();
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool CoverEntryClass::Load( ChunkLoadClass & cload )
|
||
|
{
|
||
|
WWASSERT( AttackPositionList.Count() == 0 );
|
||
|
|
||
|
CoverEntryClass * old_me = NULL;
|
||
|
|
||
|
while (cload.Open_Chunk()) {
|
||
|
switch(cload.Cur_Chunk_ID()) {
|
||
|
|
||
|
case CHUNKID_VARIABLES:
|
||
|
while (cload.Open_Micro_Chunk()) {
|
||
|
switch(cload.Cur_Micro_Chunk_ID()) {
|
||
|
|
||
|
READ_MICRO_CHUNK( cload, MICROCHUNKID_TRANSFORM, Transform );
|
||
|
READ_MICRO_CHUNK( cload, MICROCHUNKID_CROUCH, Crouch );
|
||
|
READ_MICRO_CHUNK( cload, MICROCHUNKID_IN_USE, InUse );
|
||
|
|
||
|
case MICROCHUNKID_ATTACK_POSITION:
|
||
|
{
|
||
|
Vector3 pos;
|
||
|
cload.Read(&pos,sizeof(pos));
|
||
|
AttackPositionList.Add( pos );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
READ_MICRO_CHUNK( cload, MICROCHUNKID_REMAP_PTR, old_me );
|
||
|
|
||
|
default:
|
||
|
Debug_Say(( "Unrecognized CoverEntry Variable chunkID %d\n", cload.Cur_Micro_Chunk_ID() ));
|
||
|
break;
|
||
|
|
||
|
}
|
||
|
cload.Close_Micro_Chunk();
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
Debug_Say(( "Unrecognized CoverEntry chunkID\n" ));
|
||
|
break;
|
||
|
|
||
|
}
|
||
|
cload.Close_Chunk();
|
||
|
}
|
||
|
|
||
|
// publish my remap pair
|
||
|
WWASSERT(old_me != NULL);
|
||
|
if (old_me != NULL) {
|
||
|
SaveLoadSystemClass::Register_Pointer( old_me, this );
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
Vector3 CoverEntryClass::Get_Attack_Position( Vector3 & enemy_pos )
|
||
|
{
|
||
|
// Find a cover position that will allow attack of enemy_pos (not yet)
|
||
|
|
||
|
// default to cover spot
|
||
|
Vector3 pos = Transform.Get_Translation();
|
||
|
|
||
|
if ( AttackPositionList.Count() ) {
|
||
|
int index = FreeRandom.Get_Int( AttackPositionList.Count() );
|
||
|
pos = AttackPositionList[index];
|
||
|
}
|
||
|
|
||
|
return pos;
|
||
|
}
|