int AvHMine::GetItemInfo(ItemInfo *p) const
{
	p->iSlot = AVH_FIFTH_SLOT;
	p->iPosition = 1;

	p->pszName = STRING(pev->classname);
	p->pszAmmo1 = "MineAmmo";
	p->iMaxAmmo1 = 0;//BALANCE_VAR(kMineMaxAmmo);
	p->pszAmmo2 = NULL;
	p->iMaxAmmo2 = BALANCE_VAR(kMineDamage);
	p->iMaxClip = BALANCE_VAR(kMineMaxAmmo);
	p->iFlags = ITEM_FLAG_NOAUTOSWITCHEMPTY;//ITEM_FLAG_LIMITINWORLD | ITEM_FLAG_EXHAUSTIBLE;
	p->iId = AVH_WEAPON_MINE;
	p->iWeight = kDefaultTertiaryWeaponWeight;

//	p->pszName = STRING(pev->classname);
//	p->pszAmmo1 = "MineAmmo";
//	p->iMaxAmmo1 = kMineMaxAmmo;
//	p->pszAmmo2 = NULL;
//	p->iMaxAmmo2 = -1;
//	p->iMaxClip = WEAPON_NOCLIP;
//	p->iFlags = ITEM_FLAG_LIMITINWORLD | ITEM_FLAG_EXHAUSTIBLE;
//	p->iId = m_iId = AVH_WEAPON_MINE;
//	p->iWeight = 5;
	
	return 1;
}

void AvHMUUpdateAlienEnergy(float inTimePassed, int inUser3, int inUser4, float& ioFuser)
{
	if(	(inUser3 == AVH_USER3_ALIEN_PLAYER1) ||
		(inUser3 == AVH_USER3_ALIEN_PLAYER2) ||
		(inUser3 == AVH_USER3_ALIEN_PLAYER3) ||
		(inUser3 == AVH_USER3_ALIEN_PLAYER4) ||
		(inUser3 == AVH_USER3_ALIEN_PLAYER5) ||
		(inUser3 == AVH_USER3_ALIEN_PLAYER6))
	{
		if(!GetHasUpgrade(inUser4, MASK_PLAYER_STUNNED))
		{
			// Percentage (0-1) per second
			float theAlienEnergyRate = (float)BALANCE_VAR(kAlienEnergyRate);
			//float kFadeChargingDeplectionRate = -2.8f*kAlienEnergyRate;
			float kChargingDepletionRate = -BALANCE_VAR(kChargingEnergyScalar)*theAlienEnergyRate;

			const float kMultiplier = GetHasUpgrade(inUser4, MASK_BUFFED) ? (1.0f + BALANCE_VAR(kPrimalScreamEnergyFactor)) : 1.0f;
			float theEnergyRate = theAlienEnergyRate*kMultiplier;

			float theUpgradeFactor = 1.0f;
			int theNumLevels = AvHGetAlienUpgradeLevel(inUser4, MASK_UPGRADE_5);
			if(theNumLevels > 0)
			{

				theUpgradeFactor += theNumLevels*BALANCE_VAR(kAdrenalineEnergyPercentPerLevel);
			}

			float theCurrentEnergy = ioFuser/kNormalizationNetworkFactor;
			
			float theNewEnergy = theCurrentEnergy + inTimePassed*theAlienEnergyRate*theUpgradeFactor;

//			// If we're charging, reduce energy
//			// Removed: Charge only reduces energy when active
//			if(GetHasUpgrade(inUser4, MASK_ALIEN_MOVEMENT))
//			{
//				if(inUser3 == AVH_USER3_ALIEN_PLAYER4)
//				{
//					theNewEnergy += inTimePassed*kFadeChargingDeplectionRate;
//				}
//				else
//				{
//					theNewEnergy += inTimePassed*kChargingDepletionRate;
//				}
//			}
			
			theNewEnergy = min(max(theNewEnergy, 0.0f), 1.0f);
			
			ioFuser = theNewEnergy*kNormalizationNetworkFactor;
		}
	}
}

