qf/prozac-qfcc
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/prozac-qfcc synced 2025-03-02 07:31:54 +00:00
Code Issues Projects Releases Packages Wiki Activity
prozac-qfcc/tforttm.qc
Finny Merrill db4e96e70a Engineer tweaks: 
1) added checkmove forward so it's easier to build against walls
2) Can't build sentries on top of forcefields anymore (they get bounced off)
3) fieldgens are now one unit taller than their fields, so you CAN build on the gen
4) forcefields bounce everything (including buildings) away now.
5) added #ifdef DISALLOW_BLOCKED_TELE around tele block checks. didn't get the point

Debug tweaks:
1) added #ifdef DEBUG, which enables RPrint(), dremove(), and printtrace(), as well
   as the warlock cheat and origin reporting.
2) replaced EVERY dprint with RPrint.
3) changed makefile so that all = no DEBUG and no .sym
2003-11-27 07:07:26 +00:00

1251 lines
28 KiB
C++
Raw Blame History

/*
TeamFortress 2.1 - 22/1/97
TeamFortress Software
Robin Walker, John Cook, Ian Caughley.
Functions handling all the help displaying for TeamFortress.
*/
#include "defs.qh"
// Prototypes
// Team Functions
float() TeamFortress_TeamPutPlayerInTeam;
float(float tno) TeamFortress_TeamSet;
float(float tno) TeamGetColor;
void(float tno) TeamFortress_TeamSetColor;
void() TeamFortress_CheckTeamCheats;
void(float tno, float scoretoadd) TeamFortress_TeamIncreaseScore;
float(float tno) TeamFortress_TeamGetScore;
float (float tno) TeamFortress_TeamGetLives;
float(float tno) TeamFortress_TeamGetNoPlayers;
float (float tno) TeamFortress_TeamGetMaxPlayers;
float() TeamFortress_TeamGetWinner;
void(float tno) TeamFortress_TeamShowScores;
string(float tno) TeamFortress_TeamGetColorString;
void(entity Player) TeamFortress_TeamShowMemberClasses;
float(float tno) TeamFortress_TeamGetIllegalClasses;
float(float tno) TeamFortress_TeamIsCivilian;
void(entity p) SetTeamName;
string(float tno) GetTrueTeamName;
//-------- OfN ---------------------------------//
void(float tno, entity ignore) teamprefixsprint;
//- OfN - Extra cheat checking...
float (string skin_str) Is_TF_Skin;
float (float tno, float theColor ) IsValidTopColor;
//=========================================================================
// TEAM FUNCTIONS
//=========================================================================
// Put the player into the team with the least number of players in it. Return TRUE if successful
float() TeamFortress_TeamPutPlayerInTeam =
{
local float lowest, lowest_num;
local float i, i_num;
local float teams_with_vacancy = 0;
local float maxplayers, curplayers;
for (i = 1; i <= number_of_teams; i = i + 1) {
maxplayers = TeamFortress_TeamGetMaxPlayers (i);
curplayers = TeamFortress_TeamGetNoPlayers (i);
if (curplayers < maxplayers)
teams_with_vacancy = teams_with_vacancy + 1;
}
lowest = 0;
lowest_num = -1;
for (i = 1; i <= number_of_teams; i = i + 1) {
i_num = TeamFortress_TeamGetNoPlayers(i);
if (TeamFortress_TeamGetMaxPlayers (i) > i_num) {
if (i_num < lowest_num // eww, ugly
|| lowest_num == -1
|| (i_num == lowest_num
&& random () < 1 / teams_with_vacancy)) {
lowest = i;
lowest_num = i_num;
}
}
}
if (lowest == 0) { // ummm, I don't think this should be possible..
sprint (self, PRINT_HIGH, "All teams are full!\n");
return 0;
}
return TeamFortress_TeamSet (lowest);
};
//=========================================================================
// Return the color for the team corresponding to the no passed in
float(float tno) TeamGetColor =
{
if (tno == 1)
return DARKBLUE;
if (tno == 2)
return RED;
if (tno == 3)
return YELLOW;
if (tno == 4)
return DARKGREEN;
return 0;
};
//=========================================================================
// Set the color for the team corresponding to the no passed in, to self.team_no
void(float tno) TeamFortress_TeamSetColor =
{
if (tno == 1)
{
team1col = DARKBLUE;
return;
}
if (tno == 2)
{
team2col = RED;
return;
}
if (tno == 3)
{
team3col = YELLOW;
return;
}
if (tno == 4)
{
team4col = DARKGREEN;
return;
}
};
string(float tno) GetTeamName =
{
local string st;
if (tno == 1)
{
/*if (world.b_b && world.b_b)
{
return world.b_b;
}*/
st = infokey(NIL, "team1");
if (!st)
st = infokey(NIL, "t1");
if (!st || st == "")
return "blue";
}
else if (tno == 2)
{
/*if (world.b_t != "" && world.b_t)
{
return world.b_t;
}*/
st = infokey(NIL, "team2");
if (!st)
st = infokey(NIL, "t2");
if (!st)
return "red";
}
else if (tno == 3)
{
/*if (world.b_n != "" && world.b_n)
{
return world.b_n;
}*/
st = infokey(NIL, "team3");
if (!st)
st = infokey(NIL, "t3");
if (!st)
return "yell";
}
else if (tno == 4)
{
/*if (world.b_o != "" && world.b_o)
{
return world.b_o;
}*/
st = infokey(NIL, "team4");
if (!st)
st = infokey(NIL, "t4");
if (!st)
return "teal";
}
else
st = "";
return st;
};
//returns only the team color
string(float tno) GetTrueTeamName =
{
if (tno == 1)
return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
else if (tno == 2)
return "<EFBFBD><EFBFBD><EFBFBD>";
else if (tno == 3)
return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
else if (tno == 4)
return "<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
else
return "ERROR";
};
void(entity p) SetTeamName =
{
local string st;
st = GetTeamName(p.team_no);
stuffcmd(p, "team \""); //careful about empty team
stuffcmd(p, st);
stuffcmd(p, "\"\n");
setinfokey(p, "team", st);
};
//=========================================================================
// Set the current player's.team_no to self.impulse. Return TRUE if successful
float(float tno) TeamFortress_TeamSet =
{
local string st;
local float tc, tc2;
if (teamplay < 1)
{
sprint (self, PRINT_HIGH, "Teamplay is not On, so FortressTeams are inactive.\n");
return FALSE;
}
/* if (chris)
if (prematch > time)
{
sprint(self, PRINT_HIGH, "Sorry, Chris' Teamplay Plus Mode is active and a round is in progress. Please wait for the next round to begin.\n");
PlayerObserverMode();
}*/
if (tno > number_of_teams && number_of_teams != 0)
{
sprint (self, PRINT_HIGH, "There can be only ");
st = ftos(number_of_teams);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, " teams on this map.\nTry again\n");
return FALSE;
}
if (self.team_no > 0)
{
sprint (self, PRINT_HIGH, "You're already in Team No ");
st = ftos(self.team_no);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, ".\n");
return FALSE;
}
tc = TeamFortress_TeamGetNoPlayers(tno);
if (tc >= TeamFortress_TeamGetMaxPlayers(tno))
{
//- OfN
if (mapname == "huntedr")
{
if (tno == 3)
sprint (self, PRINT_HIGH, "The game has already enough assassins, be a bodyguard.\n");
else if (tno == 1)
sprint (self, PRINT_HIGH, "You wanna be the vicepresident or what?\n");
}
else
sprint (self, PRINT_HIGH, "That team is full. Pick another.\n");
return FALSE;
}
// If the color for the team this player is changing to is 0,
// then this is the first player in this team, and we set the
// teamcolor to this player's pants color.
// If not, we change this player's color to this team.
if (TeamGetColor(tno) == 0)
{
TeamFortress_TeamSetColor(tno);
// If the color wasn't set
if (TeamGetColor(tno) == 0)
{
sprint (self, PRINT_HIGH, "You can't start a new team with your color, since another ");
sprint (self, PRINT_HIGH, "already using that color. Change your pants color, then try again.\n");
return FALSE;
}
// Announce the new team
bprint(PRINT_HIGH, self.netname);
bprint(PRINT_HIGH, " has started Team No ");
st = ftos(tno);
bprint(PRINT_HIGH, st);
bprint(PRINT_HIGH, ".\n");
// Prevent the cheatchecking mechanism from nabbing them b4 the
// color command works.
makeImmune(self,time+10);
//self.immune_to_check = time + 10;
tc = TeamGetColor (tno) - 1;
tc2 = TeamGetNiceColor (tno);
SetPlayerColor (self, tc, tc2);
self.team_no = tno;
self.lives = TeamFortress_TeamGetLives(tno);
SetTeamName(self);
// Set the Civilian Class of anyone in a Civilian Team
if (self.playerclass == PC_UNDEFINED)
{
if (TeamFortress_TeamIsCivilian(self.team_no))
{
self.impulse = 1;
TeamFortress_ChangeClass();
}
}
return TRUE;
}
// Announce the new teammember
bprint(PRINT_HIGH, self.netname);
bprint(PRINT_HIGH, " has joined Team No ");
st = ftos(tno);
bprint(PRINT_HIGH, st);
bprint(PRINT_HIGH, ".\n");
tc = TeamGetColor (tno) - 1;
tc2 = TeamGetNiceColor (tno);
SetPlayerColor (self, tc, tc2);
self.team_no = tno;
// Prevent the cheatchecking mechanism from nabbing them b4 the
// color command works.
// makeImmune(self,time+10);
//self.immune_to_check = time + 10;
self.lives = TeamFortress_TeamGetLives(tno);
// Tell them what class the other members of their team are
TeamFortress_TeamShowMemberClasses(self);
SetTeamName(self);
// Set the Civilian Class of anyone in a Civilian Team
if (self.playerclass == PC_UNDEFINED)
{
if (TeamFortress_TeamIsCivilian(self.team_no))
{
self.impulse = 1;
TeamFortress_ChangeClass();
}
}
//RJM
if (toggleflags & TFLAG_TEAMFRAGS)
self.frags = TeamFortress_TeamGetScore(self.team_no);
//RJM
//- OfN Team3 should have less players than red in Hunted
if (mapname == "huntedr")
{
local float result;
result = floor(TeamFortress_TeamGetNoPlayers(2) * HUNTED_YELLOWTEAM_FACTOR);
team3maxplayers = result;
if (team3maxplayers < 1) team3maxplayers = 1;
}
return TRUE;
};
//=========================================================================
// Make sure no-one is changing their colors
void() TeamFortress_CheckTeamCheats =
{
/*
local string st, sk;
local float tc, tc2;
local float rate;
if (self.immune_to_chec > time)
return;
if (self.deadflag)
return;
#ifdef COOP_MODE
if (coop && !deathmatch) // don't worry about it if in coop game
return;
#endif
//WK Add in hack for "skins" cheat. This is as good a place as any
if (!self.netname) {
stuffcmd(self,"name \"I'm a cheater even when RENAMED\"\n");
stuffcmd(self,"disconnect\n");
}
//WK Limit rate to 10k?
st = infokey(self,"rate");
if (st)
rate = stof(st);
if (rate > 10000) {
stuffcmd(self,"rate 10000\n");
}
//- OfN - Added checking for topcolor changes... (see IsValidTopColor in OfteN.qc)
local float tTopColor;
st = infokey(self,"topcolor");
tTopColor=stof(st);
// Have they changed color?
if (self.team_no > 0 && teamplay > 0)
{
// QuakeWorld
st = infokey(self, "bottomcolor");
tc = stof(st);
// if they're a spy, check to see if they've changed colors manually
if ((self.cutf_items & CUTF_SPY_KIT) && self.undercover_team != 0)
{
if ((TeamGetColor(self.undercover_team) - 1) != tc || !IsValidTopColor(self.undercover_team,tTopColor))
{
#ifdef CHEAT_WARNINGS
RPrint(self.netname);
RPrint(" had his colors reset.\n");
#endif
tc = TeamGetColor (self.undercover_team) - 1;
tc2 = TeamGetNiceColor (self.undercover_team);
SetPlayerColor (self, tc, tc2);
// bprint2(PRINT_MEDIUM, self.netname, " has been kicked for changing color.\n");
// sprint(self, PRINT_HIGH, "You have been kicked for changing your color. Don't do it.\n");
// stuffcmd(self, "disconnect\n");
return;
}
}
else if (tc != (TeamGetColor(self.team_no) - 1) || !IsValidTopColor(self.team_no,tTopColor))
{
#ifdef CHEAT_WARNINGS
RPrint(self.netname);
RPrint(" had his colors reset.\n");
#endif
tc = TeamGetColor (self.team_no) - 1;
tc2 = TeamGetNiceColor (self.team_no);
SetPlayerColor (self, tc, tc2);
// bprint2(PRINT_MEDIUM, self.netname, " has been kicked for changing color.\n");
// sprint(self, PRINT_HIGH, "You have been kicked for changing your color. Don't do it.\n");
// stuffcmd(self, "disconnect\n");
return;
}
// Have they changed their skin?
if (self.playerclass != PC_UNDEFINED)
{
//WK For some reason, this isn't reading right for el PC_CUSTOM
st = infokey(self, "skin");
tc = 0;
// OfN kick custom player classes using a non TF-skin
if (self.playerclass == PC_CUSTOM && !Is_TF_Skin(st))
{
TeamFortress_SetSkin(self);
// bprint2(PRINT_MEDIUM, self.netname, " has been kicked for changing skin.\n");
// sprint(self, PRINT_HIGH, "You have been kicked for changing your skin. Don't do it.\n");
// stuffcmd(self, "disconnect\n");
}
if ((self.cutf_items & CUTF_SPY_KIT) && self.undercover_skin != 0)
{
//WK tc = PC_SPY;
tc = self.playerclass;
self.playerclass = self.undercover_skin;
}
if ( self.playerclass == PC_SCOUT )
sk = "tf_scout";
else if ( self.playerclass == PC_SNIPER )
sk = "tf_snipe";
else if ( self.playerclass == PC_SOLDIER )
sk = "tf_sold";
else if ( self.playerclass == PC_DEMOMAN )
sk = "tf_demo";
else if ( self.playerclass == PC_MEDIC )
sk = "tf_medic";
else if ( self.playerclass == PC_HVYWEAP )
sk = "tf_hwguy";
else if ( self.playerclass == PC_PYRO )
sk = "tf_pyro";
else if ( self.playerclass == PC_SPY )
sk = "tf_spy";
else if ( self.playerclass == PC_ENGINEER )
sk = "tf_eng";
else
{
if ((self.cutf_items & CUTF_SPY_KIT) && self.undercover_skin != 0)
{
self.playerclass = tc;
}
return; //WK Don't check as a safety precaution.
}
if (self.cutf_items & CUTF_SPY_KIT && self.undercover_skin != 0)
{
//sprint(self,PRINT_HIGH,"Mommy Wuvs You!\n");
self.playerclass = tc;
}
//WK Ignore our custom, spy-kitting friends. Kick everyone else
if ((st != sk) && !((self.playerclass == PC_CUSTOM) && (self.cutf_items & CUTF_SPY_KIT)))
{
#ifdef CHEAT_WARNINGS
RPrint(self.netname);
RPrint(" had his skin reset.\n");
#endif
TeamFortress_SetSkin(self);
// bprint2(PRINT_MEDIUM, self.netname, " has been kicked for changing skin.\n");
// sprint(self, PRINT_HIGH, "You have been kicked for changing your skin. Don't do it.\n");
// stuffcmd(self, "disconnect\n");
}
}
// Have they Changed their Team?
st = GetTeamName(self.team_no);
if (st != infokey(self, "team"))
{
if (self.penance_time < time) { //Ignore if we're cursed
#ifdef CHEAT_WARNINGS
RPrint(self.netname);
RPrint(" had his team reset.\n");
#endif
// Set the player's team
SetTeamName(self);
// bprint2(PRINT_MEDIUM, self.netname, " has been kicked for changing team.\n");
// sprint(self, PRINT_HIGH, "You have been kicked for changing your team. Don't do it.\n");
// stuffcmd(self, "disconnect\n");
return;
}
}
}
*/
};
void (entity pl, float topcolor, float bottomcolor) SetPlayerColor =
{
local string top;
local string bottom;
top = ftos (topcolor);
bottom = ftos (bottomcolor);
setinfokey (pl, "topcolor", top);
setinfokey (pl, "bottomcolor", bottom);
stuffcmd (pl, "topcolor " + top + "\n");
stuffcmd (pl, "bottomcolor " + bottom + "\n");
// stuffcmd (pl, "color " + top + " " + bottom + "\n");
};
void (string key, string value) UserInfoCallback =
{ // FIXME: remove the cheat poller
local string oldval;
oldval = infokey (self, key);
if (value == oldval) { // generic reject
// dprint ("[oldval [" + self.netname + "](" + key + ")(" + value + ")(" + oldval + ")]\n");
}
// dprint ("[[" + self.netname + "](" + key + ")(" + value + ")(" + oldval + ")]\n");
else if (key == "topcolor") { // FIXME: some topcolors may be allowed
RPrint ("items: " + ftos (self.cutf_items & CUTF_SPY_KIT) + " ");
RPrint ("skin: " + ftos (self.is_undercover) + "\n");
if ((self.cutf_items & CUTF_SPY_KIT) && self.is_undercover) {
setinfokey(self, "topcolor", oldval);
stuffcmd(self, "color \"" + oldval + "\"\n");
} else
setinfokey (self, key, value);
} else if (key == "bottomcolor") {
setinfokey (self, "bottomcolor", oldval);
stuffcmd (self, "bottomcolor \"" + oldval + "\"\n");
} else if (key == "skin") { // FIXME: some other skins may be allowed
stuffcmd(self, "skin \"" + oldval + "\"\n");
} else if (key == "name") {
self.netname = value;
setinfokey (self, key, value);
} else if (key == "team") {
stuffcmd (self, "team \"" + oldval + "\"\n");
} else {
// accept everything else
setinfokey (self, key, value);
// RPrint ("[default [" + self.netname + "](" + key + ")(" + value + ")(" + oldval + ")]\n");
}
};
//=========================================================================
// Increase the score of a team
void(float tno, float scoretoadd) TeamFortress_TeamIncreaseScore =
{
local entity e;
if (tno == 0 || scoretoadd == 0)
return;
if (tno == 1)
team1score = team1score + scoretoadd;
if (tno == 2)
team2score = team2score + scoretoadd;
if (tno == 3)
team3score = team3score + scoretoadd;
if (tno == 4)
team4score = team4score + scoretoadd;
// If TeamFrags is on, update all the team's player's frags.
if (toggleflags & TFLAG_TEAMFRAGS)
{
e = find(NIL, classname, "player");
while (e)
{
if (e.team_no == tno)
e.frags = TeamFortress_TeamGetScore(tno);
e = find(e, classname, "player");
}
}
};
//=========================================================================
// Return the score of a team
float (float tno) TeamFortress_TeamGetScore =
{
if (tno == 1)
return team1score;
if (tno == 2)
return team2score;
if (tno == 3)
return team3score;
if (tno == 4)
return team4score;
return 0;
};
//=========================================================================
// Return the number of lives each team member in a team has
float (float tno) TeamFortress_TeamGetLives =
{
if (tno == 1)
return team1lives;
if (tno == 2)
return team2lives;
if (tno == 3)
return team3lives;
if (tno == 4)
return team4lives;
return 0;
};
//=========================================================================
// Return the number of players in a team
float (float tno) TeamFortress_TeamGetNoPlayers =
{
local float size_team = 0;
local entity search;
//local string st;
search = find (NIL, classname, "player");
while (search)
{
if (search.team_no == tno)
size_team = size_team + 1;
search = find (search, classname, "player");
}
return size_team;
};
//=========================================================================
// Return the number of lives each team member in a team has
float (float tno) TeamFortress_TeamGetMaxPlayers =
{
if (tno == 1)
return team1maxplayers;
if (tno == 2)
return team2maxplayers;
if (tno == 3)
return team3maxplayers;
if (tno == 4)
return team4maxplayers;
return 0;
};
//=========================================================================
// Return the team that's winning
float() TeamFortress_TeamGetWinner =
{
local float i,j,highest,highestteam;
i = 1;
highest = 0;
highestteam = 0;
while (i < (number_of_teams + 1))
{
j = TeamFortress_TeamGetScore(i);
if (j > highest)
{
highest = j;
highestteam = i;
}
i = i + 1;
}
return highestteam;
};
//=========================================================================
// Return the team that's winning
/*CH i saw no uses
float() TeamFortress_TeamGetSecond =
{
local float i,j,highest,highestteam, secondteam, second;
i = 1;
highestteam = TeamFortress_TeamGetWinner();
highest = TeamFortress_TeamGetScore(highestteam);
secondteam = 0;
second = 0;
while (i < (number_of_teams + 1))
{
j = TeamFortress_TeamGetScore(i);
if (j < highest && j > second)
{
second = j;
secondteam = i;
}
i = i + 1;
}
return secondteam;
};
*/
//=========================================================================
// Display all the Team Scores
void(float all) TeamFortress_TeamShowScores =
{
local string st;
local float i,j;
i = 1;
// short scores
if (all == 2)
{
while (i <= number_of_teams)
{
if (TeamGetColor(i) > 0)
{
j = TeamFortress_TeamGetScore(i);
st = TeamFortress_TeamGetColorString(i);
bprint(PRINT_HIGH, st);
bprint(PRINT_HIGH, ": ");
st = ftos(j);
bprint(PRINT_HIGH, st);
bprint(PRINT_HIGH, " ");
}
i = i + 1;
}
bprint (PRINT_HIGH, "\n");
return;
}
// long scores
while (i <= number_of_teams)
{
if (TeamGetColor(i) > 0)
{
if (all)
bprint (PRINT_HIGH, "Team ");
else
sprint (self, PRINT_HIGH, "Team ");
st = ftos(i);
if (all)
bprint (PRINT_HIGH, st);
else
sprint (self, PRINT_HIGH, st);
if (all)
bprint (PRINT_HIGH, " (");
else
sprint (self, PRINT_HIGH, " (");
st = TeamFortress_TeamGetColorString(i);
if (all)
bprint (PRINT_HIGH, st);
else
sprint (self, PRINT_HIGH, st);
if (all)
bprint (PRINT_HIGH, ") : ");
else
sprint (self, PRINT_HIGH, ") : ");
j = TeamFortress_TeamGetScore(i);
st = ftos(j);
if (all)
bprint (PRINT_HIGH, st);
else
sprint (self, PRINT_HIGH, st);
if (all)
bprint (PRINT_HIGH, "\n");
else
sprint (self, PRINT_HIGH, "\n");
}
i = i + 1;
}
};
//=========================================================================
// Return a string containing the color of the team passed in tno
string(float tno) TeamFortress_TeamGetColorString =
{
local float col;
col = TeamGetColor(tno);
if (col == 1)
return "White";
if (col == 2)
return "Brown";
if (col == 3)
return "LightBlue"; //- OfN was blue
if (col == 4)
return "Green";
if (col == 5)
return "Red";
if (col == 6)
return "Tan";
if (col == 7)
return "Pink";
if (col == 8)
return "Orange";
if (col == 9)
return "Purple";
if (col == 10)
return "DarkPurple";
if (col == 11)
return "Grey";
if (col == 12)
return "DarkGreen";
if (col == 13)
return "Yellow";
return "Blue"; // was DarkBlue
};
//=========================================================================
// Print to the Player's screen a list of all the members of his/her
// team, and the class they've chosen
void(entity Player) TeamFortress_TeamShowMemberClasses =
{
/*local string st;
st = infokey(NIL, "no_showmembers"); */
local entity e;
local float found;
found = FALSE;
e = find(NIL, classname, "player");
while (e)
{
if (((e.team_no == Player.team_no) || (e.team_no == 0)) && (e != Player))
{
if (e.model) // check if valid player
{
if (!found)
{
found = TRUE;
sprint (self, PRINT_HIGH, "The other members of your team are:\n");
}
sprint (Player, PRINT_HIGH, e.netname);
sprint (Player, PRINT_HIGH, " : ");
if (e.playerclass != PC_CUSTOM)
TeamFortress_PrintClassName(Player,e.playerclass, (e.tfstate & TFSTATE_RANDOMPC));
else
TeamFortress_PrintJobName(Player,e.job);
}
}
e = find(e, classname, "player");
}
if (!found)
{
sprint (Player, PRINT_HIGH, "There are no other players on your team.\n");
}
};
void() CalculateTeamEqualiser =
{
local float t1, t2, t3, t4;
local float t_ave, calc;
team1advantage = 1;
team2advantage = 1;
team3advantage = 1;
team4advantage = 1;
if (number_of_teams < 2)
{
// not enought teams!
// wait a while, then try again (more teams may be created)
self.nextthink = time + 60;
return;
}
if (teamplay & TEAMPLAY_LESSPLAYERSHELP)
{
t1 = TeamFortress_TeamGetNoPlayers(1);
t2 = TeamFortress_TeamGetNoPlayers(2);
t3 = TeamFortress_TeamGetNoPlayers(3);
t4 = TeamFortress_TeamGetNoPlayers(4);
if ((t1 + t2 + t3 + t4) < 1) // is there any players at all?
{
self.nextthink = time + 30;
return;
}
t_ave = (t1 + t2 + t3 + t4) / number_of_teams;
// calulate teams equalisation ratio
if (t1 > 0)
{
calc = (t_ave / t1) - 1;
if (calc != 0)
calc = (calc / 3) + 1;
else
calc = calc + 1;
team1advantage = calc;
}
if (t2 > 0 && number_of_teams >= 2)
{
calc = (t_ave / t2) - 1;
if (calc != 0)
calc = (calc / 3) + 1;
else
calc = calc + 1;
team2advantage = calc;
}
if (t3 > 0 && number_of_teams >= 3)
{
calc = (t_ave / t3) - 1;
if (calc != 0)
calc = (calc / 3) + 1;
else
calc = calc + 1;
team3advantage = calc;
}
if (t4 > 0 && number_of_teams >= 4)
{
calc = (t_ave / t4) - 1;
if (calc != 0)
calc = (calc / 3) + 1;
else
calc = calc + 1;
team4advantage = calc;
}
}
if (teamplay & TEAMPLAY_LESSSCOREHELP)
{
t1 = team1score + TEAM_HELP_RATE;
if (number_of_teams >= 2)
t2 = team2score + TEAM_HELP_RATE;
else
t2 = 0;
if (number_of_teams >= 3)
t3 = team3score + TEAM_HELP_RATE;
else
t3 = 0;
if (number_of_teams >= 4)
t4 = team4score + TEAM_HELP_RATE;
else
t4 = 0;
// calulate teams equalisation ratio
t_ave = (t2 + t3 + t4) / (number_of_teams - 1);
calc = (t_ave / t1) - 1;
if (calc != 0)
calc = (calc / 3) + 1;
else
calc = calc + 1;
team1advantage = calc * team1advantage;
if (number_of_teams >= 2)
{
t_ave = (t1 + t3 + t4) / (number_of_teams - 1);
calc = (t_ave / t2) - 1;
if (calc != 0)
calc = (calc / 3) + 1;
else
calc = calc + 1;
team2advantage = calc * team2advantage;
}
if (number_of_teams >= 3)
{
t_ave = (t2 + t1 + t4) / (number_of_teams - 1);
calc = (t_ave / t3) - 1;
if (calc != 0)
calc = (calc / 3) + 1;
else
calc = calc + 1;
team3advantage = calc * team3advantage;
}
if (number_of_teams >= 4)
{
t_ave = (t2 + t3 + t1) / (number_of_teams - 1);
calc = (t_ave / t4) - 1;
if (calc != 0)
calc = (calc / 3) + 1;
else
calc = calc + 1;
team4advantage = calc * team4advantage;
}
}
self.nextthink = time + 10;
};
void() SetupTeamEqualiser =
{
team1advantage = 1;
team2advantage = 1;
team3advantage = 1;
team4advantage = 1;
if (!(teamplay & (TEAMPLAY_LESSPLAYERSHELP | TEAMPLAY_LESSSCOREHELP)))
return;
// setup teamplay timer
local entity TE;
TE = spawn();
TE.classname = "Team Equaliser";
TE.think = CalculateTeamEqualiser;
TE.nextthink = time + 30;
};
float (entity targ, entity attacker, float damage) TeamEqualiseDamage =
{
if (targ.classname != "player" || attacker.classname != "player")
return damage;
if (Teammate(targ.team_no, attacker.team_no))
return damage;
local float adv = 0, newdam;
// increase damage done by attacker's team advantage
if (attacker.team_no == 1)
adv = team1advantage;
else if (attacker.team_no == 2)
adv = team2advantage;
else if (attacker.team_no == 3)
adv = team3advantage;
else if (attacker.team_no == 4)
adv = team4advantage;
if (adv == 0)
{
RPrint("There is a team with an advantage of 0\n");
adv = 0.1;
}
newdam = damage * adv;
// reduce damage done by target's team advantage
if (targ.team_no == 1)
adv = team1advantage;
else if (targ.team_no == 2)
adv = team2advantage;
else if (targ.team_no == 3)
adv = team3advantage;
else if (targ.team_no == 4)
adv = team4advantage;
if (adv == 0)
{
RPrint("There is a team with an advantage of 0\n");
adv = 0.1;
}
newdam = newdam * (1 / adv);
return newdam;
};
//=========================================================================
// StatusQuery
void() TeamFortress_StatusQuery =
{
local float ft;
local string st;
sprint (self, PRINT_HIGH, "players per team: ");
ft = TeamFortress_TeamGetNoPlayers(1);
st = ftos(ft);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, " ");
ft = TeamFortress_TeamGetNoPlayers(2);
st = ftos(ft);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, " ");
ft = TeamFortress_TeamGetNoPlayers(3);
st = ftos(ft);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, " ");
ft = TeamFortress_TeamGetNoPlayers(4);
st = ftos(ft);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, "\n");
sprint (self, PRINT_HIGH, " equalisation: ");
st = ftos(team1advantage);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, " ");
st = ftos(team2advantage);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, " ");
st = ftos(team3advantage);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, " ");
st = ftos(team4advantage);
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, "\n");
st = ftos(teamplay);
sprint (self, PRINT_HIGH, "Teamplay is ");
sprint (self, PRINT_HIGH, st);
sprint (self, PRINT_HIGH, "\n");
};
//=========================================================================
// Return the illegal classes for this team
float(float tno) TeamFortress_TeamGetIllegalClasses =
{
if (tno == 1)
return illegalclasses1;
if (tno == 2)
return illegalclasses2;
if (tno == 3)
return illegalclasses3;
if (tno == 4)
return illegalclasses4;
return 0;
};
//=========================================================================
// Return TRUE if this team is restricted to Civilian class
float(float tno) TeamFortress_TeamIsCivilian =
{
if (tno == 1)
{
if (civilianteams & TEAM1_CIVILIANS)
return TRUE;
}
else if (tno == 2)
{
if (civilianteams & TEAM2_CIVILIANS)
return TRUE;
}
else if (tno == 3)
{
if (civilianteams & TEAM3_CIVILIANS)
return TRUE;
}
else // if (tno == 4)
{
if (civilianteams & TEAM4_CIVILIANS)
return TRUE;
}
return FALSE;
};
//=========================================================================
// Sprints to all the members on one team except one
void(float tno, entity ignore, string st) teamsprint =
{
// Don't do teamprints in DM
if (tno == 0)
return;
local entity te;
te = find(NIL, classname, "player");
while (te)
{
if (Teammate(te.team_no,tno) && te != ignore)
{
sprint(te, PRINT_HIGH, st);
}
te = find(te, classname, "player");
}
};
Reference in a new issue View git blame Copy permalink