NS/releases/3.05/source/mod/AvHMine.cpp

//======== (C) Copyright 2002 Charles G. Cleveland All rights reserved. =========
//
// The copyright to the contents herein is the property of Charles G. Cleveland.
// The contents may be used and/or copied only with the written permission of
// Charles G. Cleveland, or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//
// Purpose: This is the weapon that marines use to deploy mines (not the mines themselves)
//
// $Workfile: AvHMine.cpp $
// $Date: 2002/10/25 21:48:21 $
//
//-------------------------------------------------------------------------------
// $Log: AvHMine.cpp,v $
// Revision 1.10  2002/10/25 21:48:21  Flayra
// - Fixe for wrong player model when holding mines
//
// Revision 1.9  2002/10/16 20:53:09  Flayra
// - Removed weapon upgrade sounds
//
// Revision 1.8  2002/10/16 01:01:58  Flayra
// - Fixed mines being resupplied from armory
//
// Revision 1.7  2002/10/03 18:46:17  Flayra
// - Added heavy view model
//
// Revision 1.6  2002/07/24 19:09:17  Flayra
// - Linux issues
//
// Revision 1.5  2002/07/24 18:55:52  Flayra
// - Linux case sensitivity stuff
//
// Revision 1.4  2002/07/24 18:45:42  Flayra
// - Linux and scripting changes
//
// Revision 1.3  2002/06/25 17:47:14  Flayra
// - Fixed mine, refactored for new disabled/enabled state
//
// Revision 1.2  2002/06/03 16:37:31  Flayra
// - Constants and tweaks to make weapon anims and times correct with new artwork, added different deploy times (this should be refactored a bit more)
//
// Revision 1.1  2002/05/23 02:33:42  Flayra
// - Post-crash checkin.  Restored @Backup from around 4/16.  Contains changes for last four weeks of development.
//
//===============================================================================
#include "mod/AvHMarineWeapons.h"
#include "mod/AvHPlayer.h"

#ifdef AVH_CLIENT
#include "cl_dll/eventscripts.h"
#include "cl_dll/in_defs.h"
#include "cl_dll/wrect.h"
#include "cl_dll/cl_dll.h"
#endif

#include "common/hldm.h"
#include "common/event_api.h"
#include "common/event_args.h"
#include "common/vector_util.h"
#include "mod/AvHMarineWeapons.h"
#include "mod/AvHMarineEquipmentConstants.h"

#ifdef AVH_SERVER
#include "mod/AvHGamerules.h"
#include "mod/AvHMarineEquipment.h"
#include "mod/AvHSharedUtil.h"
#include "mod/AvHServerUtil.h"
#endif

LINK_ENTITY_TO_CLASS(kwMine, AvHMine);

void AvHMine::DeductCostForShot(void)
{
	AvHBasePlayerWeapon::DeductCostForShot();

	//this->m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]--;

	//if(this->m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
	if(!this->m_iClip)
	{
		// no more mines! 
		RetireWeapon();
	}

}

bool AvHMine::GetCanBeResupplied() const
{
    return false;
}

int	AvHMine::GetDeployAnimation() const
{
	return 2;
}

char* AvHMine::GetHeavyViewModel() const
{
	return kTripmineHVVModel;
}

char* AvHMine::GetPlayerModel() const
{
	return kTripminePModel;
}

char* AvHMine::GetWorldModel() const
{
	return kTripmineWModel;
}

char* AvHMine::GetViewModel() const
{
	return kTripmineVModel;
}

int	AvHMine::GetShootAnimation() const
{
	// Return deploy animation for now, this should play fire animation, then a little later, play the deploy animation
	return 2;
}

void AvHMine::Holster(int skiplocal)
{
	if(!this->m_iClip)
	{
		// Out of mines
		SetThink(&AvHMine::DestroyItem);
		this->pev->nextthink = gpGlobals->time + 0.1;
	}

	AvHMarineWeapon::Holster(skiplocal);
}

void AvHMine::Init()
{
	this->mRange = kMineRange;
	this->mDamage = 0; // What to do here?  Is it taking damage from CGrenade?
}

bool AvHMine::ProcessValidAttack(void)
{
	bool theSuccess = AvHMarineWeapon::ProcessValidAttack();

    // This test is not necessary since the new collision code makes it so
    // that interpenetrating objects are not a problem.

    /*
    if(theSuccess)
	{
		#ifdef AVH_SERVER
		theSuccess = false;
		
		Vector theDropLocation;
		Vector theDropAngles;
		if(this->GetDropLocation(theDropLocation, &theDropAngles))
		{
			Vector theMineMinSize = Vector (kMineMinSize);
			Vector theMineMaxSize = Vector (kMineMaxSize);

			// TODO: Rotate extents by theDropAngles, to test bounding box extents as the mine would be placed

			if(AvHSHUGetIsAreaFree(theDropLocation, theMineMinSize, theMineMaxSize))
			{
				theSuccess = true;
			}
		}
		#endif
	}
    */
#ifdef AVH_SERVER

    if(theSuccess)
    {

    	Vector theMineOrigin;
    	Vector theMineAngles;
        
        theSuccess = this->GetDropLocation(theMineOrigin, &theMineAngles);

    }

#endif

	return theSuccess;
}

