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