void AvHMovementChamber::EnergyAliensThink()
{
	// Don't teleport until it's "warmed up"
	SetUse(&AvHMovementChamber::TeleportUse);

	// Loop through all players
	CBaseEntity* theBaseEntity = NULL;
	int theNumEntsProcessed = 0;
	
	while(((theBaseEntity = UTIL_FindEntityInSphere(theBaseEntity, this->pev->origin, BALANCE_VAR(kMovementChamberEnergyRange))) != NULL) && (theNumEntsProcessed < BALANCE_VAR(kAlienChamberMaxPlayers)))
	{
		if(theBaseEntity->pev->team == this->pev->team)
		{
			float theEnergizeAmount = BALANCE_VAR(kMovementChamberEnergyAmount);
			AvHBaseBuildable* theBuildable = dynamic_cast<AvHBaseBuildable*>(theBaseEntity);
			AvHPlayer* thePlayer = dynamic_cast<AvHPlayer*>(theBaseEntity);
			if(thePlayer && thePlayer->IsAlive())
			{
				if(thePlayer->Energize(theEnergizeAmount))
				{
					theNumEntsProcessed++;
				}
			}
			// Energize alien buildables
//			else if(theBuildable)
//			{
//				if(theBuildable->Energize(theEnergizeAmount))
//				{
//					theNumEntsProcessed++;
//				}
//			}
		}
	}

	// Play an animation (spin the arms if energizing)
	int theIdle = this->GetIdle2Animation();

	// Play sound
	if(theNumEntsProcessed > 0)
	{
		EMIT_SOUND(this->edict(), CHAN_AUTO, kAlienEnergySound, 1.0f, ATTN_NORM);

		theIdle = this->GetIdle1Animation();
	}

	this->PlayAnimationAtIndex(theIdle);
	
	// Set next think
	this->pev->nextthink = gpGlobals->time + BALANCE_VAR(kMovementChamberThinkInterval);
}

void AvHDefenseChamber::SetHasBeenBuilt()
{
	AvHAlienUpgradeBuilding::SetHasBeenBuilt();
	
	SetThink(&AvHDefenseChamber::RegenAliensThink);
	this->pev->nextthink = gpGlobals->time + BALANCE_VAR(kDefenseChamberThinkInterval);
}