#ifdef AVH_SERVER
bool AvHMine::GetDropLocation(Vector& outLocation, Vector* outAngles) const
{
	bool theSuccess = false;

	UTIL_MakeVectors( m_pPlayer->pev->v_angle + m_pPlayer->pev->punchangle );
	Vector vecSrc	 = m_pPlayer->GetGunPosition( );
	Vector vecAiming = gpGlobals->v_forward;
	
	TraceResult tr;
	
	UTIL_TraceLine( vecSrc, vecSrc + vecAiming*this->mRange, dont_ignore_monsters, ENT( m_pPlayer->pev ), &tr );

	if (tr.flFraction < 1.0)
	{
		CBaseEntity* theEntity = CBaseEntity::Instance( tr.pHit );
		
        if (!dynamic_cast<AvHDeployedMine*>(theEntity))
        {
    
            int kOffset = 8;
            Vector thePotentialOrigin = tr.vecEndPos + tr.vecPlaneNormal * kOffset;

		    BaseEntityListType theEntityList;
		    theEntityList.push_back(theEntity);

		    // Make sure there isn't an entity nearby that this would block
		    theEntity = NULL;
		    const int kMineSearchRadius = 15;
		    while((theEntity = UTIL_FindEntityInSphere(theEntity, thePotentialOrigin, kMineSearchRadius)) != NULL)
		    {
			    theEntityList.push_back(theEntity);
		    }
		    
		    // For the mine placement to be valid, the entity it hit, and all the entities nearby must be valid and non-blocking
		    theSuccess = true;
		    for(BaseEntityListType::iterator theIter = theEntityList.begin(); theIter != theEntityList.end(); theIter++)
		    {
			    CBaseEntity* theCurrentEntity = *theIter;
			    if(!theCurrentEntity || (theCurrentEntity->pev->flags & FL_CONVEYOR) || AvHSUGetIsExternalClassName(STRING(theCurrentEntity->pev->classname)) || dynamic_cast<CBaseDoor*>(theCurrentEntity) || dynamic_cast<CRotDoor*>(theCurrentEntity))
			    {
				    theSuccess = false;
				    break;
			    }
		    }

		    if(theSuccess)
		    {
			    VectorCopy(thePotentialOrigin, outLocation);
			    if(outAngles)
			    {
				    VectorCopy(UTIL_VecToAngles( tr.vecPlaneNormal ), *outAngles)
			    }
		    }

        }

	}

	return theSuccess;
}
#endif

void AvHMine::FireProjectiles(void)
{
#ifdef AVH_SERVER
	Vector theMineOrigin;
	Vector theMineAngles;
	if(this->GetDropLocation(theMineOrigin, &theMineAngles))
	{
		GetGameRules()->MarkDramaticEvent(kMinePlacePriority, this->m_pPlayer);

		AvHDeployedMine* theMine = dynamic_cast<AvHDeployedMine*>(CBaseEntity::Create( kwsDeployedMine, theMineOrigin, theMineAngles, m_pPlayer->edict() ));
		ASSERT(theMine);

		// Set the team so it doesn't blow us up, remember the owner so proper credit can be given
		theMine->pev->team = m_pPlayer->pev->team;
		//theMine->pev->owner = m_pPlayer->edict();
		theMine->SetPlacer(this->m_pPlayer->pev);

		// Set it as a marine item so it gets damage upgrades
        // Set any team-wide upgrades
        AvHTeam* theTeam = GetGameRules()->GetTeam(AvHTeamNumber(m_pPlayer->pev->team));
        ASSERT(theTeam);
        theMine->pev->iuser4 |= theTeam->GetTeamWideUpgrades();
	}
#endif
}

int	AvHMine::GetBarrelLength() const
{
	return kMineBarrellLength;
}

float AvHMine::GetRateOfFire() const
{
    return kMineROF;
}

bool AvHMine::GetFiresUnderwater() const
{
	return true;
}

BOOL AvHMine::PlayEmptySound()
{
	// None
	return 0;
}

void AvHMine::Precache()
{
	AvHMarineWeapon::Precache();

	UTIL_PrecacheOther(kwsDeployedMine);

	this->mEvent = PRECACHE_EVENT(1, kWeaponAnimationEvent);
}

bool AvHMine::Resupply()
{
 	return false;
}

void AvHMine::Spawn() 
{ 
	this->Precache();
	
    AvHMarineWeapon::Spawn(); 

	this->m_iId = AVH_WEAPON_MINE;
	
    // Set our class name
	this->pev->classname = MAKE_STRING(kwsMine);

	SET_MODEL(ENT(pev), kTripmineW2Model);

	FallInit();// get ready to fall down.

    int theNumMines = BALANCE_IVAR(kMineMaxAmmo);
    
    #ifdef AVH_SERVER
    if(GetGameRules()->GetIsCombatMode())
    {
        theNumMines = BALANCE_IVAR(kMineMaxAmmoCombat);
    }
    #endif

	this->m_iDefaultAmmo = theNumMines;
} 


bool AvHMine::UsesAmmo(void) const
{
	return true;
}

BOOL AvHMine::UseDecrement(void)
{
	return true;
}