Merge branch 'TimePath/bot_api' into 'master'
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / teamplay.qc
1 #include "teamplay.qh"
2 #include "_all.qh"
3
4 #include "cl_client.qh"
5 #include "race.qh"
6 #include "scores.qh"
7 #include "scores_rules.qh"
8
9 #include "command/vote.qh"
10
11 #include "mutators/mutators_include.qh"
12
13 #include "../common/deathtypes.qh"
14 #include "../common/teams.qh"
15
16 void TeamchangeFrags(entity e)
17 {
18         PlayerScore_Clear(e);
19 }
20
21 void LogTeamchange(float player_id, float team_number, float type)
22 {
23         if(!autocvar_sv_eventlog)
24                 return;
25
26         if(player_id < 1)
27                 return;
28
29         GameLogEcho(strcat(":team:", ftos(player_id), ":", ftos(team_number), ":", ftos(type)));
30 }
31
32 void default_delayedinit()
33 {
34         if(!scores_initialized)
35                 ScoreRules_generic();
36 }
37
38 void ActivateTeamplay()
39 {
40         serverflags |= SERVERFLAG_TEAMPLAY;
41         teamplay = 1;
42         cvar_set("teamplay", "2");  // DP needs this for sending proper getstatus replies.
43 }
44
45 void InitGameplayMode()
46 {
47         float fraglimit_override, timelimit_override, leadlimit_override, qualifying_override;
48
49         qualifying_override = -1;
50
51         VoteReset();
52
53         // find out good world mins/maxs bounds, either the static bounds found by looking for solid, or the mapinfo specified bounds
54         get_mi_min_max(1);
55         world.mins = mi_min;
56         world.maxs = mi_max;
57
58         MapInfo_LoadMapSettings(mapname);
59         serverflags &= ~SERVERFLAG_TEAMPLAY;
60         teamplay = 0;
61         cvar_set("teamplay", "0");  // DP needs this for sending proper getstatus replies.
62
63         if (!cvar_value_issafe(world.fog))
64         {
65                 LOG_INFO("The current map contains a potentially harmful fog setting, ignored\n");
66                 world.fog = string_null;
67         }
68         if(MapInfo_Map_fog != "")
69                 if(MapInfo_Map_fog == "none")
70                         world.fog = string_null;
71                 else
72                         world.fog = strzone(MapInfo_Map_fog);
73         clientstuff = strzone(MapInfo_Map_clientstuff);
74
75         MapInfo_ClearTemps();
76
77         // set both here, gamemode can override it later
78         timelimit_override = autocvar_timelimit_override;
79         fraglimit_override = autocvar_fraglimit_override;
80         leadlimit_override = autocvar_leadlimit_override;
81         gamemode_name = MapInfo_Type_ToText(MapInfo_LoadedGametype);
82
83         if(g_dm)
84         {
85                 MUTATOR_ADD(gamemode_deathmatch);
86         }
87
88         if(g_tdm)
89         {
90                 ActivateTeamplay();
91                 fraglimit_override = autocvar_g_tdm_point_limit;
92                 leadlimit_override = autocvar_g_tdm_point_leadlimit;
93                 if(autocvar_g_tdm_team_spawns)
94                         have_team_spawns = -1; // request team spawns
95                 MUTATOR_ADD(gamemode_tdm);
96         }
97
98         if(g_domination)
99         {
100                 ActivateTeamplay();
101                 fraglimit_override = autocvar_g_domination_point_limit;
102                 leadlimit_override = autocvar_g_domination_point_leadlimit;
103                 if(autocvar_g_domination_roundbased && autocvar_g_domination_roundbased_point_limit)
104                         fraglimit_override = autocvar_g_domination_roundbased_point_limit;
105                 have_team_spawns = -1; // request team spawns
106                 MUTATOR_ADD(gamemode_domination);
107         }
108
109         if(g_ctf)
110         {
111                 ActivateTeamplay();
112                 fraglimit_override = autocvar_capturelimit_override;
113                 leadlimit_override = autocvar_captureleadlimit_override;
114                 have_team_spawns = -1; // request team spawns
115                 MUTATOR_ADD(gamemode_ctf);
116         }
117
118         if(g_lms)
119         {
120                 fraglimit_override = autocvar_g_lms_lives_override;
121                 leadlimit_override = 0; // not supported by LMS
122                 if(fraglimit_override == 0)
123                         fraglimit_override = -1;
124                 MUTATOR_ADD(gamemode_lms);
125         }
126
127         if(g_ca)
128         {
129                 ActivateTeamplay();
130                 fraglimit_override = autocvar_g_ca_point_limit;
131                 leadlimit_override = autocvar_g_ca_point_leadlimit;
132                 if(autocvar_g_ca_team_spawns)
133                         have_team_spawns = -1; // request team spawns
134                 MUTATOR_ADD(gamemode_ca);
135         }
136
137         if(g_keyhunt)
138         {
139                 ActivateTeamplay();
140                 fraglimit_override = autocvar_g_keyhunt_point_limit;
141                 leadlimit_override = autocvar_g_keyhunt_point_leadlimit;
142                 if(autocvar_g_keyhunt_team_spawns)
143                         have_team_spawns = -1; // request team spawns
144                 MUTATOR_ADD(gamemode_keyhunt);
145         }
146
147         if(g_freezetag)
148         {
149                 ActivateTeamplay();
150                 fraglimit_override = autocvar_g_freezetag_point_limit;
151                 leadlimit_override = autocvar_g_freezetag_point_leadlimit;
152                 if(autocvar_g_freezetag_team_spawns)
153                         have_team_spawns = -1; // request team spawns
154                 MUTATOR_ADD(gamemode_freezetag);
155         }
156
157         if(g_assault)
158         {
159                 ActivateTeamplay();
160                 have_team_spawns = -1; // request team spawns
161                 MUTATOR_ADD(gamemode_assault);
162         }
163
164         if(g_onslaught)
165         {
166                 ActivateTeamplay();
167                 fraglimit_override = autocvar_g_onslaught_point_limit;
168                 have_team_spawns = -1; // request team spawns
169                 MUTATOR_ADD(gamemode_onslaught);
170         }
171
172         if(g_race)
173         {
174                 if(autocvar_g_race_teams)
175                 {
176                         ActivateTeamplay();
177                         race_teams = bound(2, autocvar_g_race_teams, 4);
178                         have_team_spawns = -1; // request team spawns
179                 }
180                 else
181                         race_teams = 0;
182                 qualifying_override = autocvar_g_race_qualifying_timelimit_override;
183                 fraglimit_override = autocvar_g_race_laps_limit;
184                 leadlimit_override = 0; // currently not supported by race
185
186                 // we need to find out the correct value for g_race_qualifying
187                 float want_qualifying = ((qualifying_override >= 0) ? qualifying_override : autocvar_g_race_qualifying_timelimit) > 0;
188
189                 if(autocvar_g_campaign)
190                 {
191                         g_race_qualifying = 1;
192                         independent_players = 1;
193                 }
194                 else if(!autocvar_g_campaign && want_qualifying)
195                 {
196                         g_race_qualifying = 2;
197                         independent_players = 1;
198                         race_fraglimit = (race_fraglimit >= 0) ? fraglimit_override : autocvar_fraglimit;
199                         race_leadlimit = (race_leadlimit >= 0) ? leadlimit_override : autocvar_leadlimit;
200                         race_timelimit = (race_timelimit >= 0) ? timelimit_override : autocvar_timelimit;
201                         fraglimit_override = 0;
202                         leadlimit_override = 0;
203                         timelimit_override = autocvar_g_race_qualifying_timelimit;
204                 }
205                 else
206                 {
207                         g_race_qualifying = 0;
208                 }
209
210                 MUTATOR_ADD(gamemode_race);
211         }
212
213         if(g_cts)
214         {
215                 g_race_qualifying = 1;
216                 fraglimit_override = 0;
217                 leadlimit_override = 0;
218                 independent_players = 1;
219                 MUTATOR_ADD(gamemode_cts);
220         }
221
222         if(g_nexball)
223         {
224                 fraglimit_override = autocvar_g_nexball_goallimit;
225                 leadlimit_override = autocvar_g_nexball_goalleadlimit;
226                 ActivateTeamplay();
227                 have_team_spawns = -1; // request team spawns
228                 MUTATOR_ADD(gamemode_nexball);
229         }
230
231         if(g_keepaway)
232         {
233                 MUTATOR_ADD(gamemode_keepaway);
234         }
235
236         if(g_invasion)
237         {
238                 fraglimit_override = autocvar_g_invasion_point_limit;
239                 if(autocvar_g_invasion_teams >= 2)
240                 {
241                         ActivateTeamplay();
242                         if(autocvar_g_invasion_team_spawns)
243                                 have_team_spawns = -1; // request team spawns
244                 }
245                 MUTATOR_ADD(gamemode_invasion);
246         }
247
248         cache_mutatormsg = strzone("");
249         cache_lastmutatormsg = strzone("");
250
251         // enforce the server's universal frag/time limits
252         if(!autocvar_g_campaign)
253         {
254                 if(fraglimit_override >= 0)
255                         cvar_set("fraglimit", ftos(fraglimit_override));
256                 if(timelimit_override >= 0)
257                         cvar_set("timelimit", ftos(timelimit_override));
258                 if(leadlimit_override >= 0)
259                         cvar_set("leadlimit", ftos(leadlimit_override));
260                 if(qualifying_override >= 0)
261                         cvar_set("g_race_qualifying_timelimit", ftos(qualifying_override));
262         }
263
264         InitializeEntity(world, default_delayedinit, INITPRIO_GAMETYPE_FALLBACK);
265 }
266
267 string GetClientVersionMessage()
268 {SELFPARAM();
269         string versionmsg;
270         if (self.version_mismatch) {
271                 if(self.version < autocvar_gameversion) {
272                         versionmsg = "^3Your client version is outdated.\n\n\n### YOU WON'T BE ABLE TO PLAY ON THIS SERVER ###\n\n\nPlease update!!!^8";
273                 } else {
274                         versionmsg = "^3This server is using an outdated Xonotic version.\n\n\n ### THIS SERVER IS INCOMPATIBLE AND THUS YOU CANNOT JOIN ###.^8";
275                 }
276         } else {
277                 versionmsg = "^2client version and server version are compatible.^8";
278         }
279         return versionmsg;
280 }
281
282 string getwelcomemessage(void)
283 {
284         string s, modifications, motd;
285
286         MUTATOR_CALLHOOK(BuildMutatorsPrettyString, "");
287         modifications = ret_string;
288
289         if(g_weaponarena)
290         {
291                 if(g_weaponarena_random)
292                         modifications = strcat(modifications, ", ", ftos(g_weaponarena_random), " of ", g_weaponarena_list, " Arena");
293                 else
294                         modifications = strcat(modifications, ", ", g_weaponarena_list, " Arena");
295         }
296         else if(cvar("g_balance_blaster_weaponstart") == 0)
297                 modifications = strcat(modifications, ", No start weapons");
298         if(cvar("sv_gravity") < stof(cvar_defstring("sv_gravity")))
299                 modifications = strcat(modifications, ", Low gravity");
300         if(g_cloaked && !g_cts)
301                 modifications = strcat(modifications, ", Cloaked");
302         if(g_weapon_stay && !g_cts)
303                 modifications = strcat(modifications, ", Weapons stay");
304         if(g_jetpack)
305                 modifications = strcat(modifications, ", Jet pack");
306         if(autocvar_g_powerups == 0)
307                 modifications = strcat(modifications, ", No powerups");
308         if(autocvar_g_powerups > 0)
309                 modifications = strcat(modifications, ", Powerups");
310         modifications = substring(modifications, 2, strlen(modifications) - 2);
311
312         string versionmessage;
313         versionmessage = GetClientVersionMessage();
314
315         s = strcat("This is Xonotic ", autocvar_g_xonoticversion, "\n", versionmessage);
316         s = strcat(s, "^8\n\nmatch type is ^1", gamemode_name, "^8\n");
317
318         if(modifications != "")
319                 s = strcat(s, "^8\nactive modifications: ^3", modifications, "^8\n");
320
321         if (cvar("g_nades"))
322                 s = strcat(s, "\n\n^3nades^8 are enabled, press 'g' to use them\n");
323
324         if(cache_lastmutatormsg != autocvar_g_mutatormsg)
325         {
326                 if(cache_lastmutatormsg)
327                         strunzone(cache_lastmutatormsg);
328                 if(cache_mutatormsg)
329                         strunzone(cache_mutatormsg);
330                 cache_lastmutatormsg = strzone(autocvar_g_mutatormsg);
331                 cache_mutatormsg = strzone(cache_lastmutatormsg);
332         }
333
334         if (cache_mutatormsg != "") {
335                 s = strcat(s, "\n\n^8special gameplay tips: ^7", cache_mutatormsg);
336         }
337
338         string mutator_msg = "";
339         MUTATOR_CALLHOOK(BuildGameplayTipsString, mutator_msg);
340         mutator_msg = ret_string;
341
342         s = strcat(s, mutator_msg); // trust that the mutator will do proper formatting
343
344         motd = autocvar_sv_motd;
345         if (motd != "") {
346                 s = strcat(s, "\n\n^8MOTD: ^7", strreplace("\\n", "\n", motd));
347         }
348         return s;
349 }
350
351 void SetPlayerColors(entity pl, float _color)
352 {
353         /*string s;
354         s = ftos(cl);
355         stuffcmd(pl, strcat("color ", s, " ", s, "\n")  );
356         pl.team = cl + 1;
357         //pl.clientcolors = pl.clientcolors - (pl.clientcolors & 15) + cl;
358         pl.clientcolors = 16*cl + cl;*/
359
360         float pants, shirt;
361         pants = _color & 0x0F;
362         shirt = _color & 0xF0;
363
364
365         if(teamplay) {
366                 setcolor(pl, 16*pants + pants);
367         } else {
368                 setcolor(pl, shirt + pants);
369         }
370 }
371
372 void SetPlayerTeam(entity pl, float t, float s, float noprint)
373 {
374         float _color;
375
376         if(t == 4)
377                 _color = NUM_TEAM_4 - 1;
378         else if(t == 3)
379                 _color = NUM_TEAM_3 - 1;
380         else if(t == 2)
381                 _color = NUM_TEAM_2 - 1;
382         else
383                 _color = NUM_TEAM_1 - 1;
384
385         SetPlayerColors(pl,_color);
386
387         if(t != s) {
388                 LogTeamchange(pl.playerid, pl.team, 3);  // log manual team join
389
390                 if(!noprint)
391                 bprint(pl.netname, "^7 has changed from ", Team_NumberToColoredFullName(s), "^7 to ", Team_NumberToColoredFullName(t), "\n");
392         }
393
394 }
395
396 // set c1...c4 to show what teams are allowed
397 void CheckAllowedTeams (entity for_whom)
398 {SELFPARAM();
399         float dm;
400         entity head;
401         string teament_name;
402
403         c1 = c2 = c3 = c4 = -1;
404         cb1 = cb2 = cb3 = cb4 = 0;
405
406         teament_name = string_null;
407         if(g_onslaught)
408         {
409                 // onslaught is special
410                 head = findchain(classname, "onslaught_generator");
411                 while (head)
412                 {
413                         if (head.team == NUM_TEAM_1) c1 = 0;
414                         if (head.team == NUM_TEAM_2) c2 = 0;
415                         if (head.team == NUM_TEAM_3) c3 = 0;
416                         if (head.team == NUM_TEAM_4) c4 = 0;
417                         head = head.chain;
418                 }
419         }
420         else if(g_domination)
421                 teament_name = "dom_team";
422         else if(g_ctf)
423                 teament_name = "ctf_team";
424         else if(g_tdm)
425                 teament_name = "tdm_team";
426         else if(g_nexball)
427                 teament_name = "nexball_team";
428         else if(g_assault)
429                 c1 = c2 = 0; // Assault always has 2 teams
430         else
431         {
432                 // cover anything else by treating it like tdm with no teams spawned
433                 dm = 2;
434
435                 MUTATOR_CALLHOOK(GetTeamCount, dm);
436                 dm = ret_float;
437
438                 if(dm >= 4)
439                         c1 = c2 = c3 = c4 = 0;
440                 else if(dm >= 3)
441                         c1 = c2 = c3 = 0;
442                 else
443                         c1 = c2 = 0;
444         }
445
446         // find out what teams are allowed if necessary
447         if(teament_name)
448         {
449                 head = find(world, classname, teament_name);
450                 while(head)
451                 {
452                         if(!(g_domination && head.netname == ""))
453                         {
454                                 if(head.team == NUM_TEAM_1)
455                                         c1 = 0;
456                                 else if(head.team == NUM_TEAM_2)
457                                         c2 = 0;
458                                 else if(head.team == NUM_TEAM_3)
459                                         c3 = 0;
460                                 else if(head.team == NUM_TEAM_4)
461                                         c4 = 0;
462                         }
463                         head = find(head, classname, teament_name);
464                 }
465         }
466
467         // TODO: Balance quantity of bots across > 2 teams when bot_vs_human is set (and remove next line)
468         if(c3==-1 && c4==-1)
469         if(autocvar_bot_vs_human && for_whom)
470         {
471                 if(autocvar_bot_vs_human > 0)
472                 {
473                         // bots are all blue
474                         if(IS_BOT_CLIENT(for_whom))
475                                 c1 = c3 = c4 = -1;
476                         else
477                                 c2 = -1;
478                 }
479                 else
480                 {
481                         // bots are all red
482                         if(IS_BOT_CLIENT(for_whom))
483                                 c2 = c3 = c4 = -1;
484                         else
485                                 c1 = -1;
486                 }
487         }
488
489         // if player has a forced team, ONLY allow that one
490         if(self.team_forced == NUM_TEAM_1 && c1 >= 0)
491                 c2 = c3 = c4 = -1;
492         else if(self.team_forced == NUM_TEAM_2 && c2 >= 0)
493                 c1 = c3 = c4 = -1;
494         else if(self.team_forced == NUM_TEAM_3 && c3 >= 0)
495                 c1 = c2 = c4 = -1;
496         else if(self.team_forced == NUM_TEAM_4 && c4 >= 0)
497                 c1 = c2 = c3 = -1;
498 }
499
500 float PlayerValue(entity p)
501 {
502         return 1;
503         // FIXME: it always returns 1...
504 }
505
506 // c1...c4 should be set to -1 (not allowed) or 0 (allowed).
507 // teams that are allowed will now have their player counts stored in c1...c4
508 void GetTeamCounts(entity ignore)
509 {
510         entity head;
511         float value, bvalue;
512         // now count how many players are on each team already
513
514         // FIXME: also find and memorize the lowest-scoring bot on each team (in case players must be shuffled around)
515         // also remember the lowest-scoring player
516
517         FOR_EACH_CLIENT(head)
518         {
519                 float t;
520                 if(IS_PLAYER(head) || head.caplayer)
521                         t = head.team;
522                 else if(head.team_forced > 0)
523                         t = head.team_forced; // reserve the spot
524                 else
525                         continue;
526                 if(head != ignore)// && head.netname != "")
527                 {
528                         value = PlayerValue(head);
529                         if(IS_BOT_CLIENT(head))
530                                 bvalue = value;
531                         else
532                                 bvalue = 0;
533                         if(t == NUM_TEAM_1)
534                         {
535                                 if(c1 >= 0)
536                                 {
537                                         c1 = c1 + value;
538                                         cb1 = cb1 + bvalue;
539                                 }
540                         }
541                         if(t == NUM_TEAM_2)
542                         {
543                                 if(c2 >= 0)
544                                 {
545                                         c2 = c2 + value;
546                                         cb2 = cb2 + bvalue;
547                                 }
548                         }
549                         if(t == NUM_TEAM_3)
550                         {
551                                 if(c3 >= 0)
552                                 {
553                                         c3 = c3 + value;
554                                         cb3 = cb3 + bvalue;
555                                 }
556                         }
557                         if(t == NUM_TEAM_4)
558                         {
559                                 if(c4 >= 0)
560                                 {
561                                         c4 = c4 + value;
562                                         cb4 = cb4 + bvalue;
563                                 }
564                         }
565                 }
566         }
567
568         // if the player who has a forced team has not joined yet, reserve the spot
569         if(autocvar_g_campaign)
570         {
571                 switch(autocvar_g_campaign_forceteam)
572                 {
573                         case 1: if(c1 == cb1) ++c1; break;
574                         case 2: if(c2 == cb2) ++c2; break;
575                         case 3: if(c3 == cb3) ++c3; break;
576                         case 4: if(c4 == cb4) ++c4; break;
577                 }
578         }
579 }
580
581 float TeamSmallerEqThanTeam(float ta, float tb, entity e)
582 {
583         // we assume that CheckAllowedTeams and GetTeamCounts have already been called
584         float f;
585         float ca = -1, cb = -1, cba = 0, cbb = 0, sa = 0, sb = 0;
586
587         switch(ta)
588         {
589                 case 1: ca = c1; cba = cb1; sa = team1_score; break;
590                 case 2: ca = c2; cba = cb2; sa = team2_score; break;
591                 case 3: ca = c3; cba = cb3; sa = team3_score; break;
592                 case 4: ca = c4; cba = cb4; sa = team4_score; break;
593         }
594         switch(tb)
595         {
596                 case 1: cb = c1; cbb = cb1; sb = team1_score; break;
597                 case 2: cb = c2; cbb = cb2; sb = team2_score; break;
598                 case 3: cb = c3; cbb = cb3; sb = team3_score; break;
599                 case 4: cb = c4; cbb = cb4; sb = team4_score; break;
600         }
601
602         // invalid
603         if(ca < 0 || cb < 0)
604                 return false;
605
606         // equal
607         if(ta == tb)
608                 return true;
609
610         if(IS_REAL_CLIENT(e))
611         {
612                 if(bots_would_leave)
613                 {
614                         ca -= cba * 0.999;
615                         cb -= cbb * 0.999;
616                 }
617         }
618
619         // keep teams alive (teams of size 0 always count as smaller, ignoring score)
620         if(ca < 1)
621                 if(cb >= 1)
622                         return true;
623         if(ca >= 1)
624                 if(cb < 1)
625                         return false;
626
627         // first, normalize
628         f = max(ca, cb, 1);
629         ca /= f;
630         cb /= f;
631         f = max(sa, sb, 1);
632         sa /= f;
633         sb /= f;
634
635         // the more we're at the end of the match, the more take scores into account
636         f = bound(0, game_completion_ratio * autocvar_g_balance_teams_scorefactor, 1);
637         ca += (sa - ca) * f;
638         cb += (sb - cb) * f;
639
640         return ca <= cb;
641 }
642
643 // returns # of smallest team (1, 2, 3, 4)
644 // NOTE: Assumes CheckAllowedTeams has already been called!
645 float FindSmallestTeam(entity pl, float ignore_pl)
646 {
647         float totalteams, t;
648         totalteams = 0;
649
650         // find out what teams are available
651         //CheckAllowedTeams();
652
653         // make sure there are at least 2 teams to join
654         if(c1 >= 0)
655                 totalteams = totalteams + 1;
656         if(c2 >= 0)
657                 totalteams = totalteams + 1;
658         if(c3 >= 0)
659                 totalteams = totalteams + 1;
660         if(c4 >= 0)
661                 totalteams = totalteams + 1;
662
663         if((autocvar_bot_vs_human || pl.team_forced > 0) && totalteams == 1)
664                 totalteams += 1;
665
666         if(totalteams <= 1)
667         {
668                 if(autocvar_g_campaign && pl && IS_REAL_CLIENT(pl))
669                         return 1; // special case for campaign and player joining
670                 else
671                         error(sprintf("Too few teams available for %s\n", MapInfo_Type_ToString(MapInfo_CurrentGametype())));
672         }
673
674         // count how many players are in each team
675         if(ignore_pl)
676                 GetTeamCounts(pl);
677         else
678                 GetTeamCounts(world);
679
680         RandomSelection_Init();
681
682         t = 1;
683         if(TeamSmallerEqThanTeam(2, t, pl))
684                 t = 2;
685         if(TeamSmallerEqThanTeam(3, t, pl))
686                 t = 3;
687         if(TeamSmallerEqThanTeam(4, t, pl))
688                 t = 4;
689
690         // now t is the minimum, or A minimum!
691         if(t == 1 || TeamSmallerEqThanTeam(1, t, pl))
692                 RandomSelection_Add(world, 1, string_null, 1, 1);
693         if(t == 2 || TeamSmallerEqThanTeam(2, t, pl))
694                 RandomSelection_Add(world, 2, string_null, 1, 1);
695         if(t == 3 || TeamSmallerEqThanTeam(3, t, pl))
696                 RandomSelection_Add(world, 3, string_null, 1, 1);
697         if(t == 4 || TeamSmallerEqThanTeam(4, t, pl))
698                 RandomSelection_Add(world, 4, string_null, 1, 1);
699
700         return RandomSelection_chosen_float;
701 }
702
703 float JoinBestTeam(entity pl, float only_return_best, float forcebestteam)
704 {SELFPARAM();
705         float smallest, selectedteam;
706
707         // don't join a team if we're not playing a team game
708         if(!teamplay)
709                 return 0;
710
711         // find out what teams are available
712         CheckAllowedTeams(pl);
713
714         // if we don't care what team he ends up on, put him on whatever team he entered as.
715         // if he's not on a valid team, then let other code put him on the smallest team
716         if(!forcebestteam)
717         {
718                 if(     c1 >= 0 && pl.team == NUM_TEAM_1)
719                         selectedteam = pl.team;
720                 else if(c2 >= 0 && pl.team == NUM_TEAM_2)
721                         selectedteam = pl.team;
722                 else if(c3 >= 0 && pl.team == NUM_TEAM_3)
723                         selectedteam = pl.team;
724                 else if(c4 >= 0 && pl.team == NUM_TEAM_4)
725                         selectedteam = pl.team;
726                 else
727                         selectedteam = -1;
728
729                 if(selectedteam > 0)
730                 {
731                         if(!only_return_best)
732                         {
733                                 SetPlayerColors(pl, selectedteam - 1);
734
735                                 // when JoinBestTeam is called by client.qc/ClientKill_Now_TeamChange the players team is -1 and thus skipped
736                                 // when JoinBestTeam is called by cl_client.qc/ClientConnect the player_id is 0 the log attempt is rejected
737                                 LogTeamchange(pl.playerid, pl.team, 99);
738                         }
739                         return selectedteam;
740                 }
741                 // otherwise end up on the smallest team (handled below)
742         }
743
744         smallest = FindSmallestTeam(pl, true);
745
746         if(!only_return_best && !pl.bot_forced_team)
747         {
748                 TeamchangeFrags(self);
749                 if(smallest == 1)
750                 {
751                         SetPlayerColors(pl, NUM_TEAM_1 - 1);
752                 }
753                 else if(smallest == 2)
754                 {
755                         SetPlayerColors(pl, NUM_TEAM_2 - 1);
756                 }
757                 else if(smallest == 3)
758                 {
759                         SetPlayerColors(pl, NUM_TEAM_3 - 1);
760                 }
761                 else if(smallest == 4)
762                 {
763                         SetPlayerColors(pl, NUM_TEAM_4 - 1);
764                 }
765                 else
766                 {
767                         error("smallest team: invalid team\n");
768                 }
769
770                 LogTeamchange(pl.playerid, pl.team, 2); // log auto join
771
772                 if(pl.deadflag == DEAD_NO)
773                         Damage(pl, pl, pl, 100000, DEATH_TEAMCHANGE, pl.origin, '0 0 0');
774         }
775
776         return smallest;
777 }
778
779 //void() ctf_playerchanged;
780 void SV_ChangeTeam(float _color)
781 {SELFPARAM();
782         float scolor, dcolor, steam, dteam; //, dbotcount, scount, dcount;
783
784         // in normal deathmatch we can just apply the color and we're done
785         if(!teamplay) {
786                 SetPlayerColors(self, _color);
787                 return;
788         }
789
790         scolor = self.clientcolors & 0x0F;
791         dcolor = _color & 0x0F;
792
793         if(scolor == NUM_TEAM_1 - 1)
794                 steam = 1;
795         else if(scolor == NUM_TEAM_2 - 1)
796                 steam = 2;
797         else if(scolor == NUM_TEAM_3 - 1)
798                 steam = 3;
799         else // if(scolor == NUM_TEAM_4 - 1)
800                 steam = 4;
801         if(dcolor == NUM_TEAM_1 - 1)
802                 dteam = 1;
803         else if(dcolor == NUM_TEAM_2 - 1)
804                 dteam = 2;
805         else if(dcolor == NUM_TEAM_3 - 1)
806                 dteam = 3;
807         else // if(dcolor == NUM_TEAM_4 - 1)
808                 dteam = 4;
809
810         CheckAllowedTeams(self);
811
812         if(dteam == 1 && c1 < 0) dteam = 4;
813         if(dteam == 4 && c4 < 0) dteam = 3;
814         if(dteam == 3 && c3 < 0) dteam = 2;
815         if(dteam == 2 && c2 < 0) dteam = 1;
816
817         // not changing teams
818         if(scolor == dcolor)
819         {
820                 //bprint("same team change\n");
821                 SetPlayerTeam(self, dteam, steam, true);
822                 return;
823         }
824
825         if((autocvar_g_campaign) || (autocvar_g_changeteam_banned && self.wasplayer)) {
826                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TEAMCHANGE_NOTALLOWED);
827                 return; // changing teams is not allowed
828         }
829
830         // autocvar_g_balance_teams_prevent_imbalance only makes sense if autocvar_g_balance_teams is on, as it makes the team selection dialog pointless
831         if(autocvar_g_balance_teams && autocvar_g_balance_teams_prevent_imbalance)
832         {
833                 GetTeamCounts(self);
834                 if(!TeamSmallerEqThanTeam(dteam, steam, self))
835                 {
836                         Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_TEAMCHANGE_LARGERTEAM);
837                         return;
838                 }
839         }
840
841 //      bprint("allow change teams from ", ftos(steam), " to ", ftos(dteam), "\n");
842
843         if(IS_PLAYER(self) && steam != dteam)
844         {
845                 // reduce frags during a team change
846                 TeamchangeFrags(self);
847         }
848
849         // since this is an engine function, and gamecode doesn't have any calls earlier than this, do the connecting message here
850         if(!IS_CLIENT(self))
851                 Send_Notification(NOTIF_ONE, self, MSG_INFO, INFO_CONNECTING, self.netname);
852
853         SetPlayerTeam(self, dteam, steam, !IS_CLIENT(self));
854
855         if(IS_PLAYER(self) && steam != dteam)
856         {
857                 // kill player when changing teams
858                 if(self.deadflag == DEAD_NO)
859                         Damage(self, self, self, 100000, DEATH_TEAMCHANGE, self.origin, '0 0 0');
860         }
861 }
862
863 void ShufflePlayerOutOfTeam (float source_team)
864 {
865         float smallestteam, smallestteam_count, steam;
866         float lowest_bot_score, lowest_player_score;
867         entity head, lowest_bot, lowest_player, selected;
868
869         smallestteam = 0;
870         smallestteam_count = 999999999;
871
872         if(c1 >= 0 && c1 < smallestteam_count)
873         {
874                 smallestteam = 1;
875                 smallestteam_count = c1;
876         }
877         if(c2 >= 0 && c2 < smallestteam_count)
878         {
879                 smallestteam = 2;
880                 smallestteam_count = c2;
881         }
882         if(c3 >= 0 && c3 < smallestteam_count)
883         {
884                 smallestteam = 3;
885                 smallestteam_count = c3;
886         }
887         if(c4 >= 0 && c4 < smallestteam_count)
888         {
889                 smallestteam = 4;
890                 smallestteam_count = c4;
891         }
892
893         if(!smallestteam)
894         {
895                 bprint("warning: no smallest team\n");
896                 return;
897         }
898
899         if(source_team == 1)
900                 steam = NUM_TEAM_1;
901         else if(source_team == 2)
902                 steam = NUM_TEAM_2;
903         else if(source_team == 3)
904                 steam = NUM_TEAM_3;
905         else // if(source_team == 4)
906                 steam = NUM_TEAM_4;
907
908         lowest_bot = world;
909         lowest_bot_score = 999999999;
910         lowest_player = world;
911         lowest_player_score = 999999999;
912
913         // find the lowest-scoring player & bot of that team
914         FOR_EACH_PLAYER(head)
915         {
916                 if(head.team == steam)
917                 {
918                         if(head.isbot)
919                         {
920                                 if(head.totalfrags < lowest_bot_score)
921                                 {
922                                         lowest_bot = head;
923                                         lowest_bot_score = head.totalfrags;
924                                 }
925                         }
926                         else
927                         {
928                                 if(head.totalfrags < lowest_player_score)
929                                 {
930                                         lowest_player = head;
931                                         lowest_player_score = head.totalfrags;
932                                 }
933                         }
934                 }
935         }
936
937         // prefers to move a bot...
938         if(lowest_bot != world)
939                 selected = lowest_bot;
940         // but it will move a player if it has to
941         else
942                 selected = lowest_player;
943         // don't do anything if it couldn't find anyone
944         if(!selected)
945         {
946                 bprint("warning: couldn't find a player to move from team\n");
947                 return;
948         }
949
950         // smallest team gains a member
951         if(smallestteam == 1)
952         {
953                 c1 = c1 + 1;
954         }
955         else if(smallestteam == 2)
956         {
957                 c2 = c2 + 1;
958         }
959         else if(smallestteam == 3)
960         {
961                 c3 = c3 + 1;
962         }
963         else if(smallestteam == 4)
964         {
965                 c4 = c4 + 1;
966         }
967         else
968         {
969                 bprint("warning: destination team invalid\n");
970                 return;
971         }
972         // source team loses a member
973         if(source_team == 1)
974         {
975                 c1 = c1 + 1;
976         }
977         else if(source_team == 2)
978         {
979                 c2 = c2 + 2;
980         }
981         else if(source_team == 3)
982         {
983                 c3 = c3 + 3;
984         }
985         else if(source_team == 4)
986         {
987                 c4 = c4 + 4;
988         }
989         else
990         {
991                 bprint("warning: source team invalid\n");
992                 return;
993         }
994
995         // move the player to the new team
996         TeamchangeFrags(selected);
997         SetPlayerTeam(selected, smallestteam, source_team, false);
998
999         if(selected.deadflag == DEAD_NO)
1000                 Damage(selected, selected, selected, 100000, DEATH_AUTOTEAMCHANGE, selected.origin, '0 0 0');
1001         Send_Notification(NOTIF_ONE, selected, MSG_CENTER, CENTER_DEATH_SELF_AUTOTEAMCHANGE, selected.team);
1002 }