void AvHPistol::Spawn()
{
    AvHMarineWeapon::Spawn();

	Precache();

	this->m_iId = AVH_WEAPON_PISTOL;
	this->m_iDefaultAmmo = BALANCE_VAR(kHGMaxClip)*(BALANCE_VAR(kMarineSpawnClips) + 1);

    // Set our class name
	this->pev->classname = MAKE_STRING(kwsPistol);

	SET_MODEL(ENT(this->pev), kHGWModel);

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

void AvHBaseBuildable::RecycleComplete()
{
	// Look at whether it has been built and health to determine how many points to give back
	float thePercentage = BALANCE_VAR(kRecycleResourcePercentage);

	if(!this->GetIsBuilt())
	{
		thePercentage = .8f;
	}

	// Make sure the building is still alive, can't get points back if it's dead
	if(this->pev->health <= 0)
	{
		thePercentage = 0.0f;
	}

	// Look up team
	AvHTeam* theTeam = GetGameRules()->GetTeam((AvHTeamNumber)this->pev->team);
	if(theTeam)
	{
		bool theIsEnergyTech = AvHSHUGetDoesTechCostEnergy(this->mMessageID);
		ASSERT(!theIsEnergyTech);

		float thePointsBack = GetGameRules()->GetCostForMessageID(this->mMessageID)*thePercentage;
		theTeam->SetTeamResources(theTeam->GetTeamResources() + thePointsBack);

        // Play "+ resources" event
        AvHSUPlayNumericEventAboveStructure(thePointsBack, this);

		// puzl: 980
		// Less smoke and more sparks  for recycled buildings
		this->Killed(this->pev, GIB_RECYCLED);
		// :puzl
	}
}

bool AvHBaseBuildable::Regenerate(float inRegenerationAmount, bool inPlaySound, bool dcHealing)
{
	bool theDidHeal = false;
	if ( gpGlobals->time > this->mTimeOfLastDCRegeneration + BALANCE_VAR(kDefenseChamberThinkInterval) - 0.05f || (dcHealing == false)) {
		if ( dcHealing )
			this->mTimeOfLastDCRegeneration = gpGlobals->time;
		float theMaxHealth = this->mBaseHealth;

		if(!this->GetIsBuilt())
		{
			float theNormalizedBuildPercentage = this->GetNormalizedBuildPercentage();

			theMaxHealth = (kBaseHealthPercentage + theNormalizedBuildPercentage*(1.0f - kBaseHealthPercentage))*this->mBaseHealth;
		}

		// If we aren't at full health, heal health
		if(this->pev->health < theMaxHealth)
		{
			this->pev->health = min(theMaxHealth, this->pev->health + inRegenerationAmount);
			this->HealthChanged();
			theDidHeal = true;
		}
		
		// Play regen event
		if(theDidHeal)
		{
			if(inPlaySound)
			{
				// Play regeneration event
				PLAYBACK_EVENT_FULL(0, this->edict(), gRegenerationEventID, 0, this->pev->origin, (float *)&g_vecZero, 1.0f, 0.0, /*theWeaponIndex*/ 0, 0, 0, 0 );
			}
		}
	}
	return theDidHeal;
}

void AvHDefenseChamber::RegenAliensThink()
{
	// Loop through all players
	CBaseEntity* theBaseEntity = NULL;
	int theNumEntsHealed = 0;
	
	while(((theBaseEntity = UTIL_FindEntityInSphere(theBaseEntity, this->pev->origin, BALANCE_VAR(kDefensiveChamberHealRange))) != NULL) && (theNumEntsHealed < BALANCE_VAR(kAlienChamberMaxPlayers)))
	{
		if(theBaseEntity->pev->team == this->pev->team)
		{
			AvHBaseBuildable* theBuildable = dynamic_cast<AvHBaseBuildable*>(theBaseEntity);
			AvHPlayer* thePlayer = dynamic_cast<AvHPlayer*>(theBaseEntity);
			float thePercent=BALANCE_VAR(kDefensiveChamberRegenPercent)/100.0f;
			float amount=BALANCE_VAR(kDefensiveChamberRegenAmount) + (theBaseEntity->pev->max_health*thePercent);
			if(thePlayer && thePlayer->IsAlive())
			{
				if(thePlayer->Heal(amount, true, true))
				{
					theNumEntsHealed++;
				}
			}
			else if(theBuildable && theBuildable->GetIsBuilt() && (theBuildable != this))
			{
				if(theBuildable->Regenerate(amount, true, true))
				{
					theNumEntsHealed++;
				}
			}
		}
	}
	
	// Set next think
	this->pev->nextthink = gpGlobals->time + BALANCE_VAR(kDefenseChamberThinkInterval);
	
	// Play a random idle animation
	int theIdle = this->GetIdle1Animation();
	
	if(RANDOM_LONG(0, 1))
	{
		theIdle = this->GetIdle2Animation();
	}
	
	this->PlayAnimationAtIndex(theIdle);
}

void AvHHive::ProcessHealing()
{
	// Regenerate nearby friendly aliens
	CBaseEntity* theEntity = NULL;
	const int theHiveHealRadius = BALANCE_VAR(kHiveHealRadius);

	while((theEntity = UTIL_FindEntityInSphere(theEntity, this->pev->origin, theHiveHealRadius)) != NULL)
	{
		AvHPlayer* thePlayer = dynamic_cast<AvHPlayer*>(theEntity);
		if(thePlayer)
		{
			if(thePlayer->GetIsRelevant() && (thePlayer->GetTeam() == this->GetTeamNumber()) && !thePlayer->GetIsBeingDigested())
			{
                // Hive heals percentage of player health
                float theRegenPercentage = BALANCE_VAR(kHiveRegenerationPercentage);
                int theMaxHealth = AvHPlayerUpgrade::GetMaxHealth(thePlayer->pev->iuser4, (AvHUser3)thePlayer->pev->iuser3, thePlayer->GetExperienceLevel());
                float theRegenAmount = (theRegenPercentage*theMaxHealth);
                thePlayer->Heal(theRegenAmount, true);
			}
		}
	}
	
	// Regenerate self
	bool theDidHeal = false;
	
	// If we aren't at full health, heal health
	if(this->pev->health < this->mMaxHitPoints)
	{
        float theHiveRegenAmount = BALANCE_VAR(kHiveRegenerationAmount);
        float theCombatModeScalar = /*GetGameRules()->GetIsCombatMode() ? (1.0f/BALANCE_VAR(kCombatModeTimeScalar)) :*/ 1.0f;

		this->pev->health = min((float)this->mMaxHitPoints, this->pev->health + theHiveRegenAmount*theCombatModeScalar);
		theDidHeal = true;
	}
	
	// Play regen event
	if(theDidHeal)
	{
		// Play regeneration event
		PLAYBACK_EVENT_FULL(0, this->edict(), gRegenerationEventID, 0, this->pev->origin, (float *)&g_vecZero, 1.0f, 0.0, /*theWeaponIndex*/ 0, 0, 0, 0 );
	}
}

float AvHMarineWeapon::ComputeAttackInterval() const
{
    float theROF = this->GetRateOfFire();

    int theUser4 = this->m_pPlayer->pev->iuser4;

    // Speed attack if in range of primal scream
    if(GetHasUpgrade(theUser4, MASK_BUFFED))
    {
        float theCatalystROFFactor = 1.0f + BALANCE_VAR(kCatalystROFFactor);
        theROF /= theCatalystROFFactor;
    }

    return theROF;

}

void AvHSonicGun::FireProjectiles(void)
{
	Vector vecSrc	 = m_pPlayer->GetGunPosition( );
	Vector vecAiming = m_pPlayer->GetAutoaimVector( AUTOAIM_5DEGREES );
	
	ASSERT(this->m_iPrimaryAmmoType >= 0);
	//int theNumBullets = min(kSGBulletsPerShot, this->m_iClientClip);

	float theDamageMultiplier;
	AvHPlayerUpgrade::GetWeaponUpgrade(this->m_pPlayer->pev->iuser3, this->m_pPlayer->pev->iuser4, &theDamageMultiplier);
	float theDamage = this->mDamage*theDamageMultiplier;
	
    // Fire the bullets and apply damage
	//this->m_pPlayer->FireBullets(kSGBulletsPerShot, vecSrc, vecAiming, this->GetProjectileSpread(), this->mRange, 0, 0, theDamage);
	this->m_pPlayer->FireBulletsPlayer(BALANCE_VAR(kSGBulletsPerShot), vecSrc, vecAiming, this->GetProjectileSpread(), this->mRange, BULLET_PLAYER_BUCKSHOT, 0, theDamage, 0, this->m_pPlayer->random_seed);
}

char* AvHAlienResourceTower::GetActiveSoundList() const
{
	char* theActiveSoundList = NULL;

	// Don't play active sounds until kAlienResourceTowerSoundDelayTime seconds have passed, to prevent marines from knowing where aliens start
	int theTimeToWaitBeforeSounds = BALANCE_VAR(kAlienResourceTowerSoundDelayTime);
	int theGameTime = GetGameRules()->GetGameTime();
	if((theGameTime > 0) && (theGameTime >= theTimeToWaitBeforeSounds))
	{
		theActiveSoundList = kAlienResourceTowerSoundList;
	}
	else
	{
		int a = 0;
	}

	return theActiveSoundList;
}