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