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 .entity AuxiliaryXhair;
   6 float AuxiliaryXhair_customizeentityforclient()
   7 {
   8     if(other == self.owner)
   9         return TRUE;
  10
  11     return FALSE;
  12 }
  13 float AuxiliaryXhair_SendEntity(entity to, float sf)
  14 {
  15         WriteByte(MSG_ENTITY, ENT_CLIENT_AUXILIARYXHAIR);
  16         WriteCoord(MSG_ENTITY, self.origin_x);
  17         WriteCoord(MSG_ENTITY, self.origin_y);
  18         WriteCoord(MSG_ENTITY, self.origin_z);
  19
  20     WriteByte(MSG_ENTITY, rint(self.colormod_x * 255));
  21     WriteByte(MSG_ENTITY, rint(self.colormod_y * 255));
  22     WriteByte(MSG_ENTITY, rint(self.colormod_z * 255));
  23
  24         return TRUE;
  25 }
  26
  27 void SpawnOrUpdateAuxiliaryXhair(entity own, vector loc, vector clr)
  28 {
  29
  30     if(own.AuxiliaryXhair == world || wasfreed(own.AuxiliaryXhair))
  31     {
  32         own.AuxiliaryXhair = spawn();
  33         own.AuxiliaryXhair.owner = own;
  34         own.AuxiliaryXhair.drawonlytoclient = own;
  35         Net_LinkEntity(own.AuxiliaryXhair, FALSE, 0, AuxiliaryXhair_SendEntity);
  36     }
  37
  38     own.AuxiliaryXhair.colormod = clr;
  39     setorigin(own.AuxiliaryXhair, loc);
  40         own.AuxiliaryXhair.SendFlags |= 0x01;
  41 }
  42
  43 void Release_AuxiliaryXhair(entity from)
  44 {
  45     // from.AuxiliaryXhair.drawonlytoclient = from.AuxiliaryXhair;
  46     if (from.AuxiliaryXhair != world && !wasfreed(from.AuxiliaryXhair))
  47         remove(from.AuxiliaryXhair);
  48
  49     from.AuxiliaryXhair = world;
  50 }
  51
  52 #define VEHICLE_UPDATE_PLAYER(fld,vhname) \
  53 self.owner.vehicle_##fld = self.vehicle_##fld / autocvar_g_vehicle_##vhname##_##fld
  54
  55 #define vehicles_sweap_collision(orig,vel,dt,acm,mult) \
  56 traceline(orig, orig + vel * dt, MOVE_NORMAL, self); \
  57 if(trace_fraction != 1) \
  58     acm += normalize(self.origin - trace_endpos) * (vlen(vel) * mult)
  59
  60 float  force_fromtag_power;
  61 float  force_fromtag_normpower;
  62 vector force_fromtag_origin;
  63 vector vehicles_force_fromtag_hover(string tag_name, float spring_length, float max_power)
  64 {
  65     force_fromtag_origin = gettaginfo(self, gettagindex(self, tag_name));
  66     v_forward  = normalize(v_forward) * -1;
  67     traceline(force_fromtag_origin, force_fromtag_origin - (v_forward  * spring_length), MOVE_NORMAL, self);
  68
  69     force_fromtag_power = (1 - trace_fraction) * max_power;
  70     force_fromtag_normpower = force_fromtag_power / max_power;
  71
  72     return v_forward  * force_fromtag_power;
  73 }
  74
  75 vector vehicles_force_fromtag_maglev(string tag_name, float spring_length, float max_power)
  76 {
  77
  78     force_fromtag_origin = gettaginfo(self, gettagindex(self, tag_name));
  79     v_forward  = normalize(v_forward) * -1;
  80     traceline(force_fromtag_origin, force_fromtag_origin - (v_forward  * spring_length), MOVE_NORMAL, self);
  81
  82     if(trace_fraction == 1.0)
  83     {
  84         force_fromtag_normpower = -0.25;
  85         return '0 0 -200';
  86     }
  87
  88     force_fromtag_power = ((1 - trace_fraction) - trace_fraction) * max_power;
  89     force_fromtag_normpower = force_fromtag_power / max_power;
  90
  91     return v_forward  * force_fromtag_power;
  92 }
  93
  94
  95 void vehicles_touch()
  96 {
  97     if(other.classname != "player")
  98         return;
  99
 100     if(other.deadflag != DEAD_NO)
 101         return;
 102
 103     if(other.vehicle != world)
 104         return;
 105
 106     // Remove this when bots know how to use vehicles.
 107     if (clienttype(other) != CLIENTTYPE_REAL)
 108         return;
 109
 110     self.vehicle_enter();
 111 }
 112
 113 void vehicles_enter()
 114 {
 115    // Remove this when bots know how to use vehicles
 116     if (clienttype(other) != CLIENTTYPE_REAL)
 117         return;
 118
 119     self.colormod = self.tur_head.colormod = '0 0 0';
 120
 121     if(teams_matter)
 122     if(self.team)
 123     if(self.team != other.team)
 124         return;
 125
 126     self.owner          = other;
 127     self.switchweapon   = other.switchweapon;
 128
 129     self.vehicle_hudmodel.viewmodelforclient = self.owner;
 130     self.event_damage         = vehicles_damage;
 131     self.nextthink            = 0;
 132     self.owner.angles         = self.angles;
 133     self.owner.takedamage     = DAMAGE_NO;
 134     self.owner.solid          = SOLID_NOT;
 135     self.owner.movetype       = MOVETYPE_NOCLIP;
 136     self.owner.alpha          = -1;
 137     self.owner.vehicle        = self;
 138     self.owner.event_damage   = SUB_Null;
 139     self.owner.view_ofs       = '0 0 0';
 140     self.colormap             = self.owner.colormap;
 141     if(self.tur_head)
 142         self.tur_head.colormap    = self.owner.colormap;
 143
 144     self.owner.hud            = self.hud;
 145     self.owner.PlayerPhysplug = self.PlayerPhysplug;
 146
 147     self.owner.vehicle_ammo1    = self.vehicle_ammo1;
 148     self.owner.vehicle_ammo2    = self.vehicle_ammo2;
 149     self.owner.vehicle_reload1  = self.vehicle_reload1;
 150     self.owner.vehicle_reload2  = self.vehicle_reload2;
 151
 152     other.flags &~= FL_ONGROUND;
 153     self.flags  &~= FL_ONGROUND;
 154
 155     self.team                 = self.owner.team;
 156     self.flags               -= FL_NOTARGET;
 157
 158     msg_entity = other;
 159     WriteByte (MSG_ONE, SVC_SETVIEWPORT);
 160     WriteEntity(MSG_ONE, self.vehicle_viewport);
 161
 162     WriteByte (MSG_ONE, SVC_SETVIEWANGLES);  // 10 = SVC_SETVIEWANGLES
 163     if(self.tur_head)
 164     {
 165         WriteAngle(MSG_ONE, self.tur_head.angles_x + self.angles_x);    // tilt
 166         WriteAngle(MSG_ONE, self.tur_head.angles_y + self.angles_y);    // yaw
 167         WriteAngle(MSG_ONE, 0);    // roll
 168     }
 169     else
 170     {
 171         WriteByte (MSG_ONE, SVC_SETVIEWANGLES); // 10 = SVC_SETVIEWANGLES
 172         WriteAngle(MSG_ONE,  self.angles_x * -1);    // tilt
 173         WriteAngle(MSG_ONE,  self.angles_y);    // yaw
 174         WriteAngle(MSG_ONE,  0);                // roll
 175     }
 176
 177     vehicles_clearrturn();
 178
 179     if(self.vehicle_enter)
 180         self.vehicle_enter();
 181 }
 182
 183 void vehicles_exit(float eject)
 184 {
 185         self.colormap   = 1024;
 186         self.tur_head.colormap   = 1024;
 187
 188     if (teams_matter)
 189     {
 190         if (self.team == COLOR_TEAM1)
 191             self.colormod = '1.4 0.8 0.8';
 192
 193         if (self.team == COLOR_TEAM2)
 194             self.colormod = '0.8 0.8 1.4';
 195
 196         self.tur_head.colormod = self.colormod;
 197     }
 198
 199
 200         self.flags |= FL_NOTARGET;
 201
 202     if (self.owner)
 203     {
 204         msg_entity = self.owner;
 205         WriteByte (MSG_ONE, SVC_SETVIEWPORT);
 206         WriteEntity( MSG_ONE, self.owner);
 207
 208         WriteByte (MSG_ONE, SVC_SETVIEWANGLES);    // 10 = SVC_SETVIEWANGLES
 209         WriteAngle(MSG_ONE,  0);                   // tilt
 210         WriteAngle(MSG_ONE,  self.angles_y);        // yaw
 211         WriteAngle(MSG_ONE,  0);                   // roll
 212
 213         setsize(self.owner,PL_MIN,PL_MAX);
 214
 215         self.owner.takedamage     = DAMAGE_AIM;
 216         self.owner.solid          = SOLID_SLIDEBOX;
 217         self.owner.movetype       = MOVETYPE_WALK;
 218         self.owner.effects        &~= EF_NODRAW;
 219         self.owner.alpha          = 1;
 220         self.owner.PlayerPhysplug = SUB_Null;
 221         self.owner.vehicle        = world;
 222         self.owner.view_ofs       = PL_VIEW_OFS;
 223         self.owner.event_damage   = PlayerDamage;
 224         self.owner.hud            = HUD_NORMAL;
 225         self.owner.switchweapon   = self.switchweapon;
 226     }
 227
 228     self.vehicle_hudmodel.viewmodelforclient = self;
 229         self.tur_head.nodrawtoclient             = self;
 230
 231     if(self.vehicle_exit)
 232         self.vehicle_exit(eject);
 233
 234     self.owner = world;
 235 }
 236
 237
 238 void vehicles_regen(.float timer, .float regen_field, float field_max, float rpause, float regen, float delta_time)
 239 {
 240     if(self.regen_field < field_max)
 241     if(self.timer + rpause < time)
 242     {
 243         self.regen_field = min(self.regen_field + regen * delta_time, field_max);
 244
 245         if(self.owner)
 246             self.owner.regen_field = self.regen_field / field_max;
 247     }
 248 }
 249
 250 void shieldhit_think()
 251 {
 252     self.alpha -= 0.1;
 253     if (self.alpha <= 0)
 254     {
 255         setmodel(self, "");
 256         self.alpha = -1;
 257     }
 258     else
 259     {
 260         self.nextthink = time + 0.1;
 261     }
 262 }
 263
 264 void vehicles_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 265 {
 266     float ddmg_take;
 267
 268     self.dmg_time = time;
 269
 270     if((self.vehicle_flags & VHF_HASSHIELD) && (self.vehicle_shield > 0))
 271     {
 272         if (wasfreed(self.tur_head.enemy) || self.tur_head.enemy == world)
 273         {
 274             self.tur_head.enemy = spawn();
 275             self.tur_head.enemy.effects = EF_LOWPRECISION;
 276         }
 277
 278         setmodel(self.tur_head.enemy, "models/vhshield.md3");
 279         setattachment(self.tur_head.enemy, self, "");
 280
 281         self.tur_head.enemy.colormod    = '1 1 1';
 282         self.tur_head.enemy.alpha       = 0.45;
 283         self.tur_head.enemy.scale       = (256 / vlen(self.maxs - self.mins));
 284         self.tur_head.enemy.angles      = vectoangles(normalize(hitloc - self.origin)) - self.angles;
 285         self.tur_head.enemy.think       = shieldhit_think;
 286         self.tur_head.enemy.nextthink   = time;
 287
 288         self.vehicle_shield -= damage;
 289         if(self.vehicle_shield < 0)
 290         {
 291             self.tur_head.enemy.colormod = '10 0 -1';
 292             ddmg_take = fabs(self.vehicle_shield);
 293             self.vehicle_shield         = 0;
 294             self.tur_head.enemy.alpha   = 0.75;
 295             self.vehicle_health         -= ddmg_take;
 296         }
 297     }
 298     else
 299         self.vehicle_health -= damage;
 300
 301     if(self.vehicle_health <= 0)
 302     {
 303         if(self.owner)
 304             if(self.vehicle_flags & VHF_DEATHEJECT)
 305                 vehicles_exit(VHEF_EJECT);
 306             else
 307                 vehicles_exit(VHEF_RELESE);
 308
 309         self.vehicle_die();
 310     }
 311 }
 312
 313 void vehicles_return()
 314 {
 315     pointparticles(particleeffectnum("teleport"), self.enemy.origin + '0 0 64', '0 0 0', 1);
 316     self.enemy.think = self.use;
 317     self.enemy.nextthink = time;
 318     remove(self);
 319 }
 320
 321 void vehicles_clearrturn()
 322 {
 323     entity ret;
 324     // Remove "return helper", if any.
 325     ret = findchain(classname, "vehicle_return");
 326     while(ret)
 327     {
 328         if(ret.enemy == self)
 329         {
 330             ret.think = SUB_Remove;
 331             ret.nextthink = time + 0.1;
 332             return;
 333         }
 334         ret = ret.chain;
 335     }
 336 }
 337
 338 void vehicles_setreturn(float retime, void() respawn_proc)
 339 {
 340     vehicles_clearrturn();
 341
 342     if (self.deadflag == DEAD_NO)
 343     {
 344         entity ret;
 345
 346         ret = spawn();
 347         ret.classname = "vehicle_return";
 348         ret.enemy = self;
 349         ret.think = vehicles_return;
 350         ret.nextthink = time + retime;
 351         ret.use = respawn_proc;
 352     }
 353 }
 354
 355 float vehicles_customizeentityforclient()
 356 {
 357     if(self.deadflag == DEAD_DEAD)
 358         return FALSE;
 359
 360     return TRUE;
 361 }
 362
 363 void vehicles_configcheck(string  configname, float   check_cvar)
 364 {
 365     if(check_cvar == 0)
 366         localcmd(strcat("exec ", configname, "\n"));
 367 }
 368
 369 float vehicle_initialize(string  net_name,
 370                          string  bodymodel,
 371                          string  topmodel,
 372                          string  hudmodel,
 373                          string  toptag,
 374                          string  hudtag,
 375                          string  viewtag,
 376                          float   vhud,
 377                          vector min_s,
 378                          vector max_s,
 379                          float  nodrop,
 380                          void()  spawnproc,
 381                          float() physproc,
 382                          void()  enterproc,
 383                          void(float extflag) exitfunc,
 384                          void() dieproc,
 385                          void() thinkproc )
 386 {
 387     addstat(STAT_HUD, AS_INT,  hud);
 388         addstat(STAT_VEHICLESTAT_HEALTH,  AS_FLOAT, vehicle_health);
 389         addstat(STAT_VEHICLESTAT_SHIELD,  AS_FLOAT, vehicle_shield);
 390         addstat(STAT_VEHICLESTAT_ENERGY,  AS_FLOAT, vehicle_energy);
 391
 392         addstat(STAT_VEHICLESTAT_AMMO1,   AS_INT,   vehicle_ammo1);
 393         addstat(STAT_VEHICLESTAT_RELOAD1, AS_FLOAT, vehicle_reload1);
 394
 395         addstat(STAT_VEHICLESTAT_AMMO2,   AS_INT,   vehicle_ammo2);
 396         addstat(STAT_VEHICLESTAT_RELOAD2, AS_FLOAT, vehicle_reload2);
 397
 398     if(bodymodel == "")
 399         error("vehicles: missing bodymodel!");
 400
 401     if(hudmodel == "")
 402         error("vehicles: missing hudmodel!");
 403
 404     if(net_name == "")
 405         self.netname = self.classname;
 406     else
 407         self.netname = net_name;
 408
 409     if(self.team && !teams_matter)
 410         self.team = 0;
 411
 412     setmodel(self, bodymodel);
 413
 414     self.vehicle_viewport   = spawn();
 415     self.vehicle_hudmodel   = spawn();
 416     self.tur_head           = spawn();
 417     self.tur_head.owner     = self;
 418     self.takedamage         = DAMAGE_AIM;
 419     self.bot_attack         = TRUE;
 420     self.iscreature         = TRUE;
 421     self.hud                = vhud;
 422
 423     self.customizeentityforclient = vehicles_customizeentityforclient;
 424     self.vehicle_die        = dieproc;
 425     self.vehicle_exit       = exitfunc;
 426     self.vehicle_enter      = enterproc;
 427     self.PlayerPhysplug     = physproc;
 428     self.event_damage       = vehicles_damage;
 429     self.touch              = vehicles_touch;
 430     self.think              = spawnproc;
 431     self.nextthink          = time;
 432
 433     setmodel(self.vehicle_hudmodel, hudmodel);
 434     setmodel(self.vehicle_viewport, "null");
 435
 436     if(topmodel != "")
 437     {
 438         setmodel(self.tur_head, topmodel);
 439         setattachment(self.tur_head, self, toptag);
 440         setattachment(self.vehicle_hudmodel, self.tur_head, hudtag);
 441         setattachment(self.vehicle_viewport, self.vehicle_hudmodel, viewtag);
 442     }
 443     else
 444     {
 445         setattachment(self.tur_head, self, "");
 446         setattachment(self.vehicle_hudmodel, self, hudtag);
 447         setattachment(self.vehicle_viewport, self.vehicle_hudmodel, viewtag);
 448     }
 449
 450     setsize(self, min_s, max_s);
 451     if not (nodrop)
 452     {
 453         setorigin(self, self.origin);
 454         tracebox(self.origin + '0 0 100', min_s, max_s, self.origin - '0 0 10000', MOVE_WORLDONLY, self);
 455         setorigin(self, trace_endpos);
 456     }
 457
 458     self.pos1 = self.origin;
 459     self.pos2 = self.angles;
 460
 461     return TRUE;
 462 }
 463
 464 void bugmenot()
 465 {
 466     self.vehicle_exit       = self.vehicle_exit;
 467     self.vehicle_enter      = self.vehicle_exit;
 468     self.vehicle_die        = self.vehicle_exit;
 469     self.vehicle_spawn      = self.vehicle_exit;
 470     //self.vehicle_message    = self.vehicle_exit;
 471 }