Merge branch 'master' into Lyberta/PrintMove
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / player.qc
1 #include "player.qh"
2
3 #include <common/effects/all.qh>
4 #include "bot/api.qh"
5 #include "cheats.qh"
6 #include "g_damage.qh"
7 #include "handicap.qh"
8 #include "g_subs.qh"
9 #include "miscfunctions.qh"
10 #include "portals.qh"
11 #include "teamplay.qh"
12 #include "weapons/throwing.qh"
13 #include "command/common.qh"
14 #include "../common/state.qh"
15 #include "../common/anim.qh"
16 #include "../common/animdecide.qh"
17 #include "../common/csqcmodel_settings.qh"
18 #include "../common/deathtypes/all.qh"
19 #include "../common/triggers/subs.qh"
20 #include "../common/playerstats.qh"
21 #include "../lib/csqcmodel/sv_model.qh"
22
23 #include "../common/minigames/sv_minigames.qh"
24
25 #include "../common/physics/player.qh"
26 #include "../common/effects/qc/_mod.qh"
27 #include "../common/mutators/mutator/waypoints/waypointsprites.qh"
28 #include "../common/triggers/include.qh"
29 #include "../common/wepent.qh"
30
31 #include "weapons/weaponstats.qh"
32
33 #include "../common/animdecide.qh"
34
35 void Drop_Special_Items(entity player)
36 {
37         // called when the player has become stuck or frozen
38         // so objective items aren't stuck with the player
39
40         MUTATOR_CALLHOOK(DropSpecialItems, player);
41 }
42
43 void CopyBody_Think(entity this)
44 {
45         if(this.CopyBody_nextthink && time > this.CopyBody_nextthink)
46         {
47                 this.CopyBody_think(this);
48                 if(wasfreed(this))
49                         return;
50                 this.CopyBody_nextthink = this.nextthink;
51                 this.CopyBody_think = getthink(this);
52                 setthink(this, CopyBody_Think);
53         }
54         CSQCMODEL_AUTOUPDATE(this);
55         this.nextthink = time;
56 }
57 void CopyBody(entity this, float keepvelocity)
58 {
59         if (this.effects & EF_NODRAW)
60                 return;
61         entity clone = new(body);
62         clone.enemy = this;
63         clone.lip = this.lip;
64         clone.colormap = this.colormap;
65         clone.iscreature = this.iscreature;
66         clone.teleportable = this.teleportable;
67         clone.damagedbycontents = this.damagedbycontents;
68         if(clone.damagedbycontents)
69                 IL_PUSH(g_damagedbycontents, clone);
70         clone.angles = this.angles;
71         clone.v_angle = this.v_angle;
72         clone.avelocity = this.avelocity;
73         clone.damageforcescale = this.damageforcescale;
74         clone.effects = this.effects;
75         clone.glowmod = this.glowmod;
76         clone.event_damage = this.event_damage;
77         clone.anim_state = this.anim_state;
78         clone.anim_time = this.anim_time;
79         clone.anim_lower_action = this.anim_lower_action;
80         clone.anim_lower_time = this.anim_lower_time;
81         clone.anim_upper_action = this.anim_upper_action;
82         clone.anim_upper_time = this.anim_upper_time;
83         clone.anim_implicit_state = this.anim_implicit_state;
84         clone.anim_implicit_time = this.anim_implicit_time;
85         clone.anim_lower_implicit_action = this.anim_lower_implicit_action;
86         clone.anim_lower_implicit_time = this.anim_lower_implicit_time;
87         clone.anim_upper_implicit_action = this.anim_upper_implicit_action;
88         clone.anim_upper_implicit_time = this.anim_upper_implicit_time;
89         clone.dphitcontentsmask = this.dphitcontentsmask;
90         clone.death_time = this.death_time;
91         clone.pain_finished = this.pain_finished;
92         clone.health = this.health;
93         clone.armorvalue = this.armorvalue;
94         clone.armortype = this.armortype;
95         clone.model = this.model;
96         clone.modelindex = this.modelindex;
97         clone.skin = this.skin;
98         clone.species = this.species;
99         clone.move_qcphysics = false; // don't run gamecode logic on clones, too many
100         set_movetype(clone, this.move_movetype);
101         clone.solid = this.solid;
102         clone.takedamage = this.takedamage;
103         setcefc(clone, getcefc(this));
104         clone.uncustomizeentityforclient = this.uncustomizeentityforclient;
105         clone.uncustomizeentityforclient_set = this.uncustomizeentityforclient_set;
106         if (keepvelocity == 1)
107                 clone.velocity = this.velocity;
108         clone.oldvelocity = clone.velocity;
109         clone.alpha = this.alpha;
110         clone.fade_time = this.fade_time;
111         clone.fade_rate = this.fade_rate;
112         //clone.weapon = this.weapon;
113         setorigin(clone, this.origin);
114         setsize(clone, this.mins, this.maxs);
115         clone.reset = SUB_Remove;
116         clone._ps = this._ps;
117
118         Drag_MoveDrag(this, clone);
119
120         if(clone.colormap <= maxclients && clone.colormap > 0)
121                 clone.colormap = 1024 + this.clientcolors;
122
123         CSQCMODEL_AUTOINIT(clone);
124         clone.CopyBody_nextthink = this.nextthink;
125         clone.CopyBody_think = getthink(this);
126         clone.nextthink = time;
127         setthink(clone, CopyBody_Think);
128         // "bake" the current animation frame for clones (they don't get clientside animation)
129         animdecide_load_if_needed(clone);
130         animdecide_setframes(clone, false, frame, frame1time, frame2, frame2time);
131
132         IL_PUSH(g_clones, clone);
133
134         MUTATOR_CALLHOOK(CopyBody, this, clone, keepvelocity);
135 }
136
137 void player_setupanimsformodel(entity this)
138 {
139         // load animation info
140         animdecide_load_if_needed(this);
141         animdecide_setstate(this, 0, false);
142 }
143
144 void player_anim(entity this)
145 {
146         int deadbits = (this.anim_state & (ANIMSTATE_DEAD1 | ANIMSTATE_DEAD2));
147         if(IS_DEAD(this)) {
148                 if (!deadbits) {
149                         // Decide on which death animation to use.
150                         if(random() < 0.5)
151                                 deadbits = ANIMSTATE_DEAD1;
152                         else
153                                 deadbits = ANIMSTATE_DEAD2;
154                 }
155         } else {
156                 // Clear a previous death animation.
157                 deadbits = 0;
158         }
159         int animbits = deadbits;
160         if(STAT(FROZEN, this))
161                 animbits |= ANIMSTATE_FROZEN;
162         if(this.move_movetype == MOVETYPE_FOLLOW)
163                 animbits |= ANIMSTATE_FOLLOW;
164         if(this.crouch)
165                 animbits |= ANIMSTATE_DUCK;
166         animdecide_setstate(this, animbits, false);
167         animdecide_setimplicitstate(this, IS_ONGROUND(this));
168 }
169
170 void PlayerCorpseDamage(entity this, entity inflictor, entity attacker, float damage, int deathtype, .entity weaponentity, vector hitloc, vector force)
171 {
172         float take, save;
173         vector v;
174         Violence_GibSplash_At(hitloc, force, 2, bound(0, damage, 200) / 16, this, attacker);
175
176         v = healtharmor_applydamage(this.armorvalue, autocvar_g_balance_armor_blockpercent, deathtype, damage);
177         take = v.x;
178         save = v.y;
179
180         if(sound_allowed(MSG_BROADCAST, attacker))
181         {
182                 if (save > 10)
183                         sound (this, CH_SHOTS, SND_ARMORIMPACT, VOL_BASE, ATTEN_NORM);
184                 else if (take > 30)
185                         sound (this, CH_SHOTS, SND_BODYIMPACT2, VOL_BASE, ATTEN_NORM);
186                 else if (take > 10)
187                         sound (this, CH_SHOTS, SND_BODYIMPACT1, VOL_BASE, ATTEN_NORM);
188         }
189
190         if (take > 50)
191                 Violence_GibSplash_At(hitloc, force * -0.1, 3, 1, this, attacker);
192         if (take > 100)
193                 Violence_GibSplash_At(hitloc, force * -0.2, 3, 1, this, attacker);
194
195         this.armorvalue = this.armorvalue - save;
196         this.health = this.health - take;
197         // pause regeneration for 5 seconds
198         this.pauseregen_finished = max(this.pauseregen_finished, time + autocvar_g_balance_pause_health_regen);
199
200         this.dmg_save = this.dmg_save + save;//max(save - 10, 0);
201         this.dmg_take = this.dmg_take + take;//max(take - 10, 0);
202         this.dmg_inflictor = inflictor;
203
204         if (this.health <= -autocvar_sv_gibhealth && this.alpha >= 0)
205         {
206                 // don't use any animations as a gib
207                 this.frame = 0;
208                 // view just above the floor
209                 this.view_ofs = '0 0 4';
210
211                 Violence_GibSplash(this, 1, 1, attacker);
212                 this.alpha = -1;
213                 this.solid = SOLID_NOT; // restore later
214                 this.takedamage = DAMAGE_NO; // restore later
215                 if(this.damagedbycontents)
216                         IL_REMOVE(g_damagedbycontents, this);
217                 this.damagedbycontents = false;
218         }
219 }
220
221 void calculate_player_respawn_time(entity this)
222 {
223         if(MUTATOR_CALLHOOK(CalculateRespawnTime, this))
224                 return;
225
226         float gametype_setting_tmp;
227         float sdelay_max = GAMETYPE_DEFAULTED_SETTING(respawn_delay_max);
228         float sdelay_small = GAMETYPE_DEFAULTED_SETTING(respawn_delay_small);
229         float sdelay_large = GAMETYPE_DEFAULTED_SETTING(respawn_delay_large);
230         float sdelay_small_count = GAMETYPE_DEFAULTED_SETTING(respawn_delay_small_count);
231         float sdelay_large_count = GAMETYPE_DEFAULTED_SETTING(respawn_delay_large_count);
232         float waves = GAMETYPE_DEFAULTED_SETTING(respawn_waves);
233
234         float pcount = 1;  // Include myself whether or not team is already set right and I'm a "player".
235         if (teamplay)
236         {
237                 FOREACH_CLIENT(IS_PLAYER(it) && it != this, {
238                         if(it.team == this.team)
239                                 ++pcount;
240                 });
241                 if (sdelay_small_count == 0)
242                         sdelay_small_count = 1;
243                 if (sdelay_large_count == 0)
244                         sdelay_large_count = 1;
245         }
246         else
247         {
248                 FOREACH_CLIENT(IS_PLAYER(it) && it != this, {
249                         ++pcount;
250                 });
251                 if (sdelay_small_count == 0)
252                 {
253                         if (IS_INDEPENDENT_PLAYER(this))
254                         {
255                                 // Players play independently. No point in requiring enemies.
256                                 sdelay_small_count = 1;
257                         }
258                         else
259                         {
260                                 // Players play AGAINST each other. Enemies required.
261                                 sdelay_small_count = 2;
262                         }
263                 }
264                 if (sdelay_large_count == 0)
265                 {
266                         if (IS_INDEPENDENT_PLAYER(this))
267                         {
268                                 // Players play independently. No point in requiring enemies.
269                                 sdelay_large_count = 1;
270                         }
271                         else
272                         {
273                                 // Players play AGAINST each other. Enemies required.
274                                 sdelay_large_count = 2;
275                         }
276                 }
277         }
278
279         float sdelay;
280
281         if (pcount <= sdelay_small_count)
282                 sdelay = sdelay_small;
283         else if (pcount >= sdelay_large_count)
284                 sdelay = sdelay_large;
285         else  // NOTE: this case implies sdelay_large_count > sdelay_small_count.
286                 sdelay = sdelay_small + (sdelay_large - sdelay_small) * (pcount - sdelay_small_count) / (sdelay_large_count - sdelay_small_count);
287
288         if(waves)
289                 this.respawn_time = ceil((time + sdelay) / waves) * waves;
290         else
291                 this.respawn_time = time + sdelay;
292
293         if(sdelay < sdelay_max)
294                 this.respawn_time_max = time + sdelay_max;
295         else
296                 this.respawn_time_max = this.respawn_time;
297
298         if((sdelay + waves >= 5.0) && (this.respawn_time - time > 1.75))
299                 this.respawn_countdown = 10; // first number to count down from is 10
300         else
301                 this.respawn_countdown = -1; // do not count down
302
303         if(autocvar_g_forced_respawn)
304                 this.respawn_flags = this.respawn_flags | RESPAWN_FORCE;
305 }
306
307 void PlayerDamage(entity this, entity inflictor, entity attacker, float damage, int deathtype, .entity weaponentity, vector hitloc, vector force)
308 {
309         float take, save, dh, da;
310         vector v;
311         float excess;
312
313         dh = max(this.health, 0);
314         da = max(this.armorvalue, 0);
315
316         if(!DEATH_ISSPECIAL(deathtype))
317         {
318                 damage *= Handicap_GetTotalHandicap(this);
319                 if (this != attacker && IS_PLAYER(attacker))
320                 {
321                         damage /= Handicap_GetTotalHandicap(attacker);
322                 }
323         }
324
325         if (time < this.spawnshieldtime && autocvar_g_spawnshield_blockdamage < 1)
326                 damage *= 1 - max(0, autocvar_g_spawnshield_blockdamage);
327
328         if(DEATH_ISWEAPON(deathtype, WEP_TUBA))
329         {
330                 // tuba causes blood to come out of the ears
331                 vector ear1, ear2;
332                 vector d;
333                 float f;
334                 ear1 = this.origin;
335                 ear1_z += 0.125 * this.view_ofs.z + 0.875 * this.maxs.z; // 7/8
336                 ear2 = ear1;
337                 makevectors(this.angles);
338                 ear1 += v_right * -10;
339                 ear2 += v_right * +10;
340                 d = inflictor.origin - this.origin;
341                 if (d)
342                         f = (d * v_right) / vlen(d); // this is cos of angle of d and v_right!
343                 else
344                         f = 0;  // Assum ecenter.
345                 force = v_right * vlen(force);
346                 Violence_GibSplash_At(ear1, force * -1, 2, bound(0, damage, 25) / 2 * (0.5 - 0.5 * f), this, attacker);
347                 Violence_GibSplash_At(ear2, force,      2, bound(0, damage, 25) / 2 * (0.5 + 0.5 * f), this, attacker);
348                 if(f > 0)
349                 {
350                         hitloc = ear1;
351                         force = force * -1;
352                 }
353                 else
354                 {
355                         hitloc = ear2;
356                         // force is already good
357                 }
358         }
359         else
360                 Violence_GibSplash_At(hitloc, force, 2, bound(0, damage, 200) / 16, this, attacker);
361
362         v = healtharmor_applydamage(this.armorvalue, autocvar_g_balance_armor_blockpercent, deathtype, damage);
363         take = v.x;
364         save = v.y;
365
366         if(attacker == this)
367         {
368                 // don't reset pushltime for this damage as it may be an attempt to
369                 // escape a lava pit or similar
370                 //this.pushltime = 0;
371                 this.istypefrag = 0;
372         }
373         else if(IS_PLAYER(attacker))
374         {
375                 this.pusher = attacker;
376                 this.pushltime = time + autocvar_g_maxpushtime;
377                 this.istypefrag = PHYS_INPUT_BUTTON_CHAT(this);
378         }
379         else if(time < this.pushltime)
380         {
381                 attacker = this.pusher;
382                 this.pushltime = max(this.pushltime, time + 0.6);
383         }
384         else
385         {
386                 this.pushltime = 0;
387                 this.istypefrag = 0;
388         }
389
390         MUTATOR_CALLHOOK(PlayerDamage_SplitHealthArmor, inflictor, attacker, this, force, take, save, deathtype, damage);
391         take = bound(0, M_ARGV(4, float), this.health);
392         save = bound(0, M_ARGV(5, float), this.armorvalue);
393         excess = max(0, damage - take - save);
394
395         if(sound_allowed(MSG_BROADCAST, attacker))
396         {
397                 if (save > 10)
398                         sound (this, CH_SHOTS, SND_ARMORIMPACT, VOL_BASE, ATTEN_NORM);
399                 else if (take > 30)
400                         sound (this, CH_SHOTS, SND_BODYIMPACT2, VOL_BASE, ATTEN_NORM);
401                 else if (take > 10)
402                         sound (this, CH_SHOTS, SND_BODYIMPACT1, VOL_BASE, ATTEN_NORM); // FIXME possibly remove them?
403         }
404
405         if (take > 50)
406                 Violence_GibSplash_At(hitloc, force * -0.1, 3, 1, this, attacker);
407         if (take > 100)
408                 Violence_GibSplash_At(hitloc, force * -0.2, 3, 1, this, attacker);
409
410         if (time >= this.spawnshieldtime || autocvar_g_spawnshield_blockdamage < 1)
411         {
412                 if (!(this.flags & FL_GODMODE))
413                 {
414                         this.armorvalue = this.armorvalue - save;
415                         this.health = this.health - take;
416                         // pause regeneration for 5 seconds
417                         if(take)
418                                 this.pauseregen_finished = max(this.pauseregen_finished, time + autocvar_g_balance_pause_health_regen);
419
420                         if (time > this.pain_finished)          //Don't switch pain sequences like crazy
421                         {
422                                 this.pain_finished = time + 0.5;        //Supajoe
423
424                                 if(autocvar_sv_gentle < 1) {
425                                         if(this.classname != "body") // pain anim is BORKED on our ZYMs, FIXME remove this once we have good models
426                                         {
427                                                 if (!this.animstate_override)
428                                                 {
429                                                         if (random() > 0.5)
430                                                                 animdecide_setaction(this, ANIMACTION_PAIN1, true);
431                                                         else
432                                                                 animdecide_setaction(this, ANIMACTION_PAIN2, true);
433                                                 }
434                                         }
435
436                                         if(sound_allowed(MSG_BROADCAST, attacker))
437                                         if(this.health < 25 || !(DEATH_WEAPONOF(deathtype).spawnflags & WEP_FLAG_CANCLIMB) || take > 20 || attacker != this)
438                                         if(this.health > 1)
439                                         // exclude pain sounds for laserjumps as long as you aren't REALLY low on health and would die of the next two
440                                         {
441                                                 if(deathtype == DEATH_FALL.m_id)
442                                                         PlayerSound(this, playersound_fall, CH_PAIN, VOL_BASE, VOICETYPE_PLAYERSOUND);
443                                                 else if(this.health > 75)
444                                                         PlayerSound(this, playersound_pain100, CH_PAIN, VOL_BASE, VOICETYPE_PLAYERSOUND);
445                                                 else if(this.health > 50)
446                                                         PlayerSound(this, playersound_pain75, CH_PAIN, VOL_BASE, VOICETYPE_PLAYERSOUND);
447                                                 else if(this.health > 25)
448                                                         PlayerSound(this, playersound_pain50, CH_PAIN, VOL_BASE, VOICETYPE_PLAYERSOUND);
449                                                 else
450                                                         PlayerSound(this, playersound_pain25, CH_PAIN, VOL_BASE, VOICETYPE_PLAYERSOUND);
451                                         }
452                                 }
453                         }
454
455                         // throw off bot aim temporarily
456                         float shake;
457                         if(IS_BOT_CLIENT(this) && this.health >= 1)
458                         {
459                                 shake = damage * 5 / (bound(0,skill,100) + 1);
460                                 this.v_angle_x = this.v_angle.x + (random() * 2 - 1) * shake;
461                                 this.v_angle_y = this.v_angle.y + (random() * 2 - 1) * shake;
462                                 this.v_angle_x = bound(-90, this.v_angle.x, 90);
463                         }
464                 }
465                 else
466                         this.max_armorvalue += (save + take);
467         }
468         this.dmg_save = this.dmg_save + save;//max(save - 10, 0);
469         this.dmg_take = this.dmg_take + take;//max(take - 10, 0);
470         this.dmg_inflictor = inflictor;
471
472         if (this != attacker) {
473                 float realdmg = damage - excess;
474                 if (IS_PLAYER(attacker)) {
475                         GameRules_scoring_add(attacker, DMG, realdmg);
476                 }
477                 if (IS_PLAYER(this)) {
478                         GameRules_scoring_add(this, DMGTAKEN, realdmg);
479                 }
480         }
481
482         bool abot = (IS_BOT_CLIENT(attacker));
483         bool vbot = (IS_BOT_CLIENT(this));
484
485         bool valid_damage_for_weaponstats = false;
486         Weapon awep = WEP_Null;
487
488         if(vbot || IS_REAL_CLIENT(this))
489         if(abot || IS_REAL_CLIENT(attacker))
490         if(attacker && this != attacker)
491         if(DIFF_TEAM(this, attacker))
492         {
493                 if(DEATH_ISSPECIAL(deathtype))
494                         awep = attacker.(weaponentity).m_weapon;
495                 else
496                         awep = DEATH_WEAPONOF(deathtype);
497                 valid_damage_for_weaponstats = true;
498         }
499
500         dh = dh - max(this.health, 0);
501         da = da - max(this.armorvalue, 0);
502         if(valid_damage_for_weaponstats)
503         {
504                 WeaponStats_LogDamage(awep.m_id, abot, this.(weaponentity).m_weapon.m_id, vbot, dh + da);
505         }
506
507         MUTATOR_CALLHOOK(PlayerDamaged, attacker, this, dh, da, hitloc, deathtype, damage);
508
509         if (this.health < 1)
510         {
511                 float defer_ClientKill_Now_TeamChange;
512                 defer_ClientKill_Now_TeamChange = false;
513
514                 if(this.alivetime)
515                 {
516                         PlayerStats_GameReport_Event_Player(this, PLAYERSTATS_ALIVETIME, time - this.alivetime);
517                         this.alivetime = 0;
518                 }
519
520                 if(valid_damage_for_weaponstats)
521                         WeaponStats_LogKill(awep.m_id, abot, this.(weaponentity).m_weapon.m_id, vbot);
522
523                 if(autocvar_sv_gentle < 1)
524                 if(sound_allowed(MSG_BROADCAST, attacker))
525                 {
526                         if(deathtype == DEATH_DROWN.m_id)
527                                 PlayerSound(this, playersound_drown, CH_PAIN, VOL_BASE, VOICETYPE_PLAYERSOUND);
528                         else
529                                 PlayerSound(this, playersound_death, CH_PAIN, VOL_BASE, VOICETYPE_PLAYERSOUND);
530                 }
531
532                 // get rid of kill indicator
533                 if(this.killindicator)
534                 {
535                         delete(this.killindicator);
536                         this.killindicator = NULL;
537                         if(this.killindicator_teamchange)
538                                 defer_ClientKill_Now_TeamChange = true;
539
540                         if(this.classname == "body")
541                         if(deathtype == DEATH_KILL.m_id)
542                         {
543                                 // for the lemmings fans, a small harmless explosion
544                                 Send_Effect(EFFECT_ROCKET_EXPLODE, this.origin, '0 0 0', 1);
545                         }
546                 }
547
548                 // print an obituary message
549                 if(this.classname != "body")
550                         Obituary (attacker, inflictor, this, deathtype, weaponentity);
551
552         // increment frag counter for used weapon type
553         Weapon w = DEATH_WEAPONOF(deathtype);
554                 if(w != WEP_Null && accuracy_isgooddamage(attacker, this))
555                         CS(attacker).accuracy.(accuracy_frags[w.m_id-1]) += 1;
556
557                 this.respawn_time = 0;
558                 MUTATOR_CALLHOOK(PlayerDies, inflictor, attacker, this, deathtype, damage);
559                 damage = M_ARGV(4, float);
560                 excess = max(0, damage - take - save);
561
562                 //Weapon wep = this.(weaponentity).m_weapon;
563                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
564                 {
565                         .entity went = weaponentities[slot];
566                         if(!this.(went))
567                                 continue; // TODO: clones have no weapon, but we don't want to have to check this all the time
568                         Weapon wep = this.(went).m_weapon;
569                         wep.wr_playerdeath(wep, this, went);
570                 }
571
572                 RemoveGrapplingHooks(this);
573
574                 Portal_ClearAllLater(this);
575
576                 this.fixangle = true;
577
578                 if(defer_ClientKill_Now_TeamChange)
579                         ClientKill_Now_TeamChange(this); // can turn player into spectator
580
581                 // player could have been miraculously resuscitated ;)
582                 // e.g. players in freezetag get frozen, they don't really die
583                 if(this.health >= 1 || !(IS_PLAYER(this) || this.classname == "body"))
584                         return;
585
586                 if (!this.respawn_time) // can be set in the mutator hook PlayerDies
587                         calculate_player_respawn_time(this);
588
589                 // when we get here, player actually dies
590
591                 Unfreeze(this); // remove any icy remains
592                 this.health = 0; // Unfreeze resets health, so we need to set it back
593
594                 // clear waypoints
595                 WaypointSprite_PlayerDead(this);
596                 // throw a weapon
597                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
598                 {
599                         .entity went = weaponentities[slot];
600                         SpawnThrownWeapon(this, this.origin + (this.mins + this.maxs) * 0.5, this.(went).m_weapon, went);
601                 }
602
603                 // become fully visible
604                 this.alpha = default_player_alpha;
605                 // make the corpse upright (not tilted)
606                 this.angles_x = 0;
607                 this.angles_z = 0;
608                 // don't spin
609                 this.avelocity = '0 0 0';
610                 // view from the floor
611                 this.view_ofs = '0 0 -8';
612                 // toss the corpse
613                 set_movetype(this, MOVETYPE_TOSS);
614                 // shootable corpse
615                 this.solid = SOLID_CORPSE;
616                 PS(this).ballistics_density = autocvar_g_ballistics_density_corpse;
617                 // don't stick to the floor
618                 UNSET_ONGROUND(this);
619                 // dying animation
620                 this.deadflag = DEAD_DYING;
621
622                 STAT(MOVEVARS_SPECIALCOMMAND, this) = false; // sweet release
623
624                 this.death_time = time;
625                 if (random() < 0.5)
626                         animdecide_setstate(this, this.anim_state | ANIMSTATE_DEAD1, true);
627                 else
628                         animdecide_setstate(this, this.anim_state | ANIMSTATE_DEAD2, true);
629
630                 // set damage function to corpse damage
631                 this.event_damage = PlayerCorpseDamage;
632                 // call the corpse damage function just in case it wants to gib
633                 this.event_damage(this, inflictor, attacker, excess, deathtype, weaponentity, hitloc, force);
634
635                 // set up to fade out later
636                 SUB_SetFade (this, time + 6 + random (), 1);
637                 // reset body think wrapper broken by SUB_SetFade
638                 if(this.classname == "body" && getthink(this) != CopyBody_Think) {
639                         this.CopyBody_think = getthink(this);
640                         this.CopyBody_nextthink = this.nextthink;
641                         setthink(this, CopyBody_Think);
642                         this.nextthink = time;
643                 }
644
645                 if(autocvar_sv_gentle > 0 || autocvar_ekg || this.classname == "body") {
646                         // remove corpse
647                         // clones don't run any animation code any more, so we must gib them when they die :(
648                         this.event_damage(this, inflictor, attacker, autocvar_sv_gibhealth + 1, deathtype, weaponentity, hitloc, force);
649                 }
650
651                 // reset fields the weapons may use just in case
652                 if(this.classname != "body")
653                 {
654                         FOREACH(Weapons, it != WEP_Null,
655                         {
656                                 it.wr_resetplayer(it, this);
657                                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
658                                 {
659                                         ATTACK_FINISHED_FOR(this, it.m_id, slot) = 0;
660                                 }
661                         });
662                 }
663                 MUTATOR_CALLHOOK(PlayerDied, this);
664         }
665 }
666
667 bool MoveToTeam(entity client, int team_colour, int type)
668 {
669         int lockteams_backup = lockteams;  // backup any team lock
670         lockteams = 0;  // disable locked teams
671         TeamchangeFrags(client);  // move the players frags
672         if (!SetPlayerTeamSimple(client, team_colour))
673         {
674                 return false;
675         }
676         Damage(client, client, client, 100000, DEATH_AUTOTEAMCHANGE.m_id, DMG_NOWEP, client.origin, '0 0 0');  // kill the player
677         lockteams = lockteams_backup;  // restore the team lock
678         LogTeamchange(client.playerid, client.team, type);
679         return true;
680 }
681
682 /**
683  * message "": do not say, just test flood control
684  * return value:
685  *   1 = accept
686  *   0 = reject
687  *  -1 = fake accept
688  */
689 int Say(entity source, int teamsay, entity privatesay, string msgin, bool floodcontrol)
690 {
691         if (!teamsay && !privatesay && substring(msgin, 0, 1) == " ")
692         msgin = substring(msgin, 1, -1); // work around DP say bug (say_team does not have this!)
693
694     if(source)
695                 msgin = formatmessage(source, msgin);
696
697     string colorstr;
698         if (!IS_PLAYER(source))
699                 colorstr = "^0"; // black for spectators
700         else if(teamplay)
701                 colorstr = Team_ColorCode(source.team);
702         else
703         {
704                 colorstr = "";
705                 teamsay = false;
706         }
707
708         if(game_stopped)
709                 teamsay = false;
710
711     if (!source) {
712                 colorstr = "";
713                 teamsay = false;
714     }
715
716         if(msgin != "")
717                 msgin = trigger_magicear_processmessage_forallears(source, teamsay, privatesay, msgin);
718
719         /*
720          * using bprint solves this... me stupid
721         // how can we prevent the message from appearing in a listen server?
722         // for now, just give "say" back and only handle say_team
723         if(!teamsay)
724         {
725                 clientcommand(source, strcat("say ", msgin));
726                 return;
727         }
728         */
729
730     string namestr = "";
731     if (source)
732         namestr = playername(source, autocvar_g_chat_teamcolors);
733
734     string colorprefix = (strdecolorize(namestr) == namestr) ? "^3" : "^7";
735
736     string msgstr, cmsgstr;
737     string privatemsgprefix = string_null;
738     int privatemsgprefixlen = 0;
739         if (msgin == "") {
740         msgstr = cmsgstr = "";
741         } else {
742                 if(privatesay)
743                 {
744                         msgstr = strcat("\{1}\{13}* ", colorprefix, namestr, "^3 tells you: ^7");
745                         privatemsgprefixlen = strlen(msgstr);
746                         msgstr = strcat(msgstr, msgin);
747                         cmsgstr = strcat(colorstr, colorprefix, namestr, "^3 tells you:\n^7", msgin);
748                         privatemsgprefix = strcat("\{1}\{13}* ^3You tell ", playername(privatesay, autocvar_g_chat_teamcolors), ": ^7");
749                 }
750                 else if(teamsay)
751                 {
752                         if(strstrofs(msgin, "/me", 0) >= 0)
753                         {
754                                 //msgin = strreplace("/me", "", msgin);
755                                 //msgin = substring(msgin, 3, strlen(msgin));
756                                 msgin = strreplace("/me", strcat(colorstr, "(", colorprefix, namestr, colorstr, ")^7"), msgin);
757                                 msgstr = strcat("\{1}\{13}^4* ", "^7", msgin);
758                         }
759                         else
760                                 msgstr = strcat("\{1}\{13}", colorstr, "(", colorprefix, namestr, colorstr, ") ^7", msgin);
761                         cmsgstr = strcat(colorstr, "(", colorprefix, namestr, colorstr, ")\n^7", msgin);
762                 }
763                 else
764                 {
765                         if(strstrofs(msgin, "/me", 0) >= 0)
766                         {
767                                 //msgin = strreplace("/me", "", msgin);
768                                 //msgin = substring(msgin, 3, strlen(msgin));
769                                 msgin = strreplace("/me", strcat(colorprefix, namestr), msgin);
770                                 msgstr = strcat("\{1}^4* ", "^7", msgin);
771                         }
772                         else {
773                 msgstr = "\{1}";
774                 msgstr = strcat(msgstr, (namestr != "") ? strcat(colorprefix, namestr, "^7: ") : "^7");
775                 msgstr = strcat(msgstr, msgin);
776             }
777                         cmsgstr = "";
778                 }
779                 msgstr = strcat(strreplace("\n", " ", msgstr), "\n"); // newlines only are good for centerprint
780         }
781
782         string fullmsgstr = msgstr;
783         string fullcmsgstr = cmsgstr;
784
785         // FLOOD CONTROL
786         int flood = 0;
787         var .float flood_field = floodcontrol_chat;
788         if(floodcontrol && source)
789         {
790                 float flood_spl;
791                 float flood_burst;
792                 float flood_lmax;
793                 float lines;
794                 if(privatesay)
795                 {
796                         flood_spl = autocvar_g_chat_flood_spl_tell;
797                         flood_burst = autocvar_g_chat_flood_burst_tell;
798                         flood_lmax = autocvar_g_chat_flood_lmax_tell;
799                         flood_field = floodcontrol_chattell;
800                 }
801                 else if(teamsay)
802                 {
803                         flood_spl = autocvar_g_chat_flood_spl_team;
804                         flood_burst = autocvar_g_chat_flood_burst_team;
805                         flood_lmax = autocvar_g_chat_flood_lmax_team;
806                         flood_field = floodcontrol_chatteam;
807                 }
808                 else
809                 {
810                         flood_spl = autocvar_g_chat_flood_spl;
811                         flood_burst = autocvar_g_chat_flood_burst;
812                         flood_lmax = autocvar_g_chat_flood_lmax;
813                         flood_field = floodcontrol_chat;
814                 }
815                 flood_burst = max(0, flood_burst - 1);
816                 // to match explanation in default.cfg, a value of 3 must allow three-line bursts and not four!
817
818                 // do flood control for the default line size
819                 if(msgstr != "")
820                 {
821                         getWrappedLine_remaining = msgstr;
822                         msgstr = "";
823                         lines = 0;
824                         while(getWrappedLine_remaining && (!flood_lmax || lines <= flood_lmax))
825                         {
826                                 msgstr = strcat(msgstr, " ", getWrappedLineLen(82.4289758859709, strlennocol)); // perl averagewidth.pl < gfx/vera-sans.width
827                                 ++lines;
828                         }
829                         msgstr = substring(msgstr, 1, strlen(msgstr) - 1);
830
831                         if(getWrappedLine_remaining != "")
832                         {
833                                 msgstr = strcat(msgstr, "\n");
834                                 flood = 2;
835                         }
836
837                         if (time >= source.(flood_field))
838                         {
839                                 source.(flood_field) = max(time - flood_burst * flood_spl, source.(flood_field)) + lines * flood_spl;
840                         }
841                         else
842                         {
843                                 flood = 1;
844                                 msgstr = fullmsgstr;
845                         }
846                 }
847                 else
848                 {
849                         if (time >= source.(flood_field))
850                                 source.(flood_field) = max(time - flood_burst * flood_spl, source.(flood_field)) + flood_spl;
851                         else
852                                 flood = 1;
853                 }
854
855                 if (timeout_status == TIMEOUT_ACTIVE) // when game is paused, no flood protection
856                         source.(flood_field) = flood = 0;
857         }
858
859     string sourcemsgstr, sourcecmsgstr;
860         if(flood == 2) // cannot happen for empty msgstr
861         {
862                 if(autocvar_g_chat_flood_notify_flooder)
863                 {
864                         sourcemsgstr = strcat(msgstr, "\n^3FLOOD CONTROL: ^7message too long, trimmed\n");
865                         sourcecmsgstr = "";
866                 }
867                 else
868                 {
869                         sourcemsgstr = fullmsgstr;
870                         sourcecmsgstr = fullcmsgstr;
871                 }
872                 cmsgstr = "";
873         }
874         else
875         {
876                 sourcemsgstr = msgstr;
877                 sourcecmsgstr = cmsgstr;
878         }
879
880         if (!privatesay && source && !IS_PLAYER(source))
881         {
882                 if (!game_stopped)
883                 if (teamsay || (autocvar_g_chat_nospectators == 1) || (autocvar_g_chat_nospectators == 2 && !warmup_stage))
884                         teamsay = -1; // spectators
885         }
886
887         if(flood)
888                 LOG_INFO("NOTE: ", playername(source, true), "^7 is flooding.");
889
890         // build sourcemsgstr by cutting off a prefix and replacing it by the other one
891         if(privatesay)
892                 sourcemsgstr = strcat(privatemsgprefix, substring(sourcemsgstr, privatemsgprefixlen, -1));
893
894     int ret;
895         if(source && CS(source).muted)
896         {
897                 // always fake the message
898                 ret = -1;
899         }
900         else if(flood == 1)
901         {
902                 if (autocvar_g_chat_flood_notify_flooder)
903                 {
904                         sprint(source, strcat("^3FLOOD CONTROL: ^7wait ^1", ftos(source.(flood_field) - time), "^3 seconds\n"));
905                         ret = 0;
906                 }
907                 else
908                         ret = -1;
909         }
910         else
911         {
912                 ret = 1;
913         }
914
915         if (privatesay && source && !IS_PLAYER(source))
916         {
917                 if (!game_stopped)
918                 if ((privatesay && IS_PLAYER(privatesay)) && ((autocvar_g_chat_nospectators == 1) || (autocvar_g_chat_nospectators == 2 && !warmup_stage)))
919                         ret = -1; // just hide the message completely
920         }
921
922         MUTATOR_CALLHOOK(ChatMessage, source, ret);
923         ret = M_ARGV(1, int);
924
925         if(sourcemsgstr != "" && ret != 0)
926         {
927                 if(ret < 0) // faked message, because the player is muted
928                 {
929                         sprint(source, sourcemsgstr);
930                         if(sourcecmsgstr != "" && !privatesay)
931                                 centerprint(source, sourcecmsgstr);
932                 }
933                 else if(privatesay) // private message, between 2 people only
934                 {
935                         sprint(source, sourcemsgstr);
936                         if (!autocvar_g_chat_tellprivacy) { dedicated_print(msgstr); } // send to server console too if "tellprivacy" is disabled
937                         if(!MUTATOR_CALLHOOK(ChatMessageTo, privatesay, source))
938                         {
939                                 sprint(privatesay, msgstr);
940                                 if(cmsgstr != "")
941                                         centerprint(privatesay, cmsgstr);
942                         }
943                 }
944                 else if ( teamsay && CS(source).active_minigame )
945                 {
946                         sprint(source, sourcemsgstr);
947                         dedicated_print(msgstr); // send to server console too
948                         FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != source && CS(it).active_minigame == CS(source).active_minigame && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), sprint(it, msgstr));
949                 }
950                 else if(teamsay > 0) // team message, only sent to team mates
951                 {
952                         sprint(source, sourcemsgstr);
953                         dedicated_print(msgstr); // send to server console too
954                         if(sourcecmsgstr != "")
955                                 centerprint(source, sourcecmsgstr);
956                         FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it) && it != source && it.team == source.team && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), {
957                                 sprint(it, msgstr);
958                                 if(cmsgstr != "")
959                                         centerprint(it, cmsgstr);
960                         });
961                 }
962                 else if(teamsay < 0) // spectator message, only sent to spectators
963                 {
964                         sprint(source, sourcemsgstr);
965                         dedicated_print(msgstr); // send to server console too
966                         FOREACH_CLIENT(!IS_PLAYER(it) && IS_REAL_CLIENT(it) && it != source && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), sprint(it, msgstr));
967                 }
968                 else
969                 {
970             if (source) {
971                 sprint(source, sourcemsgstr);
972                 dedicated_print(msgstr); // send to server console too
973                 MX_Say(strcat(playername(source, true), "^7: ", msgin));
974             }
975             FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != source && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), sprint(it, msgstr));
976         }
977         }
978
979         return ret;
980 }