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