game mode "keyhunt", still in testing
[divverent/nexuiz.git] / data / qcsrc / server / teamplay.qc
1 float GAME_DEATHMATCH           = 1;
2 float GAME_TEAM_DEATHMATCH      = 2;
3 float GAME_DOMINATION           = 3;
4 float GAME_CTF                  = 4;
5 float GAME_RUNEMATCH            = 5;
6 float GAME_LMS                  = 6;
7 float GAME_ARENA                = 7;
8 float GAME_KEYHUNT              = 8;
9
10 // client counts for each team
11 float c1, c2, c3, c4;
12 // # of bots on those teams
13 float cb1, cb2, cb3, cb4;
14
15 float g_domination, g_ctf, g_tdm, g_keyhunt;
16
17 float audit_teams_time;
18
19 float() IsTeamBalanceForced = {
20         if(intermission_running)
21                 return 0; // no rebalancing whatsoever please
22         if(!cvar("teamplay"))
23                 return 0;
24         if(cvar("g_campaign"))
25                 return 0;
26         if(!cvar("g_balance_teams_force"))
27                 return -1;
28         return 1;
29 }
30
31 void TeamchangeFrags(entity e)
32 {
33         if(e.classname == "player")
34         {
35                 // reduce frags during a team change
36                 DistributeFragsAmongTeam(e, (e.clientcolors & 0x0F) + 1, 1 - cvar("g_changeteam_fragtransfer") / 100);
37         }
38 }
39
40 string TeamName(float t)
41 {
42         // fixme: Search for team entities and get their .netname's!
43         if(t == COLOR_TEAM1)
44                 return "Red Team";
45         if(t == COLOR_TEAM2)
46                 return "Blue Team";
47         if(t == COLOR_TEAM3)
48                 return "Pink Team";
49         if(t == COLOR_TEAM4)
50                 return "Yellow Team";
51         return "Neutral Team";
52 }
53 string ColoredTeamName(float t)
54 {
55         // fixme: Search for team entities and get their .netname's!
56         if(t == COLOR_TEAM1)
57                 return "^1Red Team^7";
58         if(t == COLOR_TEAM2)
59                 return "^4Blue Team^7";
60         if(t == COLOR_TEAM3)
61                 return "^6Pink Team^7";
62         if(t == COLOR_TEAM4)
63                 return "^3Yellow Team^7";
64         return "Neutral Team";
65 }
66 string TeamNoName(float t)
67 {
68         // fixme: Search for team entities and get their .netname's!
69         if(t == 1)
70                 return "Red Team";
71         if(t == 2)
72                 return "Blue Team";
73         if(t == 3)
74                 return "Pink Team";
75         if(t == 4)
76                 return "Yellow Team";
77         return "Neutral Team";
78 }
79
80 void dom_init();
81 void ctf_init();
82 void runematch_init();
83 void tdm_init();
84
85 void(entity pl) LogTeamchange =
86 {
87         string str;
88         if(!cvar("sv_eventlog"))
89                 return;
90         if(pl.playerid < 1)
91                 return;
92         str = strcat(":team:", ftos(pl.playerid), ":");
93         str = strcat(str, ftos(pl.team));
94         GameLogEcho(str, FALSE);
95 }
96
97 void ResetGameCvars()
98 {
99         cvar_set("g_tdm", "0");
100         cvar_set("g_domination", "0");
101         cvar_set("g_ctf", "0");
102         cvar_set("g_runematch", "0");
103         cvar_set("g_lms", "0");
104         cvar_set("g_arena", "0");
105         cvar_set("g_keyhunt", "0");
106         cvar_set("teamplay", "0");
107 }
108
109 void ActivateTeamplay()
110 {
111         float teamplay_default;
112         teamplay_default = cvar("teamplay_default");
113
114         if(teamplay_default)
115                 cvar_set("teamplay", ftos(teamplay_default));
116         else
117                 cvar_set("teamplay", "3");
118 }
119
120 void InitGameplayMode()
121 {
122         float fraglimit_override, timelimit_override;
123
124         VoteReset();
125
126         game = cvar ("gamecfg");        // load game options
127
128         // game cvars get reset before map changes
129         // then map's cfg sets them as desired
130
131         // FIXME: also set a message or game mode name to print to players when the join
132
133         // set both here, gamemode can override it later
134         timelimit_override = cvar("timelimit_override");
135         fraglimit_override = cvar("fraglimit_override");
136
137         if(game == GAME_DOMINATION || cvar("g_domination"))
138         {
139                 ResetGameCvars();
140                 game = GAME_DOMINATION;
141                 cvar_set("g_domination", "1");
142
143                 ActivateTeamplay();
144
145                 fraglimit_override = cvar("g_domination_point_limit");
146
147                 gamemode_name = "Domination";
148                 teams_matter = 1;
149         }
150         else if(game == GAME_CTF || cvar("g_ctf"))
151         {
152                 ResetGameCvars();
153                 game = GAME_CTF;
154                 cvar_set("g_ctf", "1");
155
156                 ActivateTeamplay();
157
158                 fraglimit_override = cvar("g_ctf_capture_limit");
159
160                 gamemode_name = "Capture the Flag";
161                 teams_matter = 1;
162         }
163         else if((game == GAME_RUNEMATCH || cvar("g_runematch")) && !cvar("g_minstagib"))
164         {
165                 game = GAME_RUNEMATCH;
166                 cvar_set("g_runematch", "1");
167
168                 if(cvar("deathmatch_force_teamplay"))
169                         ActivateTeamplay();
170
171                 fraglimit_override = cvar("g_runematch_point_limit");
172
173                 gamemode_name = "Rune Match";
174                 if(cvar("teamplay"))
175                         teams_matter = 1;
176                 else
177                         teams_matter = 0;
178         }
179         else if(game == GAME_DEATHMATCH || game == GAME_TEAM_DEATHMATCH || cvar("g_tdm"))
180         {
181                 if(!cvar("deathmatch"))
182                         cvar_set("deathmatch", "1");
183
184
185                 if(game == GAME_TEAM_DEATHMATCH || cvar("g_tdm") || cvar("deathmatch_force_teamplay"))
186                 {
187                         ResetGameCvars();
188                         game = GAME_TEAM_DEATHMATCH;
189                         gamemode_name = "Team Deathmatch";
190                         ActivateTeamplay();
191                         teams_matter = 1;
192                         cvar_set("g_tdm", "1");
193                 }
194                 else
195                 {
196                         ResetGameCvars();
197                         game = GAME_DEATHMATCH;
198                         gamemode_name = "Deathmatch";
199                         teams_matter = 0;
200                 }
201
202                 fraglimit_override = cvar("fraglimit_override");
203         }
204         else if(game == GAME_LMS || cvar("g_lms"))
205         {
206                 ResetGameCvars();
207                 game = GAME_LMS;
208                 cvar_set("g_lms", "1");
209                 fraglimit_override = cvar("g_lms_lives_override");
210                 if(fraglimit_override == 0)
211                         fraglimit_override = -1;
212                 gamemode_name = "Last Man Standing";
213                 teams_matter = 0;
214                 lms_lowest_lives = 999;
215         }
216         else if(game == GAME_ARENA || cvar("g_arena"))
217         {
218                 ResetGameCvars();
219                 game = GAME_ARENA;
220                 cvar_set("g_arena", "1");
221                 fraglimit_override = cvar("g_arena_point_limit");
222                 maxspawned = cvar("g_arena_maxspawned");
223                 if(maxspawned < 2)
224                         maxspawned = 2;
225                 arena_roundbased = cvar("g_arena_roundbased");
226                 gamemode_name = "Arena";
227                 teams_matter = 0;
228         }
229         else if(game == GAME_KEYHUNT || cvar("g_keyhunt"))
230         {
231                 ResetGameCvars();
232                 game = GAME_KEYHUNT;
233                 cvar_set("g_keyhunt", "1");
234                 fraglimit_override = cvar("g_keyhunt_point_limit");
235                 ActivateTeamplay();
236                 gamemode_name = "Key Hunt";
237                 teams_matter = 1;
238         }
239         else
240         {
241                 // we can only assume...
242                 ResetGameCvars();
243                 gamemode_name = "Deathmatch";
244                 teams_matter = 0;
245         }
246 /*      else if(game == GAME_TEAM_DEATHMATCH)
247         {
248                 if(!cvar("deathmatch"))
249                         cvar_set("deathmatch", "1");
250
251                 //if(!cvar("teamplay"))
252                 //      cvar_set("teamplay", "3");
253                 ActivateTeamplay();
254
255                 fraglimit_override = cvar("fraglimit_override");
256         }*/
257
258         // enforce the server's universal frag/time limits
259         if(!cvar("g_campaign"))
260         {
261                 if(fraglimit_override >= 0)
262                         cvar_set("fraglimit", ftos(fraglimit_override));
263                 if(timelimit_override >= 0)
264                         cvar_set("timelimit", ftos(timelimit_override));
265         }
266
267         if (game == GAME_DOMINATION)//cvar("g_domination"))
268                 dom_init();
269         else if (game == GAME_CTF)//cvar("g_ctf"))
270                 ctf_init();
271         else if (game == GAME_RUNEMATCH)//cvar("g_runematch"))
272                 runematch_init();
273         else if (game == GAME_TEAM_DEATHMATCH)//cvar("g_runematch"))
274                 tdm_init();
275         else if (game == GAME_KEYHUNT)//cvar("g_keyhunt"))
276                 kh_init();
277
278         // those mutators rule each other out
279         if(cvar("g_minstagib"))
280         {
281                 cvar_set("g_instagib", "0");
282                 cvar_set("g_rocketarena", "0");
283         }
284         if(cvar("g_instagib"))
285         {
286                 cvar_set("g_minstagib", "0");
287                 cvar_set("g_rocketarena", "0");
288         }
289         if(cvar("g_rocketarena"))
290         {
291                 cvar_set("g_instagib", "0");
292                 cvar_set("g_minstagib", "0");
293         }
294
295         registercvar("_motd", "");
296         registercvar("_mutatormsg", "");
297         cvar_set("_motd", wordwrap(cvar_string("sv_motd"), 50));
298         cvar_set("_mutatormsg", wordwrap(cvar_string("g_mutatormsg"), 50));
299
300         g_domination = cvar("g_domination");
301         g_ctf = cvar("g_ctf");
302         g_tdm = cvar("g_tdm");
303         g_keyhunt = cvar("g_keyhunt");
304 }
305
306 string GetClientVersionMessage(float v) {
307         local string versionmsg;
308         if (v == 1) {
309                 versionmsg = "^1client is too old to get versioninfo.\n\n\n### YOU WON'T BE ABLE TO PLAY ON THIS SERVER ###\n\n\nUPDATE!!! (http://www.nexuiz.com)^8";
310                 // either that or someone wants to be funny
311         } else if (v != cvar("gameversion")) {
312                 if(v < cvar("gameversion")) {
313                         versionmsg = "^3Your client version is outdated.\n\n\n### YOU WON'T BE ABLE TO PLAY ON THIS SERVER ###\n\n\nPlease update!!!^8";
314                 } else {
315                         versionmsg = "^3This server is using an outdated Nexuiz version.\n\n\n ### THIS SERVER IS INCOMPATIBLE AND THUS YOU CANNOT JOIN ###.^8";
316                 }
317         } else {
318                 versionmsg = "^2client version and server version are compatible.^8";
319         }
320         return strzone(versionmsg);
321
322 }
323
324
325 void PrintWelcomeMessage(entity pl)
326 {
327         string s, mutator, modifications, padding;
328
329         /*if(self.welcomemessage_time > time)
330                 return;
331         self.welcomemessage_time = time + 0.8; */
332
333         if(self.cvar_scr_centertime == 0) return;
334         if(self.welcomemessage_time > time) return;
335         self.welcomemessage_time = time + self.cvar_scr_centertime * 0.6;
336
337         if(cvar("g_campaign"))
338         {
339                 centerprint(pl, campaign_message);
340                 return;
341         }
342
343         if(self.classname == "observer")
344         {
345                 if(cvar("g_lms") && self.frags <= 0 && self.frags > -666)
346                         return centerprint(self, strcat(NEWLINES, "^1You have no more lives left\nwait for next round\n\n\n^7press attack to spectate other players"));
347                 else if(cvar("g_lms") && self.frags == -666)
348                         return centerprint(self, strcat(NEWLINES, "^1Match has already begun\nwait for next round\n\n\n^7press attack to spectate other players"));
349         }
350         else if(self.classname == "spectator")
351         {
352                 if ((cvar("g_lms") && self.frags < 1) || cvar("g_arena"))
353                         return centerprint(self, strcat(NEWLINES, "spectating ", self.enemy.netname, "\n\n\n^7press attack for next player\npress attack2 for free fly mode"));
354                 else
355                         return centerprint(self, strcat(NEWLINES, "spectating ", self.enemy.netname, "\n\n\n^7press jump to play\n^7press attack for next player\npress attack2 for free fly mode"));
356         }
357
358
359         if(cvar("g_minstagib"))
360                 mutator = "^2Minstagib ^1";
361         else if(cvar("g_instagib"))
362                 mutator = "^2Instagib ^1";
363         else if(cvar("g_rocketarena"))
364                 mutator = "^2Rocketarena ^1";
365         else if(cvar("g_nixnex"))
366                 mutator = "^2No Items Nexuiz ^1";
367
368         if(cvar("g_midair")) {
369                 // to protect against unheedingly made changes
370                 if (modifications) {
371                         modifications = strcat(modifications, ", ");
372                 }
373                 modifications = "midair";
374         }
375         if(cvar("g_vampire")) {
376                 if (modifications) {
377                         modifications = strcat(modifications, ", ");
378                 }
379                 modifications = strcat(modifications, "vampire");
380         }
381         if(cvar("g_laserguided_missile")) {
382                 if (modifications) {
383                         modifications = strcat(modifications, ", ");
384                 }
385                 modifications = strcat(modifications, "laser-guided-missiles");
386         }
387
388         local string versionmessage;
389         versionmessage = GetClientVersionMessage(self.version);
390
391         s = strcat(s, NEWLINES, "This is Nexuiz ", cvar_string("g_nexuizversion"), "\n", versionmessage);
392         s = strcat(s, "^8\n\nmatch type is ^1", mutator, gamemode_name, "^8\n");
393
394         if(modifications != "")
395                 s = strcat(s, "^8\nactive modifications: ^3", modifications, "^8\n");
396
397         if((self.classname == "observer" || self.classname == "spectator") && self.version == cvar("gameversion")) {
398                 if(!cvar("g_arena"))
399                         s = strcat(s,"^7\n\n\npress jump to play\npress attack to spectate other players\n\n");
400                 else if(player_count < 2 && arena_roundbased)
401                 {
402                         s = strcat(s, "\n\n\n^1waiting for second player to start match^7\n\n");
403                 }
404                 else
405                 {
406                         s = strcat(s, "\n\n\n");
407                         if(champion)
408                                 s = strcat(s, "^7current champion is: ", champion.netname, "\n\n");
409                         s = strcat(s,"^7press attack to spectate other players\n\n");
410                 }
411         }
412
413
414         s = strzone(s);
415
416         if (cvar("g_grappling_hook"))
417                 s = strcat(s, "\n\n^8grappling hook is enabled, press 'e' to use it\n");
418
419         if (cvar_string("_mutatormsg") != "") {
420                 s = strcat(s, "\n\n^8special gameplay tips: ^7", cvar_string("_mutatormsg"));
421         }
422
423         if (cvar_string("_motd") != "") {
424                 s = strcat(s, "\n\n^8MOTD: ^7", cvar_string("_motd"));
425         }
426
427         s = strcat(s, "\n");
428         if(cvar("fraglimit"))
429         {
430                 padding = "";
431                 if(cvar("timelimit"))
432                         padding = "        ";
433                         //        " minutes"
434                 s = strcat(s, "\n^8frag limit: ^7", cvar_string("fraglimit"), padding);
435         }
436         if(cvar("timelimit"))
437                 s = strcat(s, "\n^8time limit: ^7", cvar_string("timelimit"), " minutes");
438
439         s = strzone(s);
440
441         centerprint(pl, s);
442         //sprint(pl, s);
443
444         strunzone(s);
445 }
446
447
448 void SetPlayerColors(entity pl, float _color)
449 {
450         /*string s;
451         s = ftos(cl);
452         stuffcmd(pl, strcat("color ", s, " ", s, "\n")  );
453         pl.team = cl + 1;
454         //pl.clientcolors = pl.clientcolors - (pl.clientcolors & 15) + cl;
455         pl.clientcolors = 16*cl + cl;*/
456
457         float pants, shirt;
458         pants = _color & 0x0F;
459         shirt = _color & 0xF0;
460
461
462         if(teamplay) {
463                 setcolor(pl, 16*pants + pants);
464         } else {
465                 setcolor(pl, shirt + pants);
466         }
467 }
468
469 void SetPlayerTeam(entity pl, float t, float s, float noprint)
470 {
471         float _color;
472
473         if(t == 4)
474                 _color = COLOR_TEAM4 - 1;
475         else if(t == 3)
476                 _color = COLOR_TEAM3 - 1;
477         else if(t == 2)
478                 _color = COLOR_TEAM2 - 1;
479         else
480                 _color = COLOR_TEAM1 - 1;
481
482         SetPlayerColors(pl,_color);
483
484         if(!noprint && t != s)
485         {
486                 //bprint(pl.netname, " has changed to ", TeamNoName(t), "\n");
487                 bprint(pl.netname, "^7 has changed from ", TeamNoName(s), " to ", TeamNoName(t), "\n");
488         }
489
490         if(t != s)
491                 LogTeamchange(pl);
492 }
493
494
495
496
497
498
499 // set c1...c4 to show what teams are allowed
500 void CheckAllowedTeams ()
501 {
502         string teament_name;
503         float dm;
504         entity head;
505
506 //      if(!dom && !ctf)
507 //              dm = 1;
508
509         c1 = c2 = c3 = c4 = -1;
510         cb1 = cb2 = cb3 = cb4 = 0;
511
512         if(g_domination)
513                 teament_name = "dom_team";
514         else if(g_ctf)
515                 teament_name = "ctf_team";
516         else if(g_tdm)
517                 teament_name = "tdm_team";
518         else
519         {
520                 // cover anything else by treating it like tdm with no teams spawned
521                 if(g_keyhunt)
522                         dm = kh_teams;
523                 else
524                         dm = cvar("g_tdm_teams");
525                 if(dm < 2)
526                         error("g_tdm_teams < 2, not enough teams to play team deathmatch\n");
527
528                 if(dm >= 4)
529                 {
530                         c1 = c2 = c3 = c4 = 0;
531                 }
532                 else if(dm >= 3)
533                 {
534                         c1 = c2 = c3 = 0;
535                 }
536                 else// if(dm >= 2)
537                 {
538                         c1 = c2 = 0;
539                 }
540                 return;
541         }
542
543         // first find out what teams are allowed
544         head = find(world, classname, teament_name);
545         while(head)
546         {
547                 if(!(g_domination && head.netname == ""))
548                 {
549                         if(head.team == COLOR_TEAM1)
550                         {
551                                 c1 = 0;
552                         }
553                         if(head.team == COLOR_TEAM2)
554                         {
555                                 c2 = 0;
556                         }
557                         if(head.team == COLOR_TEAM3)
558                         {
559                                 c3 = 0;
560                         }
561                         if(head.team == COLOR_TEAM4)
562                         {
563                                 c4 = 0;
564                         }
565                 }
566                 head = find(head, classname, teament_name);
567         }
568 }
569
570 float PlayerValue(entity p)
571 {
572         if(IsTeamBalanceForced() == 1)
573                 return 1;
574         return 1;
575 }
576
577 // c1...c4 should be set to -1 (not allowed) or 0 (allowed).
578 // teams that are allowed will now have their player counts stored in c1...c4
579 void GetTeamCounts(entity ignore)
580 {
581         entity head;
582         float value;
583         // now count how many players are on each team already
584
585         // FIXME: also find and memorize the lowest-scoring bot on each team (in case players must be shuffled around)
586         // also remember the lowest-scoring player
587
588         FOR_EACH_PLAYER(head)
589         {
590                 if(head != ignore)// && head.netname != "")
591                 {
592                         value = PlayerValue(head);
593                         if(head.team == COLOR_TEAM1)
594                         {
595                                 if(c1 >= 0)
596                                 {
597                                         c1 = c1 + value;
598                                         cb1 = cb1 + value;
599                                 }
600                         }
601                         if(head.team == COLOR_TEAM2)
602                         {
603                                 if(c2 >= 0)
604                                 {
605                                         c2 = c2 + value;
606                                         cb2 = cb2 + value;
607                                 }
608                         }
609                         if(head.team == COLOR_TEAM3)
610                         {
611                                 if(c3 >= 0)
612                                 {
613                                         c3 = c3 + value;
614                                         cb3 = cb3 + value;
615                                 }
616                         }
617                         if(head.team == COLOR_TEAM4)
618                         {
619                                 if(c4 >= 0)
620                                 {
621                                         c4 = c4 + value;
622                                         cb4 = cb4 + value;
623                                 }
624                         }
625                 }
626         }
627 }
628
629 // returns # of smallest team (1, 2, 3, 4)
630 // NOTE: Assumes CheckAllowedTeams has already been called!
631 float FindSmallestTeam(entity pl, float ignore_pl)
632 {
633         float totalteams, smallestteam, smallestteam_count, smallestteam_score, balance_type;
634         totalteams = 0;
635
636         // find out what teams are available
637         //CheckAllowedTeams();
638
639         // make sure there are at least 2 teams to join
640         if(c1 >= 0)
641                 totalteams = totalteams + 1;
642         if(c2 >= 0)
643                 totalteams = totalteams + 1;
644         if(c3 >= 0)
645                 totalteams = totalteams + 1;
646         if(c4 >= 0)
647                 totalteams = totalteams + 1;
648
649         if(totalteams <= 1)
650         {
651                 if(g_domination)
652                         error("Too few teams available for domination\n");
653                 else if(g_ctf)
654                         error("Too few teams available for ctf\n");
655                 else if(g_keyhunt)
656                         error("Too few teams available for key hunt\n");
657                 else
658                         error("Too few teams available for team deathmatch\n");
659         }
660
661
662         // count how many players are in each team
663         if(ignore_pl)
664                 GetTeamCounts(pl);
665         else
666                 GetTeamCounts(world);
667
668         // c1...c4 now have counts of each team
669         // figure out which is smallest, giving priority to the team the player is already on as a tie-breaker
670
671         smallestteam = 0;
672         smallestteam_count = 999999999;
673         smallestteam_score = 999999999;
674
675         // 2 gives priority to what team you're already on, 1 goes in order
676         // 2 doesn't seem to work though...
677         balance_type = 1;
678
679         if(balance_type == 1)
680         {
681                 if(c1 >= 0 && (c1 < smallestteam_count || (c1 <= smallestteam_count && team1_score < smallestteam_score)))
682                 {
683                         smallestteam = 1;
684                         smallestteam_count = c1;
685                         smallestteam_score = team1_score;
686                 }
687                 if(c2 >= 0 && (c2 < smallestteam_count || (c2 <= smallestteam_count && team2_score < smallestteam_score)))
688                 {
689                         smallestteam = 2;
690                         smallestteam_count = c2;
691                         smallestteam_score = team2_score;
692                 }
693                 if(c3 >= 0 && (c3 < smallestteam_count || (c3 <= smallestteam_count && team3_score < smallestteam_score)))
694                 {
695                         smallestteam = 3;
696                         smallestteam_count = c3;
697                         smallestteam_score = team3_score;
698                 }
699                 if(c4 >= 0 && (c4 < smallestteam_count || (c4 <= smallestteam_count && team4_score < smallestteam_score)))
700                 {
701                         smallestteam = 4;
702                         smallestteam_count = c4;
703                         smallestteam_score = team4_score;
704                 }
705         }
706         else
707         {
708                 if(c1 >= 0 && (c1 < smallestteam_count ||
709                                         (c1 == smallestteam_count && self.team == COLOR_TEAM1) ) )
710                 {
711                         smallestteam = 1;
712                         smallestteam_count = c1;
713                 }
714                 if(c2 >= 0 && c2 < (c2 < smallestteam_count ||
715                                         (c2 == smallestteam_count && self.team == COLOR_TEAM2) ) )
716                 {
717                         smallestteam = 2;
718                         smallestteam_count = c2;
719                 }
720                 if(c3 >= 0 && c3 < (c3 < smallestteam_count ||
721                                         (c3 == smallestteam_count && self.team == COLOR_TEAM3) ) )
722                 {
723                         smallestteam = 3;
724                         smallestteam_count = c3;
725                 }
726                 if(c4 >= 0 && c4 < (c4 < smallestteam_count ||
727                                         (c4 == smallestteam_count && self.team == COLOR_TEAM4) ) )
728                 {
729                         smallestteam = 4;
730                         smallestteam_count = c4;
731                 }
732         }
733
734         return smallestteam;
735 }
736
737 float JoinBestTeam(entity pl, float only_return_best)
738 {
739         float smallest, selectedteam;
740
741         // don't join a team if we're not playing a team game
742         if(!cvar("teamplay") && !g_domination && !g_ctf && !g_keyhunt)
743                 return 0;
744
745         // find out what teams are available
746         CheckAllowedTeams();
747
748         if(cvar("g_domination"))
749         {
750                 if(cvar("g_domination_default_teams") < 3)
751                         c3 = 999999999;
752                 if(cvar("g_domination_default_teams") < 4)
753                         c4 = 999999999;
754         }
755
756         // if we don't care what team he ends up on, put him on whatever team he entered as.
757         // if he's not on a valid team, then let other code put him on the smallest team
758         if(!cvar("g_campaign") && !cvar("g_balance_teams") && !cvar("g_balance_teams_force"))
759         {
760                 if(     c1 >= 0 && pl.team == COLOR_TEAM1)
761                         selectedteam = pl.team;
762                 else if(c2 >= 0 && pl.team == COLOR_TEAM2)
763                         selectedteam = pl.team;
764                 else if(c3 >= 0 && pl.team == COLOR_TEAM3)
765                         selectedteam = pl.team;
766                 else if(c4 >= 0 && pl.team == COLOR_TEAM4)
767                         selectedteam = pl.team;
768                 else
769                         selectedteam = -1;
770                 if(selectedteam > 0)
771                 {
772                         if(!only_return_best)
773                         {
774                                 SetPlayerColors(pl, selectedteam - 1);
775                                 LogTeamchange(pl);
776                         }
777                         return selectedteam;
778                 }
779                 // otherwise end up on the smallest team (handled below)
780         }
781
782         smallest = FindSmallestTeam(pl, TRUE);
783
784
785         if(!only_return_best)
786         {
787                 TeamchangeFrags(self);
788                 if(smallest == 1)
789                 {
790                         SetPlayerColors(pl, COLOR_TEAM1 - 1);
791                 }
792                 else if(smallest == 2)
793                 {
794                         SetPlayerColors(pl, COLOR_TEAM2 - 1);
795                 }
796                 else if(smallest == 3)
797                 {
798                         SetPlayerColors(pl, COLOR_TEAM3 - 1);
799                 }
800                 else if(smallest == 4)
801                 {
802                         SetPlayerColors(pl, COLOR_TEAM4 - 1);
803                 }
804                 else
805                 {
806                         error("smallest team: invalid team\n");
807                 }
808                 LogTeamchange(pl);
809                 if(pl.deadflag == DEAD_NO)
810                         Damage(pl, pl, pl, 100000, DEATH_TEAMCHANGE, pl.origin, '0 0 0');
811         }
812
813         return smallest;
814 }
815
816
817 void SV_ChangeTeam(float _color)
818 {
819         float scolor, dcolor, steam, dteam, dbotcount, scount, dcount;
820
821         // in normal deathmatch we can just apply the color and we're done
822         if(!cvar("teamplay")) {
823                 SetPlayerColors(self, _color);
824                 return;
825         }
826
827         scolor = self.clientcolors & 0x0F;
828         dcolor = _color & 0x0F;
829
830         if(scolor == COLOR_TEAM1 - 1)
831                 steam = 1;
832         else if(scolor == COLOR_TEAM2 - 1)
833                 steam = 2;
834         else if(scolor == COLOR_TEAM3 - 1)
835                 steam = 3;
836         else if(scolor == COLOR_TEAM4 - 1)
837                 steam = 4;
838         if(dcolor == COLOR_TEAM1 - 1)
839                 dteam = 1;
840         else if(dcolor == COLOR_TEAM2 - 1)
841                 dteam = 2;
842         else if(dcolor == COLOR_TEAM3 - 1)
843                 dteam = 3;
844         else if(dcolor == COLOR_TEAM4 - 1)
845                 dteam = 4;
846
847         // remap invalid teams in dom & ctf
848         /*
849         if(cvar("g_ctf") && dteam == 3)
850                 dteam = 2;
851         else if(cvar("g_ctf") && dteam == 4)
852                 dteam = 1;
853         else if((cvar("g_domination") && cvar("g_domination_default_teams") < 3) || (cvar("g_tdm") && cvar("g_tdm_teams") < 3))
854         {
855                 if(dteam == 3)
856                         dteam = 2;
857                 else if(dteam == 4)
858                         dteam = 1;
859         }
860         else if((cvar("g_domination") && cvar("g_domination_default_teams") < 4) || (cvar("g_tdm") && cvar("g_tdm_teams") < 4))
861         {
862                 if(dteam == 4)
863                         dteam = 1;
864         }
865         */
866
867         CheckAllowedTeams();
868         if(dteam == 3 && c3 < 0)
869                 dteam = 2;
870         if(dteam == 4 && c4 < 0)
871                 dteam = 1;
872
873         // not changing teams
874         if(scolor == dcolor)
875         {
876                 //bprint("same team change\n");
877                 SetPlayerTeam(self, dteam, steam, TRUE);
878                 return;
879         }
880
881         if(cvar("teamplay"))
882         {
883                 if(cvar("g_campaign") || cvar("g_changeteam_banned"))
884                 {
885                         sprint(self, "Team changes not allowed\n");
886                         return; // changing teams is not allowed
887                 }
888
889                 if(!cvar("g_campaign") && cvar("g_balance_teams_prevent_imbalance"))
890                 {
891                         // only allow changing to a smaller or equal size team
892
893                         // find out what teams are available
894                         CheckAllowedTeams();
895                         // count how many players on each team
896                         GetTeamCounts(world);
897
898                         // get desired team
899                         if(dteam == 1 && c1 >= 0)//dcolor == COLOR_TEAM1 - 1)
900                         {
901                                 dcount = c1;
902                                 dbotcount = cb1;
903                         }
904                         else if(dteam == 2 && c2 >= 0)//dcolor == COLOR_TEAM2 - 1)
905                         {
906                                 dcount = c2;
907                                 dbotcount = cb2;
908                         }
909                         else if(dteam == 3 && c3 >= 0)//dcolor == COLOR_TEAM3 - 1)
910                         {
911                                 dcount = c3;
912                                 dbotcount = cb3;
913                         }
914                         else if(dteam == 4 && c4 >= 0)//dcolor == COLOR_TEAM4 - 1)
915                         {
916                                 dcount = c4;
917                                 dbotcount = cb4;
918                         }
919                         else
920                         {
921                                 sprint(self, "Cannot change to an invalid team\n");
922
923                                 return;
924                         }
925
926                         // get starting team
927                         if(steam == 1)//scolor == COLOR_TEAM1 - 1)
928                                 scount = c1;
929                         else if(steam == 2)//scolor == COLOR_TEAM2 - 1)
930                                 scount = c2;
931                         else if(steam == 3)//scolor == COLOR_TEAM3 - 1)
932                                 scount = c3;
933                         else if(steam == 4)//scolor == COLOR_TEAM4 - 1)
934                                 scount = c4;
935
936                         if(scount) // started at a valid, nonempty team
937                         {
938                                 // check if we're trying to change to a larger team that doens't have bots to swap with
939                                 if(dcount >= scount && dbotcount <= 0)
940                                 {
941                                         sprint(self, "Cannot change to a larger team\n");
942                                         return; // can't change to a larger team
943                                 }
944                         }
945                 }
946         }
947
948 //      bprint("allow change teams from ", ftos(steam), " to ", ftos(dteam), "\n");
949
950         if(cvar("teamplay") && self.classname == "player" && steam != dteam)
951         {
952                 // reduce frags during a team change
953                 TeamchangeFrags(self);
954         }
955
956         SetPlayerTeam(self, dteam, steam, FALSE);
957
958         if(cvar("teamplay") && self.classname == "player" && steam != dteam)
959         {
960                 // kill player when changing teams
961                 if(self.deadflag == DEAD_NO)
962                         Damage(self, self, self, 100000, DEATH_TEAMCHANGE, self.origin, '0 0 0');
963         }
964 }
965
966 void ShufflePlayerOutOfTeam (float source_team)
967 {
968         float smallestteam, smallestteam_count, steam;
969         float lowest_bot_score, lowest_player_score;
970         entity head, lowest_bot, lowest_player, selected;
971         string m;
972
973         smallestteam = 0;
974         smallestteam_count = 999999999;
975
976         if(c1 >= 0 && c1 < smallestteam_count)
977         {
978                 smallestteam = 1;
979                 smallestteam_count = c1;
980         }
981         if(c2 >= 0 && c2 < smallestteam_count)
982         {
983                 smallestteam = 2;
984                 smallestteam_count = c2;
985         }
986         if(c3 >= 0 && c3 < smallestteam_count)
987         {
988                 smallestteam = 3;
989                 smallestteam_count = c3;
990         }
991         if(c4 >= 0 && c4 < smallestteam_count)
992         {
993                 smallestteam = 4;
994                 smallestteam_count = c4;
995         }
996
997         if(!smallestteam)
998         {
999                 bprint("warning: no smallest team\n");
1000                 return;
1001         }
1002
1003         if(source_team == 1)
1004                 steam = COLOR_TEAM1;
1005         else if(source_team == 2)
1006                 steam = COLOR_TEAM2;
1007         else if(source_team == 3)
1008                 steam = COLOR_TEAM3;
1009         else if(source_team == 4)
1010                 steam = COLOR_TEAM4;
1011
1012         lowest_bot = world;
1013         lowest_bot_score = 999999999;
1014         lowest_player = world;
1015         lowest_player_score = 999999999;
1016
1017         // find the lowest-scoring player & bot of that team
1018         FOR_EACH_PLAYER(head)
1019         {
1020                 if(head.team == steam)
1021                 {
1022                         if(head.isbot)
1023                         {
1024                                 if(head.frags < lowest_bot_score)
1025                                 {
1026                                         lowest_bot = head;
1027                                         lowest_bot_score = head.frags;
1028                                 }
1029                         }
1030                         else
1031                         {
1032                                 if(head.frags < lowest_player_score)
1033                                 {
1034                                         lowest_player = head;
1035                                         lowest_player_score = head.frags;
1036                                 }
1037                         }
1038                 }
1039         }
1040
1041         // prefers to move a bot...
1042         if(lowest_bot != world)
1043                 selected = lowest_bot;
1044         // but it will move a player if it has to
1045         else
1046                 selected = lowest_player;
1047         // don't do anything if it couldn't find anyone
1048         if(!selected)
1049         {
1050                 bprint("warning: couldn't find a player to move from team\n");
1051                 return;
1052         }
1053
1054         // smallest team gains a member
1055         if(smallestteam == 1)
1056         {
1057                 c1 = c1 + 1;
1058         }
1059         else if(smallestteam == 2)
1060         {
1061                 c2 = c2 + 1;
1062         }
1063         else if(smallestteam == 3)
1064         {
1065                 c3 = c3 + 1;
1066         }
1067         else if(smallestteam == 4)
1068         {
1069                 c4 = c4 + 1;
1070         }
1071         else
1072         {
1073                 bprint("warning: destination team invalid\n");
1074                 return;
1075         }
1076         // source team loses a member
1077         if(source_team == 1)
1078         {
1079                 c1 = c1 + 1;
1080         }
1081         else if(source_team == 2)
1082         {
1083                 c2 = c2 + 2;
1084         }
1085         else if(source_team == 3)
1086         {
1087                 c3 = c3 + 3;
1088         }
1089         else if(source_team == 4)
1090         {
1091                 c4 = c4 + 4;
1092         }
1093         else
1094         {
1095                 bprint("warning: source team invalid\n");
1096                 return;
1097         }
1098
1099         // move the player to the new team
1100         TeamchangeFrags(selected);
1101         SetPlayerTeam(selected, smallestteam, source_team, FALSE);
1102
1103         if(selected.deadflag == DEAD_NO)
1104                         Damage(selected, selected, selected, 100000, DEATH_AUTOTEAMCHANGE, selected.origin, '0 0 0');
1105         m = "You have been moved into a different team to improve team balance\nYou are now on: ";
1106         if (selected.team == 5)
1107                 m = strcat(m, "^1Red Team");
1108         else if (selected.team == 14)
1109                 m = strcat(m, "^4Blue Team");
1110         else if (selected.team == 10)
1111                 m = strcat(m, "^6Pink Team");
1112         else if (selected.team == 13)
1113                 m = strcat(m, "^3Yellow Team");
1114         centerprint(selected, m);
1115 }
1116
1117 float lastRebalanceInfo;
1118 void CauseRebalance(float source_team, float howmany_toomany)
1119 {
1120         float steam;
1121         entity head;
1122
1123         if(IsTeamBalanceForced() == 1)
1124         {
1125                 bprint("Rebalancing Teams\n");
1126                 ShufflePlayerOutOfTeam(source_team);
1127         }
1128         else
1129         {
1130                 if(1+floor(howmany_toomany) < cvar("g_balance_teams_complain"))
1131                         return;
1132                 if(time < lastRebalanceInfo + 90)
1133                         return;
1134                 lastRebalanceInfo = time;
1135                 if(source_team == 1)
1136                         steam = COLOR_TEAM1;
1137                 else if(source_team == 2)
1138                         steam = COLOR_TEAM2;
1139                 else if(source_team == 3)
1140                         steam = COLOR_TEAM3;
1141                 else if(source_team == 4)
1142                         steam = COLOR_TEAM4;
1143                 ServerConsoleEcho(strcat("Team ", ftos(source_team), " too large, complaining."), TRUE);
1144                 FOR_EACH_REALPLAYER(head)
1145                 {
1146                         if(head.team == steam)
1147                         {
1148                                 sprint(head, "\{1}\{13}^3SERVER NOTICE:^7 One of you please change teams!\n");
1149                                 centerprint_atprio(head, CENTERPRIO_REBALANCE, "^3SERVER NOTICE:\n\n^7Someone of you please change teams!");
1150                         }
1151                 }
1152         }
1153 }
1154
1155 // part of g_balance_teams_force
1156 // occasionally perform an audit of the teams to make
1157 // sure they're more or less balanced in player count.
1158 void AuditTeams()
1159 {
1160         float numplayers, numteams, toomany;
1161         float balance;
1162         balance = IsTeamBalanceForced();
1163         if(balance == 0)
1164                 return;
1165
1166         if(audit_teams_time > time)
1167                 return;
1168
1169         audit_teams_time = time + 4 + random();
1170
1171 //      bprint("Auditing teams\n");
1172
1173         CheckAllowedTeams();
1174         GetTeamCounts(world);
1175
1176
1177         numteams = numplayers = 0;
1178         if(c1 >= 0)
1179         {
1180                 numteams = numteams + 1;
1181                 numplayers = numplayers + c1;
1182         }
1183         if(c2 >= 0)
1184         {
1185                 numteams = numteams + 1;
1186                 numplayers = numplayers + c2;
1187         }
1188         if(c3 >= 0)
1189         {
1190                 numteams = numteams + 1;
1191                 numplayers = numplayers + c3;
1192         }
1193         if(c4 >= 0)
1194         {
1195                 numteams = numteams + 1;
1196                 numplayers = numplayers + c4;
1197         }
1198
1199         if(numplayers <= 0)
1200                 return; // no players to move around
1201         if(numteams < 2)
1202                 return; // don't bother shuffling if for some reason there aren't any teams
1203
1204         toomany = (numplayers / numteams) + 1;
1205
1206         if(toomany <= 0)
1207                 return; // that's weird...
1208
1209         if(c1 && c1 >= toomany)
1210                 CauseRebalance(1, c1 - toomany);
1211         if(c2 && c2 >= toomany)
1212                 CauseRebalance(2, c2 - toomany);
1213         if(c3 && c3 >= toomany)
1214                 CauseRebalance(3, c3 - toomany);
1215         if(c4 && c4 >= toomany)
1216                 CauseRebalance(4, c4 - toomany);
1217
1218         // if teams are still unbalanced, balance them further in the next audit,
1219         // which will happen sooner (keep doing rapid audits until things are in order)
1220         audit_teams_time = time + 0.7 + random()*0.3;
1221 }
1222
1223
1224
1225 /*void(entity e, float first) UpdateTeamScore =
1226 {
1227         clientno = e.FIXME;
1228         if(first)
1229         {
1230                 WriteByte (MSG_ALL, SVC_UPDATENAME);
1231                 WriteByte (MSG_ALL, clientno);
1232                 WriteString (MSG_ALL, e.netname);
1233
1234                 WriteByte (MSG_ALL, SVC_UPDATECOLORS);
1235                 WriteByte (MSG_ALL, clientno);
1236                 WriteByte (MSG_ALL, e.b_shirt * 16 + who.b_pants);
1237         }
1238
1239         WriteByte (MSG_ALL, SVC_UPDATEFRAGS);
1240         WriteByte (MSG_ALL, clientno);
1241         WriteShort (MSG_ALL, e.frags + 10000);
1242 };
1243
1244 */
1245
1246
1247 // code from here on is just to support maps that don't have team entities
1248 void tdm_spawnteam (string teamname, float teamcolor)
1249 {
1250         local entity e;
1251         e = spawn();
1252         e.classname = "tdm_team";
1253         e.netname = teamname;
1254         e.cnt = teamcolor;
1255         e.team = e.cnt + 1;
1256 };
1257
1258 // spawn some default teams if the map is not set up for tdm
1259 void() tdm_spawnteams =
1260 {
1261         float numteams;
1262
1263         numteams = cvar("g_tdm_teams");
1264
1265         tdm_spawnteam("Red", 4);
1266         tdm_spawnteam("Blue", 13);
1267 };
1268
1269 void() tdm_delayedinit =
1270 {
1271         self.think = SUB_Remove;
1272         self.nextthink = time;
1273         // if no teams are found, spawn defaults
1274         if (find(world, classname, "tdm_team") == world)
1275                 tdm_spawnteams();
1276 };
1277
1278 void() tdm_init =
1279 {
1280         local entity e;
1281         e = spawn();
1282         e.think = tdm_delayedinit;
1283         e.nextthink = time + 0.1;
1284 };
1285
1286