sv_send.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20
  21 #include "quakedef.h"
  22 #include "sv_demo.h"
  23
  24 extern cvar_t sv_airaccel_qw_stretchfactor;
  25 extern cvar_t sv_gameplayfix_customstats;
  26 extern cvar_t sv_warsowbunny_airforwardaccel;
  27 extern cvar_t sv_warsowbunny_accel;
  28 extern cvar_t sv_warsowbunny_topspeed;
  29 extern cvar_t sv_warsowbunny_turnaccel;
  30 extern cvar_t sv_warsowbunny_backtosideratio;
  31 extern cvar_t sv_onlycsqcnetworking;
  32 extern cvar_t sv_cullentities_trace_entityocclusion;
  33 extern cvar_t sv_cullentities_trace_samples_players;
  34 extern cvar_t sv_cullentities_trace_eyejitter;
  35 extern cvar_t sv_cullentities_trace_expand;
  36 extern cvar_t sv_cullentities_trace_delay_players;
  37
  38 /*
  39 =============================================================================
  40
  41 EVENT MESSAGES
  42
  43 =============================================================================
  44 */
  45
  46 /*
  47 =================
  48 SV_ClientPrint
  49
  50 Sends text across to be displayed
  51 FIXME: make this just a stuffed echo?
  52 =================
  53 */
  54 void SV_ClientPrint(const char *msg)
  55 {
  56         if (host_client->netconnection)
  57         {
  58                 MSG_WriteByte(&host_client->netconnection->message, svc_print);
  59                 MSG_WriteString(&host_client->netconnection->message, msg);
  60         }
  61 }
  62
  63 /*
  64 =================
  65 SV_ClientPrintf
  66
  67 Sends text across to be displayed
  68 FIXME: make this just a stuffed echo?
  69 =================
  70 */
  71 void SV_ClientPrintf(const char *fmt, ...)
  72 {
  73         va_list argptr;
  74         char msg[MAX_INPUTLINE];
  75
  76         va_start(argptr,fmt);
  77         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
  78         va_end(argptr);
  79
  80         SV_ClientPrint(msg);
  81 }
  82
  83 /*
  84 =================
  85 SV_BroadcastPrint
  86
  87 Sends text to all active clients
  88 =================
  89 */
  90 void SV_BroadcastPrint(const char *msg)
  91 {
  92         int i;
  93         client_t *client;
  94
  95         for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
  96         {
  97                 if (client->active && client->netconnection)
  98                 {
  99                         MSG_WriteByte(&client->netconnection->message, svc_print);
 100                         MSG_WriteString(&client->netconnection->message, msg);
 101                 }
 102         }
 103
 104         if (sv_echobprint.integer && !host_isclient.integer)
 105                 Con_Print(msg);
 106 }
 107
 108 /*
 109 =================
 110 SV_BroadcastPrintf
 111
 112 Sends text to all active clients
 113 =================
 114 */
 115 void SV_BroadcastPrintf(const char *fmt, ...)
 116 {
 117         va_list argptr;
 118         char msg[MAX_INPUTLINE];
 119
 120         va_start(argptr,fmt);
 121         dpvsnprintf(msg,sizeof(msg),fmt,argptr);
 122         va_end(argptr);
 123
 124         SV_BroadcastPrint(msg);
 125 }
 126
 127 /*
 128 =================
 129 SV_ClientCommands
 130
 131 Send text over to the client to be executed
 132 =================
 133 */
 134 void SV_ClientCommands(const char *fmt, ...)
 135 {
 136         va_list argptr;
 137         char string[MAX_INPUTLINE];
 138
 139         if (!host_client->netconnection)
 140                 return;
 141
 142         va_start(argptr,fmt);
 143         dpvsnprintf(string, sizeof(string), fmt, argptr);
 144         va_end(argptr);
 145
 146         MSG_WriteByte(&host_client->netconnection->message, svc_stufftext);
 147         MSG_WriteString(&host_client->netconnection->message, string);
 148 }
 149
 150 /*
 151 ==================
 152 SV_StartParticle
 153
 154 Make sure the event gets sent to all clients
 155 ==================
 156 */
 157 void SV_StartParticle (vec3_t org, vec3_t dir, int color, int count)
 158 {
 159         int i;
 160
 161         if (sv.datagram.cursize > MAX_PACKETFRAGMENT-18)
 162                 return;
 163         MSG_WriteByte (&sv.datagram, svc_particle);
 164         MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
 165         MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
 166         MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
 167         for (i=0 ; i<3 ; i++)
 168                 MSG_WriteChar (&sv.datagram, (int)bound(-128, dir[i]*16, 127));
 169         MSG_WriteByte (&sv.datagram, count);
 170         MSG_WriteByte (&sv.datagram, color);
 171         SV_FlushBroadcastMessages();
 172 }
 173
 174 /*
 175 ==================
 176 SV_StartEffect
 177
 178 Make sure the event gets sent to all clients
 179 ==================
 180 */
 181 void SV_StartEffect (vec3_t org, int modelindex, int startframe, int framecount, int framerate)
 182 {
 183         if (modelindex >= 256 || startframe >= 256)
 184         {
 185                 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-19)
 186                         return;
 187                 MSG_WriteByte (&sv.datagram, svc_effect2);
 188                 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
 189                 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
 190                 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
 191                 MSG_WriteShort (&sv.datagram, modelindex);
 192                 MSG_WriteShort (&sv.datagram, startframe);
 193                 MSG_WriteByte (&sv.datagram, framecount);
 194                 MSG_WriteByte (&sv.datagram, framerate);
 195         }
 196         else
 197         {
 198                 if (sv.datagram.cursize > MAX_PACKETFRAGMENT-17)
 199                         return;
 200                 MSG_WriteByte (&sv.datagram, svc_effect);
 201                 MSG_WriteCoord (&sv.datagram, org[0], sv.protocol);
 202                 MSG_WriteCoord (&sv.datagram, org[1], sv.protocol);
 203                 MSG_WriteCoord (&sv.datagram, org[2], sv.protocol);
 204                 MSG_WriteByte (&sv.datagram, modelindex);
 205                 MSG_WriteByte (&sv.datagram, startframe);
 206                 MSG_WriteByte (&sv.datagram, framecount);
 207                 MSG_WriteByte (&sv.datagram, framerate);
 208         }
 209         SV_FlushBroadcastMessages();
 210 }
 211
 212 /*
 213 ==================
 214 SV_StartSound
 215
 216 Each entity can have eight independant sound sources, like voice,
 217 weapon, feet, etc.
 218
 219 Channel 0 is an auto-allocate channel, the others override anything
 220 already running on that entity/channel pair.
 221
 222 An attenuation of 0 will play full volume everywhere in the level.
 223 Larger attenuations will drop off.  (max 4 attenuation)
 224
 225 ==================
 226 */
 227 void SV_StartSound (prvm_edict_t *entity, int channel, const char *sample, int nvolume, float attenuation, qbool reliable, float speed)
 228 {
 229         prvm_prog_t *prog = SVVM_prog;
 230         sizebuf_t *dest;
 231         int sound_num, field_mask, i, ent, speed4000;
 232
 233         dest = (reliable ? &sv.reliable_datagram : &sv.datagram);
 234
 235         if (nvolume < 0 || nvolume > 255)
 236         {
 237                 Con_Printf ("SV_StartSound: volume = %i\n", nvolume);
 238                 return;
 239         }
 240
 241         if (attenuation < 0 || attenuation > 4)
 242         {
 243                 Con_Printf ("SV_StartSound: attenuation = %f\n", attenuation);
 244                 return;
 245         }
 246
 247         if (!IS_CHAN(channel))
 248         {
 249                 Con_Printf ("SV_StartSound: channel = %i\n", channel);
 250                 return;
 251         }
 252
 253         channel = CHAN_ENGINE2NET(channel);
 254
 255         if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
 256                 return;
 257
 258 // find precache number for sound
 259         sound_num = SV_SoundIndex(sample, 1);
 260         if (!sound_num)
 261                 return;
 262
 263         ent = PRVM_NUM_FOR_EDICT(entity);
 264
 265         speed4000 = (int)floor(speed * 4000.0f + 0.5f);
 266         field_mask = 0;
 267         if (nvolume != DEFAULT_SOUND_PACKET_VOLUME)
 268                 field_mask |= SND_VOLUME;
 269         if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
 270                 field_mask |= SND_ATTENUATION;
 271         if (speed4000 && speed4000 != 4000)
 272                 field_mask |= SND_SPEEDUSHORT4000;
 273         if (ent >= 8192 || channel < 0 || channel > 7)
 274                 field_mask |= SND_LARGEENTITY;
 275         if (sound_num >= 256)
 276                 field_mask |= SND_LARGESOUND;
 277
 278 // directed messages go only to the entity they are targeted on
 279         MSG_WriteByte (dest, svc_sound);
 280         MSG_WriteByte (dest, field_mask);
 281         if (field_mask & SND_VOLUME)
 282                 MSG_WriteByte (dest, nvolume);
 283         if (field_mask & SND_ATTENUATION)
 284                 MSG_WriteByte (dest, (int)(attenuation*64));
 285         if (field_mask & SND_SPEEDUSHORT4000)
 286                 MSG_WriteShort (dest, speed4000);
 287         if (field_mask & SND_LARGEENTITY)
 288         {
 289                 MSG_WriteShort (dest, ent);
 290                 MSG_WriteChar (dest, channel);
 291         }
 292         else
 293                 MSG_WriteShort (dest, (ent<<3) | channel);
 294         if ((field_mask & SND_LARGESOUND) || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
 295                 MSG_WriteShort (dest, sound_num);
 296         else
 297                 MSG_WriteByte (dest, sound_num);
 298         for (i = 0;i < 3;i++)
 299                 MSG_WriteCoord (dest, PRVM_serveredictvector(entity, origin)[i]+0.5*(PRVM_serveredictvector(entity, mins)[i]+PRVM_serveredictvector(entity, maxs)[i]), sv.protocol);
 300
 301         // TODO do we have to do anything here when dest is &sv.reliable_datagram?
 302         if(!reliable)
 303                 SV_FlushBroadcastMessages();
 304 }
 305
 306 /*
 307 ==================
 308 SV_StartPointSound
 309
 310 Nearly the same logic as SV_StartSound, except an origin
 311 instead of an entity is provided and channel is omitted.
 312
 313 The entity sent to the client is 0 (world) and the channel
 314 is 0 (CHAN_AUTO).  SND_LARGEENTITY will never occur in this
 315 function, therefore the check for it is omitted.
 316
 317 ==================
 318 */
 319 void SV_StartPointSound (vec3_t origin, const char *sample, int nvolume, float attenuation, float speed)
 320 {
 321         int sound_num, field_mask, i, speed4000;
 322
 323         if (nvolume < 0 || nvolume > 255)
 324         {
 325                 Con_Printf ("SV_StartPointSound: volume = %i\n", nvolume);
 326                 return;
 327         }
 328
 329         if (attenuation < 0 || attenuation > 4)
 330         {
 331                 Con_Printf ("SV_StartPointSound: attenuation = %f\n", attenuation);
 332                 return;
 333         }
 334
 335         if (sv.datagram.cursize > MAX_PACKETFRAGMENT-21)
 336                 return;
 337
 338         // find precache number for sound
 339         sound_num = SV_SoundIndex(sample, 1);
 340         if (!sound_num)
 341                 return;
 342
 343         speed4000 = (int)(speed * 40.0f);
 344         field_mask = 0;
 345         if (nvolume != DEFAULT_SOUND_PACKET_VOLUME)
 346                 field_mask |= SND_VOLUME;
 347         if (attenuation != DEFAULT_SOUND_PACKET_ATTENUATION)
 348                 field_mask |= SND_ATTENUATION;
 349         if (sound_num >= 256)
 350                 field_mask |= SND_LARGESOUND;
 351         if (speed4000 && speed4000 != 4000)
 352                 field_mask |= SND_SPEEDUSHORT4000;
 353
 354 // directed messages go only to the entity they are targeted on
 355         MSG_WriteByte (&sv.datagram, svc_sound);
 356         MSG_WriteByte (&sv.datagram, field_mask);
 357         if (field_mask & SND_VOLUME)
 358                 MSG_WriteByte (&sv.datagram, nvolume);
 359         if (field_mask & SND_ATTENUATION)
 360                 MSG_WriteByte (&sv.datagram, (int)(attenuation*64));
 361         if (field_mask & SND_SPEEDUSHORT4000)
 362                 MSG_WriteShort (&sv.datagram, speed4000);
 363         // Always write entnum 0 for the world entity
 364         MSG_WriteShort (&sv.datagram, (0<<3) | 0);
 365         if (field_mask & SND_LARGESOUND)
 366                 MSG_WriteShort (&sv.datagram, sound_num);
 367         else
 368                 MSG_WriteByte (&sv.datagram, sound_num);
 369         for (i = 0;i < 3;i++)
 370                 MSG_WriteCoord (&sv.datagram, origin[i], sv.protocol);
 371         SV_FlushBroadcastMessages();
 372 }
 373
 374 /*
 375 ===============================================================================
 376
 377 FRAME UPDATES
 378
 379 ===============================================================================
 380 */
 381
 382 /*
 383 =============================================================================
 384
 385 The PVS must include a small area around the client to allow head bobbing
 386 or other small motion on the client side.  Otherwise, a bob might cause an
 387 entity that should be visible to not show up, especially when the bob
 388 crosses a waterline.
 389
 390 =============================================================================
 391 */
 392
 393 static qbool SV_PrepareEntityForSending (prvm_edict_t *ent, entity_state_t *cs, int enumber)
 394 {
 395         prvm_prog_t *prog = SVVM_prog;
 396         int i;
 397         int csqcflags;
 398         unsigned int sendflags;
 399         unsigned int version;
 400         unsigned int modelindex, effects, flags, glowsize, lightstyle, lightpflags, light[4], specialvisibilityradius;
 401         unsigned int customizeentityforclient;
 402         unsigned int sendentity;
 403         float f;
 404         prvm_vec_t *v;
 405         vec3_t cullmins, cullmaxs;
 406         model_t *model;
 407
 408         // fast path for games that do not use legacy entity networking
 409         // note: still networks clients even if they are legacy
 410         sendentity = PRVM_serveredictfunction(ent, SendEntity);
 411         if (sv_onlycsqcnetworking.integer && !sendentity && enumber > svs.maxclients)
 412                 return false;
 413
 414         // this 2 billion unit check is actually to detect NAN origins
 415         // (we really don't want to send those)
 416         if (!(VectorLength2(PRVM_serveredictvector(ent, origin)) < 2000000000.0*2000000000.0))
 417                 return false;
 418
 419         // EF_NODRAW prevents sending for any reason except for your own
 420         // client, so we must keep all clients in this superset
 421         effects = (unsigned)PRVM_serveredictfloat(ent, effects);
 422
 423         // we can omit invisible entities with no effects that are not clients
 424         // LadyHavoc: this could kill tags attached to an invisible entity, I
 425         // just hope we never have to support that case
 426         i = (int)PRVM_serveredictfloat(ent, modelindex);
 427         modelindex = (i >= 1 && i < MAX_MODELS && PRVM_serveredictstring(ent, model) && *PRVM_GetString(prog, PRVM_serveredictstring(ent, model)) && sv.models[i]) ? i : 0;
 428
 429         flags = 0;
 430         i = (int)(PRVM_serveredictfloat(ent, glow_size) * 0.25f);
 431         glowsize = (unsigned char)bound(0, i, 255);
 432         if (PRVM_serveredictfloat(ent, glow_trail))
 433                 flags |= RENDER_GLOWTRAIL;
 434         if (PRVM_serveredictedict(ent, viewmodelforclient))
 435                 flags |= RENDER_VIEWMODEL;
 436
 437         v = PRVM_serveredictvector(ent, color);
 438         f = v[0]*256;
 439         light[0] = (unsigned short)bound(0, f, 65535);
 440         f = v[1]*256;
 441         light[1] = (unsigned short)bound(0, f, 65535);
 442         f = v[2]*256;
 443         light[2] = (unsigned short)bound(0, f, 65535);
 444         f = PRVM_serveredictfloat(ent, light_lev);
 445         light[3] = (unsigned short)bound(0, f, 65535);
 446         lightstyle = (unsigned char)PRVM_serveredictfloat(ent, style);
 447         lightpflags = (unsigned char)PRVM_serveredictfloat(ent, pflags);
 448
 449         if (gamemode == GAME_TENEBRAE)
 450         {
 451                 // tenebrae's EF_FULLDYNAMIC conflicts with Q2's EF_NODRAW
 452                 if (effects & 16)
 453                 {
 454                         effects &= ~16;
 455                         lightpflags |= PFLAGS_FULLDYNAMIC;
 456                 }
 457                 // tenebrae's EF_GREEN conflicts with DP's EF_ADDITIVE
 458                 if (effects & 32)
 459                 {
 460                         effects &= ~32;
 461                         light[0] = (int)(0.2*256);
 462                         light[1] = (int)(1.0*256);
 463                         light[2] = (int)(0.2*256);
 464                         light[3] = 200;
 465                         lightpflags |= PFLAGS_FULLDYNAMIC;
 466                 }
 467         }
 468
 469         specialvisibilityradius = 0;
 470         if (lightpflags & PFLAGS_FULLDYNAMIC)
 471                 specialvisibilityradius = max(specialvisibilityradius, light[3]);
 472         if (glowsize)
 473                 specialvisibilityradius = max(specialvisibilityradius, glowsize * 4);
 474         if (flags & RENDER_GLOWTRAIL)
 475                 specialvisibilityradius = max(specialvisibilityradius, 100);
 476         if (effects & (EF_BRIGHTFIELD | EF_MUZZLEFLASH | EF_BRIGHTLIGHT | EF_DIMLIGHT | EF_RED | EF_BLUE | EF_FLAME | EF_STARDUST))
 477         {
 478                 if (effects & EF_BRIGHTFIELD)
 479                         specialvisibilityradius = max(specialvisibilityradius, 80);
 480                 if (effects & EF_MUZZLEFLASH)
 481                         specialvisibilityradius = max(specialvisibilityradius, 100);
 482                 if (effects & EF_BRIGHTLIGHT)
 483                         specialvisibilityradius = max(specialvisibilityradius, 400);
 484                 if (effects & EF_DIMLIGHT)
 485                         specialvisibilityradius = max(specialvisibilityradius, 200);
 486                 if (effects & EF_RED)
 487                         specialvisibilityradius = max(specialvisibilityradius, 200);
 488                 if (effects & EF_BLUE)
 489                         specialvisibilityradius = max(specialvisibilityradius, 200);
 490                 if (effects & EF_FLAME)
 491                         specialvisibilityradius = max(specialvisibilityradius, 250);
 492                 if (effects & EF_STARDUST)
 493                         specialvisibilityradius = max(specialvisibilityradius, 100);
 494         }
 495
 496         // early culling checks
 497         // (final culling is done by SV_MarkWriteEntityStateToClient)
 498         customizeentityforclient = PRVM_serveredictfunction(ent, customizeentityforclient);
 499         if (!customizeentityforclient && enumber > svs.maxclients && (!modelindex && !specialvisibilityradius))
 500                 return false;
 501
 502         *cs = defaultstate;
 503         cs->active = ACTIVE_NETWORK;
 504         cs->number = enumber;
 505         VectorCopy(PRVM_serveredictvector(ent, origin), cs->origin);
 506         VectorCopy(PRVM_serveredictvector(ent, angles), cs->angles);
 507         cs->flags = flags;
 508         cs->effects = effects;
 509         cs->colormap = (unsigned)PRVM_serveredictfloat(ent, colormap);
 510         cs->modelindex = modelindex;
 511         cs->skin = (unsigned)PRVM_serveredictfloat(ent, skin);
 512         cs->frame = (unsigned)PRVM_serveredictfloat(ent, frame);
 513         cs->viewmodelforclient = PRVM_serveredictedict(ent, viewmodelforclient);
 514         cs->exteriormodelforclient = PRVM_serveredictedict(ent, exteriormodeltoclient);
 515         cs->nodrawtoclient = PRVM_serveredictedict(ent, nodrawtoclient);
 516         cs->drawonlytoclient = PRVM_serveredictedict(ent, drawonlytoclient);
 517         cs->customizeentityforclient = customizeentityforclient;
 518         cs->tagentity = PRVM_serveredictedict(ent, tag_entity);
 519         cs->tagindex = (unsigned char)PRVM_serveredictfloat(ent, tag_index);
 520         cs->glowsize = glowsize;
 521         cs->traileffectnum = PRVM_serveredictfloat(ent, traileffectnum);
 522
 523         csqcflags = (int)(PRVM_serveredictfloat(ent, csqcflags));
 524         if (csqcflags & CSQCFLAG_SOLIDITY)
 525         {
 526                 cs->solid = PRVM_serveredictfloat(ent, solid);
 527                 VectorCopy(PRVM_serveredictvector(ent, mins), cs->mins);
 528                 VectorCopy(PRVM_serveredictvector(ent, maxs), cs->maxs);
 529         }
 530
 531         // don't need to init cs->colormod because the defaultstate did that for us
 532         //cs->colormod[0] = cs->colormod[1] = cs->colormod[2] = 32;
 533         v = PRVM_serveredictvector(ent, colormod);
 534         if (VectorLength2(v))
 535         {
 536                 i = (int)(v[0] * 32.0f);cs->colormod[0] = bound(0, i, 255);
 537                 i = (int)(v[1] * 32.0f);cs->colormod[1] = bound(0, i, 255);
 538                 i = (int)(v[2] * 32.0f);cs->colormod[2] = bound(0, i, 255);
 539         }
 540
 541         // don't need to init cs->glowmod because the defaultstate did that for us
 542         //cs->glowmod[0] = cs->glowmod[1] = cs->glowmod[2] = 32;
 543         v = PRVM_serveredictvector(ent, glowmod);
 544         if (VectorLength2(v))
 545         {
 546                 i = (int)(v[0] * 32.0f);cs->glowmod[0] = bound(0, i, 255);
 547                 i = (int)(v[1] * 32.0f);cs->glowmod[1] = bound(0, i, 255);
 548                 i = (int)(v[2] * 32.0f);cs->glowmod[2] = bound(0, i, 255);
 549         }
 550
 551         cs->modelindex = modelindex;
 552
 553         cs->alpha = 255;
 554         f = (PRVM_serveredictfloat(ent, alpha) * 255.0f);
 555         if (f)
 556         {
 557                 i = (int)f;
 558                 cs->alpha = (unsigned char)bound(0, i, 255);
 559         }
 560         // halflife
 561         f = (PRVM_serveredictfloat(ent, renderamt));
 562         if (f)
 563         {
 564                 i = (int)f;
 565                 cs->alpha = (unsigned char)bound(0, i, 255);
 566         }
 567
 568         cs->scale = 16;
 569         f = (PRVM_serveredictfloat(ent, scale) * 16.0f);
 570         if (f)
 571         {
 572                 i = (int)f;
 573                 cs->scale = (unsigned char)bound(0, i, 255);
 574         }
 575
 576         cs->glowcolor = 254;
 577         f = PRVM_serveredictfloat(ent, glow_color);
 578         if (f)
 579                 cs->glowcolor = (int)f;
 580
 581         if (PRVM_serveredictfloat(ent, fullbright))
 582                 cs->effects |= EF_FULLBRIGHT;
 583
 584         f = PRVM_serveredictfloat(ent, modelflags);
 585         if (f)
 586                 cs->effects |= ((unsigned int)f & 0xff) << 24;
 587
 588         if (PRVM_serveredictfloat(ent, movetype) == MOVETYPE_STEP)
 589                 cs->flags |= RENDER_STEP;
 590         if (cs->number != sv.writeentitiestoclient_cliententitynumber && (cs->effects & EF_LOWPRECISION) && cs->origin[0] >= -32768 && cs->origin[1] >= -32768 && cs->origin[2] >= -32768 && cs->origin[0] <= 32767 && cs->origin[1] <= 32767 && cs->origin[2] <= 32767)
 591                 cs->flags |= RENDER_LOWPRECISION;
 592         if (PRVM_serveredictfloat(ent, colormap) >= 1024)
 593                 cs->flags |= RENDER_COLORMAPPED;
 594         if (cs->viewmodelforclient)
 595                 cs->flags |= RENDER_VIEWMODEL; // show relative to the view
 596
 597         if (PRVM_serveredictfloat(ent, sendcomplexanimation))
 598         {
 599                 cs->flags |= RENDER_COMPLEXANIMATION;
 600                 if (PRVM_serveredictfloat(ent, skeletonindex) >= 1)
 601                         cs->skeletonobject = ent->priv.server->skeleton;
 602                 cs->framegroupblend[0].frame = PRVM_serveredictfloat(ent, frame);
 603                 cs->framegroupblend[1].frame = PRVM_serveredictfloat(ent, frame2);
 604                 cs->framegroupblend[2].frame = PRVM_serveredictfloat(ent, frame3);
 605                 cs->framegroupblend[3].frame = PRVM_serveredictfloat(ent, frame4);
 606                 cs->framegroupblend[0].start = PRVM_serveredictfloat(ent, frame1time);
 607                 cs->framegroupblend[1].start = PRVM_serveredictfloat(ent, frame2time);
 608                 cs->framegroupblend[2].start = PRVM_serveredictfloat(ent, frame3time);
 609                 cs->framegroupblend[3].start = PRVM_serveredictfloat(ent, frame4time);
 610                 cs->framegroupblend[1].lerp = PRVM_serveredictfloat(ent, lerpfrac);
 611                 cs->framegroupblend[2].lerp = PRVM_serveredictfloat(ent, lerpfrac3);
 612                 cs->framegroupblend[3].lerp = PRVM_serveredictfloat(ent, lerpfrac4);
 613                 cs->framegroupblend[0].lerp = 1.0f - cs->framegroupblend[1].lerp - cs->framegroupblend[2].lerp - cs->framegroupblend[3].lerp;
 614                 cs->frame = 0; // don't need the legacy frame
 615         }
 616
 617         cs->light[0] = light[0];
 618         cs->light[1] = light[1];
 619         cs->light[2] = light[2];
 620         cs->light[3] = light[3];
 621         cs->lightstyle = lightstyle;
 622         cs->lightpflags = lightpflags;
 623
 624         cs->specialvisibilityradius = specialvisibilityradius;
 625
 626         // calculate the visible box of this entity (don't use the physics box
 627         // as that is often smaller than a model, and would not count
 628         // specialvisibilityradius)
 629         if ((model = SV_GetModelByIndex(modelindex)) && (model->type != mod_null))
 630         {
 631                 float scale = cs->scale * (1.0f / 16.0f);
 632                 if (cs->angles[0] || cs->angles[2]) // pitch and roll
 633                 {
 634                         VectorMA(cs->origin, scale, model->rotatedmins, cullmins);
 635                         VectorMA(cs->origin, scale, model->rotatedmaxs, cullmaxs);
 636                 }
 637                 else if (cs->angles[1] || ((effects | model->effects) & EF_ROTATE))
 638                 {
 639                         VectorMA(cs->origin, scale, model->yawmins, cullmins);
 640                         VectorMA(cs->origin, scale, model->yawmaxs, cullmaxs);
 641                 }
 642                 else
 643                 {
 644                         VectorMA(cs->origin, scale, model->normalmins, cullmins);
 645                         VectorMA(cs->origin, scale, model->normalmaxs, cullmaxs);
 646                 }
 647         }
 648         else
 649         {
 650                 // if there is no model (or it could not be loaded), use the physics box
 651                 VectorAdd(cs->origin, PRVM_serveredictvector(ent, mins), cullmins);
 652                 VectorAdd(cs->origin, PRVM_serveredictvector(ent, maxs), cullmaxs);
 653         }
 654         if (specialvisibilityradius)
 655         {
 656                 cullmins[0] = min(cullmins[0], cs->origin[0] - specialvisibilityradius);
 657                 cullmins[1] = min(cullmins[1], cs->origin[1] - specialvisibilityradius);
 658                 cullmins[2] = min(cullmins[2], cs->origin[2] - specialvisibilityradius);
 659                 cullmaxs[0] = max(cullmaxs[0], cs->origin[0] + specialvisibilityradius);
 660                 cullmaxs[1] = max(cullmaxs[1], cs->origin[1] + specialvisibilityradius);
 661                 cullmaxs[2] = max(cullmaxs[2], cs->origin[2] + specialvisibilityradius);
 662         }
 663
 664         // calculate center of bbox for network prioritization purposes
 665         VectorMAM(0.5f, cullmins, 0.5f, cullmaxs, cs->netcenter);
 666
 667         // if culling box has moved, update pvs cluster links
 668         if (!VectorCompare(cullmins, ent->priv.server->cullmins) || !VectorCompare(cullmaxs, ent->priv.server->cullmaxs))
 669         {
 670                 VectorCopy(cullmins, ent->priv.server->cullmins);
 671                 VectorCopy(cullmaxs, ent->priv.server->cullmaxs);
 672                 // a value of -1 for pvs_numclusters indicates that the links are not
 673                 // cached, and should be re-tested each time, this is the case if the
 674                 // culling box touches too many pvs clusters to store, or if the world
 675                 // model does not support FindBoxClusters
 676                 ent->priv.server->pvs_numclusters = -1;
 677                 if (sv.worldmodel && sv.worldmodel->brush.FindBoxClusters)
 678                 {
 679                         i = sv.worldmodel->brush.FindBoxClusters(sv.worldmodel, cullmins, cullmaxs, MAX_ENTITYCLUSTERS, ent->priv.server->pvs_clusterlist);
 680                         if (i <= MAX_ENTITYCLUSTERS)
 681                                 ent->priv.server->pvs_numclusters = i;
 682                 }
 683         }
 684
 685         // we need to do some csqc entity upkeep here
 686         // get self.SendFlags and clear them
 687         // (to let the QC know that they've been read)
 688         if (sendentity)
 689         {
 690                 sendflags = (unsigned int)PRVM_serveredictfloat(ent, SendFlags);
 691                 PRVM_serveredictfloat(ent, SendFlags) = 0;
 692                 // legacy self.Version system
 693                 if ((version = (unsigned int)PRVM_serveredictfloat(ent, Version)))
 694                 {
 695                         if (sv.csqcentityversion[enumber] != version)
 696                                 sendflags = 0xFFFFFF;
 697                         sv.csqcentityversion[enumber] = version;
 698                 }
 699                 // move sendflags into the per-client sendflags
 700                 if (sendflags)
 701                         for (i = 0;i < svs.maxclients;i++)
 702                                 svs.clients[i].csqcentitysendflags[enumber] |= sendflags;
 703                 // mark it as inactive for non-csqc networking
 704                 cs->active = ACTIVE_SHARED;
 705         }
 706
 707         return true;
 708 }
 709
 710 static void SV_PrepareEntitiesForSending(void)
 711 {
 712         prvm_prog_t *prog = SVVM_prog;
 713         int e;
 714         prvm_edict_t *ent;
 715         // send all entities that touch the pvs
 716         sv.numsendentities = 0;
 717         sv.sendentitiesindex[0] = NULL;
 718         memset(sv.sendentitiesindex, 0, prog->num_edicts * sizeof(*sv.sendentitiesindex));
 719         for (e = 1, ent = PRVM_NEXT_EDICT(prog->edicts);e < prog->num_edicts;e++, ent = PRVM_NEXT_EDICT(ent))
 720         {
 721                 if (!ent->priv.server->free && SV_PrepareEntityForSending(ent, sv.sendentities + sv.numsendentities, e))
 722                 {
 723                         sv.sendentitiesindex[e] = sv.sendentities + sv.numsendentities;
 724                         sv.numsendentities++;
 725                 }
 726         }
 727 }
 728
 729 #define MAX_LINEOFSIGHTTRACES 64
 730
 731 qbool SV_CanSeeBox(int numtraces, vec_t eyejitter, vec_t enlarge, vec_t entboxexpand, vec3_t eye, vec3_t entboxmins, vec3_t entboxmaxs)
 732 {
 733         prvm_prog_t *prog = SVVM_prog;
 734         float pitchsign;
 735         float alpha;
 736         float starttransformed[3], endtransformed[3];
 737         float boxminstransformed[3], boxmaxstransformed[3];
 738         float localboxcenter[3], localboxextents[3], localboxmins[3], localboxmaxs[3];
 739         int blocked = 0;
 740         int traceindex;
 741         int originalnumtouchedicts;
 742         int numtouchedicts = 0;
 743         int touchindex;
 744         matrix4x4_t matrix, imatrix;
 745         model_t *model;
 746         prvm_edict_t *touch;
 747         static prvm_edict_t *touchedicts[MAX_EDICTS];
 748         vec3_t eyemins, eyemaxs, start;
 749         vec3_t boxmins, boxmaxs;
 750         vec3_t clipboxmins, clipboxmaxs;
 751         vec3_t endpoints[MAX_LINEOFSIGHTTRACES];
 752
 753         numtraces = min(numtraces, MAX_LINEOFSIGHTTRACES);
 754
 755         // jitter the eye location within this box
 756         eyemins[0] = eye[0] - eyejitter;
 757         eyemaxs[0] = eye[0] + eyejitter;
 758         eyemins[1] = eye[1] - eyejitter;
 759         eyemaxs[1] = eye[1] + eyejitter;
 760         eyemins[2] = eye[2] - eyejitter;
 761         eyemaxs[2] = eye[2] + eyejitter;
 762         // expand the box a little
 763         boxmins[0] = (enlarge+1) * entboxmins[0] - enlarge * entboxmaxs[0] - entboxexpand;
 764         boxmaxs[0] = (enlarge+1) * entboxmaxs[0] - enlarge * entboxmins[0] + entboxexpand;
 765         boxmins[1] = (enlarge+1) * entboxmins[1] - enlarge * entboxmaxs[1] - entboxexpand;
 766         boxmaxs[1] = (enlarge+1) * entboxmaxs[1] - enlarge * entboxmins[1] + entboxexpand;
 767         boxmins[2] = (enlarge+1) * entboxmins[2] - enlarge * entboxmaxs[2] - entboxexpand;
 768         boxmaxs[2] = (enlarge+1) * entboxmaxs[2] - enlarge * entboxmins[2] + entboxexpand;
 769
 770         VectorMAM(0.5f, boxmins, 0.5f, boxmaxs, endpoints[0]);
 771         for (traceindex = 1;traceindex < numtraces;traceindex++)
 772                 VectorSet(endpoints[traceindex], lhrandom(boxmins[0], boxmaxs[0]), lhrandom(boxmins[1], boxmaxs[1]), lhrandom(boxmins[2], boxmaxs[2]));
 773
 774         // calculate sweep box for the entire swarm of traces
 775         VectorCopy(eyemins, clipboxmins);
 776         VectorCopy(eyemaxs, clipboxmaxs);
 777         for (traceindex = 0;traceindex < numtraces;traceindex++)
 778         {
 779                 clipboxmins[0] = min(clipboxmins[0], endpoints[traceindex][0]);
 780                 clipboxmins[1] = min(clipboxmins[1], endpoints[traceindex][1]);
 781                 clipboxmins[2] = min(clipboxmins[2], endpoints[traceindex][2]);
 782                 clipboxmaxs[0] = max(clipboxmaxs[0], endpoints[traceindex][0]);
 783                 clipboxmaxs[1] = max(clipboxmaxs[1], endpoints[traceindex][1]);
 784                 clipboxmaxs[2] = max(clipboxmaxs[2], endpoints[traceindex][2]);
 785         }
 786
 787         // get the list of entities in the sweep box
 788         if (sv_cullentities_trace_entityocclusion.integer)
 789                 numtouchedicts = SV_EntitiesInBox(clipboxmins, clipboxmaxs, MAX_EDICTS, touchedicts);
 790         if (numtouchedicts > MAX_EDICTS)
 791         {
 792                 // this never happens
 793                 Con_Printf("SV_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
 794                 numtouchedicts = MAX_EDICTS;
 795         }
 796         // iterate the entities found in the sweep box and filter them
 797         originalnumtouchedicts = numtouchedicts;
 798         numtouchedicts = 0;
 799         for (touchindex = 0;touchindex < originalnumtouchedicts;touchindex++)
 800         {
 801                 touch = touchedicts[touchindex];
 802                 if (PRVM_serveredictfloat(touch, solid) != SOLID_BSP)
 803                         continue;
 804                 model = SV_GetModelFromEdict(touch);
 805                 if (!model || !model->brush.TraceLineOfSight)
 806                         continue;
 807                 // skip obviously transparent entities
 808                 alpha = PRVM_serveredictfloat(touch, alpha);
 809                 if (alpha && alpha < 1)
 810                         continue;
 811                 if ((int)PRVM_serveredictfloat(touch, effects) & EF_ADDITIVE)
 812                         continue;
 813                 touchedicts[numtouchedicts++] = touch;
 814         }
 815
 816         // now that we have a filtered list of "interesting" entities, fire each
 817         // ray against all of them, this gives us an early-out case when something
 818         // is visible (which it often is)
 819
 820         for (traceindex = 0;traceindex < numtraces;traceindex++)
 821         {
 822                 VectorSet(start, lhrandom(eyemins[0], eyemaxs[0]), lhrandom(eyemins[1], eyemaxs[1]), lhrandom(eyemins[2], eyemaxs[2]));
 823                 // check world occlusion
 824                 if (sv.worldmodel && sv.worldmodel->brush.TraceLineOfSight)
 825                         if (!sv.worldmodel->brush.TraceLineOfSight(sv.worldmodel, start, endpoints[traceindex], boxmins, boxmaxs))
 826                                 continue;
 827                 for (touchindex = 0;touchindex < numtouchedicts;touchindex++)
 828                 {
 829                         touch = touchedicts[touchindex];
 830                         model = SV_GetModelFromEdict(touch);
 831                         if(model && model->brush.TraceLineOfSight)
 832                         {
 833                                 // get the entity matrix
 834                                 pitchsign = SV_GetPitchSign(prog, touch);
 835                                 Matrix4x4_CreateFromQuakeEntity(&matrix, PRVM_serveredictvector(touch, origin)[0], PRVM_serveredictvector(touch, origin)[1], PRVM_serveredictvector(touch, origin)[2], pitchsign * PRVM_serveredictvector(touch, angles)[0], PRVM_serveredictvector(touch, angles)[1], PRVM_serveredictvector(touch, angles)[2], 1);
 836                                 Matrix4x4_Invert_Simple(&imatrix, &matrix);
 837                                 // see if the ray hits this entity
 838                                 Matrix4x4_Transform(&imatrix, start, starttransformed);
 839                                 Matrix4x4_Transform(&imatrix, endpoints[traceindex], endtransformed);
 840                                 Matrix4x4_Transform(&imatrix, boxmins, boxminstransformed);
 841                                 Matrix4x4_Transform(&imatrix, boxmaxs, boxmaxstransformed);
 842                                 // transform the AABB to local space
 843                                 VectorMAM(0.5f, boxminstransformed, 0.5f, boxmaxstransformed, localboxcenter);
 844                                 localboxextents[0] = fabs(boxmaxstransformed[0] - localboxcenter[0]);
 845                                 localboxextents[1] = fabs(boxmaxstransformed[1] - localboxcenter[1]);
 846                                 localboxextents[2] = fabs(boxmaxstransformed[2] - localboxcenter[2]);
 847                                 localboxmins[0] = localboxcenter[0] - localboxextents[0];
 848                                 localboxmins[1] = localboxcenter[1] - localboxextents[1];
 849                                 localboxmins[2] = localboxcenter[2] - localboxextents[2];
 850                                 localboxmaxs[0] = localboxcenter[0] + localboxextents[0];
 851                                 localboxmaxs[1] = localboxcenter[1] + localboxextents[1];
 852                                 localboxmaxs[2] = localboxcenter[2] + localboxextents[2];
 853                                 if (!model->brush.TraceLineOfSight(model, starttransformed, endtransformed, localboxmins, localboxmaxs))
 854                                 {
 855                                         blocked++;
 856                                         break;
 857                                 }
 858                         }
 859                 }
 860                 // check if the ray was blocked
 861                 if (touchindex < numtouchedicts)
 862                         continue;
 863                 // return if the ray was not blocked
 864                 return true;
 865         }
 866
 867         // no rays survived
 868         return false;
 869 }
 870
 871 void SV_MarkWriteEntityStateToClient(entity_state_t *s)
 872 {
 873         prvm_prog_t *prog = SVVM_prog;
 874         int isbmodel;
 875         model_t *model;
 876         prvm_edict_t *ed;
 877         if (sv.sententitiesconsideration[s->number] == sv.sententitiesmark)
 878                 return;
 879         sv.sententitiesconsideration[s->number] = sv.sententitiesmark;
 880         sv.writeentitiestoclient_stats_totalentities++;
 881
 882         if (s->customizeentityforclient)
 883         {
 884                 PRVM_serverglobalfloat(time) = sv.time;
 885                 PRVM_serverglobaledict(self) = s->number;
 886                 PRVM_serverglobaledict(other) = sv.writeentitiestoclient_cliententitynumber;
 887                 prog->ExecuteProgram(prog, s->customizeentityforclient, "customizeentityforclient: NULL function");
 888                 if(!PRVM_G_FLOAT(OFS_RETURN) || !SV_PrepareEntityForSending(PRVM_EDICT_NUM(s->number), s, s->number))
 889                         return;
 890         }
 891
 892         // never reject player
 893         if (s->number != sv.writeentitiestoclient_cliententitynumber)
 894         {
 895                 // check various rejection conditions
 896                 if (s->nodrawtoclient == sv.writeentitiestoclient_cliententitynumber)
 897                         return;
 898                 if (s->drawonlytoclient && s->drawonlytoclient != sv.writeentitiestoclient_cliententitynumber)
 899                         return;
 900                 if (s->effects & EF_NODRAW)
 901                         return;
 902                 // LadyHavoc: only send entities with a model or important effects
 903                 if (!s->modelindex && s->specialvisibilityradius == 0)
 904                         return;
 905
 906                 isbmodel = (model = SV_GetModelByIndex(s->modelindex)) != NULL && model->name[0] == '*';
 907                 // viewmodels don't have visibility checking
 908                 if (s->viewmodelforclient)
 909                 {
 910                         if (s->viewmodelforclient != sv.writeentitiestoclient_cliententitynumber)
 911                                 return;
 912                 }
 913                 else if (s->tagentity)
 914                 {
 915                         // tag attached entities simply check their parent
 916                         if (!sv.sendentitiesindex[s->tagentity])
 917                                 return;
 918                         SV_MarkWriteEntityStateToClient(sv.sendentitiesindex[s->tagentity]);
 919                         if (sv.sententities[s->tagentity] != sv.sententitiesmark)
 920                                 return;
 921                 }
 922                 // always send world submodels in newer protocols because they don't
 923                 // generate much traffic (in old protocols they hog bandwidth)
 924                 // but only if sv_cullentities_nevercullbmodels is off
 925                 else if (!(s->effects & EF_NODEPTHTEST) && (!isbmodel || !sv_cullentities_nevercullbmodels.integer || sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE))
 926                 {
 927                         // entity has survived every check so far, check if visible
 928                         ed = PRVM_EDICT_NUM(s->number);
 929
 930                         // if not touching a visible leaf
 931                         if (sv_cullentities_pvs.integer && !r_novis.integer && !r_trippy.integer && sv.writeentitiestoclient_pvsbytes)
 932                         {
 933                                 if (ed->priv.server->pvs_numclusters < 0)
 934                                 {
 935                                         // entity too big for clusters list
 936                                         if (sv.worldmodel && sv.worldmodel->brush.BoxTouchingPVS && !sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, sv.writeentitiestoclient_pvs, ed->priv.server->cullmins, ed->priv.server->cullmaxs))
 937                                         {
 938                                                 sv.writeentitiestoclient_stats_culled_pvs++;
 939                                                 return;
 940                                         }
 941                                 }
 942                                 else
 943                                 {
 944                                         int i;
 945                                         // check cached clusters list
 946                                         for (i = 0;i < ed->priv.server->pvs_numclusters;i++)
 947                                                 if (CHECKPVSBIT(sv.writeentitiestoclient_pvs, ed->priv.server->pvs_clusterlist[i]))
 948                                                         break;
 949                                         if (i == ed->priv.server->pvs_numclusters)
 950                                         {
 951                                                 sv.writeentitiestoclient_stats_culled_pvs++;
 952                                                 return;
 953                                         }
 954                                 }
 955                         }
 956
 957                         // or not seen by random tracelines
 958                         if (sv_cullentities_trace.integer && !isbmodel && sv.worldmodel && sv.worldmodel->brush.TraceLineOfSight && !r_trippy.integer)
 959                         {
 960                                 int samples =
 961                                         s->number <= svs.maxclients
 962                                                 ? sv_cullentities_trace_samples_players.integer
 963                                                 :
 964                                         s->specialvisibilityradius
 965                                                 ? sv_cullentities_trace_samples_extra.integer
 966                                                 : sv_cullentities_trace_samples.integer;
 967                                 float enlarge = sv_cullentities_trace_enlarge.value;
 968
 969                                 if(samples > 0)
 970                                 {
 971                                         int eyeindex;
 972                                         for (eyeindex = 0;eyeindex < sv.writeentitiestoclient_numeyes;eyeindex++)
 973                                                 if(SV_CanSeeBox(samples, sv_cullentities_trace_eyejitter.value, enlarge, sv_cullentities_trace_expand.value, sv.writeentitiestoclient_eyes[eyeindex], ed->priv.server->cullmins, ed->priv.server->cullmaxs))
 974                                                         break;
 975                                         if(eyeindex < sv.writeentitiestoclient_numeyes)
 976                                                 svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number] =
 977                                                         host.realtime + (
 978                                                                 s->number <= svs.maxclients
 979                                                                         ? sv_cullentities_trace_delay_players.value
 980                                                                         : sv_cullentities_trace_delay.value
 981                                                         );
 982                                         else if (host.realtime > svs.clients[sv.writeentitiestoclient_clientnumber].visibletime[s->number])
 983                                         {
 984                                                 sv.writeentitiestoclient_stats_culled_trace++;
 985                                                 return;
 986                                         }
 987                                 }
 988                         }
 989                 }
 990         }
 991
 992         // this just marks it for sending
 993         // FIXME: it would be more efficient to send here, but the entity
 994         // compressor isn't that flexible
 995         sv.writeentitiestoclient_stats_visibleentities++;
 996         sv.sententities[s->number] = sv.sententitiesmark;
 997 }
 998
 999 #if MAX_LEVELNETWORKEYES > 0
