void killPlayers(int safeid, std::string kothcallsign)
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
for (unsigned int i = 0; i < playerList->size(); i++) {
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player) {
if (player->playerID != safeid) {
bz_killPlayer(player->playerID, true, koth.id);
if (koth.soundEnabled)
bz_sendPlayCustomLocalSound(player->playerID, "flag_lost");
} else if (koth.soundEnabled) {
bz_sendPlayCustomLocalSound(player->playerID, "flag_won");
}
}
bz_freePlayerRecord(player);
}
bz_deleteIntList(playerList);
bz_sendTextMessagef(BZ_SERVER, BZ_ALLUSERS, "%s IS KING OF THE HILL!", kothcallsign.c_str());
return;
}
virtual bool SlashCommand ( int playerID, bz_ApiString /*command*/, bz_ApiString /*message*/, bz_APIStringList* /*params*/ )
{
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerID);
if (!player)
return true;
if ( !player->admin )
{
bz_sendTextMessage(BZ_SERVER,playerID,"You do not have permission to run /killall");
bz_freePlayerRecord(player);
return true;
}
std::string msg = player->callsign.c_str();
msg += " has killed everyone";
bz_sendTextMessage(BZ_SERVER,BZ_ALLUSERS,msg.c_str());
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList ( playerList );
for ( unsigned int i = 0; i < playerList->size(); i++ )
bz_killPlayer(playerList->get(i),false);
bz_freePlayerRecord(player);
bz_deleteIntList(playerList);
return true;
}
void TimeLimit::Event ( bz_EventData *eventData )
{
switch(eventData->eventType)
{
case bz_ePlayerJoinEvent: {
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList (playerList);
// if it's the first player that joins , then reset the time to default
if ( playerList->size() == 1 && bz_isTimeManualStart() && !bz_isCountDownActive() && !bz_isCountDownInProgress()) {
bz_setTimeLimit(saveTimeLimit);
}
}
break;
//reset the time to default at gameover
case bz_eGameEndEvent: {
bz_setTimeLimit(saveTimeLimit);
}
break;
default: {
// do nothing
}
}
}
void killAllHunters(std::string messagepass)
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
for (unsigned int i = 0; i < playerList->size(); i++){
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player) {
if (player->team != eRabbitTeam) {
bz_killPlayer(player->playerID, true, BZ_SERVER);
bz_sendTextMessage(BZ_SERVER, player->playerID, messagepass.c_str());
if (rrzoneinfo.soundEnabled)
bz_sendPlayCustomLocalSound(player->playerID,"flag_lost");
}
if (player->team == eRabbitTeam &&
rrzoneinfo.soundEnabled &&
bz_getTeamCount(eHunterTeam) > 0)
bz_sendPlayCustomLocalSound(player->playerID,"flag_won");
bz_freePlayerRecord(player);
}
}
bz_deleteIntList(playerList);
return;
}
static void genoOtherTeam(bz_eTeamType team = eNoTeam, bool spawnOnBase = false, int killerID = -1, int bait = -1, const char* flagAbbr = NULL)
{
// Create a list of players
std::shared_ptr<bz_APIIntList> playerList(bz_getPlayerIndexList());
// If the playerlist is valid
if (playerList)
{
//if no team, kill everyone
if (team == eNoTeam && bait != -1 && bait == killerID)
{
for (unsigned int i = 0; i < playerList->size(); i++)
{
int playerID = playerList->get(i);
bz_killPlayer(playerID, spawnOnBase, killerID, flagAbbr);
}
}
else if (bait != -1 && bait == killerID)
{
for (unsigned int i = 0; i < playerList->size(); i++)
{
int playerID = playerList->get(i);
if (bz_getPlayerTeam(playerID) == team)
bz_killPlayer(playerID, spawnOnBase, killerID, flagAbbr);
}
}
}
}
void killTeams(bz_eTeamType safeteam, std::string keepawaycallsign)
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList ( playerList );
for ( unsigned int i = 0; i < playerList->size(); i++ ){
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player){
if (player->team != safeteam)
{
bz_killPlayer(player->playerID, true, BZ_SERVER);
if (keepaway.soundEnabled)
bz_sendPlayCustomLocalSound(player->playerID,"flag_lost");
}
else if (keepaway.soundEnabled)
bz_sendPlayCustomLocalSound(player->playerID,"flag_won");
}
bz_freePlayerRecord(player);
}
bz_deleteIntList(playerList);
bz_sendTextMessagef (BZ_SERVER, BZ_ALLUSERS, "%s (%s) Kept the Flag Away!", getTeamColor(safeteam), keepawaycallsign.c_str());
if (keepaway.flagResetEnabled)
bz_resetFlags(true);
return;
}
void KillTeam(bz_eTeamType TeamToKill)
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
for (unsigned int i = 0; i < playerList->size(); i++) {
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player) {
if (player->team == TeamToKill) {
bz_killPlayer(player->playerID, true, BZ_SERVER);
if (tctf.soundEnabled)
bz_sendPlayCustomLocalSound(player->playerID, "flag_lost");
} else if (tctf.soundEnabled) {
bz_sendPlayCustomLocalSound(player->playerID, "flag_won");
}
bz_freePlayerRecord(player);
}
}
bz_deleteIntList(playerList);
return;
}
bool teamClear(bz_eTeamType teamToCheck)
{
if (teamToCheck == eRogueTeam || teamToCheck == eNoTeam || !koth.teamPlay)
return true;
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
bool isOut = true;
for (unsigned int i = 0; i < playerList->size(); i++) {
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player) {
if (player->team == teamToCheck && kothzone.pointIn(player->currentState.pos) && player->spawned)
isOut = false;
}
bz_freePlayerRecord(player);
}
bz_deleteIntList(playerList);
return isOut;
}
void LogDetail::listPlayers( action act , bz_PlayerJoinPartEventData_V1 *data )
{
bz_APIIntList *playerList = bz_newIntList();
bz_BasePlayerRecord *player = NULL;
std::ostringstream msg;
char playerStatus;
int numPlayers;
bz_getPlayerIndexList( playerList );
bz_debugMessage( 4 , "Players:" );
//
// Count number of players
//
numPlayers = 0;
for ( unsigned int i = 0; i < playerList->size(); i++ ) {
player = bz_getPlayerByIndex( playerList->get(i));
if (player) {
if ((player->callsign != "") && (act == join || act == auth || (data && (player->playerID != data->playerID))))
numPlayers++;
bz_freePlayerRecord( player );
}
}
//
// Display number of players, callsign, and motto string in the following format:
//
// PLAYERS (nn) [G]cc:callsign(ee:mottostring)
// nn - number of players
// G - global auth identifier (+|-| |@)
// cc - count of characters in player callsign
// callsign - player callsign
// ee - count of characters in motto string
// mottostring - player motto string
//
// eg.
// PLAYERS (2) [@]7:Thumper(16:[email protected]) [ ]3:xxx()
//
msg.str("");
msg << "PLAYERS (" << numPlayers << ")";
for ( unsigned int i = 0; i < playerList->size(); i++ ) {
player = bz_getPlayerByIndex( playerList->get(i));
if (player) {
if ((player->callsign != "") && (act == join || act == auth || (data && (player->playerID != data->playerID)))) {
playerStatus = ' ';
if (player->globalUser) playerStatus = '+';
if (player->verified) playerStatus = '+';
if (player->admin && !bz_hasPerm(player->playerID, bz_perm_hideAdmin)) playerStatus = '@';
msg << " [" << playerStatus << "]";
msg << player->callsign.size() << ':';
msg << player->callsign.c_str() << "(" << bz_getPlayerMotto(player->playerID) << ")";
}
}
}
bz_debugMessage(0, msg.str().c_str());
bz_deleteIntList(playerList);
}
void initiatekeepaway(bz_eTeamType plyrteam, bz_ApiString plyrcallsign, int plyrID)
{
keepaway.team = plyrteam;
keepaway.callsign = plyrcallsign.c_str();
if (keepaway.callsign.size() > 16)
{
std::string tofix = truncate(keepaway.callsign, 16);
keepaway.callsign = tofix;
}
keepaway.id = plyrID;
keepaway.startTime = bz_getCurrentTime();
keepaway.TTHminutes = (int)(keepaway.adjustedTime/60 + 0.5);
keepaway.TTHseconds = 30;
keepaway.toldFlagFree = false;
bool multipleof30 = false;
if ((int)((keepaway.adjustedTime / 30) + 0.5) != (double)(keepaway.adjustedTime / 30))
multipleof30 = false;
else
multipleof30 = true;
if (!multipleof30)
{
if ((!keepaway.teamPlay || keepaway.team == eRogueTeam))
bz_sendTextMessagef (BZ_SERVER, BZ_ALLUSERS, "%s has %s flag; %i secs left!", keepaway.callsign.c_str(), keepaway.flagToKeep.c_str(), (int)keepaway.adjustedTime);
else
bz_sendTextMessagef (BZ_SERVER, BZ_ALLUSERS, "%s (%s) has %s flag; %i secs left!", getTeamColor(keepaway.team), keepaway.callsign.c_str(), keepaway.flagToKeep.c_str(), (int)keepaway.adjustedTime);
}
if (keepaway.soundEnabled)
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList ( playerList );
for ( unsigned int i = 0; i < playerList->size(); i++ )
{
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player)
{
if ((player->team != keepaway.team || player->team == eRogueTeam) && player->playerID != keepaway.id)
bz_sendPlayCustomLocalSound(player->playerID,"flag_alert");
else
bz_sendPlayCustomLocalSound(player->playerID,"teamgrab");
}
bz_freePlayerRecord(player);
}
bz_deleteIntList(playerList);
}
return;
}
bool anyPlayers ( void )
{
bool moreThenZero = false;
bz_APIIntList *players = bz_getPlayerIndexList();
if ( players->size() )
moreThenZero = true;
bz_deleteIntList(players);
return moreThenZero;
}
void buildStateHash(std::string ¶ms)
{
int hash = sumString(mapFile);
int i = 0;
i += bz_getTeamScore(eRedTeam);
i += bz_getTeamScore(eGreenTeam);
i += bz_getTeamScore(eBlueTeam);
i += bz_getTeamScore(ePurpleTeam);
i += bz_getTeamWins(eRedTeam);
i += bz_getTeamWins(eGreenTeam);
i += bz_getTeamWins(eBlueTeam);
i += bz_getTeamWins(ePurpleTeam);
i += bz_getTeamLosses(eRedTeam);
i += bz_getTeamLosses(eGreenTeam);
i += bz_getTeamLosses(eBlueTeam);
i += bz_getTeamLosses(ePurpleTeam);
hash += (i * 1000);
i = 0;
bz_APIIntList *players = bz_newIntList();
bz_getPlayerIndexList(players);;
if (players && players->size())
{
for (unsigned int p = 0; p < players->size(); p++ )
{
bz_BasePlayerRecord *player = bz_getPlayerByIndex(players->get(p));
//int playerID = players->get(p);
if (player)
{
std::string BZID = player->bzID.c_str();
if (BZID.size())
i += sumString(BZID);
else
i += sumString(std::string(player->callsign.c_str()));
i += sumString("NONE");
i += player->wins;
i += player->losses;
i += player->teamKills;
bz_freePlayerRecord(player);
}
}
}
bz_deleteIntList(players);
hash += (i * 100000);
params += format("&hash=%d",hash);
}
std::string getFlag()
{
if (keepaway.flagToKeepIndex < -1) // this should never happen, but save a crash if something goes nuts
return "";
// get next flag; if not free take it from player (if forced flags)
for (unsigned int h = 0; h < keepaway.flagsList.size(); h++) // check all specified flags
{
keepaway.flagToKeepIndex++; // get next one in line
if (keepaway.flagToKeepIndex > ((int)keepaway.flagsList.size() - 1)) // go back to start if at end
keepaway.flagToKeepIndex = 0;
std::string flagCandidate = keepaway.flagsList[keepaway.flagToKeepIndex];
bool flagNotHeld = true;
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList ( playerList );
for ( unsigned int i = 0; i < playerList->size(); i++ )
{
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player)
{
const char* playerFlag = bz_getPlayerFlag(player->playerID);
if (playerFlag)
{
if (playerFlag == flagCandidate && keepaway.forcedFlags) // take it, if forced flags
{
bz_removePlayerFlag (player->playerID);
bz_sendTextMessage (BZ_SERVER, player->playerID, "Sorry, server needs your flag for Keep Away :/");
}
if (playerFlag == flagCandidate && !keepaway.forcedFlags) // look for next free flag in list
flagNotHeld = false;
}
}
bz_freePlayerRecord(player);
}
bz_deleteIntList(playerList);
if (flagNotHeld)
return flagCandidate;
}
if (!keepaway.flagsList.empty()) // we should never get here, but if we do keep going
return keepaway.flagsList[0];
else
return "";
}
void RogueGenoHandler::Event (bz_EventData *eventData)
{
switch (eventData->eventType) {
default:
// no clue
break;
// wait for a tank death and start checking for genocide and rogues
case bz_ePlayerDieEvent:
{
bz_PlayerDieEventData_V1 *dieData = (bz_PlayerDieEventData_V1*)eventData;
//if its not a genocide kill, dont care
if (dieData->flagKilledWith != "G")
break;
// if the tank killed was not a rogue, let the server/client do the normal killing
if (dieData->team != eRogueTeam)
break;
// option to disallow rogues getting points for shooting themselves
if (!allowSuicide && dieData->killerID == dieData->playerID)
break;
// if the tank killed was a rogue, kill all rogues.
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
for (unsigned int i = 0; i < playerList->size(); i++) {
int targetID = (*playerList)[i];
bz_BasePlayerRecord *playRec = bz_getPlayerByIndex (targetID);
if (!playRec)
continue;
// the sucker is a spawned rogue, kill him. This generates another death event,
// so if you kill another rogue with geno while you are a rogue you end up dead too.
// and you get both messages (victim and be careful)
if (playRec->spawned && playRec->team == eRogueTeam) {
bz_killPlayer(targetID, false, dieData->killerID, "G");
bz_sendTextMessage(BZ_SERVER, targetID, "You were a victim of Rogue Genocide");
// oops, I ended up killing myself (directly or indirectly) with Genocide!
if (targetID == dieData->killerID)
bz_sendTextMessage(BZ_SERVER, targetID, "You should be more careful with Genocide!");
}
bz_freePlayerRecord(playRec);
}
bz_deleteIntList(playerList);
}
break;
}
}
void fairCTF::Event(bz_EventData *eventData)
{
if (eventData->eventType == bz_eAllowFlagGrab)
{
bz_AllowFlagGrabData_V1* grabData = (bz_AllowFlagGrabData_V1*)eventData;
if (!allowCTF)
{
// Don't allow a team flag grab
std::string flagtype = bz_getFlagName(grabData->flagID).c_str();
if (flagtype == "R*" || flagtype == "G*" || flagtype == "B*" || flagtype == "P*")
{
grabData->allow = false;
bz_sendTextMessage (BZ_SERVER, grabData->playerID, "CTF play is currently disabled.");
}
}
}
else if (eventData->eventType == bz_ePlayerJoinEvent)
{
UpdateState(eNoTeam);
}
else if (eventData->eventType == bz_ePlayerPartEvent)
{
bz_PlayerJoinPartEventData_V1* partData = (bz_PlayerJoinPartEventData_V1*)eventData;
// Need to compensate for that leaving player.
UpdateState(partData->record->team);
}
else if (eventData->eventType == bz_eTickEvent)
{
if (droptime != 0.0 && bz_getCurrentTime() >= droptime)
{
// Time to drop any team flags.
bz_APIIntList* pl = bz_getPlayerIndexList();
for (unsigned int x = 0; x < pl->size(); x++)
{
DropTeamFlag(pl->get(x));
}
droptime = 0.0;
}
}
else
{
// Huh?
return;
}
}
inline void checkKeepAwayHolder()
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList ( playerList );
for ( unsigned int i = 0; i < playerList->size(); i++ ){
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player)
{
const char* flagHeld = bz_getPlayerFlag(player->playerID);
if (flagHeld)
{
if (flagHeld == keepaway.flagToKeep && keepaway.id == -1) // gotta a new one; initiate
{
initiatekeepaway(player->team, player->callsign, player->playerID);
bz_freePlayerRecord(player);
bz_deleteIntList(playerList);
return;
}
if (flagHeld == keepaway.flagToKeep && keepaway.id == player->playerID) // someone still has it; leave
{
bz_freePlayerRecord(player);
bz_deleteIntList(playerList);
return;
}
if (flagHeld == keepaway.flagToKeep && keepaway.id != player->playerID) // must have stolen it
{
initiatekeepaway(player->team, player->callsign, player->playerID);
bz_freePlayerRecord(player);
bz_deleteIntList(playerList);
return;
}
}
}
bz_freePlayerRecord(player);
}
keepaway.id = -1; // no one has flag
keepaway.team = eNoTeam;
bz_deleteIntList(playerList);
return;
}
bool leagueOverSeer::isValidPlayerID(int playerID)
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
for (unsigned int i = 0; i < playerList->size(); i++) //Go through all the players
{
if (playerList->get(i) == playerID)
{
bz_deleteIntList(playerList);
return true;
}
}
bz_deleteIntList(playerList);
return false;
}
void playAlert()
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList ( playerList );
for ( unsigned int i = 0; i < playerList->size(); i++ )
{
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player)
bz_sendPlayCustomLocalSound(player->playerID,"hunt_select");
bz_freePlayerRecord(player);
}
bz_deleteIntList(playerList);
return;
}
int leagueOverSeer::isValidCallsign(std::string callsign)
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
for (unsigned int i = 0; i < playerList->size(); i++) //Go through all the players
{
if (strcmp(bz_getPlayerByIndex(playerList->get(i))->callsign.c_str(), callsign.c_str()) == 0)
{
int playerID = playerList->get(i);
bz_deleteIntList(playerList);
return playerID;
}
}
bz_deleteIntList(playerList);
return -1;
}
void killAllTeam(int winner, bz_eTeamType teamToKill, bz_eTeamType teamToAward)
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
for ( unsigned int i = 0; i < playerList->size(); i++ ){
int player = (*playerList)[i];
bz_BasePlayerRecord *PlayerRecord = bz_getPlayerByIndex(player);
if (PlayerRecord->team == teamToKill)
bz_killPlayer(player,0,winner);
else if(PlayerRecord->team == teamToAward)
bz_setPlayerWins(player, (bz_getPlayerWins(player)+2));
bz_freePlayerRecord(PlayerRecord);
}
bz_setTeamWins (teamToAward, (bz_getTeamWins(teamToAward)+1));
bz_setTeamLosses (teamToKill, (bz_getTeamLosses (teamToKill)+1));
}
void fairCTF::SetDropTime()
{
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
bool TeamFlagIsCarried = false;
// is any tank carrying a team flag?
for (unsigned int i = 0; i < playerList->size(); i++)
{
const char *FlagHeld = bz_getPlayerFlag((*playerList)[i]);
if (FlagHeld != NULL && (strcmp(FlagHeld, "R*") == 0 || strcmp(FlagHeld, "G*") == 0 || strcmp(FlagHeld, "B*") == 0 || strcmp(FlagHeld, "P*") == 0))
{
TeamFlagIsCarried = true;
break;
}
}
bz_deleteIntList(playerList);
// announce drop delay only if some tank is carrying a team flag
if (TeamFlagIsCarried)
{
if (drop_delay >= 0)
{
droptime = bz_getCurrentTime() + (double)drop_delay;
if (drop_delay > 1)
{
bz_sendTextMessage(BZ_SERVER, BZ_ALLUSERS, bz_format("Currently-held team flags will be dropped in %d seconds.", drop_delay));
}
else
{
bz_sendTextMessage(BZ_SERVER, BZ_ALLUSERS, "Currently-held team flags will be dropped in 1 second.");
}
}
else
{
bz_sendTextMessage(BZ_SERVER, BZ_ALLUSERS, "Currently-held team flags will not be dropped.");
}
}
}
void buildHTMLPlayerList ( std::string ¶ms, int skip = -1 )
{
bz_APIIntList *players = bz_newIntList();
bz_getPlayerIndexList(players);;
if (players && players->size())
{
int count = (int)players->size();
if (skip > 0)
count--;
params += format("&playercount=%d", count);
int index = 0;
for( unsigned int i = 0; i < players->size(); i++ )
{
int playerID = players->get(i);
if (playerID != skip)
{
buildHTMLPlayer(params,playerID,index);
index ++;
}
}
}
bz_deleteIntList(players);
}
void rabbitTimer::Event(bz_EventData *eventData)
{
if (eventData->eventType == bz_eTickEvent)
{
bz_TickEventData_V1* tickdata = (bz_TickEventData_V1*)eventData;
if (currentRabbit != -1 && tickdata->eventTime >= rabbitDeathTime)
{
//kill the wabbit!
bz_killPlayer(currentRabbit, false, BZ_SERVER);
//stopgap. the kill event should do this, really...
currentRabbit = -1;
rabbitDeathTime = (float)tickdata->eventTime + rabbitKillTimeLimit;
bz_sendTextMessage (BZ_SERVER, BZ_ALLUSERS, "Time's up! Selecting new rabbit.");
}
else if (currentRabbit == -1 && bz_getTeamCount(eHunterTeam) >= 3) //make sure we've got enough people before reactivating the timer
{
//find the new rabbit
bz_APIIntList pl;
bz_getPlayerIndexList(&pl);
for (unsigned int i = 0; i < pl.size() && currentRabbit == -1; i++)
{
bz_BasePlayerRecord* pr = bz_getPlayerByIndex(pl.get(i));
if (pr != NULL)
{
if (pr->team == eRabbitTeam)
{
currentRabbit = pr->playerID;
int limit = (int)rabbitKillTimeLimit;
bz_sendTextMessage(BZ_SERVER, currentRabbit, bz_format("You have %d seconds to make a kill!", limit));
}
bz_freePlayerRecord(pr);
}
}
}
}
else if (eventData->eventType == bz_ePlayerDieEvent)
{
bz_PlayerDieEventData_V1* killdata = (bz_PlayerDieEventData_V1*)eventData;
if (killdata->team == eRabbitTeam)
{
currentRabbit = -1; //we will sort this out on the next tick
rabbitDeathTime = (float)killdata->eventTime + rabbitKillTimeLimit;
}
else if (killdata->killerTeam == eRabbitTeam && currentRabbit != -1)
{
if (rollOver)
{
rabbitDeathTime += rabbitKillTimeLimit;
int limit = (int)rabbitKillTimeLimit;
int timeremaining = (int)(rabbitDeathTime - killdata->eventTime);
bz_sendTextMessage(BZ_SERVER, currentRabbit, bz_format("+%d seconds: %d seconds remaining.", limit, timeremaining));
}
else
{
rabbitDeathTime = (float)killdata->eventTime + rabbitKillTimeLimit;
int limit = (int)rabbitKillTimeLimit;
bz_sendTextMessage(BZ_SERVER, currentRabbit, bz_format("%d seconds remaining.", limit));
}
}
}
else if (eventData->eventType == bz_ePlayerDieEvent)
{
bz_PlayerJoinPartEventData_V1* partdata = (bz_PlayerJoinPartEventData_V1*)eventData;
if (partdata->record->team == eRabbitTeam) //we need to select a new rabbit if the rabbit leaves.
{
currentRabbit = -1; //we will sort this out on the next tick
rabbitDeathTime = (float)partdata->eventTime + rabbitKillTimeLimit;
}
}
}
void RabidRabbitEventHandler::Event(bz_EventData *eventData)
{
if (eventData->eventType == bz_ePlayerDieEvent)
{
bz_PlayerDieEventData_V1 *DieData = (bz_PlayerDieEventData_V1*)eventData;
if (rrzoneinfo.cycleOnDie && DieData->team == eRabbitTeam) {
unsigned int i = rrzoneinfo.currentKillZone;
if (i == (zoneList.size() - 1))
rrzoneinfo.currentKillZone = 0;
else
rrzoneinfo.currentKillZone++;
}
return;
}
if ((eventData->eventType != bz_eTickEvent) || (zoneList.size() < 2))
return;
for (unsigned int i = 0; i < zoneList.size(); i++) {
if (!zoneList[i].WWFired && rrzoneinfo.currentKillZone == i) {
bz_fireWorldWep(zoneList[i].WW.c_str(),
zoneList[i].WWLifetime,
BZ_SERVER,zoneList[i].WWPosition,
zoneList[i].WWTilt,
zoneList[i].WWDirection,
zoneList[i].WWShotID,
zoneList[i].WWDT);
zoneList[i].WWFired = true;
zoneList[i].WWLastFired = bz_getCurrentTime();
} else {
if ((bz_getCurrentTime() - zoneList[i].WWLastFired) > zoneList[i].WWRepeat)
zoneList[i].WWFired = false;
}
}
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
for (unsigned int h = 0; h < playerList->size(); h++) {
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](h));
if (player) {
for (unsigned int i = 0; i < zoneList.size(); i++) {
if (zoneList[i].pointIn(player->lastKnownState.pos) &&
player->spawned && player->team == eRabbitTeam &&
rrzoneinfo.currentKillZone != i && !rrzoneinfo.rabbitNotifiedWrongZone) {
bz_sendTextMessage(BZ_SERVER,player->playerID,
"You are not in the current Rabid Rabbit zone - try another.");
rrzoneinfo.rabbitNotifiedWrongZone = true;
rrzoneinfo.rabbitNotifiedWrongZoneNum = i;
}
if (!zoneList[i].pointIn(player->lastKnownState.pos) &&
player->spawned && player->team == eRabbitTeam &&
rrzoneinfo.rabbitNotifiedWrongZone &&
rrzoneinfo.rabbitNotifiedWrongZoneNum == i)
rrzoneinfo.rabbitNotifiedWrongZone = false;
if (zoneList[i].pointIn(player->lastKnownState.pos) &&
player->spawned &&
player->team == eRabbitTeam &&
rrzoneinfo.currentKillZone == i &&
bz_getTeamCount(eHunterTeam) > 0) {
killAllHunters(zoneList[i].servermessage);
rrzoneinfo.rabbitNotifiedWrongZone = true;
rrzoneinfo.rabbitNotifiedWrongZoneNum = i;
if (i == (zoneList.size() - 1))
rrzoneinfo.currentKillZone = 0;
else
rrzoneinfo.currentKillZone++;
rrzoneinfo.rabbitNotifiedWrongZone = true;
rrzoneinfo.rabbitNotifiedWrongZoneNum = i;
}
if (zoneList[i].pointIn(player->lastKnownState.pos) &&
player->spawned &&
player->team != eRabbitTeam &&
zoneList[i].zonekillhunter) {
bz_killPlayer(player->playerID, true, BZ_SERVER);
bz_sendTextMessage (BZ_SERVER, player->playerID, zoneList[i].playermessage.c_str());
}
}
bz_freePlayerRecord(player);
}
}
bz_deleteIntList(playerList);
return;
}
void LeagueOverseer::Event (bz_EventData *eventData)
{
switch (eventData->eventType)
{
case bz_eAllowFlagGrab: // This event is called each time a player attempts to grab a flag
{
bz_AllowFlagGrabData_V1* allowFlagGrabData = (bz_AllowFlagGrabData_V1*)eventData;
std::string flagAbbr = allowFlagGrabData->flagType;
int playerID = allowFlagGrabData->playerID;
if (isPcProtectionEnabled()) // Is the server configured to protect against Pass Camping
{
// Check if the last capture was within the 'PC_PROTECTION_DELAY' amount of seconds
if (LAST_CAP + getPcProtectionDelay() > bz_getCurrentTime())
{
// Check to see if the flag being grabbed belongs to the team that just had their flag captured AND check
// to see if someone not from the victim team grabbed it
if ((getTeamTypeFromFlag(flagAbbr) == CAP_VICTIM_TEAM && bz_getPlayerTeam(playerID) != CAP_VICTIM_TEAM))
{
// Disallow the flag grab if it's being grabbed by an enemy right after a flag capture
allowFlagGrabData->allow = false;
}
}
}
}
break;
case bz_eAllowSpawn: // This event is called before a player respawns
{
bz_AllowSpawnData_V2* allowSpawnData = (bz_AllowSpawnData_V2*)eventData;
int playerID = allowSpawnData->playerID;
if (!pluginSettings.isGuestSpawningEnabled(getCurrentGameMode()) && !isLeagueMember(playerID))
{
// Disable their spawning privileges
allowSpawnData->handled = true;
allowSpawnData->allow = false;
allowSpawnData->kickPlayer = false;
sendPluginMessage(playerID, pluginSettings.getGuestSpawningMessage(getCurrentGameMode()));
}
}
break;
case bz_eBZDBChange: // This event is called each time a BZDB variable is changed
{
bz_BZDBChangeData_V1* bzdbData = (bz_BZDBChangeData_V1*)eventData;
if (bzdbData->key == "_pcProtectionDelay")
{
// Save the proposed value in a variable for easy access
int proposedValue = std::stoi(bzdbData->value.c_str());
// Our PC protection delay should be between 3 and 30 seconds only, otherwise set it to the default 5 seconds
if (proposedValue < 3 || proposedValue > 30)
{
bz_setBZDBInt("_pcProtectionDelay", 5);
}
}
}
break;
case bz_eCaptureEvent: // This event is called each time a team's flag has been captured
{
if (isMatchInProgress())
{
bz_CTFCaptureEventData_V1* captureData = (bz_CTFCaptureEventData_V1*)eventData;
std::shared_ptr<bz_BasePlayerRecord> capperData(bz_getPlayerByIndex(captureData->playerCapping));
// Keep score
(captureData->teamCapping == TEAM_ONE) ? currentMatch.incrementTeamOneScore() : currentMatch.incrementTeamTwoScore();
// Store data for PC Protection
CAP_VICTIM_TEAM = captureData->teamCapped;
CAP_WINNER_TEAM = captureData->teamCapping;
LAST_CAP = captureData->eventTime;
logMessage(pluginSettings.getDebugLevel(), "debug", "%s captured the flag at %s",
capperData->callsign.c_str(), getMatchTime().c_str());
logMessage(pluginSettings.getDebugLevel(), "debug", "Match Score %s [%i] vs %s [%i]",
currentMatch.getTeamOneName().c_str(), currentMatch.getTeamOneScore(),
currentMatch.getTeamTwoName().c_str(), currentMatch.getTeamTwoScore());
CaptureMatchEvent capEvent = CaptureMatchEvent().setBZID(capperData->bzID.c_str())
.setTime(getMatchTime());
// If it's an official match, save the team ID
if (isOfficialMatch())
{
int teamID = (captureData->teamCapping == TEAM_ONE) ? currentMatch.getTeamOneID() : currentMatch.getTeamTwoID();
capEvent.setTeamID(teamID);
}
capEvent.save();
currentMatch.saveEvent(capEvent.getJsonObject());
currentMatch.stats_flagCapture(captureData->playerCapping);
logMessage(pluginSettings.getVerboseLevel(), "debug", "CaptureMatchEvent JSON -> %s", capEvent.toString());
}
}
break;
case bz_eGameEndEvent: // This event is called each time a game ends
{
logMessage(pluginSettings.getVerboseLevel(), "debug", "A match has ended.");
// Get the current standard UTC time
bz_Time stdTime;
bz_getUTCtime(&stdTime);
std::string recordingFileName;
// Only save the recording buffer if we actually started recording when the match started
if (RECORDING)
{
logMessage(pluginSettings.getVerboseLevel(), "debug", "Recording was in progress during the match.");
std::stringstream recordingName;
std::string _matchType = (isOfficialMatch()) ? "offi" : "fm",
_teamOneName = currentMatch.getTeamOneName(),
_teamTwoName = currentMatch.getTeamTwoName();
// (offi|fm)-YYYYMMDD
recordingName << _matchType << "-" << stdTime.year << formatInt("%02d", stdTime.month) << formatInt("%02d", stdTime.day);
if (!currentMatch.isRosterEmpty())
{
std::replace(_teamOneName.begin(), _teamOneName.end(), ' ', '_');
std::replace(_teamTwoName.begin(), _teamTwoName.end(), ' ', '_');
// Team_A-vs-Team_B
recordingName << "-" << _teamOneName << "-vs-" << _teamTwoName;
}
// -HHMM
recordingName << "-" << formatInt("%02d", stdTime.hour) << formatInt("%02d", stdTime.minute);
const std::string nameForHash = recordingName.str();
std::string hash = bz_MD5(nameForHash.c_str());
// -ACBD123
recordingName << "-" << hash.substr(0, 7);
if (currentMatch.matchCanceled())
{
// -Canceled
recordingName << "-Canceled";
}
recordingName << ".rec";
recordingFileName = recordingName.str();
logMessage(pluginSettings.getVerboseLevel(), "debug", "Replay file will be named: %s", recordingFileName.c_str());
// Save the recording buffer and stop recording
bz_saveRecBuf(recordingFileName.c_str(), 0);
bz_stopRecBuf();
logMessage(pluginSettings.getVerboseLevel(), "debug", "Replay file has been saved and recording has stopped.");
// We're no longer recording, so set the boolean and announce to players that the file has been saved
RECORDING = false;
bz_sendTextMessagef(BZ_SERVER, BZ_ALLUSERS, "Match saved as: %s", recordingFileName.c_str());
}
// Format the date to -> year-month-day hour:minute:second
char matchDate[20];
sprintf(matchDate, "%02d-%02d-%02d %02d:%02d:%02d", stdTime.year, stdTime.month, stdTime.day, stdTime.hour, stdTime.minute, stdTime.second);
currentMatch.save(matchDate, recordingFileName);
if (pluginSettings.isMatchReportEnabled())
{
if (!currentMatch.isRosterEmpty())
{
MatchUrlRepo.set("query", "matchReport")
.set("data", bz_urlEncode(currentMatch.toString().c_str()))
.submit();
if (currentMatch.isFM())
{
// It was a fun match, so there is no need to do anything
logMessage(pluginSettings.getVerboseLevel(), "debug", "Fun match has completed.");
}
else if (currentMatch.matchCanceled())
{
// The match was canceled for some reason so output the reason to both the players and the server logs
logMessage(pluginSettings.getDebugLevel(), "debug", "%s", currentMatch.getCancelation().c_str());
bz_sendTextMessage(BZ_SERVER, BZ_ALLUSERS, currentMatch.getCancelation().c_str());
}
else
{
logMessage(pluginSettings.getDebugLevel(), "debug", "Reporting match data...");
bz_sendTextMessage(BZ_SERVER, BZ_ALLUSERS, "Reporting match...");
// Send the match data to the league website
MATCH_INFO_SENT = true;
}
}
}
// Reset our match data
currentMatch = Match();
// Empty our list of players since we don't need a history
activePlayerList.clear();
}
break;
case bz_eGamePauseEvent:
{
bz_GamePauseResumeEventData_V2* gamePauseData = (bz_GamePauseResumeEventData_V2*)eventData;
// Get the current UTC time
MATCH_PAUSED = time(NULL);
// Send the messages
bz_sendTextMessagef(BZ_SERVER, BZ_ALLUSERS, " with %s remaining.", getMatchTime().c_str());
logMessage(pluginSettings.getVerboseLevel(), "debug", "Match paused at %s by %s.", getMatchTime().c_str(), bz_getPlayerCallsign(gamePauseData->playerID));
PauseResumeMatchEvent pauseEvent = PauseResumeMatchEvent();
pauseEvent.setState(true)
.setTime(getMatchTime())
.setBZID(getPlayerBZID(gamePauseData->playerID))
.save();
currentMatch.saveEvent(pauseEvent.getJsonObject());
logMessage(pluginSettings.getVerboseLevel(), "debug", "PauseResumeMatchEvent JSON -> %s", pauseEvent.toString());
}
break;
case bz_eGameResumeEvent:
{
bz_GamePauseResumeEventData_V2* gameResumeData = (bz_GamePauseResumeEventData_V2*)eventData;
// Get the current UTC time
time_t now = time(NULL);
// Do the math to determine how long the match was paused
double timePaused = difftime(now, MATCH_PAUSED);
// Create a temporary variable to store and manipulate the match start time
struct tm modMatchStart = *localtime(&MATCH_START);
// Manipulate the time by adding the amount of seconds the match was paused in order to be able to accurately
// calculate the amount of time remaining with LeagueOverseer::getMatchTime()
modMatchStart.tm_sec += timePaused;
// Save the manipulated match start time
MATCH_START = mktime(&modMatchStart);
logMessage(pluginSettings.getVerboseLevel(), "debug", "Match paused for %.f seconds. Match continuing at %s.", timePaused, getMatchTime().c_str());
PauseResumeMatchEvent resumeEvent = PauseResumeMatchEvent();
resumeEvent.setState(false)
.setTime(getMatchTime())
.setBZID(getPlayerBZID(gameResumeData->playerID))
.save();
currentMatch.saveEvent(resumeEvent.getJsonObject());
logMessage(pluginSettings.getVerboseLevel(), "debug", "PauseResumeMatchEvent JSON -> %s", resumeEvent.toString());
}
break;
case bz_eGameStartEvent: // This event is triggered when a timed game begins
{
logMessage(pluginSettings.getVerboseLevel(), "debug", "A match has started");
// Empty our list of players since we don't need a history
activePlayerList.clear();
// We started recording a match, so save the status
RECORDING = bz_startRecBuf();
// We want to notify the logs if we couldn't start recording just in case an issue were to occur and the server
// owner needs to check to see if players were lying about there no replay
if (RECORDING)
{
logMessage(pluginSettings.getVerboseLevel(), "debug", "Match recording has started successfully");
}
else
{
logMessage(0, "error", "This match could not be recorded");
}
currentMatch.setMatchDuration((int) bz_getTimeLimit());
MATCH_START = time(NULL);
}
break;
case bz_eGetAutoTeamEvent: // This event is called for each new player is added to a team
{
bz_GetAutoTeamEventData_V1* autoTeamData = (bz_GetAutoTeamEventData_V1*)eventData;
int playerID = autoTeamData->playerID;
std::shared_ptr<bz_BasePlayerRecord> playerData(bz_getPlayerByIndex(playerID));
// Only force new players to observer if a match is in progress
if (isMatchInProgress())
{
// Automatically move non-league members or players who just joined to the observer team
if (!isLeagueMember(playerID) || !playerAlreadyJoined(playerData->bzID.c_str()))
{
autoTeamData->handled = true;
autoTeamData->team = eObservers;
}
}
}
break;
case bz_eGetPlayerMotto: // This event is called when the player joins. It gives us the motto of the player
{
bz_GetPlayerMottoData_V2* mottoData = (bz_GetPlayerMottoData_V2*)eventData;
if (pluginSettings.isMottoFetchEnabled())
{
std::map<std::string, std::string> parameters;
parameters["{motto}"] = mottoData->motto;
parameters["{team}"] = getPlayerTeamNameByBZID(mottoData->record->bzID.c_str());
mottoData->motto = formatMotto(parameters);
}
}
break;
case bz_ePlayerDieEvent: // This event is called each time a tank is killed
{
bz_PlayerDieEventData_V1* dieData = (bz_PlayerDieEventData_V1*)eventData;
std::shared_ptr<bz_BasePlayerRecord> victimData(bz_getPlayerByIndex(dieData->playerID));
std::shared_ptr<bz_BasePlayerRecord> killerData(bz_getPlayerByIndex(dieData->killerID));
if (isMatchInProgress())
{
KillMatchEvent killEvent = KillMatchEvent();
killEvent.setKiller(killerData->bzID.c_str())
.setVictim(victimData->bzID.c_str())
.setTime(getMatchTime())
.save();
currentMatch.saveEvent(killEvent.getJsonObject());
logMessage(pluginSettings.getVerboseLevel(), "debug", "KillMatchEvent JSON -> %s", killEvent.toString());
}
}
break;
case bz_ePlayerJoinEvent: // This event is called each time a player joins the game
{
bz_PlayerJoinPartEventData_V1* joinData = (bz_PlayerJoinPartEventData_V1*)eventData;
int playerID = joinData->playerID;
std::shared_ptr<bz_BasePlayerRecord> playerData(bz_getPlayerByIndex(playerID));
setLeagueMember(playerID);
storePlayerInfo(playerID, playerData->bzID.c_str());
JoinMatchEvent joinEvent = JoinMatchEvent().setCallsign(playerData->callsign.c_str())
.setVerified(playerData->verified)
.setIpAddress(playerData->ipAddress.c_str())
.setBZID(playerData->bzID.c_str());
joinEvent.save();
// Only notify a player if they exist, have joined the observer team, and there is a match in progress
if (isMatchInProgress() && isValidPlayerID(joinData->playerID) && playerData->team == eObservers)
{
bz_sendTextMessagef(BZ_SERVER, joinData->playerID, "*** There is currently %s match in progress, please be respectful. ***",
((isOfficialMatch()) ? "an official" : "a fun"));
}
if (pluginSettings.isMottoFetchEnabled())
{
// Only send a URL job if the user is verified
if (playerData->verified)
{
requestTeamName(playerData->callsign.c_str(), playerData->bzID.c_str());
}
}
}
break;
case bz_ePlayerPartEvent: // This event is called each time a player leaves a game
{
bz_PlayerJoinPartEventData_V1* partData = (bz_PlayerJoinPartEventData_V1*)eventData;
int playerID = partData->playerID;
std::shared_ptr<bz_BasePlayerRecord> playerData(bz_getPlayerByIndex(playerID));
removePlayerInfo(partData->record->bzID.c_str());
// Only keep track of the parting player if they are a league member and there is a match in progress
if (isLeagueMember(playerID) && isMatchInProgress())
{
if (!playerAlreadyJoined(playerData->bzID.c_str()))
{
// Create a record for the player who just left
Player partingPlayer(playerData->bzID.c_str(), playerData->team, bz_getCurrentTime());
// Push the record to our vector
activePlayerList.push_back(partingPlayer);
}
}
}
break;
case bz_eRawChatMessageEvent: // This event is called for each chat message the server receives. It is called before any filtering is done.
{
bz_ChatEventData_V1* chatData = (bz_ChatEventData_V1*)eventData;
bz_eTeamType target = chatData->team;
int playerID = chatData->from,
recipient = chatData->to;
// The server is always allowed to talk
if (playerID == BZ_SERVER)
{
break;
}
// A non-league player is attempting to talk
if (!isLeagueMember(playerID))
{
std::string allowedChatTarget = pluginSettings.getAllowedTargetChat(getCurrentGameMode());
bool ignoreMessage = true;
if (allowedChatTarget == "Observers")
{
if (recipient == eObservers || bz_getPlayerTeam(recipient) == eObservers)
{
ignoreMessage = false;
}
}
else if (allowedChatTarget == "ObvserverAdmins")
{
if (bz_getPlayerTeam(recipient) == eObservers && isVisibleAdmin(recipient))
{
ignoreMessage = false;
}
}
else if (allowedChatTarget == "Admins")
{
if (target == eAdministrators || isVisibleAdmin(recipient))
{
ignoreMessage = false;
}
}
else if (allowedChatTarget == "All")
{
ignoreMessage = false;
}
if (ignoreMessage)
{
chatData->message = "";
sendPluginMessage(playerID, pluginSettings.getGuestMessagingMessage(getCurrentGameMode()));
}
}
}
break;
case bz_eTickEvent: // This event is called once for each BZFS main loop
{
// Get the total number of tanks playing
int totalTanks = bz_getTeamCount(eRedTeam) + bz_getTeamCount(eGreenTeam) + bz_getTeamCount(eBlueTeam) + bz_getTeamCount(ePurpleTeam);
// If there are no tanks playing, then we need to do some clean up
if (totalTanks == 0)
{
// If there is an official match and no tanks playing, we need to cancel it
if (isOfficialMatch())
{
currentMatch.cancelMatch("Official match automatically canceled due to all players leaving the match.");
}
// If we have players recorded and there's no one around, empty the list
if (!activePlayerList.empty())
{
activePlayerList.clear();
}
// If there is a countdown active an no tanks are playing, then cancel it
if (bz_isCountDownActive())
{
bz_gameOver(253, eObservers);
logMessage(pluginSettings.getVerboseLevel(), "debug", "Game ended because no players were found playing with an active countdown.");
}
}
// Let's get the roll call only if there is an official match
if (isOfficialMatch())
{
// Check if the start time is not negative since our default value for the approxTimeProgress is -1. Also check
// if it's time to do a roll call, which is defined as 90 seconds after the start of the match by default,
// and make sure we don't have any match participants recorded and the match isn't paused
if (getMatchProgress() > currentMatch.getMatchRollCall() && currentMatch.isRosterEmpty() &&
!bz_isCountDownPaused() && !bz_isCountDownInProgress())
{
logMessage(pluginSettings.getVerboseLevel(), "debug", "Processing roll call...");
// @TODO Make sure all of these variables are used
std::shared_ptr<bz_APIIntList> playerList(bz_getPlayerIndexList());
bool invalidateRollCall, teamOneError, teamTwoError;
std::string teamOneMotto, teamTwoMotto;
int teamOneID, teamTwoID;
invalidateRollCall = teamOneError = teamTwoError = false;
teamOneMotto = teamTwoMotto = "";
// We can't do a roll call if the player list wasn't created
if (!playerList)
{
logMessage(pluginSettings.getVerboseLevel(), "error", "Failure to create player list for roll call.");
return;
}
for (unsigned int i = 0; i < playerList->size(); i++)
{
bz_BasePlayerRecord* playerRecord = bz_getPlayerByIndex(playerList->get(i));
if (playerRecord && isLeagueMember(playerRecord->playerID) && bz_getPlayerTeam(playerList->get(i)) != eObservers) // If player is not an observer
{
currentMatch.savePlayer(playerRecord, getTeamIdFromBZID(playerRecord->bzID.c_str()));
// @TODO Rewrite this function to be updated
// Check if there is any need to invalidate a roll call from a team
//validateTeamName(invalidateRollCall, teamOneError, currentPlayer, teamOneMotto, TEAM_ONE);
//validateTeamName(invalidateRollCall, teamTwoError, currentPlayer, teamTwoMotto, TEAM_TWO);
}
bz_freePlayerRecord(playerRecord);
}
// We were asked to invalidate the roll call because of some issue so let's check if there is still time for
// another roll call
if (invalidateRollCall && currentMatch.incrementMatchRollCall(60) < currentMatch.getMatchDuration())
{
logMessage(pluginSettings.getDebugLevel(), "debug", "Invalid player found on field at %s.", getMatchTime().c_str());
// There was an error with one of the members of either team, so request a team name update for all of
// the team members to try to fix any inconsistencies of different team names
//if (teamOneError) { requestTeamName(TEAM_ONE); }
//if (teamTwoError) { requestTeamName(TEAM_TWO); }
// Delay the next roll call by 60 seconds
logMessage(pluginSettings.getVerboseLevel(), "debug", "Match roll call time has been delayed by 60 seconds.");
// Clear the struct because it's useless data
currentMatch.clearPlayerRoster();
logMessage(pluginSettings.getVerboseLevel(), "debug", "Match participants have been cleared.");
}
// There is no need to invalidate the roll call so the team names must be right so save them in the struct
if (!invalidateRollCall)
{
currentMatch.setTeamOneID(teamOneID).setTeamOneName(teamOneMotto)
.setTeamTwoID(teamTwoID).setTeamTwoName(teamTwoMotto);
logMessage(pluginSettings.getVerboseLevel(), "debug", "Team One set to: %s", currentMatch.getTeamOneName().c_str());
logMessage(pluginSettings.getVerboseLevel(), "debug", "Team Two set to: %s", currentMatch.getTeamTwoName().c_str());
}
}
}
}
break;
default: break;
}
}
void leagueOverSeer::Event(bz_EventData *eventData)
{
switch (eventData->eventType)
{
case bz_eCaptureEvent: //Someone caps
{
bz_CTFCaptureEventData_V1 *capData = (bz_CTFCaptureEventData_V1*)eventData;
if (officialMatch) //Only keep score if it's official
{
if (capData->teamCapping == teamOne) teamOnePoints++;
else if (capData->teamCapping == teamTwo) teamTwoPoints++;
}
}
break;
case bz_eGameEndEvent: //A /gameover or a match has ended
{
//Clear the bool variables
funMatch = false;
matchStartTime = 0;
matchParticipantsRecorded = false;
if (doNotReportMatch && officialMatch) //The match was canceled via /gameover or /superkill and we do not want to report these matches
{
officialMatch = false; //Match is over
doNotReportMatch = false; //Reset the variable for next usage
teamOnePoints = 0;
teamTwoPoints = 0;
matchPlayers.clear();
bz_debugMessage(DEBUG, "DEBUG :: League Over Seer :: Official match was not reported.");
bz_sendTextMessage(BZ_SERVER, BZ_ALLUSERS, "Official match was not reported.");
}
else if (officialMatch)
{
officialMatch = false; //Match is over
time_t t = time(NULL); //Get the current time
tm * now = gmtime(&t);
char match_date[20];
sprintf(match_date, "%02d-%02d-%02d %02d:%02d:%02d", now->tm_year + 1900, now->tm_mon + 1, now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec); //Format the date to -> year-month-day hour:minute:second
//Convert ints to std::string with std::ostringstream
std::ostringstream teamOnePointsConversion;
teamOnePointsConversion << (teamOnePoints);
std::ostringstream teamTwoPointsConversion;
teamTwoPointsConversion << (teamTwoPoints);
std::ostringstream matchTimeConversion;
matchTimeConversion << (matchDuration/60);
//Keep references to values for quick reference
std::string teamOnePointsFinal = teamOnePointsConversion.str();
std::string teamTwoPointsFinal = teamTwoPointsConversion.str();
std::string matchTimeFinal = matchTimeConversion.str();
// Store match data in the logs
bz_debugMessagef(DEBUG, "Match Data :: League Over Seer Match Report");
bz_debugMessagef(DEBUG, "Match Data :: -----------------------------");
bz_debugMessagef(DEBUG, "Match Data :: Match Time : %s", match_date);
bz_debugMessagef(DEBUG, "Match Data :: Duration : %s", matchTimeFinal.c_str());
bz_debugMessagef(DEBUG, "Match Data :: Team One Score : %s", teamOnePointsFinal.c_str());
bz_debugMessagef(DEBUG, "Match Data :: Team Two Score : %s", teamTwoPointsFinal.c_str());
// Start building POST data to be sent to the league website
std::string matchToSend = "query=reportMatch";
matchToSend += "&teamOneWins=" + std::string(bz_urlEncode(teamOnePointsFinal.c_str()));
matchToSend += "&teamTwoWins=" + std::string(bz_urlEncode(teamTwoPointsFinal.c_str()));
matchToSend += "&duration=" + std::string(bz_urlEncode(matchTimeFinal.c_str())) + "&matchTime=" + std::string(bz_urlEncode(match_date));
if (rotLeague) //Only add this parameter if it's a rotational league such as Open League
matchToSend += "&mapPlayed=" + std::string(bz_urlEncode(map.c_str()));
matchToSend += "&teamOnePlayers=";
bz_debugMessagef(DEBUG, "Match Data :: Team One Players");
for (unsigned int i = 0; i < matchPlayers.size(); i++) //Add all the red players to the match report
{
if (matchPlayers.at(i).team == teamOne)
{
matchToSend += std::string(bz_urlEncode(matchPlayers.at(i).bzid.c_str())) + ",";
bz_debugMessagef(DEBUG, "Match Data :: %s (%s)", matchPlayers.at(i).callsign.c_str(), matchPlayers.at(i).bzid.c_str());
}
}
matchToSend.erase(matchToSend.size() - 1);
matchToSend += "&teamTwoPlayers=";
bz_debugMessagef(DEBUG, "Match Data :: Team Two Players");
for (unsigned int i = 0; i < matchPlayers.size(); i++) //Add all the red players to the match report
{
if (matchPlayers.at(i).team == teamTwo)
{
matchToSend += std::string(bz_urlEncode(matchPlayers.at(i).bzid.c_str())) + ",";
bz_debugMessagef(DEBUG, "Match Data :: %s (%s)", matchPlayers.at(i).callsign.c_str(), matchPlayers.at(i).bzid.c_str());
}
}
matchToSend.erase(matchToSend.size() - 1);
bz_debugMessagef(DEBUG, "Match Data :: -----------------------------");
bz_debugMessagef(DEBUG, "Match Data :: End of Match Report");
bz_debugMessagef(DEBUG, "DEBUG :: League Over Seer :: Reporting match data...");
bz_sendTextMessage(BZ_SERVER, BZ_ALLUSERS, "Reporting match...");
bz_addURLJob(LEAGUE_URL.c_str(), this, matchToSend.c_str()); //Send the match data to the league website
//Clear all the structures and scores for next match
matchPlayers.clear();
teamOnePoints = 0;
teamTwoPoints = 0;
}
else
bz_debugMessage(DEBUG, "DEBUG :: League Over Seer :: Fun match was not reported.");
}
break;
case bz_eGameStartEvent: //The countdown has started
{
if (officialMatch) //Don't waste memory if the match isn't official
{
//Set the team scores to zero just in case
teamOnePoints = 0;
teamTwoPoints = 0;
matchDuration = bz_getTimeLimit();
matchStartTime = bz_getCurrentTime();
doNotReportMatch = false;
matchPlayers.clear();
}
}
break;
case bz_eGetPlayerMotto: // Change the motto of a player when they join
{
bz_GetPlayerMottoData_V2* mottoEvent = (bz_GetPlayerMottoData_V2*)eventData;
// Prepare the SQL query with the BZID of the player
sqlite3_bind_text(getPlayerMotto, 1, mottoEvent->record->bzID.c_str(), -1, SQLITE_TRANSIENT);
if (sqlite3_step(getPlayerMotto) == SQLITE_ROW) // If returns a team name, use it
mottoEvent->motto = (const char*)sqlite3_column_text(getPlayerMotto, 0);
else
mottoEvent->motto = "";
sqlite3_reset(getPlayerMotto); //Clear the prepared statement so it can be reused
}
case bz_ePlayerJoinEvent: //A player joins
{
bz_PlayerJoinPartEventData_V1 *joinData = (bz_PlayerJoinPartEventData_V1*)eventData;
if (!joinData)
return;
if ((bz_isCountDownActive() || bz_isCountDownInProgress()) && officialMatch)
bz_sendTextMessage(BZ_SERVER, joinData->playerID, "*** There is currently an official match in progress, please be respectful. ***");
else if ((bz_isCountDownActive() || bz_isCountDownInProgress()) && funMatch)
bz_sendTextMessage(BZ_SERVER, joinData->playerID, "*** There is currently a fun match in progress, please be respectful. ***");
if (joinData->record->verified)
{
// Build the POST data for the URL job
std::string teamMotto = "query=teamNameQuery";
teamMotto += "&teamPlayers=" + std::string(joinData->record->bzID.c_str());
bz_debugMessagef(DEBUG, "DEBUG :: League Over Seer :: Getting motto for %s...", joinData->record->callsign.c_str());
bz_addURLJob(LEAGUE_URL.c_str(), this, teamMotto.c_str()); //Send the team update request to the league website
}
}
break;
case bz_eSlashCommandEvent: //Someone uses a slash command
{
bz_SlashCommandEventData_V1 *commandData = (bz_SlashCommandEventData_V1*)eventData;
bz_BasePlayerRecord *playerData = bz_getPlayerByIndex(commandData->from);
std::string command = commandData->message.c_str(); //Use std::string for quick reference
if (strncmp("/gameover", commandData->message.c_str(), 9) == 0)
bz_sendTextMessagef(BZ_SERVER, commandData->from, "** '/gameover' is disabled, please use /finish or /cancel instead **");
else if (strncmp("/countdown pause", commandData->message.c_str(), 16) == 0)
bz_sendTextMessagef(BZ_SERVER, commandData->from, "** '/countdown pause' is disabled, please use /pause instead **");
else if (strncmp("/countdown resume", commandData->message.c_str(), 17 ) == 0)
bz_sendTextMessagef(BZ_SERVER, commandData->from, "** '/countdown resume' is disabled, please use /resume instead **");
else if (isdigit(atoi(commandData->message.c_str()) + 12))
bz_sendTextMessage(BZ_SERVER, commandData->from, "** '/countdown TIME' is disabled, please use /official or /fm instead **");
bz_freePlayerRecord(playerData);
}
break;
case bz_eTickEvent: //Tick tock tick tock...
{
int totaltanks = bz_getTeamCount(eRogueTeam) + bz_getTeamCount(eRedTeam) + bz_getTeamCount(eGreenTeam) + bz_getTeamCount(eBlueTeam) + bz_getTeamCount(ePurpleTeam);
if (totaltanks == 0)
{
//Incase a boolean gets messed up in the plugin, reset all the plugin variables when there are no players (Observers excluded)
officialMatch = false;
doNotReportMatch = false;
funMatch = false;
teamOnePoints = 0;
teamTwoPoints = 0;
//This should never happen but just incase the countdown is going when there are no tanks
if (bz_isCountDownActive())
bz_gameOver(253, eObservers);
}
if (matchStartTime > 0 && matchStartTime + matchRollCall < bz_getCurrentTime() && officialMatch && !matchParticipantsRecorded)
{
bool invalidateRollCall = false;
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList(playerList);
for (unsigned int i = 0; i < playerList->size(); i++)
{
bz_BasePlayerRecord *playerRecord = bz_getPlayerByIndex(playerList->get(i));
if (bz_getPlayerTeam(playerList->get(i)) != eObservers) //If player is not an observer
{
playersInMatch currentPlayer;
currentPlayer.team = playerRecord->team; //Add team to structure
currentPlayer.callsign = playerRecord->callsign.c_str(); //Add team to structure
currentPlayer.bzid = playerRecord->bzID.c_str(); //Add bzid to structure
if (std::string(playerRecord->bzID.c_str()).empty())
invalidateRollCall = true;
matchPlayers.push_back(currentPlayer);
}
bz_freePlayerRecord(playerRecord);
}
bz_deleteIntList(playerList);
if (invalidateRollCall && matchRollCall < matchDuration)
{
bz_debugMessagef(DEBUG, "DEBUG :: League Over Seer :: Invalid player found on field at %i:%i.", (int)(matchRollCall/60), (int)(fmod(matchRollCall,60.0)));
matchParticipantsRecorded = false;
matchRollCall += 30;
matchPlayers.clear();
}
else
matchParticipantsRecorded = true;
}
}
break;
default:
break;
}
}
void TeamFlagResetHandler::Event ( bz_EventData *eventData )
{
if (eventData->eventType != bz_eTickEvent)
return;
if (tfr.timerOff == true)
return;
bz_APIIntList *playerList = bz_newIntList();
bz_getPlayerIndexList ( playerList );
// check to see if anyone has picked up a team flag & count players per team
for ( unsigned int i = 0; i < playerList->size(); i++ ){
bz_BasePlayerRecord *player = bz_getPlayerByIndex(playerList->operator[](i));
if (player) {
tfr.flagTouched = bz_getPlayerFlag(player->playerID);
if (tfr.flagTouched){
if (strcmp(tfr.flagTouched, "R*") == 0){
tfr.redLastTouched = bz_getCurrentTime();
tfr.redFlagWasHeld = true;
}
if (strcmp(tfr.flagTouched, "G*") == 0){
tfr.greenLastTouched = bz_getCurrentTime();
tfr.greenFlagWasHeld = true;
}
if (strcmp(tfr.flagTouched, "B*") == 0){
tfr.blueLastTouched = bz_getCurrentTime();
tfr.blueFlagWasHeld = true;
}
if (strcmp(tfr.flagTouched, "P*") == 0){
tfr.purpleLastTouched = bz_getCurrentTime();
tfr.purpleFlagWasHeld = true;
}
}
bz_freePlayerRecord(player);
}
}
bz_deleteIntList(playerList);
// if no teamplay, no need to reset flags
tfr.OKToReset = false;
if (bz_getTeamCount(eRedTeam) * bz_getTeamCount(eGreenTeam) > 0)
tfr.OKToReset = true;
if (bz_getTeamCount(eRedTeam) * bz_getTeamCount(eBlueTeam) > 0)
tfr.OKToReset = true;
if (bz_getTeamCount(eRedTeam) * bz_getTeamCount(ePurpleTeam) > 0)
tfr.OKToReset = true;
if (bz_getTeamCount(eGreenTeam) * bz_getTeamCount(eBlueTeam) > 0)
tfr.OKToReset = true;
if (bz_getTeamCount(eGreenTeam) * bz_getTeamCount(ePurpleTeam) > 0)
tfr.OKToReset = true;
if (bz_getTeamCount(eBlueTeam) * bz_getTeamCount(ePurpleTeam) > 0)
tfr.OKToReset = true;
if (tfr.OKToReset == false){
ResetFlagData();
return;
}
// check if time's up on flags and reset (if they were held at least once after last reset)
if (bz_getCurrentTime() - tfr.redLastTouched > tfr.idleTime && tfr.redFlagWasHeld){
if (bz_getTeamCount(eRedTeam) > 0){
resetTeamFlag ("R*");
bz_sendTextMessagef (BZ_SERVER, BZ_ALLUSERS, "Red flag sat idle too long - reset by server.");
}
tfr.redFlagWasHeld = false;
tfr.redLastTouched = bz_getCurrentTime();
}
if (bz_getCurrentTime() - tfr.greenLastTouched > tfr.idleTime && tfr.greenFlagWasHeld){
if (bz_getTeamCount(eGreenTeam) > 0){
resetTeamFlag ("G*");
bz_sendTextMessagef (BZ_SERVER, BZ_ALLUSERS, "Green flag sat idle too long - reset by server.");
}
tfr.greenLastTouched = bz_getCurrentTime();
tfr.greenFlagWasHeld = false;
}
if (bz_getCurrentTime() - tfr.blueLastTouched > tfr.idleTime && tfr.blueFlagWasHeld){
if (bz_getTeamCount(eBlueTeam) > 0){
resetTeamFlag ("B*");
bz_sendTextMessagef (BZ_SERVER, BZ_ALLUSERS, "Blue flag sat idle too long - reset by server.");
}
tfr.blueLastTouched = bz_getCurrentTime();
tfr.blueFlagWasHeld = false;
}
if (bz_getCurrentTime() - tfr.purpleLastTouched > tfr.idleTime && tfr.purpleFlagWasHeld){
if (bz_getTeamCount(ePurpleTeam) > 0){
resetTeamFlag ("P*");
bz_sendTextMessagef (BZ_SERVER, BZ_ALLUSERS, "Purple flag sat idle too long - reset by server.");
}
tfr.purpleLastTouched = bz_getCurrentTime();
tfr.purpleFlagWasHeld = false;
}
return;
}
