qcsrc/server/vehicles/spiderbot.qc

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