bool SetSkinPage::PopulateMenuPage(player_t *player_ptr)
{
this->SetEscLink("%s", Translate(player_ptr, 780));
this->SetTitle("%s", Translate(player_ptr, 781));
for( int i = 1; i <= max_players; i++ )
{
player_t player;
player.index = i;
if (!FindPlayerByIndex(&player)) continue;
if (player.is_dead) continue;
if (player_ptr->index != player.index &&
gpManiClient->HasAccess(player.index, IMMUNITY, IMMUNITY_SETSKIN))
{
continue;
}
MenuItem *ptr = new SetSkinItem();
ptr->SetDisplayText("[%s] %i", player.name, player.user_id);
ptr->SetHiddenText("%s", player.name);
ptr->params.AddParam("user_id", player.user_id);
this->AddItem(ptr);
}
this->SortHidden();
return true;
}
void CRPGPlayer::ChargeTouch( CBaseEntity *pOther )
{
if (!m_bUsingCharge)
RETURN_META(MRES_IGNORED);
edict_t *pEdict = serverents->BaseEntityToEdict( pOther );
if (!pEdict || pEdict->IsFree())
RETURN_META(MRES_IGNORED);
int e_index = engine->IndexOfEdict(pEdict);
if ((e_index >= 0) && (e_index <= playerinfo->GetGlobalVars()->maxClients))
{
CRPGPlayer *pPlayer = FindPlayerByIndex(e_index);
if (!pPlayer)
RETURN_META(MRES_IGNORED);
if (pPlayer->GetPlayerInfo()->GetTeamIndex() == TEAM_UNDEAD)
{
// let's throw this fool around
Vector EyePosition = VFuncs::EyePosition(GetBaseEntity());
QAngle EyeAngles = GetPlayerInfo()->GetAbsAngles();
Vector forward;
AngleVectors(EyeAngles, &forward);
const Vector FinalVelocity = (BRUTE_SKILL_CHARGE_FORCE * forward);
VFuncs::Teleport((CBaseAnimating*)pPlayer->GetBaseEntity(), NULL, NULL, &FinalVelocity);
}
}
RETURN_META(MRES_IGNORED);
}
//---------------------------------------------------------------------------------
// Purpose: Give everyone ammo
//---------------------------------------------------------------------------------
void ManiWarmupTimer::GiveAllAmmo(void)
{
for (int i = 1; i <= max_players; i++)
{
player_t player;
player.index = i;
if (!FindPlayerByIndex(&player)) continue;
if (player.is_dead) continue;
if (player.player_info->IsHLTV()) continue;
CBaseEntity *pPlayer = EdictToCBE(player.entity);
CBaseCombatCharacter *pCombat = CBaseEntity_MyCombatCharacterPointer(pPlayer);
CBaseCombatWeapon *pWeapon = CBaseCombatCharacter_Weapon_GetSlot(pCombat, 0);
if (pWeapon)
{
int ammo_index;
ammo_index = CBaseCombatWeapon_GetPrimaryAmmoType(pWeapon);
CBaseCombatCharacter_GiveAmmo(pCombat, 999, ammo_index, true);
ammo_index = CBaseCombatWeapon_GetSecondaryAmmoType(pWeapon);
CBaseCombatCharacter_GiveAmmo(pCombat, 999, ammo_index, true);
}
pWeapon = CBaseCombatCharacter_Weapon_GetSlot(pCombat, 1);
if (pWeapon)
{
int ammo_index;
ammo_index = CBaseCombatWeapon_GetPrimaryAmmoType(pWeapon);
CBaseCombatCharacter_GiveAmmo(pCombat, 999, ammo_index, true);
ammo_index = CBaseCombatWeapon_GetSecondaryAmmoType(pWeapon);
CBaseCombatCharacter_GiveAmmo(pCombat, 999, ammo_index, true);
}
}
}
//---------------------------------------------------------------------------------
// Purpose: Plugin Loaded
//---------------------------------------------------------------------------------
void ManiAFK::Load(void)
{
if (gpManiGameType->GetVFuncIndex(MANI_VFUNC_USER_CMDS) == -1) return;
for (int i = 0; i < MANI_MAX_PLAYERS; i++)
{
this->ResetPlayer(i, false);
player_t player;
player.index = i + 1;
if (!FindPlayerByIndex(&player))
{
continue;
}
if (player.is_bot) continue;
if (!afk_list[i].hooked)
{
g_ManiSMMHooks.HookProcessUsercmds((CBasePlayer *) EdictToCBE(player.entity));
afk_list[i].hooked = true;
}
afk_list[i].check_player = true;
}
next_check = 0;
}
//---------------------------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------------------------
int PlaySoundItem::MenuItemFired(player_t *player_ptr, MenuPage *m_page_ptr)
{
int index;
if (this->params.GetParam("index", &index))
{
char play_sound[512];
for (int i = 1; i <= max_players; i++ )
{
player_t player;
player.index = i;
if (!FindPlayerByIndex(&player)) continue;
if (player.is_bot) continue;
player_settings_t *player_settings;
player_settings = FindPlayerSettings(&player);
if (!player_settings) continue;
// This player doesn't want to hear sounds
if (!player_settings->server_sounds) continue;
if ( mani_play_sound_type.GetBool() )
snprintf(play_sound, sizeof(play_sound), "play \"%s\"\n",sound_list[index].sound_name);
else
snprintf(play_sound, sizeof(play_sound), "playgamesound \"%s\"\n",sound_list[index].sound_name);
engine->ClientCommand(player.entity, play_sound);
//UTIL_EmitSoundSingle(&player, sound_list[index].sound_name);
}
}
return REPOP_MENU;
}
//---------------------------------------------------------------------------------
// Purpose: Plugin Loaded
//---------------------------------------------------------------------------------
void ManiPing::Load(void)
{
this->LoadImmunityList();
for (int i = 0; i < MANI_MAX_PLAYERS; i ++)
{
this->ResetPlayer(i);
}
for (int i = 1; i <= max_players; i++)
{
player_t player;
player.index = i;
if (!FindPlayerByIndex(&player)) continue;
if (player.is_bot) continue;
if (!this->IsPlayerImmune(&player) &&
!gpManiClient->HasAccess(player.index, ADMIN, ADMIN_BASIC_ADMIN, false, true) &&
!gpManiClient->HasAccess(player.index, IMMUNITY, IMMUNITY_PING, false, true))
{
ping_list[player.index - 1].check_ping = true;
}
}
next_check = 0.0;
}
//---------------------------------------------------------------------------------
// Purpose: Round Started
//---------------------------------------------------------------------------------
void ManiWarmupTimer::RoundStart(void)
{
if (war_mode) return;
if (mani_warmup_timer.GetInt() == 0) return;
if (!check_timer) return;
if ((!gpManiGameType->IsGameType(MANI_GAME_CSS)) && (!gpManiGameType->IsGameType(MANI_GAME_CSGO))) return;
for (int i = 1; i <= max_players; i++)
{
player_t player;
player.index = i;
if (!FindPlayerByIndex(&player)) continue;
if (player.player_info->IsHLTV()) continue;
CBaseEntity *pPlayer = EdictToCBE(player.entity);
CBaseCombatCharacter *pCombat = CBaseEntity_MyCombatCharacterPointer(pPlayer);
CBasePlayer *pBase = (CBasePlayer*) pPlayer;
if (!pCombat) continue;
for (int j = 0; j < MAX_WEAPONS_USED; j++)
{
CBaseCombatWeapon *pWeapon = CBaseCombatCharacter_Weapon_OwnsThisType(pCombat, gpManiWeaponMgr->GetWeaponName(j), 0);
if (!pWeapon) continue;
if (strcmp(CBaseCombatWeapon_GetName(pWeapon), "weapon_c4") != 0)
{
continue;
}
CBasePlayer_RemovePlayerItem(pBase, pWeapon);
// Switch to knife
pWeapon = CBaseCombatCharacter_Weapon_GetSlot(pCombat, 2);
if (pWeapon)
{
CBaseCombatCharacter_Weapon_Switch(pCombat, pWeapon, 0);
}
}
}
CBaseEntity *weaponc4 = (CBaseEntity*)CGlobalEntityList_FindEntityByClassname(NULL, "weapon_c4");
if (weaponc4)
{
CCSUTILRemove(weaponc4);
}
CUtlVector<CBaseEntity*> hostages;
CBaseEntity *hostage = (CBaseEntity*)CGlobalEntityList_FindEntityByClassname(NULL, "hostage_entity");
while (hostage)
{
hostages.AddToTail(hostage);
hostage = (CBaseEntity*)CGlobalEntityList_FindEntityByClassname(hostage, "hostage_entity");
}
for (int x = 0; x < hostages.Count(); x++)
{
CCSUTILRemove(hostages[x]);
}
}
void ManiWeaponMgr::Load()
{
if ((!gpManiGameType->IsGameType(MANI_GAME_CSS)) && (!gpManiGameType->IsGameType(MANI_GAME_CSGO))) return;
this->CleanUp();
this->SetupWeapons();
this->LoadRestrictions();
for (int i = 0; i < MANI_MAX_PLAYERS; i++)
{
hooked[i] = false;
ignore_hook[i] = false;
next_message[i] = 0.0;
}
for (int i = 0; i < MANI_MAX_PLAYERS; i++)
{
player_t player;
player.index = i + 1;
if (!FindPlayerByIndex(&player))
{
continue;
}
if (player.is_bot) continue;
g_ManiSMMHooks.HookWeapon_CanUse((CBasePlayer *) EdictToCBE(player.entity));
hooked[i] = true;
ignore_hook[i] = false;
}
}
//---------------------------------------------------------------------------------
// Purpose: Check Player on connect
//---------------------------------------------------------------------------------
void ManiObserverTrack::NetworkIDValidated(player_t *player_ptr)
{
if (war_mode) return;
if (gpManiGameType->GetVFuncIndex(MANI_VFUNC_SET_OBSERVER_TARGET) == -1) return;
if (!gpManiGameType->IsSpectatorAllowed()) return;
observer_id[player_ptr->index - 1] = -1;
if (IsLAN() || player_ptr->is_bot) return;
for (int i = 0; i < max_players; i++)
{
if (strcmp(observer_steam[i], player_ptr->steam_id) == 0)
{
// Observed player is leaving server
if (!IsLAN() && !player_ptr->is_bot)
{
observer_id[i] = player_ptr->index;
player_t observer;
observer.index = i + 1;
if (!FindPlayerByIndex(&observer)) continue;
OutputHelpText(GREEN_CHAT, &observer, "%s", Translate(&observer, 3121, "%s%s", player_ptr->name, player_ptr->steam_id));
}
}
}
}
//---------------------------------------------------------------------------------
// Purpose: Take a string, remove carriage return, remove comments, strips leading
// and ending spaces
//---------------------------------------------------------------------------------
void ClientMsg
(
Color *col,
const unsigned int seconds,
const bool admin_only,
const int level,
const char* fmt, ...
)
{
player_t player;
tchar szBuf[256];
va_list arg_ptr;
va_start(arg_ptr, fmt);
vsnprintf(szBuf, sizeof(szBuf)-1, fmt, arg_ptr);
va_end(arg_ptr);
Color admin_only_colour(255, 0, 0, 255);
szBuf[sizeof(szBuf)-1] = 0;
for (int i = 1; i <= max_players; i++ )
{
player.index = i;
if (!FindPlayerByIndex (&player))
{
continue;
}
if (player.is_bot)
{
continue;
}
if (admin_only)
{
if (gpManiClient->HasAccess(player.index, ADMIN, ADMIN_BASIC_ADMIN))
{
KeyValues *kv = new KeyValues("Msg");
kv->SetString("title", szBuf);
kv->SetString("Msg", "message");
kv->SetColor("color", admin_only_colour); // Red
kv->SetInt("level", level);
kv->SetInt("time", seconds);
helpers->CreateMessage(player.entity, DIALOG_MSG, kv, gpManiISPCCallback);
kv->deleteThis();
}
}
else
{
KeyValues *kv = new KeyValues("Msg");
kv->SetString("title", szBuf);
kv->SetString("Msg", "message");
kv->SetColor("color", *col);
kv->SetInt("level", level);
kv->SetInt("time", seconds);
helpers->CreateMessage(player.entity, DIALOG_MSG, kv, gpManiISPCCallback);
kv->deleteThis();
}
}
}
void ManiWeaponMgr::AutoBuyReBuy()
{
player_t player;
player.index = con_command_index + 1;
if (!FindPlayerByIndex(&player)) return;
if (player.is_bot) return;
this->RemoveWeapons(&player, true, false);
ignore_hook[player.index - 1] = false;
}
bf_write *ManiSMMHooks::UserMessageBegin(IRecipientFilter *filter, int msg_type)
#endif
{
if ( mani_hint_sounds.GetBool() )
{
#if defined ( GAME_CSGO )
RETURN_META(MRES_IGNORED);
#else
RETURN_META_VALUE(MRES_IGNORED,NULL);
#endif
}
player_t player;
if ( msg_type == hintMsg_message_index )
{
#if defined ( GAME_CSGO )
for ( int i = 0; i < filter.GetRecipientCount(); i++ )
{
player.index = filter.GetRecipientIndex(i);
#else
for ( int i = 0; i < filter->GetRecipientCount(); i++ )
{
player.index = filter->GetRecipientIndex(i);
#endif
if ( !FindPlayerByIndex(&player) ) continue;
//Stop Sound!!!
#if defined ( GAME_CSGO )
esounds->StopSound( player.index, 6, "UI/hint.wav", 0 );
#else
esounds->StopSound( player.index, 6, "UI/hint.wav");
#endif
}
}
#if defined ( GAME_CSGO )
RETURN_META(MRES_IGNORED);
#else
RETURN_META_VALUE(MRES_IGNORED,NULL);
#endif
}
#endif // GAME_ORANGE
#ifdef GAME_ORANGE
void RespawnEntities_handler(const CCommand &command)
#else
void RespawnEntities_handler()
#endif
{
//Override exploit
RETURN_META(MRES_SUPERCEDE);
}
//---------------------------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------------------------
void ProcessPlayActionSound( player_t *target_player, int sound_id)
{
char play_sound[512];
player_settings_t *player_settings;
if (!action_sound_list[sound_id].in_use) return;
if (!target_player)
{
for (int i = 1; i <= max_players; i++ )
{
player_t player;
player.index = i;
if (!FindPlayerByIndex(&player)) continue;
if (player.is_bot) continue;
player_settings = FindPlayerSettings(&player);
if (!player_settings) continue;
// This player doesn't want to hear sounds
if (!player_settings->server_sounds) continue;
if ( mani_play_sound_type.GetBool() )
snprintf(play_sound, sizeof(play_sound), "play \"%s\"\n",action_sound_list[sound_id].sound_file);
else
snprintf(play_sound, sizeof(play_sound), "playgamesound \"%s\"\n",action_sound_list[sound_id].sound_file);
engine->ClientCommand(player.entity, play_sound);
//UTIL_EmitSoundSingle(&player, action_sound_list[sound_id].sound_file);
}
}
else
{
player_settings = FindPlayerSettings(target_player);
if (!player_settings) return;
// This player doesn't want to hear sounds
if (!player_settings->server_sounds) return;
if ( mani_play_sound_type.GetBool() )
snprintf(play_sound, sizeof(play_sound), "play \"%s\"\n",action_sound_list[sound_id].sound_file);
else
snprintf(play_sound, sizeof(play_sound), "playgamesound \"%s\"\n",action_sound_list[sound_id].sound_file);
engine->ClientCommand(target_player->entity, play_sound);
//UTIL_EmitSoundSingle(target_player, action_sound_list[sound_id].sound_file);
}
}
//---------------------------------------------------------------------------------
// Purpose: Check if player can pickup weapon or not
//---------------------------------------------------------------------------------
bool ManiWeaponMgr::CanPickUpWeapon(CBasePlayer *pPlayer, CBaseCombatWeapon *pWeapon)
{
if (war_mode) return true;
if (mani_weapon_restrict_prevent_pickup.GetInt() == 0) return true;
if (gpManiWarmupTimer->KnivesOnly()) return true;
edict_t *pEdict = serverents->BaseEntityToEdict((CBasePlayer *) pPlayer);
if (!pEdict) return true;
#if defined ( GAME_CSGO )
int index = IndexOfEdict(pEdict);
#else
int index = engine->IndexOfEdict(pEdict);
#endif
if (index < 1 || index > max_players) return true;
if (ignore_hook[index - 1])
{
return true;
}
const char *weapon_name = CBaseCombatWeapon_GetName(pWeapon);
// Find index
for (int i = 0; i < MAX_WEAPONS_USED; i++)
{
if ( !weapons[i] ) break; // for DS tool and listen servers ... order of processing different
if (strcmp(weapons[i]->GetWeaponName(), weapon_name) != 0) continue;
if (weapons[i]->GetDisplayID() == 0) continue;
player_t player;
player.index = index;
if (!FindPlayerByIndex(&player)) break;
int reason, limit, ratio;
if (!weapons[i]->CanBuy(&player, 0, reason, limit, ratio))
{
if (next_message[player.index - 1] < gpGlobals->curtime)
{
ShowRestrictReason(&player, weapons[i], reason, limit, ratio);
next_message[player.index - 1] = gpGlobals->curtime + 1.2;
}
return false;
}
break;
}
return true;
}
//---------------------------------------------------------------------------------
// Purpose: Plugin Loaded
//---------------------------------------------------------------------------------
void ManiLogCSSStats::Load(void)
{
this->ResetStats();
for (int i = 1; i <= max_players; i++)
{
player_t player;
player.index = i;
if (!FindPlayerByIndex(&player)) continue;
this->UpdatePlayerIDInfo(&player, false);
}
level_ended = false;
}
bool ObservePlayerPage::PopulateMenuPage(player_t *player_ptr)
{
this->SetEscLink("%s", Translate(player_ptr, 3110));
this->SetTitle("%s", Translate(player_ptr, 3111));
MenuItem *ptr = NULL;
if (gpManiObserverTrack->observer_id[player_ptr->index - 1] != -1)
{
ptr = new ObservePlayerItem;
ptr->SetDisplayText("%s", Translate(player_ptr, 3114));
ptr->params.AddParamVar("user_id", "%i", -1);
ptr->SetHiddenText(" ");
this->AddItem(ptr);
}
for( int i = 1; i <= max_players; i++ )
{
player_t player;
player.index = i;
if (!FindPlayerByIndex(&player)) continue;
if (player.player_info->IsFakeClient())
{
continue;
}
ptr = new ObservePlayerItem;
if (gpManiObserverTrack->observer_id[player_ptr->index - 1] == player.index)
{
ptr->SetDisplayText("%s [%s] %i",
Translate(player_ptr, 3112),
player.name,
player.user_id);
}
else
{
ptr->SetDisplayText("[%s] %i",
player.name,
player.user_id);
}
ptr->SetHiddenText("%s", player.name);
ptr->params.AddParamVar("user_id", "%i", player.user_id);
this->AddItem(ptr);
}
this->SortHidden();
return true;
}
//---------------------------------------------------------------------------------
// Purpose: Say to all
//---------------------------------------------------------------------------------
void SayToAll(const int colour, bool echo, const char *fmt, ...)
{
va_list argptr;
char tempString[1024];
player_t server_player;
bool found_player = false;
if (war_mode)
{
return;
}
va_start ( argptr, fmt );
vsnprintf( tempString, sizeof(tempString), fmt, argptr );
va_end ( argptr );
MRecipientFilter mrf;
mrf.MakeReliable();
mrf.RemoveAllRecipients();
if (echo) OutputToConsole(NULL, "%s\n", tempString);
for (int i = 1; i <= max_players; i++)
{
server_player.index = i;
if (!FindPlayerByIndex(&server_player))
{
continue;
}
if (server_player.is_bot)
{
continue;
}
found_player = true;
mrf.AddPlayer(i);
if (!(gpManiGameType->IsGameType(MANI_GAME_CSS) ||
gpManiGameType->IsGameType(MANI_GAME_CSGO)))
{
if (echo) OutputToConsole(&server_player, "%s\n", tempString);
}
}
if (found_player)
{
UTIL_SayText(colour, &mrf, tempString);
}
}
//---------------------------------------------------------------------------------
// Purpose: Process the round ending
//---------------------------------------------------------------------------------
void ManiCSSObjectives::CSSRoundEnd(int winning_team, const char *message)
{
if (war_mode) return;
if (mani_css_objectives.GetInt() == 0) return;
if (gpManiWarmupTimer->InWarmupRound()) return;
if (FStrEq(message, "#Game_Commencing") ||
FStrEq(message, "#Round_Draw")) return;
bool found_player = false;
for (int i = 1; i <= max_players; i++)
{
player_t player;
player.index = i;
if (!FindPlayerByIndex(&player)) continue;
if (player.team != 2 && player.team != 3) continue;
if (player.team == winning_team) continue;
if (player.is_dead) continue;
found_player = true;
// Slay the player
SlayPlayer(&player, false, false, false);
}
if (!found_player) return;
int help_index = 0;
if (winning_team == 2)
{
// T's won
help_index = 1360;
}
else
{
// CT's won
help_index = 1361;
}
SayToAll(LIGHT_GREEN_CHAT, true, "%s", Translate(NULL, help_index));
}
//---------------------------------------------------------------------------------
// Purpose: Level Shutdown
//---------------------------------------------------------------------------------
void ManiAFK::LevelShutdown(void)
{
for (int i = 0; i < MANI_MAX_PLAYERS; i++)
{
if (afk_list[i].hooked)
{
player_t player;
player.index = i + 1;
if (FindPlayerByIndex(&player))
{
g_ManiSMMHooks.UnHookProcessUsercmds((CBasePlayer *) EdictToCBE(player.entity));
}
}
this->ResetPlayer(i, false);
afk_list[i].hooked = false;
}
}
//---------------------------------------------------------------------------------
// Purpose: Level Shutdown
//---------------------------------------------------------------------------------
void ManiWeaponMgr::LevelShutdown(void)
{
if ((!gpManiGameType->IsGameType(MANI_GAME_CSS)) && (!gpManiGameType->IsGameType(MANI_GAME_CSGO))) return;
for (int i = 0; i < MANI_MAX_PLAYERS; i++)
{
if (hooked[i])
{
player_t player;
player.index = i + 1;
if (FindPlayerByIndex(&player))
{
g_ManiSMMHooks.UnHookWeapon_CanUse((CBasePlayer *) EdictToCBE(player.entity));
}
hooked[i] = false;
ignore_hook[i] = false;
next_message[i] = 0.0;
}
}
}
//---------------------------------------------------------------------------------
// Purpose: Say to player
//---------------------------------------------------------------------------------
void SayToPlayer(const int colour, player_t *player, const char *fmt, ...)
{
va_list argptr;
char tempString[1024];
player_t recipient_player;
if (war_mode)
{
return;
}
va_start ( argptr, fmt );
vsnprintf( tempString, sizeof(tempString), fmt, argptr );
va_end ( argptr );
MRecipientFilter mrf;
mrf.MakeReliable();
recipient_player.index = player->index;
if (!FindPlayerByIndex(&recipient_player))
{
return;
}
if (recipient_player.is_bot)
{
return;
}
mrf.AddPlayer(player->index);
if (!(gpManiGameType->IsGameType(MANI_GAME_CSS) ||
gpManiGameType->IsGameType(MANI_GAME_CSGO)))
{
OutputToConsole(player, "%s\n", tempString);
}
// OutputToConsole(NULL, "%s\n", tempString);
UTIL_SayText(colour, &mrf, tempString);
}
//---------------------------------------------------------------------------------
// Purpose: Process the ma_endobserve command
//---------------------------------------------------------------------------------
PLUGIN_RESULT ManiObserverTrack::ProcessMaEndObserve
(
player_t *player_ptr,
const char *command_name,
const int help_id,
const int command_type
)
{
if (war_mode) return PLUGIN_CONTINUE;
if (gpManiGameType->GetVFuncIndex(MANI_VFUNC_SET_OBSERVER_TARGET) == -1) return PLUGIN_CONTINUE;
if (!gpManiGameType->IsSpectatorAllowed()) return PLUGIN_CONTINUE;
if (player_ptr)
{
// Check if player is admin
if (!gpManiClient->HasAccess(player_ptr->index, ADMIN, ADMIN_BASIC_ADMIN, war_mode)) return PLUGIN_BAD_ADMIN;
}
if (observer_id[player_ptr->index - 1] == -1)
{
OutputHelpText(GREEN_CHAT, player_ptr, "%s", Translate(player_ptr, 3119));
strcpy(observer_steam[player_ptr->index - 1], "");
}
else
{
player_t target;
target.index = observer_id[player_ptr->index - 1];
if (FindPlayerByIndex(&target))
{
OutputHelpText(GREEN_CHAT, player_ptr, "%s", Translate(player_ptr, 3120, "%s%s", target.name, target.steam_id));
}
observer_id[player_ptr->index - 1] = -1;
strcpy(observer_steam[player_ptr->index - 1], "");
}
return PLUGIN_STOP;
}
//---------------------------------------------------------------------------------
// Purpose: Do set observer mode on round start
//---------------------------------------------------------------------------------
void ManiObserverTrack::PlayerSpawn(player_t *player_ptr)
{
if (war_mode) return;
if (!gpManiGameType->IsSpectatorAllowed()) return;
if (gpManiGameType->GetVFuncIndex(MANI_VFUNC_SET_OBSERVER_TARGET) == -1) return;
for (int i = 0; i < max_players; i++)
{
if (observer_id[i] != player_ptr->index)
{
// Not observing
continue;
}
player_t observer;
observer.index = i + 1;
if (!FindPlayerByIndex(&observer))
{
observer_id[i] = -1;
}
if (observer.team != gpManiGameType->GetSpectatorIndex())
{
continue;
}
if (!gpManiGameType->IsValidActiveTeam(player_ptr->team))
{
continue;
}
CBaseEntity *pTarget = EdictToCBE(player_ptr->entity);
CBasePlayer *pBase = (CBasePlayer *) EdictToCBE(observer.entity);
CBasePlayer_SetObserverTarget(pBase, pTarget);
OutputHelpText(GREEN_CHAT, &observer, "%s", Translate(&observer, 3116, "%s%s", player_ptr->name, player_ptr->steam_id));
}
}
//---------------------------------------------------------------------------------
// Purpose: Do set observer mode on player death
//---------------------------------------------------------------------------------
void ManiObserverTrack::PlayerDeath(player_t *player_ptr)
{
if (war_mode) return;
if (gpManiGameType->GetVFuncIndex(MANI_VFUNC_SET_OBSERVER_TARGET) == -1) return;
if (!gpManiGameType->IsSpectatorAllowed()) return;
if (observer_id[player_ptr->index - 1] == -1) return;
player_t target;
target.index = observer_id[player_ptr->index - 1];
if (!FindPlayerByIndex(&target)) return;
if (target.is_dead)
{
OutputHelpText(GREEN_CHAT, player_ptr, "%s", Translate(player_ptr, 3117, "%s", target.name));
return;
}
CBaseEntity *pTarget = EdictToCBE(target.entity);
CBasePlayer *pBase = (CBasePlayer *) EdictToCBE(player_ptr->entity);
CBasePlayer_SetObserverTarget(pBase, pTarget);
OutputHelpText(GREEN_CHAT, player_ptr, "%s", Translate(player_ptr, 3116, "%s%s", target.name, target.steam_id));
}
//---------------------------------------------------------------------------------
// Purpose: Check all players on round start
//---------------------------------------------------------------------------------
void ManiVictimStats::RoundEnd(void)
{
if (mani_show_victim_stats.GetInt() == 1 && !war_mode)
{
player_t victim;
for (int i = 1; i <= max_players; i++)
{
victim.index = i;
if (damage_list[i - 1][i - 1].shown_stats)
{
continue;
}
if (!FindPlayerByIndex(&victim))
{
continue;
}
ShowStats(&victim, NULL);
}
}
}
//---------------------------------------------------------------------------------
// Purpose: Check Player on disconnect
//---------------------------------------------------------------------------------
void ManiAntiRejoin::ClientDisconnect(player_t *player_ptr)
{
if (war_mode) return;
if (IsLAN()) return;
if ((!gpManiGameType->IsGameType(MANI_GAME_CSS)) && (!gpManiGameType->IsGameType(MANI_GAME_CSGO))) return;
if (mani_anti_rejoin.GetInt() == 0) return;
if (player_ptr->is_bot) return;
int ct = 0;
int t = 0;
for (int i = 0; i < max_players; i++)
{
player_t player;
player.index = i + 1;
if (!FindPlayerByIndex(&player)) continue;
if (player.team == 2)
{
t ++;
}
else if (player.team == 3)
{
ct ++;
}
if (ct != 0 && t != 0)
{
break;
}
}
if (ct == 0 || t == 0)
{
return;
}
rejoin_list[player_ptr->steam_id] = gpManiTeam->GetTeamScore(2) + gpManiTeam->GetTeamScore(3);
}
//---------------------------------------------------------------------------------
// Purpose: Say string to specific teams
//---------------------------------------------------------------------------------
void SayToTeam
(
const int colour,
bool ct_side,
bool t_side,
bool spectator,
const char *fmt, ...
)
{
va_list argptr;
char tempString[1024];
if (war_mode)
{
return;
}
va_start ( argptr, fmt );
vsnprintf( tempString, sizeof(tempString), fmt, argptr );
va_end ( argptr );
MRecipientFilter mrf;
player_t recipient_player;
mrf.MakeReliable();
mrf.RemoveAllRecipients();
for (int i = 1; i <= max_players; i++)
{
recipient_player.index = i;
if (!FindPlayerByIndex (&recipient_player))
{
continue;
}
if (recipient_player.is_bot)
{
continue;
}
if (ct_side)
{
if (recipient_player.team == TEAM_B)
{
mrf.AddPlayer(i);
}
}
if (t_side)
{
if (recipient_player.team == TEAM_A)
{
mrf.AddPlayer(i);
}
}
if (gpManiGameType->IsSpectatorAllowed() && spectator)
{
if (recipient_player.team == gpManiGameType->GetSpectatorIndex())
{
mrf.AddPlayer(i);
}
}
}
OutputToConsole(NULL, "%s\n", tempString);
UTIL_SayText(colour, &mrf, tempString);
}
//---------------------------------------------------------------------------------
// Purpose: Do timed afk if needed
//---------------------------------------------------------------------------------
void ManiPing::GameFrame(void)
{
if (war_mode) return;
if (mani_high_ping_kick.GetInt() == 0) return;
// High ping kicker enabled
if (next_check > gpGlobals->curtime)
{
return;
}
next_check = gpGlobals->curtime + 1.5;
bool all_pings_high = true;
// Use 80% of limit as global ping spikes may not bring all players over the
// spike ping limit although all players will have their pings increase
int global_ping_limit = (int) (mani_high_ping_kick_ping_limit.GetFloat() * 0.8);
for (int i = 0; i < max_players; i++)
{
ping_player_t *ptr = &(ping_player_list[i]);
ptr->in_use = true;
ptr->player.index = i + 1;
if (!FindPlayerByIndex(&ptr->player))
{
ptr->in_use = false;
continue;
}
if (ptr->player.is_bot)
{
ptr->in_use = false;
continue;
}
// Valid player
INetChannelInfo *nci = engine->GetPlayerNetInfo(i + 1);
float ping = nci->GetAvgLatency(0);
const char * szCmdRate = engine->GetClientConVarValue( i + 1, "cl_cmdrate" );
int nCmdRate = (20 > Q_atoi( szCmdRate )) ? 20 : Q_atoi(szCmdRate);
ping -= (0.5f/nCmdRate) + TICKS_TO_TIME( 1.0f ); // correct latency
// in GoldSrc we had a different, not fixed tickrate. so we have to adjust
// Source pings by half a tick to match the old GoldSrc pings.
ping -= TICKS_TO_TIME( 0.5f );
ping = ping * 1000.0f; // as msecs
ptr->current_ping = clamp( ping, 5, 1000 ); // set bounds, dont show pings under 5 msecs
// Crude attempt to protect against all pings from being high and kicking everyone
if (ptr->current_ping < global_ping_limit)
{
all_pings_high = false;
}
}
for (int i = 0; i < max_players; i++)
{
if (!ping_list[i].check_ping ||
!ping_player_list[i].in_use)
{
continue;
}
if (all_pings_high)
{
ping_player_list[i].current_ping = mani_high_ping_kick_ping_limit.GetInt() / 2;
}
if (ping_list[i].count == 0)
{
// Init ping
ping_list[i].average_ping = ping_player_list[i].current_ping;
}
else
{
ping_list[i].average_ping += ping_player_list[i].current_ping;
}
// Bump up average ping
ping_list[i].count += 1;
if (ping_list[i].count > mani_high_ping_kick_samples_required.GetInt())
{
if ((ping_list[i].average_ping / ping_list[i].count) > mani_high_ping_kick_ping_limit.GetInt())
{
player_t *ptr = &(ping_player_list[i].player);
SayToAll (ORANGE_CHAT, false, "Player %s was autokicked for breaking the %ims ping limit on this server\n",
ptr->name,
mani_high_ping_kick_ping_limit.GetInt()
);
char log_reason[256];
snprintf(log_reason, sizeof(log_reason),
"[MANI_ADMIN_PLUGIN] Kicked player [%s] steam id [%s] for exceeding ping limit\n",
ptr->name, ptr->steam_id);
UTIL_KickPlayer(ptr,
(char *) mani_high_ping_kick_message.GetString(),
(char *) mani_high_ping_kick_message.GetString(),
log_reason);
ping_list[i].check_ping = false;
}
else
{
ping_list[i].count = 0;
}
}
}
}
//---------------------------------------------------------------------------------
// Purpose: Check Player on connect
//---------------------------------------------------------------------------------
bool ManiReservedSlot::NetworkIDValidated(player_t *player_ptr)
{
bool is_reserve_player = false;
player_t temp_player;
int allowed_players;
int total_players;
m_iUnaccountedPlayers--;
if ((war_mode) || (!mani_reserve_slots.GetBool()) || (mani_reserve_slots_number_of_slots.GetInt() == 0)) // with the other method ( zero slots )
{ // other player is kicked BEFORE
return true; // NetworkIDValidated
}
total_players = m_iUnaccountedPlayers + GetNumberOfActivePlayers(true);
// DirectLogCommand("[DEBUG] Total players on server [%i]\n", total_players);
if (total_players <= (max_players - mani_reserve_slots_number_of_slots.GetInt()))
{
// DirectLogCommand("[DEBUG] No reserve slot action required\n");
return true;
}
GetIPAddressFromPlayer(player_ptr);
Q_strcpy (player_ptr->steam_id, engine->GetPlayerNetworkIDString(player_ptr->entity));
IPlayerInfo *playerinfo = playerinfomanager->GetPlayerInfo(player_ptr->entity);
if (playerinfo && playerinfo->IsConnected())
{
Q_strcpy(player_ptr->name, playerinfo->GetName());
}
else
{
Q_strcpy(player_ptr->name,"");
}
if (FStrEq("BOT", player_ptr->steam_id))
return true;
player_ptr->is_bot = false;
if (IsPlayerInReserveList(player_ptr))
is_reserve_player = true;
else if (mani_reserve_slots_include_admin.GetBool() && gpManiClient->HasAccess(player_ptr->index, ADMIN, ADMIN_BASIC_ADMIN))
is_reserve_player = true;
if (mani_reserve_slots_allow_slot_fill.GetInt() != 1)
{
// Keep reserve slots free at all times
allowed_players = max_players - mani_reserve_slots_number_of_slots.GetInt();
if (total_players > allowed_players)
{
if (!is_reserve_player) {
DisconnectPlayer(player_ptr);
return false;
}
temp_player.index = FindPlayerToKick();
FindPlayerByIndex(&temp_player);
DisconnectPlayer(&temp_player);
}
}
return true;
}
DECL_MEMBER_DETOUR11_void(ConnectClientDetour, void *, int, int, int, const char *, const char *, const char*, int, void *, bool, CrossPlayPlatform_t ) {
CSteamID SteamID;
Q_memset ( &SteamID, 0, sizeof(SteamID) );
if ( p8 >= 20 )
memcpy ( &SteamID, &p7[20], sizeof(SteamID) );
#elif defined ( GAME_ORANGE )
#define CCD_MEMBER_CALL(pw) MEMBER_CALL(ConnectClientDetour)(p1,p2,p3,p4,p5,p6,pw,p8,p9)
DECL_MEMBER_DETOUR9_void(ConnectClientDetour, void *, int, int, int, int, const char *, const char *, const char*, int ) {
CSteamID SteamID;
Q_memset ( &SteamID, 0, sizeof(SteamID) );
if ( p9 >= 20 )
memcpy ( &SteamID, &p8[20], sizeof(SteamID) );
#else
#define CCD_MEMBER_CALL(pw) MEMBER_CALL(ConnectClientDetour)(p1,p2,p3,p4,p5,pw,p7,p8,p9,pA)
DECL_MEMBER_DETOUR10_void(ConnectClientDetour, void *, int, int, int, const char *, const char *, const char*, int, char const*, int ) {
CSteamID SteamID;
Q_memset ( &SteamID, 0, sizeof(SteamID) );
if ( pA >= 16 )
memcpy ( &SteamID, &p9[8], sizeof(SteamID) );
#endif
int total_players = m_iUnaccountedPlayers + GetNumberOfActivePlayers(true);
player_t player;
Q_memset ( &player, 0, sizeof(player) );
strcpy ( player.steam_id, SteamID.Render() );
bool AdminAccess = gpManiClient->HasAccess(&player, ADMIN, ADMIN_BASIC_ADMIN) && ( mani_reserve_slots_include_admin.GetInt() == 1 );
if ( FillSlotMode() ) {
if ( total_players == max_players ) {
if(SteamID.GetEAccountType() != 1 || SteamID.GetEUniverse() != 1)
#if defined ( GAME_CSGO )
return CCD_MEMBER_CALL(p6);
#elif defined ( GAME_ORANGE )
return CCD_MEMBER_CALL(p7);
#else
return CCD_MEMBER_CALL(p6);
#endif
bool ReservedAccess = gpManiReservedSlot->IsPlayerInReserveList(&player);
if ( AdminAccess || ReservedAccess ) {
int kick_index = gpManiReservedSlot->FindPlayerToKick();
if ( kick_index < 1 ) {
engine->LogPrint("MAP: Error, couldn't find anybody to kick for reserved slots!!!\n");
#if defined ( GAME_CSGO )
return CCD_MEMBER_CALL(p6);
#elif defined ( GAME_ORANGE )
return CCD_MEMBER_CALL(p7);
#else
return CCD_MEMBER_CALL(p6);
#endif
}
Q_memset ( &player, 0, sizeof(player) );
player.index = kick_index;
FindPlayerByIndex(&player);
gpManiReservedSlot->DisconnectPlayer(&player);
}
}
}
ConVar *pwd = g_pCVar->FindVar( "sv_password" );
if ( pwd && !FStrEq(pwd->GetString(),"")) {
if ( AdminAccess && !war_mode && !mani_reserve_slots_enforce_password.GetBool() ) {
return CCD_MEMBER_CALL(pwd->GetString());
}
}
#if defined ( GAME_CSGO )
return CCD_MEMBER_CALL(p6);
#elif defined ( GAME_ORANGE )
return CCD_MEMBER_CALL(p7);
#else
return CCD_MEMBER_CALL(p6);
#endif
}
