qcsrc/server/vehicles/spiderbot.qc

   1 #include "spiderbot.qh"
   2
   3 #ifdef SVQC
   4 float autocvar_g_vehicle_spiderbot;
   5
   6 float autocvar_g_vehicle_spiderbot_respawntime;
   7
   8 float autocvar_g_vehicle_spiderbot_speed_stop;
   9 float autocvar_g_vehicle_spiderbot_speed_strafe;
  10 float autocvar_g_vehicle_spiderbot_speed_walk;
  11 float autocvar_g_vehicle_spiderbot_turnspeed;
  12 float autocvar_g_vehicle_spiderbot_turnspeed_strafe;
  13 float autocvar_g_vehicle_spiderbot_movement_inertia;
  14
  15 float autocvar_g_vehicle_spiderbot_springlength;
  16 float autocvar_g_vehicle_spiderbot_springup;
  17 float autocvar_g_vehicle_spiderbot_springblend;
  18 float autocvar_g_vehicle_spiderbot_tiltlimit;
  19
  20 float autocvar_g_vehicle_spiderbot_head_pitchlimit_down;
  21 float autocvar_g_vehicle_spiderbot_head_pitchlimit_up;
  22 float autocvar_g_vehicle_spiderbot_head_turnlimit;
  23 float autocvar_g_vehicle_spiderbot_head_turnspeed;
  24
  25 //float autocvar_g_vehicle_spiderbot_energy;
  26 //float autocvar_g_vehicle_spiderbot_energy_regen;
  27 //float autocvar_g_vehicle_spiderbot_energy_regen_pause;
  28
  29 float autocvar_g_vehicle_spiderbot_health;
  30 float autocvar_g_vehicle_spiderbot_health_regen;
  31 float autocvar_g_vehicle_spiderbot_health_regen_pause;
  32
  33 float autocvar_g_vehicle_spiderbot_shield;
  34 float autocvar_g_vehicle_spiderbot_shield_regen;
  35 float autocvar_g_vehicle_spiderbot_shield_regen_pause;
  36
  37 float autocvar_g_vehicle_spiderbot_minigun_damage;
  38 float autocvar_g_vehicle_spiderbot_minigun_refire;
  39 float autocvar_g_vehicle_spiderbot_minigun_spread;
  40 float autocvar_g_vehicle_spiderbot_minigun_ammo_cost;
  41 float autocvar_g_vehicle_spiderbot_minigun_ammo_max;
  42 float autocvar_g_vehicle_spiderbot_minigun_ammo_regen;
  43 float autocvar_g_vehicle_spiderbot_minigun_ammo_regen_pause;
  44 float autocvar_g_vehicle_spiderbot_minigun_force;
  45 float autocvar_g_vehicle_spiderbot_minigun_solidpenetration;
  46
  47 float autocvar_g_vehicle_spiderbot_rocket_damage;
  48 float autocvar_g_vehicle_spiderbot_rocket_force;
  49 float autocvar_g_vehicle_spiderbot_rocket_radius;
  50 float autocvar_g_vehicle_spiderbot_rocket_speed;
  51 float autocvar_g_vehicle_spiderbot_rocket_spread;
  52 float autocvar_g_vehicle_spiderbot_rocket_refire;
  53 float autocvar_g_vehicle_spiderbot_rocket_refire2;
  54 float autocvar_g_vehicle_spiderbot_rocket_reload;
  55 float autocvar_g_vehicle_spiderbot_rocket_health;
  56 float autocvar_g_vehicle_spiderbot_rocket_noise;
  57 float autocvar_g_vehicle_spiderbot_rocket_turnrate;
  58 float autocvar_g_vehicle_spiderbot_rocket_lifetime;
  59
  60 float autocvar_g_vehicle_spiderbot_blowup_radius;
  61 float autocvar_g_vehicle_spiderbot_blowup_coredamage;
  62 float autocvar_g_vehicle_spiderbot_blowup_edgedamage;
  63 float autocvar_g_vehicle_spiderbot_blowup_forceintensity;
  64
  65 vector autocvar_g_vehicle_spiderbot_bouncepain;
  66
  67
  68 void spiderbot_exit(float eject);
  69 void spiderbot_enter();
  70 void spiderbot_spawn(float);
  71 const float SBRM_FIRST = 0;
  72 const float SBRM_VOLLY = 0;
  73 const float SBRM_GUIDE = 1;
  74 const float SBRM_ARTILLERY = 2;
  75 const float SBRM_LAST = 2;
  76
  77 void spiderbot_rocket_artillery()
  78 {
  79     self.nextthink  = time;
  80     UpdateCSQCProjectile(self);
  81 }
  82
  83 void spiderbot_rocket_unguided()
  84 {
  85     vector newdir, olddir;
  86
  87     self.nextthink  = time;
  88
  89     olddir = normalize(self.velocity);
  90     newdir = normalize(self.pos1 - self.origin) + randomvec() * autocvar_g_vehicle_spiderbot_rocket_noise;
  91     self.velocity = normalize(olddir + newdir * autocvar_g_vehicle_spiderbot_rocket_turnrate) * autocvar_g_vehicle_spiderbot_rocket_speed;
  92
  93     UpdateCSQCProjectile(self);
  94
  95     if (self.owner.deadflag != DEAD_NO || self.cnt < time || vlen(self.pos1 - self.origin) < 16)
  96         self.use();
  97 }
  98
  99 void spiderbot_rocket_guided()
 100 {
 101     vector newdir, olddir;
 102
 103     self.nextthink  = time;
 104
 105     if (!self.realowner.vehicle)
 106         self.think = spiderbot_rocket_unguided;
 107
 108     crosshair_trace(self.realowner);
 109     olddir = normalize(self.velocity);
 110     newdir = normalize(trace_endpos - self.origin) + randomvec() * autocvar_g_vehicle_spiderbot_rocket_noise;
 111     self.velocity = normalize(olddir + newdir * autocvar_g_vehicle_spiderbot_rocket_turnrate) * autocvar_g_vehicle_spiderbot_rocket_speed;
 112
 113     UpdateCSQCProjectile(self);
 114
 115     if (self.owner.deadflag != DEAD_NO || self.cnt < time)
 116         self.use();
 117 }
 118
 119 void spiderbot_guide_release()
 120 {
 121     entity rkt;
 122     rkt = findchainentity(realowner, self.owner);
 123     if (!rkt)
 124         return;
 125
 126     crosshair_trace(self.owner);
 127     while(rkt)
 128     {
 129         if(rkt.think == spiderbot_rocket_guided)
 130         {
 131             rkt.pos1 = trace_endpos;
 132             rkt.think = spiderbot_rocket_unguided;
 133         }
 134         rkt = rkt.chain;
 135     }
 136 }
 137
 138 float spiberbot_calcartillery_flighttime;
 139 vector spiberbot_calcartillery(vector org, vector tgt, float ht)
 140 {
 141         float grav, sdist, zdist, vs, vz, jumpheight;
 142         vector sdir;
 143
 144         grav  = autocvar_sv_gravity;
 145         zdist = tgt.z - org.z;
 146         sdist = vlen(tgt - org - zdist * '0 0 1');
 147         sdir  = normalize(tgt - org - zdist * '0 0 1');
 148
 149         // how high do we need to go?
 150         jumpheight = fabs(ht);
 151         if(zdist > 0)
 152                 jumpheight = jumpheight + zdist;
 153
 154         // push so high...
 155         vz = sqrt(2 * grav * jumpheight); // NOTE: sqrt(positive)!
 156
 157         // we start with downwards velocity only if it's a downjump and the jump apex should be outside the jump!
 158         if(ht < 0)
 159                 if(zdist < 0)
 160                         vz = -vz;
 161
 162         vector solution;
 163         solution = solve_quadratic(0.5 * grav, -vz, zdist); // equation "z(ti) = zdist"
 164         // ALWAYS solvable because jumpheight >= zdist
 165         if(!solution.z)
 166                 solution.y = solution.x; // just in case it is not solvable due to roundoff errors, assume two equal solutions at their center (this is mainly for the usual case with ht == 0)
 167         if(zdist == 0)
 168                 solution.x = solution.y; // solution_x is 0 in this case, so don't use it, but rather use solution_y (which will be sqrt(0.5 * jumpheight / grav), actually)
 169
 170         if(zdist < 0)
 171         {
 172                 // down-jump
 173                 if(ht < 0)
 174                 {
 175                         // almost straight line type
 176                         // jump apex is before the jump
 177                         // we must take the larger one
 178                         spiberbot_calcartillery_flighttime = solution.y;
 179                 }
 180                 else
 181                 {
 182                         // regular jump
 183                         // jump apex is during the jump
 184                         // we must take the larger one too
 185                         spiberbot_calcartillery_flighttime = solution.y;
 186                 }
 187         }
 188         else
 189         {
 190                 // up-jump
 191                 if(ht < 0)
 192                 {
 193                         // almost straight line type
 194                         // jump apex is after the jump
 195                         // we must take the smaller one
 196                         spiberbot_calcartillery_flighttime = solution.x;
 197                 }
 198                 else
 199                 {
 200                         // regular jump
 201                         // jump apex is during the jump
 202                         // we must take the larger one
 203                         spiberbot_calcartillery_flighttime = solution.y;
 204                 }
 205         }
 206         vs = sdist / spiberbot_calcartillery_flighttime;
 207
 208         // finally calculate the velocity
 209         return sdir * vs + '0 0 1' * vz;
 210 }
 211
 212 void spiderbot_rocket_do()
 213 {
 214
 215     vector v;
 216     entity rocket = world;
 217
 218     if (self.wait != -10)
 219     {
 220         if (self.owner.BUTTON_ATCK2 && self.vehicle_weapon2mode == SBRM_GUIDE)
 221         {
 222             if (self.wait == 1)
 223             if (self.tur_head.frame == 9 || self.tur_head.frame == 1)
 224             {
 225                 if(self.gun2.cnt < time && self.tur_head.frame == 9)
 226                     self.tur_head.frame = 1;
 227
 228                 return;
 229             }
 230             self.wait = 1;
 231         }
 232         else
 233         {
 234             if(self.wait)
 235                 spiderbot_guide_release();
 236
 237             self.wait = 0;
 238         }
 239     }
 240
 241     if(self.gun2.cnt > time)
 242         return;
 243
 244     if (self.tur_head.frame >= 9)
 245     {
 246         self.tur_head.frame = 1;
 247         self.wait = 0;
 248     }
 249
 250     if (self.wait != -10)
 251         if (!self.owner.BUTTON_ATCK2)
 252             return;
 253
 254
 255     v = gettaginfo(self.tur_head,gettagindex(self.tur_head,"tag_fire"));
 256
 257     switch(self.vehicle_weapon2mode)
 258     {
 259         case SBRM_VOLLY:
 260             rocket = vehicles_projectile("spiderbot_rocket_launch", "weapons/rocket_fire.wav",
 261                                    v, normalize(randomvec() * autocvar_g_vehicle_spiderbot_rocket_spread + v_forward) * autocvar_g_vehicle_spiderbot_rocket_speed,
 262                                    autocvar_g_vehicle_spiderbot_rocket_damage, autocvar_g_vehicle_spiderbot_rocket_radius, autocvar_g_vehicle_spiderbot_rocket_force, 1,
 263                                    DEATH_VH_SPID_ROCKET, PROJECTILE_SPIDERROCKET, autocvar_g_vehicle_spiderbot_rocket_health, false, true, self.owner);
 264             crosshair_trace(self.owner);
 265             float _dist = (random() * autocvar_g_vehicle_spiderbot_rocket_radius) + vlen(v - trace_endpos);
 266             _dist -= (random() * autocvar_g_vehicle_spiderbot_rocket_radius) ;
 267             rocket.nextthink  = time + (_dist / autocvar_g_vehicle_spiderbot_rocket_speed);
 268             rocket.think     = vehicles_projectile_explode;
 269
 270             if(self.owner.BUTTON_ATCK2 && self.tur_head.frame == 1)
 271                 self.wait = -10;
 272             break;
 273         case SBRM_GUIDE:
 274             rocket = vehicles_projectile("spiderbot_rocket_launch", "weapons/rocket_fire.wav",
 275                                    v, normalize(v_forward) * autocvar_g_vehicle_spiderbot_rocket_speed,
 276                                    autocvar_g_vehicle_spiderbot_rocket_damage, autocvar_g_vehicle_spiderbot_rocket_radius, autocvar_g_vehicle_spiderbot_rocket_force, 1,
 277                                    DEATH_VH_SPID_ROCKET, PROJECTILE_SPIDERROCKET, autocvar_g_vehicle_spiderbot_rocket_health, false, false, self.owner);
 278             crosshair_trace(self.owner);
 279             rocket.pos1       = trace_endpos;
 280             rocket.nextthink  = time;
 281             rocket.think      = spiderbot_rocket_guided;
 282
 283
 284         break;
 285         case SBRM_ARTILLERY:
 286             rocket = vehicles_projectile("spiderbot_rocket_launch", "weapons/rocket_fire.wav",
 287                                    v, normalize(v_forward) * autocvar_g_vehicle_spiderbot_rocket_speed,
 288                                    autocvar_g_vehicle_spiderbot_rocket_damage, autocvar_g_vehicle_spiderbot_rocket_radius, autocvar_g_vehicle_spiderbot_rocket_force, 1,
 289                                    DEATH_VH_SPID_ROCKET, PROJECTILE_SPIDERROCKET, autocvar_g_vehicle_spiderbot_rocket_health, false, true, self.owner);
 290
 291             crosshair_trace(self.owner);
 292
 293             rocket.pos1       = trace_endpos + randomvec() * (0.75 * autocvar_g_vehicle_spiderbot_rocket_radius);
 294             rocket.pos1_z       = trace_endpos.z;
 295
 296             traceline(v, v + '0 0 1' * MAX_SHOT_DISTANCE, MOVE_WORLDONLY, self);
 297             float h1 = 0.75 * vlen(v - trace_endpos);
 298
 299             //v = trace_endpos;
 300             traceline(v , rocket.pos1 + '0 0 1' * MAX_SHOT_DISTANCE, MOVE_WORLDONLY, self);
 301             float h2 = 0.75 * vlen(rocket.pos1 - v);
 302
 303             rocket.velocity  = spiberbot_calcartillery(v, rocket.pos1, ((h1 < h2) ? h1 : h2));
 304             rocket.movetype  = MOVETYPE_TOSS;
 305             rocket.gravity   = 1;
 306             //rocket.think     = spiderbot_rocket_artillery;
 307         break;
 308     }
 309     rocket.classname  = "spiderbot_rocket";
 310
 311     rocket.cnt = time + autocvar_g_vehicle_spiderbot_rocket_lifetime;
 312
 313     self.tur_head.frame += 1;
 314     if (self.tur_head.frame == 9)
 315         self.attack_finished_single = autocvar_g_vehicle_spiderbot_rocket_reload;
 316     else
 317         self.attack_finished_single = ((self.vehicle_weapon2mode ==  SBRM_VOLLY) ? autocvar_g_vehicle_spiderbot_rocket_refire2 : autocvar_g_vehicle_spiderbot_rocket_refire);
 318
 319     self.gun2.cnt = time + self.attack_finished_single;
 320 }
 321
 322 float spiderbot_aiframe()
 323 {
 324     return false;
 325 }
 326
 327 float spiderbot_frame()
 328 {
 329     vector ad, vf;
 330     entity player, spider;
 331     float ftmp;
 332
 333         if(intermission_running)
 334                 return 1;
 335
 336     player = self;
 337     spider = self.vehicle;
 338     self   = spider;
 339
 340     vehicles_painframe();
 341
 342     player.BUTTON_ZOOM      = 0;
 343     player.BUTTON_CROUCH    = 0;
 344     player.switchweapon     = 0;
 345
 346
 347 #if 1 // 0 to enable per-gun impact aux crosshairs
 348     // Avarage gun impact point's -> aux cross
 349     ad = gettaginfo(spider.tur_head, gettagindex(spider.tur_head, "tag_hardpoint01"));
 350     vf = v_forward;
 351     ad += gettaginfo(spider.tur_head, gettagindex(spider.tur_head, "tag_hardpoint02"));
 352     vf += v_forward;
 353     ad = ad * 0.5;
 354     v_forward = vf * 0.5;
 355     traceline(ad, ad + v_forward * MAX_SHOT_DISTANCE, MOVE_NORMAL, spider);
 356     UpdateAuxiliaryXhair(player, trace_endpos, ('1 0 0' * player.vehicle_reload1) + ('0 1 0' * (1 - player.vehicle_reload1)), 0);
 357 #else
 358     ad = gettaginfo(spider.gun1, gettagindex(spider.gun1, "barrels"));
 359     traceline(ad, ad + v_forward * MAX_SHOT_DISTANCE, MOVE_NORMAL, spider);
 360     UpdateAuxiliaryXhair(player, trace_endpos, ('1 0 0' * player.vehicle_reload1) + ('0 1 0' * (1 - player.vehicle_reload1)), 0);
 361     vf = ad;
 362     ad = gettaginfo(spider.gun2, gettagindex(spider.gun2, "barrels"));
 363     traceline(ad, ad + v_forward * MAX_SHOT_DISTANCE, MOVE_NORMAL, spider);
 364     UpdateAuxiliaryXhair(player, trace_endpos, ('1 0 0' * player.vehicle_reload1) + ('0 1 0' * (1 - player.vehicle_reload1)), 1);
 365     ad = 0.5 * (ad + vf);
 366 #endif
 367
 368     crosshair_trace(player);
 369     ad = vectoangles(normalize(trace_endpos - ad));
 370     ad = AnglesTransform_ToAngles(AnglesTransform_LeftDivide(AnglesTransform_FromAngles(spider.angles), AnglesTransform_FromAngles(ad))) - spider.tur_head.angles;
 371     ad = AnglesTransform_Normalize(ad, true);
 372     //UpdateAuxiliaryXhair(player, trace_endpos, ('1 0 0' * player.vehicle_reload2) + ('0 1 0' * (1 - player.vehicle_reload2)), 2);
 373
 374     // Rotate head
 375     ftmp = autocvar_g_vehicle_spiderbot_head_turnspeed * sys_frametime;
 376     ad.y = bound(-ftmp, ad.y, ftmp);
 377     spider.tur_head.angles_y = bound(autocvar_g_vehicle_spiderbot_head_turnlimit * -1, spider.tur_head.angles.y + ad.y, autocvar_g_vehicle_spiderbot_head_turnlimit);
 378
 379     // Pitch head
 380     ad.x = bound(ftmp * -1, ad.x, ftmp);
 381     spider.tur_head.angles_x = bound(autocvar_g_vehicle_spiderbot_head_pitchlimit_down, spider.tur_head.angles.x + ad.x, autocvar_g_vehicle_spiderbot_head_pitchlimit_up);
 382
 383
 384     //fixedmakevectors(spider.angles);
 385     makevectors(spider.angles + '-2 0 0' * spider.angles.x);
 386
 387     movelib_groundalign4point(autocvar_g_vehicle_spiderbot_springlength, autocvar_g_vehicle_spiderbot_springup, autocvar_g_vehicle_spiderbot_springblend, autocvar_g_vehicle_spiderbot_tiltlimit);
 388
 389     if(spider.flags & FL_ONGROUND)
 390     {
 391         if(spider.frame == 4 && self.tur_head.wait != 0)
 392         {
 393             sound (self, CH_TRIGGER_SINGLE, "vehicles/spiderbot_land.wav", VOL_VEHICLEENGINE, ATTEN_NORM);
 394             spider.frame = 5;
 395         }
 396
 397         if(player.BUTTON_JUMP && self.tur_head.wait < time)
 398         {
 399             sound (self, CH_TRIGGER_SINGLE, "vehicles/spiderbot_jump.wav", VOL_VEHICLEENGINE, ATTEN_NORM);
 400             //dprint("spiderbot_jump:", ftos(soundlength("vehicles/spiderbot_jump.wav")), "\n");
 401             self.delay = 0;
 402
 403             self.tur_head.wait = time + 2;
 404             player.BUTTON_JUMP = 0;
 405             spider.velocity   = v_forward * 700 + v_up * 600;
 406             spider.frame = 4;
 407         }
 408         else
 409         {
 410             if(vlen(player.movement) == 0)
 411             {
 412                 if(self.sound_nexttime < time || self.delay != 3)
 413                 {
 414                     self.delay = 3;
 415                     self.sound_nexttime = time + 6.486500; //soundlength("vehicles/spiderbot_idle.wav");
 416                     //dprint("spiderbot_idle:", ftos(soundlength("vehicles/spiderbot_idle.wav")), "\n");
 417                     sound (self, CH_TRIGGER_SINGLE, "vehicles/spiderbot_idle.wav", VOL_VEHICLEENGINE, ATTEN_NORM);
 418                 }
 419                 movelib_beak_simple(autocvar_g_vehicle_spiderbot_speed_stop);
 420                 spider.frame = 5;
 421             }
 422             else
 423             {
 424                 // Turn Body
 425                 if(player.movement_x == 0 && player.movement.y != 0)
 426                     ftmp = autocvar_g_vehicle_spiderbot_turnspeed_strafe * sys_frametime;
 427                 else
 428                     ftmp = autocvar_g_vehicle_spiderbot_turnspeed * sys_frametime;
 429
 430                 ftmp = bound(-ftmp, spider.tur_head.angles.y, ftmp);
 431                 spider.angles_y = anglemods(spider.angles.y + ftmp);
 432                 spider.tur_head.angles_y -= ftmp;
 433
 434                 if(player.movement.x != 0)
 435                 {
 436                     if(player.movement.x > 0)
 437                     {
 438                         player.movement_x = 1;
 439                         spider.frame = 0;
 440                     }
 441                     else if(player.movement.x < 0)
 442                     {
 443                         player.movement_x = -1;
 444                         spider.frame = 1;
 445                     }
 446                     player.movement_y = 0;
 447                     movelib_move_simple(normalize(v_forward * player.movement.x),autocvar_g_vehicle_spiderbot_speed_walk,autocvar_g_vehicle_spiderbot_movement_inertia);
 448
 449                     if(self.sound_nexttime < time || self.delay != 1)
 450                     {
 451                         self.delay = 1;
 452                         self.sound_nexttime = time + 6.486500; //soundlength("vehicles/spiderbot_walk.wav");
 453                         sound (self, CH_TRIGGER_SINGLE, "vehicles/spiderbot_walk.wav", VOL_VEHICLEENGINE, ATTEN_NORM);
 454                         //dprint("spiderbot_walk:", ftos(soundlength("vehicles/spiderbot_walk.wav")), "\n");
 455                     }
 456                 }
 457                 else if(player.movement.y != 0)
 458                 {
 459                     if(player.movement.y < 0)
 460                     {
 461                         player.movement_y = -1;
 462                         spider.frame = 2;
 463                     }
 464                     else if(player.movement.y > 0)
 465                     {
 466                         player.movement_y = 1;
 467                         spider.frame = 3;
 468                     }
 469                     movelib_move_simple(normalize(v_right * player.movement.y),autocvar_g_vehicle_spiderbot_speed_strafe,autocvar_g_vehicle_spiderbot_movement_inertia);
 470                     if(self.sound_nexttime < time || self.delay != 2)
 471                     {
 472                         self.delay = 2;
 473                         self.sound_nexttime = time + 6.486500; //soundlength("vehicles/spiderbot_strafe.wav");
 474                         sound (self, CH_TRIGGER_SINGLE, "vehicles/spiderbot_strafe.wav", VOL_VEHICLEENGINE, ATTEN_NORM);
 475                         //dprint("spiderbot_strafe:", ftos(soundlength("vehicles/spiderbot_strafe.wav")), "\n");
 476                     }
 477                 }
 478             }
 479         }
 480     }
 481
 482     self.angles_x = bound(-autocvar_g_vehicle_spiderbot_tiltlimit, self.angles.x, autocvar_g_vehicle_spiderbot_tiltlimit);
 483     self.angles_z = bound(-autocvar_g_vehicle_spiderbot_tiltlimit, self.angles.z, autocvar_g_vehicle_spiderbot_tiltlimit);
 484
 485     if(player.BUTTON_ATCK)
 486     {
 487         spider.cnt = time;
 488         if(spider.vehicle_ammo1 >= autocvar_g_vehicle_spiderbot_minigun_ammo_cost && spider.tur_head.attack_finished_single <= time)
 489         {
 490             entity gun;
 491             vector v;
 492             spider.misc_bulletcounter += 1;
 493
 494             self = player;
 495
 496             (spider.misc_bulletcounter % 2) ? gun = spider.gun1 : gun = spider.gun2;
 497             v = gettaginfo(gun, gettagindex(gun, "barrels"));
 498             v_forward = normalize(v_forward);
 499             v += v_forward * 50;
 500
 501             fireBullet(v, v_forward, autocvar_g_vehicle_spiderbot_minigun_spread, autocvar_g_vehicle_spiderbot_minigun_solidpenetration,
 502                                 autocvar_g_vehicle_spiderbot_minigun_damage, autocvar_g_vehicle_spiderbot_minigun_force, DEATH_VH_SPID_MINIGUN, 0);
 503
 504 //            fireBullet (v, v_forward, autocvar_g_vehicle_spiderbot_minigun_spread, autocvar_g_vehicle_spiderbot_minigun_damage,
 505 //                autocvar_g_vehicle_spiderbot_minigun_spread, DEATH_VH_SPID_MINIGUN, 0);
 506
 507             sound (gun, CH_WEAPON_A, "weapons/uzi_fire.wav", VOL_BASE, ATTEN_NORM);
 508             //trailparticles(self, particleeffectnum("spiderbot_minigun_trail"), v, trace_endpos);
 509             pointparticles(particleeffectnum("spiderbot_minigun_muzzleflash"), v, v_forward * 2500, 1);
 510
 511             self = spider;
 512
 513             spider.vehicle_ammo1 -= autocvar_g_vehicle_spiderbot_minigun_ammo_cost;
 514             spider.tur_head.attack_finished_single = time + autocvar_g_vehicle_spiderbot_minigun_refire;
 515             player.vehicle_ammo1 = (spider.vehicle_ammo1 / autocvar_g_vehicle_spiderbot_minigun_ammo_max) * 100;
 516             spider.gun1.angles_z += 45;
 517             spider.gun2.angles_z -= 45;
 518             if(spider.gun1.angles.z >= 360)
 519             {
 520                 spider.gun1.angles_z = 0;
 521                 spider.gun2.angles_z = 0;
 522             }
 523         }
 524     }
 525     else
 526         vehicles_regen(spider.cnt, vehicle_ammo1, autocvar_g_vehicle_spiderbot_minigun_ammo_max,
 527                                            autocvar_g_vehicle_spiderbot_minigun_ammo_regen_pause,
 528                                            autocvar_g_vehicle_spiderbot_minigun_ammo_regen, frametime, false);
 529
 530
 531     spiderbot_rocket_do();
 532
 533     if(self.vehicle_flags  & VHF_SHIELDREGEN)
 534         vehicles_regen(spider.dmg_time, vehicle_shield, autocvar_g_vehicle_spiderbot_shield, autocvar_g_vehicle_spiderbot_shield_regen_pause, autocvar_g_vehicle_spiderbot_shield_regen, frametime, true);
 535
 536     if(self.vehicle_flags  & VHF_HEALTHREGEN)
 537         vehicles_regen(spider.dmg_time, vehicle_health, autocvar_g_vehicle_spiderbot_health, autocvar_g_vehicle_spiderbot_health_regen_pause, autocvar_g_vehicle_spiderbot_health_regen, frametime, false);
 538
 539     player.BUTTON_ATCK = player.BUTTON_ATCK2 = 0;
 540     player.vehicle_ammo2 = spider.tur_head.frame;
 541
 542     if(spider.gun2.cnt <= time)
 543         player.vehicle_reload2 = 100;
 544     else
 545         player.vehicle_reload2 = 100 - ((spider.gun2.cnt - time) / spider.attack_finished_single) * 100;
 546
 547     setorigin(player, spider.origin + '0 0 1' * SPIDERBOT_MAX_z);
 548     player.velocity = spider.velocity;
 549
 550     VEHICLE_UPDATE_PLAYER(player, health, spiderbot);
 551
 552     if(self.vehicle_flags & VHF_HASSHIELD)
 553         VEHICLE_UPDATE_PLAYER(player, shield, spiderbot);
 554
 555     self = player;
 556     return 1;
 557 }
 558 void spiderbot_think()
 559 {
 560     if(self.flags & FL_ONGROUND)
 561         movelib_beak_simple(autocvar_g_vehicle_spiderbot_speed_stop);
 562
 563     self.nextthink = time;
 564 }
 565
 566 void spiderbot_enter()
 567 {
 568     self.vehicle_weapon2mode = SBRM_GUIDE;
 569     self.movetype   = MOVETYPE_WALK;
 570     CSQCVehicleSetup(self.owner, 0);
 571     self.owner.vehicle_health = (self.vehicle_health / autocvar_g_vehicle_spiderbot_health) * 100;
 572     self.owner.vehicle_shield = (self.vehicle_shield / autocvar_g_vehicle_spiderbot_shield) * 100;
 573
 574     if(self.owner.flagcarried)
 575     {
 576         setattachment(self.owner.flagcarried, self.tur_head, "");
 577         setorigin(self.owner.flagcarried, '-20 0 120');
 578     }
 579 }
 580
 581 void spiderbot_exit(float eject)
 582 {
 583     entity e;
 584     vector spot;
 585
 586     e = findchain(classname,"spiderbot_rocket");
 587     while(e)
 588     {
 589         if(e.owner == self.owner)
 590         {
 591             e.realowner = self.owner;
 592             e.owner = world;
 593         }
 594         e = e.chain;
 595     }
 596
 597     //self.velocity   = '0 0 0';
 598     self.think      = spiderbot_think;
 599     self.nextthink  = time;
 600     self.frame      = 5;
 601     self.movetype   = MOVETYPE_WALK;
 602
 603     if (!self.owner)
 604         return;
 605
 606         makevectors(self.angles);
 607         if(eject)
 608         {
 609             spot = self.origin + v_forward * 100 + '0 0 64';
 610             spot = vehicles_findgoodexit(spot);
 611             setorigin(self.owner , spot);
 612             self.owner.velocity = (v_up + v_forward * 0.25) * 750;
 613             self.owner.oldvelocity = self.owner.velocity;
 614         }
 615         else
 616         {
 617                 if(vlen(self.velocity) > autocvar_g_vehicle_spiderbot_speed_strafe)
 618                 {
 619                         self.owner.velocity = normalize(self.velocity) * vlen(self.velocity);
 620                         self.owner.velocity_z += 200;
 621                         spot = self.origin + v_forward * 128 + '0 0 64';
 622                         spot = vehicles_findgoodexit(spot);
 623                 }
 624                 else
 625                 {
 626                         self.owner.velocity = self.velocity * 0.5;
 627                         self.owner.velocity_z += 10;
 628                         spot = self.origin + v_forward * 256 + '0 0 64';
 629                         spot = vehicles_findgoodexit(spot);
 630                 }
 631             self.owner.oldvelocity = self.owner.velocity;
 632             setorigin(self.owner , spot);
 633         }
 634
 635         antilag_clear(self.owner);
 636     self.owner = world;
 637 }
 638
 639 void spider_impact()
 640 {
 641         if(autocvar_g_vehicle_spiderbot_bouncepain.x)
 642                 vehicles_impact(autocvar_g_vehicle_spiderbot_bouncepain.x, autocvar_g_vehicle_spiderbot_bouncepain.y, autocvar_g_vehicle_spiderbot_bouncepain.z);
 643 }
 644
 645 void spiderbot_headfade()
 646 {
 647         self.think = spiderbot_headfade;
 648         self.nextthink = self.fade_time;
 649         self.alpha = 1 - (time - self.fade_time) * self.fade_rate;
 650
 651     if(self.cnt < time || self.alpha < 0.1)
 652     {
 653         if(self.alpha > 0.1)
 654         {
 655             sound (self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
 656             pointparticles(particleeffectnum("explosion_big"), self.origin + '0 0 100', '0 0 0', 1);
 657         }
 658         remove(self);
 659     }
 660 }
 661
 662 void spiderbot_blowup()
 663 {
 664     if(self.cnt > time)
 665     {
 666         if(random() < 0.1)
 667         {
 668             sound (self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
 669             pointparticles(particleeffectnum("explosion_small"), randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
 670         }
 671         self.nextthink = time + 0.1;
 672         return;
 673     }
 674
 675     entity h, g1, g2, b;
 676     b = spawn();
 677     h = spawn();
 678     g1 = spawn();
 679     g2 = spawn();
 680
 681     setmodel(b,  "models/vehicles/spiderbot.dpm");
 682     setmodel(h,  "models/vehicles/spiderbot_top.dpm");
 683     setmodel(g1, "models/vehicles/spiderbot_barrels.dpm");
 684     setmodel(g2, "models/vehicles/spiderbot_barrels.dpm");
 685
 686     setorigin(b, self.origin);
 687     b.frame         = 11;
 688     b.angles        = self.angles;
 689     setsize(b, self.mins, self.maxs);
 690
 691     setorigin(h, gettaginfo(self, gettagindex(self, "tag_head")));
 692     h.movetype      = MOVETYPE_BOUNCE;
 693     h.solid         = SOLID_BBOX;
 694     h.velocity      = v_up * (500 + random() * 500) + randomvec() * 128;
 695     h.modelflags    = MF_ROCKET;
 696     h.effects       = EF_FLAME | EF_LOWPRECISION;
 697     h.avelocity     = randomvec() * 360;
 698
 699     h.alpha         = 1;
 700     h.cnt           = time + (3.5 * random());
 701     h.fade_rate     = 1 / min(autocvar_g_vehicle_spiderbot_respawntime, 10);
 702     h.fade_time     = time;
 703     h.think         = spiderbot_headfade;
 704     h.nextthink     = time;
 705
 706     setorigin(g1, gettaginfo(self.tur_head, gettagindex(self.tur_head, "tag_hardpoint01")));
 707     g1.movetype     = MOVETYPE_TOSS;
 708     g1.solid        = SOLID_CORPSE;
 709     g1.velocity     = v_forward * 700 + (randomvec() * 32);
 710     g1.avelocity    = randomvec() * 180;
 711
 712     setorigin(g2, gettaginfo(self.tur_head, gettagindex(self.tur_head, "tag_hardpoint02")));
 713     g2.movetype     = MOVETYPE_TOSS;
 714     g2.solid        = SOLID_CORPSE;
 715     g2.velocity     = v_forward * 700 + (randomvec() * 32);
 716     g2.avelocity    = randomvec() * 180;
 717
 718     h.colormod = b.colormod = g1.colormod = g2.colormod = '-2 -2 -2';
 719
 720     SUB_SetFade(b,  time + 5, min(autocvar_g_vehicle_spiderbot_respawntime, 1));
 721     //SUB_SetFade(h,  time, min(autocvar_g_vehicle_spiderbot_respawntime, 10));
 722     SUB_SetFade(g1, time, min(autocvar_g_vehicle_spiderbot_respawntime, 10));
 723     SUB_SetFade(g2, time, min(autocvar_g_vehicle_spiderbot_respawntime, 10));
 724
 725         RadiusDamage(self, self.enemy, autocvar_g_vehicle_spiderbot_blowup_coredamage,
 726                                 autocvar_g_vehicle_spiderbot_blowup_edgedamage,
 727                                 autocvar_g_vehicle_spiderbot_blowup_radius, world, world,
 728                                 autocvar_g_vehicle_spiderbot_blowup_forceintensity, DEATH_VH_SPID_DEATH, world);
 729
 730     self.alpha = self.tur_head.alpha = self.gun1.alpha = self.gun2.alpha = -1;
 731     self.movetype   = MOVETYPE_NONE;
 732     self.deadflag   = DEAD_DEAD;
 733     self.solid      = SOLID_NOT;
 734     self.tur_head.effects  &=  ~EF_FLAME;
 735         self.vehicle_hudmodel.viewmodelforclient = self;
 736         setorigin(self, self.pos1);
 737 }
 738
 739 void spiderbot_die()
 740 {
 741     self.health             = 0;
 742     self.event_damage       = func_null;
 743     self.takedamage         = DAMAGE_NO;
 744     self.touch              = func_null;
 745     self.cnt                = 3.4 + time + random() * 2;
 746     self.think              = spiderbot_blowup;
 747     self.nextthink          = time;
 748     self.deadflag           = DEAD_DYING;
 749         self.frame              = 5;
 750         self.tur_head.effects  |= EF_FLAME;
 751         self.colormod           = self.tur_head.colormod = '-1 -1 -1';
 752         self.frame              = 10;
 753         self.movetype           = MOVETYPE_TOSS;
 754 }
 755
 756 float spiderbot_impulse(float _imp)
 757 {
 758     switch(_imp)
 759     {
 760         case 10:
 761         case 15:
 762         case 18:
 763             self.vehicle.vehicle_weapon2mode += 1;
 764             if(self.vehicle.vehicle_weapon2mode > SBRM_LAST)
 765                 self.vehicle.vehicle_weapon2mode = SBRM_FIRST;
 766
 767             //centerprint(self, strcat("Rocket mode is ", ftos(self.vehicle.vehicle_weapon2mode)));
 768             CSQCVehicleSetup(self, 0);
 769             return true;
 770         case 12:
 771         case 16:
 772         case 19:
 773             self.vehicle.vehicle_weapon2mode -= 1;
 774             if(self.vehicle.vehicle_weapon2mode < SBRM_FIRST)
 775                 self.vehicle.vehicle_weapon2mode = SBRM_LAST;
 776
 777             //centerprint(self, strcat("Rocket mode is ", ftos(self.vehicle.vehicle_weapon2mode)));
 778             CSQCVehicleSetup(self, 0);
 779             return true;
 780
 781         /*
 782         case 17: // toss gun, could be used to exit?
 783             break;
 784         case 20: // Manual minigun reload?
 785             break;
 786         */
 787     }
 788     return false;
 789 }
 790
 791 void spiderbot_spawn(float _f)
 792 {
 793     if(!self.gun1)
 794     {
 795         self.vehicles_impulse   = spiderbot_impulse;
 796         self.gun1               = spawn();
 797         self.gun2               = spawn();
 798         setmodel(self.gun1, "models/vehicles/spiderbot_barrels.dpm");
 799         setmodel(self.gun2, "models/vehicles/spiderbot_barrels.dpm");
 800         setattachment(self.gun1, self.tur_head, "tag_hardpoint01");
 801         setattachment(self.gun2, self.tur_head, "tag_hardpoint02");
 802         self.gravity            = 2;
 803         self.mass               = 5000;
 804     }
 805
 806     self.frame              = 5;
 807     self.tur_head.frame     = 1;
 808     self.think              = spiderbot_think;
 809     self.nextthink          = time;
 810     self.vehicle_health     = autocvar_g_vehicle_spiderbot_health;
 811     self.vehicle_shield     = autocvar_g_vehicle_spiderbot_shield;
 812     self.movetype           = MOVETYPE_WALK;
 813     self.solid              = SOLID_SLIDEBOX;
 814     self.alpha              = self.tur_head.alpha = self.gun1.alpha = self.gun2.alpha = 1;
 815     self.tur_head.angles    = '0 0 0';
 816
 817     setorigin(self, self.pos1 + '0 0 128');
 818     self.angles = self.pos2;
 819     self.vehicle_impact = spider_impact;
 820     self.damageforcescale = 0.03;
 821 }
 822
 823 void spawnfunc_vehicle_spiderbot()
 824 {
 825     if(!autocvar_g_vehicle_spiderbot)
 826     {
 827         remove(self);
 828         return;
 829     }
 830
 831     self.vehicle_flags |= VHF_DMGSHAKE;
 832     //self.vehicle_flags |= VHF_DMGROLL;
 833     //self.vehicle_flags |= VHF_DMGHEADROLL;
 834
 835     precache_model ( "models/vhshield.md3");
 836     precache_model ( "models/vehicles/spiderbot.dpm");
 837     precache_model ( "models/vehicles/spiderbot_top.dpm");
 838     precache_model ( "models/vehicles/spiderbot_barrels.dpm");
 839     precache_model ( "models/vehicles/spiderbot_cockpit.dpm");
 840     precache_model ( "models/uziflash.md3");
 841
 842     precache_sound ( "weapons/uzi_fire.wav" );
 843     precache_sound ( "weapons/rocket_impact.wav");
 844
 845     precache_sound ( "vehicles/spiderbot_die.wav");
 846     precache_sound ( "vehicles/spiderbot_idle.wav");
 847     precache_sound ( "vehicles/spiderbot_jump.wav");
 848     precache_sound ( "vehicles/spiderbot_strafe.wav");
 849     precache_sound ( "vehicles/spiderbot_walk.wav");
 850     precache_sound ( "vehicles/spiderbot_land.wav");
 851
 852     if(autocvar_g_vehicle_spiderbot_shield)
 853         self.vehicle_flags |= VHF_HASSHIELD;
 854
 855     if(autocvar_g_vehicle_spiderbot_shield_regen)
 856         self.vehicle_flags |= VHF_SHIELDREGEN;
 857
 858     if(autocvar_g_vehicle_spiderbot_health_regen)
 859         self.vehicle_flags |= VHF_HEALTHREGEN;
 860
 861     if(!vehicle_initialize(
 862              "Spiderbot",
 863              "models/vehicles/spiderbot.dpm",
 864              "models/vehicles/spiderbot_top.dpm",
 865              "models/vehicles/spiderbot_cockpit.dpm",
 866              "tag_head", "tag_hud", "",
 867              HUD_SPIDERBOT,
 868              SPIDERBOT_MIN, SPIDERBOT_MAX,
 869              false,
 870              spiderbot_spawn, autocvar_g_vehicle_spiderbot_respawntime,
 871              spiderbot_frame,
 872              spiderbot_enter, spiderbot_exit,
 873              spiderbot_die,   spiderbot_think,
 874              false,
 875              autocvar_g_vehicle_spiderbot_health,
 876              autocvar_g_vehicle_spiderbot_shield))
 877     {
 878         remove(self);
 879         return;
 880     }
 881 }
 882 #endif // SVQC