Merge branch 'master' into Lyberta/TeamplayOverhaul
[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 /** print(), but only print if the server is not local */
668 void dedicated_print(string input)
669 {
670         if (server_is_dedicated) print(input);
671 }
672
673 void PrintToChat(entity player, string text)
674 {
675         text = strcat("\{1}^7", text, "\n");
676         sprint(player, text);
677 }
678
679 void DebugPrintToChat(entity player, string text)
680 {
681         if (autocvar_developer)
682         {
683                 PrintToChat(player, text);
684         }
685 }
686
687 void PrintToChatAll(string text)
688 {
689         text = strcat("\{1}^7", text, "\n");
690         bprint(text);
691 }
692
693 void DebugPrintToChatAll(string text)
694 {
695         if (autocvar_developer)
696         {
697                 PrintToChatAll(text);
698         }
699 }
700
701 void PrintToChatTeam(int teamnum, string text)
702 {
703         text = strcat("\{1}^7", text, "\n");
704         FOREACH_CLIENT(IS_REAL_CLIENT(it),
705         {
706                 if (it.team == teamnum)
707                 {
708                         sprint(it, text);
709                 }
710         });
711 }
712
713 void DebugPrintToChatTeam(int teamnum, string text)
714 {
715         if (autocvar_developer)
716         {
717                 PrintToChatTeam(teamnum, text);
718         }
719 }
720
721 /**
722  * message "": do not say, just test flood control
723  * return value:
724  *   1 = accept
725  *   0 = reject
726  *  -1 = fake accept
727  */
728 int Say(entity source, int teamsay, entity privatesay, string msgin, bool floodcontrol)
729 {
730         if (!teamsay && !privatesay && substring(msgin, 0, 1) == " ")
731         msgin = substring(msgin, 1, -1); // work around DP say bug (say_team does not have this!)
732
733     if(source)
734                 msgin = formatmessage(source, msgin);
735
736     string colorstr;
737         if (!IS_PLAYER(source))
738                 colorstr = "^0"; // black for spectators
739         else if(teamplay)
740                 colorstr = Team_ColorCode(source.team);
741         else
742         {
743                 colorstr = "";
744                 teamsay = false;
745         }
746
747         if(game_stopped)
748                 teamsay = false;
749
750     if (!source) {
751                 colorstr = "";
752                 teamsay = false;
753     }
754
755         if(msgin != "")
756                 msgin = trigger_magicear_processmessage_forallears(source, teamsay, privatesay, msgin);
757
758         /*
759          * using bprint solves this... me stupid
760         // how can we prevent the message from appearing in a listen server?
761         // for now, just give "say" back and only handle say_team
762         if(!teamsay)
763         {
764                 clientcommand(source, strcat("say ", msgin));
765                 return;
766         }
767         */
768
769     string namestr = "";
770     if (source)
771         namestr = playername(source, autocvar_g_chat_teamcolors);
772
773     string colorprefix = (strdecolorize(namestr) == namestr) ? "^3" : "^7";
774
775     string msgstr, cmsgstr;
776     string privatemsgprefix = string_null;
777     int privatemsgprefixlen = 0;
778         if (msgin == "") {
779         msgstr = cmsgstr = "";
780         } else {
781                 if(privatesay)
782                 {
783                         msgstr = strcat("\{1}\{13}* ", colorprefix, namestr, "^3 tells you: ^7");
784                         privatemsgprefixlen = strlen(msgstr);
785                         msgstr = strcat(msgstr, msgin);
786                         cmsgstr = strcat(colorstr, colorprefix, namestr, "^3 tells you:\n^7", msgin);
787                         privatemsgprefix = strcat("\{1}\{13}* ^3You tell ", playername(privatesay, autocvar_g_chat_teamcolors), ": ^7");
788                 }
789                 else if(teamsay)
790                 {
791                         if(strstrofs(msgin, "/me", 0) >= 0)
792                         {
793                                 //msgin = strreplace("/me", "", msgin);
794                                 //msgin = substring(msgin, 3, strlen(msgin));
795                                 msgin = strreplace("/me", strcat(colorstr, "(", colorprefix, namestr, colorstr, ")^7"), msgin);
796                                 msgstr = strcat("\{1}\{13}^4* ", "^7", msgin);
797                         }
798                         else
799                                 msgstr = strcat("\{1}\{13}", colorstr, "(", colorprefix, namestr, colorstr, ") ^7", msgin);
800                         cmsgstr = strcat(colorstr, "(", colorprefix, namestr, colorstr, ")\n^7", msgin);
801                 }
802                 else
803                 {
804                         if(strstrofs(msgin, "/me", 0) >= 0)
805                         {
806                                 //msgin = strreplace("/me", "", msgin);
807                                 //msgin = substring(msgin, 3, strlen(msgin));
808                                 msgin = strreplace("/me", strcat(colorprefix, namestr), msgin);
809                                 msgstr = strcat("\{1}^4* ", "^7", msgin);
810                         }
811                         else {
812                 msgstr = "\{1}";
813                 msgstr = strcat(msgstr, (namestr != "") ? strcat(colorprefix, namestr, "^7: ") : "^7");
814                 msgstr = strcat(msgstr, msgin);
815             }
816                         cmsgstr = "";
817                 }
818                 msgstr = strcat(strreplace("\n", " ", msgstr), "\n"); // newlines only are good for centerprint
819         }
820
821         string fullmsgstr = msgstr;
822         string fullcmsgstr = cmsgstr;
823
824         // FLOOD CONTROL
825         int flood = 0;
826         var .float flood_field = floodcontrol_chat;
827         if(floodcontrol && source)
828         {
829                 float flood_spl;
830                 float flood_burst;
831                 float flood_lmax;
832                 float lines;
833                 if(privatesay)
834                 {
835                         flood_spl = autocvar_g_chat_flood_spl_tell;
836                         flood_burst = autocvar_g_chat_flood_burst_tell;
837                         flood_lmax = autocvar_g_chat_flood_lmax_tell;
838                         flood_field = floodcontrol_chattell;
839                 }
840                 else if(teamsay)
841                 {
842                         flood_spl = autocvar_g_chat_flood_spl_team;
843                         flood_burst = autocvar_g_chat_flood_burst_team;
844                         flood_lmax = autocvar_g_chat_flood_lmax_team;
845                         flood_field = floodcontrol_chatteam;
846                 }
847                 else
848                 {
849                         flood_spl = autocvar_g_chat_flood_spl;
850                         flood_burst = autocvar_g_chat_flood_burst;
851                         flood_lmax = autocvar_g_chat_flood_lmax;
852                         flood_field = floodcontrol_chat;
853                 }
854                 flood_burst = max(0, flood_burst - 1);
855                 // to match explanation in default.cfg, a value of 3 must allow three-line bursts and not four!
856
857                 // do flood control for the default line size
858                 if(msgstr != "")
859                 {
860                         getWrappedLine_remaining = msgstr;
861                         msgstr = "";
862                         lines = 0;
863                         while(getWrappedLine_remaining && (!flood_lmax || lines <= flood_lmax))
864                         {
865                                 msgstr = strcat(msgstr, " ", getWrappedLineLen(82.4289758859709, strlennocol)); // perl averagewidth.pl < gfx/vera-sans.width
866                                 ++lines;
867                         }
868                         msgstr = substring(msgstr, 1, strlen(msgstr) - 1);
869
870                         if(getWrappedLine_remaining != "")
871                         {
872                                 msgstr = strcat(msgstr, "\n");
873                                 flood = 2;
874                         }
875
876                         if (time >= source.(flood_field))
877                         {
878                                 source.(flood_field) = max(time - flood_burst * flood_spl, source.(flood_field)) + lines * flood_spl;
879                         }
880                         else
881                         {
882                                 flood = 1;
883                                 msgstr = fullmsgstr;
884                         }
885                 }
886                 else
887                 {
888                         if (time >= source.(flood_field))
889                                 source.(flood_field) = max(time - flood_burst * flood_spl, source.(flood_field)) + flood_spl;
890                         else
891                                 flood = 1;
892                 }
893
894                 if (timeout_status == TIMEOUT_ACTIVE) // when game is paused, no flood protection
895                         source.(flood_field) = flood = 0;
896         }
897
898     string sourcemsgstr, sourcecmsgstr;
899         if(flood == 2) // cannot happen for empty msgstr
900         {
901                 if(autocvar_g_chat_flood_notify_flooder)
902                 {
903                         sourcemsgstr = strcat(msgstr, "\n^3FLOOD CONTROL: ^7message too long, trimmed\n");
904                         sourcecmsgstr = "";
905                 }
906                 else
907                 {
908                         sourcemsgstr = fullmsgstr;
909                         sourcecmsgstr = fullcmsgstr;
910                 }
911                 cmsgstr = "";
912         }
913         else
914         {
915                 sourcemsgstr = msgstr;
916                 sourcecmsgstr = cmsgstr;
917         }
918
919         if (!privatesay && source && !IS_PLAYER(source))
920         {
921                 if (!game_stopped)
922                 if (teamsay || (autocvar_g_chat_nospectators == 1) || (autocvar_g_chat_nospectators == 2 && !warmup_stage))
923                         teamsay = -1; // spectators
924         }
925
926         if(flood)
927                 LOG_INFO("NOTE: ", playername(source, true), "^7 is flooding.");
928
929         // build sourcemsgstr by cutting off a prefix and replacing it by the other one
930         if(privatesay)
931                 sourcemsgstr = strcat(privatemsgprefix, substring(sourcemsgstr, privatemsgprefixlen, -1));
932
933     int ret;
934         if(source && CS(source).muted)
935         {
936                 // always fake the message
937                 ret = -1;
938         }
939         else if(flood == 1)
940         {
941                 if (autocvar_g_chat_flood_notify_flooder)
942                 {
943                         sprint(source, strcat("^3FLOOD CONTROL: ^7wait ^1", ftos(source.(flood_field) - time), "^3 seconds\n"));
944                         ret = 0;
945                 }
946                 else
947                         ret = -1;
948         }
949         else
950         {
951                 ret = 1;
952         }
953
954         if (privatesay && source && !IS_PLAYER(source))
955         {
956                 if (!game_stopped)
957                 if ((privatesay && IS_PLAYER(privatesay)) && ((autocvar_g_chat_nospectators == 1) || (autocvar_g_chat_nospectators == 2 && !warmup_stage)))
958                         ret = -1; // just hide the message completely
959         }
960
961         MUTATOR_CALLHOOK(ChatMessage, source, ret);
962         ret = M_ARGV(1, int);
963
964         if(sourcemsgstr != "" && ret != 0)
965         {
966                 if(ret < 0) // faked message, because the player is muted
967                 {
968                         sprint(source, sourcemsgstr);
969                         if(sourcecmsgstr != "" && !privatesay)
970                                 centerprint(source, sourcecmsgstr);
971                 }
972                 else if(privatesay) // private message, between 2 people only
973                 {
974                         sprint(source, sourcemsgstr);
975                         if (!autocvar_g_chat_tellprivacy) { dedicated_print(msgstr); } // send to server console too if "tellprivacy" is disabled
976                         if(!MUTATOR_CALLHOOK(ChatMessageTo, privatesay, source))
977                         {
978                                 sprint(privatesay, msgstr);
979                                 if(cmsgstr != "")
980                                         centerprint(privatesay, cmsgstr);
981                         }
982                 }
983                 else if ( teamsay && CS(source).active_minigame )
984                 {
985                         sprint(source, sourcemsgstr);
986                         dedicated_print(msgstr); // send to server console too
987                         FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != source && CS(it).active_minigame == CS(source).active_minigame && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), sprint(it, msgstr));
988                 }
989                 else if(teamsay > 0) // team message, only sent to team mates
990                 {
991                         sprint(source, sourcemsgstr);
992                         dedicated_print(msgstr); // send to server console too
993                         if(sourcecmsgstr != "")
994                                 centerprint(source, sourcecmsgstr);
995                         FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it) && it != source && it.team == source.team && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), {
996                                 sprint(it, msgstr);
997                                 if(cmsgstr != "")
998                                         centerprint(it, cmsgstr);
999                         });
1000                 }
1001                 else if(teamsay < 0) // spectator message, only sent to spectators
1002                 {
1003                         sprint(source, sourcemsgstr);
1004                         dedicated_print(msgstr); // send to server console too
1005                         FOREACH_CLIENT(!IS_PLAYER(it) && IS_REAL_CLIENT(it) && it != source && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), sprint(it, msgstr));
1006                 }
1007                 else
1008                 {
1009             if (source) {
1010                 sprint(source, sourcemsgstr);
1011                 dedicated_print(msgstr); // send to server console too
1012                 MX_Say(strcat(playername(source, true), "^7: ", msgin));
1013             }
1014             FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != source && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), sprint(it, msgstr));
1015         }
1016         }
1017
1018         return ret;
1019 }