Merge branch 'master' into terencehill/accuracy_shotgun
[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, 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(g_ca)
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, 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         .entity weaponentity = weaponentities[0]; // TODO: unhardcode
488
489         if(vbot || IS_REAL_CLIENT(this))
490         if(abot || IS_REAL_CLIENT(attacker))
491         if(attacker && this != attacker)
492         if(DIFF_TEAM(this, attacker))
493         {
494                 if(DEATH_ISSPECIAL(deathtype))
495                         awep = attacker.(weaponentity).m_weapon;
496                 else
497                         awep = DEATH_WEAPONOF(deathtype);
498                 valid_damage_for_weaponstats = true;
499         }
500
501         dh = dh - max(this.health, 0);
502         da = da - max(this.armorvalue, 0);
503         if(valid_damage_for_weaponstats)
504         {
505                 WeaponStats_LogDamage(awep.m_id, abot, this.(weaponentity).m_weapon.m_id, vbot, dh + da);
506         }
507
508         MUTATOR_CALLHOOK(PlayerDamaged, attacker, this, dh, da, hitloc, deathtype, damage);
509
510         if (this.health < 1)
511         {
512                 float defer_ClientKill_Now_TeamChange;
513                 defer_ClientKill_Now_TeamChange = false;
514
515                 if(this.alivetime)
516                 {
517                         PlayerStats_GameReport_Event_Player(this, PLAYERSTATS_ALIVETIME, time - this.alivetime);
518                         this.alivetime = 0;
519                 }
520
521                 if(valid_damage_for_weaponstats)
522                         WeaponStats_LogKill(awep.m_id, abot, this.(weaponentity).m_weapon.m_id, vbot);
523
524                 if(autocvar_sv_gentle < 1)
525                 if(sound_allowed(MSG_BROADCAST, attacker))
526                 {
527                         if(deathtype == DEATH_DROWN.m_id)
528                                 PlayerSound(this, playersound_drown, CH_PAIN, VOL_BASE, VOICETYPE_PLAYERSOUND);
529                         else
530                                 PlayerSound(this, playersound_death, CH_PAIN, VOL_BASE, VOICETYPE_PLAYERSOUND);
531                 }
532
533                 // get rid of kill indicator
534                 if(this.killindicator)
535                 {
536                         delete(this.killindicator);
537                         this.killindicator = NULL;
538                         if(this.killindicator_teamchange)
539                                 defer_ClientKill_Now_TeamChange = true;
540
541                         if(this.classname == "body")
542                         if(deathtype == DEATH_KILL.m_id)
543                         {
544                                 // for the lemmings fans, a small harmless explosion
545                                 Send_Effect(EFFECT_ROCKET_EXPLODE, this.origin, '0 0 0', 1);
546                         }
547                 }
548
549                 // print an obituary message
550                 if(this.classname != "body")
551                         Obituary (attacker, inflictor, this, deathtype);
552
553         // increment frag counter for used weapon type
554         Weapon w = DEATH_WEAPONOF(deathtype);
555                 if(w != WEP_Null && accuracy_isgooddamage(attacker, this))
556                         CS(attacker).accuracy.(accuracy_frags[w.m_id-1]) += 1;
557
558                 this.respawn_time = 0;
559                 MUTATOR_CALLHOOK(PlayerDies, inflictor, attacker, this, deathtype, damage);
560                 damage = M_ARGV(4, float);
561                 excess = max(0, damage - take - save);
562
563                 //Weapon wep = this.(weaponentity).m_weapon;
564                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
565                 {
566                         .entity went = weaponentities[slot];
567                         if(!this.(weaponentity))
568                                 continue; // TODO: clones have no weapon, but we don't want to have to check this all the time
569                         Weapon wep = this.(weaponentity).m_weapon;
570                         wep.wr_playerdeath(wep, this, went);
571                 }
572
573                 RemoveGrapplingHooks(this);
574
575                 Portal_ClearAllLater(this);
576
577                 this.fixangle = true;
578
579                 if(defer_ClientKill_Now_TeamChange)
580                         ClientKill_Now_TeamChange(this); // can turn player into spectator
581
582                 // player could have been miraculously resuscitated ;)
583                 // e.g. players in freezetag get frozen, they don't really die
584                 if(this.health >= 1 || !(IS_PLAYER(this) || this.classname == "body"))
585                         return;
586
587                 if (!this.respawn_time) // can be set in the mutator hook PlayerDies
588                         calculate_player_respawn_time(this);
589
590                 // when we get here, player actually dies
591
592                 Unfreeze(this); // remove any icy remains
593                 this.health = 0; // Unfreeze resets health, so we need to set it back
594
595                 // clear waypoints
596                 WaypointSprite_PlayerDead(this);
597                 // throw a weapon
598                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
599                 {
600                         .entity went = weaponentities[slot];
601                         SpawnThrownWeapon(this, this.origin + (this.mins + this.maxs) * 0.5, this.(went).m_weapon, went);
602                 }
603
604                 // become fully visible
605                 this.alpha = default_player_alpha;
606                 // make the corpse upright (not tilted)
607                 this.angles_x = 0;
608                 this.angles_z = 0;
609                 // don't spin
610                 this.avelocity = '0 0 0';
611                 // view from the floor
612                 this.view_ofs = '0 0 -8';
613                 // toss the corpse
614                 set_movetype(this, MOVETYPE_TOSS);
615                 // shootable corpse
616                 this.solid = SOLID_CORPSE;
617                 PS(this).ballistics_density = autocvar_g_ballistics_density_corpse;
618                 // don't stick to the floor
619                 UNSET_ONGROUND(this);
620                 // dying animation
621                 this.deadflag = DEAD_DYING;
622
623                 STAT(MOVEVARS_SPECIALCOMMAND, this) = false; // sweet release
624
625                 this.death_time = time;
626                 if (random() < 0.5)
627                         animdecide_setstate(this, this.anim_state | ANIMSTATE_DEAD1, true);
628                 else
629                         animdecide_setstate(this, this.anim_state | ANIMSTATE_DEAD2, true);
630
631                 /* // postpone resize until frame end so that dead player can still
632                 // properly get hit by all the projectiles fired in this frame (shotgun)
633                 if (this.maxs.z > 5)
634                 {
635                         this.maxs_z = 5;
636                         setsize(this, this.mins, this.maxs);
637                 }
638                 */
639
640                 // set damage function to corpse damage
641                 this.event_damage = PlayerCorpseDamage;
642                 // call the corpse damage function just in case it wants to gib
643                 this.event_damage(this, inflictor, attacker, excess, deathtype, hitloc, force);
644
645                 // set up to fade out later
646                 SUB_SetFade (this, time + 6 + random (), 1);
647                 // reset body think wrapper broken by SUB_SetFade
648                 if(this.classname == "body" && getthink(this) != CopyBody_Think) {
649                         this.CopyBody_think = getthink(this);
650                         this.CopyBody_nextthink = this.nextthink;
651                         setthink(this, CopyBody_Think);
652                         this.nextthink = time;
653                 }
654
655                 if(autocvar_sv_gentle > 0 || autocvar_ekg || this.classname == "body") {
656                         // remove corpse
657                         // clones don't run any animation code any more, so we must gib them when they die :(
658                         this.event_damage(this, inflictor, attacker, autocvar_sv_gibhealth + 1, deathtype, hitloc, force);
659                 }
660
661                 // reset fields the weapons may use just in case
662                 if(this.classname != "body")
663                 {
664                         FOREACH(Weapons, it != WEP_Null,
665                         {
666                                 it.wr_resetplayer(it, this);
667                                 for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
668                                 {
669                                         ATTACK_FINISHED_FOR(this, it.m_id, slot) = 0;
670                                 }
671                         });
672                 }
673                 MUTATOR_CALLHOOK(PlayerDied, this);
674         }
675 }
676
677 bool MoveToTeam(entity client, int team_colour, int type)
678 {
679         int lockteams_backup = lockteams;  // backup any team lock
680         lockteams = 0;  // disable locked teams
681         TeamchangeFrags(client);  // move the players frags
682         if (!SetPlayerTeamSimple(client, team_colour))
683         {
684                 return false;
685         }
686         Damage(client, client, client, 100000, DEATH_AUTOTEAMCHANGE.m_id, client.origin, '0 0 0');  // kill the player
687         lockteams = lockteams_backup;  // restore the team lock
688         LogTeamchange(client.playerid, client.team, type);
689         return true;
690 }
691
692 /** print(), but only print if the server is not local */
693 void dedicated_print(string input)
694 {
695         if (server_is_dedicated) print(input);
696 }
697
698 void PrintToChat(entity player, string text)
699 {
700         text = strcat("\{1}^7", text, "\n");
701         sprint(player, text);
702 }
703
704 void DebugPrintToChat(entity player, string text)
705 {
706         if (autocvar_developer)
707         {
708                 PrintToChat(player, text);
709         }
710 }
711
712 void PrintToChatAll(string text)
713 {
714         text = strcat("\{1}^7", text, "\n");
715         bprint(text);
716 }
717
718 void DebugPrintToChatAll(string text)
719 {
720         if (autocvar_developer)
721         {
722                 PrintToChatAll(text);
723         }
724 }
725
726 void PrintToChatTeam(int teamnum, string text)
727 {
728         text = strcat("\{1}^7", text, "\n");
729         FOREACH_CLIENT(IS_REAL_CLIENT(it),
730         {
731                 if (it.team == teamnum)
732                 {
733                         sprint(it, text);
734                 }
735         });
736 }
737
738 void DebugPrintToChatTeam(int teamnum, string text)
739 {
740         if (autocvar_developer)
741         {
742                 PrintToChatTeam(teamnum, text);
743         }
744 }
745
746 /**
747  * message "": do not say, just test flood control
748  * return value:
749  *   1 = accept
750  *   0 = reject
751  *  -1 = fake accept
752  */
753 int Say(entity source, int teamsay, entity privatesay, string msgin, bool floodcontrol)
754 {
755         if (!teamsay && !privatesay && substring(msgin, 0, 1) == " ")
756         msgin = substring(msgin, 1, -1); // work around DP say bug (say_team does not have this!)
757
758     if(source)
759                 msgin = formatmessage(source, msgin);
760
761     string colorstr;
762         if (!IS_PLAYER(source))
763                 colorstr = "^0"; // black for spectators
764         else if(teamplay)
765                 colorstr = Team_ColorCode(source.team);
766         else
767         {
768                 colorstr = "";
769                 teamsay = false;
770         }
771
772         if(game_stopped)
773                 teamsay = false;
774
775     if (!source) {
776                 colorstr = "";
777                 teamsay = false;
778     }
779
780         if(msgin != "")
781                 msgin = trigger_magicear_processmessage_forallears(source, teamsay, privatesay, msgin);
782
783         /*
784          * using bprint solves this... me stupid
785         // how can we prevent the message from appearing in a listen server?
786         // for now, just give "say" back and only handle say_team
787         if(!teamsay)
788         {
789                 clientcommand(source, strcat("say ", msgin));
790                 return;
791         }
792         */
793
794     string namestr = "";
795     if (source)
796         namestr = playername(source, autocvar_g_chat_teamcolors);
797
798     string colorprefix = (strdecolorize(namestr) == namestr) ? "^3" : "^7";
799
800     string msgstr, cmsgstr;
801     string privatemsgprefix = string_null;
802     int privatemsgprefixlen = 0;
803         if (msgin == "") {
804         msgstr = cmsgstr = "";
805         } else {
806                 if(privatesay)
807                 {
808                         msgstr = strcat("\{1}\{13}* ", colorprefix, namestr, "^3 tells you: ^7");
809                         privatemsgprefixlen = strlen(msgstr);
810                         msgstr = strcat(msgstr, msgin);
811                         cmsgstr = strcat(colorstr, colorprefix, namestr, "^3 tells you:\n^7", msgin);
812                         privatemsgprefix = strcat("\{1}\{13}* ^3You tell ", playername(privatesay, autocvar_g_chat_teamcolors), ": ^7");
813                 }
814                 else if(teamsay)
815                 {
816                         if(strstrofs(msgin, "/me", 0) >= 0)
817                         {
818                                 //msgin = strreplace("/me", "", msgin);
819                                 //msgin = substring(msgin, 3, strlen(msgin));
820                                 msgin = strreplace("/me", strcat(colorstr, "(", colorprefix, namestr, colorstr, ")^7"), msgin);
821                                 msgstr = strcat("\{1}\{13}^4* ", "^7", msgin);
822                         }
823                         else
824                                 msgstr = strcat("\{1}\{13}", colorstr, "(", colorprefix, namestr, colorstr, ") ^7", msgin);
825                         cmsgstr = strcat(colorstr, "(", colorprefix, namestr, colorstr, ")\n^7", msgin);
826                 }
827                 else
828                 {
829                         if(strstrofs(msgin, "/me", 0) >= 0)
830                         {
831                                 //msgin = strreplace("/me", "", msgin);
832                                 //msgin = substring(msgin, 3, strlen(msgin));
833                                 msgin = strreplace("/me", strcat(colorprefix, namestr), msgin);
834                                 msgstr = strcat("\{1}^4* ", "^7", msgin);
835                         }
836                         else {
837                 msgstr = "\{1}";
838                 msgstr = strcat(msgstr, (namestr != "") ? strcat(colorprefix, namestr, "^7: ") : "^7");
839                 msgstr = strcat(msgstr, msgin);
840             }
841                         cmsgstr = "";
842                 }
843                 msgstr = strcat(strreplace("\n", " ", msgstr), "\n"); // newlines only are good for centerprint
844         }
845
846         string fullmsgstr = msgstr;
847         string fullcmsgstr = cmsgstr;
848
849         // FLOOD CONTROL
850         int flood = 0;
851         var .float flood_field = floodcontrol_chat;
852         if(floodcontrol && source)
853         {
854                 float flood_spl;
855                 float flood_burst;
856                 float flood_lmax;
857                 float lines;
858                 if(privatesay)
859                 {
860                         flood_spl = autocvar_g_chat_flood_spl_tell;
861                         flood_burst = autocvar_g_chat_flood_burst_tell;
862                         flood_lmax = autocvar_g_chat_flood_lmax_tell;
863                         flood_field = floodcontrol_chattell;
864                 }
865                 else if(teamsay)
866                 {
867                         flood_spl = autocvar_g_chat_flood_spl_team;
868                         flood_burst = autocvar_g_chat_flood_burst_team;
869                         flood_lmax = autocvar_g_chat_flood_lmax_team;
870                         flood_field = floodcontrol_chatteam;
871                 }
872                 else
873                 {
874                         flood_spl = autocvar_g_chat_flood_spl;
875                         flood_burst = autocvar_g_chat_flood_burst;
876                         flood_lmax = autocvar_g_chat_flood_lmax;
877                         flood_field = floodcontrol_chat;
878                 }
879                 flood_burst = max(0, flood_burst - 1);
880                 // to match explanation in default.cfg, a value of 3 must allow three-line bursts and not four!
881
882                 // do flood control for the default line size
883                 if(msgstr != "")
884                 {
885                         getWrappedLine_remaining = msgstr;
886                         msgstr = "";
887                         lines = 0;
888                         while(getWrappedLine_remaining && (!flood_lmax || lines <= flood_lmax))
889                         {
890                                 msgstr = strcat(msgstr, " ", getWrappedLineLen(82.4289758859709, strlennocol)); // perl averagewidth.pl < gfx/vera-sans.width
891                                 ++lines;
892                         }
893                         msgstr = substring(msgstr, 1, strlen(msgstr) - 1);
894
895                         if(getWrappedLine_remaining != "")
896                         {
897                                 msgstr = strcat(msgstr, "\n");
898                                 flood = 2;
899                         }
900
901                         if (time >= source.(flood_field))
902                         {
903                                 source.(flood_field) = max(time - flood_burst * flood_spl, source.(flood_field)) + lines * flood_spl;
904                         }
905                         else
906                         {
907                                 flood = 1;
908                                 msgstr = fullmsgstr;
909                         }
910                 }
911                 else
912                 {
913                         if (time >= source.(flood_field))
914                                 source.(flood_field) = max(time - flood_burst * flood_spl, source.(flood_field)) + flood_spl;
915                         else
916                                 flood = 1;
917                 }
918
919                 if (timeout_status == TIMEOUT_ACTIVE) // when game is paused, no flood protection
920                         source.(flood_field) = flood = 0;
921         }
922
923     string sourcemsgstr, sourcecmsgstr;
924         if(flood == 2) // cannot happen for empty msgstr
925         {
926                 if(autocvar_g_chat_flood_notify_flooder)
927                 {
928                         sourcemsgstr = strcat(msgstr, "\n^3FLOOD CONTROL: ^7message too long, trimmed\n");
929                         sourcecmsgstr = "";
930                 }
931                 else
932                 {
933                         sourcemsgstr = fullmsgstr;
934                         sourcecmsgstr = fullcmsgstr;
935                 }
936                 cmsgstr = "";
937         }
938         else
939         {
940                 sourcemsgstr = msgstr;
941                 sourcecmsgstr = cmsgstr;
942         }
943
944         if (!privatesay && source && !IS_PLAYER(source))
945         {
946                 if (!game_stopped)
947                 if (teamsay || (autocvar_g_chat_nospectators == 1) || (autocvar_g_chat_nospectators == 2 && !warmup_stage))
948                         teamsay = -1; // spectators
949         }
950
951         if(flood)
952                 LOG_INFO("NOTE: ", playername(source, true), "^7 is flooding.");
953
954         // build sourcemsgstr by cutting off a prefix and replacing it by the other one
955         if(privatesay)
956                 sourcemsgstr = strcat(privatemsgprefix, substring(sourcemsgstr, privatemsgprefixlen, -1));
957
958     int ret;
959         if(source && CS(source).muted)
960         {
961                 // always fake the message
962                 ret = -1;
963         }
964         else if(flood == 1)
965         {
966                 if (autocvar_g_chat_flood_notify_flooder)
967                 {
968                         sprint(source, strcat("^3FLOOD CONTROL: ^7wait ^1", ftos(source.(flood_field) - time), "^3 seconds\n"));
969                         ret = 0;
970                 }
971                 else
972                         ret = -1;
973         }
974         else
975         {
976                 ret = 1;
977         }
978
979         if (privatesay && source && !IS_PLAYER(source))
980         {
981                 if (!game_stopped)
982                 if ((privatesay && !IS_PLAYER(privatesay)) || (autocvar_g_chat_nospectators == 1) || (autocvar_g_chat_nospectators == 2 && !warmup_stage))
983                         ret = -1; // just hide the message completely
984         }
985
986         MUTATOR_CALLHOOK(ChatMessage, source, ret);
987         ret = M_ARGV(1, int);
988
989         if(sourcemsgstr != "" && ret != 0)
990         {
991                 if(ret < 0) // faked message, because the player is muted
992                 {
993                         sprint(source, sourcemsgstr);
994                         if(sourcecmsgstr != "" && !privatesay)
995                                 centerprint(source, sourcecmsgstr);
996                 }
997                 else if(privatesay) // private message, between 2 people only
998                 {
999                         sprint(source, sourcemsgstr);
1000                         if (!autocvar_g_chat_tellprivacy) { dedicated_print(msgstr); } // send to server console too if "tellprivacy" is disabled
1001                         if(!MUTATOR_CALLHOOK(ChatMessageTo, privatesay, source))
1002                         {
1003                                 sprint(privatesay, msgstr);
1004                                 if(cmsgstr != "")
1005                                         centerprint(privatesay, cmsgstr);
1006                         }
1007                 }
1008                 else if ( teamsay && CS(source).active_minigame )
1009                 {
1010                         sprint(source, sourcemsgstr);
1011                         dedicated_print(msgstr); // send to server console too
1012                         FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != source && CS(it).active_minigame == CS(source).active_minigame && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), sprint(it, msgstr));
1013                 }
1014                 else if(teamsay > 0) // team message, only sent to team mates
1015                 {
1016                         sprint(source, sourcemsgstr);
1017                         dedicated_print(msgstr); // send to server console too
1018                         if(sourcecmsgstr != "")
1019                                 centerprint(source, sourcecmsgstr);
1020                         FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it) && it != source && it.team == source.team && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), {
1021                                 sprint(it, msgstr);
1022                                 if(cmsgstr != "")
1023                                         centerprint(it, cmsgstr);
1024                         });
1025                 }
1026                 else if(teamsay < 0) // spectator message, only sent to spectators
1027                 {
1028                         sprint(source, sourcemsgstr);
1029                         dedicated_print(msgstr); // send to server console too
1030                         FOREACH_CLIENT(!IS_PLAYER(it) && IS_REAL_CLIENT(it) && it != source && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), sprint(it, msgstr));
1031                 }
1032                 else
1033                 {
1034             if (source) {
1035                 sprint(source, sourcemsgstr);
1036                 dedicated_print(msgstr); // send to server console too
1037                 MX_Say(strcat(playername(source, true), "^7: ", msgin));
1038             }
1039             FOREACH_CLIENT(IS_REAL_CLIENT(it) && it != source && !MUTATOR_CALLHOOK(ChatMessageTo, it, source), sprint(it, msgstr));
1040         }
1041         }
1042
1043         return ret;
1044 }