mirror of
https://github.com/unknownworlds/NS.git
synced 2024-12-11 05:10:56 +00:00
ad7db200f6
git-svn-id: https://unknownworlds.svn.cloudforge.com/ns1@280 67975925-1194-0748-b3d5-c16f83f1a3a1
706 lines
24 KiB
C++
706 lines
24 KiB
C++
#include "types.h"
|
|
#include "mod/AvHPlayer.h"
|
|
#include "mod/AvHPlayerUpgrade.h"
|
|
#include "mod/AvHServerUtil.h"
|
|
#include "mod/AvHGamerules.h"
|
|
#include "mod/AvHMarineEquipment.h"
|
|
#include "mod/AvHSharedUtil.h"
|
|
|
|
extern int gLevelUpEventID;
|
|
|
|
bool AvHPlayer::GiveCombatModeUpgrade(AvHMessageID inMessageID, bool inInstantaneous)
|
|
{
|
|
bool theSuccess = false;
|
|
bool theEffectivePlayerClassChanged = false;
|
|
|
|
// Process every upgrade here
|
|
AvHUser3 theUser3 = (AvHUser3)this->pev->iuser3;
|
|
int thePlayerLevel = this->GetExperienceLevel();
|
|
float theHealthPercentage = this->pev->health/AvHPlayerUpgrade::GetMaxHealth(this->pev->iuser4, theUser3, thePlayerLevel);
|
|
float theArmorPercentage = this->pev->armorvalue/AvHPlayerUpgrade::GetMaxArmorLevel(this->pev->iuser4, theUser3);
|
|
bool thePreserveHealthArmorPercentage = true;
|
|
CBasePlayerItem* theCreatedItem = NULL;
|
|
|
|
// Marine upgrades
|
|
if(this->GetIsMarine())
|
|
{
|
|
Vector thePlayerMinSize, thePlayerMaxSize;
|
|
this->GetSize(thePlayerMinSize, thePlayerMaxSize);
|
|
|
|
Vector thePlayersFeet = this->pev->origin;
|
|
thePlayersFeet.z += thePlayerMinSize.z;
|
|
|
|
switch(inMessageID)
|
|
{
|
|
case BUILD_SHOTGUN:
|
|
case BUILD_GRENADE_GUN:
|
|
case BUILD_HMG:
|
|
case BUILD_WELDER:
|
|
case BUILD_MINES:
|
|
case BUILD_JETPACK:
|
|
case BUILD_HEAVY:
|
|
//voogru: spawn the weapon in the middle of nowhere to prevent anyone else from getting it.
|
|
theCreatedItem = dynamic_cast<CBasePlayerItem*>(AvHSUBuildTechForPlayer(inMessageID, Vector(9999,9999,9999), this));
|
|
|
|
ASSERT(theCreatedItem);
|
|
|
|
if((inMessageID == BUILD_JETPACK) || (inMessageID == BUILD_HEAVY))
|
|
{
|
|
theEffectivePlayerClassChanged = true;
|
|
}
|
|
|
|
theSuccess = true;
|
|
break;
|
|
|
|
case BUILD_SCAN:
|
|
AvHSUBuildTechForPlayer(inMessageID, thePlayersFeet, this);
|
|
theSuccess = true;
|
|
break;
|
|
|
|
// case RESEARCH_DISTRESSBEACON:
|
|
// AvHSUResearchStarted(this, inMessageID);
|
|
// AvHSUResearchComplete(this, inMessageID);
|
|
// theSuccess = true;
|
|
// break;
|
|
|
|
// Give upgrades
|
|
case RESEARCH_ARMOR_ONE:
|
|
this->GiveTeamUpgrade(RESEARCH_ARMOR_ONE);
|
|
theSuccess = true;
|
|
break;
|
|
|
|
case RESEARCH_ARMOR_TWO:
|
|
this->GiveTeamUpgrade(RESEARCH_ARMOR_ONE);
|
|
this->GiveTeamUpgrade(RESEARCH_ARMOR_TWO);
|
|
theSuccess = true;
|
|
break;
|
|
|
|
case RESEARCH_ARMOR_THREE:
|
|
this->GiveTeamUpgrade(RESEARCH_ARMOR_ONE);
|
|
this->GiveTeamUpgrade(RESEARCH_ARMOR_TWO);
|
|
this->GiveTeamUpgrade(RESEARCH_ARMOR_THREE);
|
|
theSuccess = true;
|
|
break;
|
|
|
|
case RESEARCH_WEAPONS_ONE:
|
|
this->GiveTeamUpgrade(RESEARCH_WEAPONS_ONE);
|
|
theSuccess = true;
|
|
break;
|
|
|
|
case RESEARCH_WEAPONS_TWO:
|
|
this->GiveTeamUpgrade(RESEARCH_WEAPONS_ONE);
|
|
this->GiveTeamUpgrade(RESEARCH_WEAPONS_TWO);
|
|
theSuccess = true;
|
|
break;
|
|
|
|
case RESEARCH_WEAPONS_THREE:
|
|
this->GiveTeamUpgrade(RESEARCH_WEAPONS_ONE);
|
|
this->GiveTeamUpgrade(RESEARCH_WEAPONS_TWO);
|
|
this->GiveTeamUpgrade(RESEARCH_WEAPONS_THREE);
|
|
theSuccess = true;
|
|
break;
|
|
|
|
case RESEARCH_GRENADES:
|
|
this->GiveNamedItem(kwsGrenade);
|
|
// NOTE: Fall through below
|
|
|
|
case RESEARCH_MOTIONTRACK:
|
|
this->GiveTeamUpgrade(inMessageID);
|
|
theSuccess = true;
|
|
break;
|
|
|
|
//case BUILD_AMMO:
|
|
//case BUILD_HEALTH:
|
|
case BUILD_RESUPPLY:
|
|
// Find all friendly players nearby (right now this just resupplies current player)
|
|
// Give them health and ammo, equal to # of current level
|
|
AvHSUResupplyFriendliesInRange(1, this);
|
|
thePreserveHealthArmorPercentage = false;
|
|
theSuccess = true;
|
|
|
|
// Add new tech node to allow us to buy it again
|
|
//AvHTechNode theTechNode(BUILD_RESUPPLY, TECH_FOUR_LEVEL_TWO, TECH_FOUR_LEVEL_TWO, TECH_NULL, 0, 0, true);
|
|
//this->mCombatNodes.AddTechNode(theTechNode);
|
|
break;
|
|
|
|
case BUILD_CAT:
|
|
// Don't give out cat-packs every time
|
|
AvHCatalyst::GiveCatalyst(this);
|
|
theSuccess = true;
|
|
break;
|
|
}
|
|
}
|
|
else if(this->GetIsAlien())
|
|
{
|
|
theSuccess = this->ExecuteAlienMorphMessage(inMessageID, inInstantaneous);
|
|
thePreserveHealthArmorPercentage = false;
|
|
}
|
|
|
|
if(thePreserveHealthArmorPercentage)
|
|
{
|
|
this->pev->health = theHealthPercentage*AvHPlayerUpgrade::GetMaxHealth(this->pev->iuser4, theUser3, thePlayerLevel);
|
|
this->pev->armorvalue = theArmorPercentage*AvHPlayerUpgrade::GetMaxArmorLevel(this->pev->iuser4, theUser3);
|
|
}
|
|
|
|
if(theEffectivePlayerClassChanged)
|
|
{
|
|
this->EffectivePlayerClassChanged();
|
|
}
|
|
|
|
return theSuccess;
|
|
}
|
|
|
|
float AvHPlayer::GetExperience() const
|
|
{
|
|
return this->mExperience;
|
|
}
|
|
|
|
int AvHPlayer::GetExperienceLevelsSpent() const
|
|
{
|
|
return this->mExperienceLevelsSpent;
|
|
}
|
|
|
|
void AvHPlayer::SetExperienceLevelsSpent(int inSpentLevels)
|
|
{
|
|
this->mExperienceLevelsSpent = inSpentLevels;
|
|
}
|
|
|
|
void AvHPlayer::AwardExperienceForObjective(float inHealthChange, AvHMessageID inMessageID)
|
|
{
|
|
bool theAwardExperience = false;
|
|
|
|
if(GetGameRules()->GetIsCombatMode())
|
|
{
|
|
switch(inMessageID)
|
|
{
|
|
case ALIEN_BUILD_HIVE:
|
|
case BUILD_COMMANDSTATION:
|
|
theAwardExperience = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(theAwardExperience)
|
|
{
|
|
int theMaxHealth = GetGameRules()->GetBaseHealthForMessageID(inMessageID);
|
|
float thePercentageOfHealth = inHealthChange/theMaxHealth;
|
|
int theCombatObjectiveExperienceScalar = BALANCE_VAR(kCombatObjectiveExperienceScalar);
|
|
float theExperienceGained = thePercentageOfHealth*theCombatObjectiveExperienceScalar;
|
|
this->SetExperience(this->GetExperience() + theExperienceGained);
|
|
}
|
|
}
|
|
|
|
void AvHPlayer::SetExperience(float inExperience)
|
|
{
|
|
if(GetGameRules()->GetIsCombatMode())
|
|
{
|
|
int theCurrentLevel = AvHPlayerUpgrade::GetPlayerLevel(this->GetExperience());
|
|
|
|
this->mExperience = inExperience;
|
|
|
|
// Update server player data in case we get disconnected
|
|
AvHTeam* theTeam = this->GetTeamPointer();
|
|
if(theTeam)
|
|
{
|
|
AvHServerPlayerData* theServerPlayerData = this->GetServerPlayerData();
|
|
if(theServerPlayerData)
|
|
{
|
|
theServerPlayerData->SetExperience(this->mExperience);
|
|
}
|
|
}
|
|
|
|
int theNewLevel = AvHPlayerUpgrade::GetPlayerLevel(this->GetExperience());
|
|
|
|
if(theCurrentLevel != theNewLevel)
|
|
{
|
|
int theIsMarine = this->GetIsMarine();
|
|
PLAYBACK_EVENT_FULL(0, this->edict(), gLevelUpEventID, 0, this->pev->origin, (float *)&g_vecZero, 0.0, 0.0, theIsMarine, 0, 0, 0 );
|
|
|
|
// Give player health and armor back on level-up, to allow more soloing, heroics, and reduce dependence on hives/resupply
|
|
AvHUser3 theUser3 = AvHUser3(this->pev->iuser3);
|
|
float theMaxHealth = AvHPlayerUpgrade::GetMaxHealth(this->pev->iuser4, theUser3, theCurrentLevel);
|
|
float theHealthPercentage = this->pev->health/theMaxHealth;
|
|
|
|
float theLevelUpHealthPercentage = BALANCE_VAR(kCombatLevelupHealthIncreasePercent)/100.0f;
|
|
theHealthPercentage = min(theHealthPercentage + theLevelUpHealthPercentage, 1.0f);
|
|
this->pev->health = theHealthPercentage*theMaxHealth;
|
|
|
|
float theMaxArmor = AvHPlayerUpgrade::GetMaxArmorLevel(this->pev->iuser4, theUser3);
|
|
float theArmorPercentage = this->pev->armorvalue/theMaxArmor;
|
|
|
|
float theLevelUpArmorPercentage = BALANCE_VAR(kCombatLevelupArmorIncreasePercent)/100.0f;
|
|
theArmorPercentage = min(theArmorPercentage + theLevelUpArmorPercentage, 1.0f);
|
|
this->pev->armorvalue = theArmorPercentage*theMaxArmor;
|
|
|
|
// Unlock tiers as player levels up
|
|
// if(theNewLevel >= 4)
|
|
// {
|
|
// this->mCombatNodes.SetResearchDone(COMBAT_TIER2_UNLOCK);
|
|
// }
|
|
// if(theNewLevel >= 7)
|
|
// {
|
|
// this->mCombatNodes.SetResearchDone(COMBAT_TIER3_UNLOCK);
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
|
|
int AvHPlayer::GetExperienceLevel() const
|
|
{
|
|
int theLevel = 1;
|
|
|
|
if(GetGameRules()->GetIsCombatMode())
|
|
{
|
|
theLevel = AvHPlayerUpgrade::GetPlayerLevel(this->GetExperience());
|
|
}
|
|
|
|
return theLevel;
|
|
}
|
|
|
|
AvHTechTree& AvHPlayer::GetCombatNodes()
|
|
{
|
|
return this->mCombatNodes;
|
|
}
|
|
|
|
MessageIDListType& AvHPlayer::GetPurchasedCombatUpgrades()
|
|
{
|
|
return this->mPurchasedCombatUpgrades;
|
|
}
|
|
|
|
void AvHPlayer::SetCombatNodes(const AvHTechTree& inTechNodes)
|
|
{
|
|
this->mCombatNodes = inTechNodes;
|
|
}
|
|
|
|
void AvHPlayer::GiveCombatUpgradesOnSpawn()
|
|
{
|
|
// Save off previously-spent upgrades and respend them
|
|
MessageIDListType theUpgrades = this->mGiveCombatUpgrades;
|
|
|
|
// Need to run through these in order
|
|
for(MessageIDListType::iterator theIter = theUpgrades.begin(); theIter != theUpgrades.end(); theIter++)
|
|
{
|
|
AvHMessageID theCurrentCombatUpgrade = *theIter;
|
|
if(theCurrentCombatUpgrade != MESSAGE_NULL)
|
|
{
|
|
this->GiveCombatModeUpgrade(theCurrentCombatUpgrade, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
void AvHPlayer::PurchaseCombatUpgrade(AvHMessageID inMessageID)
|
|
{
|
|
this->mPurchasedCombatUpgrades.push_back(inMessageID);
|
|
//this->mExperienceLevelsSpent++;
|
|
|
|
// Remove any upgrades that this prempts
|
|
bool theOneShot = false;
|
|
switch(inMessageID)
|
|
{
|
|
case BUILD_AMMO:
|
|
case BUILD_HEALTH:
|
|
case BUILD_RESUPPLY:
|
|
case BUILD_CAT:
|
|
case BUILD_SCAN:
|
|
//case BUILD_MINES:
|
|
//case RESEARCH_DISTRESSBEACON:
|
|
theOneShot = true;
|
|
break;
|
|
}
|
|
|
|
// Don't add it as a permanent upgrade to get every time we spawn
|
|
if(!theOneShot)
|
|
{
|
|
this->mGiveCombatUpgrades.push_back(inMessageID);
|
|
}
|
|
|
|
this->RemoveCombatUpgradesPremptedBy(inMessageID);
|
|
}
|
|
|
|
void AvHPlayer::RemoveCombatUpgrade(AvHMessageID inMessageID)
|
|
{
|
|
MessageIDListType::iterator theIter = std::find(this->mGiveCombatUpgrades.begin(), this->mGiveCombatUpgrades.end(), inMessageID);
|
|
if(theIter != this->mGiveCombatUpgrades.end())
|
|
{
|
|
this->mGiveCombatUpgrades.erase(theIter);
|
|
|
|
// Take away the upgrade
|
|
this->GiveTeamUpgrade(inMessageID, false);
|
|
}
|
|
}
|
|
|
|
void AvHPlayer::RemoveCombatUpgradesPremptedBy(AvHMessageID inMessageID)
|
|
{
|
|
switch(inMessageID)
|
|
{
|
|
case BUILD_JETPACK:
|
|
this->RemoveCombatUpgrade(BUILD_HEAVY);
|
|
break;
|
|
case BUILD_HEAVY:
|
|
this->RemoveCombatUpgrade(BUILD_JETPACK);
|
|
break;
|
|
case BUILD_HMG:
|
|
this->RemoveCombatUpgrade(BUILD_SHOTGUN);
|
|
this->RemoveCombatUpgrade(BUILD_GRENADE_GUN);
|
|
break;
|
|
case BUILD_GRENADE_GUN:
|
|
this->RemoveCombatUpgrade(BUILD_SHOTGUN);
|
|
this->RemoveCombatUpgrade(BUILD_HMG);
|
|
break;
|
|
case ALIEN_LIFEFORM_TWO:
|
|
this->RemoveCombatUpgrade(ALIEN_LIFEFORM_ONE);
|
|
break;
|
|
case ALIEN_LIFEFORM_THREE:
|
|
this->RemoveCombatUpgrade(ALIEN_LIFEFORM_TWO);
|
|
break;
|
|
case ALIEN_LIFEFORM_FOUR:
|
|
this->RemoveCombatUpgrade(ALIEN_LIFEFORM_THREE);
|
|
break;
|
|
case ALIEN_LIFEFORM_FIVE:
|
|
this->RemoveCombatUpgrade(ALIEN_LIFEFORM_FOUR);
|
|
break;
|
|
|
|
//case BUILD_WELDER
|
|
// this->RemoveCombatUpgrade(BUILD_MINES);
|
|
// break;
|
|
//case BUILD_MINES:
|
|
// this->RemoveCombatUpgrade(BUILD_WELDER);
|
|
// break;
|
|
}
|
|
}
|
|
|
|
void AvHPlayer::ProcessCombatDeath()
|
|
{
|
|
// Unspend lifeform (return to skulk, but get the levels spent on lifeform back)
|
|
if(this->GetIsAlien())
|
|
{
|
|
AvHMessageID theLifeformID = MESSAGE_NULL;
|
|
AvHUser3 theUser3 = this->GetUser3(false);
|
|
if(theUser3 == AVH_USER3_ALIEN_EMBRYO)
|
|
{
|
|
// Use the last lifeform we were, unless we're evolving into a new one (assumes only one lifeform change per life)
|
|
theUser3 = this->GetPreviousUser3(false);
|
|
switch(this->mEvolution)
|
|
{
|
|
case ALIEN_LIFEFORM_TWO:
|
|
theUser3 = AVH_USER3_ALIEN_PLAYER2;
|
|
break;
|
|
case ALIEN_LIFEFORM_THREE:
|
|
theUser3 = AVH_USER3_ALIEN_PLAYER3;
|
|
break;
|
|
case ALIEN_LIFEFORM_FOUR:
|
|
theUser3 = AVH_USER3_ALIEN_PLAYER4;
|
|
break;
|
|
case ALIEN_LIFEFORM_FIVE:
|
|
theUser3 = AVH_USER3_ALIEN_PLAYER5;
|
|
break;
|
|
}
|
|
}
|
|
|
|
AvHSHUUser3ToMessageID(theUser3, theLifeformID);
|
|
ASSERT(theLifeformID != MESSAGE_NULL);
|
|
|
|
int theLifeformCost = GetGameRules()->GetCostForMessageID(theLifeformID);
|
|
this->SetExperienceLevelsSpent(this->GetExperienceLevelsSpent() - theLifeformCost);
|
|
|
|
this->RemoveCombatUpgrade(theLifeformID);
|
|
|
|
// Make all lifeforms chooseable again
|
|
this->SetLifeformCombatNodesAvailable(true);
|
|
}
|
|
}
|
|
|
|
void AvHPlayer::SetLifeformCombatNodesAvailable(bool inAvailable)
|
|
{
|
|
MessageIDListType theLifeformList;
|
|
theLifeformList.push_back(ALIEN_LIFEFORM_ONE);
|
|
theLifeformList.push_back(ALIEN_LIFEFORM_TWO);
|
|
theLifeformList.push_back(ALIEN_LIFEFORM_THREE);
|
|
theLifeformList.push_back(ALIEN_LIFEFORM_FOUR);
|
|
theLifeformList.push_back(ALIEN_LIFEFORM_FIVE);
|
|
|
|
for(MessageIDListType::iterator theIter = theLifeformList.begin(); theIter != theLifeformList.end(); theIter++)
|
|
{
|
|
AvHMessageID theLifeformID = *theIter;
|
|
this->mCombatNodes.SetIsResearchable(theLifeformID, inAvailable);
|
|
this->mCombatNodes.SetResearchDone(theLifeformID, !inAvailable);
|
|
}
|
|
}
|
|
|
|
bool AvHPlayer::ExecuteCombatMessage(AvHMessageID inMessageID, bool& outIsAvailable, bool inForce)
|
|
{
|
|
bool theMessageExecuted = false;
|
|
|
|
// Only explicitly deny messages in the tech tree, let the others fall back to NS-mode handling
|
|
if(this->mCombatNodes.GetIsMessageInTechTree(inMessageID))
|
|
{
|
|
if(this->mCombatNodes.GetIsMessageAvailable(inMessageID) || inForce)
|
|
{
|
|
if(this->GiveCombatModeUpgrade(inMessageID))
|
|
{
|
|
theMessageExecuted = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Explicitly deny
|
|
outIsAvailable = false;
|
|
}
|
|
}
|
|
|
|
return theMessageExecuted;
|
|
}
|
|
|
|
bool AvHPlayer::GetHasCombatModeUpgrade(AvHMessageID inMessageID) const
|
|
{
|
|
bool theHasUpgrade = false;
|
|
|
|
MessageIDListType::const_iterator theIter = std::find(this->mPurchasedCombatUpgrades.begin(), this->mPurchasedCombatUpgrades.end(), inMessageID);
|
|
if(theIter != this->mPurchasedCombatUpgrades.end())
|
|
{
|
|
theHasUpgrade = true;
|
|
}
|
|
|
|
return theHasUpgrade;
|
|
}
|
|
|
|
void AvHPlayer::InternalCombatThink()
|
|
{
|
|
// Only update every so often
|
|
if(GetGameRules()->GetIsCombatMode())
|
|
{
|
|
// Save our data in case we get kicked off
|
|
AvHServerPlayerData* theServerPlayerData = this->GetServerPlayerData();
|
|
if(theServerPlayerData)
|
|
{
|
|
theServerPlayerData->SetCombatNodes(this->mCombatNodes);
|
|
theServerPlayerData->SetPurchasedCombatUpgrades(this->mPurchasedCombatUpgrades);
|
|
theServerPlayerData->SetExperienceLevelsSpent(this->mExperienceLevelsSpent);
|
|
}
|
|
|
|
// If it's time for an update
|
|
float theCurrentTime = gpGlobals->time;
|
|
const float theCombatThinkInterval = BALANCE_VAR(kCombatThinkInterval);
|
|
|
|
// Give support from a fake commander
|
|
if(this->GetIsMarine() && this->GetIsRelevant() && !this->GetIsBeingDigested())
|
|
{
|
|
if(this->mTimeOfLastCombatThink == 0 || (theCurrentTime > (this->mTimeOfLastCombatThink + theCombatThinkInterval)))
|
|
{
|
|
// Only allow one upgrade per think
|
|
bool theSuccess = false;
|
|
|
|
// Does player have resupply upgrade?
|
|
if(this->GetHasCombatModeUpgrade(BUILD_RESUPPLY))
|
|
{
|
|
// Do they need it?
|
|
float theHealthPercentage = this->pev->health/AvHPlayerUpgrade::GetMaxHealth(this->pev->iuser4, (AvHUser3)this->pev->iuser3, this->GetExperienceLevel());
|
|
// float theAmmoPercentage = this->GetCurrentWeaponAmmoPercentage(); // changed to fix #542
|
|
bool theAmmoResupply = this->GetShouldResupplyAmmo();
|
|
|
|
if((theHealthPercentage < BALANCE_VAR(kCombatResupplyHealthPercentage)) || theAmmoResupply) //(theAmmoPercentage < BALANCE_VAR(kCombatResupplyAmmoPercentage)))
|
|
{
|
|
// Resupply player
|
|
this->GiveCombatModeUpgrade(BUILD_RESUPPLY);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
|
|
// Does player have resupply upgrade?
|
|
if(this->GetHasCombatModeUpgrade(BUILD_CAT))
|
|
{
|
|
// Catalyst player after he gets a kill
|
|
if(this->pev->frags > this->mSavedCombatFrags)
|
|
{
|
|
//if(RANDOM_LONG(0, 1) == 0)
|
|
//{
|
|
AvHCatalyst::GiveCatalyst(this);
|
|
theSuccess = true;
|
|
//}
|
|
}
|
|
}
|
|
this->mSavedCombatFrags = this->pev->frags;
|
|
|
|
// Does player have scan upgrade?
|
|
if(!theSuccess && this->GetHasCombatModeUpgrade(BUILD_SCAN) && !this->GetIsBeingDigested())
|
|
{
|
|
// Needed if there is a cloaked enemy nearby
|
|
bool theCloakedEnemyNearby = false;
|
|
|
|
// Look in sphere for cloakables
|
|
CBaseEntity* theSphereEntity = NULL;
|
|
while ((theSphereEntity = UTIL_FindEntityInSphere(theSphereEntity, this->pev->origin, BALANCE_VAR(kScanRadius))) != NULL)
|
|
{
|
|
if(!AvHSUGetIsExternalClassName(STRING(theSphereEntity->pev->classname)))
|
|
{
|
|
AvHCloakable* theCloakable = dynamic_cast<AvHCloakable*>(theSphereEntity);
|
|
if(theCloakable && theCloakable->GetIsPartiallyCloaked() && (theSphereEntity->pev->team != this->pev->team))
|
|
{
|
|
//if(this->GetIsEntityInSight(theSphereEntity))
|
|
//{
|
|
theCloakedEnemyNearby = true;
|
|
break;
|
|
//}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Lucky enough to receive?
|
|
if(theCloakedEnemyNearby /*&& (RANDOM_LONG(0, 1) == 0)*/)
|
|
{
|
|
// Scan
|
|
this->GiveCombatModeUpgrade(BUILD_SCAN);
|
|
theSuccess = true;
|
|
}
|
|
}
|
|
|
|
// // Does player have distress beacon?
|
|
// if(!theSuccess && this->GetHasCombatModeUpgrade(RESEARCH_DISTRESSBEACON))
|
|
// {
|
|
// // Needed?
|
|
// int theNumTeammatesWaitingToSpawn = 0;
|
|
// FOR_ALL_ENTITIES(kAvHPlayerClassName, AvHPlayer*);
|
|
// if(theEntity->GetTeam() == this->GetTeam())
|
|
// {
|
|
// if(theEntity->GetPlayMode() == PLAYMODE_AWAITINGREINFORCEMENT)
|
|
// {
|
|
// theNumTeammatesWaitingToSpawn++;
|
|
// }
|
|
// }
|
|
// END_FOR_ALL_ENTITIES(kAvHPlayerClassName);
|
|
//
|
|
// // Lucky enough?
|
|
// int theNumPlayersOnTeam = 0;
|
|
// AvHTeam* theTeamPointer = this->GetTeamPointer();
|
|
// if(theTeamPointer)
|
|
// {
|
|
// theNumPlayersOnTeam = theTeamPointer->GetPlayerCount();
|
|
// }
|
|
//
|
|
// float theDeadPercentage = (float)theNumTeammatesWaitingToSpawn/theNumPlayersOnTeam;
|
|
// if(theDeadPercentage > BALANCE_VAR(kCombatDistressBeaconDeadPercentage))
|
|
// {
|
|
// // Distress!
|
|
// this->GiveCombatModeUpgrade(RESEARCH_DISTRESSBEACON);
|
|
// theSuccess = true;
|
|
// }
|
|
// }
|
|
|
|
// Update time
|
|
this->mTimeOfLastCombatThink = theCurrentTime;
|
|
}
|
|
}
|
|
else if(this->GetIsAlien() && this->GetIsRelevant())
|
|
{
|
|
// Give aliens experience slowly over time
|
|
if(this->mTimeOfLastCombatThink == 0 || (theCurrentTime > (this->mTimeOfLastCombatThink + theCombatThinkInterval)))
|
|
{
|
|
float theExperienceRate = BALANCE_VAR(kCombatExperienceAlienGrowthRate);
|
|
float theExperienceGained = theCombatThinkInterval*theExperienceRate;
|
|
this->SetExperience(this->GetExperience() + theExperienceGained);
|
|
|
|
// Update time
|
|
this->mTimeOfLastCombatThink = theCurrentTime;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void AvHTeam::InitializeCombatTechNodes()
|
|
{
|
|
// If team is marine
|
|
if(this->mTeamType == AVH_CLASS_TYPE_MARINE)
|
|
{
|
|
this->AddTechNode(RESEARCH_WEAPONS_ONE, TECH_ONE_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(RESEARCH_WEAPONS_TWO, TECH_ONE_LEVEL_TWO, TECH_ONE_LEVEL_ONE, TECH_NULL, false);
|
|
this->AddTechNode(RESEARCH_WEAPONS_THREE, TECH_NULL, TECH_ONE_LEVEL_TWO, TECH_NULL, false);
|
|
this->AddTechNode(BUILD_SHOTGUN, TECH_ONE_LEVEL_THREE, TECH_ONE_LEVEL_ONE, TECH_NULL, false);
|
|
this->AddTechNode(BUILD_GRENADE_GUN, TECH_NULL, TECH_ONE_LEVEL_THREE, TECH_NULL, false);
|
|
this->AddTechNode(BUILD_HMG, TECH_NULL, TECH_ONE_LEVEL_THREE, TECH_NULL, false);
|
|
|
|
this->AddTechNode(RESEARCH_ARMOR_ONE, TECH_TWO_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(RESEARCH_ARMOR_TWO, TECH_TWO_LEVEL_TWO, TECH_TWO_LEVEL_ONE, TECH_NULL, false);
|
|
this->AddTechNode(RESEARCH_ARMOR_THREE, TECH_NULL, TECH_TWO_LEVEL_TWO, TECH_NULL, false);
|
|
this->AddTechNode(BUILD_JETPACK, TECH_NULL, TECH_TWO_LEVEL_TWO, TECH_NULL, false);
|
|
this->AddTechNode(BUILD_HEAVY, TECH_NULL, TECH_TWO_LEVEL_TWO, TECH_NULL, false);
|
|
|
|
this->AddTechNode(BUILD_SCAN, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false, false);
|
|
this->AddTechNode(RESEARCH_MOTIONTRACK, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
//this->AddTechNode(RESEARCH_DISTRESSBEACON, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, true, false);
|
|
|
|
this->AddTechNode(BUILD_RESUPPLY, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false, false);
|
|
this->AddTechNode(BUILD_CAT, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false, false);
|
|
|
|
this->AddTechNode(BUILD_WELDER, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false, false);
|
|
this->AddTechNode(BUILD_MINES, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false, false);
|
|
this->AddTechNode(RESEARCH_GRENADES, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false, false);
|
|
}
|
|
else
|
|
{
|
|
|
|
// Deny skulks so that player can't "re-evolve" to skulks.
|
|
this->AddTechNode(ALIEN_LIFEFORM_ONE, TECH_NULL, TECH_PLAYER_UNAVAILABLE, TECH_NULL, false);
|
|
|
|
this->AddTechNode(ALIEN_LIFEFORM_TWO, TECH_ONE_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_LIFEFORM_THREE, TECH_ONE_LEVEL_TWO, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_LIFEFORM_FOUR, TECH_ONE_LEVEL_THREE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_LIFEFORM_FIVE, TECH_ONE_LEVEL_FOUR, TECH_NULL, TECH_NULL, false);
|
|
|
|
this->AddTechNode(ALIEN_HIVE_TWO_UNLOCK, TECH_TWO_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_HIVE_THREE_UNLOCK, TECH_THREE_LEVEL_TWO, TECH_TWO_LEVEL_ONE, TECH_NULL, false);
|
|
|
|
this->AddTechNode(ALIEN_EVOLUTION_ONE, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_EVOLUTION_TWO, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_EVOLUTION_THREE, TECH_THREE_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
|
|
this->AddTechNode(ALIEN_EVOLUTION_TEN, TECH_FOUR_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_EVOLUTION_TWELVE, TECH_FOUR_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_EVOLUTION_ELEVEN, TECH_FOUR_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
|
|
this->AddTechNode(ALIEN_EVOLUTION_SEVEN, TECH_FIVE_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_EVOLUTION_EIGHT, TECH_FIVE_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
this->AddTechNode(ALIEN_EVOLUTION_NINE, TECH_FIVE_LEVEL_ONE, TECH_NULL, TECH_NULL, false);
|
|
}
|
|
}
|
|
|
|
void AvHGamerules::AwardExperience(AvHPlayer* inPlayer, int inTargetLevel, bool inAwardFriendliesInRange)
|
|
{
|
|
PlayerListType thePlayerList;
|
|
thePlayerList.push_back(inPlayer);
|
|
|
|
if(inAwardFriendliesInRange)
|
|
{
|
|
// Award experience to player, and any other players nearby
|
|
int theExperienceRadius = BALANCE_VAR(kCombatFriendlyNearbyRange);
|
|
|
|
// Make list of players to split it between. If a player is at full experience, extra is wasted.
|
|
CBaseEntity* theEntity = NULL;
|
|
while ((theEntity = UTIL_FindEntityInSphere(theEntity, inPlayer->pev->origin, theExperienceRadius)) != NULL)
|
|
{
|
|
const char* theClassName = STRING(theEntity->pev->classname);
|
|
if(!AvHSUGetIsExternalClassName(theClassName))
|
|
{
|
|
AvHPlayer* thePlayer = dynamic_cast<AvHPlayer*>(theEntity);
|
|
if(thePlayer && (thePlayer != inPlayer) && (thePlayer->pev->team == inPlayer->pev->team) && thePlayer->GetIsRelevant() && !thePlayer->GetIsBeingDigested())
|
|
{
|
|
thePlayerList.push_back(thePlayer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ASSERT(thePlayerList.size() > 0);
|
|
|
|
float theExperienceFactor = GetGameRules()->GetIsIronMan() ? BALANCE_VAR(kCombatIronManExperienceScalar) : 1.0f;
|
|
|
|
int theExperienceToAward = BALANCE_VAR(kCombatExperienceBaseAward) + inTargetLevel*BALANCE_VAR(kCombatExperienceLevelAward);
|
|
|
|
float theExperienceForEach = (theExperienceToAward/(float)thePlayerList.size() + BALANCE_VAR(kCombatExperienceCrowdAward))*theExperienceFactor;
|
|
|
|
for(PlayerListType::iterator thePlayerIter = thePlayerList.begin(); thePlayerIter != thePlayerList.end(); thePlayerIter++)
|
|
{
|
|
AvHPlayer* theCurrentPlayer = (*thePlayerIter);
|
|
theCurrentPlayer->SetExperience(theCurrentPlayer->GetExperience() + theExperienceForEach);
|
|
}
|
|
}
|