1000 #define MAX_EYE_RECURSION 1 // increase if recursion gets supported by portals
1001 void SV_AddCameraEyes(void)
1002 {
1003         prvm_prog_t *prog = SVVM_prog;
1004         int e, i, j, k;
1005         prvm_edict_t *ed;
1006         static int cameras[MAX_LEVELNETWORKEYES];
1007         static vec3_t camera_origins[MAX_LEVELNETWORKEYES];
1008         static int eye_levels[MAX_CLIENTNETWORKEYES];
1009         int n_cameras = 0;
1010         vec3_t mi, ma;
1011
1012         for(i = 0; i < sv.writeentitiestoclient_numeyes; ++i)
1013                 eye_levels[i] = 0;
1014
1015         // check line of sight to portal entities and add them to PVS
1016         for (e = 1, ed = PRVM_NEXT_EDICT(prog->edicts);e < prog->num_edicts;e++, ed = PRVM_NEXT_EDICT(ed))
1017         {
1018                 if (!ed->priv.server->free)
1019                 {
1020                         if(PRVM_serveredictfunction(ed, camera_transform))
1021                         {
1022                                 PRVM_serverglobalfloat(time) = sv.time;
1023                                 PRVM_serverglobaledict(self) = e;
1024                                 PRVM_serverglobaledict(other) = sv.writeentitiestoclient_cliententitynumber;
1025                                 VectorCopy(sv.writeentitiestoclient_eyes[0], PRVM_serverglobalvector(trace_endpos));
1026                                 VectorCopy(sv.writeentitiestoclient_eyes[0], PRVM_G_VECTOR(OFS_PARM0));
1027                                 VectorClear(PRVM_G_VECTOR(OFS_PARM1));
1028                                 prog->ExecuteProgram(prog, PRVM_serveredictfunction(ed, camera_transform), "QC function e.camera_transform is missing");
1029                                 if(!VectorCompare(PRVM_serverglobalvector(trace_endpos), sv.writeentitiestoclient_eyes[0]))
1030                                 {
1031                                         VectorCopy(PRVM_serverglobalvector(trace_endpos), camera_origins[n_cameras]);
1032                                         cameras[n_cameras] = e;
1033                                         ++n_cameras;
1034                                         if(n_cameras >= MAX_LEVELNETWORKEYES)
1035                                                 break;
1036                                 }
1037                         }
1038                 }
1039         }
1040
1041         if(!n_cameras)
1042                 return;
1043
1044         // i is loop counter, is reset to 0 when an eye got added
1045         // j is camera index to check
1046         for(i = 0, j = 0; sv.writeentitiestoclient_numeyes < MAX_CLIENTNETWORKEYES && i < n_cameras; ++i, ++j, j %= n_cameras)
1047         {
1048                 if(!cameras[j])
1049                         continue;
1050                 ed = PRVM_EDICT_NUM(cameras[j]);
1051                 VectorAdd(PRVM_serveredictvector(ed, origin), PRVM_serveredictvector(ed, mins), mi);
1052                 VectorAdd(PRVM_serveredictvector(ed, origin), PRVM_serveredictvector(ed, maxs), ma);
1053                 for(k = 0; k < sv.writeentitiestoclient_numeyes; ++k)
1054                 if(eye_levels[k] <= MAX_EYE_RECURSION)
1055                 {
1056                         if(SV_CanSeeBox(sv_cullentities_trace_samples.integer, sv_cullentities_trace_eyejitter.value, sv_cullentities_trace_enlarge.value, sv_cullentities_trace_expand.value, sv.writeentitiestoclient_eyes[k], mi, ma))
1057                         {
1058                                 eye_levels[sv.writeentitiestoclient_numeyes] = eye_levels[k] + 1;
1059                                 VectorCopy(camera_origins[j], sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes]);
1060                                 // Con_Printf("added eye %d: %f %f %f because we can see %f %f %f .. %f %f %f from eye %d\n", j, sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes][0], sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes][1], sv.writeentitiestoclient_eyes[sv.writeentitiestoclient_numeyes][2], mi[0], mi[1], mi[2], ma[0], ma[1], ma[2], k);
1061                                 sv.writeentitiestoclient_numeyes++;
1062                                 cameras[j] = 0;
1063                                 i = 0;
1064                                 break;
1065                         }
1066                 }
1067         }
1068 }
1069 #else
1070 void SV_AddCameraEyes(void)
1071 {
1072 }
1073 #endif
1074
1075 /*
1076 =============
1077 SV_CleanupEnts
1078
1079 =============
1080 */
1081 static void SV_CleanupEnts (void)
1082 {
1083         prvm_prog_t *prog = SVVM_prog;
1084         int             e;
1085         prvm_edict_t    *ent;
1086
1087         ent = PRVM_NEXT_EDICT(prog->edicts);
1088         for (e=1 ; e<prog->num_edicts ; e++, ent = PRVM_NEXT_EDICT(ent))
1089                 PRVM_serveredictfloat(ent, effects) = (int)PRVM_serveredictfloat(ent, effects) & ~EF_MUZZLEFLASH;
1090 }
1091
1092 /*
1093 ==================
1094 SV_WriteClientdataToMessage
1095
1096 ==================
1097 */
1098 void SV_WriteClientdataToMessage (client_t *client, prvm_edict_t *ent, sizebuf_t *msg, int *stats)
1099 {
1100         prvm_prog_t *prog = SVVM_prog;
1101         int             bits;
1102         int             i;
1103         prvm_edict_t    *other;
1104         int             items;
1105         vec3_t  punchvector;
1106         int             viewzoom;
1107         const char *s;
1108         float   *statsf = (float *)stats;
1109         float gravity;
1110
1111 //
1112 // send a damage message
1113 //
1114         if (PRVM_serveredictfloat(ent, dmg_take) || PRVM_serveredictfloat(ent, dmg_save))
1115         {
1116                 other = PRVM_PROG_TO_EDICT(PRVM_serveredictedict(ent, dmg_inflictor));
1117                 MSG_WriteByte (msg, svc_damage);
1118                 MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_save));
1119                 MSG_WriteByte (msg, (int)PRVM_serveredictfloat(ent, dmg_take));
1120                 for (i=0 ; i<3 ; i++)
1121                         MSG_WriteCoord (msg, PRVM_serveredictvector(other, origin)[i] + 0.5*(PRVM_serveredictvector(other, mins)[i] + PRVM_serveredictvector(other, maxs)[i]), sv.protocol);
1122
1123                 PRVM_serveredictfloat(ent, dmg_take) = 0;
1124                 PRVM_serveredictfloat(ent, dmg_save) = 0;
1125         }
1126
1127 //
1128 // send the current viewpos offset from the view entity
1129 //
1130         SV_SetIdealPitch ();            // how much to look up / down ideally
1131
1132 // a fixangle might get lost in a dropped packet.  Oh well.
1133         if(PRVM_serveredictfloat(ent, fixangle))
1134         {
1135                 // angle fixing was requested by global thinking code...
1136                 // so store the current angles for later use
1137                 VectorCopy(PRVM_serveredictvector(ent, angles), host_client->fixangle_angles);
1138                 host_client->fixangle_angles_set = true;
1139
1140                 // and clear fixangle for the next frame
1141                 PRVM_serveredictfloat(ent, fixangle) = 0;
1142         }
1143
1144         if (host_client->fixangle_angles_set)
1145         {
1146                 MSG_WriteByte (msg, svc_setangle);
1147                 for (i=0 ; i < 3 ; i++)
1148                         MSG_WriteAngle (msg, host_client->fixangle_angles[i], sv.protocol);
1149                 host_client->fixangle_angles_set = false;
1150         }
1151
1152         // the runes are in serverflags, pack them into the items value, also pack
1153         // in the items2 value for mission pack huds
1154         // (used only in the mission packs, which do not use serverflags)
1155         items = (int)PRVM_serveredictfloat(ent, items) | ((int)PRVM_serveredictfloat(ent, items2) << 23) | ((int)PRVM_serverglobalfloat(serverflags) << 28);
1156
1157         VectorCopy(PRVM_serveredictvector(ent, punchvector), punchvector);
1158
1159         // cache weapon model name and index in client struct to save time
1160         // (this search can be almost 1% of cpu time!)
1161         s = PRVM_GetString(prog, PRVM_serveredictstring(ent, weaponmodel));
1162         if (strcmp(s, client->weaponmodel))
1163         {
1164                 strlcpy(client->weaponmodel, s, sizeof(client->weaponmodel));
1165                 client->weaponmodelindex = SV_ModelIndex(s, 1);
1166         }
1167
1168         viewzoom = (int)(PRVM_serveredictfloat(ent, viewzoom) * 255.0f);
1169         if (viewzoom == 0)
1170                 viewzoom = 255;
1171
1172         bits = 0;
1173
1174         if ((int)PRVM_serveredictfloat(ent, flags) & FL_ONGROUND)
1175                 bits |= SU_ONGROUND;
1176         if (PRVM_serveredictfloat(ent, waterlevel) >= 2)
1177                 bits |= SU_INWATER;
1178         if (PRVM_serveredictfloat(ent, idealpitch))
1179                 bits |= SU_IDEALPITCH;
1180
1181         for (i=0 ; i<3 ; i++)
1182         {
1183                 if (PRVM_serveredictvector(ent, punchangle)[i])
1184                         bits |= (SU_PUNCH1<<i);
1185                 if (sv.protocol != PROTOCOL_QUAKE && sv.protocol != PROTOCOL_QUAKEDP && sv.protocol != PROTOCOL_NEHAHRAMOVIE && sv.protocol != PROTOCOL_NEHAHRABJP && sv.protocol != PROTOCOL_NEHAHRABJP2 && sv.protocol != PROTOCOL_NEHAHRABJP3)
1186                         if (punchvector[i])
1187                                 bits |= (SU_PUNCHVEC1<<i);
1188                 if (PRVM_serveredictvector(ent, velocity)[i])
1189                         bits |= (SU_VELOCITY1<<i);
1190         }
1191
1192         gravity = PRVM_serveredictfloat(ent, gravity);if (!gravity) gravity = 1.0f;
1193
1194         memset(stats, 0, sizeof(int[MAX_CL_STATS]));
1195         stats[STAT_VIEWHEIGHT] = (int)PRVM_serveredictvector(ent, view_ofs)[2];
1196         stats[STAT_ITEMS] = items;
1197         stats[STAT_WEAPONFRAME] = (int)PRVM_serveredictfloat(ent, weaponframe);
1198         stats[STAT_ARMOR] = (int)PRVM_serveredictfloat(ent, armorvalue);
1199         stats[STAT_WEAPON] = client->weaponmodelindex;
1200         stats[STAT_HEALTH] = (int)PRVM_serveredictfloat(ent, health);
1201         stats[STAT_AMMO] = (int)PRVM_serveredictfloat(ent, currentammo);
1202         stats[STAT_SHELLS] = (int)PRVM_serveredictfloat(ent, ammo_shells);
1203         stats[STAT_NAILS] = (int)PRVM_serveredictfloat(ent, ammo_nails);
1204         stats[STAT_ROCKETS] = (int)PRVM_serveredictfloat(ent, ammo_rockets);
1205         stats[STAT_CELLS] = (int)PRVM_serveredictfloat(ent, ammo_cells);
1206         stats[STAT_ACTIVEWEAPON] = (int)PRVM_serveredictfloat(ent, weapon);
1207         stats[STAT_VIEWZOOM] = viewzoom;
1208         stats[STAT_TOTALSECRETS] = (int)PRVM_serverglobalfloat(total_secrets);
1209         stats[STAT_TOTALMONSTERS] = (int)PRVM_serverglobalfloat(total_monsters);
1210         // the QC bumps these itself by sending svc_'s, so we have to keep them
1211         // zero or they'll be corrected by the engine
1212         //stats[STAT_SECRETS] = PRVM_serverglobalfloat(found_secrets);
1213         //stats[STAT_MONSTERS] = PRVM_serverglobalfloat(killed_monsters);
1214
1215         if(!sv_gameplayfix_customstats.integer)
1216         {
1217                 statsf[STAT_MOVEVARS_AIRACCEL_QW_STRETCHFACTOR] = sv_airaccel_qw_stretchfactor.value;
1218                 statsf[STAT_MOVEVARS_AIRCONTROL_PENALTY] = sv_aircontrol_penalty.value;
1219                 statsf[STAT_MOVEVARS_AIRSPEEDLIMIT_NONQW] = sv_airspeedlimit_nonqw.value;
1220                 statsf[STAT_MOVEVARS_AIRSTRAFEACCEL_QW] = sv_airstrafeaccel_qw.value;
1221                 statsf[STAT_MOVEVARS_AIRCONTROL_POWER] = sv_aircontrol_power.value;
1222                 // movement settings for prediction
1223                 // note: these are not sent in protocols with lower MAX_CL_STATS limits
1224                 stats[STAT_MOVEFLAGS] = MOVEFLAG_VALID
1225                         | (sv_gameplayfix_q2airaccelerate.integer ? MOVEFLAG_Q2AIRACCELERATE : 0)
1226                         | (sv_gameplayfix_nogravityonground.integer ? MOVEFLAG_NOGRAVITYONGROUND : 0)
1227                         | (sv_gameplayfix_gravityunaffectedbyticrate.integer ? MOVEFLAG_GRAVITYUNAFFECTEDBYTICRATE : 0)
1228                 ;
1229                 statsf[STAT_MOVEVARS_WARSOWBUNNY_AIRFORWARDACCEL] = sv_warsowbunny_airforwardaccel.value;
1230                 statsf[STAT_MOVEVARS_WARSOWBUNNY_ACCEL] = sv_warsowbunny_accel.value;
1231                 statsf[STAT_MOVEVARS_WARSOWBUNNY_TOPSPEED] = sv_warsowbunny_topspeed.value;
1232                 statsf[STAT_MOVEVARS_WARSOWBUNNY_TURNACCEL] = sv_warsowbunny_turnaccel.value;
1233                 statsf[STAT_MOVEVARS_WARSOWBUNNY_BACKTOSIDERATIO] = sv_warsowbunny_backtosideratio.value;
1234                 statsf[STAT_MOVEVARS_AIRSTOPACCELERATE] = sv_airstopaccelerate.value;
1235                 statsf[STAT_MOVEVARS_AIRSTRAFEACCELERATE] = sv_airstrafeaccelerate.value;
1236                 statsf[STAT_MOVEVARS_MAXAIRSTRAFESPEED] = sv_maxairstrafespeed.value;
1237                 statsf[STAT_MOVEVARS_AIRCONTROL] = sv_aircontrol.value;
1238                 statsf[STAT_FRAGLIMIT] = fraglimit.value;
1239                 statsf[STAT_TIMELIMIT] = timelimit.value;
1240                 statsf[STAT_MOVEVARS_FRICTION] = sv_friction.value;
1241                 statsf[STAT_MOVEVARS_WATERFRICTION] = sv_waterfriction.value >= 0 ? sv_waterfriction.value : sv_friction.value;
1242                 statsf[STAT_MOVEVARS_TICRATE] = sys_ticrate.value;
1243                 statsf[STAT_MOVEVARS_TIMESCALE] = host_timescale.value;
1244                 statsf[STAT_MOVEVARS_GRAVITY] = sv_gravity.value;
1245                 statsf[STAT_MOVEVARS_STOPSPEED] = sv_stopspeed.value;
1246                 statsf[STAT_MOVEVARS_MAXSPEED] = sv_maxspeed.value;
1247                 statsf[STAT_MOVEVARS_SPECTATORMAXSPEED] = sv_maxspeed.value; // FIXME: QW has a separate cvar for this
1248                 statsf[STAT_MOVEVARS_ACCELERATE] = sv_accelerate.value;
1249                 statsf[STAT_MOVEVARS_AIRACCELERATE] = sv_airaccelerate.value >= 0 ? sv_airaccelerate.value : sv_accelerate.value;
1250                 statsf[STAT_MOVEVARS_WATERACCELERATE] = sv_wateraccelerate.value >= 0 ? sv_wateraccelerate.value : sv_accelerate.value;
1251                 statsf[STAT_MOVEVARS_ENTGRAVITY] = gravity;
1252                 statsf[STAT_MOVEVARS_JUMPVELOCITY] = sv_jumpvelocity.value;
1253                 statsf[STAT_MOVEVARS_EDGEFRICTION] = sv_edgefriction.value;
1254                 statsf[STAT_MOVEVARS_MAXAIRSPEED] = sv_maxairspeed.value;
1255                 statsf[STAT_MOVEVARS_STEPHEIGHT] = sv_stepheight.value;
1256                 statsf[STAT_MOVEVARS_AIRACCEL_QW] = sv_airaccel_qw.value;
1257                 statsf[STAT_MOVEVARS_AIRACCEL_SIDEWAYS_FRICTION] = sv_airaccel_sideways_friction.value;
1258         }
1259
1260         if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1261         {
1262                 if (stats[STAT_VIEWHEIGHT] != DEFAULT_VIEWHEIGHT) bits |= SU_VIEWHEIGHT;
1263                 bits |= SU_ITEMS;
1264                 if (stats[STAT_WEAPONFRAME]) bits |= SU_WEAPONFRAME;
1265                 if (stats[STAT_ARMOR]) bits |= SU_ARMOR;
1266                 bits |= SU_WEAPON;
1267                 // FIXME: which protocols support this?  does PROTOCOL_DARKPLACES3 support viewzoom?
1268                 if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4 || sv.protocol == PROTOCOL_DARKPLACES5)
1269                         if (viewzoom != 255)
1270                                 bits |= SU_VIEWZOOM;
1271         }
1272
1273         if (bits >= 65536)
1274                 bits |= SU_EXTEND1;
1275         if (bits >= 16777216)
1276                 bits |= SU_EXTEND2;
1277
1278         // send the data
1279         MSG_WriteByte (msg, svc_clientdata);
1280         MSG_WriteShort (msg, bits);
1281         if (bits & SU_EXTEND1)
1282                 MSG_WriteByte(msg, bits >> 16);
1283         if (bits & SU_EXTEND2)
1284                 MSG_WriteByte(msg, bits >> 24);
1285
1286         if (bits & SU_VIEWHEIGHT)
1287                 MSG_WriteChar (msg, stats[STAT_VIEWHEIGHT]);
1288
1289         if (bits & SU_IDEALPITCH)
1290                 MSG_WriteChar (msg, (int)PRVM_serveredictfloat(ent, idealpitch));
1291
1292         for (i=0 ; i<3 ; i++)
1293         {
1294                 if (bits & (SU_PUNCH1<<i))
1295                 {
1296                         if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1297                                 MSG_WriteChar(msg, (int)PRVM_serveredictvector(ent, punchangle)[i]);
1298                         else
1299                                 MSG_WriteAngle16i(msg, PRVM_serveredictvector(ent, punchangle)[i]);
1300                 }
1301                 if (bits & (SU_PUNCHVEC1<<i))
1302                 {
1303                         if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1304                                 MSG_WriteCoord16i(msg, punchvector[i]);
1305                         else
1306                                 MSG_WriteCoord32f(msg, punchvector[i]);
1307                 }
1308                 if (bits & (SU_VELOCITY1<<i))
1309                 {
1310                         if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1311                                 MSG_WriteChar(msg, (int)(PRVM_serveredictvector(ent, velocity)[i] * (1.0f / 16.0f)));
1312                         else
1313                                 MSG_WriteCoord32f(msg, PRVM_serveredictvector(ent, velocity)[i]);
1314                 }
1315         }
1316
1317         if (bits & SU_ITEMS)
1318                 MSG_WriteLong (msg, stats[STAT_ITEMS]);
1319
1320         if (sv.protocol == PROTOCOL_DARKPLACES5)
1321         {
1322                 if (bits & SU_WEAPONFRAME)
1323                         MSG_WriteShort (msg, stats[STAT_WEAPONFRAME]);
1324                 if (bits & SU_ARMOR)
1325                         MSG_WriteShort (msg, stats[STAT_ARMOR]);
1326                 if (bits & SU_WEAPON)
1327                         MSG_WriteShort (msg, stats[STAT_WEAPON]);
1328                 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1329                 MSG_WriteShort (msg, stats[STAT_AMMO]);
1330                 MSG_WriteShort (msg, stats[STAT_SHELLS]);
1331                 MSG_WriteShort (msg, stats[STAT_NAILS]);
1332                 MSG_WriteShort (msg, stats[STAT_ROCKETS]);
1333                 MSG_WriteShort (msg, stats[STAT_CELLS]);
1334                 MSG_WriteShort (msg, stats[STAT_ACTIVEWEAPON]);
1335                 if (bits & SU_VIEWZOOM)
1336                         MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1337         }
1338         else if (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1339         {
1340                 if (bits & SU_WEAPONFRAME)
1341                         MSG_WriteByte (msg, stats[STAT_WEAPONFRAME]);
1342                 if (bits & SU_ARMOR)
1343                         MSG_WriteByte (msg, stats[STAT_ARMOR]);
1344                 if (bits & SU_WEAPON)
1345                 {
1346                         if (sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3)
1347                                 MSG_WriteShort (msg, stats[STAT_WEAPON]);
1348                         else
1349                                 MSG_WriteByte (msg, stats[STAT_WEAPON]);
1350                 }
1351                 MSG_WriteShort (msg, stats[STAT_HEALTH]);
1352                 MSG_WriteByte (msg, stats[STAT_AMMO]);
1353                 MSG_WriteByte (msg, stats[STAT_SHELLS]);
1354                 MSG_WriteByte (msg, stats[STAT_NAILS]);
1355                 MSG_WriteByte (msg, stats[STAT_ROCKETS]);
1356                 MSG_WriteByte (msg, stats[STAT_CELLS]);
1357                 if (gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE || gamemode == GAME_QUOTH || IS_OLDNEXUIZ_DERIVED(gamemode))
1358                 {
1359                         for (i = 0;i < 32;i++)
1360                                 if (stats[STAT_ACTIVEWEAPON] & (1<<i))
1361                                         break;
1362                         MSG_WriteByte (msg, i);
1363                 }
1364                 else
1365                         MSG_WriteByte (msg, stats[STAT_ACTIVEWEAPON]);
1366                 if (bits & SU_VIEWZOOM)
1367                 {
1368                         if (sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3 || sv.protocol == PROTOCOL_DARKPLACES4)
1369                                 MSG_WriteByte (msg, bound(0, stats[STAT_VIEWZOOM], 255));
1370                         else
1371                                 MSG_WriteShort (msg, bound(0, stats[STAT_VIEWZOOM], 65535));
1372                 }
1373         }
1374 }
1375
1376 void SV_FlushBroadcastMessages(void)
1377 {
1378         int i;
1379         client_t *client;
1380         if (sv.datagram.cursize <= 0)
1381                 return;
1382         for (i = 0, client = svs.clients;i < svs.maxclients;i++, client++)
1383         {
1384                 if (!client->begun || !client->netconnection || client->unreliablemsg.cursize + sv.datagram.cursize > client->unreliablemsg.maxsize || client->unreliablemsg_splitpoints >= (int)(sizeof(client->unreliablemsg_splitpoint)/sizeof(client->unreliablemsg_splitpoint[0])))
1385                         continue;
1386                 SZ_Write(&client->unreliablemsg, sv.datagram.data, sv.datagram.cursize);
1387                 client->unreliablemsg_splitpoint[client->unreliablemsg_splitpoints++] = client->unreliablemsg.cursize;
1388         }
1389         SZ_Clear(&sv.datagram);
1390 }
1391
1392 static void SV_WriteUnreliableMessages(client_t *client, sizebuf_t *msg, int maxsize, int maxsize2)
1393 {
1394         // scan the splitpoints to find out how many we can fit in
1395         int numsegments, j, split;
1396         if (!client->unreliablemsg_splitpoints)
1397                 return;
1398         // always accept the first one if it's within 1024 bytes, this ensures
1399         // that very big datagrams which are over the rate limit still get
1400         // through, just to keep it working
1401         for (numsegments = 1;numsegments < client->unreliablemsg_splitpoints;numsegments++)
1402                 if (msg->cursize + client->unreliablemsg_splitpoint[numsegments] > maxsize)
1403                         break;
1404         // the first segment gets an exemption from the rate limiting, otherwise
1405         // it could get dropped consistently due to a low rate limit
1406         if (numsegments == 1)
1407                 maxsize = maxsize2;
1408         // some will fit, so add the ones that will fit
1409         split = client->unreliablemsg_splitpoint[numsegments-1];
1410         // note this discards ones that were accepted by the segments scan but
1411         // can not fit, such as a really huge first one that will never ever
1412         // fit in a packet...
1413         if (msg->cursize + split <= maxsize)
1414                 SZ_Write(msg, client->unreliablemsg.data, split);
1415         // remove the part we sent, keeping any remaining data
1416         client->unreliablemsg.cursize -= split;
1417         if (client->unreliablemsg.cursize > 0)
1418                 memmove(client->unreliablemsg.data, client->unreliablemsg.data + split, client->unreliablemsg.cursize);
1419         // adjust remaining splitpoints
1420         client->unreliablemsg_splitpoints -= numsegments;
1421         for (j = 0;j < client->unreliablemsg_splitpoints;j++)
1422                 client->unreliablemsg_splitpoint[j] = client->unreliablemsg_splitpoint[numsegments + j] - split;
1423 }
1424
1425 /*
1426 =======================
1427 SV_SendClientDatagram
1428 =======================
1429 */
1430 static void SV_SendClientDatagram (client_t *client)
1431 {
1432         int clientrate, maxrate, maxsize, maxsize2, downloadsize;
1433         sizebuf_t msg;
1434         int stats[MAX_CL_STATS];
1435         static unsigned char sv_sendclientdatagram_buf[NET_MAXMESSAGE];
1436         double timedelta;
1437
1438         // obey rate limit by limiting packet frequency if the packet size
1439         // limiting fails
1440         // (usually this is caused by reliable messages)
1441         if (!NetConn_CanSend(client->netconnection))
1442                 return;
1443
1444         // PROTOCOL_DARKPLACES5 and later support packet size limiting of updates
1445         maxrate = max(NET_MINRATE, sv_maxrate.integer);
1446         if (sv_maxrate.integer != maxrate)
1447                 Cvar_SetValueQuick(&sv_maxrate, maxrate);
1448
1449         // clientrate determines the 'cleartime' of a packet
1450         // (how long to wait before sending another, based on this packet's size)
1451         clientrate = bound(NET_MINRATE, client->rate, maxrate);
1452
1453         switch (sv.protocol)
1454         {
1455         case PROTOCOL_QUAKE:
1456         case PROTOCOL_QUAKEDP:
1457         case PROTOCOL_NEHAHRAMOVIE:
1458         case PROTOCOL_NEHAHRABJP:
1459         case PROTOCOL_NEHAHRABJP2:
1460         case PROTOCOL_NEHAHRABJP3:
1461         case PROTOCOL_QUAKEWORLD:
1462                 // no packet size limit support on Quake protocols because it just
1463                 // causes missing entities/effects
1464                 // packets are simply sent less often to obey the rate limit
1465                 maxsize = 1024;
1466                 maxsize2 = 1024;
1467                 break;
1468         case PROTOCOL_DARKPLACES1:
1469         case PROTOCOL_DARKPLACES2:
1470         case PROTOCOL_DARKPLACES3:
1471         case PROTOCOL_DARKPLACES4:
1472                 // no packet size limit support on DP1-4 protocols because they kick
1473                 // the client off if they overflow, and miss effects
1474                 // packets are simply sent less often to obey the rate limit
1475                 maxsize = sizeof(sv_sendclientdatagram_buf);
1476                 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1477                 break;
1478         default:
1479                 // DP5 and later protocols support packet size limiting which is a
1480                 // better method than limiting packet frequency as QW does
1481                 //
1482                 // at very low rates (or very small sys_ticrate) the packet size is
1483                 // not reduced below 128, but packets may be sent less often
1484
1485                 // how long are bursts?
1486                 timedelta = host_client->rate_burstsize / (double)client->rate;
1487
1488                 // how much of the burst do we keep reserved?
1489                 timedelta *= 1 - net_burstreserve.value;
1490
1491                 // only try to use excess time
1492                 timedelta = bound(0, host.realtime - host_client->netconnection->cleartime, timedelta);
1493
1494                 // but we know next packet will be in sys_ticrate, so we can use up THAT bandwidth
1495                 timedelta += sys_ticrate.value;
1496
1497                 // note: packet overhead (not counted in maxsize) is 28 bytes
1498                 maxsize = (int)(clientrate * timedelta) - 28;
1499
1500                 // put it in sound bounds
1501                 maxsize = bound(128, maxsize, 1400);
1502                 maxsize2 = 1400;
1503
1504                 // csqc entities can easily exceed 128 bytes, so disable throttling in
1505                 // mods that use csqc (they are likely to use less bandwidth anyway)
1506                 if((net_usesizelimit.integer == 1) ? (sv.csqc_progsize > 0) : (net_usesizelimit.integer < 1))
1507                         maxsize = maxsize2;
1508
1509                 break;
1510         }
1511
1512         if (LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) == LHNETADDRESSTYPE_LOOP && !host_limitlocal.integer)
1513         {
1514                 // for good singleplayer, send huge packets
1515                 maxsize = sizeof(sv_sendclientdatagram_buf);
1516                 maxsize2 = sizeof(sv_sendclientdatagram_buf);
1517                 // never limit frequency in singleplayer
1518                 clientrate = 1000000000;
1519         }
1520
1521         // while downloading, limit entity updates to half the packet
1522         // (any leftover space will be used for downloading)
1523         if (host_client->download_file)
1524                 maxsize /= 2;
1525
1526         msg.data = sv_sendclientdatagram_buf;
1527         msg.maxsize = sizeof(sv_sendclientdatagram_buf);
1528         msg.cursize = 0;
1529         msg.allowoverflow = false;
1530
1531         if (host_client->begun)
1532         {
1533                 // the player is in the game
1534                 MSG_WriteByte (&msg, svc_time);
1535                 MSG_WriteFloat (&msg, sv.time);
1536
1537                 // add the client specific data to the datagram
1538                 SV_WriteClientdataToMessage (client, client->edict, &msg, stats);
1539                 // now update the stats[] array using any registered custom fields
1540                 VM_SV_UpdateCustomStats(client, client->edict, &msg, stats);
1541                 // set host_client->statsdeltabits
1542                 Protocol_UpdateClientStats (stats);
1543
1544                 // add as many queued unreliable messages (effects) as we can fit
1545                 // limit effects to half of the remaining space
1546                 if (client->unreliablemsg.cursize)
1547                         SV_WriteUnreliableMessages (client, &msg, maxsize/2, maxsize2);
1548
1549                 // now write as many entities as we can fit, and also sends stats
1550                 SV_WriteEntitiesToClient (client, client->edict, &msg, maxsize);
1551         }
1552         else if (host.realtime > client->keepalivetime)
1553         {
1554                 // the player isn't totally in the game yet
1555                 // send small keepalive messages if too much time has passed
1556                 // (may also be sending downloads)
1557                 client->keepalivetime = host.realtime + 5;
1558                 MSG_WriteChar (&msg, svc_nop);
1559         }
1560
1561         // if a download is active, see if there is room to fit some download data
1562         // in this packet
1563         downloadsize = min(maxsize*2,maxsize2) - msg.cursize - 7;
1564         if (host_client->download_file && host_client->download_started && downloadsize > 0)
1565         {
1566                 fs_offset_t downloadstart;
1567                 unsigned char data[1400];
1568                 downloadstart = FS_Tell(host_client->download_file);
1569                 downloadsize = min(downloadsize, (int)sizeof(data));
1570                 downloadsize = FS_Read(host_client->download_file, data, downloadsize);
1571                 // note this sends empty messages if at the end of the file, which is
1572                 // necessary to keep the packet loss logic working
1573                 // (the last blocks may be lost and need to be re-sent, and that will
1574                 //  only occur if the client acks the empty end messages, revealing
1575                 //  a gap in the download progress, causing the last blocks to be
1576                 //  sent again)
1577                 MSG_WriteChar (&msg, svc_downloaddata);
1578                 MSG_WriteLong (&msg, downloadstart);
1579                 MSG_WriteShort (&msg, downloadsize);
1580                 if (downloadsize > 0)
1581                         SZ_Write (&msg, data, downloadsize);
1582         }
1583
1584         // reliable only if none is in progress
1585         if(client->sendsignon != 2 && !client->netconnection->sendMessageLength)
1586                 SV_WriteDemoMessage(client, &(client->netconnection->message), false);
1587         // unreliable
1588         SV_WriteDemoMessage(client, &msg, false);
1589
1590 // send the datagram
1591         NetConn_SendUnreliableMessage (client->netconnection, &msg, sv.protocol, clientrate, client->rate_burstsize, client->sendsignon == 2);
1592         if (client->sendsignon == 1 && !client->netconnection->message.cursize)
1593                 client->sendsignon = 2; // prevent reliable until client sends prespawn (this is the keepalive phase)
1594 }
1595
1596 /*
1597 =======================
1598 SV_UpdateToReliableMessages
1599 =======================
1600 */
1601 static void SV_UpdateToReliableMessages (void)
1602 {
1603         prvm_prog_t *prog = SVVM_prog;
1604         int i, j;
1605         client_t *client;
1606         const char *name;
1607         const char *model;
1608         const char *skin;
1609         int clientcamera;
1610
1611 // check for changes to be sent over the reliable streams
1612         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1613         {
1614                 // update the host_client fields we care about according to the entity fields
1615                 host_client->edict = PRVM_EDICT_NUM(i+1);
1616
1617                 // DP_SV_CLIENTNAME
1618                 name = PRVM_GetString(prog, PRVM_serveredictstring(host_client->edict, netname));
1619                 if (name == NULL)
1620                         name = "";
1621                 // always point the string back at host_client->name to keep it safe
1622                 //strlcpy (host_client->name, name, sizeof (host_client->name));
1623                 if (name != host_client->name) // prevent buffer overlap SIGABRT on Mac OSX
1624                         strlcpy (host_client->name, name, sizeof (host_client->name));
1625                 SV_Name(i);
1626
1627                 // DP_SV_CLIENTCOLORS
1628                 host_client->colors = (int)PRVM_serveredictfloat(host_client->edict, clientcolors);
1629                 if (host_client->old_colors != host_client->colors)
1630                 {
1631                         host_client->old_colors = host_client->colors;
1632                         // send notification to all clients
1633                         MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1634                         MSG_WriteByte (&sv.reliable_datagram, i);
1635                         MSG_WriteByte (&sv.reliable_datagram, host_client->colors);
1636                 }
1637
1638                 // NEXUIZ_PLAYERMODEL
1639                 model = PRVM_GetString(prog, PRVM_serveredictstring(host_client->edict, playermodel));
1640                 if (model == NULL)
1641                         model = "";
1642                 // always point the string back at host_client->name to keep it safe
1643                 //strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
1644                 if (model != host_client->playermodel) // prevent buffer overlap SIGABRT on Mac OSX
1645                         strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
1646                 PRVM_serveredictstring(host_client->edict, playermodel) = PRVM_SetEngineString(prog, host_client->playermodel);
1647
1648                 // NEXUIZ_PLAYERSKIN
1649                 skin = PRVM_GetString(prog, PRVM_serveredictstring(host_client->edict, playerskin));
1650                 if (skin == NULL)
1651                         skin = "";
1652                 // always point the string back at host_client->name to keep it safe
1653                 //strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
1654                 if (skin != host_client->playerskin) // prevent buffer overlap SIGABRT on Mac OSX
1655                         strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
1656                 PRVM_serveredictstring(host_client->edict, playerskin) = PRVM_SetEngineString(prog, host_client->playerskin);
1657
1658                 // TODO: add an extension name for this [1/17/2008 Black]
1659                 clientcamera = PRVM_serveredictedict(host_client->edict, clientcamera);
1660                 if (clientcamera > 0)
1661                 {
1662                         int oldclientcamera = host_client->clientcamera;
1663                         if (clientcamera >= prog->max_edicts || PRVM_EDICT_NUM(clientcamera)->priv.required->free)
1664                                 clientcamera = PRVM_NUM_FOR_EDICT(host_client->edict);
1665                         host_client->clientcamera = clientcamera;
1666
1667                         if (oldclientcamera != host_client->clientcamera && host_client->netconnection)
1668                         {
1669                                 MSG_WriteByte(&host_client->netconnection->message, svc_setview);
1670                                 MSG_WriteShort(&host_client->netconnection->message, host_client->clientcamera);
1671                         }
1672                 }
1673
1674                 // frags
1675                 host_client->frags = (int)PRVM_serveredictfloat(host_client->edict, frags);
1676                 if(IS_OLDNEXUIZ_DERIVED(gamemode))
1677                         if(!host_client->begun && host_client->netconnection)
1678                                 host_client->frags = -666;
1679                 if (host_client->old_frags != host_client->frags)
1680                 {
1681                         host_client->old_frags = host_client->frags;
1682                         // send notification to all clients
1683                         MSG_WriteByte (&sv.reliable_datagram, svc_updatefrags);
1684                         MSG_WriteByte (&sv.reliable_datagram, i);
1685                         MSG_WriteShort (&sv.reliable_datagram, host_client->frags);
1686                 }
1687         }
1688
1689         for (j = 0, client = svs.clients;j < svs.maxclients;j++, client++)
1690                 if (client->netconnection && (client->begun || client->clientconnectcalled)) // also send MSG_ALL to people who are past ClientConnect, but not spawned yet
1691                         SZ_Write (&client->netconnection->message, sv.reliable_datagram.data, sv.reliable_datagram.cursize);
1692
1693         SZ_Clear (&sv.reliable_datagram);
1694 }
1695
1696
1697 /*
1698 =======================
1699 SV_SendClientMessages
1700 =======================
1701 */
1702 void SV_SendClientMessages(void)
1703 {
1704         int i, prepared = false;
1705
1706         if (sv.protocol == PROTOCOL_QUAKEWORLD)
1707                 Sys_Error("SV_SendClientMessages: no quakeworld support\n");
1708
1709         SV_FlushBroadcastMessages();
1710
1711 // update frags, names, etc
1712         SV_UpdateToReliableMessages();
1713
1714 // build individual updates
1715         for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
1716         {
1717                 if (!host_client->active)
1718                         continue;
1719                 if (!host_client->netconnection)
1720                         continue;
1721
1722                 if (host_client->netconnection->message.overflowed)
1723                 {
1724                         SV_DropClient (true);   // if the message couldn't send, kick off
1725                         continue;
1726                 }
1727
1728                 if (!prepared)
1729                 {
1730                         prepared = true;
1731                         // only prepare entities once per frame
1732                         SV_PrepareEntitiesForSending();
1733                 }
1734                 SV_SendClientDatagram(host_client);
1735         }
1736
1737 // clear muzzle flashes
1738         SV_CleanupEnts();
1739 }