data/qcsrc/server/vehicles/spiderbot.qc

   1 #define MODEL_SPIDERBOT_FORWARD_START 1
   2 #define MODEL_SPIDERBOT_FORWARD_END 31
   3 #define MODEL_SPIDERBOT_FORWARD_LENGTH 31
   4
   5 #define MODEL_SPIDERBOT_BACKWARDS_START 32
   6 #define MODEL_SPIDERBOT_BACKWARDS_END 62
   7 #define MODEL_SPIDERBOT_BACKWARDS_LENGTH 31
   8
   9 #define MODEL_SPIDERBOT_LEFT_START 63
  10 #define MODEL_SPIDERBOT_LEFT_END 93
  11 #define MODEL_SPIDERBOT_LEFT_LENGTH 31
  12
  13 #define MODEL_SPIDERBOT_RIGHT_START 94
  14 #define MODEL_SPIDERBOT_RIGHT_END 124
  15 #define MODEL_SPIDERBOT_RIGHT_LENGTH 31
  16
  17 #define MODEL_SPIDERBOT_JUMP_START 125
  18 #define MODEL_SPIDERBOT_JUMP_END 155
  19 #define MODEL_SPIDERBOT_JUMP_LENGTH 31
  20
  21 #define spiderbot_MIN '-75 -75 5'
  22 #define spiderbot_MAX '75 75 105'
  23
  24 /*
  25 .void() anim_now;
  26 .void() anim_next;
  27
  28 void spider_anim_idle()
  29 {
  30     movelib_beak_simple(cvar("g_vehicle_spiderbot_speed_stop"));
  31     if(self.anim_next != self.anim_now)
  32         self.anim_now = self.anim_next;
  33 }
  34
  35 void spider_anim_forward()
  36 {
  37     movelib_move_simple(normalize(v_forward),cvar("g_vehicle_spiderbot_speed_walk"),cvar("g_vehicle_spiderbot_movement_inertia"));
  38
  39     if((self.frame < MODEL_SPIDERBOT_FORWARD_START) || (self.frame > MODEL_SPIDERBOT_FORWARD_END))
  40         self.frame = MODEL_SPIDERBOT_FORWARD_START;
  41     else
  42         self.frame += 0.8;
  43
  44     if(self.frame > MODEL_SPIDERBOT_FORWARD_END)
  45         self.anim_now = self.anim_next;
  46 }
  47
  48 void spider_anim_backward()
  49 {
  50     movelib_move_simple(normalize(v_forward * -1),cvar("g_vehicle_spiderbot_speed_walk"),cvar("g_vehicle_spiderbot_movement_inertia"));
  51
  52     if(self.frame < MODEL_SPIDERBOT_BACKWARDS_START)
  53         self.frame = MODEL_SPIDERBOT_BACKWARDS_START;
  54     else
  55         self.frame += 0.8;
  56
  57     if(self.frame > MODEL_SPIDERBOT_BACKWARDS_END)
  58         self.anim_now = self.anim_next;
  59 }
  60
  61 void spider_anim_strafel()
  62 {
  63     movelib_move_simple(normalize(v_right * -1),cvar("g_vehicle_spiderbot_speed_strafe"),cvar("g_vehicle_spiderbot_movement_inertia"));
  64
  65     if(self.frame < MODEL_SPIDERBOT_LEFT_START)
  66         self.frame = MODEL_SPIDERBOT_LEFT_START;
  67     else
  68         self.frame += 0.8;
  69
  70     if(self.frame > MODEL_SPIDERBOT_LEFT_END)
  71         self.anim_now = self.anim_next;
  72 }
  73
  74 void spider_anim_strafer()
  75 {
  76     movelib_move_simple(normalize(v_right),cvar("g_vehicle_spiderbot_speed_strafe"),cvar("g_vehicle_spiderbot_movement_inertia"));
  77
  78     if(self.frame < MODEL_SPIDERBOT_RIGHT_START)
  79         self.frame = MODEL_SPIDERBOT_RIGHT_START;
  80     else
  81         self.frame += 0.8;
  82
  83     if(self.frame > MODEL_SPIDERBOT_RIGHT_END)
  84         self.anim_now = self.anim_next;
  85 }
  86
  87 void spider_anim_jump()
  88 {
  89     //movelib_move_simple(normalize(v_forward),cvar("g_vehicle_spiderbot_speed_walk"),cvar("g_vehicle_spiderbot_movement_inertia"));
  90
  91     if(self.frame < MODEL_SPIDERBOT_JUMP_START)
  92         self.frame = MODEL_SPIDERBOT_JUMP_START;
  93     else
  94         self.frame += 1;
  95
  96     if(self.frame <= 8)
  97         movelib_beak_simple(cvar("g_vehicle_spiderbot_speed_stop"));
  98
  99     if(self.frame == 9)
 100         self.velocity = v_forward * 400 + v_up * 400;
 101
 102     if(self.frame >= 19)
 103         movelib_beak_simple(cvar("g_vehicle_spiderbot_speed_stop"));
 104
 105     if(self.frame > MODEL_SPIDERBOT_JUMP_END)
 106         self.anim_now = self.anim_next;
 107 }
 108
 109 void anim_do()
 110 {
 111     if not (self.anim_now)
 112         self.anim_now = self.anim_next;
 113
 114     self.anim_now();
 115 }
 116
 117 */
 118
 119 /*
 120 void anim_do()
 121 {
 122     self.frame = self.frame + 0.8;
 123     if ((self.frame < self.anim_start) || (self.frame > self.anim_end))
 124         if(self.anim_start == 0)
 125         {
 126             self.frame = 0;
 127             self.anim_end = 0;
 128         }
 129         else
 130             self.frame = self.anim_start;
 131 }
 132 */
 133
 134 void spiderbot_exit(float eject);
 135 void spiderbot_enter();
 136
 137 void spiderbot_rocket_explode()
 138 {
 139     vector org2;
 140
 141     if(self.event_damage != SUB_Null)
 142     {
 143         self.event_damage = SUB_Null;
 144         self.think = spiderbot_rocket_explode;
 145         self.nextthink = time;
 146         return;
 147     }
 148
 149     sound (self, CHAN_PROJECTILE, "weapons/rocket_impact.wav", VOL_BASE, ATTN_NORM);
 150     org2 = findbetterlocation (self.origin, 16);
 151     pointparticles(particleeffectnum("rocket_explode"), org2, '0 0 0', 1);
 152     w_deathtypestring = "dident escape the rocket barrage";
 153
 154     if(!self.owner)
 155         self.owner = self.realowner;
 156
 157     RadiusDamage (self, self.owner,
 158      cvar("g_vehicle_spiderbot_rocket_damage"),
 159      cvar("g_vehicle_spiderbot_rocket_edgedamage"),
 160      cvar("g_vehicle_spiderbot_rocket_radius"), world,
 161      cvar("g_vehicle_spiderbot_rocket_force"), DEATH_TURRET, world);
 162
 163     remove (self);
 164 }
 165
 166 void spiderbot_rocket_touch()
 167 {
 168     if(self.owner)
 169     {
 170         if(other == self.owner.vehicle)
 171             return;
 172
 173         if(other == self.owner.vehicle.tur_head)
 174             return;
 175     }
 176
 177     PROJECTILE_TOUCH;
 178     spiderbot_rocket_explode();
 179 }
 180
 181 void spiderbot_rocket_think()
 182 {
 183     vector newdir,olddir;
 184
 185     self.nextthink  = time;
 186     if not(self.owner)
 187     {
 188         UpdateCSQCProjectile(self);
 189         return;
 190     }
 191
 192     self.solid      = SOLID_BBOX;
 193     self.touch      = spiderbot_rocket_touch;
 194     olddir = normalize(self.velocity);
 195     newdir = normalize(self.owner.cursor_trace_endpos - self.origin);
 196     newdir += randomvec() * cvar("g_vehicle_spiderbot_rocket_noise");
 197     self.velocity = normalize(olddir + newdir * cvar("g_vehicle_spiderbot_rocket_turnrate")) * cvar("g_vehicle_spiderbot_rocket_speed");
 198
 199     UpdateCSQCProjectile(self);
 200 }
 201
 202 void spiderbot_rocket_do()
 203 {
 204     entity missile;
 205
 206     if(self.gun2.cnt > time)
 207         return;
 208
 209     if(self.tur_head.frame > 7)
 210         self.tur_head.frame = 0;
 211
 212     if not (self.owner.BUTTON_ATCK2)
 213         return;
 214
 215     self.tur_head.frame += 1;
 216     if(self.tur_head.frame > 7)
 217         self.attack_finished_single = cvar("g_vehicle_spiderbot_rocket_reload");
 218     else
 219         self.attack_finished_single = cvar("g_vehicle_spiderbot_rocket_refire");
 220
 221     self.gun2.cnt = time + self.attack_finished_single;
 222
 223     sound (self, CHAN_WEAPON, "weapons/rocket_fire.wav", VOL_BASE, ATTN_NORM);
 224     missile                    = spawn ();
 225     setsize (missile, '-3 -1 -1', '3 1 1'); // give it some size so it can be shot
 226     setorigin(missile,gettaginfo(self.tur_head,gettagindex(self.tur_head,"tag_fire")));
 227     te_explosion (missile.origin);
 228
 229     missile.classname       = "spiderbot_rocket";
 230     missile.owner           = self.owner;
 231     missile.bot_dodge       = TRUE;
 232     missile.bot_dodgerating = 75;
 233     missile.nextthink       = time;// + 0.2;
 234     missile.movetype        = MOVETYPE_FLYMISSILE;
 235     missile.velocity        = normalize(v_forward + (v_up * 0.5) + randomvec() * 0.25) * cvar("g_vehicle_spiderbot_rocket_speed");
 236     missile.angles          = vectoangles(missile.velocity);
 237     missile.think           = spiderbot_rocket_think;
 238     missile.flags           = FL_PROJECTILE;
 239     missile.solid           = SOLID_NOT;
 240
 241         CSQCProjectile(missile, FALSE, PROJECTILE_ROCKET, FALSE); // no culling, has fly sound
 242 }
 243
 244 void spiderbot_minigun_fire_Flash_Go() {
 245         if (self.frame > 10){
 246                 self.alpha = -1;
 247                 setmodel(self,"");
 248                 return;
 249         }
 250
 251         self.frame = self.frame + 2;
 252         self.alpha = self.alpha - 0.2;
 253         self.nextthink = time + 0.02;
 254 }
 255
 256 void spiderbot_minigun_fire(entity gun,float trail)
 257 {
 258
 259     entity flash;
 260     vector v;
 261     v = gettaginfo(gun,gettagindex(gun,"barrels"));
 262     v_forward = normalize(v_forward);
 263
 264     sound (gun, CHAN_WEAPON, "weapons/uzi_fire.wav", VOL_BASE, ATTN_NORM);
 265
 266     fireBullet (v, v_forward, cvar("g_vehicle_spiderbot_minigun_spread"), cvar("g_vehicle_spiderbot_minigun_damage"),
 267         cvar("g_vehicle_spiderbot_minigun_spread"), DEATH_TURRET, 0);
 268
 269     if not (gun.enemy)
 270     {
 271         gun.enemy = spawn();
 272         setattachment(gun.enemy , gun, "barrels");
 273         setorigin(gun.enemy ,gun.enemy.origin + '48 0 0');
 274     }
 275
 276     flash = gun.enemy; //spawn();
 277     setmodel(flash, "models/uziflash.md3"); // precision set below
 278     flash.think = spiderbot_minigun_fire_Flash_Go;
 279     flash.nextthink = time + 0.02;
 280     flash.frame = 2;
 281     flash.angles_z = flash.v_angle_z + random() * 180;
 282     flash.alpha = 1;
 283     flash.effects = EF_ADDITIVE | EF_FULLBRIGHT | EF_LOWPRECISION;
 284     if(trail)
 285         trailparticles(self, particleeffectnum("EF_MGTURRETTRAIL"), v, trace_endpos);
 286 }
 287
 288 void spiderbot_miniguns_do()
 289 {
 290     if ((self.owner.BUTTON_ATCK) && (self.owner.vehicle_heat < 1) && (self.tur_head.attack_finished_single < time))
 291     {
 292
 293         self.gun1.angles_z += 36;
 294         self.gun2.angles_z -= 36;
 295         if(self.gun1.angles_z >= 360)
 296         {
 297             self.gun1.angles_z = 0;
 298             self.gun2.angles_z = 360;
 299         }
 300
 301         self = self.owner;
 302         if(self.uzi_bulletcounter == 1)
 303         {
 304             spiderbot_minigun_fire(self.vehicle.gun1,0);
 305             spiderbot_minigun_fire(self.vehicle.gun2,1);
 306             self.uzi_bulletcounter = 0;
 307         }
 308         else
 309         {
 310             spiderbot_minigun_fire(self.vehicle.gun1,1);
 311             spiderbot_minigun_fire(self.vehicle.gun2,0);
 312             self.uzi_bulletcounter += 1;
 313         }
 314
 315         self = self.vehicle;
 316         self.owner.vehicle_heat += cvar("g_vehicle_spiderbot_minigun_heat");
 317         if(self.owner.vehicle_heat >= 1)
 318         {
 319             self.vehicle_heat = 1;
 320             self.owner.vehicle_heat = 1;
 321             self.tur_head.attack_finished_single = (1/(cvar("g_vehicle_spiderbot_minigun_cooldown") * server_fps))+time;
 322         }
 323         else
 324             self.tur_head.attack_finished_single = cvar("g_vehicle_spiderbot_minigun_refire") + time;
 325
 326         return;
 327     }
 328     else
 329         if(self.vehicle_heat != 0)
 330         {
 331             self.vehicle_heat = max(self.vehicle_heat - cvar("g_vehicle_spiderbot_minigun_cooldown"),0);
 332             if(self.tur_head.attack_finished_single < time)
 333             {
 334                 self.vehicle_heat = 0;
 335                 self.owner.vehicle_heat = 0;
 336             }
 337             else
 338             {
 339                 if(self.tur_head.uzi_bulletcounter < time)
 340                 {
 341                     self.tur_head.uzi_bulletcounter = time + 0.2;
 342                     self.owner.vehicle_heat  = self.vehicle_heat;
 343                 }
 344                 else
 345                     self.owner.vehicle_heat = 1;
 346             }
 347         }
 348         else
 349             self.owner.vehicle_heat = max(self.owner.vehicle_heat - cvar("g_vehicle_spiderbot_minigun_cooldown"),0);
 350
 351 }
 352 #define SBS_IDLE  0
 353 #define SBS_JUMP  1
 354 #define SBS_WALK  2
 355 #define SBS_BACK  3
 356 #define SBS_LEFT  4
 357 #define SBS_RIGHT 5
 358 .float state;
 359
 360 float spiderbot_pplug()
 361 {
 362     vector ad;
 363     entity player,spider;
 364     float ftmp,ftmp2;
 365
 366     player = self;
 367     spider = self.vehicle;
 368
 369 /*
 370         self.BUTTON_ATCK = 0;
 371         self.button1 = 0;
 372         self.BUTTON_JUMP = 0;
 373         self.BUTTON_ATCK2 = 0;
 374
 375
 376         self.BUTTON_HOOK = 0;
 377         self.BUTTON_INFO = 0;
 378         self.button8 = 0;
 379         self.BUTTON_CHAT = 0;
 380         self.BUTTON_USE = 0;
 381 */
 382
 383     player.BUTTON_ZOOM = 0;
 384     player.BUTTON_CROUCH = 0;
 385
 386
 387     if(player.BUTTON_USE)
 388     {
 389         self = spider;
 390         spiderbot_exit(0);
 391         self = player;
 392         return 0;
 393     }
 394
 395     player.exteriormodeltoclient = spider.tur_head;
 396
 397     spider.tur_head.angles_x *= -1;
 398     spider.angles_x *= -1;
 399     //player.angles_x *= -1;
 400     makevectors(spider.angles);
 401
 402     //ad = player.v_angle - (spider.tur_head.angles + spider.angles);
 403     ad = player.v_angle -  (spider.tur_head.angles + spider.angles);
 404
 405     // Rotate head
 406     ftmp = cvar("g_vehicle_spiderbot_head_turnspeed") / server_fps;
 407     ftmp2 = ftmp * -1;
 408     spider.tur_head.angles_y += bound(ftmp2,shortangle_f(ad_y,spider.tur_head.angles_y),ftmp);
 409     spider.tur_head.angles_y = bound(cvar("g_vehicle_spiderbot_head_turnlimit") * -1,spider.tur_head.angles_y,cvar("g_vehicle_spiderbot_head_turnlimit"));
 410
 411     // Pitch head
 412     ftmp = cvar("g_vehicle_spiderbot_head_pitchspeed") / server_fps;
 413     ftmp2 = ftmp * -1;
 414     spider.tur_head.angles_x += bound(ftmp2,shortangle_f(ad_x,spider.tur_head.angles_x),ftmp);
 415     spider.tur_head.angles_x = bound(cvar("g_vehicle_spiderbot_head_pitchlimit_down"),spider.tur_head.angles_x,cvar("g_vehicle_spiderbot_head_pitchlimit_up"));
 416
 417     spider.tur_head.angles_x *= -1;
 418     spider.angles_x *= -1;
 419     //player.angles_x *= -1;
 420
 421     // Turn Body
 422     ftmp = cvar("g_vehicle_spiderbot_turnspeed") / server_fps;
 423     ftmp2 = ftmp * -1;
 424     ftmp = bound(ftmp2,spider.tur_head.angles_y,ftmp);
 425
 426     self = spider;
 427     if(spider.flags & FL_ONGROUND)
 428     {
 429         //if(spider.state != SBS_JUMP)
 430         if(player.BUTTON_JUMP)
 431         {
 432             player.BUTTON_JUMP = 0;
 433             spider.anim_start = MODEL_SPIDERBOT_JUMP_START;
 434             spider.anim_end   = MODEL_SPIDERBOT_JUMP_END;
 435             spider.velocity   = v_forward * 700 + v_up * 600;
 436             spider.state = SBS_JUMP;
 437             spider.frame = 4;
 438         }
 439         else
 440         {
 441             if(vlen(player.movement) == 0)
 442             {
 443                 movelib_beak_simple(cvar("g_vehicle_spiderbot_speed_stop"));
 444                 spider.anim_start = 0;
 445                 spider.anim_end = 0;
 446                 spider.state = SBS_IDLE;
 447                 spider.frame = 5;
 448             }
 449             else
 450             {
 451                 spider.angles_y = safeangle(spider.angles_y + ftmp);
 452                 spider.tur_head.angles_y -= ftmp;
 453
 454                 if(player.movement_x != 0)
 455                 {
 456                     if(player.movement_x > 0)
 457                     {
 458                         player.movement_x = 1;
 459                         spider.anim_start = MODEL_SPIDERBOT_FORWARD_START;
 460                         spider.anim_end   = MODEL_SPIDERBOT_FORWARD_END;
 461                         spider.state = SBS_WALK;
 462                         spider.frame = 0;
 463                     }
 464                     else if(player.movement_x < 0)
 465                     {
 466                         player.movement_x = -1;
 467                         spider.anim_start = MODEL_SPIDERBOT_BACKWARDS_START;
 468                         spider.anim_end   = MODEL_SPIDERBOT_BACKWARDS_END;
 469                         spider.state = SBS_BACK;
 470                         spider.frame = 1;
 471                     }
 472                     player.movement_y = 0;
 473                     movelib_move_simple(normalize(v_forward * player.movement_x),cvar("g_vehicle_spiderbot_speed_walk"),cvar("g_vehicle_spiderbot_movement_inertia"));
 474                 }
 475                 else if(player.movement_y != 0)
 476                 {
 477                     if(player.movement_y < 0)
 478                     {
 479                         player.movement_y = -1;
 480                         spider.anim_start = MODEL_SPIDERBOT_LEFT_START;
 481                         spider.anim_end   = MODEL_SPIDERBOT_LEFT_END;
 482                         spider.state = SBS_LEFT;
 483                         spider.frame = 2;
 484                     }
 485                     else if(player.movement_y > 0)
 486                     {
 487                         player.movement_y = 1;
 488                         spider.anim_start = MODEL_SPIDERBOT_RIGHT_START;
 489                         spider.anim_end   = MODEL_SPIDERBOT_RIGHT_END;
 490                         spider.state = SBS_RIGHT;
 491                         spider.frame = 3;
 492                     }
 493                     movelib_move_simple(normalize(v_right * player.movement_y),cvar("g_vehicle_spiderbot_speed_strafe"),cvar("g_vehicle_spiderbot_movement_inertia"));
 494                 }
 495
 496             }
 497         }
 498         movelib_groundalign4point(300,100,0.25);
 499     }
 500
 501     //anim_do();
 502     spiderbot_miniguns_do();
 503     spiderbot_rocket_do();
 504     vehicle_stdproc_regen();
 505
 506     player.BUTTON_ATCK = player.BUTTON_ATCK2 = 0;
 507     player.rockets = spider.tur_head.frame;
 508
 509     if(spider.gun2.cnt <= time)
 510         player.rockets_reload = 1;
 511     else
 512         player.rockets_reload = 1 - ((spider.gun2.cnt - time) /spider.attack_finished_single);
 513
 514     self = player;
 515
 516     setorigin(player,spider.origin + '0 0 64');
 517     player.velocity = spider.velocity;
 518
 519     return 1;
 520 }
 521
 522 void spiderbot_think()
 523 {
 524     if(self.flags & FL_ONGROUND)
 525     {
 526         movelib_beak_simple(cvar("g_vehicle_spiderbot_speed_stop"));
 527         //movelib_groundalign4point(300,100);
 528     }
 529
 530     self.nextthink = time;
 531 }
 532
 533 void spiderbot_enter()
 534 {
 535     self.owner = other;
 536
 537     self.event_damage         = vehicle_stdproc_damage ;
 538     self.colormap             = self.owner.colormap;
 539     self.tur_head.colormap    = self.owner.colormap;
 540     self.vehicle_hudmodel.viewmodelforclient = self.owner;
 541     self.nextthink = 0;
 542     self.owner.angles         = self.angles;
 543     self.owner.takedamage     = DAMAGE_NO;
 544     self.owner.solid          = SOLID_NOT;
 545     self.owner.movetype       = MOVETYPE_NOCLIP;
 546     self.owner.alpha          = -1;
 547     self.owner.PlayerPhysplug = spiderbot_pplug;
 548     self.owner.vehicle        = self;
 549     self.owner.event_damage   = SUB_Null;
 550     self.owner.hud            = HUD_SPIDERBOT;
 551     self.owner.vehicle_health = (self.vehicle_health / cvar("g_vehicle_spiderbot_health"));
 552     self.owner.vehicle_shield = (self.vehicle_shield / cvar("g_vehicle_spiderbot_shield"));
 553     self.team                   = self.owner.team;
 554
 555     //setorigin(self.owner,self.origin);
 556     //setattachment(self.owner,self,"");
 557     //setorigin(self.owner,'0 0 0');
 558
 559     msg_entity = other;
 560     WriteByte (MSG_ONE, SVC_SETVIEWPORT);
 561     WriteEntity( MSG_ONE, self.vehicle_viewport);
 562
 563     WriteByte (MSG_ONE, SVC_SETVIEWANGLES);  // 10 = SVC_SETVIEWANGLES
 564     WriteAngle(MSG_ONE, self.tur_head.angles_x + self.angles_x);    // tilt
 565     WriteAngle(MSG_ONE, self.tur_head.angles_y + self.angles_y);    // yaw
 566     WriteAngle(MSG_ONE, 0);    // roll
 567     //WriteAngle(MSG_ONE, self.tur_head.angles_z + self.angles_z);    // roll
 568
 569     //self.owner.view_ofs = '0 0 0';
 570     //self.tur_head.nodrawtoclient = self.owner;
 571 }
 572
 573 void spiderbot_exit(float eject)
 574 {
 575     entity e;
 576     self.frame = 5;
 577     e = findchain(classname,"spiderbot_rocket");
 578     while(e)
 579     {
 580         if(e.owner == self.owner)
 581         {
 582             e.realowner = self.owner;
 583             e.owner = world;
 584             //e.solid = SOLID_BBOX;
 585             //e.think = SUB_Null;
 586             //e.nextthink = -1;
 587         }
 588         e = e.chain;
 589     }
 590
 591     self.velocity = '0 0 0';
 592
 593     msg_entity = self.owner;
 594     WriteByte (MSG_ONE, SVC_SETVIEWPORT);
 595     WriteEntity( MSG_ONE, self.owner);
 596
 597     WriteByte (MSG_ONE, SVC_SETVIEWANGLES);  // 10 = SVC_SETVIEWANGLES
 598     WriteAngle(MSG_ONE, 0);    // tilt
 599     WriteAngle(MSG_ONE, self.angles_y);    // yaw
 600     WriteAngle(MSG_ONE, 0);    // roll
 601
 602     //setattachment(self.owner,world,"");
 603     self.think = spiderbot_think;
 604     self.nextthink = time;
 605     self.owner.takedamage     = DAMAGE_AIM;
 606     self.owner.solid          = SOLID_SLIDEBOX;
 607     self.owner.movetype       = MOVETYPE_WALK;
 608
 609     setsize(self.owner,PL_MIN,PL_MAX);
 610
 611     self.owner.alpha          = 1;
 612     self.owner.PlayerPhysplug = SUB_Null;
 613     self.owner.vehicle        = world;
 614         self.owner.view_ofs       = PL_VIEW_OFS;
 615         self.owner.hud            = HUD_NORMAL;
 616         self.owner.event_damage   = PlayerDamage;
 617
 618         self.colormap            = 1024;
 619         self.tur_head.colormap   = 1024;
 620     self.team                = -1;
 621
 622         self.vehicle_hudmodel.viewmodelforclient = self;
 623         self.tur_head.nodrawtoclient             = self;
 624
 625     setattachment(self.owner,world,"");
 626
 627         makevectors(self.angles);
 628         if(eject)
 629         {
 630             setorigin(self.owner,self.origin + v_forward * 100 + '0 0 64');
 631             self.owner.velocity = (v_up + v_forward * 0.25) * 750;
 632         }
 633         else
 634         setorigin(self.owner,self.origin - v_forward * 200 + '0 0 64');
 635
 636     self.owner = world;
 637 }
 638
 639 void spiderbot_touch()
 640 {
 641     if(self.owner)
 642     {
 643         if(vlen(self.velocity) == 0)
 644             return;
 645
 646         if(other.classname != "player")
 647             return;
 648
 649         //todo: add check for velocity here (so we dont cush players runing onto us from behind)
 650
 651         Damage(other,self,self.owner,cvar("g_vehicle_spiderbot_crush_dmg"),DEATH_TURRET,'0 0 0', normalize(other.origin - self.origin) * cvar("g_vehicle_spiderbot_crush_force") );
 652         return;
 653     }
 654
 655     if(other.classname != "player")
 656         return;
 657
 658     if(other.deadflag != DEAD_NO)
 659         return;
 660
 661     if(other.vehicle != world)
 662         return;
 663
 664     spiderbot_enter();
 665 }
 666
 667 float spiderbot_customizeentityforclient()
 668 {
 669     if(self.deadflag == DEAD_DEAD)
 670         return FALSE;
 671
 672     return TRUE;
 673 }
 674
 675 //void spiderbot_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force);
 676 void spiderbot_spawn()
 677 {
 678     self.frame = 5;
 679     self.think = spiderbot_think;
 680     self.nextthink = time;
 681
 682     self.vehicle_health = CCVAR("_health");
 683     self.vehicle_shield = CCVAR("_shield");
 684     self.event_damage = vehicle_stdproc_damage;
 685     self.iscreature = TRUE;
 686     self.movetype   = MOVETYPE_WALK;
 687     self.solid      = SOLID_SLIDEBOX;
 688     self.takedamage = DAMAGE_AIM;
 689     self.touch      = spiderbot_touch;
 690     self.alpha      = self.tur_head.alpha = self.gun1.alpha = self.gun2.alpha = 1;
 691     self.tur_head.angles = '0 0 0';
 692         self.colormap = 1024;
 693         self.tur_head.colormap = 1024;
 694         self.deadflag    = DEAD_NO;
 695     self.bot_attack = TRUE;
 696
 697     setsize(self,spiderbot_MIN,spiderbot_MAX);
 698     setorigin(self,self.tur_aimpos);
 699     pointparticles(particleeffectnum("teleport"), self.origin + '0 0 64', '0 0 0', 1);
 700 }
 701
 702 void spiderbot_blowup()
 703 {
 704     sound (self, CHAN_PROJECTILE, "weapons/rocket_impact.wav", VOL_BASE, ATTN_NORM);
 705     pointparticles(particleeffectnum("rocket_explode"), findbetterlocation (self.origin, 16), '0 0 0', 1);
 706
 707     RadiusDamage (self, self, 250, 15, 250, world, 250, DEATH_TURRET, world);
 708
 709     self.alpha = self.tur_head.alpha = self.gun1.alpha = self.gun2.alpha = -1;
 710     self.nextthink  = time + 10;
 711     self.think      = spiderbot_spawn;
 712
 713     setorigin(self,self.tur_aimpos);
 714 }
 715
 716 void spiderbot_die()
 717 {
 718
 719     self.health = 0;
 720     self.event_damage = SUB_Null;
 721     self.iscreature = FALSE;
 722     self.solid      = SOLID_NOT;
 723     self.takedamage = DAMAGE_NO;
 724     self.touch      = SUB_Null;
 725     self.nextthink  = time + random() * 2;
 726     self.think      = spiderbot_blowup;
 727     self.deadflag    = DEAD_DEAD;
 728         self.vehicle_hudmodel.viewmodelforclient = self;
 729         self.frame = 0;
 730         self.tur_head.frame = 0;
 731
 732 }
 733
 734 void vewhicle_spiderbot_dinit()
 735 {
 736
 737     server_fps = (1 / sys_ticrate);
 738
 739     addstat(STAT_HUD, AS_INT,  hud);
 740         addstat(STAT_SPIDERBOT_ROCKETS, AS_INT,   rockets);
 741         addstat(STAT_SPIDERBOT_RELOAD,  AS_FLOAT, rockets_reload);
 742         addstat(STAT_SPIDERBOT_HEAT,    AS_FLOAT, vehicle_heat);
 743         addstat(STAT_SPIDERBOT_HEALTH,  AS_FLOAT, vehicle_health);
 744         addstat(STAT_SPIDERBOT_SHIELD,  AS_FLOAT, vehicle_shield);
 745
 746     if (self.netname == "")      self.netname     = "spiderbot";
 747
 748     self.tur_head = spawn();
 749     self.gun1 = spawn();
 750     self.gun2 = spawn();
 751     self.vehicle_viewport = spawn();
 752     self.gravity = 2;
 753     self.vehicle_hudmodel = spawn();
 754     self.vehicle_flags = VHF_HASSHIELD | VHF_SHIELDREGEN | VHF_HEALTHREGEN;
 755     self.cvar_basename = "g_vehicle_spiderbot";
 756
 757     setmodel (self.vehicle_hudmodel, "models/spiderbot/cp.md3");
 758     setmodel (self.vehicle_viewport, "null");
 759     setmodel(self,"models/spiderbot/spiderbot.dpm");
 760     setmodel(self.tur_head,"models/spiderbot/spiderbot_top.dpm");
 761     setmodel(self.gun1,"models/spiderbot/spiderbot_barrels.dpm");
 762     setmodel(self.gun2,"models/spiderbot/spiderbot_barrels.dpm");
 763
 764     setattachment(self.tur_head,self,"tag_head");
 765     setattachment(self.vehicle_hudmodel,self.tur_head,"");
 766     setattachment(self.vehicle_viewport,self.vehicle_hudmodel,"");
 767     setattachment(self.gun1,self.tur_head,"tag_hardpoint01");
 768     setattachment(self.gun2,self.tur_head,"tag_hardpoint02");
 769
 770     self.tur_head.owner = self;
 771     self.customizeentityforclient          = spiderbot_customizeentityforclient;
 772
 773     setorigin(self.vehicle_viewport,'35 0 -14');
 774     self.tur_aimpos = self.origin;
 775     spiderbot_spawn();
 776
 777     self.vehicle_die = spiderbot_die;
 778     self.vehicle_exit = spiderbot_exit;
 779 }
 780
 781 void spawnfunc_vehicle_spiderbot()
 782 {
 783     // g_turrets_common_precash();
 784
 785     precache_model ( "models/vhshield.md3");
 786     precache_model ( "models/spiderbot/cp.md3");
 787     precache_model ( "models/spiderbot/spiderbot.dpm");
 788     precache_model ( "models/spiderbot/spiderbot_top.dpm");
 789     precache_model ( "models/spiderbot/spiderbot_barrels.dpm");
 790
 791     precache_model ( "models/turrets/rocket.md3");
 792     precache_sound ( "weapons/rocket_impact.wav" );
 793
 794     self.team                = -1;
 795     self.think = vewhicle_spiderbot_dinit;
 796     self.nextthink = time + 0.5;
 797 }