qcsrc/server/vehicles/racer.qc

   1 #define RACER_MIN '-120 -120 -40'
   2 #define RACER_MAX '120 120 40'
   3 #define RACER_TICRATE 0.05
   4
   5 void racer_exit(float eject);
   6 void racer_enter();
   7
   8 // Auto cvars
   9 float autocvar_g_vehicle_racer_speed_afterburn;
  10 float autocvar_g_vehicle_racer_afterburn_cost;
  11
  12 float autocvar_g_vehicle_racer_anglestabilizer;
  13 float autocvar_g_vehicle_racer_downforce;
  14
  15 float autocvar_g_vehicle_racer_speed_forward;
  16 float autocvar_g_vehicle_racer_speed_strafe;
  17 float autocvar_g_vehicle_racer_springlength;
  18 float autocvar_g_vehicle_racer_upforcedamper;
  19
  20 float autocvar_g_vehicle_racer_hovertype;
  21 float autocvar_g_vehicle_racer_hoverpower;
  22
  23 float autocvar_g_vehicle_racer_turnroll;
  24 float autocvar_g_vehicle_racer_turnspeed;
  25 float autocvar_g_vehicle_racer_pitchspeed;
  26
  27 float autocvar_g_vehicle_racer_energy;
  28 float autocvar_g_vehicle_racer_energy_regen;
  29 float autocvar_g_vehicle_racer_energy_regen_pause;
  30
  31 float autocvar_g_vehicle_racer_health;
  32 float autocvar_g_vehicle_racer_health_regen;
  33 float autocvar_g_vehicle_racer_health_regen_pause;
  34
  35 float autocvar_g_vehicle_racer_shield;
  36 float autocvar_g_vehicle_racer_shield_regen;
  37 float autocvar_g_vehicle_racer_shield_regen_pause;
  38
  39 float autocvar_g_vehicle_racer_laser_cost;
  40 float autocvar_g_vehicle_racer_laser_damage;
  41 float autocvar_g_vehicle_racer_laser_radius;
  42 float autocvar_g_vehicle_racer_laser_refire;
  43 float autocvar_g_vehicle_racer_laser_speed;
  44
  45 float autocvar_g_vehicle_racer_rocket_accel;
  46 float autocvar_g_vehicle_racer_rocket_damage;
  47 float autocvar_g_vehicle_racer_rocket_radius;
  48 float autocvar_g_vehicle_racer_rocket_refire;
  49 float autocvar_g_vehicle_racer_rocket_speed;
  50 float autocvar_g_vehicle_racer_rocket_turnrate;
  51
  52 float autocvar_g_vehicle_racer_rocket_locktarget;
  53 float autocvar_g_vehicle_racer_rocket_locking_time;
  54 float autocvar_g_vehicle_racer_rocket_locking_releasetime;
  55 float autocvar_g_vehicle_racer_rocket_locked_time;
  56 float autocvar_g_vehicle_racer_rocket_locked_maxangle;
  57
  58 float autocvar_g_vehicle_racer_respawntime;
  59 float autocvar_g_vehicle_racer_collision_multiplier;
  60
  61 float autocvar_g_vehicle_racer_blowup_radius;
  62 float autocvar_g_vehicle_racer_blowup_coredamage;
  63 float autocvar_g_vehicle_racer_blowup_edgedamage;
  64 float autocvar_g_vehicle_racer_blowup_forceintensity;
  65
  66 var vector racer_force_from_tag(string tag_name, float spring_length, float max_power);
  67
  68 void racer_align4point()
  69 {
  70     vector push_vector, v_add;
  71     float fl_push, fr_push, bl_push, br_push;
  72
  73     push_vector  = racer_force_from_tag("tag_engine_fr", autocvar_g_vehicle_racer_springlength, autocvar_g_vehicle_racer_hoverpower);
  74     fr_push      = force_fromtag_normpower;
  75     vehicles_sweap_collision(force_fromtag_origin, self.velocity, frametime, v_add, autocvar_g_vehicle_racer_collision_multiplier);
  76
  77     push_vector += racer_force_from_tag("tag_engine_fl", autocvar_g_vehicle_racer_springlength, autocvar_g_vehicle_racer_hoverpower);
  78     fl_push      = force_fromtag_normpower;
  79     vehicles_sweap_collision(force_fromtag_origin, self.velocity, frametime, v_add, autocvar_g_vehicle_racer_collision_multiplier);
  80
  81     push_vector += racer_force_from_tag("tag_engine_br", autocvar_g_vehicle_racer_springlength, autocvar_g_vehicle_racer_hoverpower);
  82     br_push      = force_fromtag_normpower;
  83     vehicles_sweap_collision(force_fromtag_origin, self.velocity, frametime, v_add, autocvar_g_vehicle_racer_collision_multiplier);
  84
  85     push_vector += racer_force_from_tag("tag_engine_bl", autocvar_g_vehicle_racer_springlength, autocvar_g_vehicle_racer_hoverpower);
  86     bl_push      = force_fromtag_normpower;
  87     vehicles_sweap_collision(force_fromtag_origin, self.velocity, frametime, v_add, autocvar_g_vehicle_racer_collision_multiplier);
  88
  89     self.velocity += (push_vector * frametime);
  90
  91     // Anti ocilation
  92     if(self.velocity_z  > 0)
  93         self.velocity_z  *= autocvar_g_vehicle_racer_upforcedamper;
  94
  95     self.velocity += v_add;
  96     self.velocity_z -= autocvar_sv_gravity * frametime;
  97
  98     push_vector_x =  (fl_push - bl_push);
  99     push_vector_x += (fr_push - br_push);
 100     push_vector_x *= 360;
 101
 102     push_vector_z = (fr_push - fl_push);
 103     push_vector_z += (br_push - bl_push);
 104     push_vector_z *= 360;
 105
 106     // Apply angle diffrance
 107     self.angles_z += push_vector_z * frametime;
 108     self.angles_x += push_vector_x * frametime;
 109     // Apply stabilizer
 110     self.angles_x *= 1 - (autocvar_g_vehicle_racer_anglestabilizer * frametime);
 111     self.angles_z *= 1 - (autocvar_g_vehicle_racer_anglestabilizer * frametime);
 112 }
 113
 114 void racer_rocket_explode()
 115 {
 116         PROJECTILE_TOUCH;
 117     if(other.owner == self.owner)
 118         return;
 119
 120         self.event_damage = SUB_Null;
 121
 122     sound (self, CHAN_PROJECTILE, "weapons/rocket_impact.wav", VOL_BASE, ATTN_NORM);
 123     pointparticles(particleeffectnum("rocket_explode"), findbetterlocation (self.origin, 16), '0 0 0', 1);
 124     RadiusDamage (self, self.realowner ,autocvar_g_vehicle_racer_rocket_damage, 0, autocvar_g_vehicle_racer_rocket_radius, world, 150, DEATH_WAKIROCKET, world);
 125
 126     remove (self);
 127 }
 128
 129 void racer_bolt_explode()
 130 {
 131         PROJECTILE_TOUCH;
 132     pointparticles(particleeffectnum("wakizashi_gun_impact"), findbetterlocation (self.origin, 8), trace_plane_normal * 1000, 1);
 133     RadiusDamage (self, self.realowner, autocvar_g_vehicle_racer_laser_damage, 0, autocvar_g_vehicle_racer_laser_radius, world, 150, DEATH_WAKIGUN, world);
 134     sound (self, CHAN_PROJECTILE, "weapons/laserimpact.wav", VOL_BASE, ATTN_NORM);
 135     remove (self);
 136 }
 137
 138 void racer_fire_cannon(string tagname)
 139 {
 140     entity bolt;
 141     vector v;
 142
 143     bolt = spawn();
 144     sound (self, CHAN_WEAPON, "weapons/lasergun_fire.wav", VOL_BASE, ATTN_NORM);
 145
 146     setorigin(bolt, gettaginfo(self, gettagindex(self, tagname)));
 147     PROJECTILE_MAKETRIGGER(bolt);
 148
 149     bolt.movetype        = MOVETYPE_FLYMISSILE;
 150     bolt.flags           = FL_PROJECTILE | FL_NOTARGET;
 151     bolt.owner           = self;
 152     bolt.realowner       = self.owner;
 153     bolt.touch           = racer_bolt_explode;
 154     bolt.think           = racer_bolt_explode;
 155     bolt.nextthink       = time + 9;
 156
 157     bolt.bot_dodge       = TRUE;
 158     bolt.bot_dodgerating = autocvar_g_vehicle_racer_laser_damage;
 159
 160         // Fix z-aim (for chase mode)
 161     v = normalize(trace_endpos - bolt.origin);
 162     v_forward_z = v_z * 0.5;
 163
 164     bolt.velocity = v_forward * autocvar_g_vehicle_racer_laser_speed;
 165
 166     pointparticles(particleeffectnum("wakizashi_gun_muzzleflash"), bolt.origin, bolt.velocity, 1);
 167
 168     CSQCProjectile(bolt, TRUE, PROJECTILE_LASER, TRUE);
 169 }
 170
 171 void racer_rocket_groundhugger()
 172 {
 173     vector olddir, newdir;
 174     float oldvel, newvel;
 175
 176     self.nextthink  = time;
 177
 178     if ((self.owner.deadflag != DEAD_NO) || (self.cnt < time))
 179     {
 180         racer_rocket_explode();
 181         return;
 182     }
 183
 184     if not (self.realowner.vehicle)
 185     {
 186         UpdateCSQCProjectile(self);
 187         return;
 188     }
 189
 190     olddir = normalize(self.velocity);
 191     oldvel = vlen(self.velocity);
 192     newvel = oldvel + self.lip;
 193
 194     tracebox(self.origin, self.mins, self.maxs, self.origin + olddir * 64, MOVE_WORLDONLY,self);
 195     if(trace_fraction <= 0.5)
 196     {
 197         // Hitting somethign soon, just speed ahead
 198         self.velocity = olddir * newvel;
 199         UpdateCSQCProjectile(self);
 200         return;
 201     }
 202
 203     traceline(trace_endpos, trace_endpos - '0 0 64', MOVE_NORMAL, self);
 204     if(trace_fraction != 1.0)
 205     {
 206         newdir = normalize(trace_endpos + '0 0 64' - self.origin) * autocvar_g_vehicle_racer_rocket_turnrate;
 207         self.velocity = normalize(olddir + newdir) * newvel;
 208     }
 209     else
 210     {
 211         self.velocity = olddir * newvel;
 212         self.velocity_z -= 1600 * sys_frametime; // 2x grav looks better for this one
 213     }
 214
 215     UpdateCSQCProjectile(self);
 216     return;
 217 }
 218
 219 void racer_rocket_tracker()
 220 {
 221     vector olddir, newdir;
 222     float oldvel, newvel;
 223
 224     self.nextthink  = time;
 225
 226     if ((self.owner.deadflag != DEAD_NO) || (self.cnt < time))
 227     {
 228         racer_rocket_explode();
 229         return;
 230     }
 231
 232     if not (self.realowner.vehicle)
 233     {
 234         UpdateCSQCProjectile(self);
 235         return;
 236     }
 237
 238     olddir = normalize(self.velocity);
 239     oldvel = vlen(self.velocity);
 240     newvel = oldvel + self.lip;
 241     makevectors(vectoangles(olddir));
 242
 243     traceline(self.origin, self.origin + v_forward * 64 - '0 0 32', MOVE_NORMAL, self);
 244     newdir = normalize(self.enemy.origin - self.origin);
 245
 246     if(vlen(newdir - v_forward) > autocvar_g_vehicle_racer_rocket_locked_maxangle)
 247     {
 248         //bprint("Target lost!\n");
 249         //dprint("OF:", ftos(vlen(newdir - v_forward)), "\n");
 250         self.think = racer_rocket_groundhugger;
 251         return;
 252     }
 253
 254     if(trace_fraction != 1.0)
 255         newdir_z += 16 * sys_frametime;
 256
 257     self.velocity = normalize(olddir + newdir * autocvar_g_vehicle_racer_rocket_turnrate) * newvel;
 258     self.velocity_z -= 800 * sys_frametime;
 259
 260     UpdateCSQCProjectile(self);
 261     return;
 262 }
 263
 264 void racer_fire_rocket(string tagname, entity trg)
 265 {
 266     entity rocket;
 267
 268     sound (self, CHAN_WEAPON, "weapons/rocket_fire.wav", VOL_BASE, ATTN_NORM);
 269
 270     rocket = spawn();
 271     setsize (rocket, '-1 -1 -1', '1 1 1');
 272     setorigin(rocket, gettaginfo(self, gettagindex(self, tagname)));
 273
 274     rocket.lip              = autocvar_g_vehicle_racer_rocket_accel * sys_frametime;
 275     rocket.wait             = autocvar_g_vehicle_racer_rocket_turnrate;
 276     rocket.solid            = SOLID_BBOX;
 277     rocket.movetype         = MOVETYPE_FLYMISSILE;
 278     rocket.flags            = FL_PROJECTILE;
 279     rocket.owner            = self;
 280     rocket.realowner        = self.owner;
 281     rocket.touch            = racer_rocket_explode;
 282     rocket.bot_dodge        = TRUE;
 283     rocket.bot_dodgerating  = autocvar_g_vehicle_racer_rocket_damage;
 284     rocket.cnt              = time + 9;
 285     rocket.velocity         = v_forward * autocvar_g_vehicle_racer_rocket_speed;
 286
 287     if(trg)
 288         rocket.think            = racer_rocket_tracker;
 289     else
 290         rocket.think            = racer_rocket_groundhugger;
 291
 292     rocket.nextthink        = time;
 293     rocket.enemy            = trg;
 294
 295     CSQCProjectile(rocket, TRUE, PROJECTILE_ROCKET, TRUE);
 296 }
 297
 298 .float fire1_waspressed;
 299 .float fire2_waspressed;
 300 float racer_frame()
 301 {
 302     entity player, racer;
 303     vector df;
 304     float ftmp, ftmp2;
 305
 306     player          = self;
 307     racer           = self.vehicle;
 308
 309     player.BUTTON_ZOOM = player.BUTTON_CROUCH = 0;
 310
 311     self = racer;
 312
 313     if(player.BUTTON_USE)
 314     {
 315         vehicles_exit(VHEF_NORMAL);
 316         self = player;
 317         return 0;
 318     }
 319
 320     if(racer.deadflag != DEAD_NO)
 321     {
 322         self = player;
 323         player.BUTTON_ATCK = player.BUTTON_ATCK2 = 0;
 324         return 1;
 325     }
 326
 327     racer_align4point();
 328     // Move abt crosshir insted of v_angle. this allows custom chase camera.
 329     crosshair_trace(player);
 330 #if VEHICLES_VIEWROTATE_CROSSHAIR
 331     racer.angles_x *= -1;
 332     df = vectoangles(normalize(trace_endpos - self.origin + '0 0 32'));
 333     if(df_x > 180)  df_x -= 360;
 334     if(df_x < -180) df_x += 360;
 335     if(df_y > 180)  df_y -= 360;
 336     if(df_y < -180) df_y += 360;
 337
 338     // Yaw
 339     ftmp = autocvar_g_vehicle_racer_turnspeed * sys_frametime;
 340     ftmp2 = ftmp * -1;
 341
 342     ftmp = bound(ftmp2, shortangle_f(df_y - racer.angles_y, racer.angles_y), ftmp);
 343     ftmp2 = anglemods(racer.angles_y + ftmp);
 344
 345     // Roll
 346     ftmp = bound(-45, shortangle_f(df_z + ((racer.angles_y - ftmp2) * autocvar_g_vehicle_racer_turnroll), racer.angles_z), 45);
 347     ftmp = anglemods(racer.angles_z + ftmp) * frametime;
 348     racer.angles_z = bound(-65, racer.angles_z + ftmp, 65);
 349
 350     // Turn
 351     racer.angles_y = ftmp2;
 352
 353     // Pitch
 354     ftmp = autocvar_g_vehicle_racer_pitchspeed * sys_frametime;
 355     ftmp2 = ftmp * -1;
 356
 357     ftmp = bound(ftmp2, shortangle_f(player.v_angle_x - racer.angles_x, racer.angles_x), ftmp);
 358     racer.angles_x = anglemods(racer.angles_x + ftmp);
 359
 360     makevectors(racer.angles);
 361     racer.angles_x *= -1;
 362 #else
 363     racer.angles_x *= -1;
 364
 365     // Yaw
 366     ftmp = autocvar_g_vehicle_racer_turnspeed * sys_frametime;
 367     ftmp = bound(-ftmp, shortangle_f(player.v_angle_y - racer.angles_y, racer.angles_y), ftmp);
 368     racer.angles_y = anglemods(racer.angles_y + ftmp);
 369
 370     // Roll
 371     racer.angles_z += -ftmp * autocvar_g_vehicle_racer_turnroll * sys_frametime;
 372
 373     // Pitch
 374     ftmp = autocvar_g_vehicle_racer_pitchspeed  * sys_frametime;
 375     ftmp = bound(-ftmp, shortangle_f(player.v_angle_x - racer.angles_x, racer.angles_x), ftmp);
 376     racer.angles_x = bound(-30, anglemods(racer.angles_x + ftmp), 30);
 377
 378     makevectors(racer.angles);
 379     racer.angles_x *= -1;
 380 #endif
 381
 382     df = racer.velocity * -0.5;
 383
 384     if(player.movement_x != 0)
 385     {
 386         if(player.movement_x > 0)
 387             df += v_forward  * autocvar_g_vehicle_racer_speed_forward;
 388         else if(player.movement_x < 0)
 389             df -= v_forward  * autocvar_g_vehicle_racer_speed_forward;
 390     }
 391
 392     if(player.movement_y != 0)
 393     {
 394         if(player.movement_y < 0)
 395             df -= v_right * autocvar_g_vehicle_racer_speed_strafe;
 396         else if(player.movement_y > 0)
 397             df += v_right * autocvar_g_vehicle_racer_speed_strafe;
 398     }
 399
 400     // limit _z to avoid flying on normal thrust
 401     if(df_z > 0)
 402         df_z = min(df_z, 700);
 403
 404     // Afterburn
 405     if (player.BUTTON_JUMP)
 406     if(racer.vehicle_energy >= (autocvar_g_vehicle_racer_afterburn_cost * frametime))
 407     {
 408         racer.wait = time;
 409         racer.vehicle_energy -= autocvar_g_vehicle_racer_afterburn_cost * frametime;
 410         df += (v_forward * autocvar_g_vehicle_racer_speed_afterburn);
 411         self.owner.vehicle_energy = racer.vehicle_energy / autocvar_g_vehicle_racer_energy;
 412     }
 413
 414     racer.velocity  += df * frametime;
 415
 416     df = (vlen(racer.velocity) * autocvar_g_vehicle_racer_downforce * v_up) * frametime;
 417     racer.velocity  = racer.velocity - df;
 418     player.movement = racer.velocity;
 419
 420     if(player.BUTTON_ATCK)
 421     if(time > racer.attack_finished_single)
 422     if(racer.vehicle_energy >= autocvar_g_vehicle_racer_laser_cost)
 423     {
 424         racer.vehicle_energy -= autocvar_g_vehicle_racer_laser_cost;
 425         racer.wait = time;
 426
 427         crosshair_trace(player);
 428         if(racer.cnt)
 429         {
 430             racer_fire_cannon("tag_fire1");
 431             racer.cnt = 0;
 432         }
 433         else
 434         {
 435             racer_fire_cannon("tag_fire2");
 436             racer.cnt = 1;
 437         }
 438         racer.attack_finished_single = time + autocvar_g_vehicle_racer_laser_refire;
 439         self.owner.vehicle_energy = racer.vehicle_energy / autocvar_g_vehicle_racer_energy;
 440     }
 441
 442     if(autocvar_g_vehicle_racer_rocket_locktarget)
 443     {
 444         vehicles_locktarget2((1 / autocvar_g_vehicle_racer_rocket_locking_time) * frametime,
 445                          (1 / autocvar_g_vehicle_racer_rocket_locking_releasetime) * frametime,
 446                          autocvar_g_vehicle_racer_rocket_locked_time);
 447
 448         if(self.lock_target)
 449         {
 450             if(racer.lock_strength == 1)
 451                 UpdateAuxiliaryXhair(player, real_origin(self.lock_target), '1 0 0', 0);
 452             else if(self.lock_strength > 0.5)
 453                 UpdateAuxiliaryXhair(player, real_origin(self.lock_target), '0 1 0', 0);
 454             else if(self.lock_strength < 0.5)
 455                 UpdateAuxiliaryXhair(player, real_origin(self.lock_target), '0 0 1', 0);
 456         }
 457     }
 458
 459     if(time > racer.delay)
 460     if(player.BUTTON_ATCK2)
 461     {
 462         racer_fire_rocket("tag_rocket_r", ((self.lock_strength == 1 && self.lock_target) ? self.lock_target : world));
 463         racer_fire_rocket("tag_rocket_l", ((self.lock_strength == 1 && self.lock_target) ? self.lock_target : world));
 464
 465         self.lock_strength  = 0;
 466         self.lock_target    = world;
 467
 468         racer.delay = time + autocvar_g_vehicle_racer_rocket_refire;
 469         racer.lip = time;
 470     }
 471
 472     player.fire2_waspressed = player.BUTTON_ATCK2;
 473
 474     player.vehicle_reload1 = (time - racer.lip) / (racer.delay - racer.lip);
 475
 476     if(self.vehicle_flags  & VHF_SHIELDREGEN)
 477         vehicles_regen(dmg_time, vehicle_shield, autocvar_g_vehicle_racer_shield, autocvar_g_vehicle_racer_shield_regen_pause, autocvar_g_vehicle_racer_shield_regen, frametime);
 478
 479     if(self.vehicle_flags  & VHF_HEALTHREGEN)
 480         vehicles_regen(dmg_time, vehicle_health, autocvar_g_vehicle_racer_health, autocvar_g_vehicle_racer_health_regen_pause, autocvar_g_vehicle_racer_health_regen, frametime);
 481
 482     if(self.vehicle_flags  & VHF_ENERGYREGEN)
 483         vehicles_regen(wait, vehicle_energy, autocvar_g_vehicle_racer_energy, autocvar_g_vehicle_racer_energy_regen_pause, autocvar_g_vehicle_racer_energy_regen, frametime);
 484
 485
 486     VEHICLE_UPDATE_PLAYER(health, racer);
 487
 488     if(self.vehicle_flags & VHF_HASSHIELD)
 489         VEHICLE_UPDATE_PLAYER(shield, racer);
 490
 491
 492     player.BUTTON_ATCK = player.BUTTON_ATCK2 = 0;
 493     setorigin(player,racer.origin + '0 0 32');
 494     player.velocity = racer.velocity;
 495
 496     self = player;
 497     return 1;
 498 }
 499
 500 void racer_think()
 501 {
 502     float a, b, c;
 503
 504     self.nextthink = time;
 505
 506     a = autocvar_g_vehicle_racer_anglestabilizer;
 507     b = autocvar_g_vehicle_racer_springlength;
 508     c = autocvar_g_vehicle_racer_hoverpower;
 509
 510     autocvar_g_vehicle_racer_anglestabilizer = 36;
 511     autocvar_g_vehicle_racer_springlength = 96;
 512     autocvar_g_vehicle_racer_hoverpower = 300;
 513
 514     racer_align4point();
 515
 516     if(self.velocity_z < 0)
 517         self.velocity_z *= 0.95;
 518
 519     autocvar_g_vehicle_racer_anglestabilizer = a;
 520     autocvar_g_vehicle_racer_springlength = b;
 521     autocvar_g_vehicle_racer_hoverpower = c;
 522
 523     self.velocity_x *= 0.95;
 524     self.velocity_y *= 0.95;
 525 }
 526
 527 void racer_enter()
 528 {
 529     self.owner.vehicle_health = (self.vehicle_health / autocvar_g_vehicle_racer_health);
 530     self.owner.vehicle_shield = (self.vehicle_shield / autocvar_g_vehicle_racer_shield);
 531 }
 532
 533 void racer_spawn();
 534
 535 void racer_exit(float eject)
 536 {
 537     vehicles_setreturn(autocvar_g_vehicle_racer_respawntime, racer_spawn);
 538
 539     self.think      = racer_think;
 540     self.nextthink  = time;
 541
 542     if not (self.owner)
 543         return;
 544
 545         makevectors(self.angles);
 546         if(eject)
 547         {
 548             setorigin(self.owner, self.origin + v_forward * 100 + v_up * 32);
 549             self.owner.velocity = (v_up + v_forward * 0.25) * 750;
 550         }
 551         else
 552         {
 553             setorigin(self.owner, self.origin - v_forward * 100 + v_up * 32);
 554             self.owner.velocity = v_forward * -150;
 555         }
 556     self.owner = world;
 557 }
 558
 559 void racer_touch()
 560 {
 561     if(self.owner)
 562     {
 563         //self.velocity = 0.999 * self.velocity;
 564         // TO-DO Impact reaction (crush players, damage self on high speed impact etc)
 565         return;
 566     }
 567
 568     if(other.classname != "player")
 569         return;
 570
 571     if(other.deadflag != DEAD_NO)
 572         return;
 573
 574     if(other.vehicle != world)
 575         return;
 576
 577     vehicles_enter();
 578 }
 579
 580 void racer_spawn()
 581 {
 582     self.think = racer_think;
 583     self.nextthink = time;
 584
 585     self.flags      = FL_NOTARGET;
 586     self.effects   = 0;
 587
 588     self.vehicle_health = autocvar_g_vehicle_racer_health;
 589     self.vehicle_shield = autocvar_g_vehicle_racer_shield;
 590
 591     self.event_damage = vehicles_damage;
 592     self.touch      = racer_touch;
 593
 594     self.iscreature = TRUE;
 595     self.scale      = 0.5;
 596     self.movetype   = MOVETYPE_BOUNCEMISSILE;
 597     self.solid      = SOLID_SLIDEBOX;
 598     self.takedamage = DAMAGE_AIM;
 599
 600     self.alpha      = 1;
 601         self.colormap   = 1024;
 602         self.deadflag   = DEAD_NO;
 603     self.bot_attack = TRUE;
 604
 605     self.vehicle_energy = 1;
 606     self.vehicle_hudmodel.viewmodelforclient = self;
 607
 608     setorigin(self, self.pos1);
 609     self.angles = self.pos2;
 610
 611     setsize(self, RACER_MIN * 0.5, RACER_MAX * 0.5);
 612     pointparticles(particleeffectnum("teleport"), self.origin + '0 0 64', '0 0 0', 1);
 613     self.delay = time;
 614
 615     vehicles_common_spawn();
 616 }
 617
 618 void racer_blowup()
 619 {
 620
 621     sound (self, CHAN_PROJECTILE, "weapons/rocket_impact.wav", VOL_BASE, ATTN_NORM);
 622     pointparticles(particleeffectnum("rocket_explode"), self.origin, '0 0 0', 1);
 623
 624     self.deadflag    = DEAD_DEAD;
 625     self.vehicle_exit(VHEF_NORMAL);
 626
 627     RadiusDamage (self, self, autocvar_g_vehicle_racer_blowup_coredamage,
 628                                         autocvar_g_vehicle_racer_blowup_edgedamage,
 629                                         autocvar_g_vehicle_racer_blowup_radius, world,
 630                                         autocvar_g_vehicle_racer_blowup_forceintensity,
 631                                         DEATH_WAKIBLOWUP, world);
 632
 633     self.alpha = -1;
 634     self.nextthink  = time + autocvar_g_vehicle_racer_respawntime;
 635     self.think      = racer_spawn;
 636     self.movetype   = MOVETYPE_NONE;
 637     self.effects    = EF_NODRAW;
 638
 639     self.colormod  = '0 0 0';
 640     self.avelocity = '0 0 0';
 641     self.velocity  = '0 0 0';
 642
 643     setorigin(self, self.pos1);
 644 }
 645
 646 void racer_deadtouch()
 647 {
 648     self.avelocity_x *= 0.7;
 649     self.cnt -= 1;
 650     if(self.cnt <= 0)
 651         racer_blowup();
 652 }
 653
 654 void racer_die()
 655 {
 656     self.health       = 0;
 657     self.event_damage = SUB_Null;
 658     self.iscreature   = FALSE;
 659     self.solid        = SOLID_CORPSE;
 660     self.takedamage   = DAMAGE_NO;
 661     self.deadflag     = DEAD_DYING;
 662     self.movetype     = MOVETYPE_BOUNCE;
 663     self.wait         = time;
 664     self.cnt          = 1 + random() * 3;
 665     self.touch        = racer_deadtouch;
 666
 667     pointparticles(particleeffectnum("rocket_explode"), findbetterlocation (self.origin, 16), '0 0 0', 1);
 668
 669     self.velocity     += '0 0 700';
 670
 671     if(random() < 0.5)
 672         self.avelocity_z  = 16;
 673     else
 674         self.avelocity_z  = -16;
 675
 676     self.avelocity_x = -vlen(self.velocity) * 0.2;
 677
 678     self.colormod = '-0.5 -0.5 -0.5';
 679
 680         self.think     = racer_blowup;
 681         self.nextthink = 2 + time + random() * 3;
 682 }
 683
 684 void racer_dinit()
 685 {
 686     if not (vehicle_initialize(
 687              "Wakizashi",
 688              "models/vehicles/wakizashi.dpm",
 689              "",
 690              "models/vehicles/wakizashi_cockpit.dpm",
 691              "", "", "tag_viewport",
 692              HUD_WAKIZASHI,
 693              0.5 * RACER_MIN, 0.5 * RACER_MAX,
 694              FALSE,
 695              racer_spawn, racer_frame,
 696              racer_enter, racer_exit,
 697              racer_die,   racer_think))
 698     {
 699         remove(self);
 700         return;
 701     }
 702
 703     if(autocvar_g_vehicle_racer_hovertype != 0)
 704         racer_force_from_tag = vehicles_force_fromtag_maglev;
 705     else
 706         racer_force_from_tag = vehicles_force_fromtag_hover;
 707
 708     // FIXME: this be hakkz, fix the models insted (scale body, add tag_viewport to the hudmodel).
 709     self.scale = 0.5;
 710     setattachment(self.vehicle_hudmodel, self, "");
 711     setattachment(self.vehicle_viewport, self, "tag_viewport");
 712 }
 713
 714 void spawnfunc_vehicle_racer()
 715 {
 716
 717     precache_sound ("weapons/laserimpact.wav");
 718     precache_sound ("weapons/lasergun_fire.wav");
 719     precache_sound ("weapons/rocket_fire.wav");
 720     precache_sound ("weapons/rocket_impact.wav");
 721
 722     precache_model ("models/vhshield.md3");
 723     precache_model ("models/vehicles/wakizashi.dpm");
 724     precache_model ("models/vehicles/wakizashi_cockpit.dpm");
 725
 726
 727     vehicles_configcheck("vehicle_racer.cfg", autocvar_g_vehicle_racer_health);
 728     if(autocvar_g_vehicle_racer_energy)
 729         if(autocvar_g_vehicle_racer_energy_regen)
 730             self.vehicle_flags |= VHF_ENERGYREGEN;
 731
 732     if(autocvar_g_vehicle_racer_shield)
 733         self.vehicle_flags |= VHF_HASSHIELD;
 734
 735     if(autocvar_g_vehicle_racer_shield_regen)
 736         self.vehicle_flags |= VHF_SHIELDREGEN;
 737
 738     if(autocvar_g_vehicle_racer_health_regen)
 739         self.vehicle_flags |= VHF_HEALTHREGEN;
 740
 741     self.think = racer_dinit;
 742     self.nextthink = time + 1;
 743 }