qcsrc/server/vehicles/bumblebee.qc

   1 #ifdef SVQC
   2 // Auto cvars
   3 float autocvar_g_vehicle_bumblebee_speed_forward;
   4 float autocvar_g_vehicle_bumblebee_speed_strafe;
   5 float autocvar_g_vehicle_bumblebee_speed_up;
   6 float autocvar_g_vehicle_bumblebee_speed_down;
   7 float autocvar_g_vehicle_bumblebee_turnspeed;
   8 float autocvar_g_vehicle_bumblebee_pitchspeed;
   9 float autocvar_g_vehicle_bumblebee_pitchlimit;
  10 float autocvar_g_vehicle_bumblebee_friction;
  11
  12 float autocvar_g_vehicle_bumblebee_energy;
  13 float autocvar_g_vehicle_bumblebee_energy_regen;
  14 float autocvar_g_vehicle_bumblebee_energy_regen_pause;
  15
  16 float autocvar_g_vehicle_bumblebee_health;
  17 float autocvar_g_vehicle_bumblebee_health_regen;
  18 float autocvar_g_vehicle_bumblebee_health_regen_pause;
  19
  20 float autocvar_g_vehicle_bumblebee_shield;
  21 float autocvar_g_vehicle_bumblebee_shield_regen;
  22 float autocvar_g_vehicle_bumblebee_shield_regen_pause;
  23
  24 float autocvar_g_vehicle_bumblebee_cannon_cost;
  25 float autocvar_g_vehicle_bumblebee_cannon_damage;
  26 float autocvar_g_vehicle_bumblebee_cannon_radius;
  27 float autocvar_g_vehicle_bumblebee_cannon_refire;
  28 float autocvar_g_vehicle_bumblebee_cannon_speed;
  29 float autocvar_g_vehicle_bumblebee_cannon_spread;
  30 float autocvar_g_vehicle_bumblebee_cannon_force;
  31
  32 float autocvar_g_vehicle_bumblebee_cannon_turnspeed;
  33 float autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down;
  34 float autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up;
  35 float autocvar_g_vehicle_bumblebee_cannon_turnlimit_in;
  36 float autocvar_g_vehicle_bumblebee_cannon_turnlimit_out;
  37
  38 float autocvar_g_vehicle_bumblebee_raygun_turnspeed;
  39 float autocvar_g_vehicle_bumblebee_raygun_pitchlimit_down;
  40 float autocvar_g_vehicle_bumblebee_raygun_pitchlimit_up;
  41 float autocvar_g_vehicle_bumblebee_raygun_turnlimit_sides;
  42
  43 float autocvar_g_vehicle_bumblebee_respawntime;
  44
  45 float autocvar_g_vehicle_bumblebee_blowup_radius;
  46 float autocvar_g_vehicle_bumblebee_blowup_coredamage;
  47 float autocvar_g_vehicle_bumblebee_blowup_edgedamage;
  48 float autocvar_g_vehicle_bumblebee_blowup_forceintensity;
  49
  50 float autocvar_g_vehicle_bumblebee;
  51
  52 #define BUMB_MIN '-120 -120 -120'
  53 #define BUMB_MAX '120 120 120'
  54
  55 void bumb_fire_cannon(entity _gun, string _tagname, entity _owner)
  56 {
  57     vector v;
  58     entity bolt;
  59
  60     v = gettaginfo(_gun, gettagindex(_gun, _tagname));
  61     bolt = vehicles_projectile("bigplasma_muzzleflash", "weapons/flacexp3.wav",
  62                            v, normalize(v_forward + randomvec() * autocvar_g_vehicle_bumblebee_cannon_spread) * autocvar_g_vehicle_bumblebee_cannon_speed,
  63                            autocvar_g_vehicle_bumblebee_cannon_damage, autocvar_g_vehicle_bumblebee_cannon_radius, autocvar_g_vehicle_bumblebee_cannon_force,  0,
  64                            DEATH_BUMB_GUN, PROJECTILE_BUMBLE_GUN, 0, TRUE, TRUE, _owner);
  65
  66
  67     //bolt.velocity = v_forward * autocvar_g_vehicle_bumblebee_cannon_speed;
  68 }
  69
  70 float bumb_gunner_frame()
  71 {
  72     entity vehic, gun, gunner;
  73
  74     vehic   = self.vehicle.owner;
  75     gun     = self.vehicle;
  76     gunner  = self;
  77     self    = vehic;
  78
  79     vehic.solid = SOLID_NOT;
  80     setorigin(gunner, vehic.origin);
  81     gunner.velocity = vehic.velocity;
  82     crosshair_trace(gunner);
  83     vector _ct = trace_endpos;
  84     vector ad;
  85
  86     if(gun.lock_time < time)
  87         gun.enemy = world;
  88
  89     if(trace_ent)
  90     if(trace_ent.movetype)
  91     if(trace_ent.takedamage)
  92     if(!trace_ent.deadflag)
  93     {
  94         if(teamplay)
  95         {
  96             if(trace_ent.team != gunner.team)
  97             {
  98                 gun.enemy = trace_ent;
  99                 gun.lock_time = time + 5;
 100             }
 101         }
 102         else
 103         {
 104             gun.enemy = trace_ent;
 105             gun.lock_time = time + 5;
 106         }
 107     }
 108
 109     if(gun.enemy)
 110     {
 111         float i, distance, impact_time;
 112
 113         vector vf = real_origin(gun.enemy);
 114         vector _vel = gun.enemy.velocity;
 115         if(gun.enemy.movetype == MOVETYPE_WALK)
 116             _vel_z *= 0.1;
 117
 118
 119         ad = vf;
 120         for(i = 0; i < 4; ++i)
 121         {
 122             distance = vlen(ad - gunner.origin);
 123             impact_time = distance / autocvar_g_vehicle_bumblebee_cannon_speed;
 124             ad = vf + _vel * impact_time;
 125         }
 126         trace_endpos = ad;
 127
 128
 129         UpdateAuxiliaryXhair(gunner, ad, '1 0 1', 1);
 130         vehicle_aimturret(vehic, trace_endpos, vehic.gun1, "fire",
 131                           autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down * -1,  autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up,
 132                           autocvar_g_vehicle_bumblebee_cannon_turnlimit_out * -1,  autocvar_g_vehicle_bumblebee_cannon_turnlimit_in,  autocvar_g_vehicle_bumblebee_cannon_turnspeed);
 133
 134     }
 135     else
 136         vehicle_aimturret(vehic, _ct, vehic.gun1, "fire",
 137                           autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down * -1,  autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up,
 138                           autocvar_g_vehicle_bumblebee_cannon_turnlimit_out * -1,  autocvar_g_vehicle_bumblebee_cannon_turnlimit_in,  autocvar_g_vehicle_bumblebee_cannon_turnspeed);
 139
 140     if(gunner.BUTTON_ATCK)
 141     if(time > gun.attack_finished_single)
 142     if(vehic.vehicle_energy >= autocvar_g_vehicle_bumblebee_cannon_cost)
 143     {
 144         vehic.vehicle_energy -= autocvar_g_vehicle_bumblebee_cannon_cost;
 145         vehic.wait = time;
 146         bumb_fire_cannon(gun, "fire", gunner);
 147         gun.attack_finished_single = time + autocvar_g_vehicle_bumblebee_cannon_refire;
 148     }
 149
 150     VEHICLE_UPDATE_PLAYER(gunner, health, bumblebee);
 151     VEHICLE_UPDATE_PLAYER(gunner, energy, bumblebee);
 152
 153     if(vehic.vehicle_flags & VHF_HASSHIELD)
 154         VEHICLE_UPDATE_PLAYER(gunner, shield, bumblebee);
 155
 156     ad = gettaginfo(gun, gettagindex(gun, "fire"));
 157     traceline(ad, ad + v_forward * MAX_SHOT_DISTANCE, MOVE_NORMAL, gun);
 158     UpdateAuxiliaryXhair(gunner, trace_endpos, ('1 0 0' * gunner.vehicle_reload1) + ('0 1 0' * (1 - gunner.vehicle_reload1)), 0);
 159
 160
 161     vehic.solid = SOLID_BBOX;
 162     gunner.BUTTON_ATCK = gunner.BUTTON_ATCK2 = gunner.BUTTON_CROUCH = 0;
 163     self = gunner;
 164     return 1;
 165 }
 166
 167 .entity gunner1;
 168 .entity gunner2;
 169
 170 void bumb_gunner_exit(float _exitflag)
 171 {
 172     dprint("^2Gunner1 exits\n");
 173
 174     if (clienttype(self) == CLIENTTYPE_REAL)
 175     {
 176         msg_entity = self;
 177         WriteByte (MSG_ONE, SVC_SETVIEWPORT);
 178         WriteEntity( MSG_ONE, self);
 179
 180         WriteByte (MSG_ONE, SVC_SETVIEWANGLES);
 181         WriteAngle(MSG_ONE, 0);
 182         WriteAngle(MSG_ONE, self.vehicle.angles_y);
 183         WriteAngle(MSG_ONE, 0);
 184     }
 185
 186     setsize(self, PL_MIN,PL_MAX);
 187
 188     self.takedamage     = DAMAGE_AIM;
 189     self.solid          = SOLID_SLIDEBOX;
 190     self.movetype       = MOVETYPE_WALK;
 191     self.effects        &~= EF_NODRAW;
 192     self.alpha          = 1;
 193     self.PlayerPhysplug = SUB_Null;
 194     self.view_ofs       = PL_VIEW_OFS;
 195     self.event_damage   = PlayerDamage;
 196     self.hud            = HUD_NORMAL;
 197     self.switchweapon   = self.vehicle.switchweapon;
 198
 199     if(self.flagcarried)
 200     {
 201         self.flagcarried.scale = 0.6;
 202         setattachment(self.flagcarried, self, "");
 203         setorigin(self.flagcarried, FLAG_CARRY_POS);
 204     }
 205
 206     CSQCVehicleSetup(self, HUD_NORMAL);
 207     self.vehicle.vehicle_hudmodel.viewmodelforclient = self.vehicle;
 208
 209     if(self == self.vehicle.owner.gunner1)
 210         self.vehicle.owner.gunner1 = world;
 211     else if(self == self.vehicle.owner.gunner2)
 212         self.vehicle.owner.gunner2 = world;
 213     else
 214         dprint("^1self != gunner1 or gunner2, this is a BIG PROBLEM, tell tZork this happend.\n");
 215
 216     self.vehicle.phase = time + 1;
 217     self.vehicle        = world;
 218 }
 219
 220 float bumb_gunner_enter()
 221 {
 222     RemoveGrapplingHook(other);
 223
 224     self.gun1.vehicle_pilot = other;
 225     self.gunner1            = other;
 226     //self.gun1.owner         = other;
 227     self.gunner1.vehicle    = self.gun1;
 228     self.gun1.switchweapon  = other.switchweapon;
 229     self.gun1.vehicle_exit  = bumb_gunner_exit;
 230
 231
 232     other.angles            = self.angles;
 233     other.takedamage        = DAMAGE_NO;
 234     other.solid             = SOLID_NOT;
 235     other.movetype          = MOVETYPE_NOCLIP;
 236     other.alpha             = -1;
 237     other.event_damage      = SUB_Null;
 238     other.view_ofs          = '0 0 0';
 239     other.hud               = self.gun1.hud;
 240     other.PlayerPhysplug    = self.gun1.PlayerPhysplug;
 241     other.vehicle_ammo1     = self.vehicle_ammo1;
 242     other.vehicle_ammo2     = self.vehicle_ammo2;
 243     other.vehicle_reload1   = self.vehicle_reload1;
 244     other.vehicle_reload2   = self.vehicle_reload2;
 245     other.vehicle_energy    = self.vehicle_energy;
 246     other.PlayerPhysplug    = bumb_gunner_frame;
 247     other.flags             &~= FL_ONGROUND;
 248
 249     msg_entity = other;
 250     WriteByte (MSG_ONE, SVC_SETVIEWPORT);
 251     WriteEntity(MSG_ONE, self.gun1.vehicle_viewport);
 252     WriteByte (MSG_ONE, SVC_SETVIEWANGLES);
 253     WriteAngle(MSG_ONE, self.gun1.angles_x + self.angles_x); // tilt
 254     WriteAngle(MSG_ONE, self.gun1.angles_y + self.angles_y); // yaw
 255     WriteAngle(MSG_ONE, 0);                                  // roll
 256     self.gun1.vehicle_hudmodel.viewmodelforclient = other;
 257
 258     return TRUE;
 259 }
 260
 261 float vehicles_valid_pilot()
 262 {
 263     if(other.classname != "player")
 264         return FALSE;
 265
 266     if(other.deadflag != DEAD_NO)
 267         return FALSE;
 268
 269     if(other.vehicle != world)
 270         return FALSE;
 271
 272     // Remove this when bots know how to use vehicles.
 273     if (clienttype(other) != CLIENTTYPE_REAL)
 274         return FALSE;
 275
 276     return TRUE;
 277 }
 278
 279 void bumb_touch()
 280 {
 281
 282     if(self.gunner1 != world && self.gunner2 != world)
 283     {
 284         vehicles_touch();
 285         return;
 286     }
 287
 288     if (vehicles_valid_pilot())
 289     {
 290         if(self.gun1.phase <= time)
 291             if (bumb_gunner_enter())
 292                 return;
 293
 294         if(self.gun2.phase <= time)
 295             if (bumb_gunner_enter())
 296                 return;
 297
 298     }
 299
 300     vehicles_touch();
 301 }
 302
 303 float bumb_pilot_frame()
 304 {
 305     entity pilot, vehic;
 306     vector newvel;
 307
 308     pilot = self;
 309     vehic = self.vehicle;
 310     self   = vehic;
 311
 312     if(vehic.deadflag != DEAD_NO)
 313     {
 314         self = pilot;
 315         pilot.BUTTON_ATCK = pilot.BUTTON_ATCK2 = 0;
 316         return 1;
 317     }
 318
 319     crosshair_trace(pilot);
 320
 321     vector vang;
 322     float ftmp;
 323
 324     vang = vehic.angles;
 325     newvel = vectoangles(normalize(trace_endpos - self.origin + '0 0 32'));
 326     vang_x *= -1;
 327     newvel_x *= -1;
 328     if(newvel_x > 180)  newvel_x -= 360;
 329     if(newvel_x < -180) newvel_x += 360;
 330     if(newvel_y > 180)  newvel_y -= 360;
 331     if(newvel_y < -180) newvel_y += 360;
 332
 333     ftmp = shortangle_f(pilot.v_angle_y - vang_y, vang_y);
 334     if(ftmp > 180)  ftmp -= 360; if(ftmp < -180) ftmp += 360;
 335     vehic.avelocity_y = bound(-autocvar_g_vehicle_bumblebee_turnspeed, ftmp + vehic.avelocity_y * 0.9, autocvar_g_vehicle_bumblebee_turnspeed);
 336
 337     // Pitch
 338     ftmp = 0;
 339     if(pilot.movement_x > 0 && vang_x < autocvar_g_vehicle_bumblebee_pitchlimit) ftmp = 5;
 340     else if(pilot.movement_x < 0 && vang_x > -autocvar_g_vehicle_bumblebee_pitchlimit) ftmp = -20;
 341
 342     newvel_x = bound(-autocvar_g_vehicle_bumblebee_pitchlimit, newvel_x , autocvar_g_vehicle_bumblebee_pitchlimit);
 343     ftmp = vang_x - bound(-autocvar_g_vehicle_bumblebee_pitchlimit, newvel_x + ftmp, autocvar_g_vehicle_bumblebee_pitchlimit);
 344     vehic.avelocity_x = bound(-autocvar_g_vehicle_bumblebee_pitchspeed, ftmp + vehic.avelocity_x * 0.9, autocvar_g_vehicle_bumblebee_pitchspeed);
 345
 346     vehic.angles_x = anglemods(vehic.angles_x);
 347     vehic.angles_y = anglemods(vehic.angles_y);
 348     vehic.angles_z = anglemods(vehic.angles_z);
 349
 350     makevectors('0 1 0' * vehic.angles_y);
 351     newvel = vehic.velocity * -autocvar_g_vehicle_bumblebee_friction;
 352
 353     if(pilot.movement_x != 0)
 354     {
 355         if(pilot.movement_x > 0)
 356             newvel += v_forward  * autocvar_g_vehicle_bumblebee_speed_forward;
 357         else if(pilot.movement_x < 0)
 358             newvel -= v_forward  * autocvar_g_vehicle_bumblebee_speed_forward;
 359     }
 360
 361     if(pilot.movement_y != 0)
 362     {
 363         if(pilot.movement_y < 0)
 364             newvel -= v_right * autocvar_g_vehicle_bumblebee_speed_strafe;
 365         else if(pilot.movement_y > 0)
 366             newvel += v_right * autocvar_g_vehicle_bumblebee_speed_strafe;
 367         ftmp = newvel * v_right;
 368         ftmp *= frametime * 0.1;
 369         vehic.angles_z = bound(-15, vehic.angles_z + ftmp, 15);
 370     }
 371     else
 372     {
 373         vehic.angles_z *= 0.95;
 374         if(vehic.angles_z >= -1 && vehic.angles_z <= -1)
 375             vehic.angles_z = 0;
 376     }
 377
 378     if(pilot.BUTTON_CROUCH)
 379         newvel -=   v_up * autocvar_g_vehicle_bumblebee_speed_down;
 380     else if (pilot.BUTTON_JUMP)
 381         newvel +=  v_up * autocvar_g_vehicle_bumblebee_speed_up;
 382
 383     vehic.velocity  += newvel * frametime;
 384     pilot.velocity = pilot.movement  = vehic.velocity;
 385     setorigin(pilot,vehic.origin + '0 0 32');
 386
 387     vehicle_aimturret(vehic, trace_endpos, self.gun3, "fire",
 388                           autocvar_g_vehicle_bumblebee_raygun_pitchlimit_down * -1,  autocvar_g_vehicle_bumblebee_raygun_pitchlimit_up,
 389                           autocvar_g_vehicle_bumblebee_raygun_turnlimit_sides * -1,  autocvar_g_vehicle_bumblebee_raygun_turnlimit_sides,  autocvar_g_vehicle_bumblebee_raygun_turnspeed);
 390
 391     /*
 392     if(!vehic.gunner1)
 393     vehicle_aimturret(vehic, trace_endpos, self.gun1, "fire",
 394                           autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down * -1,  autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up,
 395                           autocvar_g_vehicle_bumblebee_cannon_turnlimit_out * -1,  autocvar_g_vehicle_bumblebee_cannon_turnlimit_in,  autocvar_g_vehicle_bumblebee_cannon_turnspeed);
 396     //if(!vehic.gunner2)
 397     vehicle_aimturret(vehic, trace_endpos, self.gun2, "fire",
 398                           autocvar_g_vehicle_bumblebee_cannon_pitchlimit_down * -1,  autocvar_g_vehicle_bumblebee_cannon_pitchlimit_up,
 399                           autocvar_g_vehicle_bumblebee_cannon_turnlimit_in * -1,  autocvar_g_vehicle_bumblebee_cannon_turnlimit_out,  autocvar_g_vehicle_bumblebee_cannon_turnspeed);
 400
 401
 402
 403     if(pilot.BUTTON_ATCK)
 404     if(time > vehic.attack_finished_single)
 405     if(vehic.vehicle_energy >= autocvar_g_vehicle_bumblebee_cannon_cost)
 406     {
 407         vehic.vehicle_energy -= autocvar_g_vehicle_bumblebee_cannon_cost;
 408         vehic.wait = time;
 409
 410         if(vehic.cnt)
 411         {
 412             bumb_fire_cannon(vehic.gun1, "fire", pilot);
 413             vehic.cnt = 0;
 414         }
 415         else
 416         {
 417             bumb_fire_cannon(vehic.gun2, "fire", pilot);
 418             vehic.cnt = 1;
 419         }
 420         vehic.attack_finished_single = time + autocvar_g_vehicle_bumblebee_cannon_refire;
 421     }
 422     */
 423
 424     if(vehic.vehicle_flags  & VHF_SHIELDREGEN)
 425         vehicles_regen(dmg_time, vehicle_shield, autocvar_g_vehicle_bumblebee_shield, autocvar_g_vehicle_bumblebee_shield_regen_pause, autocvar_g_vehicle_bumblebee_shield_regen, frametime, TRUE);
 426
 427     if(vehic.vehicle_flags  & VHF_HEALTHREGEN)
 428         vehicles_regen(dmg_time, vehicle_health, autocvar_g_vehicle_bumblebee_health, autocvar_g_vehicle_bumblebee_health_regen_pause, autocvar_g_vehicle_bumblebee_health_regen, frametime, FALSE);
 429
 430     if(vehic.vehicle_flags  & VHF_ENERGYREGEN)
 431         vehicles_regen(wait, vehicle_energy, autocvar_g_vehicle_bumblebee_energy, autocvar_g_vehicle_bumblebee_energy_regen_pause, autocvar_g_vehicle_bumblebee_energy_regen, frametime, FALSE);
 432
 433     VEHICLE_UPDATE_PLAYER(pilot, health, bumblebee);
 434     VEHICLE_UPDATE_PLAYER(pilot, energy, bumblebee);
 435
 436     if(vehic.vehicle_flags & VHF_HASSHIELD)
 437         VEHICLE_UPDATE_PLAYER(pilot, shield, bumblebee);
 438
 439
 440     pilot.BUTTON_ATCK = pilot.BUTTON_ATCK2 = pilot.BUTTON_CROUCH = 0;
 441     self = pilot;
 442
 443     return 1;
 444 }
 445
 446 void bumb_think()
 447 {
 448     self.velocity = self.velocity * 0.99;
 449     self.nextthink = time + 0.1;
 450 }
 451
 452 void bumb_enter()
 453 {
 454     self.touch  = bumb_touch;
 455 }
 456
 457 void bumb_exit(float eject)
 458 {
 459     self.owner = world;
 460     self.touch = vehicles_touch;
 461 }
 462
 463 void bumb_spawn(float _f)
 464 {
 465     self.vehicle_health = autocvar_g_vehicle_bumblebee_health;
 466     self.vehicle_shield = autocvar_g_vehicle_bumblebee_shield;
 467     self.movetype       = MOVETYPE_TOSS;
 468     self.solid          = SOLID_BBOX;
 469     //self.vehicle_energy = 1;
 470     self.movetype = MOVETYPE_FLY;
 471     setorigin(self, self.origin + '0 0 25');
 472 }
 473
 474 void bumb_die()
 475 {
 476     self.deadflag    = DEAD_DEAD;
 477     self.vehicle_exit(VHEF_NORMAL);
 478
 479     self.health       = 0;
 480     self.event_damage = SUB_Null;
 481     self.solid        = SOLID_CORPSE;
 482     self.takedamage   = DAMAGE_NO;
 483     self.deadflag     = DEAD_DYING;
 484     self.movetype     = MOVETYPE_BOUNCE;
 485
 486     RadiusDamage (self, self.enemy, autocvar_g_vehicle_bumblebee_blowup_coredamage,
 487                                         autocvar_g_vehicle_bumblebee_blowup_edgedamage,
 488                                         autocvar_g_vehicle_bumblebee_blowup_radius, world,
 489                                         autocvar_g_vehicle_bumblebee_blowup_forceintensity,
 490                                         DEATH_WAKIBLOWUP, world);
 491
 492     pointparticles(particleeffectnum("rocket_explode"), findbetterlocation (self.origin, 16), '0 0 0', 1);
 493 }
 494
 495 void bumb_dinit()
 496 {
 497     if not (vehicle_initialize(
 498              "Bumblebee", "models/vehicles/bumblebee_body.dpm",
 499              "", "models/vehicles/spiderbot_cockpit.dpm", "", "", "tag_viewport",
 500              HUD_BUMBLEBEE, BUMB_MIN, BUMB_MAX, FALSE,
 501              bumb_spawn, autocvar_g_vehicle_bumblebee_respawntime,
 502              bumb_pilot_frame, bumb_enter, bumb_exit,
 503              bumb_die, bumb_think, FALSE, autocvar_g_vehicle_bumblebee_health))
 504     {
 505         remove(self);
 506         return;
 507     }
 508
 509
 510     self.gun1 = spawn();
 511     self.gun2 = spawn();
 512     self.gun3 = spawn();
 513
 514     self.vehicle_flags |= VHF_MULTISLOT;
 515
 516     self.gun1.owner = self;
 517     self.gun2.owner = self;
 518     self.gun3.owner = self;
 519
 520     setmodel(self.gun1, "models/vehicles/bumblebee_plasma_right.dpm");
 521     setmodel(self.gun2, "models/vehicles/bumblebee_plasma_left.dpm");
 522     setmodel(self.gun3, "models/vehicles/bumblebee_ray.dpm");
 523
 524     setattachment(self.gun1, self, "cannon_right");
 525     setattachment(self.gun2, self, "cannon_left");
 526     setattachment(self.gun3, self, "raygun");
 527
 528     vehicle_addplayerslot(self, self.gun1, HUD_RAPTOR, "models/vehicles/wakizashi_cockpit.dpm", bumb_gunner_frame, bumb_gunner_exit);
 529     vehicle_addplayerslot(self, self.gun2, HUD_RAPTOR, "models/vehicles/wakizashi_cockpit.dpm", bumb_gunner_frame, bumb_gunner_exit);
 530
 531     //fixme-model
 532     setorigin(self.gun1.vehicle_hudmodel, '90 -27 -23');
 533     setorigin(self.gun1.vehicle_viewport, '-85 0 50');
 534
 535     setorigin(self.gun2.vehicle_hudmodel, '90 -27 -23');
 536     setorigin(self.gun2.vehicle_viewport, '-85 0 50');
 537     self.scale = 1.5;
 538
 539     /*
 540     float i;
 541     for(i=1; gettaginfo(self.gun1, i), gettaginfo_name; ++i)
 542     {
 543
 544         dprint(" ------- ^1gettaginfo_name^2(",ftos(i),") ^3=", gettaginfo_name, "\n");
 545     }
 546     */
 547 }
 548
 549 void spawnfunc_vehicle_bumblebee()
 550 {
 551     if(!autocvar_g_vehicle_bumblebee)
 552     {
 553         remove(self);
 554         return;
 555     }
 556
 557     precache_model ("models/vehicles/bumblebee_body.dpm");
 558     precache_model ("models/vehicles/bumblebee_plasma_left.dpm");
 559     precache_model ("models/vehicles/bumblebee_plasma_right.dpm");
 560     precache_model ("models/vehicles/bumblebee_ray.dpm");
 561     precache_model ("models/vehicles/wakizashi_cockpit.dpm");
 562     precache_model ("models/vehicles/spiderbot_cockpit.dpm");
 563     precache_model ("models/vehicles/raptor_cockpit.dpm");
 564
 565     if(autocvar_g_vehicle_bumblebee_energy)
 566         if(autocvar_g_vehicle_bumblebee_energy_regen)
 567             self.vehicle_flags |= VHF_ENERGYREGEN;
 568
 569     if(autocvar_g_vehicle_bumblebee_shield)
 570         self.vehicle_flags |= VHF_HASSHIELD;
 571
 572     if(autocvar_g_vehicle_bumblebee_shield_regen)
 573         self.vehicle_flags |= VHF_SHIELDREGEN;
 574
 575     if(autocvar_g_vehicle_bumblebee_health_regen)
 576         self.vehicle_flags |= VHF_HEALTHREGEN;
 577
 578     self.think = bumb_dinit;
 579     self.nextthink = time + 1;
 580 }
 581 #endif // SVQC
 582
 583 #ifdef CSQC
 584 void bumblebee_draw()
 585 {
 586
 587 }
 588
 589 void bumblebee_draw2d()
 590 {
 591
 592 }
 593
 594 void bumblebee_read_extra()
 595 {
 596
 597 }
 598
 599 void vehicle_bumblebee_assemble()
 600 {
 601
 602 }
 603 #endif //CSQC
 604
 605 /*
 606 vector predict_target(entity _targ, vector _from, float _shot_speed)
 607 {
 608     float i;                // loop
 609     float _distance;        // How far to target
 610     float _impact_time;     // How long untill projectile impacts
 611     vector _predict_pos;    // Predicted enemy location
 612     vector _original_origin;// Where target is before predicted
 613
 614      _original_origin = real_origin(_targ); // Typicaly center of target BBOX
 615
 616     _predict_pos = _original_origin;
 617     for(i = 0; i < 4; ++i)  // Loop a few times to increase prediction accuracy (increase loop count if accuracy is to low)
 618     {
 619         _distance = vlen(_predict_pos - _from); // Get distance to previos predicted location
 620         _impact_time = _distance / _shot_speed; // Calculate impact time
 621         _predict_pos = _original_origin + _targ.velocity * _impact_time; // Calculate new predicted location
 622     }
 623
 624     return _predict_pos;
 625 }
 626 */