qcsrc/server/vehicles/vehicles.qc

   1 void vehicles_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force);
   2 void vehicles_return();
   3 void vehicles_clearrturn();
   4
   5 #define MAX_AXH 4
   6 .entity AuxiliaryXhair[MAX_AXH];
   7
   8 float SendAuxiliaryXhair(entity to, float sf)
   9 {
  10
  11         WriteByte(MSG_ENTITY, ENT_CLIENT_AUXILIARYXHAIR);
  12
  13         WriteByte(MSG_ENTITY, self.cnt);
  14
  15         WriteCoord(MSG_ENTITY, self.origin_x);
  16         WriteCoord(MSG_ENTITY, self.origin_y);
  17         WriteCoord(MSG_ENTITY, self.origin_z);
  18
  19     WriteByte(MSG_ENTITY, rint(self.colormod_x * 255));
  20     WriteByte(MSG_ENTITY, rint(self.colormod_y * 255));
  21     WriteByte(MSG_ENTITY, rint(self.colormod_z * 255));
  22
  23     return TRUE;
  24 }
  25
  26 void UpdateAuxiliaryXhair(entity own, vector loc, vector clr, float axh_id)
  27 {
  28     entity axh;
  29
  30     axh_id = bound(0, axh_id, MAX_AXH);
  31     axh = own.AuxiliaryXhair[axh_id];
  32
  33     if(axh == world || wasfreed(axh))  // MADNESS? THIS IS QQQQCCCCCCCCC (wasfreed, why do you exsist?)
  34     {
  35         axh                     = spawn();
  36         axh.cnt                 = axh_id;
  37         axh.drawonlytoclient    = own;
  38         axh.owner               = own;
  39         Net_LinkEntity(axh, FALSE, 0, SendAuxiliaryXhair);
  40     }
  41
  42     setorigin(axh, loc);
  43     axh.colormod            = clr;
  44     axh.SendFlags           = 0x01;
  45     own.AuxiliaryXhair[axh_id] = axh;
  46 }
  47
  48 /*
  49 // SVC_TEMPENTITY based, horrible with even 50 ping. hm.
  50 // WriteByte(MSG_ONE, SVC_TEMPENTITY) uses reliable messagess, never use for thinsg that need continous updates.
  51 void SendAuxiliaryXhair2(entity own, vector loc, vector clr, float axh_id)
  52 {
  53         msg_entity = own;
  54
  55         WriteByte(MSG_ONE, SVC_TEMPENTITY);
  56         WriteByte(MSG_ONE, TE_CSQC_AUXILIARYXHAIR);
  57
  58         WriteByte(MSG_ONE, axh_id);
  59
  60         WriteCoord(MSG_ONE, loc_x);
  61         WriteCoord(MSG_ONE, loc_y);
  62         WriteCoord(MSG_ONE, loc_z);
  63
  64     WriteByte(MSG_ONE, rint(clr_x * 255));
  65     WriteByte(MSG_ONE, rint(clr_y * 255));
  66     WriteByte(MSG_ONE, rint(clr_z * 255));
  67
  68 }
  69 */
  70
  71 void CSQCVehicleSetup(entity own, float vehicle_id)
  72 {
  73         msg_entity = own;
  74
  75         WriteByte(MSG_ONE, SVC_TEMPENTITY);
  76         WriteByte(MSG_ONE, TE_CSQC_VEHICLESETUP);
  77         WriteByte(MSG_ONE, vehicle_id);
  78 }
  79
  80 .entity lock_target;
  81 .float  lock_strength;
  82 .float  lock_time;
  83 void vehicles_locktarget2(float incr, float decr, float _lock_time)
  84 {
  85     if(self.lock_time > time)
  86         return;
  87
  88     if not (trace_ent.vehicle_flags & VHF_ISVEHICLE || trace_ent.turrcaps_flags & TFL_TURRCAPS_ISTURRET)
  89         self.lock_strength = min(self.lock_strength - decr, 1);
  90     else if(trace_ent.deadflag != DEAD_NO)
  91         self.lock_strength = min(self.lock_strength - decr, 1);
  92
  93     if(self.lock_target == world && trace_ent != world)
  94         self.lock_target = trace_ent;
  95
  96     // Have a locking target
  97     // Trace hit current target
  98     if(trace_ent == self.lock_target && trace_ent != world)
  99     {
 100         self.lock_strength = min(self.lock_strength + incr, 1);
 101         if(self.lock_strength == 1)
 102             self.lock_time = time + _lock_time;
 103     }
 104     else
 105     {
 106         self.lock_strength = max(self.lock_strength - decr, 0);
 107
 108         if(self.lock_strength == 0)
 109             self.lock_target = world;
 110     }
 111 }
 112
 113
 114 #define VEHICLE_UPDATE_PLAYER(fld,vhname) \
 115 self.owner.vehicle_##fld = self.vehicle_##fld / autocvar_g_vehicle_##vhname##_##fld
 116
 117 #define vehicles_sweap_collision(orig,vel,dt,acm,mult) \
 118 traceline(orig, orig + vel * dt, MOVE_NORMAL, self); \
 119 if(trace_fraction != 1) \
 120     acm += normalize(self.origin - trace_endpos) * (vlen(vel) * mult)
 121
 122 float  force_fromtag_power;
 123 float  force_fromtag_normpower;
 124 vector force_fromtag_origin;
 125 vector vehicles_force_fromtag_hover(string tag_name, float spring_length, float max_power)
 126 {
 127     force_fromtag_origin = gettaginfo(self, gettagindex(self, tag_name));
 128     v_forward  = normalize(v_forward) * -1;
 129     traceline(force_fromtag_origin, force_fromtag_origin - (v_forward  * spring_length), MOVE_NORMAL, self);
 130
 131     force_fromtag_power = (1 - trace_fraction) * max_power;
 132     force_fromtag_normpower = force_fromtag_power / max_power;
 133
 134     return v_forward  * force_fromtag_power;
 135 }
 136
 137 vector vehicles_force_fromtag_maglev(string tag_name, float spring_length, float max_power)
 138 {
 139
 140     force_fromtag_origin = gettaginfo(self, gettagindex(self, tag_name));
 141     v_forward  = normalize(v_forward) * -1;
 142     traceline(force_fromtag_origin, force_fromtag_origin - (v_forward  * spring_length), MOVE_NORMAL, self);
 143
 144     if(trace_fraction == 1.0)
 145     {
 146         force_fromtag_normpower = -0.25;
 147         return '0 0 -200';
 148     }
 149
 150     force_fromtag_power = ((1 - trace_fraction) - trace_fraction) * max_power;
 151     force_fromtag_normpower = force_fromtag_power / max_power;
 152
 153     return v_forward  * force_fromtag_power;
 154 }
 155
 156
 157 void vehicles_touch()
 158 {
 159     // Vehicle currently
 160     if(self.owner)
 161     {
 162         // Colided with world?
 163         if(other == world)
 164         {
 165             // Apply velocity based self damage here
 166         }
 167         else
 168         {
 169             if(other.vehicle_flags & VHF_ISVEHICLE)
 170             {
 171                 other.velocity += self.velocity * (self.mass / other.mass);
 172             }
 173         }
 174     }
 175
 176     if(other.classname != "player")
 177         return;
 178
 179     if(other.deadflag != DEAD_NO)
 180         return;
 181
 182     if(other.vehicle != world)
 183         return;
 184
 185     // Remove this when bots know how to use vehicles.
 186     if (clienttype(other) != CLIENTTYPE_REAL)
 187         return;
 188
 189     self.vehicle_enter();
 190 }
 191
 192 void vehicles_enter()
 193 {
 194    // Remove this when bots know how to use vehicles
 195     if (clienttype(other) != CLIENTTYPE_REAL)
 196         return;
 197
 198     if(self.phase > time)
 199         return;
 200
 201     if(teams_matter)
 202     if(self.team)
 203     if(self.team != other.team)
 204         return;
 205
 206     self.owner          = other;
 207     self.switchweapon   = other.switchweapon;
 208
 209     self.vehicle_hudmodel.viewmodelforclient = self.owner;
 210     self.event_damage         = vehicles_damage;
 211     self.nextthink            = 0;
 212     self.owner.angles         = self.angles;
 213     self.owner.takedamage     = DAMAGE_NO;
 214     self.owner.solid          = SOLID_NOT;
 215     self.owner.movetype       = MOVETYPE_NOCLIP;
 216     self.owner.alpha          = -1;
 217     self.owner.vehicle        = self;
 218     self.owner.event_damage   = SUB_Null;
 219     self.owner.view_ofs       = '0 0 0';
 220     self.colormap             = self.owner.colormap;
 221     if(self.tur_head)
 222         self.tur_head.colormap    = self.owner.colormap;
 223
 224     self.owner.hud            = self.hud;
 225     self.owner.PlayerPhysplug = self.PlayerPhysplug;
 226
 227     self.owner.vehicle_ammo1    = self.vehicle_ammo1;
 228     self.owner.vehicle_ammo2    = self.vehicle_ammo2;
 229     self.owner.vehicle_reload1  = self.vehicle_reload1;
 230     self.owner.vehicle_reload2  = self.vehicle_reload2;
 231
 232     other.flags &~= FL_ONGROUND;
 233     self.flags  &~= FL_ONGROUND;
 234
 235     self.team                 = self.owner.team;
 236     self.flags               -= FL_NOTARGET;
 237
 238     msg_entity = other;
 239     WriteByte (MSG_ONE, SVC_SETVIEWPORT);
 240     WriteEntity(MSG_ONE, self.vehicle_viewport);
 241
 242     WriteByte (MSG_ONE, SVC_SETVIEWANGLES);  // 10 = SVC_SETVIEWANGLES
 243     if(self.tur_head)
 244     {
 245         WriteAngle(MSG_ONE, self.tur_head.angles_x + self.angles_x);    // tilt
 246         WriteAngle(MSG_ONE, self.tur_head.angles_y + self.angles_y);    // yaw
 247         WriteAngle(MSG_ONE, 0);    // roll
 248     }
 249     else
 250     {
 251         WriteByte (MSG_ONE, SVC_SETVIEWANGLES); // 10 = SVC_SETVIEWANGLES
 252         WriteAngle(MSG_ONE,  self.angles_x * -1);    // tilt
 253         WriteAngle(MSG_ONE,  self.angles_y);    // yaw
 254         WriteAngle(MSG_ONE,  0);                // roll
 255     }
 256
 257     vehicles_clearrturn();
 258
 259     CSQCVehicleSetup(self.owner, self.hud);
 260
 261     if(self.vehicle_enter)
 262         self.vehicle_enter();
 263 }
 264
 265 void vehicles_exit(float eject)
 266 {
 267         self.flags |= FL_NOTARGET;
 268
 269     if (self.owner)
 270     {
 271         msg_entity = self.owner;
 272         WriteByte (MSG_ONE, SVC_SETVIEWPORT);
 273         WriteEntity( MSG_ONE, self.owner);
 274
 275         WriteByte (MSG_ONE, SVC_SETVIEWANGLES); // 10 = SVC_SETVIEWANGLES
 276         WriteAngle(MSG_ONE, 0);                 // tilt
 277         WriteAngle(MSG_ONE, self.angles_y);     // yaw
 278         WriteAngle(MSG_ONE, 0);                 // roll
 279
 280         setsize(self.owner, PL_MIN,PL_MAX);
 281
 282         self.owner.takedamage     = DAMAGE_AIM;
 283         self.owner.solid          = SOLID_SLIDEBOX;
 284         self.owner.movetype       = MOVETYPE_WALK;
 285         self.owner.effects        &~= EF_NODRAW;
 286         self.owner.alpha          = 1;
 287         self.owner.PlayerPhysplug = SUB_Null;
 288         self.owner.vehicle        = world;
 289         self.owner.view_ofs       = PL_VIEW_OFS;
 290         self.owner.event_damage   = PlayerDamage;
 291         self.owner.hud            = HUD_NORMAL;
 292         self.owner.switchweapon   = self.switchweapon;
 293     }
 294
 295     self.vehicle_hudmodel.viewmodelforclient = self;
 296         self.tur_head.nodrawtoclient             = self;
 297
 298     self.phase = time + 1;
 299
 300     if(!teams_matter)
 301         self.team = 0;
 302
 303     if(self.vehicle_exit)
 304         self.vehicle_exit(eject);
 305
 306     self.owner = world;
 307 }
 308
 309
 310 void vehicles_regen(.float timer, .float regen_field, float field_max, float rpause, float regen, float delta_time)
 311 {
 312     if(self.regen_field < field_max)
 313     if(self.timer + rpause < time)
 314     {
 315         self.regen_field = min(self.regen_field + regen * delta_time, field_max);
 316
 317         if(self.owner)
 318             self.owner.regen_field = self.regen_field / field_max;
 319     }
 320 }
 321
 322 void shieldhit_think()
 323 {
 324     self.alpha -= 0.1;
 325     if (self.alpha <= 0)
 326     {
 327         setmodel(self, "");
 328         self.alpha = -1;
 329     }
 330     else
 331     {
 332         self.nextthink = time + 0.1;
 333     }
 334 }
 335
 336 void vehicles_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 337 {
 338     float ddmg_take;
 339
 340     self.dmg_time = time;
 341
 342     if((self.vehicle_flags & VHF_HASSHIELD) && (self.vehicle_shield > 0))
 343     {
 344         if (wasfreed(self.tur_head.enemy) || self.tur_head.enemy == world)
 345         {
 346             self.tur_head.enemy = spawn();
 347             self.tur_head.enemy.effects = EF_LOWPRECISION;
 348         }
 349
 350         setmodel(self.tur_head.enemy, "models/vhshield.md3");
 351         setattachment(self.tur_head.enemy, self, "");
 352
 353         self.tur_head.enemy.colormod    = '1 1 1';
 354         self.tur_head.enemy.alpha       = 0.45;
 355         self.tur_head.enemy.scale       = 256 / vlen(self.maxs - self.mins);
 356         self.tur_head.enemy.angles      = vectoangles(normalize(hitloc - self.origin)) - self.angles;
 357         self.tur_head.enemy.think       = shieldhit_think;
 358         self.tur_head.enemy.nextthink   = time;
 359
 360         self.vehicle_shield -= damage;
 361         if(self.vehicle_shield < 0)
 362         {
 363             self.tur_head.enemy.colormod = '2 0 0';
 364             ddmg_take = fabs(self.vehicle_shield);
 365             self.vehicle_shield         = 0;
 366             self.tur_head.enemy.alpha   = 0.75;
 367             self.vehicle_health         -= ddmg_take;
 368         }
 369     }
 370     else
 371         self.vehicle_health -= damage;
 372
 373     if(self.vehicle_health <= 0)
 374     {
 375         if(self.owner)
 376             if(self.vehicle_flags & VHF_DEATHEJECT)
 377                 vehicles_exit(VHEF_EJECT);
 378             else
 379                 vehicles_exit(VHEF_RELESE);
 380
 381         self.vehicle_die();
 382     }
 383 }
 384
 385 void vehicles_return()
 386 {
 387     pointparticles(particleeffectnum("teleport"), self.enemy.origin + '0 0 64', '0 0 0', 1);
 388     self.enemy.think = self.use;
 389     self.enemy.nextthink = time;
 390     remove(self);
 391 }
 392
 393 void vehicles_clearrturn()
 394 {
 395     entity ret;
 396     // Remove "return helper", if any.
 397     ret = findchain(classname, "vehicle_return");
 398     while(ret)
 399     {
 400         if(ret.enemy == self)
 401         {
 402             ret.think = SUB_Remove;
 403             ret.nextthink = time + 0.1;
 404             return;
 405         }
 406         ret = ret.chain;
 407     }
 408 }
 409
 410 void vehicles_setreturn(float retime, void() respawn_proc)
 411 {
 412     vehicles_clearrturn();
 413
 414     if (self.deadflag == DEAD_NO)
 415     {
 416         entity ret;
 417
 418         ret = spawn();
 419         ret.classname = "vehicle_return";
 420         ret.enemy = self;
 421         ret.think = vehicles_return;
 422         ret.nextthink = time + retime;
 423         ret.use = respawn_proc;
 424     }
 425 }
 426
 427 float vehicles_customizeentityforclient()
 428 {
 429     return self.deadflag == DEAD_DEAD ? FALSE : TRUE;
 430 }
 431
 432 void vehicles_configcheck(string  configname, float check_cvar)
 433 {
 434     if(check_cvar == 0)
 435         localcmd(strcat("exec ", configname, "\n"));
 436 }
 437
 438 void vehicles_reset_colors()
 439 {
 440     entity e;
 441     float _effects, _colormap;
 442     vector _glowmod, _colormod;
 443
 444     if(autocvar_g_nodepthtestplayers)
 445         _effects = EF_NODEPTHTEST;
 446
 447     if(autocvar_g_fullbrightplayers)
 448         _effects |= EF_FULLBRIGHT;
 449
 450     if(self.team)
 451         _colormap = 1024 + (self.team - 1) * 17;
 452     else
 453         _colormap = 1024;
 454
 455     _glowmod    = '0 0 0';
 456     _colormod   = '0 0 0';
 457
 458     // Find all ents attacked to main model and setup effects, colormod etc.
 459     e = findchainentity(tag_entity, self);
 460     while(e)
 461     {
 462         e.effects   = _effects;
 463         e.colormod  = _colormod;
 464         e.colormap  = _colormap;
 465         e.alpha     = 1;
 466
 467         e = e.chain;
 468     }
 469
 470     self.effects  = _effects;
 471     self.colormod = _colormod;
 472     self.colormap = _colormap;
 473
 474     self.alpha          = 1;
 475     self.avelocity      = '0 0 0';
 476     self.velocity       = '0 0 0';
 477
 478 }
 479
 480 float vehicle_initialize(string  net_name,
 481                          string  bodymodel,
 482                          string  topmodel,
 483                          string  hudmodel,
 484                          string  toptag,
 485                          string  hudtag,
 486                          string  viewtag,
 487                          float   vhud,
 488                          vector min_s,
 489                          vector max_s,
 490                          float  nodrop,
 491                          void()  spawnproc,
 492                          float() physproc,
 493                          void()  enterproc,
 494                          void(float extflag) exitfunc,
 495                          void() dieproc,
 496                          void() thinkproc )
 497 {
 498     addstat(STAT_HUD, AS_INT,  hud);
 499         addstat(STAT_VEHICLESTAT_HEALTH,  AS_FLOAT, vehicle_health);
 500         addstat(STAT_VEHICLESTAT_SHIELD,  AS_FLOAT, vehicle_shield);
 501         addstat(STAT_VEHICLESTAT_ENERGY,  AS_FLOAT, vehicle_energy);
 502
 503         addstat(STAT_VEHICLESTAT_AMMO1,   AS_INT,   vehicle_ammo1);
 504         addstat(STAT_VEHICLESTAT_RELOAD1, AS_FLOAT, vehicle_reload1);
 505
 506         addstat(STAT_VEHICLESTAT_AMMO2,   AS_INT,   vehicle_ammo2);
 507         addstat(STAT_VEHICLESTAT_RELOAD2, AS_FLOAT, vehicle_reload2);
 508
 509
 510     if(bodymodel == "")
 511         error("vehicles: missing bodymodel!");
 512
 513     if(hudmodel == "")
 514         error("vehicles: missing hudmodel!");
 515
 516     if(net_name == "")
 517         self.netname = self.classname;
 518     else
 519         self.netname = net_name;
 520
 521     if(self.team && !teams_matter)
 522         self.team = 0;
 523
 524     self.vehicle_flags |= VHF_ISVEHICLE;
 525
 526     setmodel(self, bodymodel);
 527
 528     self.vehicle_viewport   = spawn();
 529     self.vehicle_hudmodel   = spawn();
 530     self.tur_head           = spawn();
 531     self.tur_head.owner     = self;
 532     self.takedamage         = DAMAGE_AIM;
 533     self.bot_attack         = TRUE;
 534     self.iscreature         = TRUE;
 535     self.hud                = vhud;
 536
 537     self.customizeentityforclient = vehicles_customizeentityforclient;
 538     self.vehicle_die        = dieproc;
 539     self.vehicle_exit       = exitfunc;
 540     self.vehicle_enter      = enterproc;
 541     self.PlayerPhysplug     = physproc;
 542     self.event_damage       = vehicles_damage;
 543     self.touch              = vehicles_touch;
 544     self.think              = spawnproc;
 545     self.nextthink          = time;
 546
 547     if(autocvar_g_nodepthtestplayers)
 548         self.effects = self.effects | EF_NODEPTHTEST;
 549
 550     if(autocvar_g_fullbrightplayers)
 551         self.effects = self.effects | EF_FULLBRIGHT;
 552
 553     setmodel(self.vehicle_hudmodel, hudmodel);
 554     setmodel(self.vehicle_viewport, "null");
 555
 556     if(topmodel != "")
 557     {
 558         setmodel(self.tur_head, topmodel);
 559         setattachment(self.tur_head, self, toptag);
 560         setattachment(self.vehicle_hudmodel, self.tur_head, hudtag);
 561         setattachment(self.vehicle_viewport, self.vehicle_hudmodel, viewtag);
 562     }
 563     else
 564     {
 565         setattachment(self.tur_head, self, "");
 566         setattachment(self.vehicle_hudmodel, self, hudtag);
 567         setattachment(self.vehicle_viewport, self.vehicle_hudmodel, viewtag);
 568     }
 569
 570     setsize(self, min_s, max_s);
 571     if not (nodrop)
 572     {
 573         setorigin(self, self.origin);
 574         tracebox(self.origin + '0 0 100', min_s, max_s, self.origin - '0 0 10000', MOVE_WORLDONLY, self);
 575         setorigin(self, trace_endpos);
 576     }
 577
 578     self.pos1 = self.origin;
 579     self.pos2 = self.angles;
 580
 581     return TRUE;
 582 }
 583
 584
 585 void bugmenot()
 586 {
 587     self.vehicle_exit       = self.vehicle_exit;
 588     self.vehicle_enter      = self.vehicle_exit;
 589     self.vehicle_die        = self.vehicle_exit;
 590     self.vehicle_spawn      = self.vehicle_exit;
 591     self.AuxiliaryXhair     = self.AuxiliaryXhair;
 592     //self.vehicle_message    = self.vehicle_exit;
 593 }