void CMiniBuffer::SetupMenu(menumode_t eMenuMode)
{
if (GetDigitanksPlayer()->GetPrimaryCPU() != NULL)
GetDigitanksPlayer()->GetPrimaryCPU()->SetupMenu(eMenuMode);
CHUD* pHUD = DigitanksWindow()->GetHUD();
tstring p;
if (!IsConstructing() && !IsUpgrading() && CanStructureUpgrade())
{
pHUD->SetButtonListener(0, CHUD::BeginUpgrade);
if (UpgradeCost() <= GetDigitanksPlayer()->GetPower())
{
pHUD->SetButtonTexture(0, "MacroBuffer");
pHUD->SetButtonColor(0, Color(50, 50, 50));
}
tstring s;
s += "UPGRADE TO MACRO-BUFFER\n \n";
s += "Macro-Buffers provide larger Network radius and can be updated by installing downloaded updates. Upgrading will make this structure inactive until the upgrade is complete.\n \n";
s += tsprintf(tstring("Turns to upgrade: %d Turns\n \n"), GetTurnsToUpgrade());
s += "Shortcut: Q";
pHUD->SetButtonInfo(0, s);
pHUD->SetButtonTooltip(0, "Upgrade To Macro-Buffer");
}
}
bool CStructure::NeedsOrders()
{
if (IsUpgrading() || IsConstructing())
return false;
if (CanStructureUpgrade())
return true;
return BaseClass::NeedsOrders();
}
void CStructure::StartTurn()
{
BaseClass::StartTurn();
FindGround();
if (!GetSupplier() && !dynamic_cast<CCPU*>(this))
{
if (GetPlayerOwner())
GetPlayerOwner()->RemoveUnit(this);
SetSupplier(NULL);
}
if (GetSupplier() && !GetSupplier()->GetPlayerOwner())
{
GetSupplier()->RemoveChild(this);
if (GetPlayerOwner())
GetPlayerOwner()->RemoveUnit(this);
SetSupplier(NULL);
}
if (GetPlayerOwner() == NULL)
return;
if (IsConstructing())
{
m_iTurnsToConstruct--;
if (m_iTurnsToConstruct == (size_t)0)
{
GetDigitanksPlayer()->AppendTurnInfo(tstring("Construction finished on ") + GetEntityName());
CompleteConstruction();
GetDigitanksPlayer()->AddActionItem(this, ACTIONTYPE_NEWSTRUCTURE);
}
else
GetDigitanksPlayer()->AppendTurnInfo(tsprintf(tstring("Constructing ") + GetEntityName() + " (%d turns left)", m_iTurnsToConstruct.Get()));
}
if (IsUpgrading())
{
m_iTurnsToUpgrade--;
if (m_iTurnsToUpgrade == (size_t)0)
{
GetDigitanksPlayer()->AppendTurnInfo(GetEntityName() + " finished upgrading.");
UpgradeComplete();
}
else
GetDigitanksPlayer()->AppendTurnInfo(tsprintf(tstring("Upgrading ") + GetEntityName() + " (%d turns left)", GetTurnsToUpgrade()));
}
}
void CStructure::ModifyContext(class CRenderingContext* pContext) const
{
BaseClass::ModifyContext(pContext);
if (IsConstructing() || IsUpgrading())
{
pContext->SetBlend(BLEND_ALPHA);
pContext->SetColor(Color(255, 255, 255));
pContext->SetAlpha(GetVisibility() * RemapValClamped((float)(GameServer()->GetGameTime() - m_flConstructionStartTime), 0.0f, 2.0f, 0.0f, 1.0f));
pContext->Translate(Vector(0, 0, RemapValClamped((float)(GameServer()->GetGameTime() - m_flConstructionStartTime), 0.0f, 3.0f, -3.0f, 0.0f)));
}
if (GetPlayerOwner())
{
pContext->SetUniform("bColorSwapInAlpha", true);
pContext->SetUniform("vecColorSwap", GetPlayerOwner()->GetColor());
}
}
void CMiniBuffer::UpdateInfo(tstring& s)
{
tstring p;
s = "";
s += "BUFFER INFO\n";
s += "Network extender\n \n";
if (GetPlayerOwner())
{
s += "Team: " + GetPlayerOwner()->GetPlayerName() + "\n";
if (GetDigitanksPlayer() == DigitanksGame()->GetCurrentLocalDigitanksPlayer())
s += " Friendly\n \n";
else
s += " Hostile\n \n";
}
else
{
s += "Team: Neutral\n \n";
}
if (IsConstructing())
{
s += "(Constructing)\n";
s += tsprintf(tstring("Turns left: %d\n"), GetTurnsRemainingToConstruct());
return;
}
if (IsUpgrading())
{
s += "(Upgrading to Macro-Buffer)\n";
s += tsprintf(tstring("Turns left: %d\n"), GetTurnsRemainingToUpgrade());
return;
}
s += tsprintf(tstring("Fleet Points: %d\n"), FleetPoints());
s += tsprintf(tstring("Bandwidth: %.1f/turn\n"), Bandwidth());
s += tsprintf(tstring("Network Size: %d\n"), (int)GetDataFlowRadius());
s += tsprintf(tstring("Efficiency: %d\n"), (int)(GetChildEfficiency()*100));
}
//-----------------------------------------------------------------------------
// Hit by a friendly engineer's wrench
//-----------------------------------------------------------------------------
bool CObjectSentrygun::OnWrenchHit( CTFPlayer *pPlayer, CTFWrench *pWrench, Vector vecHitPos )
{
bool bRepair = false;
bool bUpgrade = false;
bRepair = Command_Repair( pPlayer/*, pWrench->GetRepairValue()*/ );
// Don't put in upgrade metal until the object is fully healed
if ( CanBeUpgraded( pPlayer ) )
{
bUpgrade = CheckUpgradeOnHit( pPlayer );
}
DoWrenchHitEffect( vecHitPos, bRepair, bUpgrade );
if ( !IsUpgrading() )
{
// player ammo into rockets
// 1 ammo = 1 shell
// 2 ammo = 1 rocket
// only fill rockets if we have extra shells
int iPlayerMetal = pPlayer->GetAmmoCount( TF_AMMO_METAL );
// If the sentry has less that 100% ammo, put some ammo in it
if ( m_iAmmoShells < m_iMaxAmmoShells && iPlayerMetal > 0 )
{
int iMaxShellsPlayerCanAfford = (int)( (float)iPlayerMetal / tf_sentrygun_metal_per_shell.GetFloat() );
// cap the amount we can add
int iAmountToAdd = min( SENTRYGUN_ADD_SHELLS, iMaxShellsPlayerCanAfford );
iAmountToAdd = min( ( m_iMaxAmmoShells - m_iAmmoShells ), iAmountToAdd );
pPlayer->RemoveAmmo( iAmountToAdd * tf_sentrygun_metal_per_shell.GetInt(), TF_AMMO_METAL );
m_iAmmoShells += iAmountToAdd;
if ( iAmountToAdd > 0 )
{
bRepair = true;
}
}
// One rocket per two ammo
iPlayerMetal = pPlayer->GetAmmoCount( TF_AMMO_METAL );
if ( m_iAmmoRockets < m_iMaxAmmoRockets && m_iUpgradeLevel == 3 && iPlayerMetal > 0 )
{
int iMaxRocketsPlayerCanAfford = (int)( (float)iPlayerMetal / tf_sentrygun_metal_per_rocket.GetFloat() );
int iAmountToAdd = min( ( SENTRYGUN_ADD_ROCKETS ), iMaxRocketsPlayerCanAfford );
iAmountToAdd = min( ( m_iMaxAmmoRockets - m_iAmmoRockets ), iAmountToAdd );
pPlayer->RemoveAmmo( iAmountToAdd * tf_sentrygun_metal_per_rocket.GetFloat(), TF_AMMO_METAL );
m_iAmmoRockets += iAmountToAdd;
if ( iAmountToAdd > 0 )
{
bRepair = true;
}
}
}
return ( bRepair || bUpgrade );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CObjectTeleporter::TeleporterThink( void )
{
SetContextThink( &CObjectTeleporter::TeleporterThink, gpGlobals->curtime + BUILD_TELEPORTER_NEXT_THINK, TELEPORTER_THINK_CONTEXT );
// At any point, if our match is not ready, revert to IDLE
if ( IsDisabled() || IsRedeploying() || IsMatchingTeleporterReady() == false )
{
ShowDirectionArrow( false );
if ( GetState() != TELEPORTER_STATE_IDLE && !IsUpgrading() )
{
SetState( TELEPORTER_STATE_IDLE );
CObjectTeleporter *pMatch = GetMatchingTeleporter();
if ( !pMatch )
{
// The other end has been destroyed. Revert back to L1.
m_iUpgradeLevel = 1;
// We need to adjust for any damage received if we downgraded
float flHealthPercentage = GetHealth() / GetMaxHealthForCurrentLevel();
SetMaxHealth( GetMaxHealthForCurrentLevel() );
SetHealth( (int)( GetMaxHealthForCurrentLevel() * flHealthPercentage ) );
m_iUpgradeMetal = 0;
}
}
return;
}
if ( m_flMyNextThink && m_flMyNextThink > gpGlobals->curtime )
return;
// pMatch is not NULL and is not building
CObjectTeleporter *pMatch = GetMatchingTeleporter();
Assert( pMatch );
Assert( pMatch->m_iState != TELEPORTER_STATE_BUILDING );
switch ( m_iState )
{
// Teleporter is not yet active, do nothing
case TELEPORTER_STATE_BUILDING:
case TELEPORTER_STATE_UPGRADING:
ShowDirectionArrow( false );
break;
default:
case TELEPORTER_STATE_IDLE:
// Do we have a match that is active?
// Make sure both ends wait through full recharge time in case they get upgraded while recharging.
if ( IsMatchingTeleporterReady() && !IsUpgrading() && gpGlobals->curtime > m_flRechargeTime )
{
SetState( TELEPORTER_STATE_READY );
EmitSound( "Building_Teleporter.Ready" );
if ( GetObjectMode() == TELEPORTER_TYPE_ENTRANCE )
{
ShowDirectionArrow( true );
}
}
break;
case TELEPORTER_STATE_READY:
break;
case TELEPORTER_STATE_SENDING:
{
pMatch->TeleporterReceive( m_hTeleportingPlayer, 1.0 );
m_flRechargeTime = gpGlobals->curtime + ( BUILD_TELEPORTER_FADEOUT_TIME + BUILD_TELEPORTER_FADEIN_TIME + g_flTeleporterRechargeTimes[ GetUpgradeLevel() - 1] );
// change state to recharging...
SetState( TELEPORTER_STATE_RECHARGING );
}
break;
case TELEPORTER_STATE_RECEIVING:
{
// get the position we'll move the player to
Vector newPosition = GetAbsOrigin();
newPosition.z += TELEPORTER_MAXS.z + 1;
// Telefrag anyone in the way
CBaseEntity *pEnts[256];
Vector mins, maxs;
Vector expand( 4, 4, 4 );
mins = newPosition + VEC_HULL_MIN - expand;
maxs = newPosition + VEC_HULL_MAX + expand;
CTFPlayer *pTeleportingPlayer = m_hTeleportingPlayer.Get();
// move the player
if ( pTeleportingPlayer )
{
CUtlVector<CBaseEntity*> hPlayersToKill;
bool bClear = true;
// Telefrag any players in the way
int numEnts = UTIL_EntitiesInBox( pEnts, 256, mins, maxs, 0 );
if ( numEnts )
{
//Iterate through the list and check the results
for ( int i = 0; i < numEnts && bClear; i++ )
{
if ( pEnts[i] == NULL )
continue;
if ( pEnts[i] == this )
continue;
// kill players
if ( pEnts[i]->IsPlayer() )
{
if ( !pTeleportingPlayer->InSameTeam(pEnts[i]) )
{
hPlayersToKill.AddToTail( pEnts[i] );
}
continue;
}
if ( pEnts[i]->IsBaseObject() )
continue;
// Solid entities will prevent a teleport
if ( pEnts[i]->IsSolid() && pEnts[i]->ShouldCollide( pTeleportingPlayer->GetCollisionGroup(), MASK_ALL ) &&
g_pGameRules->ShouldCollide( pTeleportingPlayer->GetCollisionGroup(), pEnts[i]->GetCollisionGroup() ) )
{
// We're going to teleport into something solid. Abort & destroy this exit.
bClear = false;
}
}
}
if ( bClear )
{
// Telefrag all enemy players we've found
for ( int player = 0; player < hPlayersToKill.Count(); player++ )
{
CTakeDamageInfo info( this, pTeleportingPlayer, 1000, DMG_CRUSH, TF_DMG_TELEFRAG );
hPlayersToKill[player]->TakeDamage( info );
}
pTeleportingPlayer->Teleport( &newPosition, &(GetAbsAngles()), &vec3_origin );
// Unzoom if we are a sniper zoomed!
if ( ( pTeleportingPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_SNIPER ) &&
pTeleportingPlayer->m_Shared.InCond( TF_COND_AIMING ) )
{
CTFWeaponBase *pWpn = pTeleportingPlayer->GetActiveTFWeapon();
if ( pWpn && pWpn->GetWeaponID() == TF_WEAPON_SNIPERRIFLE )
{
CTFSniperRifle *pRifle = static_cast<CTFSniperRifle*>( pWpn );
pRifle->ToggleZoom();
}
}
pTeleportingPlayer->SetFOV( pTeleportingPlayer, 0, tf_teleporter_fov_time.GetFloat(), tf_teleporter_fov_start.GetInt() );
color32 fadeColor = {255,255,255,100};
UTIL_ScreenFade( pTeleportingPlayer, fadeColor, 0.25, 0.4, FFADE_IN );
}
else
{
DetonateObject();
}
}
SetState( TELEPORTER_STATE_RECEIVING_RELEASE );
m_flMyNextThink = gpGlobals->curtime + ( BUILD_TELEPORTER_FADEIN_TIME );
}
break;
case TELEPORTER_STATE_RECEIVING_RELEASE:
{
CTFPlayer *pTeleportingPlayer = m_hTeleportingPlayer.Get();
if ( pTeleportingPlayer )
{
int iTeam = GetBuilder() ? GetBuilder()->GetTeamNumber() : GetTeamNumber();
pTeleportingPlayer->m_Shared.SetTeleporterEffectColor( iTeam );
pTeleportingPlayer->TeleportEffect();
pTeleportingPlayer->m_Shared.RemoveCond( TF_COND_SELECTED_TO_TELEPORT );
if ( !m_bWasMapPlaced && GetBuilder() )
CTF_GameStats.Event_PlayerUsedTeleport( GetBuilder(), pTeleportingPlayer );
IGameEvent * event = gameeventmanager->CreateEvent( "player_teleported" );
if ( event )
{
event->SetInt( "userid", pTeleportingPlayer->GetUserID() );
if ( GetBuilder() )
event->SetInt( "builderid", GetBuilder()->GetUserID() );
Vector vecOrigin = GetAbsOrigin();
Vector vecDestinationOrigin = GetMatchingTeleporter()->GetAbsOrigin();
Vector vecDifference = Vector( vecOrigin.x - vecDestinationOrigin.x, vecOrigin.y - vecDestinationOrigin.y, vecOrigin.z - vecDestinationOrigin.z );
float flDist = sqrtf( pow( vecDifference.x, 2 ) + pow( vecDifference.y, 2 ) + pow( vecDifference.z, 2 ) );
event->SetFloat( "dist", flDist );
gameeventmanager->FireEvent( event, true );
}
// Don't thank ourselves.
if ( pTeleportingPlayer != GetBuilder() )
pTeleportingPlayer->SpeakConceptIfAllowed( MP_CONCEPT_TELEPORTED );
}
// reset the pointers to the player now that we're done teleporting
SetTeleportingPlayer( NULL );
pMatch->SetTeleportingPlayer( NULL );
SetState( TELEPORTER_STATE_RECHARGING );
m_flMyNextThink = gpGlobals->curtime + ( g_flTeleporterRechargeTimes[ GetUpgradeLevel() - 1 ] );
}
break;
case TELEPORTER_STATE_RECHARGING:
// If we are finished recharging, go active
if ( gpGlobals->curtime > m_flRechargeTime )
{
SetState( TELEPORTER_STATE_READY );
EmitSound( "Building_Teleporter.Ready" );
}
break;
}
}
//-----------------------------------------------------------------------------
// Hit by a friendly engineer's wrench
//-----------------------------------------------------------------------------
bool CObjectSentrygun::OnWrenchHit( CTFPlayer *pPlayer )
{
bool bDidWork = false;
// If the player repairs it at all, we're done
if ( GetHealth() < GetMaxHealth() )
{
if ( Command_Repair( pPlayer ) )
{
bDidWork = true;
}
}
// Don't put in upgrade metal until the sentry is fully healed
if ( !bDidWork && CanBeUpgraded( pPlayer ) )
{
int iPlayerMetal = pPlayer->GetAmmoCount( TF_AMMO_METAL );
int iAmountToAdd = min( tf_sentrygun_upgrade_per_hit.GetInt(), iPlayerMetal );
if ( iAmountToAdd > ( m_iUpgradeMetalRequired - m_iUpgradeMetal ) )
iAmountToAdd = ( m_iUpgradeMetalRequired - m_iUpgradeMetal );
if ( tf_cheapobjects.GetBool() == false )
{
pPlayer->RemoveAmmo( iAmountToAdd, TF_AMMO_METAL );
}
m_iUpgradeMetal += iAmountToAdd;
if ( iAmountToAdd > 0 )
{
bDidWork = true;
}
if ( m_iUpgradeMetal >= m_iUpgradeMetalRequired )
{
StartUpgrading();
m_iUpgradeMetal = 0;
}
}
if ( !IsUpgrading() )
{
// player ammo into rockets
// 1 ammo = 1 shell
// 2 ammo = 1 rocket
// only fill rockets if we have extra shells
int iPlayerMetal = pPlayer->GetAmmoCount( TF_AMMO_METAL );
// If the sentry has less that 100% ammo, put some ammo in it
if ( m_iAmmoShells < m_iMaxAmmoShells && iPlayerMetal > 0 )
{
int iMaxShellsPlayerCanAfford = (int)( (float)iPlayerMetal / tf_sentrygun_metal_per_shell.GetFloat() );
// cap the amount we can add
int iAmountToAdd = min( SENTRYGUN_ADD_SHELLS, iMaxShellsPlayerCanAfford );
iAmountToAdd = min( ( m_iMaxAmmoShells - m_iAmmoShells ), iAmountToAdd );
pPlayer->RemoveAmmo( iAmountToAdd * tf_sentrygun_metal_per_shell.GetInt(), TF_AMMO_METAL );
m_iAmmoShells += iAmountToAdd;
if ( iAmountToAdd > 0 )
{
bDidWork = true;
}
}
// One rocket per two ammo
iPlayerMetal = pPlayer->GetAmmoCount( TF_AMMO_METAL );
if ( m_iAmmoRockets < m_iMaxAmmoRockets && m_iUpgradeLevel == 3 && iPlayerMetal > 0 )
{
int iMaxRocketsPlayerCanAfford = (int)( (float)iPlayerMetal / tf_sentrygun_metal_per_rocket.GetFloat() );
int iAmountToAdd = min( ( SENTRYGUN_ADD_ROCKETS ), iMaxRocketsPlayerCanAfford );
iAmountToAdd = min( ( m_iMaxAmmoRockets - m_iAmmoRockets ), iAmountToAdd );
pPlayer->RemoveAmmo( iAmountToAdd * tf_sentrygun_metal_per_rocket.GetFloat(), TF_AMMO_METAL );
m_iAmmoRockets += iAmountToAdd;
if ( iAmountToAdd > 0 )
{
bDidWork = true;
}
}
}
return bDidWork;
}
void CStructure::DrawSchema(int x, int y, int w, int h)
{
CRenderingContext c(GameServer()->GetRenderer(), true);
c.SetBlend(BLEND_ALPHA);
c.SetColor(Color(255, 255, 255));
float flYPosition = (float)y + h;
float flXPosition = (float)x + w + 20;
int iIconFontSize = 11;
tstring sFont = "text";
float flIconFontHeight = glgui::RootPanel()->GetFontHeight(sFont, iIconFontSize) + 2;
if (IsConstructing())
{
tstring sTurns = tsprintf(tstring("Turns To Construct: %d"), GetTurnsRemainingToConstruct());
float flWidth = glgui::RootPanel()->GetTextWidth(sTurns, sTurns.length(), sFont, iIconFontSize);
glgui::CLabel::PaintText(sTurns, sTurns.length(), sFont, iIconFontSize, flXPosition - flWidth, (float)y);
return;
}
if (IsUpgrading())
{
tstring sTurns = tsprintf(tstring("Turns To Upgrade: %d"), GetTurnsRemainingToUpgrade());
float flWidth = glgui::RootPanel()->GetTextWidth(sTurns, sTurns.length(), sFont, iIconFontSize);
glgui::CLabel::PaintText(sTurns, sTurns.length(), sFont, iIconFontSize, flXPosition - flWidth, (float)y);
return;
}
if (GetUnitType() == STRUCTURE_CPU)
{
CCPU* pCPU = static_cast<CCPU*>(this);
if (pCPU->IsProducing())
{
tstring sTurns = "Rogue: 1"; // It only ever takes one turn to make a rogue.
float flWidth = glgui::RootPanel()->GetTextWidth(sTurns, sTurns.length(), sFont, iIconFontSize);
glgui::CLabel::PaintText(sTurns, sTurns.length(), sFont, iIconFontSize, flXPosition - flWidth, (float)y);
}
}
else if (GetUnitType() == STRUCTURE_TANKLOADER || GetUnitType() == STRUCTURE_INFANTRYLOADER || GetUnitType() == STRUCTURE_ARTILLERYLOADER)
{
CLoader* pLoader = static_cast<CLoader*>(this);
if (pLoader->IsProducing())
{
tstring sUnit;
if (pLoader->GetBuildUnit() == UNIT_INFANTRY)
sUnit = "Resistor";
else if (pLoader->GetBuildUnit() == UNIT_ARTILLERY)
sUnit = "Artillery";
else
sUnit = "Digitank";
tstring sTurns = tsprintf(sUnit + ": %d", pLoader->GetTurnsRemainingToProduce());
float flWidth = glgui::RootPanel()->GetTextWidth(sTurns, sTurns.length(), sFont, iIconFontSize);
glgui::CLabel::PaintText(sTurns, sTurns.length(), sFont, iIconFontSize, flXPosition - flWidth, (float)y);
}
}
if (Bandwidth() > 0)
{
tstring sBandwidth = tsprintf(tstring(": %.1f"), Bandwidth());
float flWidth = glgui::RootPanel()->GetTextWidth(sBandwidth, sBandwidth.length(), sFont, iIconFontSize);
DigitanksWindow()->GetHUD()->PaintHUDSheet("BandwidthIcon", flXPosition - flWidth - flIconFontHeight, flYPosition - flIconFontHeight + 5, flIconFontHeight, flIconFontHeight);
glgui::CLabel::PaintText(sBandwidth, sBandwidth.length(), sFont, iIconFontSize, flXPosition - flWidth, flYPosition);
flYPosition -= flIconFontHeight;
}
if (FleetPoints() > 0)
{
tstring sFleetPoints = tsprintf(tstring(": %d"), FleetPoints());
float flWidth = glgui::RootPanel()->GetTextWidth(sFleetPoints, sFleetPoints.length(), sFont, iIconFontSize);
DigitanksWindow()->GetHUD()->PaintHUDSheet("FleetPointsIcon", flXPosition - flWidth - flIconFontHeight, flYPosition - flIconFontHeight + 5, flIconFontHeight, flIconFontHeight);
glgui::CLabel::PaintText(sFleetPoints, sFleetPoints.length(), sFont, iIconFontSize, flXPosition - flWidth, flYPosition);
flYPosition -= flIconFontHeight;
}
if (Power() > 0)
{
tstring sPower = tsprintf(tstring(": %.1f"), Power());
float flWidth = glgui::RootPanel()->GetTextWidth(sPower, sPower.length(), sFont, iIconFontSize);
DigitanksWindow()->GetHUD()->PaintHUDSheet("PowerIcon", (flXPosition - flWidth - flIconFontHeight), (flYPosition - flIconFontHeight) + 5, flIconFontHeight, flIconFontHeight);
glgui::CLabel::PaintText(sPower, sPower.length(), sFont, iIconFontSize, flXPosition - flWidth, flYPosition);
flYPosition -= flIconFontHeight;
}
}
