void CheckAutoTransparentProps(const Vector &pos, const QAngle &ang)
{
float opacity = clamp(cl_goal_opacity.GetFloat(), 0.0f, 1.0f);
for (int i = gpGlobals->maxClients; i <= ClientEntityList().GetHighestEntityIndex(); i++)
{
C_BaseEntity *pEnt = ClientEntityList().GetBaseEntity(i);
if(!dynamic_cast<C_AutoTransparentProp *>(pEnt))
continue;
// Check if the camera is behind the goal line and close to the goal. Use an additional offset so the goal post doesn't get in the way.
if (opacity != 1.0f
&& (pos.y <= SDKGameRules()->m_vFieldMin.GetY() + cl_goal_opacity_fieldoffset.GetFloat() && pEnt->GetLocalOrigin().y < SDKGameRules()->m_vKickOff.GetY()
|| pos.y >= SDKGameRules()->m_vFieldMax.GetY() - cl_goal_opacity_fieldoffset.GetFloat() && pEnt->GetLocalOrigin().y > SDKGameRules()->m_vKickOff.GetY())
&& pos.x >= SDKGameRules()->m_vKickOff.GetX() - 500 && pos.x <= SDKGameRules()->m_vKickOff.GetX() + 500)
{
pEnt->SetRenderMode(kRenderTransColor);
pEnt->SetRenderColorA(opacity * 255);
}
else
{
pEnt->SetRenderMode(kRenderNormal);
}
}
}
void CReplayManager::StartReplay(bool isHighlightReplay)
{
if (!sv_replays.GetBool())
return;
m_bIsHighlightReplay = isHighlightReplay;
m_nReplayIndex = FindNextHighlightReplayIndex((m_bIsHighlightReplay ? 0 : -1), SDKGameRules()->State_Get());
if (m_nReplayIndex == -1)
return;
MatchEvent *pMatchEvent = m_MatchEvents[m_nReplayIndex];
m_bIsHighlightStart = true;
m_bIsReplayStart = true;
float replayActivationDelay;
if (m_bIsHighlightReplay)
replayActivationDelay = SDKGameRules()->State_Get() == MATCH_PERIOD_COOLDOWN ? sv_ball_highlightsdelay_cooldown.GetFloat() : sv_ball_highlightsdelay_intermissions.GetFloat();
else
replayActivationDelay = sv_ball_goalcelebduration.GetFloat();
m_flReplayActivationTime = gpGlobals->curtime + replayActivationDelay;
m_nReplayRunIndex = 0;
m_bReplayIsPending = true;
m_bIsReplaying = false;
CalcMaxReplayRunsAndDuration(pMatchEvent, m_flReplayActivationTime);
}
static void OnWeatherTypeChange(IConVar *var, const char *pOldValue, float flOldValue)
{
#ifdef GAME_DLL
if (SDKGameRules())
SDKGameRules()->SetWeather((PrecipitationType_t)((ConVar*)var)->GetInt());
#endif
}
void C_Camera::CalcHawkEyeView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
{
C_SDKPlayer *pLocal = C_SDKPlayer::GetLocalSDKPlayer();
eyeOrigin = SDKGameRules()->m_vKickOff;
eyeOrigin.z += 500;
eyeOrigin.y += pLocal->GetTeam()->m_nForward * ((SDKGameRules()->m_vFieldMax.GetY() - SDKGameRules()->m_vFieldMin.GetY()) * (1.0f / 8.0f));
}
//
// Name: CreateGameRule( GameModeID_enum GameMode )
// Author: Hekar Khani
// Description: Initializes the gamerules based on
// selected argument and enabled gamemodes
// Notes:
//
void CreateGameRule( GameModeID_enum GameMode )
{
Msg("=================================================\n");
Msg("[LF] Gamemode: ");
switch( GameMode )
{
//-------------------------------------------------
#ifdef MOD_SF132
case GAMEMODE_SF132:
CreateGameRulesObject( "CSF132GameRules" );
Msg("Sourceforts 132");
break;
#endif // MOD_SF132
//-------------------------------------------------
#ifdef MOD_CLASSIC
case GAMEMODE_CLASSIC:
CreateGameRulesObject( "CClassicGameRules" );
Msg("CTF\n");
break;
#endif // MOD_CLASSIC
case GAMEMODE_DOM:
CreateGameRulesObject( "CDomGameRules" );
Msg("Domination\n");
break;
//-------------------------------------------------
default:
//-------------------------------------------------
#ifdef MOD_SF132
// Check if the mapname is prefixed as a SF132 map and use
// the 132 gamerules if so
if ( Q_strstr( gpGlobals->mapname.ToCStr(), "sf132_" ) )
{
CreateGameRulesObject( "CSF132GameRules" );
SDKGameRules()->SetSourcefortsMap( true );
Msg("Sourceforts 132\n");
}
else
#endif // MOD_SF132
//-------------------------------------------------
#ifdef MOD_CLASSIC
{
// The Classic gamerules work with 194
// and CTF based 195 maps
CreateGameRulesObject( "CClassicGameRules" );
SDKGameRules()->SetSourcefortsMap( true );
Msg("Sourceforts 194\n");
}
#endif // MOD_CLASSIC
//-------------------------------------------------
// This "break" is here in case MOD_SF132
// is enabled and MOD_CLASSIC is disabled
break;
}
Msg("=================================================\n");
Assert( g_pGameRules );
g_pGameRules->Init();
}
void CC_CreatePlayerBall(const CCommand &args)
{
if (!SDKGameRules()->IsIntermissionState() || SDKGameRules()->IsCeremony())
return;
CSDKPlayer *pPl = ToSDKPlayer(UTIL_GetCommandClient());
if (!CSDKPlayer::IsOnField(pPl))
return;
if (pPl->GetFlags() & FL_REMOTECONTROLLED)
return;
trace_t tr;
CTraceFilterSkipTwoEntities traceFilter(pPl, pPl->GetPlayerBall(), COLLISION_GROUP_NONE);
UTIL_TraceHull(
pPl->GetLocalOrigin() + VEC_VIEW,
pPl->GetLocalOrigin() + VEC_VIEW + pPl->EyeDirection3D() * 150,
-Vector(BALL_PHYS_RADIUS, BALL_PHYS_RADIUS, BALL_PHYS_RADIUS),
Vector(BALL_PHYS_RADIUS, BALL_PHYS_RADIUS, BALL_PHYS_RADIUS),
MASK_SOLID,
&traceFilter,
&tr);
Vector pos = tr.endpos;
if (pPl->GetPlayerBall())
{
if (pPl->GetPlayerBall()->GetHoldingPlayer())
{
//pPl->GetPlayerBall()->RemoveFromPlayerHands(pPl->GetPlayerBall()->GetHoldingPlayer());
pPl->GetPlayerBall()->State_Transition(BALL_STATE_NORMAL);
}
if (sv_ball_update_physics.GetBool())
pPl->GetPlayerBall()->CreateVPhysics();
pPl->GetPlayerBall()->SetPos(pos, false);
pPl->GetPlayerBall()->RemoveAllTouches();
}
else
pPl->SetPlayerBall(CreatePlayerBall(pos, pPl));
//pPl->GetPlayerBall()->m_nSkin = pPl->GetPlayerBallSkin() == -1 ? g_IOSRand.RandomInt(0, BALL_SKIN_COUNT - 1) : pPl->GetPlayerBallSkin();
pPl->GetPlayerBall()->SetSkinName(pPl->GetPlayerBallSkinName());
pPl->GetPlayerBall()->SetBallCannonMode(false);
pPl->GetPlayerBall()->SaveBallCannonSettings();
pPl->m_Shared.SetStamina(100);
}
int C_Camera::GetTVCamMode()
{
C_SDKPlayer *pLocal = C_SDKPlayer::GetLocalSDKPlayer();
if (!pLocal)
return TVCAM_MODE_SIDELINE;
if (SDKGameRules()->IsCeremony())
{
return TVCAM_MODE_SIDELINE;
}
else if (GetReplayManager() && GetReplayManager()->IsReplaying())
{
switch (GetReplayManager()->m_nReplayRunIndex)
{
case 0: default: return mp_tvcam_replaycam1.GetInt();
case 1: return mp_tvcam_replaycam2.GetInt();
case 2: return mp_tvcam_replaycam3.GetInt();
}
}
else if (GetMatchBall() && GetMatchBall()->m_eBallState == BALL_STATE_GOAL)
{
return TVCAM_MODE_CELEBRATION;
}
else
{
return m_nTVCamMode;
}
}
int C_Camera::GetCamMode()
{
C_SDKPlayer *pLocal = C_SDKPlayer::GetLocalSDKPlayer();
if (!pLocal)
return CAM_MODE_ROAMING;
if (GetReplayManager() && GetReplayManager()->IsReplaying())
{
return CAM_MODE_TVCAM;
}
else if (GetMatchBall() && GetMatchBall()->m_eBallState == BALL_STATE_GOAL || SDKGameRules()->State_Get() == MATCH_PERIOD_PENALTIES)
{
if (pLocal->IsObserver() || pLocal->GetFlags() & FL_USE_TV_CAM)
return CAM_MODE_TVCAM;
else
return CAM_MODE_FREE_CHASE;
}
else
{
if (pLocal->IsObserver())
return m_nCamMode;
else
return CAM_MODE_FREE_CHASE;
}
}
void *SendProxy_SDKGameRules( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
{
CSDKGameRules *pRules = SDKGameRules();
Assert( pRules );
pRecipients->SetAllRecipients();
return pRules;
}
void CReplayManager::CheckReplay()
{
if (m_bReplayIsPending && gpGlobals->curtime >= m_flReplayActivationTime || m_bIsReplaying)
RestoreSnapshot();
else if (!m_bIsReplaying && !SDKGameRules()->IsIntermissionState()
&& (!m_bReplayIsPending || m_MatchEvents.Count() > 0 && m_MatchEvents.Tail()->snapshotEndTime >= gpGlobals->curtime))
TakeSnapshot();
}
void CReplayManager::AddMatchEvent(match_event_t type, int team, CSDKPlayer *pPlayer1, CSDKPlayer *pPlayer2/* = NULL*/, CSDKPlayer *pPlayer3/* = NULL*/)
{
MatchEvent *pMatchEvent = new MatchEvent;
if (type == MATCH_EVENT_GOAL || type == MATCH_EVENT_OWNGOAL || type == MATCH_EVENT_MISS || type == MATCH_EVENT_KEEPERSAVE || type == MATCH_EVENT_REDCARD)
{
float replayStartTime = GetReplayStartTime() + 1.0f;
for (int i = 0; i < m_Snapshots.Count(); i++)
{
if (m_Snapshots[i]->snaptime >= replayStartTime)
{
pMatchEvent->snapshots.AddToTail(m_Snapshots[i]);
m_Snapshots[i]->replayCount += 1;
}
}
pMatchEvent->snapshotEndTime = gpGlobals->curtime + 1.0f;
}
else
pMatchEvent->snapshotEndTime = 0;
pMatchEvent->matchPeriod = SDKGameRules()->State_Get();
pMatchEvent->matchEventType = type;
pMatchEvent->second = SDKGameRules()->GetMatchDisplayTimeSeconds();
pMatchEvent->team = team;
pMatchEvent->atMinGoalPos = GetMatchBall()->GetPos().y < SDKGameRules()->m_vKickOff.GetY();
pMatchEvent->pPlayer1Data = pPlayer1 ? pPlayer1->GetPlayerData() : NULL;
pMatchEvent->pPlayer2Data = pPlayer2 ? pPlayer2->GetPlayerData() : NULL;
pMatchEvent->pPlayer3Data = pPlayer3 ? pPlayer3->GetPlayerData() : NULL;
m_MatchEvents.AddToTail(pMatchEvent);
if (type == MATCH_EVENT_GOAL || type == MATCH_EVENT_OWNGOAL || type == MATCH_EVENT_YELLOWCARD || type == MATCH_EVENT_SECONDYELLOWCARD || type == MATCH_EVENT_REDCARD)
{
char matchEventPlayerNames[MAX_MATCH_EVENT_PLAYER_NAME_LENGTH] = {};
if (pPlayer1 && !pPlayer2 && !pPlayer3)
Q_strncpy(matchEventPlayerNames, UTIL_VarArgs("%s", pPlayer1->GetPlayerName()), MAX_MATCH_EVENT_PLAYER_NAME_LENGTH);
else if (pPlayer1 && pPlayer2 && !pPlayer3)
Q_strncpy(matchEventPlayerNames, UTIL_VarArgs("%.15s (%.15s)", pPlayer1->GetPlayerName(), pPlayer2->GetPlayerName()), MAX_MATCH_EVENT_PLAYER_NAME_LENGTH);
else if (pPlayer1 && pPlayer2 && pPlayer3)
Q_strncpy(matchEventPlayerNames, UTIL_VarArgs("%.10s (%.10s, %.10s)", pPlayer1->GetPlayerName(), pPlayer2->GetPlayerName(), pPlayer3->GetPlayerName()), MAX_MATCH_EVENT_PLAYER_NAME_LENGTH);
GetGlobalTeam(pMatchEvent->team)->AddMatchEvent(pMatchEvent->matchPeriod, pMatchEvent->second, pMatchEvent->matchEventType, matchEventPlayerNames);
}
}
void CTriggerKill::Touch( CBaseEntity *pOther )
{
if (pOther->IsPlayer())
{
CTakeDamageInfo info( this, this, 10000, m_bitsDamageInflict );
pOther->TakeDamage( info );
ToSDKPlayer(pOther)->PlayerDeathThink();
ToSDKPlayer(pOther)->SetKilledByString(m_sKillerPrintString);
}
else if (dynamic_cast<CBriefcase*>(pOther))
{
// This code doesn't work, the briefcase needs some sort of flag
// to be triggered and I can't be bothered to figure it out right now.
AssertMsg(false, "Untested code");
SDKGameRules()->CleanupMiniObjective_Briefcase();
SDKGameRules()->SetupMiniObjective_Briefcase();
}
}
void CCrowdTextureProxy::OnBind( void *pEntity )
{
Assert ( m_AnimatedTextureVar );
if( m_AnimatedTextureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
{
return;
}
ITexture *pTexture;
pTexture = m_AnimatedTextureVar->GetTextureValue();
int numFrames = pTexture->GetNumAnimationFrames();
if ( numFrames <= 0 )
{
Assert( !"0 frames in material calling animated texture proxy" );
return;
}
// NOTE: Must not use relative time based methods here
// because the bind proxy can be called many times per frame.
// Prevent multiple Wrap callbacks to be sent for no wrap mode
if (SDKGameRules())
m_FrameRate = max(0, (int)(30 * abs(SDKGameRules()->m_nBallZone) / 100.0f));
else
m_FrameRate = 0;
if (m_nFrameCount != gpGlobals->framecount)
{
m_nFrameCount = gpGlobals->framecount;
m_flFrame = fmod(m_flFrame + m_FrameRate * gpGlobals->frametime, numFrames);
}
m_AnimatedTextureFrameNumVar->SetIntValue( (int)m_flFrame );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
const Color &C_PlayerResource::GetPlayerColor(int index )
{
if ( !IsConnected( index ) )
return g_ColorWhite;
if (SDKGameRules()->GetMatchDisplayTimeSeconds(true, false) < GetNextCardJoin(index))
return g_ColorRed;
if (GetYellowCards(index) % 2 == 1)
return g_ColorYellow;
if (GetTeam(index) == TEAM_SPECTATOR)
return GetGlobalTeam(GetSpecTeam(index))->GetHudKitColor();
return GetGlobalTeam(GetTeam(index))->GetHudKitColor();
}
void CSDKPlayer::UpdateCurrentTime()
{
m_flCurrentTime += gpGlobals->frametime * GetSlowMoMultiplier();
m_flSlowMoMultiplier = Approach(GetSlowMoGoal(), m_flSlowMoMultiplier, gpGlobals->frametime*2);
if (m_flSlowMoTime > 0 && gpGlobals->curtime > m_flSlowMoTime)
{
m_flSlowMoTime = 0;
m_iSlowMoType = SLOWMO_NONE;
#ifdef GAME_DLL
SDKGameRules()->PlayerSlowMoUpdate(this);
#endif
}
UpdateViewBobRamp();
}
void CSDKPlayer::ActivateSlowMo()
{
if (!m_flSlowMoSeconds)
return;
m_flSlowMoTime = gpGlobals->curtime + m_flSlowMoSeconds + 0.5f; // 1 second becomes 1.5 seconds, 2 becomes 2.5, etc
m_flSlowMoSeconds = 0;
m_iSlowMoType = m_bHasSuperSlowMo?SLOWMO_STYLESKILL:SLOWMO_ACTIVATED;
#ifdef GAME_DLL
SDKGameRules()->PlayerSlowMoUpdate(this);
if (m_bHasSuperSlowMo || m_flSlowMoTime > 3)
CDove::SpawnDoves(this);
#endif
ReadyWeapon();
}
void CSDKPlayer::MoveToTargetPos(Vector &pos, Vector &vel, QAngle &ang)
{
Vector dir = m_vTargetPos - pos;
dir.z = 0;
float distToTarget = dir.Length2D();
dir.NormalizeInPlace();
VectorAngles(dir, ang);
float wishDist = mp_remotecontrolledspeed.GetInt() * gpGlobals->frametime;
vel = dir * mp_remotecontrolledspeed.GetInt();
pos = pos + vel * gpGlobals->frametime;
pos.z = SDKGameRules()->m_vKickOff.GetZ();
if (wishDist >= distToTarget)
{
trace_t trace;
UTIL_TraceHull(m_vTargetPos, m_vTargetPos, GetPlayerMins(), GetPlayerMaxs(), MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER, &trace);
if (trace.startsolid)
{
m_vTargetPos = pos + dir * (GetPlayerMaxs().x - GetPlayerMins().x);
}
else
{
m_bIsAtTargetPos = true;
RemoveFlag(FL_REMOTECONTROLLED);
//RemoveSolidFlags(FSOLID_NOT_SOLID);
SetCollisionGroup(COLLISION_GROUP_PLAYER);
if (m_bHoldAtTargetPos)
AddFlag(FL_ATCONTROLS);
//#ifdef GAME_DLL
// if (ShotButtonsPressed())
// m_bShotButtonsReleased = false;
//#endif
pos = m_vTargetPos;
vel = vec3_origin;
}
}
}
void C_Camera::CalcTVCamView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
{
if (!GetMatchBall())
return;
C_BaseEntity *pTarget;
bool atMinGoalPos;
Vector targetPos;
int tvcamMode = GetTVCamMode();
if (GetReplayManager() && GetReplayManager()->IsReplaying())
{
pTarget = GetReplayBall();
if (!pTarget)
return;
atMinGoalPos = GetReplayManager()->m_bAtMinGoalPos;
targetPos = pTarget->GetLocalOrigin();
}
else
{
if (GetMatchBall() && GetMatchBall()->m_eBallState == BALL_STATE_GOAL)
{
pTarget = GetMatchBall()->m_pLastActivePlayer;
if (!pTarget)
pTarget = GetMatchBall();
atMinGoalPos = pTarget->GetLocalOrigin().y < SDKGameRules()->m_vKickOff.GetY();
targetPos = pTarget->GetLocalOrigin();
}
else
{
pTarget = CBasePlayer::GetLocalPlayer()->GetObserverTarget();
if (!pTarget)
pTarget = GetMatchBall();
atMinGoalPos = pTarget->GetLocalOrigin().y < SDKGameRules()->m_vKickOff.GetY();
targetPos = pTarget->GetLocalOrigin();
// Move the camera towards the defending team's goal
if (GetMatchBall()->m_nLastActiveTeam != TEAM_NONE)
{
if (m_nLastPossessingTeam == TEAM_NONE)
{
m_nLastPossessingTeam = GetMatchBall()->m_nLastActiveTeam;
m_flLastPossessionChange = gpGlobals->curtime;
m_flPossCoeff = 0;
m_flOldPossCoeff = 0;
}
else
{
if (GetMatchBall()->m_nLastActiveTeam != m_nLastPossessingTeam)
{
m_nLastPossessingTeam = GetMatchBall()->m_nLastActiveTeam;
m_flLastPossessionChange = gpGlobals->curtime;
m_flOldPossCoeff = m_flPossCoeff;
}
float timeFrac = min(1.0f, (gpGlobals->curtime - m_flLastPossessionChange) / mp_tvcam_offset_forward_time.GetFloat());
float frac = pow(timeFrac, 2) * (3 - 2 * timeFrac);
m_flPossCoeff = Lerp(frac, m_flOldPossCoeff, (float)GetGlobalTeam(GetMatchBall()->m_nLastActiveTeam)->m_nForward);
}
if (tvcamMode == TVCAM_MODE_SIDELINE)
{
targetPos.y += m_flPossCoeff * mp_tvcam_offset_forward.GetInt();
}
}
}
}
if (tvcamMode != TVCAM_MODE_CELEBRATION)
{
// Make sure the camera doesn't move too far away from the field borders
targetPos.x = clamp(targetPos.x, SDKGameRules()->m_vFieldMin.GetX() + mp_tvcam_border_south.GetInt(), SDKGameRules()->m_vFieldMax.GetX() - mp_tvcam_border_north.GetInt());
targetPos.y = clamp(targetPos.y, SDKGameRules()->m_vFieldMin.GetY() + mp_tvcam_border_west.GetInt(), SDKGameRules()->m_vFieldMax.GetY() - mp_tvcam_border_east.GetInt());
targetPos.z = SDKGameRules()->m_vKickOff.GetZ();
}
if (m_vOldTargetPos == vec3_invalid)
m_vOldTargetPos = targetPos;
else
{
float speedCoeff = tvcamMode == TVCAM_MODE_CELEBRATION ? mp_tvcam_speed_coeff_fast.GetFloat() : mp_tvcam_speed_coeff.GetFloat();
float speedExp = tvcamMode == TVCAM_MODE_CELEBRATION ? mp_tvcam_speed_exponent_fast.GetFloat() : mp_tvcam_speed_exponent.GetFloat();
Vector changeDir = targetPos - m_vOldTargetPos;
float changeDist = changeDir.Length();
changeDir.NormalizeInPlace();
targetPos = m_vOldTargetPos + changeDir * min(changeDist, pow(changeDist * speedCoeff, speedExp) * gpGlobals->frametime);
}
switch (GetTVCamMode())
{
case TVCAM_MODE_SIDELINE:
{
if (SDKGameRules() && SDKGameRules()->IsIntermissionState() && GetReplayManager() && !GetReplayManager()->IsReplaying())
{
//float xLength = SDKGameRules()->m_vFieldMax.GetX() - SDKGameRules()->m_vFieldMin.GetX();
//float yLength = SDKGameRules()->m_vFieldMax.GetY() - SDKGameRules()->m_vFieldMin.GetY();
float zPos = 450;
Vector points[4];
points[0] = Vector(SDKGameRules()->m_vFieldMin.GetX(), SDKGameRules()->m_vFieldMin.GetY(), SDKGameRules()->m_vKickOff.GetZ() + zPos);
points[1] = Vector(SDKGameRules()->m_vFieldMin.GetX(), SDKGameRules()->m_vFieldMax.GetY(), SDKGameRules()->m_vKickOff.GetZ() + zPos);
points[2] = Vector(SDKGameRules()->m_vFieldMax.GetX(), SDKGameRules()->m_vFieldMax.GetY(), SDKGameRules()->m_vKickOff.GetZ() + zPos);
points[3] = Vector(SDKGameRules()->m_vFieldMax.GetX(), SDKGameRules()->m_vFieldMin.GetY(), SDKGameRules()->m_vKickOff.GetZ() + zPos);
float totalLength = (points[1] - points[0]).Length() + (points[2] - points[1]).Length() + (points[3] - points[2]).Length() + (points[0] - points[3]).Length();
Vector newPoints[4];
const float maxDuration = 180.0f;
float timePassed = fmodf(gpGlobals->curtime, maxDuration);
float lengthSum = 0;
int offset = 0;
float length = 0;
do
{
for (int i = 0; i < 4; i++)
newPoints[i] = points[(i + offset) % 4];
length = (newPoints[2] - newPoints[1]).Length();
lengthSum += length;
offset += 1;
} while (timePassed > (lengthSum / totalLength * maxDuration));
float maxStepTime = length / totalLength * maxDuration;
float frac = 1 - ((lengthSum / totalLength * maxDuration) - timePassed) / maxStepTime;
Vector output;
Catmull_Rom_Spline(newPoints[0], newPoints[1], newPoints[2], newPoints[3], frac, output);
/* float targetDist = (newPoints[2] - newPoints[1]).Length() * frac;
float epsilon = 10.0f;
float oldDiff = 0;
float diff = 0;
float change = 0.001f;
bool add = true;
do
{
frac = clamp(frac += (add ? change : -change), 0.0f, 1.0f);
Catmull_Rom_Spline(newPoints[0], newPoints[1], newPoints[2], newPoints[3], frac, output);
oldDiff = diff;
diff = abs((output - newPoints[1]).Length() - targetDist);
if (diff >= oldDiff)
add = !add;
} while (diff > epsilon);*/
eyeOrigin = output;
VectorAngles(SDKGameRules()->m_vKickOff - output, eyeAngles);
}
/*else if (SDKGameRules() && !SDKGameRules()->IsIntermissionState() && gpGlobals->curtime <= SDKGameRules()->m_flStateEnterTime + 4)
{
Vector points[4];
float zPosStart = 450;
float zPosEnd = 50;
points[0] = Vector(SDKGameRules()->m_vFieldMin.GetX(), SDKGameRules()->m_vKickOff.GetY() + 10000, SDKGameRules()->m_vKickOff.GetZ() + zPosStart);
points[1] = Vector(SDKGameRules()->m_vFieldMin.GetX(), SDKGameRules()->m_vKickOff.GetY(), SDKGameRules()->m_vKickOff.GetZ() + zPosStart);
points[2] = Vector(SDKGameRules()->m_vKickOff.GetX(), SDKGameRules()->m_vKickOff.GetY() - 300, SDKGameRules()->m_vKickOff.GetZ() + zPosEnd);
points[3] = Vector(SDKGameRules()->m_vKickOff.GetX(), SDKGameRules()->m_vKickOff.GetY() + 10000, SDKGameRules()->m_vKickOff.GetZ() + zPosEnd);
float frac = min(1.0f, (gpGlobals->curtime - SDKGameRules()->m_flStateEnterTime) / 3.0f);
Vector output;
Catmull_Rom_Spline(points[0], points[1], points[2], points[3], frac, output);
eyeOrigin = output;
VectorAngles(Vector(SDKGameRules()->m_vKickOff.GetX(), SDKGameRules()->m_vKickOff.GetY(), SDKGameRules()->m_vKickOff.GetZ() + 100) - output, eyeAngles);
}*/
else
{
Vector newPos = Vector(targetPos.x - mp_tvcam_sideline_offset_north.GetInt(), targetPos.y, targetPos.z + mp_tvcam_sideline_offset_height.GetInt());
Vector offsetTargetPos = Vector(targetPos.x - mp_tvcam_offset_north.GetInt(), targetPos.y, targetPos.z);
Vector newDir = offsetTargetPos - newPos;
newDir.NormalizeInPlace();
eyeOrigin = newPos;
VectorAngles(newDir, eyeAngles);
}
}
break;
case TVCAM_MODE_FIXED_SIDELINE:
{
Vector newPos = Vector(SDKGameRules()->m_vFieldMin.GetX() - 500, SDKGameRules()->m_vKickOff.GetY(), SDKGameRules()->m_vKickOff.GetZ() + 1000);
Vector offsetTargetPos = Vector(targetPos.x - 500, targetPos.y, targetPos.z);
Vector newDir = offsetTargetPos - newPos;
float dist = newDir.Length();
newDir.NormalizeInPlace();
newPos = offsetTargetPos - min(750, dist) * newDir;
eyeOrigin = newPos;
VectorAngles(newDir, eyeAngles);
}
break;
case TVCAM_MODE_BEHIND_GOAL:
{
float yPos = atMinGoalPos ? SDKGameRules()->m_vFieldMin.GetY() : SDKGameRules()->m_vFieldMax.GetY();
Vector goalCenter = Vector((SDKGameRules()->m_vFieldMin.GetX() + SDKGameRules()->m_vFieldMax.GetX()) / 2.0f, yPos, SDKGameRules()->m_vKickOff.GetZ());
Vector newPos = goalCenter + Vector(0, 300 * (atMinGoalPos ? -1 : 1), 300);
Vector newDir = targetPos - newPos;
newDir.NormalizeInPlace();
eyeOrigin = newPos;
VectorAngles(newDir, eyeAngles);
}
break;
case TVCAM_MODE_TOPDOWN:
{
eyeOrigin = Vector(targetPos.x, targetPos.y, SDKGameRules()->m_vKickOff.GetZ() + 1000);
eyeAngles = QAngle(89, 0, 0);
}
break;
case TVCAM_MODE_FLY_FOLLOW:
{
Vector newPos = Vector(targetPos.x, targetPos.y + (atMinGoalPos ? 1 : -1) * 500, SDKGameRules()->m_vKickOff.GetZ() + 225);
Vector newDir = targetPos - newPos;
newDir.NormalizeInPlace();
eyeOrigin = newPos;
VectorAngles(newDir, eyeAngles);
}
break;
case TVCAM_MODE_GOAL_LINE:
{
Vector center = Vector(SDKGameRules()->m_vKickOff.GetX(), (atMinGoalPos ? SDKGameRules()->m_vFieldMin.GetY() + 5 : SDKGameRules()->m_vFieldMax.GetY() - 5), SDKGameRules()->m_vKickOff.GetZ());
Vector newPos = center;
newPos.x -= 350;
newPos.z += 200;
QAngle newAng;
VectorAngles(center - newPos, newAng);
eyeOrigin = newPos;
eyeAngles = newAng;
}
break;
case TVCAM_MODE_CELEBRATION:
{
Vector newPos = Vector(
targetPos.x < SDKGameRules()->m_vKickOff.GetX() ? SDKGameRules()->m_vFieldMin.GetX() - 500 : SDKGameRules()->m_vFieldMax.GetX() + 500,
targetPos.y < SDKGameRules()->m_vKickOff.GetY() ? SDKGameRules()->m_vFieldMin.GetY() - 500 : SDKGameRules()->m_vFieldMax.GetY() + 500,
SDKGameRules()->m_vKickOff.GetZ() + 1000);
Vector newDir = targetPos - newPos;
float dist = newDir.Length();
newDir.NormalizeInPlace();
newPos = targetPos - min(300, dist) * newDir;
eyeOrigin = newPos;
VectorAngles(newDir, eyeAngles);
}
break;
}
m_vOldTargetPos = targetPos;
fov = C_SDKPlayer::GetLocalSDKPlayer()->GetFOV();
}
// returns true if the selection has been handled and the player's menu
// can be closed...false if the menu should be displayed again
bool CSDKPlayer::HandleCommand_JoinTeam( int team )
{
CSDKGameRules *mp = SDKGameRules();
int iOldTeam = GetTeamNumber();
if ( !GetGlobalTeam( team ) )
{
Warning( "HandleCommand_JoinTeam( %d ) - invalid team index.\n", team );
return false;
}
#if defined ( SDK_USE_TEAMS )
// If we already died and changed teams once, deny
if( m_bTeamChanged && team != TEAM_SPECTATOR && iOldTeam != TEAM_SPECTATOR )
{
ClientPrint( this, HUD_PRINTCENTER, "game_switch_teams_once" );
return true;
}
#endif
if ( team == TEAM_UNASSIGNED )
{
// Attempt to auto-select a team, may set team to T, CT or SPEC
team = mp->SelectDefaultTeam();
if ( team == TEAM_UNASSIGNED )
{
// still team unassigned, try to kick a bot if possible
ClientPrint( this, HUD_PRINTTALK, "#All_Teams_Full" );
team = TEAM_SPECTATOR;
}
}
if ( team == iOldTeam )
return true; // we wouldn't change the team
#if defined ( SDK_USE_TEAMS )
if ( mp->TeamFull( team ) )
{
if ( team == SDK_TEAM_BLUE )
{
ClientPrint( this, HUD_PRINTTALK, "#BlueTeam_Full" );
}
else if ( team == SDK_TEAM_RED )
{
ClientPrint( this, HUD_PRINTTALK, "#RedTeam_Full" );
}
ShowViewPortPanel( PANEL_TEAM );
return false;
}
#endif
if ( team == TEAM_SPECTATOR )
{
// Prevent this if the cvar is set
if ( !mp_allowspectators.GetInt() && !IsHLTV() )
{
ClientPrint( this, HUD_PRINTTALK, "#Cannot_Be_Spectator" );
ShowViewPortPanel( PANEL_TEAM );
return false;
}
ChangeTeam( TEAM_SPECTATOR );
return true;
}
// If the code gets this far, the team is not TEAM_UNASSIGNED
// Player is switching to a new team (It is possible to switch to the
// same team just to choose a new appearance)
#if defined ( SDK_USE_TEAMS )
if (mp->TeamStacked( team, GetTeamNumber() ))//players are allowed to change to their own team so they can just change their model
{
// The specified team is full
ClientPrint(
this,
HUD_PRINTCENTER,
( team == SDK_TEAM_BLUE ) ? "#BlueTeam_full" : "#RedTeam_full" );
ShowViewPortPanel( PANEL_TEAM );
return false;
}
#endif
// Switch their actual team...
ChangeTeam( team );
#if defined ( SDK_USE_PLAYERCLASSES )
// Force them to choose a new class
m_Shared.SetDesiredPlayerClass( PLAYERCLASS_UNDEFINED );
m_Shared.SetPlayerClass( PLAYERCLASS_UNDEFINED );
#endif
return true;
}
Formation *C_Team::GetFormation()
{
// FIXME: Clamping this to avoid problems when mp_maxplayers is lowered, since mp_maxplayers seems to get synced before other variables do
return SDKGameRules()->GetFormations()[clamp(m_nFormationIndex, 0, SDKGameRules()->GetFormations().Count() - 1)];
}
void CPlayerBall::State_KEEPERHANDS_Think()
{
int wasOrIsinPenBoxOfTeam = m_nInPenBoxOfTeam != TEAM_NONE ? m_nInPenBoxOfTeam : m_nWasInPenBoxOfTeam;
if (!CSDKPlayer::IsOnField(m_pPl, wasOrIsinPenBoxOfTeam))
{
m_pPl = GetGlobalTeam(wasOrIsinPenBoxOfTeam)->GetPlayerByPosType(POS_GK);
if (!m_pPl)
return State_Transition(BALL_STATE_NORMAL);
m_pPl->SetShotButtonsReleased(false);
m_pHoldingPlayer = m_pPl;
m_pPl->m_pHoldingBall = this;
m_pPl->DoServerAnimationEvent(PLAYERANIMEVENT_CARRY);
EnablePlayerCollisions(false);
}
UpdateCarrier();
Vector min = GetGlobalTeam(m_pPl->GetTeamNumber())->m_vPenBoxMin - Vector(BALL_PHYS_RADIUS, BALL_PHYS_RADIUS, 0);
Vector max = GetGlobalTeam(m_pPl->GetTeamNumber())->m_vPenBoxMax + Vector(BALL_PHYS_RADIUS, BALL_PHYS_RADIUS, 0);
// Ball outside the penalty box
if (m_nInPenBoxOfTeam == TEAM_NONE)
{
Vector vel, pos;
// Throw the ball towards the kick-off spot if it's behind the goal line and either would end up inside the goal or is in a map with a walled field
if ((m_pPl->GetTeam()->m_nForward == 1 && m_vPos.y < min.y || m_pPl->GetTeam()->m_nForward == -1 && m_vPos.y > max.y)
&& (SDKGameRules()->HasWalledField()
|| (m_vPos.x >= m_pPl->GetTeam()->m_vGoalCenter.GetX() - SDKGameRules()->m_vGoalTriggerSize.x
&& m_vPos.x <= m_pPl->GetTeam()->m_vGoalCenter.GetX() + SDKGameRules()->m_vGoalTriggerSize.x)))
{
pos = Vector(m_vPos.x, (m_pPl->GetTeam()->m_nForward == 1 ? SDKGameRules()->m_vFieldMin.GetY() - BALL_PHYS_RADIUS : SDKGameRules()->m_vFieldMax.GetY() + BALL_PHYS_RADIUS) + m_pPl->GetTeam()->m_nForward * 36, m_vPos.z);
vel = 25 * Vector(0, m_pPl->GetTeam()->m_nForward, 0);
}
else
{
pos = m_vPos;
vel = m_vPlVel;
}
SetPos(pos, false);
SetVel(vel, 0, FL_SPIN_FORCE_NONE, BODY_PART_KEEPERHANDS, true, sv_ball_shottaker_mindelay_short.GetFloat(), true);
return State_Transition(BALL_STATE_NORMAL);
}
Vector handPos;
QAngle handAng;
m_pPl->GetAttachment("keeperballrighthand", handPos, handAng);
SetPos(handPos, false);
SetAng(handAng);
if (m_pPl->ShotButtonsReleased() && m_pPl->IsChargedshooting() && m_pPl->CanShoot())
{
Vector vel;
int spinFlags;
PlayerAnimEvent_t animEvent;
if (m_aPlAng[PITCH] > sv_ball_keepershot_minangle.GetInt())
{
Vector dir;
AngleVectors(m_aPlAng, &dir);
vel = m_vPlForwardVel2D + dir * sv_ball_keeperthrow_strength.GetInt();
spinFlags = FL_SPIN_FORCE_NONE;
animEvent = PLAYERANIMEVENT_KEEPER_HANDS_THROW;
}
else
{
QAngle ang = m_aPlAng;
ang[PITCH] = min(sv_ball_keepershot_minangle.GetFloat(), m_aPlAng[PITCH]);
Vector dir;
AngleVectors(m_aPlAng, &dir);
vel = dir * GetChargedshotStrength(GetPitchCoeff(), sv_ball_chargedshot_minstrength.GetInt(), sv_ball_chargedshot_maxstrength.GetInt());
spinFlags = FL_SPIN_PERMIT_SIDE;
animEvent = PLAYERANIMEVENT_KEEPER_HANDS_KICK;
if (vel.Length() > 1000)
EmitSound("Ball.Kickhard");
else
EmitSound("Ball.Kicknormal");
}
m_pPl->DoServerAnimationEvent(animEvent);
RemoveAllTouches();
SetPos(Vector(m_vPlPos.x, m_vPlPos.y, m_vPlPos.z + sv_ball_bodypos_keeperhands.GetFloat()) + m_vPlForward2D * 36, false);
SetVel(vel, 1.0f, spinFlags, BODY_PART_KEEPERHANDS, true, sv_ball_shottaker_mindelay_short.GetFloat(), true);
return State_Transition(BALL_STATE_NORMAL);
}
}
void CReplayManager::RestoreSnapshot()
{
float watchDuration = gpGlobals->curtime - m_flReplayStartTime;
if (watchDuration > m_flRunDuration)
{
if (m_nReplayRunIndex < m_nMaxReplayRuns - 1)
{
m_nReplayRunIndex += 1;
m_bIsReplayStart = true;
}
else if (m_bIsHighlightReplay)
{
m_nReplayIndex = FindNextHighlightReplayIndex(m_nReplayIndex + 1, SDKGameRules()->State_Get());
if (m_nReplayIndex == -1)
{
StopReplay();
return;
}
m_nReplayRunIndex = 0;
m_bIsReplayStart = true;
m_bIsHighlightStart = true;
}
else
{
StopReplay();
return;
}
}
MatchEvent *pMatchEvent = m_MatchEvents[m_nReplayIndex];
if (m_bIsReplayStart)
{
m_bIsReplayStart = false;
m_bAtMinGoalPos = pMatchEvent->atMinGoalPos;
m_bIsReplaying = true;
m_bReplayIsPending = false;
CalcMaxReplayRunsAndDuration(pMatchEvent, gpGlobals->curtime);
watchDuration = 0;
if (m_bIsHighlightReplay && m_bIsHighlightStart)
{
m_bIsHighlightStart = false;
if (pMatchEvent->matchEventType == MATCH_EVENT_GOAL)
{
IGameEvent *pEvent = gameeventmanager->CreateEvent("highlight_goal");
if (pEvent)
{
pEvent->SetInt("second", pMatchEvent->second);
pEvent->SetInt("match_period", pMatchEvent->matchPeriod);
pEvent->SetInt("scoring_team", pMatchEvent->team);
pEvent->SetString("scorer", pMatchEvent->pPlayer1Data ? pMatchEvent->pPlayer1Data->m_szName : "");
pEvent->SetString("first_assister", pMatchEvent->pPlayer2Data ? pMatchEvent->pPlayer2Data->m_szName : "");
pEvent->SetString("second_assister", pMatchEvent->pPlayer3Data ? pMatchEvent->pPlayer3Data->m_szName : "");
gameeventmanager->FireEvent(pEvent);
}
}
else if (pMatchEvent->matchEventType == MATCH_EVENT_OWNGOAL)
{
IGameEvent *pEvent = gameeventmanager->CreateEvent("highlight_owngoal");
if (pEvent)
{
pEvent->SetInt("second", pMatchEvent->second);
pEvent->SetInt("match_period", pMatchEvent->matchPeriod);
pEvent->SetInt("scoring_team", pMatchEvent->team);
pEvent->SetString("scorer", pMatchEvent->pPlayer1Data ? pMatchEvent->pPlayer1Data->m_szName : "");
gameeventmanager->FireEvent(pEvent);
}
}
else if (pMatchEvent->matchEventType == MATCH_EVENT_MISS)
{
IGameEvent *pEvent = gameeventmanager->CreateEvent("highlight_miss");
if (pEvent)
{
pEvent->SetInt("second", pMatchEvent->second);
pEvent->SetInt("match_period", pMatchEvent->matchPeriod);
pEvent->SetInt("finishing_team", pMatchEvent->team);
pEvent->SetString("finisher", pMatchEvent->pPlayer1Data ? pMatchEvent->pPlayer1Data->m_szName : "");
pEvent->SetString("first_assister", pMatchEvent->pPlayer2Data ? pMatchEvent->pPlayer2Data->m_szName : "");
pEvent->SetString("second_assister", pMatchEvent->pPlayer3Data ? pMatchEvent->pPlayer3Data->m_szName : "");
gameeventmanager->FireEvent(pEvent);
}
}
else if (pMatchEvent->matchEventType == MATCH_EVENT_KEEPERSAVE)
{
IGameEvent *pEvent = gameeventmanager->CreateEvent("highlight_keepersave");
if (pEvent)
{
pEvent->SetInt("second", pMatchEvent->second);
pEvent->SetInt("match_period", pMatchEvent->matchPeriod);
pEvent->SetInt("keeper_team", pMatchEvent->team);
pEvent->SetString("keeper", pMatchEvent->pPlayer1Data ? pMatchEvent->pPlayer1Data->m_szName : "");
pEvent->SetString("finisher", pMatchEvent->pPlayer2Data ? pMatchEvent->pPlayer2Data->m_szName : "");
gameeventmanager->FireEvent(pEvent);
}
}
else if (pMatchEvent->matchEventType == MATCH_EVENT_REDCARD)
{
IGameEvent *pEvent = gameeventmanager->CreateEvent("highlight_redcard");
if (pEvent)
{
pEvent->SetInt("second", pMatchEvent->second);
pEvent->SetInt("match_period", pMatchEvent->matchPeriod);
pEvent->SetInt("fouling_team", pMatchEvent->team);
pEvent->SetString("fouling_player", pMatchEvent->pPlayer1Data ? pMatchEvent->pPlayer1Data->m_szName : "");
gameeventmanager->FireEvent(pEvent);
}
}
}
}
CBall *pRealBall = GetMatchBall();
if (pRealBall && !(pRealBall->GetEffects() & EF_NODRAW))
{
pRealBall->AddEffects(EF_NODRAW);
pRealBall->AddSolidFlags(FSOLID_NOT_SOLID);
}
for (int i = 1; i <= gpGlobals->maxClients; i++)
{
CSDKPlayer *pRealPl = ToSDKPlayer(UTIL_PlayerByIndex(i));
if (!CSDKPlayer::IsOnField(pRealPl))
continue;
if (!(pRealPl->GetEffects() & EF_NODRAW))
{
pRealPl->AddEffects(EF_NODRAW);
pRealPl->DoServerAnimationEvent(PLAYERANIMEVENT_CANCEL);
pRealPl->AddSolidFlags(FSOLID_NOT_SOLID);
pRealPl->SetMoveType(MOVETYPE_NONE);
}
if (pRealPl->GetPlayerBall() && !(pRealPl->GetPlayerBall()->GetEffects() & EF_NODRAW))
{
pRealPl->GetPlayerBall()->AddEffects(EF_NODRAW);
pRealPl->GetPlayerBall()->AddSolidFlags(FSOLID_NOT_SOLID);
}
}
float normalRunDuration = m_flRunDuration - m_flSlowMoDuration;
if (watchDuration > normalRunDuration)
watchDuration = normalRunDuration + m_flSlowMoCoeff * (watchDuration - normalRunDuration);
// To find the correct snapshot calculate the time passed since we started watching the replay and match it to the right snapshot in our recording list
Snapshot *pNextSnap = NULL;
Snapshot *pSnap = NULL;
float snapDuration = 0;
// Traverse backwards looking for a recorded snapshot matching the time since replay start
for (int i = pMatchEvent->snapshots.Count() - 1; i >= 0; i--)
{
// Save the snapshot of the previous iteration, so we have a snapshot to interpolate to when we found our target snapshot
pNextSnap = pSnap;
// Save the current snapshot
pSnap = pMatchEvent->snapshots[i];
// Snapshots have absolute match times, so calculate the relative time span between the first recorded snapshot and the current snapshot
snapDuration = pSnap->snaptime - pMatchEvent->snapshots[0]->snaptime - m_flReplayStartTimeOffset;
// We usually only play the last x seconds of a replay instead of the whole thing, so subtract the start time offset from the time since the first snapshot.
// The first snapshot which time span is equal or shorter than the duration since replay start is the one which should be shown next.
if (snapDuration <= watchDuration)
break;
}
// No snapshots in the list
if (!pSnap)
return;
float nextSnapDuration;
if (pNextSnap)
nextSnapDuration = pNextSnap->snaptime - pMatchEvent->snapshots[0]->snaptime - m_flReplayStartTimeOffset;
else
nextSnapDuration = 0;
BallSnapshot *pBallSnap = pSnap->pBallSnapshot;
if (pBallSnap)
{
if (!m_pBall)
{
m_pBall = (CReplayBall *)CreateEntityByName("replayball");
m_pBall->Spawn();
}
if (Q_strcmp(m_pBall->m_szSkinName, GetMatchBall()->GetSkinName()))
Q_strncpy(m_pBall->m_szSkinName.GetForModify(), GetMatchBall()->GetSkinName(), MAX_KITNAME_LENGTH);
m_pBall->VPhysicsGetObject()->SetPosition(pBallSnap->pos, pBallSnap->ang, false);
m_pBall->VPhysicsGetObject()->SetVelocity(&pBallSnap->vel, &pBallSnap->rot);
}
else
{
UTIL_Remove(m_pBall);
m_pBall = NULL;
}
float frac;
if (pNextSnap)
{
// Calc fraction between both snapshots
frac = clamp((watchDuration - snapDuration) / (nextSnapDuration - snapDuration), 0.0f, 1.0f);
}
else
{
// Exact snapshot time matched or no next snapshot to interpolate to
frac = 0.0f;
}
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 11; j++)
{
PlayerSnapshot *pPlSnap = pSnap->pPlayerSnapshot[i][j];
if (!pPlSnap)
{
UTIL_Remove(m_pPlayers[i][j]);
m_pPlayers[i][j] = NULL;
continue;
}
if (!m_pPlayers[i][j])
{
m_pPlayers[i][j] = (CReplayPlayer *)CreateEntityByName("replayplayer");
m_pPlayers[i][j]->Spawn();
m_pPlayers[i][j]->SetNumAnimOverlays(NUM_LAYERS_WANTED);
}
CReplayPlayer *pPl = m_pPlayers[i][j];
pPl->m_nTeamNumber = pPlSnap->teamNumber;
pPl->m_nTeamPosIndex = pPlSnap->teamPosIndex;
pPl->m_bIsKeeper = pPlSnap->isKeeper;
pPl->m_nShirtNumber = pPlSnap->shirtNumber;
if (Q_strcmp(pPl->m_szPlayerName, pPlSnap->pPlayerData->m_szName))
Q_strncpy(pPl->m_szPlayerName.GetForModify(), pPlSnap->pPlayerData->m_szName, MAX_PLAYER_NAME_LENGTH);
if (Q_strcmp(pPl->m_szShirtName, pPlSnap->pPlayerData->m_szShirtName))
Q_strncpy(pPl->m_szShirtName.GetForModify(), pPlSnap->pPlayerData->m_szShirtName, MAX_PLAYER_NAME_LENGTH);
pPl->m_nSkinIndex = pPlSnap->skinIndex;
pPl->m_nBody = pPlSnap->body;
PlayerSnapshot *pNextPlSnap = NULL;
if (pNextSnap)
pNextPlSnap = pNextSnap->pPlayerSnapshot[i][j];
if (frac > 0.0f && pNextPlSnap)
{
pPl->SetLocalOrigin(Lerp( frac, pPlSnap->pos, pNextPlSnap->pos ));
//pPl->SetLocalVelocity(Lerp( frac, pPlSnap->vel, pNextPlSnap->vel ));
pPl->SetLocalAngles(Lerp( frac, pPlSnap->ang, pNextPlSnap->ang ));
}
else
{
pPl->SetLocalOrigin(pPlSnap->pos);
//pPl->SetLocalVelocity(pPlSnap->vel);
pPl->SetLocalAngles(pPlSnap->ang);
}
bool interpolationAllowed;
if (frac > 0.0f && pNextPlSnap && pPlSnap->masterSequence == pNextPlSnap->masterSequence)
{
// If the master state changes, all layers will be invalid too, so don't interp (ya know, interp barely ever happens anyway)
interpolationAllowed = true;
}
else
interpolationAllowed = false;
// First do the master settings
if (interpolationAllowed)
{
pPl->SetSequence( Lerp( frac, pPlSnap->masterSequence, pNextPlSnap->masterSequence ) );
pPl->SetCycle( Lerp( frac, pPlSnap->masterCycle, pNextPlSnap->masterCycle ) );
if( pPlSnap->masterCycle > pNextPlSnap->masterCycle )
{
// the older record is higher in frame than the newer, it must have wrapped around from 1 back to 0
// add one to the newer so it is lerping from .9 to 1.1 instead of .9 to .1, for example.
float newCycle = Lerp( frac, pPlSnap->masterCycle, pNextPlSnap->masterCycle + 1 );
pPl->SetCycle(newCycle < 1 ? newCycle : newCycle - 1 );// and make sure .9 to 1.2 does not end up 1.05
}
else
{
pPl->SetCycle( Lerp( frac, pPlSnap->masterCycle, pNextPlSnap->masterCycle ) );
}
pPl->SetPoseParameter(pPl->GetModelPtr(), 4, Lerp(frac, pPlSnap->moveX, pNextPlSnap->moveX));
pPl->SetPoseParameter(pPl->GetModelPtr(), 3, Lerp(frac, pPlSnap->moveY, pNextPlSnap->moveY));
}
else
{
pPl->SetSequence(pPlSnap->masterSequence);
pPl->SetCycle(pPlSnap->masterCycle);
pPl->SetPoseParameter(pPl->GetModelPtr(), 4, pPlSnap->moveX);
pPl->SetPoseParameter(pPl->GetModelPtr(), 3, pPlSnap->moveY);
}
// Now do all the layers
for (int layerIndex = 0; layerIndex < NUM_LAYERS_WANTED; layerIndex++)
{
CAnimationLayer *pTargetLayer = pPl->GetAnimOverlay(layerIndex);
if(!pTargetLayer)
continue;
LayerRecord *pSourceLayer = &pPlSnap->layerRecords[layerIndex];
pTargetLayer->m_nOrder = pSourceLayer->order;
pTargetLayer->m_nSequence = pSourceLayer->sequence;
pTargetLayer->m_flPlaybackRate = pSourceLayer->playbackRate;
pTargetLayer->m_fFlags = pSourceLayer->flags;
pTargetLayer->m_bLooping = pSourceLayer->looping;
pTargetLayer->m_bSequenceFinished = pSourceLayer->sequenceFinished;
pTargetLayer->m_nPriority = pSourceLayer->priority;
pTargetLayer->m_nActivity = pSourceLayer->activity;
pTargetLayer->m_flLastAccess = pSourceLayer->lastAccess;
pTargetLayer->m_flLastEventCheck = pSourceLayer->lastEventCheck;
if (interpolationAllowed)
{
LayerRecord *pNextSourceLayer = &pNextPlSnap->layerRecords[layerIndex];
if(pSourceLayer->order == pNextSourceLayer->order && pSourceLayer->sequence == pNextSourceLayer->sequence)
{
// We can't interpolate across a sequence or order change
if( pSourceLayer->cycle > pNextSourceLayer->cycle )
{
// the older record is higher in frame than the newer, it must have wrapped around from 1 back to 0
// add one to the newer so it is lerping from .9 to 1.1 instead of .9 to .1, for example.
float newCycle = Lerp( frac, pSourceLayer->cycle, pNextSourceLayer->cycle + 1 );
pTargetLayer->m_flCycle = newCycle < 1 ? newCycle : newCycle - 1;// and make sure .9 to 1.2 does not end up 1.05
}
else
{
pTargetLayer->m_flCycle = Lerp(frac, pSourceLayer->cycle, pNextSourceLayer->cycle);
}
pTargetLayer->m_flWeight = Lerp(frac, pSourceLayer->weight, pNextSourceLayer->weight);
pTargetLayer->m_flLayerAnimtime = Lerp(frac, pSourceLayer->layerAnimtime, pNextSourceLayer->layerAnimtime);
pTargetLayer->m_flBlendIn = Lerp(frac, pSourceLayer->blendIn, pNextSourceLayer->blendIn);
pTargetLayer->m_flBlendOut = Lerp(frac, pSourceLayer->blendOut, pNextSourceLayer->blendOut);
pTargetLayer->m_flPrevCycle = Lerp(frac, pSourceLayer->prevCycle, pNextSourceLayer->prevCycle);
pTargetLayer->m_flKillDelay = Lerp(frac, pSourceLayer->killDelay, pNextSourceLayer->killDelay);
pTargetLayer->m_flKillRate = Lerp(frac, pSourceLayer->killRate, pNextSourceLayer->killRate);
pTargetLayer->m_flLayerFadeOuttime = Lerp(frac, pSourceLayer->layerFadeOuttime, pNextSourceLayer->layerFadeOuttime);
}
}
else
{
//Either no interp, or interp failed. Just use record.
pTargetLayer->m_flCycle = pSourceLayer->cycle;
pTargetLayer->m_flWeight = pSourceLayer->weight;
pTargetLayer->m_flLayerAnimtime = pSourceLayer->layerAnimtime;
pTargetLayer->m_flBlendIn = pSourceLayer->blendIn;
pTargetLayer->m_flBlendOut = pSourceLayer->blendOut;
pTargetLayer->m_flPrevCycle = pSourceLayer->prevCycle;
pTargetLayer->m_flKillDelay = pSourceLayer->killDelay;
pTargetLayer->m_flKillRate = pSourceLayer->killRate;
pTargetLayer->m_flLayerFadeOuttime = pSourceLayer->layerFadeOuttime;
}
}
}
}
}
//Tony; we don't have to check anything special for SDK_USE_TEAMS here; it's all pretty generic, except for the one assert.
bool CSDKPlayer::HandleCommand_JoinClass( int iClass )
{
Assert( GetTeamNumber() != TEAM_SPECTATOR );
#if defined ( SDK_USE_TEAMS )
Assert( GetTeamNumber() != TEAM_UNASSIGNED );
#endif
if( GetTeamNumber() == TEAM_SPECTATOR )
return false;
if( iClass == PLAYERCLASS_UNDEFINED )
return false; //they typed in something weird
int iOldPlayerClass = m_Shared.DesiredPlayerClass();
// See if we're joining the class we already are
if( iClass == iOldPlayerClass )
return true;
if( !SDKGameRules()->IsPlayerClassOnTeam( iClass, GetTeamNumber() ) )
return false;
const char *classname = SDKGameRules()->GetPlayerClassName( iClass, GetTeamNumber() );
if( SDKGameRules()->CanPlayerJoinClass( this, iClass ) )
{
m_Shared.SetDesiredPlayerClass( iClass ); //real class value is set when the player spawns
//Tony; don't do this until we have a spawn timer!!
// if( State_Get() == STATE_PICKINGCLASS )
// State_Transition( STATE_OBSERVER_MODE );
if( iClass == PLAYERCLASS_RANDOM )
{
if( IsAlive() )
{
ClientPrint(this, HUD_PRINTTALK, "#game_respawn_asrandom" );
}
else
{
ClientPrint(this, HUD_PRINTTALK, "#game_spawn_asrandom" );
}
}
else
{
if( IsAlive() )
{
ClientPrint(this, HUD_PRINTTALK, "#game_respawn_as", classname );
}
else
{
ClientPrint(this, HUD_PRINTTALK, "#game_spawn_as", classname );
}
}
IGameEvent * event = gameeventmanager->CreateEvent( "player_changeclass" );
if ( event )
{
event->SetInt( "userid", GetUserID() );
event->SetInt( "class", iClass );
gameeventmanager->FireEvent( event );
}
}
else
{
ClientPrint(this, HUD_PRINTTALK, "#game_class_limit", classname );
ShowClassSelectMenu();
}
// Incase we don't get the class menu message before the spawn timer
// comes up, fake that we've closed the menu.
SetClassMenuOpen( false );
//Tony; TODO; this is temp, I may integrate with the teamplayroundrules; If I do, there will be wavespawn too.
if ( State_Get() == STATE_PICKINGCLASS /*|| IsDead()*/ ) //Tony; undone, don't transition if dead; only go into active state at this point if we were picking class.
State_Transition( STATE_ACTIVE ); //Done picking stuff and we're in the pickingclass state, or dead, so we can spawn now.
return true;
}
void CReplayManager::StopReplay()
{
if (m_bReplayIsPending)
m_bReplayIsPending = false;
if (!m_bIsReplaying)
return;
m_bIsReplaying = false;
if (m_pBall)
{
UTIL_Remove(m_pBall);
m_pBall = NULL;
}
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 11; j++)
{
if (m_pPlayers[i][j])
{
UTIL_Remove(m_pPlayers[i][j]);
m_pPlayers[i][j] = NULL;
}
}
}
if (IsMarkedForDeletion())
return;
CBall *pRealBall = GetMatchBall();
if (pRealBall)
{
//pRealBall->SetRenderMode(kRenderNormal);
//pRealBall->SetRenderColorA(255);
pRealBall->RemoveEffects(EF_NODRAW);
pRealBall->RemoveSolidFlags(FSOLID_NOT_SOLID);
}
for (int i = 1; i <= gpGlobals->maxClients; i++)
{
CSDKPlayer *pRealPl = ToSDKPlayer(UTIL_PlayerByIndex(i));
if (!CSDKPlayer::IsOnField(pRealPl))
continue;
//pRealPl->SetRenderMode(kRenderNormal);
//pRealPl->SetRenderColorA(255);
pRealPl->SetLocalOrigin(pRealPl->GetSpawnPos());
QAngle ang;
VectorAngles(Vector(0, pRealPl->GetTeam()->m_nForward, 0), ang);
pRealPl->SetLocalAngles(ang);
pRealPl->SnapEyeAngles(ang);
pRealPl->SetLocalVelocity(vec3_origin);
pRealPl->RemoveEffects(EF_NODRAW);
//pRealPl->RemoveEFlags(EFL_NOCLIP_ACTIVE);
pRealPl->SetMoveType(MOVETYPE_WALK);
pRealPl->RemoveSolidFlags(FSOLID_NOT_SOLID);
if (pRealPl->GetPlayerBall())
{
pRealPl->GetPlayerBall()->RemoveEffects(EF_NODRAW);
pRealPl->GetPlayerBall()->RemoveSolidFlags(FSOLID_NOT_SOLID);
}
}
if (SDKGameRules()->IsIntermissionState())
{
IGameEvent *pEvent = gameeventmanager->CreateEvent("match_period");
if (pEvent)
{
pEvent->SetInt("period", SDKGameRules()->State_Get());
gameeventmanager->FireEvent(pEvent);
}
}
}
void CSDKPlayer::CheckBallShield(const Vector &oldPos, Vector &newPos, const Vector &oldVel, Vector &newVel, const QAngle &oldAng, QAngle &newAng)
{
bool stopPlayer = false;
const float border = (GetFlags() & FL_SHIELD_KEEP_IN) ? -mp_shield_border.GetInt() : mp_shield_border.GetInt();
int forward;
#ifdef CLIENT_DLL
forward = GetPlayersTeam(this)->m_nForward;
#else
forward = GetTeam()->m_nForward;
#endif
if (SDKGameRules()->m_nShieldType != SHIELD_NONE)
{
if (SDKGameRules()->m_nShieldType == SHIELD_GOALKICK ||
SDKGameRules()->m_nShieldType == SHIELD_PENALTY ||
SDKGameRules()->m_nShieldType == SHIELD_FREEKICK ||
(SDKGameRules()->m_nShieldType == SHIELD_KICKOFF && !SDKGameRules()->IsIntermissionState()) ||
SDKGameRules()->m_nShieldType == SHIELD_CORNER)
{
const float radius = mp_shield_ball_radius.GetFloat();
Vector dir = newPos - SDKGameRules()->m_vShieldPos;
if (dir.Length2DSqr() < pow(radius, 2))
{
dir.z = 0;
dir.NormalizeInPlace();
newPos = SDKGameRules()->m_vShieldPos + dir * radius;
stopPlayer = true;
}
}
if (SDKGameRules()->m_nShieldType == SHIELD_GOALKICK ||
SDKGameRules()->m_nShieldType == SHIELD_PENALTY ||
SDKGameRules()->m_nShieldType == SHIELD_KEEPERHANDS)
{
int side = (SDKGameRules()->m_nShieldType == SHIELD_PENALTY ? GetGlobalTeam(SDKGameRules()->m_nShieldTeam)->GetOppTeamNumber() : SDKGameRules()->m_nShieldTeam);
Vector min = GetGlobalTeam(side)->m_vPenBoxMin - border;
Vector max = GetGlobalTeam(side)->m_vPenBoxMax + border;
if (GetFlags() & FL_SHIELD_KEEP_OUT || SDKGameRules()->m_nShieldType == SHIELD_PENALTY)
{
if (SDKGameRules()->m_vKickOff.GetY() > min.y)
min.y -= 500;
else
max.y += 500;
}
bool isInsideBox = newPos.x > min.x && newPos.y > min.y && newPos.x < max.x && newPos.y < max.y;
Vector boxCenter = (min + max) / 2;
if (GetFlags() & FL_SHIELD_KEEP_OUT && isInsideBox)
{
bool oldPosInBox = true;
if (newPos.x > min.x && oldPos.x <= min.x && newPos.x < boxCenter.x)
{
newPos.x = min.x;
oldPosInBox = false;
}
else if (newPos.x < max.x && oldPos.x >= max.x && newPos.x > boxCenter.x)
{
newPos.x = max.x;
oldPosInBox = false;
}
if (newPos.y > min.y && oldPos.y <= min.y && newPos.y < boxCenter.y)
{
newPos.y = min.y;
oldPosInBox = false;
}
else if (newPos.y < max.y && oldPos.y >= max.y && newPos.y > boxCenter.y)
{
newPos.y = max.y;
oldPosInBox = false;
}
stopPlayer = true;
if (SDKGameRules()->m_nShieldType == SHIELD_KEEPERHANDS && oldPosInBox)
{
Vector goalCenter = GetGlobalTeam(SDKGameRules()->m_nShieldTeam)->m_vGoalCenter;
goalCenter.y -= GetGlobalTeam(SDKGameRules()->m_nShieldTeam)->m_nForward * 500;
if ((goalCenter - newPos).Length2DSqr() < (goalCenter - oldPos).Length2DSqr())
{
newPos.x = oldPos.x;
newPos.y = oldPos.y;
stopPlayer = true;
}
else
stopPlayer = false;
}
}
else if (GetFlags() & FL_SHIELD_KEEP_IN && !isInsideBox)
{
if (newPos.x < min.x)
newPos.x = min.x;
else if (newPos.x > max.x)
newPos.x = max.x;
if (newPos.y < min.y)
newPos.y = min.y;
else if (newPos.y > max.y)
newPos.y = max.y;
stopPlayer = true;
}
}
if (SDKGameRules()->m_nShieldType == SHIELD_THROWIN && GetFlags() & FL_SHIELD_KEEP_OUT ||
SDKGameRules()->m_nShieldType == SHIELD_FREEKICK ||
SDKGameRules()->m_nShieldType == SHIELD_CORNER ||
SDKGameRules()->m_nShieldType == SHIELD_KICKOFF ||
SDKGameRules()->m_nShieldType == SHIELD_PENALTY && (GetFlags() & FL_SHIELD_KEEP_OUT))
{
float radius = SDKGameRules()->GetShieldRadius(GetTeamNumber(), GetFlags() & FL_SHIELD_KEEP_IN) + border;
Vector dir = newPos - SDKGameRules()->m_vShieldPos;
if (!SDKGameRules()->IsIntermissionState() &&
((GetFlags() & FL_SHIELD_KEEP_OUT) && dir.Length2D() < radius ||
(GetFlags() & FL_SHIELD_KEEP_IN) && dir.Length2D() > radius))
{
dir.z = 0;
dir.NormalizeInPlace();
newPos = SDKGameRules()->m_vShieldPos + dir * radius;
stopPlayer = true;
}
if (SDKGameRules()->m_nShieldType == SHIELD_KICKOFF && (GetFlags() & FL_SHIELD_KEEP_OUT)
&& (!SDKGameRules()->IsIntermissionState() || SDKGameRules()->State_Get() == MATCH_PERIOD_WARMUP && mp_shield_block_opponent_half.GetBool()))
{
int forward;
#ifdef CLIENT_DLL
forward = GetPlayersTeam(this)->m_nForward;
#else
forward = GetTeam()->m_nForward;
#endif
float yBorder = SDKGameRules()->m_vKickOff.GetY() - abs(border) * forward;
if (ZeroSign(newPos.y - yBorder) == forward)
{
newPos.y = yBorder;
stopPlayer = true;
}
}
if (SDKGameRules()->m_nShieldType == SHIELD_FREEKICK && mp_shield_block_sixyardbox.GetBool())
{
int teamPosType;
#ifdef CLIENT_DLL
teamPosType = GameResources()->GetTeamPosType(entindex());
#else
teamPosType = GetTeamPosType();
#endif
if (teamPosType != POS_GK || GetTeamNumber() != GetGlobalTeam(SDKGameRules()->m_nShieldTeam)->GetOppTeamNumber())
{
int side = GetGlobalTeam(SDKGameRules()->m_nShieldTeam)->GetOppTeamNumber();
Vector min = GetGlobalTeam(side)->m_vSixYardBoxMin - border;
Vector max = GetGlobalTeam(side)->m_vSixYardBoxMax + border;
if (GetGlobalTeam(side)->m_nForward == 1)
min.y -= 500;
else
max.y += 500;
bool isInsideBox = newPos.x > min.x && newPos.y > min.y && newPos.x < max.x && newPos.y < max.y;
Vector boxCenter = (min + max) / 2;
if (isInsideBox)
{
if (newPos.x > min.x && oldPos.x <= min.x && newPos.x < boxCenter.x)
newPos.x = min.x;
else if (newPos.x < max.x && oldPos.x >= max.x && newPos.x > boxCenter.x)
newPos.x = max.x;
if (newPos.y > min.y && oldPos.y <= min.y && newPos.y < boxCenter.y)
newPos.y = min.y;
else if (newPos.y < max.y && oldPos.y >= max.y && newPos.y > boxCenter.y)
newPos.y = max.y;
stopPlayer = true;
}
}
}
}
if (SDKGameRules()->m_nShieldType == SHIELD_THROWIN && GetFlags() & FL_SHIELD_KEEP_IN)
{
const int xLength = mp_shield_throwin_movement_x.GetInt();
const int yLength = mp_shield_throwin_movement_y.GetInt();
Vector xSign = SDKGameRules()->m_vShieldPos.GetX() > SDKGameRules()->m_vKickOff.GetX() ? 1 : -1;
Vector min = SDKGameRules()->m_vShieldPos + Vector(xSign == -1 ? -xLength : 0, -yLength / 2, 0);
Vector max = SDKGameRules()->m_vShieldPos + Vector(xSign == -1 ? 0 : xLength, yLength / 2, 0);
bool isInsideBox = newPos.x > min.x && newPos.y > min.y && newPos.x < max.x && newPos.y < max.y;
if (!isInsideBox)
{
if (newPos.x < min.x)
newPos.x = min.x;
else if (newPos.x > max.x)
newPos.x = max.x;
if (newPos.y < min.y)
newPos.y = min.y;
else if (newPos.y > max.y)
newPos.y = max.y;
stopPlayer = true;
}
}
}
if (!SDKGameRules()->IsIntermissionState() && mp_field_padding_enabled.GetBool())
{
float border = mp_field_padding.GetInt();
Vector min = SDKGameRules()->m_vFieldMin - border;
Vector max = SDKGameRules()->m_vFieldMax + border;
if (newPos.x < min.x || newPos.y < min.y || newPos.x > max.x || newPos.y > max.y)
{
if (newPos.x < min.x)
newPos.x = min.x;
else if (newPos.x > max.x)
newPos.x = max.x;
if (newPos.y < min.y)
newPos.y = min.y;
else if (newPos.y > max.y)
newPos.y = max.y;
stopPlayer = true;
}
}
if (stopPlayer)
{
//newVel = oldVel;
trace_t trace;
UTIL_TraceHull(newPos, newPos, GetPlayerMins(), GetPlayerMaxs(), MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER, &trace);
if (trace.startsolid)
{
// Stay at the old pos since the new pos is taken
newPos = oldPos;
}
Vector dir = newPos - oldPos;
dir.z = 0;
float speed = dir.NormalizeInPlace();
newVel = dir * min(speed * 100, mp_runspeed.GetInt());
//newVel.x = (newPos - oldPos).x * 100;
//newVel.y = (newPos - oldPos).y * 100;
//newPos = pos;
}
}
void CKeeperBot::BotAdjustPos()
{
float modifier = KEEPER_MID_COEFF;
QAngle ang = m_oldcmd.viewangles;
Vector target = GetTeam()->m_vGoalCenter;
if (m_vBallVel.Length2D() > 750 && m_flAngToBallVel < 60)
{
float yDist = GetTeam()->m_vGoalCenter.GetY() - m_vBallPos.y;
float vAng = acos(Sign(yDist) * m_vBallDir2D.y);
float xDist = Sign(m_vBallDir2D.x) * abs(yDist) * tan(vAng);
target.x = clamp(m_vBallPos.x + xDist, GetTeam()->m_vGoalCenter.GetX() - 150, GetTeam()->m_vGoalCenter.GetX() + 150);
}
if (m_pBall->State_Get() == BALL_STATE_KEEPERHANDS && m_pBall->GetCurrentPlayer() == this)
{
if (ShotButtonsReleased())
{
modifier = KEEPER_CLOSE_COEFF;
//m_cmd.buttons |= (IN_ATTACK2 | IN_ATTACK);
m_cmd.buttons |= IN_ALT1;
CSDKPlayer *pPl = FindClosestPlayerToSelf(true, true);
if (!pPl && SDKGameRules()->IsIntermissionState())
pPl = FindClosestPlayerToSelf(false, true);
if (pPl)
{
VectorAngles(pPl->GetLocalOrigin() - GetLocalOrigin(), ang);
ang[PITCH] = g_IOSRand.RandomFloat(-40, 0);
//m_flBotNextShot = gpGlobals->curtime + 1;
}
else
{
VectorAngles(Vector(0, GetTeam()->m_nForward, 0), ang);
ang[YAW] += g_IOSRand.RandomFloat(-45, 45);
ang[PITCH] = g_IOSRand.RandomFloat(-40, 0);
//m_flBotNextShot = gpGlobals->curtime + 1;
}
}
}
else// if (gpGlobals->curtime >= m_flBotNextShot)
{
VectorAngles(m_vDirToBall, ang);
float ballDistToGoal = (m_vBallPos - GetTeam()->m_vGoalCenter).Length2D();
CSDKPlayer *pClosest = FindClosestPlayerToBall();
m_cmd.buttons |= IN_ATTACK;
if (ballDistToGoal < 750 && m_vDirToBall.Length2D() < 200 && m_vDirToBall.z < 200 && (m_vDirToBall.z < 80 || m_vBallVel.z <= 0))
{
modifier = KEEPER_CLOSE_COEFF;// max(0.15f, 1 - ballDistToGoal / 750);
VectorAngles(Vector(0, GetTeam()->m_nForward, 0), ang);
bool diving = false;
if (m_flAngToBallVel < 60 && m_flAngToBallVel > 15)
{
if (abs(m_vDirToBall.x) > 50 && abs(m_vDirToBall.x) < 200 && m_vDirToBall.z < 150 && abs(m_vDirToBall.x) < 150 && m_vBallVel.Length() > 200)
{
m_cmd.buttons |= IN_JUMP;
m_cmd.buttons |= Sign(m_vDirToBall.x) == GetTeam()->m_nRight ? IN_MOVERIGHT : IN_MOVELEFT;
//m_cmd.buttons |= (IN_ATTACK2 | IN_ATTACK);
diving = true;
}
else if (m_vDirToBall.z > 100 && m_vDirToBall.z < 150 && m_vDirToBall.Length2D() < 100)
{
m_cmd.buttons |= IN_JUMP;
//m_cmd.buttons |= (IN_ATTACK2 | IN_ATTACK);
diving = true;
}
else if (abs(m_vDirToBall.y) > 50 && abs(m_vDirToBall.y) < 200 && m_vDirToBall.z < 100 && abs(m_vDirToBall.x) < 50 && m_vBallVel.Length() < 200 && pClosest != this)
{
m_cmd.buttons |= IN_JUMP;
m_cmd.buttons |= Sign(m_vLocalDirToBall.x) == GetTeam()->m_nForward ? IN_FORWARD : IN_BACK;
//m_cmd.buttons |= (IN_ATTACK2 | IN_ATTACK);
diving = true;
}
}
if (!diving)
{
if (m_vDirToBall.Length2D() < 50)
{
modifier = KEEPER_CLOSE_COEFF;
//m_cmd.buttons |= (IN_ATTACK2 | IN_ATTACK);
CSDKPlayer *pPl = FindClosestPlayerToSelf(true, true);
if (!pPl && SDKGameRules()->IsIntermissionState())
pPl = FindClosestPlayerToSelf(false, true);
if (pPl)
{
VectorAngles(pPl->GetLocalOrigin() - GetLocalOrigin(), ang);
ang[PITCH] = g_IOSRand.RandomFloat(-40, 0);
//m_flBotNextShot = gpGlobals->curtime + 1;
}
else
{
VectorAngles(Vector(0, GetTeam()->m_nForward, 0), ang);
ang[YAW] += g_IOSRand.RandomFloat(-45, 45);
ang[PITCH] = g_IOSRand.RandomFloat(-40, 0);
//m_flBotNextShot = gpGlobals->curtime + 1;
}
}
else
modifier = KEEPER_CLOSE_COEFF;
}
}
else if (ballDistToGoal < 1250 && m_flAngToBallVel < 60 && m_vBallVel.Length2D() > 300 && (m_vBallVel.z > 100 || m_vDirToBall.z > 100))
{
modifier = KEEPER_FAR_COEFF;
}
else if (ballDistToGoal < 1000 && m_vDirToBall.z < 80 && m_vBallVel.Length2D() < 300 && m_vBallVel.z < 100)
{
if (pClosest == this)
modifier = KEEPER_CLOSE_COEFF;
else
modifier = max(KEEPER_FAR_COEFF, 1 - pow(min(1, ballDistToGoal / 750.0f), 2));
}
else
{
modifier = KEEPER_MID_COEFF;
}
m_cmd.viewangles = ang;
m_LastAngles = m_cmd.viewangles;
SetLocalAngles(m_cmd.viewangles);
SnapEyeAngles(ang);
Vector targetPosDir = target + modifier * (m_vBallPos - target) - GetLocalOrigin();
targetPosDir.z = 0;
float dist = targetPosDir.Length2D();
VectorNormalizeFast(targetPosDir);
Vector localDir;
VectorIRotate(targetPosDir, EntityToWorldTransform(), localDir);
//float speed;
//if (dist < 10)
// speed = 0;
//else if (dist < 100)
// speed = mp_runspeed.GetInt();
//else
// speed = mp_sprintspeed.GetInt();
//float speed = clamp(dist - 10, 0, mp_runspeed.GetInt());
float speed = 0;
if (dist > 30)
speed = clamp(5 * dist, 0, mp_sprintspeed.GetInt() * (mp_botkeeperskill.GetInt() / 100.0f));
if (speed > mp_runspeed.GetInt())
m_cmd.buttons |= IN_SPEED;
m_cmd.forwardmove = localDir.x * speed;
m_cmd.sidemove = -localDir.y * speed;
if (m_cmd.forwardmove > 0)
m_cmd.buttons |= IN_FORWARD;
else if (m_cmd.forwardmove < 0)
m_cmd.buttons |= IN_BACK;
if (m_cmd.sidemove > 0)
m_cmd.buttons |= IN_RIGHT;
else if (m_cmd.sidemove < 0)
m_cmd.buttons |= IN_MOVELEFT;
}
m_cmd.viewangles = ang;
}
//-----------------------------------------------------------------------------
// Purpose: determine the class name of the weapon that got a kill
//-----------------------------------------------------------------------------
const char *CSDKGameRules::GetKillingWeaponName( const CTakeDamageInfo &info, CSDKPlayer *pVictim, int *iWeaponID )
{
CBaseEntity *pInflictor = info.GetInflictor();
CBaseEntity *pKiller = info.GetAttacker();
CBasePlayer *pScorer = SDKGameRules()->GetDeathScorer( pKiller, pInflictor, pVictim );
const char *killer_weapon_name = "world";
*iWeaponID = SDK_WEAPON_NONE;
if ( pScorer && pInflictor && ( pInflictor == pScorer ) )
{
// If the inflictor is the killer, then it must be their current weapon doing the damage
if ( pScorer->GetActiveWeapon() )
{
killer_weapon_name = pScorer->GetActiveWeapon()->GetClassname();
if ( pScorer->IsPlayer() )
{
*iWeaponID = ToSDKPlayer(pScorer)->GetActiveSDKWeapon()->GetWeaponID();
}
}
}
else if ( pInflictor )
{
killer_weapon_name = STRING( pInflictor->m_iClassname );
CWeaponSDKBase *pWeapon = dynamic_cast< CWeaponSDKBase * >( pInflictor );
if ( pWeapon )
{
*iWeaponID = pWeapon->GetWeaponID();
}
else
{
CBaseGrenadeProjectile *pBaseGrenade = dynamic_cast<CBaseGrenadeProjectile*>( pInflictor );
if ( pBaseGrenade )
{
*iWeaponID = pBaseGrenade->GetWeaponID();
}
}
}
// strip certain prefixes from inflictor's classname
const char *prefix[] = { "weapon_", "NPC_", "func_" };
for ( int i = 0; i< ARRAYSIZE( prefix ); i++ )
{
// if prefix matches, advance the string pointer past the prefix
int len = Q_strlen( prefix[i] );
if ( strncmp( killer_weapon_name, prefix[i], len ) == 0 )
{
killer_weapon_name += len;
break;
}
}
// grenade projectiles need to be translated to 'grenade'
if ( 0 == Q_strcmp( killer_weapon_name, "grenade_projectile" ) )
{
killer_weapon_name = "grenade";
}
return killer_weapon_name;
}
void C_Camera::CalcChaseCamView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
{
C_SDKPlayer *pLocal = C_SDKPlayer::GetLocalSDKPlayer();
C_BaseEntity *pTarget = NULL;
if ((pLocal->m_nButtons & IN_ZOOM)
&& !pLocal->IsObserver()
&& g_PR->GetTeamPosType(GetLocalPlayerIndex()) == POS_GK
&& GetMatchBall()
&& Sign(GetMatchBall()->GetLocalOrigin().y - SDKGameRules()->m_vKickOff.GetY()) == pLocal->GetTeam()->m_nForward)
{
CalcHawkEyeView(eyeOrigin, eyeAngles, fov);
return;
}
if (pLocal->IsObserver())
pTarget = GetTarget();
else
pTarget = pLocal;
if (!pTarget || !pTarget->GetBaseAnimating() && !pTarget->GetModel())
{
CalcRoamingView( eyeOrigin, eyeAngles, fov );
return;
}
eyeOrigin = pTarget->EyePosition();
eyeAngles = pTarget->EyeAngles();
const QAngle camAngles = ::input->GetCameraAngles();
Vector &camOffset = ::input->GetCameraOffset();
float dist = cl_cam_firstperson.GetBool() ? -10 : cl_cam_dist.GetFloat();
float height = cl_cam_firstperson.GetBool() ? 8 : cl_cam_height.GetFloat();
if (pLocal->IsObserver() && GetCamMode() == CAM_MODE_LOCKED_CHASE && !dynamic_cast<C_MatchBall *>(pTarget))
{
camOffset[PITCH] = eyeAngles[PITCH];
camOffset[YAW] = eyeAngles[YAW];
}
else
{
camOffset[PITCH] = camAngles[PITCH];
camOffset[YAW] = camAngles[YAW];
}
if (camOffset[PITCH] >= 0)
{
camOffset[ROLL] = dist;
}
else
{
float coeff = clamp(cos(DEG2RAD(camOffset[PITCH] + 90)), 0.001f, 1.0f);
camOffset[ROLL] = min((VEC_VIEW.z + height - 5) / coeff, dist);
}
eyeAngles[PITCH] = camOffset[PITCH];
eyeAngles[YAW] = camOffset[YAW];
eyeAngles[ROLL] = 0;
Vector camForward, camRight, camUp;
AngleVectors(eyeAngles, &camForward, &camRight, &camUp);
VectorMA(eyeOrigin, -camOffset[ROLL], camForward, eyeOrigin);
eyeOrigin.z += height;
if (!pLocal->IsObserver())
{
// Apply a smoothing offset to smooth out prediction errors.
Vector vSmoothOffset;
pLocal->GetPredictionErrorSmoothingVector( vSmoothOffset );
eyeOrigin += Vector(vSmoothOffset.x, vSmoothOffset.y, 0);
}
fov = pLocal->GetFOV();
}
void RecvProxy_SDKGameRules( const RecvProp *pProp, void **pOut, void *pData, int objectID )
{
CSDKGameRules *pRules = SDKGameRules();
Assert( pRules );
*pOut = pRules;
}
///////////////////////////////////////////////////
// BotKeeperThink
//
// put movement values into m_cmd, then that gets run after
// and moves the bot.
//
void CKeeperBot::BotThink()
{
// Prevent bot from running all the way back to his goal on penalties
if (SDKGameRules()->State_Get() != MATCH_PERIOD_PENALTIES || (GetTeam()->m_vGoalCenter - GetLocalOrigin()).Length2D() < 1000)
BotAdjustPos();
}