Paranoia2/dlls/ammodesc.cpp

/*
ammodesc.cpp - virtual generic ammo that not needs to be hardcoded
Copyright (C) 2014 Uncle Mike

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.
*/

#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "player.h"
#include "monsters.h"
#include "weapons.h"
#include "nodes.h"
#include "soundent.h"
#include "decals.h"
#include "gamerules.h"

extern int gEvilImpulse101;

AmmoInfo CBasePlayerAmmo :: AmmoInfoArray[MAX_AMMO_SLOTS];
AmmoDesc CBasePlayerAmmo :: AmmoDescArray[MAX_AMMO_DESC];
int giAmmoIndex = 0;
int giAmmoEnts = 0;

// Precaches the ammo and queues the ammo info for sending to clients
void AddAmmoNameToAmmoRegistry( const char *szAmmoname )
{
	// make sure it's not already in the registry
	for( int i = 1; i < MAX_AMMO_SLOTS; i++ )
	{
		if( !CBasePlayerAmmo :: AmmoInfoArray[i].pszName )
			continue;

		if( !Q_stricmp( CBasePlayerAmmo :: AmmoInfoArray[i].pszName, szAmmoname ))
			return; // ammo already in registry, just quite
	}

	if( giAmmoIndex >= MAX_AMMO_SLOTS )
	{
		ALERT( at_error, "Too many ammo types. ammotype %s was ignored\n", szAmmoname );
		return;
	}

	CBasePlayerAmmo :: AmmoInfoArray[giAmmoIndex].pszName = szAmmoname;
	CBasePlayerAmmo :: AmmoInfoArray[giAmmoIndex].iId = giAmmoIndex;   // yes, this info is redundant
	giAmmoIndex++;
}

void AddAmmoNameToAmmoRegistry( const AmmoInfo *pInfo )
{
	if( !pInfo || !pInfo->pszName || !*pInfo->pszName )
		return; // bad name specified

	// make sure it's not already in the registry
	for( int i = 1; i < MAX_AMMO_SLOTS; i++ )
	{
		if( !CBasePlayerAmmo :: AmmoInfoArray[i].pszName )
			continue;

		if( !Q_stricmp( CBasePlayerAmmo :: AmmoInfoArray[i].pszName, pInfo->pszName ))
		{
			ALERT( at_warning, "AmmoInfo: duplicate info for ammotype %s was ignored\n", pInfo->pszName );
			return; // ammo already in registry
		}
	}

	if( giAmmoIndex >= MAX_AMMO_SLOTS )
	{
		ALERT( at_error, "Too many ammo types. ammotype %s was ignored\n", pInfo->pszName );
		return;
	}

	CBasePlayerAmmo :: AmmoInfoArray[giAmmoIndex] = *pInfo;
	CBasePlayerAmmo :: AmmoInfoArray[giAmmoIndex].iId = giAmmoIndex;   // yes, this info is redundant
	giAmmoIndex++;
}

AmmoInfo *UTIL_FindAmmoType( const char *szAmmoname )
{
	if( !szAmmoname || !*szAmmoname )
	{
		ALERT( at_error, "FindAmmoType: NULL type\n" );
		return NULL; // bad name specified
          }

	if( !Q_stricmp( szAmmoname, "none" ))
		return NULL; // no ammo specified

	for( int i = 1; i < MAX_AMMO_SLOTS; i++ )
	{
		if( !CBasePlayerAmmo :: AmmoInfoArray[i].pszName )
			continue;

		if( !Q_stricmp( CBasePlayerAmmo :: AmmoInfoArray[i].pszName, szAmmoname ))
			return &CBasePlayerAmmo :: AmmoInfoArray[i];
	}

	ALERT( at_error, "FindAmmoType: coudn't find ammo type '%s'\n", szAmmoname );

	return NULL;
}

AmmoDesc *UTIL_FindAmmoDesc( const char *szClassname )
{
	if( !szClassname || !*szClassname )
	{
		ALERT( at_error, "FindAmmoDesc: NULL classname\n" );
		return NULL; // bad classname specified
          }

	for( int i = 0; i < giAmmoEnts; i++ )
	{
		if( !CBasePlayerAmmo :: AmmoDescArray[i].classname )
			continue;

		if( !Q_stricmp( STRING( CBasePlayerAmmo :: AmmoDescArray[i].classname ), szClassname ))
			return &CBasePlayerAmmo :: AmmoDescArray[i];
	}

	ALERT( at_error, "FindAmmoDesc: coudn't find entity '%s'\n", szClassname );

	return NULL;
}

