bool MatchHelpers::playerBlockingRestart(const Player& p)
{
const Player* restarter;
if(myTeamInControl(p)) {
restarter = nearestOwnPlayerToBall(*p.getTeam());
}
else {
restarter = nearestOppositePlayerToBall(*p.getTeam());
}
return &p != restarter && (!playerPositionedForRestart(*restarter, p) ||
(p.getMatch()->getBall()->grabbed() &&
!myTeamInControl(p) &&
inOpposingPenaltyArea(p)));
}
SegmentedShotStrategy::SegmentedShotStrategy(ShotPath* _path, bool useSuperTexture, bool faint) :
ShotStrategy(_path)
{
// initialize times
prevTime = getPath().getStartTime();
lastTime = currentTime = prevTime;
// start at first segment
lastSegment = segment = 0;
// get team
Player* p = lookupPlayer(_path->getPlayer());
team = p ? p->getTeam() : RogueTeam;
// initialize scene nodes
boltSceneNode = new BoltSceneNode(_path->getPosition());
const float* c = Team::getRadarColor(team);
if (faint){
boltSceneNode->setColor(c[0], c[1], c[2],0.2f);
boltSceneNode->setTextureColor(1.0f,1.0f,1.0f,0.3f);
} else {
boltSceneNode->setColor(c[0], c[1], c[2], 1.0f);
}
TextureManager &tm = TextureManager::instance();
std::string imageName = Team::getImagePrefix(team);
if (useSuperTexture)
imageName += BZDB.get("superPrefix");
imageName += BZDB.get("boltTexture");
int texture = tm.getTextureID(imageName.c_str());
if (texture >= 0)
boltSceneNode->setTexture(texture);
}
/**
* @brief Debug function to print a player's inventory
*/
void G_InvList_f (const Player& player)
{
Edict* ent = nullptr;
gi.DPrintf("Print inventory for '%s'\n", player.pers.netname);
while ((ent = G_EdictsGetNextLivingActorOfTeam(ent, player.getTeam()))) {
gi.DPrintf("actor: '%s'\n", ent->chr.name);
const Container* cont = nullptr;
while ((cont = ent->chr.inv.getNextCont(cont, true))) {
Com_Printf("Container: %i\n", cont->id);
Item* item = nullptr;
while ((item = cont->getNextItem(item))) {
Com_Printf(".. item.def(): %i, item.ammo: %i, item.ammoLeft: %i, x: %i, y: %i\n",
(item->def() ? item->def()->idx : NONE), (item->ammoDef() ? item->ammoDef()->idx : NONE),
item->getAmmoLeft(), item->getX(), item->getY());
if (item->def())
Com_Printf(".... weapon: %s\n", item->def()->id);
if (item->ammoDef())
Com_Printf(".... ammo: %s (%i)\n", item->ammoDef()->id, item->getAmmoLeft());
}
}
const float invWeight = ent->chr.inv.getWeight();
const int maxWeight = ent->chr.score.skills[ABILITY_POWER];
const float penalty = GET_ENCUMBRANCE_PENALTY(invWeight, maxWeight);
const int normalTU = GET_TU(ent->chr.score.skills[ABILITY_SPEED], 1.0f - WEIGHT_NORMAL_PENALTY);
const int tus = GET_TU(ent->chr.score.skills[ABILITY_SPEED], penalty);
const int tuPenalty = tus - normalTU;
const char* penaltyStr = 1.0f - penalty < WEIGHT_NORMAL_PENALTY ? "'Light weight'" : (1.0f - penalty < WEIGHT_HEAVY_PENALTY ? "'Normal weight'" : "'Encumbered'");
Com_Printf("Weight: %g/%i, Encumbrance: %s (%.0f%%), TU's: %i (normal: %i, penalty/bonus: %+i)\n", invWeight, maxWeight, penaltyStr, invWeight / maxWeight * 100.0f, tus, normalTU, tuPenalty);
}
}
static void G_Players_f (const Player& player)
{
int count = 0;
char smallBuf[64];
char largeBuf[1280];
/* print information */
largeBuf[0] = 0;
Player* p = nullptr;
while ((p = G_PlayerGetNextActiveHuman(p))) {
Com_sprintf(smallBuf, sizeof(smallBuf), "(%i) Team %i %s status: %s\n", p->getNum(),
p->getTeam(), p->pers.netname, (p->roundDone ? "waiting" : "playing"));
/* can't print all of them in one packet */
if (strlen(smallBuf) + strlen(largeBuf) > sizeof(largeBuf) - 100) {
Q_strcat(largeBuf, sizeof(largeBuf), "...\n");
break;
}
Q_strcat(largeBuf, sizeof(largeBuf), "%s", smallBuf);
count++;
}
G_ClientPrintf(player, PRINT_CONSOLE, "%s\n%i players\n", largeBuf, count);
}
void G_EventEndRoundAnnounce (const Player& player)
{
G_EventAdd(PM_ALL, EV_ENDROUNDANNOUNCE, -1);
gi.WriteByte(player.getNum());
gi.WriteByte(player.getTeam());
G_EventEnd();
}
void G_EventReset (const Player& player, int activeTeam)
{
G_EventAdd(G_PlayerToPM(player), EV_RESET | EVENT_INSTANTLY, -1);
gi.WriteByte(player.getTeam());
gi.WriteByte(activeTeam);
G_EventEnd();
}
bool Player::operator==(const Player& other) const {
return true
&& _isNameSet(mgen::SHALLOW) == other._isNameSet(mgen::SHALLOW)
&& _isTeamSet(mgen::SHALLOW) == other._isTeamSet(mgen::SHALLOW)
&& getName() == other.getName()
&& getTeam() == other.getTeam();
}
void NetworkCore::PlayerSpawn( RakNet::BitStream *bitStream, RakNet::Packet *pkt )
{
// Do some checking here to make sure the player is allowed to spawn before sending the RPC back
CarType iCarType;
bitStream->Read( iCarType );
int size = GameCore::mPlayerPool->getNumberOfPlayers();
Player *pPlayer = GameCore::mPlayerPool->getPlayer( pkt->guid );
unsigned char packetid;
RakNet::BitStream bsSpawn;
if( pPlayer->getPlayerState() != PLAYER_STATE_SPAWN_SEL )
{
return;
}
// Don't allow spawn if they haven't selected a team yet
if( pPlayer->getTeam() == NO_TEAM )
{
packetid = ID_SPAWN_NO_TEAM;
bsSpawn.Write( packetid );
bsSpawn.Write( pkt->guid );
bsSpawn.Write( 0 ); // Arbitrary car type, gets ignored
m_RPC->Signal( "PlayerSpawn", &bsSpawn, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pkt->guid, false, false );
pPlayer->setPlayerState( PLAYER_STATE_TEAM_SEL );
return;
}
if( GameCore::mGameplay->mGameActive == false )
{
//packetid = ID_SPAWN_GAME_INACTIVE;
//bsSpawn.Write( packetid );
//m_RPC->Signal( "PlayerSpawn", &bsSpawn, HIGH_PRIORITY, RELIABLE_ORDERED, 0, pkt->guid, false, false );
pPlayer->setCarType( iCarType );
pPlayer->setPlayerState( PLAYER_STATE_INGAME );
// Check how many players we now have spawned
int size = GameCore::mPlayerPool->getNumberOfPlayers();
int c = 0;
for(int i=0;i<size;i++)
{
Player* tmpPlayer = GameCore::mPlayerPool->getPlayer(i);
if( tmpPlayer->getPlayerState() == PLAYER_STATE_INGAME )
c ++;
}
// Start the game (will cause all waiting players to spawn)
if( GameCore::mGameplay->mGameActive == false && c >= NUM_PLAYERS_TO_START )
GameCore::mGameplay->startGame();
// return;
}
pPlayer->setCarType( iCarType );
GameCore::mNetworkCore->sendPlayerSpawn( pPlayer );
return;
}
void Flag::collideTo(Player& player) {
if (!isDead()) {
receiveDamage(player);
if (life <= 0) {
killedBy = player.getTeam();
}
}
}
/**
* @brief Write player stats to network buffer
* @sa G_SendStats
*/
void G_SendPlayerStats (const Player& player)
{
Edict* ent = nullptr;
while ((ent = G_EdictsGetNextActor(ent)))
if (ent->team == player.getTeam()) {
G_EventActorStats(*ent, G_PlayerToPM(player));
G_SendWoundStats(ent);
}
}
/**
* @brief Sets visible edict on player spawn
* @sa G_ClientStartMatch
* @sa G_CheckVisTeam
* @sa G_AppearPerishEvent
*/
void G_CheckVisPlayer (Player& player, const vischeckflags_t visFlags)
{
Edict* ent = nullptr;
/* check visibility */
while ((ent = G_EdictsGetNextInUse(ent))) {
/* check if he's visible */
G_DoTestVis(player.getTeam(), ent, visFlags, G_PlayerToPM(player), nullptr);
}
}
/**
* @brief Check whether a forced turn end should be executed
*/
void G_CheckForceEndRound (void)
{
/* check for roundlimits in multiplayer only */
if (!sv_roundtimelimit->integer || G_IsSinglePlayer())
return;
if (!G_MatchIsRunning())
return;
if (level.time != ceil(level.time))
return;
const int diff = level.roundstartTime + sv_roundtimelimit->integer - level.time;
switch (diff) {
case 240:
gi.BroadcastPrintf(PRINT_HUD, _("4 minutes left until forced turn end."));
return;
case 180:
gi.BroadcastPrintf(PRINT_HUD, _("3 minutes left until forced turn end."));
return;
case 120:
gi.BroadcastPrintf(PRINT_HUD, _("2 minutes left until forced turn end."));
return;
case 60:
gi.BroadcastPrintf(PRINT_HUD, _("1 minute left until forced turn end."));
return;
case 30:
gi.BroadcastPrintf(PRINT_HUD, _("30 seconds left until forced turn end."));
return;
case 15:
gi.BroadcastPrintf(PRINT_HUD, _("15 seconds left until forced turn end."));
return;
}
/* active team still has time left */
if (level.time < level.roundstartTime + sv_roundtimelimit->integer)
return;
gi.BroadcastPrintf(PRINT_HUD, _("Current active team hit the max round time."));
/* store this in a local variable, as the global variable is changed in G_ClientEndRound */
const int activeTeam = level.activeTeam;
/* set all team members to ready (only human players) */
Player* p = nullptr;
while ((p = G_PlayerGetNextActiveHuman(p))) {
if (p->getTeam() == activeTeam) {
G_ClientEndRound(*p);
level.nextEndRound = level.framenum;
}
}
level.roundstartTime = level.time;
}
static void G_Say_f (Player& player, bool arg0, bool team)
{
if (gi.Cmd_Argc() < 2 && !arg0)
return;
if (G_CheckFlood(player))
return;
char text[256];
if (arg0) {
Com_sprintf(text, sizeof(text), "%s %s", gi.Cmd_Argv(0), gi.Cmd_Args());
} else {
Com_sprintf(text, sizeof(text), "%s", gi.Cmd_Args());
}
/* strip quotes */
char* s = text;
if (s[0] == '"' && s[strlen(s) - 1] == '"') {
s[strlen(s) - 1] = '\0';
s++;
}
if (sv_dedicated->integer) {
if (!team)
gi.DPrintf("%s: %s\n", player.pers.netname, s);
else
gi.DPrintf("^B%s (team): %s\n", player.pers.netname, s);
}
Player* p = nullptr;
while ((p = G_PlayerGetNextActiveHuman(p))) {
if (team && p->getTeam() != player.getTeam())
continue;
if (!team)
G_ClientPrintf(*p, PRINT_CHAT, "%s: %s\n", player.pers.netname, s);
else
G_ClientPrintf(*p, PRINT_CHAT, "^B%s (team): %s\n", player.pers.netname, s);
}
}
/// @brief Set up the game for a particular player. Sends PlayerJoin for each
/// connected client, then an overall update on gamestate
void NetworkCore::SetupGameForPlayer( RakNet::RakNetGUID playerid )
{
Player *playerSend;
int size = GameCore::mPlayerPool->getNumberOfPlayers();
for( int j = 0; j < size; j ++ )
{
// Don't send a new client PlayerJoin of themselves
if( GameCore::mPlayerPool->getPlayerGUID( j ) == playerid )
continue;
playerSend = GameCore::mPlayerPool->getPlayer( j );
if( playerSend )
{
RakNet::BitStream bsJoin;
bsJoin.Write( GameCore::mPlayerPool->getPlayerGUID( j ) );
bsJoin.Write( playerSend->getTeam() );
//RakNet::RakString *strName = new RakNet::RakString("RemotePlayer");
RakNet::StringCompressor().EncodeString( playerSend->getNickname(), 128, &bsJoin );
m_RPC->Signal( "PlayerJoin", &bsJoin, HIGH_PRIORITY, RELIABLE_ORDERED, 0, playerid, false, false );
if( playerSend->getCar() )
{
unsigned char packetid;
RakNet::BitStream bsSpawn;
packetid = ID_SPAWN_SUCCESS;
bsSpawn.Write( packetid );
bsSpawn.Write( GameCore::mPlayerPool->getPlayerGUID( j ) );
bsSpawn.Write( playerSend->getCarType() );
//bsSpawn.Write( playerSend->getVIP() );
m_RPC->Signal( "PlayerSpawn", &bsSpawn, HIGH_PRIORITY, RELIABLE_ORDERED, 0, playerid, false, false );
}
}
}
for( int j = 0; j < MAX_POWERUPS; j ++ )
{
if( GameCore::mPowerupPool->getPowerup( j ) )
{
RakNet::BitStream bsSend;
bsSend.Write( j );
bsSend.Write( GameCore::mPowerupPool->getPowerup( j )->getType() );
bsSend.Write( GameCore::mPowerupPool->getPowerup( j )->getPosition() );
m_RPC->Signal( "PowerupCreate", &bsSend, HIGH_PRIORITY, RELIABLE_ORDERED, 0, playerid, false, false );
}
}
GamestateUpdatePlayer( playerid );
}
void HomingMissile::acquireTarget(void)
{
int best_target = -1;
float best_dist = 10000;
for(Server::Entpool::iterator ii=server->entities.begin(); ii!=server->entities.end(); ii++)
{
if(!ii->second->isPlayer())
continue;
Player *ent = (Player*)ii->second;
float dist = (ent->getPosition().positionVector() - targetPos).getMagnitude();
if(dist > best_dist)
continue;
if(ent->shouldDelete() || !ent->canCollideWith(this))
continue;
if(ent->getTeam() == ownerTeam && ownerTeam != team_free)
continue;
best_target = ent->getEntId();
best_dist = dist;
}
target = best_target;
}
Vector3 MatchHelpers::ownGoalPosition(const Player& p)
{
return ownGoalPosition(*p.getTeam());
}
/**
* @sa G_PlayerSoldiersCount
*/
void G_ClientEndRound (Player& player)
{
Player* p;
const int lastTeamIndex = (G_GetActiveTeam() + level.teamOfs) % MAX_TEAMS;
if (!G_IsAIPlayer(&player)) {
/* inactive players can't end their inactive turn :) */
if (level.activeTeam != player.getTeam())
return;
/* check for "team oszillation" */
if (level.framenum < level.nextEndRound)
return;
level.nextEndRound = level.framenum + 20;
}
/* only use this for teamplay matches like coopX or fight2on2 and above
* also skip this for ai players, this is only called when all ai actors
* have finished their 'thinking' */
if (!G_IsAIPlayer(&player) && sv_teamplay->integer) {
/* check if all team members are ready */
if (!player.roundDone) {
player.roundDone = true;
G_EventEndRoundAnnounce(player);
G_EventEnd();
}
p = nullptr;
while ((p = G_PlayerGetNextActiveHuman(p)))
if (p->getTeam() == level.activeTeam && !p->roundDone && G_PlayerSoldiersCount(*p) > 0)
return;
p = nullptr;
while ((p = G_PlayerGetNextActiveAI(p)))
if (p->getTeam() == level.activeTeam && !p->roundDone && G_PlayerSoldiersCount(*p) > 0)
return;
} else {
player.roundDone = true;
}
/* clear any remaining reaction fire */
G_ReactionFireOnEndTurn();
if (!G_IsAIPlayer(&player)) {
if (g_lastseen->integer > 0) {
Edict* ent = nullptr;
while ((ent = G_EdictsGetNextActor(ent))) {
if (G_IsAI(ent) && G_IsVisibleForTeam(ent, level.activeTeam)) {
player.lastSeen = level.actualRound;
break;
}
}
if (level.actualRound - player.lastSeen > g_lastseen->integer) {
Com_Printf("round end triggered by g_lastseen (player %i (team %i) last seen in round %i of %i rounds)\n",
player.getNum(), level.activeTeam, player.lastSeen, level.actualRound);
G_MatchEndTrigger(-1, 0);
}
}
}
/* let all the invisible players perish now */
G_CheckVisTeamAll(level.activeTeam, VIS_APPEAR, nullptr);
G_GetNextActiveTeam();
AI_CheckRespawn(TEAM_ALIEN);
/* no other team left? */
if (!G_MatchIsRunning())
return;
if (lastTeamIndex > (level.activeTeam + level.teamOfs) % MAX_TEAMS)
level.actualRound++;
/* communicate next player in row to clients */
G_EventEndRound();
/* store the round start time to be able to abort the round after a give time */
level.roundstartTime = level.time;
/* Wounded team members bleed */
G_BleedWounds(level.activeTeam);
/* Update the state of stuned team-members. The actual statistics are sent below! */
G_UpdateStunState(level.activeTeam);
/* Give the actors of the now active team their TUs. */
G_GiveTimeUnits(level.activeTeam);
/* apply morale behaviour, reset reaction fire */
G_ReactionFireReset(level.activeTeam);
if (mor_panic->integer)
G_MoraleBehaviour(level.activeTeam);
G_UpdateCarriedWeight(level.activeTeam);
/* start ai - there is only one player for ai teams, and the last pointer must only
* be updated for ai players */
p = G_GetPlayerForTeam(level.activeTeam);
if (p == nullptr)
gi.Error("Could not find player for team %i", level.activeTeam);
/* finish off events */
G_EventEnd();
/* reset ready flag for every player on the current team (even ai players) */
p = nullptr;
while ((p = G_PlayerGetNextActiveHuman(p))) {
if (p->getTeam() == level.activeTeam) {
p->roundDone = false;
}
}
p = nullptr;
while ((p = G_PlayerGetNextActiveAI(p))) {
if (p->getTeam() == level.activeTeam) {
p->roundDone = false;
}
}
}
bool MatchHelpers::myTeamInControl(const Player& p)
{
return p.getMatch()->getReferee()->isFirstTeamInControl() == p.getTeam()->isFirst();
}
bool MatchHelpers::attacksUp(const Player& p)
{
return attacksUp(*p.getTeam());
}
bool MatchHelpers::nearestOwnPlayerTo(const Player& p, const Vector3& v)
{
Player* np = nearestOwnPlayerTo(*p.getTeam(), v);
return &p == np;
}
bool MatchHelpers::isOpposingPlayer(const Player& p1, const Player& p2)
{
return p1.getTeam()->isFirst() != p2.getTeam()->isFirst();
}
