qcsrc/server/cl_player.qc

   1 .entity accuracy;
   2 .float accuracy_frags[WEP_MAXCOUNT];
   3
   4 float weaponstats_buffer;
   5
   6 void WeaponStats_Init()
   7 {
   8         if(autocvar_sv_weaponstats_file != "")
   9                 weaponstats_buffer = buf_create();
  10         else
  11                 weaponstats_buffer = -1;
  12 }
  13
  14 #define WEAPONSTATS_GETINDEX(awep,abot,vwep,vbot) (((vwep) + (awep) * (WEP_LAST - WEP_FIRST + 1) - (WEP_FIRST + WEP_FIRST * (WEP_LAST - WEP_FIRST + 1))) * 4 + (abot) * 2 + (vbot))
  15
  16 void WeaponStats_ready(entity fh, entity pass, float status)
  17 {
  18         float i, j, n, ibot, jbot, idx;
  19         vector v;
  20         string prefix, s;
  21         switch(status)
  22         {
  23                 case URL_READY_CANWRITE:
  24                         prefix = strcat(autocvar_hostname, "\t", GetGametype(), "_", GetMapname(), "\t");
  25                         url_fputs(fh, "#begin statsfile\n");
  26                         url_fputs(fh, strcat("#date ", strftime(TRUE, "%a %b %e %H:%M:%S %Z %Y"), "\n"));
  27                         url_fputs(fh, strcat("#config ", ftos(crc16(FALSE, cvar_purechanges)), "\n"));
  28                         url_fputs(fh, strcat("#cvar_purechanges ", ftos(cvar_purechanges_count), "\n"));
  29                         n = tokenizebyseparator(cvar_purechanges, "\n");
  30                         for(i = 0; i < n; ++i)
  31                                 url_fputs(fh, strcat("#cvar_purechange ", argv(i), "\n"));
  32                         for(i = WEP_FIRST; i <= WEP_LAST; ++i) for(ibot = 0; ibot <= 1; ++ibot)
  33                                 for(j = WEP_FIRST; j <= WEP_LAST; ++j) for(jbot = 0; jbot <= 1; ++jbot)
  34                                 {
  35                                         idx = WEAPONSTATS_GETINDEX(i, ibot, j, jbot);
  36                                         v = stov(bufstr_get(weaponstats_buffer, idx));
  37                                         if(v != '0 0 0')
  38                                         {
  39                                                 //vector is: kills hits damage
  40                                                 url_fputs(fh, sprintf("%s%d %d\t%d %d\t", prefix, i, ibot, j, jbot));
  41                                                 url_fputs(fh, sprintf("%d %d %g\n", v_x, v_y, v_z));
  42                                         }
  43                                 }
  44                         url_fputs(fh, "#end\n\n");
  45                         url_fclose(fh, WeaponStats_ready, world);
  46                         buf_del(weaponstats_buffer);
  47                         weaponstats_buffer = -1;
  48                         break;
  49                 case URL_READY_CANREAD:
  50                         print("Got response from weapon stats server:\n");
  51                         while((s = url_fgets(fh)))
  52                                 print("  ", s, "\n");
  53                         print("End of response.\n");
  54                         url_fclose(fh, WeaponStats_ready, world);
  55                         break;
  56                 case URL_READY_CLOSED:
  57                         print("Weapon stats written\n");
  58                         break;
  59                 case URL_READY_ERROR:
  60                 default:
  61                         print("Weapon stats writing failed: ", ftos(status), "\n");
  62                         break;
  63         }
  64 }
  65
  66 void WeaponStats_Shutdown()
  67 {
  68         if(weaponstats_buffer < 0)
  69                 return;
  70         if(autocvar_sv_weaponstats_file != "")
  71         {
  72                 url_fopen(autocvar_sv_weaponstats_file, FILE_APPEND, WeaponStats_ready, world);
  73         }
  74         else
  75         {
  76                 buf_del(weaponstats_buffer);
  77                 weaponstats_buffer = -1;
  78         }
  79 }
  80
  81 void WeaponStats_LogItem(float awep, float abot, float vwep, float vbot, vector item)
  82 {
  83         float idx;
  84         if(weaponstats_buffer < 0)
  85                 return;
  86         if(awep < WEP_FIRST || vwep < WEP_FIRST)
  87                 return;
  88         if(awep > WEP_LAST || vwep > WEP_LAST)
  89                 return;
  90         idx = WEAPONSTATS_GETINDEX(awep,abot,vwep,vbot);
  91         bufstr_set(weaponstats_buffer, idx, vtos(stov(bufstr_get(weaponstats_buffer, idx)) + item));
  92 }
  93 void WeaponStats_LogDamage(float awep, float abot, float vwep, float vbot, float damage)
  94 {
  95         if(damage < 0)
  96                 error("negative damage?");
  97         WeaponStats_LogItem(awep, abot, vwep, vbot, '0 0 1' * damage + '0 1 0');
  98 }
  99 void WeaponStats_LogKill(float awep, float abot, float vwep, float vbot)
 100 {
 101         WeaponStats_LogItem(awep, abot, vwep, vbot, '1 0 0');
 102 }
 103
 104 // changes by LordHavoc on 03/29/04 and 03/30/04 at Vermeulen's request
 105 // merged player_run and player_stand to player_anim
 106 // added death animations to player_anim
 107 // can now spawn thrown weapons from anywhere, not just from players
 108 // thrown weapons now fade out after 20 seconds
 109 // created PlayerGib function
 110 // PlayerDie no longer uses hitloc or damage
 111 // PlayerDie now supports dying animations as well as gibbing
 112 // cleaned up PlayerDie a lot
 113 // added CopyBody
 114
 115 .entity pusher;
 116 .float pushltime;
 117
 118 void CopyBody(float keepvelocity)
 119 {
 120         local entity oldself;
 121         if (self.effects & EF_NODRAW)
 122                 return;
 123         oldself = self;
 124         self = spawn();
 125         self.enemy = oldself;
 126         self.lip = oldself.lip;
 127         self.colormap = oldself.colormap;
 128         self.glowmod = oldself.glowmod;
 129         self.iscreature = oldself.iscreature;
 130         self.angles = oldself.angles;
 131         self.avelocity = oldself.avelocity;
 132         self.classname = "body";
 133         self.damageforcescale = oldself.damageforcescale;
 134         self.effects = oldself.effects;
 135         self.event_damage = oldself.event_damage;
 136         self.animstate_startframe = oldself.animstate_startframe;
 137         self.animstate_numframes = oldself.animstate_numframes;
 138         self.animstate_framerate = oldself.animstate_framerate;
 139         self.animstate_starttime = oldself.animstate_starttime;
 140         self.animstate_endtime = oldself.animstate_endtime;
 141         self.animstate_override = oldself.animstate_override;
 142         self.animstate_looping = oldself.animstate_looping;
 143         self.frame = oldself.frame;
 144         self.dead_frame = oldself.dead_frame;
 145         self.pain_finished = oldself.pain_finished;
 146         self.health = oldself.health;
 147         self.armorvalue = oldself.armorvalue;
 148         self.armortype = oldself.armortype;
 149         self.model = oldself.model;
 150         self.modelindex = oldself.modelindex;
 151         self.modelindex_lod0 = oldself.modelindex_lod0;
 152         self.modelindex_lod0_from_xonotic = oldself.modelindex_lod0_from_xonotic;
 153         self.modelindex_lod1 = oldself.modelindex_lod1;
 154         self.modelindex_lod2 = oldself.modelindex_lod2;
 155         self.skinindex = oldself.skinindex;
 156         self.species = oldself.species;
 157         self.movetype = oldself.movetype;
 158         self.nextthink = oldself.nextthink;
 159         self.solid = oldself.solid;
 160         self.ballistics_density = oldself.ballistics_density;
 161         self.takedamage = oldself.takedamage;
 162         self.think = oldself.think;
 163         self.customizeentityforclient = oldself.customizeentityforclient;
 164         self.uncustomizeentityforclient = oldself.uncustomizeentityforclient;
 165         self.uncustomizeentityforclient_set = oldself.uncustomizeentityforclient_set;
 166         if (keepvelocity == 1)
 167                 self.velocity = oldself.velocity;
 168         self.oldvelocity = self.velocity;
 169         self.fade_time = oldself.fade_time;
 170         self.fade_rate = oldself.fade_rate;
 171         //self.weapon = oldself.weapon;
 172         setorigin(self, oldself.origin);
 173         setsize(self, oldself.mins, oldself.maxs);
 174         self.prevorigin = oldself.origin;
 175         self.reset = SUB_Remove;
 176
 177         Drag_MoveDrag(oldself, self);
 178
 179         self = oldself;
 180 }
 181
 182 float player_getspecies()
 183 {
 184         float s;
 185         get_model_parameters(self.model, self.skinindex);
 186         s = get_model_parameters_species;
 187         get_model_parameters(string_null, 0);
 188         if(s < 0)
 189                 return SPECIES_HUMAN;
 190         return s;
 191 }
 192
 193 void player_setupanimsformodel()
 194 {
 195         local string animfilename;
 196         local float animfile;
 197         // defaults for legacy .zym models without animinfo files
 198         self.anim_die1 = '0 1 0.5'; // 2 seconds
 199         self.anim_die2 = '1 1 0.5'; // 2 seconds
 200         self.anim_draw = '2 1 3'; // TODO: analyze models and set framerate
 201         self.anim_duck = '3 1 100'; // this anim seems bogus in most models, so make it play VERY briefly!
 202         self.anim_duckwalk = '4 1 1';
 203         self.anim_duckjump = '5 1 100'; // zym anims keep playing until changed, so this only has to start the anim, landing will end it
 204         self.anim_duckidle = '6 1 1';
 205         self.anim_idle = '7 1 1';
 206         self.anim_jump = '8 1 100'; // zym anims keep playing until changed, so this only has to start the anim, landing will end it
 207         self.anim_pain1 = '9 1 2'; // 0.5 seconds
 208         self.anim_pain2 = '10 1 2'; // 0.5 seconds
 209         self.anim_shoot = '11 1 5'; // TODO: analyze models and set framerate
 210         self.anim_taunt = '12 1 0.33'; // FIXME?  there is no code using this anim
 211         self.anim_run = '13 1 1';
 212         self.anim_runbackwards = '14 1 1';
 213         self.anim_strafeleft = '15 1 1';
 214         self.anim_straferight = '16 1 1';
 215         self.anim_dead1 = '17 1 1';
 216         self.anim_dead2 = '18 1 1';
 217         self.anim_forwardright = '19 1 1';
 218         self.anim_forwardleft = '20 1 1';
 219         self.anim_backright = '21 1 1';
 220         self.anim_backleft  = '22 1 1';
 221         self.anim_melee = '23 1 1';
 222         animparseerror = FALSE;
 223         animfilename = strcat(self.model, ".animinfo");
 224         animfile = fopen(animfilename, FILE_READ);
 225         if (animfile >= 0)
 226         {
 227                 self.anim_die1         = animparseline(animfile);
 228                 self.anim_die2         = animparseline(animfile);
 229                 self.anim_draw         = animparseline(animfile);
 230                 self.anim_duck         = animparseline(animfile);
 231                 self.anim_duckwalk     = animparseline(animfile);
 232                 self.anim_duckjump     = animparseline(animfile);
 233                 self.anim_duckidle     = animparseline(animfile);
 234                 self.anim_idle         = animparseline(animfile);
 235                 self.anim_jump         = animparseline(animfile);
 236                 self.anim_pain1        = animparseline(animfile);
 237                 self.anim_pain2        = animparseline(animfile);
 238                 self.anim_shoot        = animparseline(animfile);
 239                 self.anim_taunt        = animparseline(animfile);
 240                 self.anim_run          = animparseline(animfile);
 241                 self.anim_runbackwards = animparseline(animfile);
 242                 self.anim_strafeleft   = animparseline(animfile);
 243                 self.anim_straferight  = animparseline(animfile);
 244                 self.anim_forwardright = animparseline(animfile);
 245                 self.anim_forwardleft  = animparseline(animfile);
 246                 self.anim_backright    = animparseline(animfile);
 247                 self.anim_backleft     = animparseline(animfile);
 248                 self.anim_melee        = animparseline(animfile);
 249                 fclose(animfile);
 250
 251                 // derived anims
 252                 self.anim_dead1 = '0 1 1' + '1 0 0' * (self.anim_die1_x + self.anim_die1_y - 1);
 253                 self.anim_dead2 = '0 1 1' + '1 0 0' * (self.anim_die2_x + self.anim_die2_y - 1);
 254
 255                 if (animparseerror)
 256                         print("Parse error in ", animfilename, ", some player animations are broken\n");
 257         }
 258         else
 259                 dprint("File ", animfilename, " not found, assuming legacy .zym model animation timings\n");
 260         // reset animstate now
 261         setanim(self, self.anim_idle, TRUE, FALSE, TRUE);
 262 };
 263
 264 void player_anim (void)
 265 {
 266         updateanim(self);
 267         if (self.weaponentity)
 268                 updateanim(self.weaponentity);
 269
 270         if (self.deadflag != DEAD_NO)
 271         {
 272                 if (time > self.animstate_endtime)
 273                 {
 274                         if (self.maxs_z > 5)
 275                         {
 276                                 self.maxs_z = 5;
 277                                 setsize(self, self.mins, self.maxs);
 278                         }
 279                         self.frame = self.dead_frame;
 280                 }
 281                 return;
 282         }
 283
 284         if (!self.animstate_override)
 285         {
 286                 if (!(self.flags & FL_ONGROUND))
 287                 {
 288                         if (self.crouch)
 289                                 setanim(self, self.anim_duckjump, FALSE, TRUE, self.restart_jump);
 290                         else
 291                                 setanim(self, self.anim_jump, FALSE, TRUE, self.restart_jump);
 292                         self.restart_jump = FALSE;
 293                 }
 294                 else if (self.crouch)
 295                 {
 296                         if (self.movement_x * self.movement_x + self.movement_y * self.movement_y > 20)
 297                                 setanim(self, self.anim_duckwalk, TRUE, FALSE, FALSE);
 298                         else
 299                                 setanim(self, self.anim_duckidle, TRUE, FALSE, FALSE);
 300                 }
 301                 else if ((self.movement_x * self.movement_x + self.movement_y * self.movement_y) > 20)
 302                 {
 303                         if (self.movement_x > 0 && self.movement_y == 0)
 304                                 setanim(self, self.anim_run, TRUE, FALSE, FALSE);
 305                         else if (self.movement_x < 0 && self.movement_y == 0)
 306                                 setanim(self, self.anim_runbackwards, TRUE, FALSE, FALSE);
 307                         else if (self.movement_x == 0 && self.movement_y > 0)
 308                                 setanim(self, self.anim_straferight, TRUE, FALSE, FALSE);
 309                         else if (self.movement_x == 0 && self.movement_y < 0)
 310                                 setanim(self, self.anim_strafeleft, TRUE, FALSE, FALSE);
 311                         else if (self.movement_x > 0 && self.movement_y > 0)
 312                                 setanim(self, self.anim_forwardright, TRUE, FALSE, FALSE);
 313                         else if (self.movement_x > 0 && self.movement_y < 0)
 314                                 setanim(self, self.anim_forwardleft, TRUE, FALSE, FALSE);
 315                         else if (self.movement_x < 0 && self.movement_y > 0)
 316                                 setanim(self, self.anim_backright, TRUE, FALSE, FALSE);
 317                         else if (self.movement_x < 0 && self.movement_y < 0)
 318                                 setanim(self, self.anim_backleft, TRUE, FALSE, FALSE);
 319                         else
 320                                 setanim(self, self.anim_run, TRUE, FALSE, FALSE);
 321                 }
 322                 else
 323                         setanim(self, self.anim_idle, TRUE, FALSE, FALSE);
 324         }
 325
 326         if (self.weaponentity)
 327         if (!self.weaponentity.animstate_override)
 328                 setanim(self.weaponentity, self.weaponentity.anim_idle, TRUE, FALSE, FALSE);
 329 }
 330
 331 void SpawnThrownWeapon (vector org, float w)
 332 {
 333         if(g_minstagib)
 334         if(self.ammo_cells <= 0)
 335                 return;
 336
 337         if(g_pinata)
 338         {
 339                 float j;
 340                 for(j = WEP_FIRST; j <= WEP_LAST; ++j)
 341                 {
 342                         if(self.weapons & W_WeaponBit(j))
 343                                 if(W_IsWeaponThrowable(j))
 344                                         W_ThrowNewWeapon(self, j, FALSE, org, randomvec() * 175 + '0 0 325');
 345                 }
 346         }
 347         else
 348         {
 349                 if(W_IsWeaponThrowable(self.weapon))
 350                         W_ThrowNewWeapon(self, self.weapon, FALSE, org, randomvec() * 125 + '0 0 200');
 351         }
 352 }
 353
 354 void PlayerCorpseDamage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 355 {
 356         local float take, save;
 357         vector v;
 358         Violence_GibSplash_At(hitloc, force, 2, bound(0, damage, 200) / 16, self, attacker);
 359
 360         // damage resistance (ignore most of the damage from a bullet or similar)
 361         damage = max(damage - 5, 1);
 362
 363         v = healtharmor_applydamage(self.armorvalue, autocvar_g_balance_armor_blockpercent, damage);
 364         take = v_x;
 365         save = v_y;
 366
 367         if(sound_allowed(MSG_BROADCAST, attacker))
 368         {
 369                 if (save > 10)
 370                         sound (self, CH_SHOTS, "misc/armorimpact.wav", VOL_BASE, ATTN_NORM);
 371                 else if (take > 30)
 372                         sound (self, CH_SHOTS, "misc/bodyimpact2.wav", VOL_BASE, ATTN_NORM);
 373                 else if (take > 10)
 374                         sound (self, CH_SHOTS, "misc/bodyimpact1.wav", VOL_BASE, ATTN_NORM);
 375         }
 376
 377         if (take > 50)
 378                 Violence_GibSplash_At(hitloc, force * -0.1, 3, 1, self, attacker);
 379         if (take > 100)
 380                 Violence_GibSplash_At(hitloc, force * -0.2, 3, 1, self, attacker);
 381
 382         if (!(self.flags & FL_GODMODE))
 383         {
 384                 self.armorvalue = self.armorvalue - save;
 385                 self.health = self.health - take;
 386                 // pause regeneration for 5 seconds
 387                 self.pauseregen_finished = max(self.pauseregen_finished, time + autocvar_g_balance_pause_health_regen);
 388         }
 389         self.dmg_save = self.dmg_save + save;//max(save - 10, 0);
 390         self.dmg_take = self.dmg_take + take;//max(take - 10, 0);
 391         self.dmg_inflictor = inflictor;
 392
 393         if (self.health <= -autocvar_sv_gibhealth && self.modelindex != 0)
 394         {
 395                 // don't use any animations as a gib
 396                 self.frame = 0;
 397                 self.dead_frame = 0;
 398                 // view just above the floor
 399                 self.view_ofs = '0 0 4';
 400
 401                 Violence_GibSplash(self, 1, 1, attacker);
 402                 self.modelindex = 0; // restore later
 403                 self.solid = SOLID_NOT; // restore later
 404         }
 405 }
 406
 407 void ClientKill_Now_TeamChange();
 408 void freezetag_CheckWinner();
 409
 410 void PlayerDamage (entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 411 {
 412         local float take, save, waves, sdelay, dh, da, j;
 413         vector v;
 414         float valid_damage_for_weaponstats;
 415         float excess;
 416
 417         if((g_arena && numspawned < 2) || (g_ca && ca_players < required_ca_players) && !inWarmupStage)
 418                 return;
 419
 420         dh = max(self.health, 0);
 421         da = max(self.armorvalue, 0);
 422
 423         if(!DEATH_ISSPECIAL(deathtype))
 424         {
 425                 damage *= sqrt(bound(1.0, self.cvar_cl_handicap, 100.0));
 426                 if(self != attacker)
 427                         damage /= sqrt(bound(1.0, attacker.cvar_cl_handicap, 100.0));
 428         }
 429
 430         if(DEATH_ISWEAPON(deathtype, WEP_TUBA))
 431         {
 432                 // tuba causes blood to come out of the ears
 433                 vector ear1, ear2;
 434                 vector d;
 435                 float f;
 436                 ear1 = self.origin;
 437                 ear1_z += 0.125 * self.view_ofs_z + 0.875 * self.maxs_z; // 7/8
 438                 ear2 = ear1;
 439                 makevectors(self.angles);
 440                 ear1 += v_right * -10;
 441                 ear2 += v_right * +10;
 442                 d = inflictor.origin - self.origin;
 443                 f = (d * v_right) / vlen(d); // this is cos of angle of d and v_right!
 444                 force = v_right * vlen(force);
 445                 Violence_GibSplash_At(ear1, force * -1, 2, bound(0, damage, 25) / 2 * (0.5 - 0.5 * f), self, attacker);
 446                 Violence_GibSplash_At(ear2, force,      2, bound(0, damage, 25) / 2 * (0.5 + 0.5 * f), self, attacker);
 447                 if(f > 0)
 448                 {
 449                         hitloc = ear1;
 450                         force = force * -1;
 451                 }
 452                 else
 453                 {
 454                         hitloc = ear2;
 455                         // force is already good
 456                 }
 457         }
 458         else
 459                 Violence_GibSplash_At(hitloc, force, 2, bound(0, damage, 200) / 16, self, attacker);
 460
 461         if (!g_minstagib)
 462         {
 463                 v = healtharmor_applydamage(self.armorvalue, autocvar_g_balance_armor_blockpercent, damage);
 464                 take = v_x;
 465                 save = v_y;
 466         }
 467         else
 468         {
 469                 save = 0;
 470                 take = damage;
 471         }
 472
 473         frag_inflictor = inflictor;
 474         frag_attacker = attacker;
 475         frag_target = self;
 476         damage_take = take;
 477         damage_save = save;
 478         damage_force = force;
 479         MUTATOR_CALLHOOK(PlayerDamage_SplitHealthArmor);
 480         take = bound(0, damage_take, self.health);
 481         save = bound(0, damage_save, self.armorvalue);
 482         excess = max(0, damage - take - save);
 483
 484         if(sound_allowed(MSG_BROADCAST, attacker))
 485         {
 486                 if (save > 10)
 487                         sound (self, CH_SHOTS, "misc/armorimpact.wav", VOL_BASE, ATTN_NORM);
 488                 else if (take > 30)
 489                         sound (self, CH_SHOTS, "misc/bodyimpact2.wav", VOL_BASE, ATTN_NORM);
 490                 else if (take > 10)
 491                         sound (self, CH_SHOTS, "misc/bodyimpact1.wav", VOL_BASE, ATTN_NORM); // FIXME possibly remove them?
 492         }
 493
 494         if (take > 50)
 495                 Violence_GibSplash_At(hitloc, force * -0.1, 3, 1, self, attacker);
 496         if (take > 100)
 497                 Violence_GibSplash_At(hitloc, force * -0.2, 3, 1, self, attacker);
 498
 499         if (time >= self.spawnshieldtime)
 500         {
 501                 if (!(self.flags & FL_GODMODE))
 502                 {
 503                         self.armorvalue = self.armorvalue - save;
 504                         self.health = self.health - take;
 505                         // pause regeneration for 5 seconds
 506                         self.pauseregen_finished = max(self.pauseregen_finished, time + autocvar_g_balance_pause_health_regen);
 507
 508                         if (time > self.pain_finished)          //Don't switch pain sequences like crazy
 509                         {
 510                                 self.pain_finished = time + 0.5;        //Supajoe
 511
 512                                 if(sv_gentle < 1) {
 513                                         if(self.classname != "body") // pain anim is BORKED on our ZYMs, FIXME remove this once we have good models
 514                                         {
 515                                                 if (random() > 0.5)
 516                                                         setanim(self, self.anim_pain1, FALSE, TRUE, TRUE);
 517                                                 else
 518                                                         setanim(self, self.anim_pain2, FALSE, TRUE, TRUE);
 519                                         }
 520
 521                                         if(sound_allowed(MSG_BROADCAST, attacker))
 522                                         if(!DEATH_ISWEAPON(deathtype, WEP_LASER) || attacker != self || self.health < 2 * autocvar_g_balance_laser_primary_damage * autocvar_g_balance_selfdamagepercent + 1)
 523                                         if(self.health > 1)
 524                                         // exclude pain sounds for laserjumps as long as you aren't REALLY low on health and would die of the next two
 525                                         {
 526                                                 if(deathtype == DEATH_FALL)
 527                                                         PlayerSound(playersound_fall, CH_PAIN, VOICETYPE_PLAYERSOUND);
 528                                                 else if(self.health > 75) // TODO make a "gentle" version?
 529                                                         PlayerSound(playersound_pain100, CH_PAIN, VOICETYPE_PLAYERSOUND);
 530                                                 else if(self.health > 50)
 531                                                         PlayerSound(playersound_pain75, CH_PAIN, VOICETYPE_PLAYERSOUND);
 532                                                 else if(self.health > 25)
 533                                                         PlayerSound(playersound_pain50, CH_PAIN, VOICETYPE_PLAYERSOUND);
 534                                                 else
 535                                                         PlayerSound(playersound_pain25, CH_PAIN, VOICETYPE_PLAYERSOUND);
 536                                         }
 537                                 }
 538
 539                                 // throw off bot aim temporarily
 540                                 local float shake;
 541                                 shake = damage * 5 / (bound(0,skill,100) + 1);
 542                                 self.v_angle_x = self.v_angle_x + (random() * 2 - 1) * shake;
 543                                 self.v_angle_y = self.v_angle_y + (random() * 2 - 1) * shake;
 544                         }
 545                 }
 546                 else
 547                         self.max_armorvalue += (save + take);
 548         }
 549         self.dmg_save = self.dmg_save + save;//max(save - 10, 0);
 550         self.dmg_take = self.dmg_take + take;//max(take - 10, 0);
 551         self.dmg_inflictor = inflictor;
 552
 553         if(attacker == self)
 554         {
 555                 // don't reset pushltime for self damage as it may be an attempt to
 556                 // escape a lava pit or similar
 557                 //self.pushltime = 0;
 558         }
 559         else if(attacker.classname == "player")
 560         {
 561                 self.pusher = attacker;
 562                 self.pushltime = time + autocvar_g_maxpushtime;
 563         }
 564         else if(time < self.pushltime)
 565         {
 566                 attacker = self.pusher;
 567                 self.pushltime = max(self.pushltime, time + 0.6);
 568         }
 569         else
 570                 self.pushltime = 0;
 571
 572         float abot, vbot, awep;
 573         abot = (clienttype(attacker) == CLIENTTYPE_BOT);
 574         vbot = (clienttype(self) == CLIENTTYPE_BOT);
 575
 576         valid_damage_for_weaponstats = 0;
 577         if(vbot || clienttype(self) == CLIENTTYPE_REAL)
 578         if(abot || clienttype(attacker) == CLIENTTYPE_REAL)
 579         if(attacker && self != attacker)
 580         if(IsDifferentTeam(self, attacker))
 581         {
 582                 if(DEATH_ISSPECIAL(deathtype))
 583                         awep = attacker.weapon;
 584                 else
 585                         awep = DEATH_WEAPONOF(deathtype);
 586                 valid_damage_for_weaponstats = 1;
 587         }
 588
 589         if(valid_damage_for_weaponstats)
 590         {
 591                 dh = dh - max(self.health, 0);
 592                 da = da - max(self.armorvalue, 0);
 593                 WeaponStats_LogDamage(awep, abot, self.weapon, vbot, dh + da);
 594         }
 595
 596         if (self.health < 1)
 597         {
 598                 float defer_ClientKill_Now_TeamChange;
 599                 defer_ClientKill_Now_TeamChange = FALSE;
 600
 601                 if(self.alivetime)
 602                 {
 603                         PlayerStats_Event(self, PLAYERSTATS_ALIVETIME, time - self.alivetime);
 604                         self.alivetime = 0;
 605                 }
 606
 607                 if(valid_damage_for_weaponstats)
 608                         WeaponStats_LogKill(awep, abot, self.weapon, vbot);
 609
 610                 if(sv_gentle < 1) // TODO make a "gentle" version?
 611                 if(sound_allowed(MSG_BROADCAST, attacker))
 612                 {
 613                         if(deathtype == DEATH_DROWN)
 614                                 PlayerSound(playersound_drown, CH_PAIN, VOICETYPE_PLAYERSOUND);
 615                         else
 616                                 PlayerSound(playersound_death, CH_PAIN, VOICETYPE_PLAYERSOUND);
 617                 }
 618
 619                 // get rid of kill indicator
 620                 if(self.killindicator)
 621                 {
 622                         remove(self.killindicator);
 623                         self.killindicator = world;
 624                         if(self.killindicator_teamchange)
 625                                 defer_ClientKill_Now_TeamChange = TRUE;
 626
 627                         if(self.classname == "body")
 628                         if(deathtype == DEATH_KILL)
 629                         {
 630                                 // for the lemmings fans, a small harmless explosion
 631                                 pointparticles(particleeffectnum("rocket_explode"), self.origin, '0 0 0', 1);
 632                         }
 633                 }
 634
 635                 if(!g_freezetag)
 636                 {
 637                         // become fully visible
 638                         self.alpha = 1;
 639                         // throw a weapon
 640                         SpawnThrownWeapon (self.origin + (self.mins + self.maxs) * 0.5, self.switchweapon);
 641                 }
 642
 643                 // print an obituary message
 644                 Obituary (attacker, inflictor, self, deathtype);
 645                 race_PreDie();
 646                 DropAllRunes(self);
 647
 648         // increment frag counter for used weapon type
 649         float w;
 650         w = DEATH_WEAPONOF(deathtype);
 651         if(WEP_VALID(w))
 652         if(self.classname == "player")
 653         if(self != attacker)
 654         attacker.accuracy.(accuracy_frags[w-1]) += 1;
 655
 656                 if(deathtype == DEATH_HURTTRIGGER && g_freezetag)
 657                 {
 658                         PutClientInServer();
 659                         count_alive_players(); // re-count players
 660                         freezetag_CheckWinner();
 661                         return;
 662                 }
 663
 664                 frag_attacker = attacker;
 665                 frag_inflictor = inflictor;
 666                 frag_target = self;
 667                 MUTATOR_CALLHOOK(PlayerDies);
 668                 weapon_action(self.weapon, WR_PLAYERDEATH);
 669
 670                 if(self.flagcarried)
 671                 {
 672                         if(attacker.classname != "player")
 673                                 DropFlag(self.flagcarried, self, attacker); // penalty for flag loss by suicide
 674                         else if(attacker.team == self.team)
 675                                 DropFlag(self.flagcarried, attacker, attacker); // penalty for flag loss by suicide/teamkill
 676                         else
 677                                 DropFlag(self.flagcarried, world, attacker);
 678                 }
 679                 if(self.ballcarried && g_nexball)
 680                         DropBall(self.ballcarried, self.origin, self.velocity);
 681                 Portal_ClearAllLater(self);
 682
 683                 if(clienttype(self) == CLIENTTYPE_REAL)
 684                 {
 685                         stuffcmd(self, "-zoom\n");
 686                         self.fixangle = TRUE;
 687                         //msg_entity = self;
 688                         //WriteByte (MSG_ONE, SVC_SETANGLE);
 689                         //WriteAngle (MSG_ONE, self.v_angle_x);
 690                         //WriteAngle (MSG_ONE, self.v_angle_y);
 691                         //WriteAngle (MSG_ONE, 80);
 692                 }
 693
 694                 if(defer_ClientKill_Now_TeamChange) // TODO does this work with FreezeTag?
 695                         ClientKill_Now_TeamChange();
 696
 697                 if(g_arena)
 698                         Spawnqueue_Unmark(self);
 699
 700                 if(g_freezetag)
 701                         return;
 702
 703                 // when we get here, player actually dies
 704                 // clear waypoints (do this AFTER FreezeTag)
 705                 WaypointSprite_PlayerDead();
 706
 707                 // make the corpse upright (not tilted)
 708                 self.angles_x = 0;
 709                 self.angles_z = 0;
 710                 // don't spin
 711                 self.avelocity = '0 0 0';
 712                 // view from the floor
 713                 self.view_ofs = '0 0 -8';
 714                 // toss the corpse
 715                 self.movetype = MOVETYPE_TOSS;
 716                 // shootable corpse
 717                 self.solid = SOLID_CORPSE;
 718                 self.ballistics_density = autocvar_g_ballistics_density_corpse;
 719                 // don't stick to the floor
 720                 self.flags &~= FL_ONGROUND;
 721                 // dying animation
 722                 self.deadflag = DEAD_DYING;
 723                 // when to allow respawn
 724                 sdelay = 0;
 725                 waves = 0;
 726                 sdelay = cvar(strcat("g_", GetGametype(), "_respawn_delay"));
 727                 if(!sdelay)
 728                 {
 729                         if(g_cts)
 730                                 sdelay = 0; // no respawn delay in CTS
 731                         else
 732                                 sdelay = autocvar_g_respawn_delay;
 733                 }
 734                 waves = cvar(strcat("g_", GetGametype(), "_respawn_waves"));
 735                 if(!waves)
 736                         waves = autocvar_g_respawn_waves;
 737                 if(waves)
 738                         self.death_time = ceil((time + sdelay) / waves) * waves;
 739                 else
 740                         self.death_time = time + sdelay;
 741                 if((sdelay + waves >= 5.0) && (self.death_time - time > 1.75))
 742                         self.respawn_countdown = 10; // first number to count down from is 10
 743                 else
 744                         self.respawn_countdown = -1; // do not count down
 745                 if (random() < 0.5)
 746                 {
 747                         setanim(self, self.anim_die1, FALSE, TRUE, TRUE);
 748                         self.dead_frame = self.anim_dead1_x;
 749                 }
 750                 else
 751                 {
 752                         setanim(self, self.anim_die2, FALSE, TRUE, TRUE);
 753                         self.dead_frame = self.anim_dead2_x;
 754                 }
 755                 // set damage function to corpse damage
 756                 self.event_damage = PlayerCorpseDamage;
 757                 // call the corpse damage function just in case it wants to gib
 758                 self.event_damage(inflictor, attacker, excess, deathtype, hitloc, force);
 759                 // set up to fade out later
 760                 SUB_SetFade (self, time + 6 + random (), 1);
 761
 762                 if(sv_gentle > 0 || autocvar_ekg) {
 763                         // remove corpse
 764                         PlayerCorpseDamage (inflictor, attacker, autocvar_sv_gibhealth+1.0, deathtype, hitloc, force);
 765                 }
 766
 767                 // reset fields the weapons may use just in case
 768                 for (j = WEP_FIRST; j <= WEP_LAST; ++j)
 769                 {
 770                         weapon_action(j, WR_RESETPLAYER);
 771                         ATTACK_FINISHED_FOR(self, j) = 0;
 772                 }
 773         }
 774 }
 775
 776 .float muted; // to be used by prvm_edictset server playernumber muted 1
 777 float Say(entity source, float teamsay, entity privatesay, string msgin, float floodcontrol)
 778 // message "": do not say, just test flood control
 779 // return value:
 780 //   1 = accept
 781 //   0 = reject
 782 //  -1 = fake accept
 783 {
 784         string msgstr, colorstr, cmsgstr, namestr, fullmsgstr, sourcemsgstr, fullcmsgstr, sourcecmsgstr, privatemsgprefix;
 785         float flood, privatemsgprefixlen;
 786         var .float flood_field;
 787         entity head;
 788         float ret;
 789
 790         if(Ban_MaybeEnforceBan(source))
 791                 return 0;
 792
 793         if(!teamsay && !privatesay)
 794                 if(substring(msgin, 0, 1) == " ")
 795                         msgin = substring(msgin, 1, strlen(msgin) - 1); // work around DP say bug (say_team does not have this!)
 796
 797         msgin = formatmessage(msgin);
 798
 799         if(source.classname != "player")
 800                 colorstr = "^0"; // black for spectators
 801         else if(teamplay)
 802                 colorstr = Team_ColorCode(source.team);
 803         else
 804                 teamsay = FALSE;
 805
 806         if(intermission_running)
 807                 teamsay = FALSE;
 808
 809         if(msgin != "")
 810                 msgin = trigger_magicear_processmessage_forallears(source, teamsay, privatesay, msgin);
 811
 812         /*
 813          * using bprint solves this... me stupid
 814         // how can we prevent the message from appearing in a listen server?
 815         // for now, just give "say" back and only handle say_team
 816         if(!teamsay)
 817         {
 818                 clientcommand(self, strcat("say ", msgin));
 819                 return;
 820         }
 821         */
 822
 823         if(autocvar_g_chat_teamcolors)
 824                 namestr = playername(source);
 825         else
 826                 namestr = source.netname;
 827
 828         if(msgin != "")
 829         {
 830                 if(privatesay)
 831                 {
 832                         msgstr = strcat("\{1}\{13}* ^3", namestr, "^3 tells you: ^7");
 833                         privatemsgprefixlen = strlen(msgstr);
 834                         msgstr = strcat(msgstr, msgin);
 835                         cmsgstr = strcat(colorstr, "^3", namestr, "^3 tells you:\n^7", msgin);
 836                         if(autocvar_g_chat_teamcolors)
 837                                 privatemsgprefix = strcat("\{1}\{13}* ^3You tell ", playername(privatesay), ": ^7");
 838                         else
 839                                 privatemsgprefix = strcat("\{1}\{13}* ^3You tell ", privatesay.netname, ": ^7");
 840                 }
 841                 else if(teamsay)
 842                 {
 843                         msgstr = strcat("\{1}\{13}", colorstr, "(^3", namestr, colorstr, ") ^7", msgin);
 844                         cmsgstr = strcat(colorstr, "(^3", namestr, colorstr, ")\n^7", msgin);
 845                 }
 846                 else
 847                 {
 848                         msgstr = strcat("\{1}", namestr, "^7: ", msgin);
 849                         cmsgstr = "";
 850                 }
 851                 msgstr = strcat(strreplace("\n", " ", msgstr), "\n"); // newlines only are good for centerprint
 852         }
 853         else
 854         {
 855                 msgstr = cmsgstr = "";
 856         }
 857
 858         fullmsgstr = msgstr;
 859         fullcmsgstr = cmsgstr;
 860
 861         // FLOOD CONTROL
 862         flood = 0;
 863         if(floodcontrol)
 864         {
 865                 float flood_spl;
 866                 float flood_burst;
 867                 float flood_lmax;
 868                 float lines;
 869                 if(privatesay)
 870                 {
 871                         flood_spl = autocvar_g_chat_flood_spl_tell;
 872                         flood_burst = autocvar_g_chat_flood_burst_tell;
 873                         flood_lmax = autocvar_g_chat_flood_lmax_tell;
 874                         flood_field = floodcontrol_chattell;
 875                 }
 876                 else if(teamsay)
 877                 {
 878                         flood_spl = autocvar_g_chat_flood_spl_team;
 879                         flood_burst = autocvar_g_chat_flood_burst_team;
 880                         flood_lmax = autocvar_g_chat_flood_lmax_team;
 881                         flood_field = floodcontrol_chatteam;
 882                 }
 883                 else
 884                 {
 885                         flood_spl = autocvar_g_chat_flood_spl;
 886                         flood_burst = autocvar_g_chat_flood_burst;
 887                         flood_lmax = autocvar_g_chat_flood_lmax;
 888                         flood_field = floodcontrol_chat;
 889                 }
 890                 flood_burst = max(0, flood_burst - 1);
 891                 // to match explanation in default.cfg, a value of 3 must allow three-line bursts and not four!
 892
 893                 // do flood control for the default line size
 894                 if(msgstr != "")
 895                 {
 896                         getWrappedLine_remaining = msgstr;
 897                         msgstr = "";
 898                         lines = 0;
 899                         while(getWrappedLine_remaining && (!flood_lmax || lines <= flood_lmax))
 900                         {
 901                                 msgstr = strcat(msgstr, " ", getWrappedLineLen(82.4289758859709, strlennocol)); // perl averagewidth.pl < gfx/vera-sans.width
 902                                 ++lines;
 903                         }
 904                         msgstr = substring(msgstr, 1, strlen(msgstr) - 1);
 905
 906                         if(getWrappedLine_remaining != "")
 907                         {
 908                                 msgstr = strcat(msgstr, "\n");
 909                                 flood = 2;
 910                         }
 911
 912                         if(time >= source.flood_field)
 913                         {
 914                                 source.flood_field = max(time - flood_burst * flood_spl, source.flood_field) + lines * flood_spl;
 915                         }
 916                         else
 917                         {
 918                                 flood = 1;
 919                                 msgstr = fullmsgstr;
 920                         }
 921                 }
 922                 else
 923                 {
 924                         if(time >= source.flood_field)
 925                                 source.flood_field = max(time - flood_burst * flood_spl, source.flood_field) + flood_spl;
 926                         else
 927                                 flood = 1;
 928                 }
 929
 930                 if (timeoutStatus == 2) //when game is paused, no flood protection
 931                         source.flood_field = flood = 0;
 932         }
 933
 934         if(flood == 2) // cannot happen for empty msgstr
 935         {
 936                 if(autocvar_g_chat_flood_notify_flooder)
 937                 {
 938                         sourcemsgstr = strcat(msgstr, "\n^3FLOOD CONTROL: ^7message too long, trimmed\n");
 939                         sourcecmsgstr = "";
 940                 }
 941                 else
 942                 {
 943                         sourcemsgstr = fullmsgstr;
 944                         sourcecmsgstr = fullcmsgstr;
 945                 }
 946                 cmsgstr = "";
 947         }
 948         else
 949         {
 950                 sourcemsgstr = msgstr;
 951                 sourcecmsgstr = cmsgstr;
 952         }
 953
 954         if(!privatesay)
 955         if(source.classname != "player")
 956         {
 957                 if(teamsay || (autocvar_g_chat_nospectators == 1) || (autocvar_g_chat_nospectators == 2 && !inWarmupStage))
 958                         teamsay = -1; // spectators
 959         }
 960
 961         if(flood)
 962                 print("NOTE: ", playername(source), "^7 is flooding.\n");
 963
 964         // build sourcemsgstr by cutting off a prefix and replacing it by the other one
 965         if(privatesay)
 966                 sourcemsgstr = strcat(privatemsgprefix, substring(sourcemsgstr, privatemsgprefixlen, -1));
 967
 968         if(source.muted)
 969         {
 970                 // always fake the message
 971                 ret = -1;
 972         }
 973         else if(flood == 1)
 974         {
 975                 if(autocvar_g_chat_flood_notify_flooder)
 976                 {
 977                         sprint(source, strcat("^3FLOOD CONTROL: ^7wait ^1", ftos(source.flood_field - time), "^3 seconds\n"));
 978                         ret = 0;
 979                 }
 980                 else
 981                         ret = -1;
 982         }
 983         else
 984         {
 985                 ret = 1;
 986         }
 987
 988         if(sourcemsgstr != "" && ret != 0)
 989         {
 990                 if(ret < 0) // fake
 991                 {
 992                         sprint(source, sourcemsgstr);
 993                         if(sourcecmsgstr != "" && !privatesay)
 994                                 centerprint(source, sourcecmsgstr);
 995                 }
 996                 else if(privatesay)
 997                 {
 998                         sprint(source, sourcemsgstr);
 999                         sprint(privatesay, msgstr);
1000                         if(cmsgstr != "")
1001                                 centerprint(privatesay, cmsgstr);
1002                 }
1003                 else if(teamsay > 0)
1004                 {
1005                         sprint(source, sourcemsgstr);
1006                         if(sourcecmsgstr != "")
1007                                 centerprint(source, sourcecmsgstr);
1008                         FOR_EACH_REALPLAYER(head) if(head.team == source.team)
1009                                 if(head != source)
1010                                 {
1011                                         sprint(head, msgstr);
1012                                         if(cmsgstr != "")
1013                                                 centerprint(head, cmsgstr);
1014                                 }
1015                 }
1016                 else if(teamsay < 0)
1017                 {
1018                         sprint(source, sourcemsgstr);
1019                         FOR_EACH_REALCLIENT(head) if(head.classname != "player")
1020                                 if(head != source)
1021                                         sprint(head, msgstr);
1022                 }
1023                 else if(sourcemsgstr != msgstr)
1024                 {
1025                         sprint(source, sourcemsgstr);
1026                         FOR_EACH_REALCLIENT(head)
1027                                 if(head != source)
1028                                         sprint(head, msgstr);
1029                 }
1030                 else
1031                         bprint(msgstr);
1032         }
1033
1034         return ret;
1035 }
1036
1037 float GetVoiceMessageVoiceType(string type)
1038 {
1039         if(type == "taunt")
1040                 return VOICETYPE_TAUNT;
1041         if(type == "teamshoot")
1042                 return VOICETYPE_LASTATTACKER;
1043         return VOICETYPE_TEAMRADIO;
1044 }
1045
1046 string allvoicesamples;
1047 .string GetVoiceMessageSampleField(string type)
1048 {
1049         GetPlayerSoundSampleField_notFound = 0;
1050         switch(type)
1051         {
1052 #define _VOICEMSG(m) case #m: return playersound_##m;
1053                 ALLVOICEMSGS
1054 #undef _VOICEMSG
1055         }
1056         GetPlayerSoundSampleField_notFound = 1;
1057         return playersound_taunt;
1058 }
1059
1060 .string GetPlayerSoundSampleField(string type)
1061 {
1062         GetPlayerSoundSampleField_notFound = 0;
1063         switch(type)
1064         {
1065 #define _VOICEMSG(m) case #m: return playersound_##m;
1066                 ALLPLAYERSOUNDS
1067 #undef _VOICEMSG
1068         }
1069         GetPlayerSoundSampleField_notFound = 1;
1070         return playersound_taunt;
1071 }
1072
1073 void PrecacheGlobalSound(string samplestring)
1074 {
1075         float n, i;
1076         tokenize_console(samplestring);
1077         n = stof(argv(1));
1078         if(n > 0)
1079         {
1080                 for(i = 1; i <= n; ++i)
1081                         precache_sound(strcat(argv(0), ftos(i), ".wav"));
1082         }
1083         else
1084         {
1085                 precache_sound(strcat(argv(0), ".wav"));
1086         }
1087 }
1088
1089 void PrecachePlayerSounds(string f)
1090 {
1091         float fh;
1092         string s;
1093         fh = fopen(f, FILE_READ);
1094         if(fh < 0)
1095                 return;
1096         while((s = fgets(fh)))
1097         {
1098                 if(tokenize_console(s) != 3)
1099                 {
1100                         dprint("Invalid sound info line: ", s, "\n");
1101                         continue;
1102                 }
1103                 PrecacheGlobalSound(strcat(argv(1), " ", argv(2)));
1104         }
1105         fclose(fh);
1106
1107         if not(allvoicesamples)
1108         {
1109 #define _VOICEMSG(m) allvoicesamples = strcat(allvoicesamples, " ", #m);
1110                 ALLVOICEMSGS
1111 #undef _VOICEMSG
1112                 allvoicesamples = strzone(substring(allvoicesamples, 1, strlen(allvoicesamples) - 1));
1113         }
1114 }
1115
1116 void ClearPlayerSounds()
1117 {
1118 #define _VOICEMSG(m) if(self.playersound_##m) { strunzone(self.playersound_##m); self.playersound_##m = string_null; }
1119         ALLPLAYERSOUNDS
1120         ALLVOICEMSGS
1121 #undef _VOICEMSG
1122 }
1123
1124 float LoadPlayerSounds(string f, float first)
1125 {
1126         float fh;
1127         string s;
1128         var .string field;
1129         fh = fopen(f, FILE_READ);
1130         if(fh < 0)
1131         {
1132                 dprint("Player sound file not found: ", f, "\n");
1133                 return 0;
1134         }
1135         while((s = fgets(fh)))
1136         {
1137                 if(tokenize_console(s) != 3)
1138                         continue;
1139                 field = GetPlayerSoundSampleField(argv(0));
1140                 if(GetPlayerSoundSampleField_notFound)
1141                         field = GetVoiceMessageSampleField(argv(0));
1142                 if(GetPlayerSoundSampleField_notFound)
1143                         continue;
1144                 if(self.field)
1145                         strunzone(self.field);
1146                 self.field = strzone(strcat(argv(1), " ", argv(2)));
1147         }
1148         fclose(fh);
1149         return 1;
1150 }
1151
1152 .float modelindex_for_playersound;
1153 .float skinindex_for_playersound;
1154 void UpdatePlayerSounds()
1155 {
1156         if(self.modelindex == self.modelindex_for_playersound)
1157         if(self.skinindex == self.skinindex_for_playersound)
1158                 return;
1159         self.modelindex_for_playersound = self.modelindex;
1160         self.skinindex_for_playersound = self.skinindex;
1161         ClearPlayerSounds();
1162         LoadPlayerSounds("sound/player/default.sounds", 1);
1163         if(!autocvar_g_debug_defaultsounds)
1164                 if(!LoadPlayerSounds(get_model_datafilename(self.model, self.skinindex, "sounds"), 0))
1165                         LoadPlayerSounds(get_model_datafilename(self.model, 0, "sounds"), 0);
1166 }
1167
1168 void FakeGlobalSound(string sample, float chan, float voicetype)
1169 {
1170         float n;
1171         float tauntrand;
1172
1173         if(sample == "")
1174                 return;
1175
1176         tokenize_console(sample);
1177         n = stof(argv(1));
1178         if(n > 0)
1179                 sample = strcat(argv(0), ftos(floor(random() * n + 1)), ".wav"); // randomization
1180         else
1181                 sample = strcat(argv(0), ".wav"); // randomization
1182
1183         switch(voicetype)
1184         {
1185                 case VOICETYPE_LASTATTACKER_ONLY:
1186                         break;
1187                 case VOICETYPE_LASTATTACKER:
1188                         if(self.pusher)
1189                         {
1190                                 msg_entity = self;
1191                                 if(clienttype(msg_entity) == CLIENTTYPE_REAL)
1192                                         soundto(MSG_ONE, self, chan, sample, VOL_BASE, ATTN_NONE);
1193                         }
1194                         break;
1195                 case VOICETYPE_TEAMRADIO:
1196                         msg_entity = self;
1197                         if(msg_entity.cvar_cl_voice_directional == 1)
1198                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_MIN);
1199                         else
1200                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_NONE);
1201                         break;
1202                 case VOICETYPE_AUTOTAUNT:
1203                         if(!sv_autotaunt)
1204                                 break;
1205                         if(!sv_taunt)
1206                                 break;
1207                         if(sv_gentle)
1208                                 break;
1209                         tauntrand = random();
1210                         msg_entity = self;
1211                         if (tauntrand < msg_entity.cvar_cl_autotaunt)
1212                         {
1213                                 if (msg_entity.cvar_cl_voice_directional >= 1)
1214                                         soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, bound(ATTN_MIN, msg_entity.cvar_cl_voice_directional_taunt_attenuation, ATTN_MAX));
1215                                 else
1216                                         soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_NONE);
1217                         }
1218                         break;
1219                 case VOICETYPE_TAUNT:
1220                         if(self.classname == "player")
1221                                 if(self.deadflag == DEAD_NO)
1222                                         setanim(self, self.anim_taunt, FALSE, TRUE, TRUE);
1223                         if(!sv_taunt)
1224                                 break;
1225                         if(sv_gentle)
1226                                 break;
1227                         msg_entity = self;
1228                         if (msg_entity.cvar_cl_voice_directional >= 1)
1229                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, bound(ATTN_MIN, msg_entity.cvar_cl_voice_directional_taunt_attenuation, ATTN_MAX));
1230                         else
1231                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_NONE);
1232                         break;
1233                 case VOICETYPE_PLAYERSOUND:
1234                         msg_entity = self;
1235                         soundto(MSG_ONE, self, chan, sample, VOL_BASE, ATTN_NORM);
1236                         break;
1237                 default:
1238                         backtrace("Invalid voice type!");
1239                         break;
1240         }
1241 }
1242
1243 void GlobalSound(string sample, float chan, float voicetype)
1244 {
1245         float n;
1246         float tauntrand;
1247
1248         if(sample == "")
1249                 return;
1250
1251         tokenize_console(sample);
1252         n = stof(argv(1));
1253         if(n > 0)
1254                 sample = strcat(argv(0), ftos(floor(random() * n + 1)), ".wav"); // randomization
1255         else
1256                 sample = strcat(argv(0), ".wav"); // randomization
1257
1258         switch(voicetype)
1259         {
1260                 case VOICETYPE_LASTATTACKER_ONLY:
1261                         if(self.pusher)
1262                         {
1263                                 msg_entity = self.pusher;
1264                                 if(clienttype(msg_entity) == CLIENTTYPE_REAL)
1265                                 {
1266                                         if(msg_entity.cvar_cl_voice_directional == 1)
1267                                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_MIN);
1268                                         else
1269                                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_NONE);
1270                                 }
1271                         }
1272                         break;
1273                 case VOICETYPE_LASTATTACKER:
1274                         if(self.pusher)
1275                         {
1276                                 msg_entity = self.pusher;
1277                                 if(clienttype(msg_entity) == CLIENTTYPE_REAL)
1278                                 {
1279                                         if(msg_entity.cvar_cl_voice_directional == 1)
1280                                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_MIN);
1281                                         else
1282                                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_NONE);
1283                                 }
1284                                 msg_entity = self;
1285                                 if(clienttype(msg_entity) == CLIENTTYPE_REAL)
1286                                         soundto(MSG_ONE, self, chan, sample, VOL_BASE, ATTN_NONE);
1287                         }
1288                         break;
1289                 case VOICETYPE_TEAMRADIO:
1290                         FOR_EACH_REALCLIENT(msg_entity)
1291                                 if(!teamplay || msg_entity.team == self.team)
1292                                 {
1293                                         if(msg_entity.cvar_cl_voice_directional == 1)
1294                                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_MIN);
1295                                         else
1296                                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_NONE);
1297                                 }
1298                         break;
1299                 case VOICETYPE_AUTOTAUNT:
1300                         if(!sv_autotaunt)
1301                                 break;
1302                         if(!sv_taunt)
1303                                 break;
1304                         if(sv_gentle)
1305                                 break;
1306                         tauntrand = random();
1307                         FOR_EACH_REALCLIENT(msg_entity)
1308                                 if (tauntrand < msg_entity.cvar_cl_autotaunt)
1309                                 {
1310                                         if (msg_entity.cvar_cl_voice_directional >= 1)
1311                                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, bound(ATTN_MIN, msg_entity.cvar_cl_voice_directional_taunt_attenuation, ATTN_MAX));
1312                                         else
1313                                                 soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_NONE);
1314                                 }
1315                         break;
1316                 case VOICETYPE_TAUNT:
1317                         if(self.classname == "player")
1318                                 if(self.deadflag == DEAD_NO)
1319                                         setanim(self, self.anim_taunt, FALSE, TRUE, TRUE);
1320                         if(!sv_taunt)
1321                                 break;
1322                         if(sv_gentle)
1323                                 break;
1324                         FOR_EACH_REALCLIENT(msg_entity)
1325                         {
1326                                 if (msg_entity.cvar_cl_voice_directional >= 1)
1327                                         soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, bound(ATTN_MIN, msg_entity.cvar_cl_voice_directional_taunt_attenuation, ATTN_MAX));
1328                                 else
1329                                         soundto(MSG_ONE, self, chan, sample, VOL_BASEVOICE, ATTN_NONE);
1330                         }
1331                         break;
1332                 case VOICETYPE_PLAYERSOUND:
1333                         sound(self, chan, sample, VOL_BASE, ATTN_NORM);
1334                         break;
1335                 default:
1336                         backtrace("Invalid voice type!");
1337                         break;
1338         }
1339 }
1340
1341 void PlayerSound(.string samplefield, float chan, float voicetype)
1342 {
1343         GlobalSound(self.samplefield, chan, voicetype);
1344 }
1345
1346 void VoiceMessage(string type, string msg)
1347 {
1348         var .string sample;
1349         float voicetype, ownteam;
1350         float flood;
1351         sample = GetVoiceMessageSampleField(type);
1352
1353         if(GetPlayerSoundSampleField_notFound)
1354         {
1355                 sprint(self, strcat("Invalid voice. Use one of: ", allvoicesamples, "\n"));
1356                 return;
1357         }
1358
1359         voicetype = GetVoiceMessageVoiceType(type);
1360         ownteam = (voicetype == VOICETYPE_TEAMRADIO);
1361
1362         flood = Say(self, ownteam, world, msg, 1);
1363
1364         if (flood > 0)
1365                 GlobalSound(self.sample, CH_VOICE, voicetype);
1366         else if (flood < 0)
1367                 FakeGlobalSound(self.sample, CH_VOICE, voicetype);
1368 }
1369
1370 void MoveToTeam(entity client, float team_colour, float type, float show_message)
1371 {
1372 //      show_message
1373 //      0 (00) automove centerprint, admin message
1374 //      1 (01) automove centerprint, no admin message
1375 //      2 (10) no centerprint, admin message
1376 //      3 (11) no centerprint, no admin message
1377
1378         float lockteams_backup;
1379
1380         lockteams_backup = lockteams;  // backup any team lock
1381
1382         lockteams = 0;  // disable locked teams
1383
1384         TeamchangeFrags(client);  // move the players frags
1385         SetPlayerColors(client, team_colour - 1);  // set the players colour
1386         Damage(client, client, client, 100000, ((show_message & 2) ? DEATH_QUIET : DEATH_AUTOTEAMCHANGE), client.origin, '0 0 0');  // kill the player
1387
1388         lockteams = lockteams_backup;  // restore the team lock
1389
1390         LogTeamchange(client.playerid, client.team, type);
1391
1392         if not(show_message & 1) // admin message
1393                 sprint(client, strcat("\{1}\{13}^3", admin_name(), "^7: You have been moved to the ", Team_ColorNameLowerCase(team_colour), " team\n"));  // send a chat message
1394
1395         bprint(strcat(client.netname, " joined the ", ColoredTeamName(client.team), "\n"));
1396 }