void AddAmmoEntityToArray( const AmmoDesc *pDesc )
{
	if( !pDesc || !pDesc->classname || !pDesc->type )
		return; // bad name specified or type not found

	if( giAmmoEnts >= MAX_AMMO_DESC )
	{
		ALERT( at_error, "Too many ammo entities specified. %s was ignored\n", STRING( pDesc->classname ));
		return;
	}

	// make sure it's not already in the registry
	for( int i = 0; i < giAmmoEnts; i++ )
	{
		if( !Q_stricmp( STRING( CBasePlayerAmmo :: AmmoDescArray[i].classname ), STRING( pDesc->classname )))
		{
			ALERT( at_warning, "AmmoDesc: duplicate info for %s was ignored\n", STRING( pDesc->classname ));
			return; // ammo already in registry
		}
	}

	// add new entry
	CBasePlayerAmmo :: AmmoDescArray[giAmmoEnts] = *pDesc;
	giAmmoEnts++;
}

void UTIL_ParseAmmoInfo( char *&pfile )
{
	AmmoInfo tmpInfo;
	char token[256];
	int section = 0;

	memset( &tmpInfo, 0, sizeof( AmmoInfo ));

	// apply default params
	tmpInfo.iMaxCarry = 255;
	tmpInfo.flDistance = 8192.0f;
	tmpInfo.iNumShots = 1;

	while( pfile != NULL )
	{
		pfile = COM_ParseFile( pfile, token );

		if( !Q_stricmp( token, "{" ))
			section++;
		else if( !Q_stricmp( token, "}" ))
		{
			section--;
			break;
		}
		else if( section > 0 )
		{
			if( !Q_stricmp( token, "name" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpInfo.pszName = STRING( ALLOC_STRING( token )); // zone memory
			}
			else if( !Q_stricmp( token, "MaxCarry" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpInfo.iMaxCarry = bound( 1, Q_atoi( token ), 255 ); // a byte limit
			}
			else if( !Q_stricmp( token, "ShellModel" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpInfo.iShellIndex = PRECACHE_MODEL( token ); // shell model
			}
			else if( !Q_stricmp( token, "Damage" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpInfo.flPlayerDamage = tmpInfo.flMonsterDamage = Q_atof( token ); // healing damage is allowed
			}
			else if( !Q_stricmp( token, "PlayerDamage" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpInfo.flPlayerDamage = Q_atof( token ); // healing damage is allowed
			}
			else if( !Q_stricmp( token, "MonsterDamage" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpInfo.flMonsterDamage = Q_atof( token ); // healing damage is allowed
			}
			else if( !Q_stricmp( token, "NumShots" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpInfo.iNumShots = bound( 1, Q_atoi( token ), 32 ); // shots per one shot
			}
			else if( !Q_stricmp( token, "Distance" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpInfo.flDistance = bound( 64.0f, Q_atof( token ), 32768.0f ); // shots per one shot
			}
			else if( !Q_stricmp( token, "Missile" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpInfo.iMissileClassName = ALLOC_STRING( token );
				UTIL_PrecacheOther( token );
			}
		}
	}

	if( section ) ALERT( at_warning, "invalid braced sections %i in ammodescripton\n", section );
	else AddAmmoNameToAmmoRegistry( &tmpInfo );
}

void UTIL_ParseAmmoEntity( char *&pfile, const char *classname )
{
	AmmoDesc tmpDesc;
	char token[256];
	int section = 0;

	memset( &tmpDesc, 0, sizeof( AmmoDesc ));

	tmpDesc.classname = ALLOC_STRING( classname );

	while( pfile != NULL )
	{
		pfile = COM_ParseFile( pfile, token );

		if( !Q_stricmp( token, "{" ))
			section++;
		else if( !Q_stricmp( token, "}" ))
		{
			section--;
			break;
		}
		else if( section > 0 )
		{
			if( !Q_stricmp( token, "model" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpDesc.ammomodel = ALLOC_STRING( token );
				PRECACHE_MODEL( STRING( tmpDesc.ammomodel ));
			}
			else if( !Q_stricmp( token, "sound" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpDesc.clipsound = ALLOC_STRING( token );
				PRECACHE_SOUND( STRING( tmpDesc.clipsound ));
			}
			else if( !Q_stricmp( token, "type" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpDesc.type = UTIL_FindAmmoType( token );
			}
			else if( !Q_stricmp( token, "count" ))
			{
				pfile = COM_ParseFile( pfile, token );
				tmpDesc.count = RandomRange( token );
			}
		}
	}

	if( section ) ALERT( at_warning, "invalid braced sections %i in %s\n", section, classname );
	else AddAmmoEntityToArray( &tmpDesc );
}

void UTIL_InitAmmoDescription( const char *filename )
{
	char *afile = (char *)LOAD_FILE( filename, NULL );

	giAmmoIndex = 1;
	giAmmoEnts = 0;

	if( !afile )
	{
 		ALERT( at_error, "ammo description file %s not found!\n", filename );
		return;
	}

	char *pfile = afile;
	char token[256];

	// parse all the ammoinfos
	while( pfile != NULL )
	{
		pfile = COM_ParseFile( pfile, token );

		if( !Q_stricmp( token, "ammoinfo" ))
			UTIL_ParseAmmoInfo( pfile );
		else pfile = COM_SkipBracedSection( pfile );
	}

	pfile = afile; // reset pointer

	// parse ammo_ virtual entities
	while( pfile != NULL )
	{
		pfile = COM_ParseFile( pfile, token );

		if( Q_stricmp( token, "ammoinfo" ))
			UTIL_ParseAmmoEntity( pfile, token );
		else pfile = COM_SkipBracedSection( pfile );
	}

	FREE_FILE( afile );
}

// ====================== AMMO_GENERIC ================================

LINK_ENTITY_TO_CLASS( ammo_generic, CBasePlayerAmmo );

// Wargon: SaveData для юзабельности патронов.
TYPEDESCRIPTION CBasePlayerAmmo::m_SaveData[] = 
{
	DEFINE_FIELD( CBasePlayerAmmo, m_bCustomAmmo, FIELD_BOOLEAN ),
	DEFINE_FIELD( CBasePlayerAmmo, m_iAmmoCaps, FIELD_INTEGER ),
	DEFINE_FIELD( CBasePlayerAmmo, m_rAmmoCount, FIELD_RANGE ),
	DEFINE_FIELD( CBasePlayerAmmo, m_iAmmoType, FIELD_STRING ),
}; IMPLEMENT_SAVERESTORE( CBasePlayerAmmo, CBaseEntity );

void CBasePlayerAmmo :: Precache( void )
{
	if( IsGenericAmmo() && !pev->model )
	{
		if( !InitGenericAmmo( ))
			return;
	}

	PRECACHE_MODEL( STRING( pev->model ));
	PRECACHE_SOUND( STRING( pev->noise ));
}

void CBasePlayerAmmo :: KeyValue( KeyValueData *pkvd )
{
	if( FStrEq( pkvd->szKeyName, "count" ))
	{
		m_rAmmoCount = RandomRange( pkvd->szValue );
		pkvd->fHandled = TRUE;
	}
	else CBaseEntity :: KeyValue( pkvd );
}

BOOL CBasePlayerAmmo :: InitGenericAmmo( void )
{
	// two way to create this - manually fill field 'netname' or just to create virtual entity
	if( IsGenericAmmo( ))
	{
		// find description of virtual entity
		AmmoDesc *pDesc = UTIL_FindAmmoDesc( STRING( pev->netname ));		

		if( !pDesc )
		{
			REMOVE_ENTITY( edict( ));
			return FALSE; // description is missed
		}

		// copy the description into entity struct
		m_iAmmoType = ALLOC_STRING( pDesc->type->pszName );
		pev->model = pDesc->ammomodel;
		pev->noise = pDesc->clipsound;

		// level-designer specified ammocount for current entity
		if( !m_rAmmoCount.IsDefined( ))
			m_rAmmoCount = pDesc->count;
		m_bCustomAmmo = TRUE;

		return TRUE;
	}
	return FALSE; // not a generic
}

void CBasePlayerAmmo :: Spawn( void )
{
	if( IsGenericAmmo( ))
	{
		// try to initialize virtual entity
		if( !InitGenericAmmo( ))
			return;
		Precache();
		SET_MODEL(ENT(pev), STRING( pev->model ));
	}

	pev->movetype = MOVETYPE_TOSS;
	pev->solid = SOLID_TRIGGER;
	UTIL_SetSize( pev, Vector( -16, -16, 0 ), Vector( 16, 16, 16 ));
	UTIL_SetOrigin( this, pev->origin );

	if( !FBitSet( ObjectCaps(), FCAP_USE_ONLY ) || FBitSet( pev->spawnflags, SF_NORESPAWN ))
		SetTouch( &CBasePlayerAmmo:: DefaultTouch );

	// Wargon: Патроны юзабельны.
	SetUse( &CBasePlayerAmmo :: DefaultUse );
	m_iAmmoCaps = CBaseEntity::ObjectCaps() | FCAP_IMPULSE_USE;
}

BOOL CBasePlayerAmmo :: AddAmmo( CBaseEntity *pOther ) 
{ 
	if( pOther->GiveAmmo( m_rAmmoCount.Random(), STRING( m_iAmmoType )) != -1 )
	{
		EMIT_SOUND( ENT(pev), CHAN_ITEM, STRING( pev->noise ), 1, ATTN_NORM );
		return TRUE;
	}

	return FALSE;
}

CBaseEntity *CBasePlayerAmmo :: Respawn( void )
{
	SetBits( pev->effects, EF_NODRAW );
	SetTouch( NULL );

	// Wargon: Патроны неюзабельны.
	SetUse( NULL );
	m_iAmmoCaps = CBaseEntity::ObjectCaps();

	// move to wherever I'm supposed to respawn.
	UTIL_SetOrigin( this, g_pGameRules->VecAmmoRespawnSpot( this ));

	SetThink( &CBasePlayerAmmo:: Materialize );
	AbsoluteNextThink( g_pGameRules->FlAmmoRespawnTime( this ));

	return this;
}

void CBasePlayerAmmo :: Materialize( void )
{
	if( FBitSet( pev->effects, EF_NODRAW ))
	{
		// changing from invisible state to visible.
		EMIT_SOUND_DYN( ENT( pev ), CHAN_WEAPON, "items/suitchargeok1.wav", 1, ATTN_NORM, 0, 150 );
		pev->effects &= ~EF_NODRAW;
		pev->effects |= EF_MUZZLEFLASH;
	}

	if( !FBitSet( ObjectCaps(), FCAP_USE_ONLY ))
		SetTouch( &CBasePlayerAmmo:: DefaultTouch );

	// Wargon: Патроны юзабельны.
	SetUse( &CBasePlayerAmmo :: DefaultUse );
	m_iAmmoCaps = CBaseEntity :: ObjectCaps() | FCAP_IMPULSE_USE;
}

void CBasePlayerAmmo :: DefaultTouch( CBaseEntity *pOther )
{
	if( !pOther->IsPlayer( ))
	{
		return;
	}

	if( AddAmmo( pOther ))
	{
		if( g_pGameRules->AmmoShouldRespawn( this ) == GR_AMMO_RESPAWN_YES )
		{
			Respawn();
		}
		else
		{
			SetTouch( NULL );

			// Wargon: Патроны неюзабельны.
			SetUse( NULL );
			m_iAmmoCaps = CBaseEntity :: ObjectCaps();
			SetThink( &CBasePlayerAmmo :: SUB_Remove );
			SetNextThink( 0.1 );
		}
	}
	else if( gEvilImpulse101 )
	{
		// evil impulse 101 hack, kill always
		SetTouch( NULL );

		// Wargon: Патроны неюзабельны.
		SetUse( NULL );
		m_iAmmoCaps = CBaseEntity :: ObjectCaps();

		SetThink( &CBasePlayerAmmo :: SUB_Remove );
		SetNextThink( 0.1 );
	}
}