6f7198c2a9f225e803fe7f63d5faa557063262a6
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / ctf.qc
1 #define FLAG_MIN (PL_MIN + '0 0 -13')
2 #define FLAG_MAX (PL_MAX + '0 0 -13')
3
4 .entity basewaypoint;
5 .entity sprite;
6 entity ctf_worldflaglist; // CTF flags in the map
7 .entity ctf_worldflagnext;
8 .float dropperid;
9 .float ctf_droptime;
10
11 .float next_take_time;                  // the next time a player can pick up a flag (time + blah)
12                                                                 /// I used this, in part, to fix the looping score bug. - avirox
13 //float FLAGSCORE_PICKUP        =  1;
14 //float FLAGSCORE_RETURN        =  5; // returned by owner team
15 //float FLAGSCORE_RETURNROGUE   = 10; // returned by rogue team
16 //float FLAGSCORE_CAPTURE       =  5;
17
18 #define FLAG_CARRY_POS '-15 0 7'
19
20 .float ctf_captureshielded; // set to 1 if the player is too bad to be allowed to capture
21
22 float captureshield_min_negscore; // punish at -20 points
23 float captureshield_max_ratio; // punish at most 30% of each team
24 float captureshield_force; // push force of the shield
25
26 float ctf_captureshield_shielded(entity p)
27 {
28         float s, se;
29         entity e;
30         float players_worseeq, players_total;
31
32         if(captureshield_max_ratio <= 0)
33                 return FALSE;
34
35         s = PlayerScore_Add(p, SP_SCORE, 0);
36         if(s >= -captureshield_min_negscore)
37                 return FALSE;
38
39         players_total = players_worseeq = 0;
40         FOR_EACH_PLAYER(e)
41         {
42                 if(e.team != p.team)
43                         continue;
44                 se = PlayerScore_Add(e, SP_SCORE, 0);
45                 if(se <= s)
46                         ++players_worseeq;
47                 ++players_total;
48         }
49
50         // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
51         // use this rule here
52
53         if(players_worseeq >= players_total * captureshield_max_ratio)
54                 return FALSE;
55
56         return TRUE;
57 }
58
59 void ctf_captureshield_update(entity p, float dir)
60 {
61         float should;
62         if(dir == p.ctf_captureshielded) // 0: shield only, 1: unshield only
63         {
64                 should = ctf_captureshield_shielded(p);
65                 if(should != dir)
66                 {
67                         if(should)
68                         {
69                                 Send_CSQC_Centerprint_Generic(other, CPID_CTF_CAPTURESHIELD, "^3You are ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Get some defensive scores before trying again.", 5, 0);
70                                 // TODO csqc notifier for this
71                         }
72                         else
73                         {
74                                 Send_CSQC_Centerprint_Generic(p, CPID_CTF_CAPTURESHIELD, "^3You are now free.\n\n^3Feel free to ^1try to capture^3 the flag again\n^3if you think you will succeed.", 5, 0);
75                                 // TODO csqc notifier for this
76                         }
77                         p.ctf_captureshielded = should;
78                 }
79         }
80 }
81
82 float ctf_captureshield_customize()
83 {
84         if not(other.ctf_captureshielded)
85                 return FALSE;
86         if(self.team == other.team)
87                 return FALSE;
88         return TRUE;
89 }
90
91 .float ctf_captureshield_touch_msgtime;
92 void ctf_captureshield_touch()
93 {
94         if not(other.ctf_captureshielded)
95                 return;
96         if(self.team == other.team)
97                 return;
98         vector mymid;
99         vector othermid;
100         mymid = (self.absmin + self.absmax) * 0.5;
101         othermid = (other.absmin + other.absmax) * 0.5;
102         Damage(other, self, self, 0, DEATH_HURTTRIGGER, mymid, normalize(othermid - mymid) * captureshield_force);
103         if (time - other.ctf_captureshield_touch_msgtime > 2)
104                 Send_CSQC_Centerprint_Generic(other, CPID_CTF_CAPTURESHIELD, "^3You are ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Get some defensive scores before trying again.", 5, 0);
105         other.ctf_captureshield_touch_msgtime = time;
106 }
107
108 void ctf_flag_spawnstuff()
109 {
110         entity e;
111         e = spawn();
112         e.enemy = self;
113         e.team = self.team;
114         e.touch = ctf_captureshield_touch;
115         e.customizeentityforclient = ctf_captureshield_customize;
116         e.classname = "ctf_captureshield";
117         e.effects = EF_ADDITIVE;
118         e.movetype = MOVETYPE_NOCLIP;
119         e.solid = SOLID_TRIGGER;
120         e.avelocity = '7 0 11';
121         setorigin(e, self.origin);
122         setmodel(e, "models/ctf/shield.md3");
123         e.scale = 0.5;
124         setsize(e, e.scale * e.mins, e.scale * e.maxs);
125
126         waypoint_spawnforitem_force(self, self.origin);
127         self.nearestwaypointtimeout = 0; // activate waypointing again
128         self.basewaypoint = self.nearestwaypoint;
129
130         if(self.team == COLOR_TEAM1)
131                 WaypointSprite_SpawnFixed("redbase", self.origin + '0 0 61', self, sprite, RADARICON_FLAG, colormapPaletteColor(COLOR_TEAM1 - 1, FALSE));
132         else
133                 WaypointSprite_SpawnFixed("bluebase", self.origin + '0 0 61', self, sprite, RADARICON_FLAG, colormapPaletteColor(COLOR_TEAM2 - 1, FALSE));
134 }
135
136 float ctf_score_value(string parameter)
137 {
138         if(g_ctf_win_mode != 2)
139                 return cvar(strcat("g_ctf_personal", parameter));
140         else
141                 return cvar(strcat("g_ctf_flag", parameter));
142 }
143
144 void FakeTimeLimit(entity e, float t)
145 {
146         msg_entity = e;
147         WriteByte(MSG_ONE, 3); // svc_updatestat
148         WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
149         if(t < 0)
150                 WriteCoord(MSG_ONE, autocvar_timelimit);
151         else
152                 WriteCoord(MSG_ONE, (t + 1) / 60);
153 }
154
155 float   flagcaptimerecord;
156 .float  flagpickuptime;
157 //.float  iscommander;
158 //.float  ctf_state;
159
160 void() FlagThink;
161 void() FlagTouch;
162
163 void place_flag()
164 {
165         if(self.classname != "item_flag_team")
166         {
167                 backtrace("PlaceFlag a non-flag");
168                 return;
169         }
170
171         setattachment(self, world, "");
172         self.mdl = self.model;
173         self.flags = FL_ITEM | FL_NOTARGET;
174         self.solid = SOLID_TRIGGER;
175         self.movetype = MOVETYPE_NONE;
176         self.velocity = '0 0 0';
177         self.origin_z = self.origin_z + 6;
178         self.think = FlagThink;
179         self.touch = FlagTouch;
180         self.nextthink = time + 0.1;
181         self.cnt = FLAG_BASE;
182         self.mangle = self.angles;
183         self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
184         //self.effects = self.effects | EF_DIMLIGHT;
185         if(self.noalign)
186         {
187                 self.dropped_origin = self.origin;
188         }
189         else
190         {
191                 droptofloor();
192                 self.movetype = MOVETYPE_TOSS;
193         }
194
195         InitializeEntity(self, ctf_flag_spawnstuff, INITPRIO_SETLOCATION);
196 }
197
198 void LogCTF(string mode, float flagteam, entity actor)
199 {
200         string s;
201         if(!autocvar_sv_eventlog)
202                 return;
203         s = strcat(":ctf:", mode);
204         s = strcat(s, ":", ftos(flagteam));
205         if(actor != world)
206                 s = strcat(s, ":", ftos(actor.playerid));
207         GameLogEcho(s);
208 }
209
210 void RegenFlag(entity e)
211 {
212         if(e.classname != "item_flag_team")
213         {
214                 backtrace("RegenFlag a non-flag");
215                 return;
216         }
217
218         if(e.waypointsprite_attachedforcarrier)
219                 WaypointSprite_DetachCarrier(e);
220
221         setattachment(e, world, "");
222         e.damageforcescale = 0;
223         e.takedamage = DAMAGE_NO;
224         e.movetype = MOVETYPE_NONE;
225         if(!e.noalign)
226                 e.movetype = MOVETYPE_TOSS;
227         e.velocity = '0 0 0';
228         e.solid = SOLID_TRIGGER;
229         // TODO: play a sound here
230         setorigin(e, e.dropped_origin);
231         e.angles = e.mangle;
232         e.cnt = FLAG_BASE;
233         e.owner = world;
234         e.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND and any other junk
235 }
236
237 void ReturnFlag(entity e)
238 {
239         if(e.classname != "item_flag_team")
240         {
241                 backtrace("ReturnFlag a non-flag");
242                 return;
243         }
244
245         if (e.owner)
246         if (e.owner.flagcarried == e)
247         {
248                 WaypointSprite_DetachCarrier(e.owner);
249                 e.owner.flagcarried = world;
250
251                 if(e.speedrunning)
252                         FakeTimeLimit(e.owner, -1);
253         }
254         e.owner = world;
255         RegenFlag(e);
256 }
257
258 void DropFlag(entity e, entity penalty_receiver, entity attacker)
259 {
260         entity p;
261
262         if(e.classname != "item_flag_team")
263         {
264                 backtrace("DropFlag a non-flag");
265                 return;
266         }
267
268         if(e.speedrunning)
269         {
270                 ReturnFlag(e);
271                 return;
272         }
273
274         if (!e.owner)
275         {
276                 dprint("FLAG: drop - no owner?!?!\n");
277                 return;
278         }
279         p = e.owner;
280         if (p.flagcarried != e)
281         {
282                 dprint("FLAG: drop - owner is not carrying this flag??\n");
283                 return;
284         }
285         //bprint(p.netname, "^7 lost the ", e.netname, "\n");
286         Send_KillNotification (p.netname, e.netname, "", INFO_LOSTFLAG, MSG_INFO);
287
288         if(penalty_receiver)
289                 UpdateFrags(penalty_receiver, -ctf_score_value("penalty_suicidedrop"));
290         else
291                 UpdateFrags(p, -ctf_score_value("penalty_drop"));
292         PlayerScore_Add(p, SP_CTF_DROPS, +1);
293         ctf_captureshield_update(p, 0); // shield only
294         e.playerid = attacker.playerid;
295         e.ctf_droptime = time;
296         WaypointSprite_Spawn("flagdropped", 0, 0, e, '0 0 1' * 61, world, COLOR_TEAM1 + COLOR_TEAM2 - e.team, e, waypointsprite_attachedforcarrier, FALSE, RADARICON_FLAG, '0 1 1');
297         WaypointSprite_Ping(e.waypointsprite_attachedforcarrier);
298         
299         if(p.waypointsprite_attachedforcarrier)
300         {
301                 WaypointSprite_DetachCarrier(p);
302         }
303         else
304         {
305                 bprint("\{1}^1Flag carrier had no flag sprite?!?\n");
306                 backtrace("Flag carrier had no flag sprite?!?");
307         }
308         LogCTF("dropped", p.team, p);
309         sound (p, CH_TRIGGER, self.noise4, VOL_BASE, ATTN_NONE);
310
311         setattachment(e, world, "");
312         e.damageforcescale = autocvar_g_balance_ctf_damageforcescale;
313         e.takedamage = DAMAGE_YES;
314
315         if (p.flagcarried == e)
316                 p.flagcarried = world;
317         e.owner = world;
318
319         e.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND and any other junk
320         e.solid = SOLID_TRIGGER;
321         e.movetype = MOVETYPE_TOSS;
322         // setsize(e, '-16 -16 0', '16 16 74');
323         setorigin(e, p.origin - '0 0 24' + '0 0 37');
324         e.cnt = FLAG_DROPPED;
325         e.velocity = '0 0 300';
326         e.pain_finished = time + autocvar_g_ctf_flag_returntime;//30;
327
328         trace_startsolid = FALSE;
329         tracebox(e.origin, e.mins, e.maxs, e.origin, TRUE, e);
330         if(trace_startsolid)
331                 dprint("FLAG FALLTHROUGH will happen SOON\n");
332 }
333
334 void FlagThink()
335 {
336         entity e;
337
338         self.nextthink = time + 0.1;
339
340         // sorry, we have to reset the flag size if it got squished by something
341         if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX)
342         {
343                 // if we can grow back, grow back
344                 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
345                 if(!trace_startsolid)
346                         setsize(self, FLAG_MIN, FLAG_MAX);
347         }
348
349         if(self == ctf_worldflaglist) // only for the first flag
350         {
351                 FOR_EACH_CLIENT(e)
352                         ctf_captureshield_update(e, 1); // release shield only
353         }
354
355         if(self.speedrunning)
356         if(self.cnt == FLAG_CARRY)
357         {
358                 if(self.owner)
359                 if(flagcaptimerecord)
360                 if(time >= self.flagpickuptime + flagcaptimerecord)
361                 {
362                         bprint("The ", self.netname, " became impatient after ", ftos_decimals(flagcaptimerecord, 2), " seconds and returned itself\n");
363
364                         sound (self, CH_TRIGGER, self.noise3, VOL_BASE, ATTN_NONE);
365                         self.owner.impulse = 141; // returning!
366
367                         e = self;
368                         self = self.owner;
369                         ReturnFlag(e);
370                         ImpulseCommands();
371                         self = e;
372                         return;
373                 }
374         }
375
376         if (self.cnt == FLAG_BASE)
377                 return;
378
379         if (self.cnt == FLAG_DROPPED)
380         {
381                 // flag fallthrough? FIXME remove this if bug is really fixed now
382                 if(self.origin_z < -131072)
383                 {
384                         dprint("FLAG FALLTHROUGH just happened\n");
385                         self.pain_finished = 0;
386                 }
387                 setattachment(self, world, "");
388                 if (time > self.pain_finished)
389                 {
390                         bprint("The ", self.netname, " has returned to base\n");
391                         sound (self, CH_TRIGGER, self.noise3, VOL_BASE, ATTN_NONE);
392                         LogCTF("returned", self.team, world);
393                         ReturnFlag(self);
394                 }
395                 return;
396         }
397
398         e = self.owner;
399         if (e.classname != "player" || (e.deadflag) || (e.flagcarried != self))
400         {
401                 dprint("CANNOT HAPPEN - player dead and STILL had a flag!\n");
402                 DropFlag(self, world, world);
403                 return;
404         }
405 }
406
407 float ctf_usekey()
408 {
409         if(self.flagcarried)
410         {
411                 DropFlag(self.flagcarried, self, world);
412                 return TRUE;
413         }
414         return FALSE;
415 }
416
417 void flag_cap_ring_spawn(vector org)
418 {
419         shockwave_spawn("models/ctf/shockwavetransring.md3", org - '0 0 15', -0.8, 0, 1);
420 }
421
422 void FlagTouch()
423 {
424         if(gameover) return;
425
426         float t;
427         entity player;
428         string s, s0, h0, h1;
429         if (other.classname != "player")
430                 return;
431         if (other.health < 1) // ignore dead players
432                 return;
433
434         if (self.cnt == FLAG_CARRY)
435                 return;
436
437         if (self.cnt == FLAG_BASE)
438         if (other.team == self.team)
439         if (other.flagcarried) // he's got a flag
440         if (other.flagcarried.team != self.team) // capture
441         {
442                 if (other.flagcarried == world)
443                 {
444                         return;
445                 }
446                 if(autocvar_g_ctf_captimerecord_always || player_count - currentbots <= 1) // at most one human
447                 {
448                         t = time - other.flagcarried.flagpickuptime;
449                         s = ftos_decimals(t, 2);
450                         s0 = ftos_decimals(flagcaptimerecord, 2);
451                         h0 = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
452                         h1 = other.netname;
453                         if(h0 == h1)
454                                 h0 = "their";
455                         else
456                                 h0 = strcat(h0, "^7's"); // h0: display text for previous netname
457                         if (flagcaptimerecord == 0)
458                         {
459                                 s = strcat(" in ", s, " seconds");
460                                 flagcaptimerecord = t;
461                                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(t));
462                                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), h1);
463                                 write_recordmarker(other, time - t, t);
464                         }
465                         else if (t < flagcaptimerecord)
466                         {
467                                 s = strcat(" in ", s, " seconds, breaking ", h0, " previous record of ", s0, " seconds");
468                                 flagcaptimerecord = t;
469                                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(t));
470                                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), h1);
471                                 write_recordmarker(other, time - t, t);
472                         }
473                         else
474                         {
475                                 s = strcat(" in ", s, " seconds, failing to break ", h0, " record of ", s0, " seconds");
476                         }
477                 }
478                 else
479                         s = "";
480
481                 Send_KillNotification (other.netname, other.flagcarried.netname, s, INFO_CAPTUREFLAG, MSG_INFO);
482
483                 PlayerTeamScore_Add(other, SP_CTF_CAPS, ST_CTF_CAPS, 1);
484                 LogCTF("capture", other.flagcarried.team, other);
485                 // give credit to the individual player
486                 UpdateFrags(other, ctf_score_value("score_capture"));
487
488                 if (autocvar_g_ctf_flag_capture_effects) {
489                         if (other.team == COLOR_TEAM1) { // red team scores effect
490                                 pointparticles(particleeffectnum("red_ground_quake"), self.origin, '0 0 0', 1);
491                                 flag_cap_ring_spawn(self.origin);
492                         }
493                         if (other.team == COLOR_TEAM2) { // blue team scores effect
494                                 pointparticles(particleeffectnum("blue_ground_quake"), self.origin, '0 0 0', 1);
495                                 flag_cap_ring_spawn(self.origin);
496                         }
497                 }
498
499                 sound (other, CH_TRIGGER, self.noise2, VOL_BASE, ATTN_NONE);
500                 WaypointSprite_DetachCarrier(other);
501                 if(self.speedrunning)
502                         FakeTimeLimit(other, -1);
503                 RegenFlag (other.flagcarried);
504                 other.flagcarried = world;
505                 other.next_take_time = time + 1;
506         }
507         if (self.cnt == FLAG_BASE)
508         if (other.team == COLOR_TEAM1 || other.team == COLOR_TEAM2) // only red and blue team can steal flags
509         if (other.team != self.team)
510         if (!other.flagcarried)
511         if (!other.ctf_captureshielded)
512         {
513                 if (other.next_take_time > time)
514                         return;
515
516                 if (autocvar_g_ctf_flag_pickup_effects) // pickup effect
517                         pointparticles(particleeffectnum("smoke_ring"), 0.5 * (self.absmin + self.absmax), '0 0 0', 1);
518
519                 // pick up
520                 self.flagpickuptime = time; // used for timing runs
521                 self.speedrunning = other.speedrunning; // if speedrunning, flag will self-return and teleport the owner back after the record
522                 if(other.speedrunning)
523                 if(flagcaptimerecord)
524                         FakeTimeLimit(other, time + flagcaptimerecord);
525                 self.solid = SOLID_NOT;
526                 setorigin(self, self.origin); // relink
527                 self.owner = other;
528                 other.flagcarried = self;
529                 self.cnt = FLAG_CARRY;
530                 self.angles = '0 0 0';
531                 //bprint(other.netname, "^7 got the ", self.netname, "\n");
532                 Send_KillNotification (other.netname, self.netname, "", INFO_GOTFLAG, MSG_INFO);
533                 UpdateFrags(other, ctf_score_value("score_pickup_base"));
534                 self.dropperid = other.playerid;
535                 PlayerScore_Add(other, SP_CTF_PICKUPS, 1);
536                 LogCTF("steal", self.team, other);
537                 sound (other, CH_TRIGGER, self.noise, VOL_BASE, ATTN_NONE);
538
539                 FOR_EACH_PLAYER(player)
540                         if(player.team == self.team)
541                                 centerprint(player, "The enemy got your flag! Retrieve it!");
542
543                 self.movetype = MOVETYPE_NONE;
544                 setorigin(self, FLAG_CARRY_POS);
545                 setattachment(self, other, "");
546                 WaypointSprite_AttachCarrier("flagcarrier", other, RADARICON_FLAGCARRIER, '1 1 0');
547                 WaypointSprite_Ping(self.sprite);
548
549                 return;
550         }
551
552         if (self.cnt == FLAG_DROPPED)
553         {
554                 self.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND and any other junk
555                 if (other.team == self.team || (other.team != COLOR_TEAM1 && other.team != COLOR_TEAM2))
556                 {
557                         // return flag
558                         Send_KillNotification (other.netname, self.netname, "", INFO_RETURNFLAG, MSG_INFO);
559                         //bprint(other.netname, "^7 returned the ", self.netname, "\n");
560
561                         // punish the player who last had it
562                         FOR_EACH_PLAYER(player)
563                                 if(player.playerid == self.dropperid)
564                                 {
565                                         PlayerScore_Add(player, SP_SCORE, -ctf_score_value("penalty_returned"));
566                                         ctf_captureshield_update(player, 0); // shield only
567                                 }
568
569                         // punish the team who was last carrying it
570                         if(self.team == COLOR_TEAM1)
571                                 TeamScore_AddToTeam(COLOR_TEAM2, ST_SCORE, -ctf_score_value("penalty_returned"));
572                         else
573                                 TeamScore_AddToTeam(COLOR_TEAM1, ST_SCORE, -ctf_score_value("penalty_returned"));
574
575                         // reward the player who returned it
576                         if(other.playerid == self.playerid) // is this the guy who killed the FC last?
577                         {
578                                 if (other.team == COLOR_TEAM1 || other.team == COLOR_TEAM2)
579                                         UpdateFrags(other, ctf_score_value("score_return_by_killer"));
580                                 else
581                                         UpdateFrags(other, ctf_score_value("score_return_rogue_by_killer"));
582                         }
583                         else
584                         {
585                                 if (other.team == COLOR_TEAM1 || other.team == COLOR_TEAM2)
586                                         UpdateFrags(other, ctf_score_value("score_return"));
587                                 else
588                                         UpdateFrags(other, ctf_score_value("score_return_rogue"));
589                         }
590                         PlayerScore_Add(other, SP_CTF_RETURNS, 1);
591                         LogCTF("return", self.team, other);
592                         sound (other, CH_TRIGGER, self.noise1, VOL_BASE, ATTN_NONE);
593                         ReturnFlag(self);
594                 }
595                 else if (!other.flagcarried && (other.playerid != self.dropperid || time > self.ctf_droptime + autocvar_g_balance_ctf_delay_collect))
596                 {
597                         if(self.waypointsprite_attachedforcarrier)
598                                 WaypointSprite_DetachCarrier(self);
599
600                         if (autocvar_g_ctf_flag_pickup_effects) // field pickup effect
601                                 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (self.absmin + self.absmax), '0 0 0', 1);
602
603                         // pick up
604                         self.solid = SOLID_NOT;
605                         setorigin(self, self.origin); // relink
606                         self.owner = other;
607                         other.flagcarried = self;
608                         self.cnt = FLAG_CARRY;
609                         Send_KillNotification (other.netname, self.netname, "", INFO_PICKUPFLAG, MSG_INFO);
610                         //bprint(other.netname, "^7 picked up the ", self.netname, "\n");
611
612                         float f;
613                         f = bound(0, (self.pain_finished - time) / autocvar_g_ctf_flag_returntime, 1);
614                         //print("factor is ", ftos(f), "\n");
615                         f = ctf_score_value("score_pickup_dropped_late") * (1-f)
616                           + ctf_score_value("score_pickup_dropped_early") * f;
617                         f = floor(f + 0.5);
618                         self.dropperid = other.playerid;
619                         //print("score is ", ftos(f), "\n");
620
621                         UpdateFrags(other, f);
622                         PlayerScore_Add(other, SP_CTF_PICKUPS, 1);
623                         LogCTF("pickup", self.team, other);
624                         sound (other, CH_TRIGGER, self.noise, VOL_BASE, ATTN_NONE);
625
626                         FOR_EACH_PLAYER(player)
627                                 if(player.team == self.team)
628                                         centerprint(player, "The enemy got your flag! Retrieve it!");
629
630                         self.movetype = MOVETYPE_NONE;  // flag must have MOVETYPE_NONE here, otherwise it will drop through the floor...
631                         setorigin(self, FLAG_CARRY_POS);
632                         setattachment(self, other, "");
633                         self.damageforcescale = 0;
634                         self.takedamage = DAMAGE_NO;
635                         WaypointSprite_AttachCarrier("flagcarrier", other, RADARICON_FLAGCARRIER, '1 1 0');
636                 }
637         }
638 }
639
640 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
641 CTF Starting point for a player
642 in team one (Red).
643
644 Keys:
645 "angle"
646  viewing angle when spawning
647 */
648 void spawnfunc_info_player_team1()
649 {
650         if(g_assault)
651         {
652                 remove(self);
653                 return;
654         }
655         self.team = COLOR_TEAM1; // red
656         spawnfunc_info_player_deathmatch();
657 }
658 //self.team = 4;self.classname = "info_player_start";spawnfunc_info_player_start();}
659
660 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
661 CTF Starting point for a player in
662 team two (Blue).
663
664 Keys:
665 "angle"
666  viewing angle when spawning
667 */
668 void spawnfunc_info_player_team2()
669 {
670         if(g_assault)
671         {
672                 remove(self);
673                 return;
674         }
675         self.team = COLOR_TEAM2; // blue
676         spawnfunc_info_player_deathmatch();
677 }
678 //self.team = 13;self.classname = "info_player_start";spawnfunc_info_player_start();}
679
680 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
681 CTF Starting point for a player in
682 team three (Yellow).
683
684 Keys:
685 "angle"
686  viewing angle when spawning
687 */
688 void spawnfunc_info_player_team3()
689 {
690         if(g_assault)
691         {
692                 remove(self);
693                 return;
694         }
695         self.team = COLOR_TEAM3; // yellow
696         spawnfunc_info_player_deathmatch();
697 }
698
699
700 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
701 CTF Starting point for a player in
702 team four (Magenta).
703
704 Keys:
705 "angle"
706  viewing angle when spawning
707 */
708 void spawnfunc_info_player_team4()
709 {
710         if(g_assault)
711         {
712                 remove(self);
713                 return;
714         }
715         self.team = COLOR_TEAM4; // purple
716         spawnfunc_info_player_deathmatch();
717 }
718
719 void item_flag_reset()
720 {
721         DropFlag(self, world, world);
722         if(self.waypointsprite_attachedforcarrier)
723                 WaypointSprite_DetachCarrier(self);
724         ReturnFlag(self);
725 }
726
727 void item_flag_postspawn()
728 { // Check CTF Item Flag Post Spawn
729
730         // Flag Glow Trail Support
731         if(autocvar_g_ctf_flag_glowtrails)
732         { // Provide Flag Glow Trail
733                 if(self.team == COLOR_TEAM1)
734                         // Red
735                         self.glow_color = 251;
736                 else
737                 if(self.team == COLOR_TEAM2)
738                         // Blue
739                         self.glow_color = 210;
740
741                 self.glow_size = 25;
742                 self.glow_trail = 1;
743         }
744 }
745
746 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
747 CTF flag for team one (Red).
748 Multiple are allowed.
749
750 Keys:
751 "angle"
752  Angle the flag will point
753 (minus 90 degrees)
754 "model"
755  model to use, note this needs red and blue as skins 0 and 1
756  (default models/ctf/flag.md3)
757 "noise"
758  sound played when flag is picked up
759  (default ctf/take.wav)
760 "noise1"
761  sound played when flag is returned by a teammate
762  (default ctf/return.wav)
763 "noise2"
764  sound played when flag is captured
765  (default ctf/redcapture.wav)
766 "noise3"
767  sound played when flag is lost in the field and respawns itself
768  (default ctf/respawn.wav)
769 */
770
771 void spawnfunc_item_flag_team2();
772 void spawnfunc_item_flag_team1()
773 {
774         if (!g_ctf)
775         {
776                 remove(self);
777                 return;
778         }
779
780         if (g_ctf_reverse)
781         {
782                 float old_g_ctf_reverse = g_ctf_reverse;
783                 g_ctf_reverse = 0; // avoid an endless loop
784                 spawnfunc_item_flag_team2();
785                 g_ctf_reverse = old_g_ctf_reverse;
786                 return;
787         }
788
789         // link flag into ctf_worldflaglist
790         self.ctf_worldflagnext = ctf_worldflaglist;
791         ctf_worldflaglist = self;
792
793         self.classname = "item_flag_team";
794         self.team = COLOR_TEAM1; // color 4 team (red)
795         self.items = IT_KEY2; // gold key (redish enough)
796         self.netname = "^1RED^7 flag";
797         self.target = "###item###";
798         self.skin = autocvar_g_ctf_flag_red_skin;
799         if(self.spawnflags & 1)
800                 self.noalign = 1;
801         if (!self.model)
802                 self.model = autocvar_g_ctf_flag_red_model;
803         if (!self.noise)
804                 self.noise = "ctf/red_taken.wav";
805         if (!self.noise1)
806                 self.noise1 = "ctf/red_returned.wav";
807         if (!self.noise2)
808                 self.noise2 = "ctf/red_capture.wav"; // blue team scores by capturing the red flag
809         if (!self.noise3)
810                 self.noise3 = "ctf/flag_respawn.wav";
811         if (!self.noise4)
812                 self.noise4 = "ctf/red_dropped.wav";
813         precache_model (self.model);
814         setmodel (self, self.model); // precision set below
815         precache_sound (self.noise);
816         precache_sound (self.noise1);
817         precache_sound (self.noise2);
818         precache_sound (self.noise3);
819         precache_sound (self.noise4);
820         //setsize(self, '-16 -16 -37', '16 16 37');
821         setsize(self, FLAG_MIN, FLAG_MAX);
822         setorigin(self, self.origin + '0 0 37');
823         self.nextthink = time + 0.2; // start after doors etc
824         self.think = place_flag;
825
826         if(!self.scale)
827                 self.scale = 0.6;
828         //if(!self.glow_size)
829         //      self.glow_size = 50;
830
831         self.effects = self.effects | EF_LOWPRECISION;
832         if(autocvar_g_ctf_fullbrightflags)
833                 self.effects |= EF_FULLBRIGHT;
834         if(autocvar_g_ctf_dynamiclights)
835                 self.effects |= EF_RED;
836
837         // From Spidflisk
838         item_flag_postspawn();
839
840         precache_model("models/ctf/shield.md3");
841         precache_model("models/ctf/shockwavetransring.md3");
842
843         self.reset = item_flag_reset;
844 }
845
846 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -24) (48 48 64)
847 CTF flag for team two (Blue).
848 Multiple are allowed.
849
850 Keys:
851 "angle"
852  Angle the flag will point
853 (minus 90 degrees)
854 "model"
855  model to use, note this needs red and blue as skins 0 and 1
856  (default models/ctf/flag.md3)
857 "noise"
858  sound played when flag is picked up
859  (default ctf/take.wav)
860 "noise1"
861  sound played when flag is returned by a teammate
862  (default ctf/return.wav)
863 "noise2"
864  sound played when flag is captured
865  (default ctf/bluecapture.wav)
866 "noise3"
867  sound played when flag is lost in the field and respawns itself
868  (default ctf/respawn.wav)
869 */
870
871 void spawnfunc_item_flag_team2()
872 {
873         if (!g_ctf)
874         {
875                 remove(self);
876                 return;
877         }
878
879         if (g_ctf_reverse)
880         {
881                 float old_g_ctf_reverse = g_ctf_reverse;
882                 g_ctf_reverse = 0; // avoid an endless loop
883                 spawnfunc_item_flag_team1();
884                 g_ctf_reverse = old_g_ctf_reverse;
885                 return;
886         }
887
888         // link flag into ctf_worldflaglist
889         self.ctf_worldflagnext = ctf_worldflaglist;
890         ctf_worldflaglist = self;
891
892         self.classname = "item_flag_team";
893         self.team = COLOR_TEAM2; // color 13 team (blue)
894         self.items = IT_KEY1; // silver key (bluish enough)
895         self.netname = "^4BLUE^7 flag";
896         self.target = "###item###";
897         self.skin = autocvar_g_ctf_flag_blue_skin;
898         if(self.spawnflags & 1)
899                 self.noalign = 1;
900         if (!self.model)
901                 self.model = autocvar_g_ctf_flag_blue_model;
902         if (!self.noise)
903                 self.noise = "ctf/blue_taken.wav";
904         if (!self.noise1)
905                 self.noise1 = "ctf/blue_returned.wav";
906         if (!self.noise2)
907                 self.noise2 = "ctf/blue_capture.wav"; // blue team scores by capturing the red flag
908         if (!self.noise3)
909                 self.noise3 = "ctf/flag_respawn.wav";
910         if (!self.noise4)
911                 self.noise4 = "ctf/blue_dropped.wav";
912         precache_model (self.model);
913         setmodel (self, self.model); // precision set below
914         precache_sound (self.noise);
915         precache_sound (self.noise1);
916         precache_sound (self.noise2);
917         precache_sound (self.noise3);
918         precache_sound (self.noise4);
919         //setsize(self, '-16 -16 -37', '16 16 37');
920         setsize(self, FLAG_MIN, FLAG_MAX);
921         setorigin(self, self.origin + '0 0 37');
922         self.nextthink = time + 0.2; // start after doors etc
923         self.think = place_flag;
924
925         if(!self.scale)
926                 self.scale = 0.6;
927         //if(!self.glow_size)
928         //      self.glow_size = 50;
929
930         self.effects = self.effects | EF_LOWPRECISION;
931         if(autocvar_g_ctf_fullbrightflags)
932                 self.effects |= EF_FULLBRIGHT;
933         if(autocvar_g_ctf_dynamiclights)
934                 self.effects |= EF_BLUE;
935
936         // From Spidflisk
937         item_flag_postspawn();
938
939         precache_model("models/ctf/shield.md3");
940         precache_model("models/ctf/shockwavetransring.md3");
941
942         self.reset = item_flag_reset;
943 }
944
945
946 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
947 Team declaration for CTF gameplay, this allows you to decide what team
948 names and control point models are used in your map.
949
950 Note: If you use spawnfunc_ctf_team entities you must define at least 2!  However, unlike
951 domination, you don't need to make a blank one too.
952
953 Keys:
954 "netname"
955  Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)
956 "cnt"
957  Scoreboard color of the team (for example 4 is red and 13 is blue)
958
959 */
960
961 void spawnfunc_ctf_team()
962 {
963         if (!g_ctf)
964         {
965                 remove(self);
966                 return;
967         }
968         self.classname = "ctf_team";
969         self.team = self.cnt + 1;
970 }
971
972 // code from here on is just to support maps that don't have control point and team entities
973 void ctf_spawnteam (string teamname, float teamcolor)
974 {
975         entity oldself;
976         oldself = self;
977         self = spawn();
978         self.classname = "ctf_team";
979         self.netname = teamname;
980         self.cnt = teamcolor;
981
982         spawnfunc_ctf_team();
983
984         self = oldself;
985 }
986
987 // spawn some default teams if the map is not set up for ctf
988 void ctf_spawnteams()
989 {
990         float numteams;
991
992         numteams = 2;//cvar("g_ctf_default_teams");
993
994         ctf_spawnteam("Red", COLOR_TEAM1 - 1);
995         ctf_spawnteam("Blue", COLOR_TEAM2 - 1);
996 }
997
998 void ctf_delayedinit()
999 {
1000         // if no teams are found, spawn defaults
1001         if (find(world, classname, "ctf_team") == world)
1002                 ctf_spawnteams();
1003
1004         ScoreRules_ctf();
1005 }
1006
1007 void ctf_init()
1008 {
1009         InitializeEntity(world, ctf_delayedinit, INITPRIO_GAMETYPE);
1010         flagcaptimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1011
1012         captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1013         captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1014         captureshield_force = autocvar_g_ctf_shield_force;
1015
1016
1017 //#NO AUTOCVARS START
1018         g_ctf_win_mode = cvar("g_ctf_win_mode");
1019 //#NO AUTOCVARS END
1020 }
1021
1022 void ctf_setstatus2(entity flag, float shift)
1023 {
1024         if (flag.cnt == FLAG_CARRY)
1025                 if (flag.owner == self)
1026                         self.items |= shift * 3;
1027                 else
1028                         self.items |= shift * 1;
1029         else if (flag.cnt == FLAG_DROPPED)
1030                 self.items |= shift * 2;
1031         else
1032         {
1033                 // no status bits
1034         }
1035 }
1036
1037 void ctf_setstatus()
1038 {
1039         self.items &~= IT_RED_FLAG_TAKEN;
1040         self.items &~= IT_RED_FLAG_LOST;
1041         self.items &~= IT_BLUE_FLAG_TAKEN;
1042         self.items &~= IT_BLUE_FLAG_LOST;
1043         self.items &~= IT_CTF_SHIELDED;
1044
1045         entity flag;
1046         float redflags, blueflags;
1047
1048         if(self.ctf_captureshielded)
1049                 self.items |= IT_CTF_SHIELDED;
1050
1051         redflags = 0;
1052         blueflags = 0;
1053
1054         for (flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext) if(flag.cnt != FLAG_BASE)
1055         {
1056                 if(flag.items & IT_KEY2) // blue
1057                         ++redflags;
1058                 else if(flag.items & IT_KEY1) // red
1059                         ++blueflags;
1060         }
1061
1062         // blinking magic: if there is more than one flag, show one of these in a clever way
1063         if(redflags)
1064                 redflags = mod(floor(time * redflags * 0.75), redflags);
1065         if(blueflags)
1066                 blueflags = mod(floor(time * blueflags * 0.75), blueflags);
1067
1068         for (flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext) if(flag.cnt != FLAG_BASE)
1069         {
1070                 if(flag.items & IT_KEY2) // blue
1071                 {
1072                         if(--redflags == -1) // happens exactly once (redflags is in 0..count-1, and will --'ed count times)
1073                                 ctf_setstatus2(flag, IT_RED_FLAG_TAKEN);
1074                 }
1075                 else if(flag.items & IT_KEY1) // red
1076                 {
1077                         if(--blueflags == -1) // happens exactly once
1078                                 ctf_setstatus2(flag, IT_BLUE_FLAG_TAKEN);
1079                 }
1080         }
1081 }
1082 /*
1083 entity ctf_team_has_commander(float cteam)
1084 {
1085         entity pl;
1086         if(cteam != COLOR_TEAM1 || cteam != COLOR_TEAM2)
1087                 return world;
1088
1089         FOR_EACH_REALPLAYER(pl) {
1090                 if(pl.team == cteam && pl.iscommander) {
1091                         return pl;
1092                 }
1093         }
1094         return world;
1095 }
1096
1097 void ctf_setstate(entity e, float st)
1098 {
1099         e.ctf_state = st;
1100         ++e.version;
1101 }
1102
1103 void ctf_new_commander(float cteam)
1104 {
1105         entity pl, plmax;
1106
1107         plmax = world;
1108         FOR_EACH_REALPLAYER(pl) {
1109                 if(pl.team == cteam) {
1110                         if(pl.iscommander) { // don't reassign if alreay there
1111                                 return;
1112                         }
1113                         if(plmax == world || plmax.frags < pl.frags) <<<<<<<<<<<<<<<<< BROKEN in new scoring system
1114                                 plmax = pl;
1115                 }
1116         }
1117         if(plmax == world) {
1118                 bprint(strcat(ColoredTeamName(cteam), " Team has no Commander!\n"));
1119                 return;
1120         }
1121
1122         plmax.iscommander = TRUE;
1123         ctf_setstate(plmax, 3);
1124         sprint(plmax, "^3You're the commander now!\n");
1125         centerprint(plmax, "^3You're the commander now!\n");
1126 }
1127
1128 void ctf_clientconnect()
1129 {
1130         self.iscommander = FALSE;
1131
1132         if(!self.team || self.classname != "player") {
1133                 ctf_setstate(self, -1);
1134         } else
1135                 ctf_setstate(self, 0);
1136
1137         self.team_saved = self.team;
1138
1139         if(self.team != 0 && self.classname == "player" && !ctf_team_has_commander(self.team)) {
1140                 ctf_new_commander(self.team);
1141         }
1142 }
1143
1144 void ctf_playerchanged()
1145 {
1146         if(!self.team || self.classname != "player") {
1147                 ctf_setstate(self, -1);
1148         } else if(self.ctf_state < 0 && self.classname == "player") {
1149                 ctf_setstate(self, 0);
1150         }
1151
1152         if(self.iscommander &&
1153            (self.classname != "player" || self.team != self.team_saved)
1154                 )
1155         {
1156                 self.iscommander = FALSE;
1157                 if(self.classname == "player")
1158                         ctf_setstate(self, 0);
1159                 else
1160                         ctf_setstate(self, -1);
1161                 ctf_new_commander(self.team_saved);
1162         }
1163
1164         self.team_saved = self.team;
1165
1166         ctf_new_commander(self.team);
1167 }
1168
1169 void ctf_clientdisconnect()
1170 {
1171         if(self.iscommander)
1172         {
1173                 ctf_new_commander(self.team);
1174         }
1175 }
1176
1177 entity GetPlayer(string);
1178 float ctf_clientcommand()
1179 {
1180         entity e;
1181         if(argv(0) == "order") {
1182                 if(!g_ctf) {
1183                         sprint(self, "This command is not supported in this gamemode.\n");
1184                         return TRUE;
1185                 }
1186                 if(!self.iscommander) {
1187                         sprint(self, "^1You are not the commander!\n");
1188                         return TRUE;
1189                 }
1190                 if(argv(2) == "") {
1191                         sprint(self, "Usage: order #player status   - (playernumber as in status)\n");
1192                         return TRUE;
1193                 }
1194                 e = GetPlayer(argv(1));
1195                 if(e == world) {
1196                         sprint(self, "Invalid player.\nUsage: order #player status   - (playernumber as in status)\n");
1197                         return TRUE;
1198                 }
1199                 if(e.team != self.team) {
1200                         sprint(self, "^3You can only give orders to your own team!\n");
1201                         return TRUE;
1202                 }
1203                 if(argv(2) == "attack") {
1204                         sprint(self, strcat("Ordering ", e.netname, " to attack!\n"));
1205                         sprint(e, "^1Attack!\n");
1206                         centerprint(e, "^7You've been ordered to^9\n^1Attack!\n");
1207                         ctf_setstate(e, 1);
1208                 } else if(argv(2) == "defend") {
1209                         sprint(self, strcat("Ordering ", e.netname, " to defend!\n"));
1210                         sprint(e, "^Defend!\n");
1211                         centerprint(e, "^7You've been ordered to^9\n^2Defend!\n");
1212                         ctf_setstate(e, 2);
1213                 } else {
1214                         sprint(self, "^7Invalid command, use ^3attack^7, or ^3defend^7.\n");
1215                 }
1216                 return TRUE;
1217         }
1218         return FALSE;
1219 }
1220 */