data/qcsrc/server/tturrets/units/unit_ewheel.qc

   1 #define ewheel_amin_stop 0
   2 #define ewheel_amin_fwd_slow 1
   3 #define ewheel_amin_fwd_fast 2
   4 #define ewheel_amin_bck_slow 3
   5 #define ewheel_amin_bck_fast 4
   6
   7 void turret_ewheel_projectile_explode()
   8 {
   9     vector org2;
  10
  11     org2 = findbetterlocation (self.origin, 8);
  12     pointparticles(particleeffectnum("laser_impact"), org2, trace_plane_normal * 1000, 1);
  13     //w_deathtypestring = "saw the eweel. to late.";
  14 #ifdef TURRET_DEBUG
  15     float d;
  16
  17     d = RadiusDamage (self, self.owner, self.owner.shot_dmg, 0, self.owner.shot_radius, world, self.owner.shot_force, DEATH_TURRET, world);
  18     self.owner.tur_dbg_dmg_t_h = self.owner.tur_dbg_dmg_t_h + d; //self.owner.shot_dmg;
  19     self.owner.tur_dbg_dmg_t_f = self.owner.tur_dbg_dmg_t_f + self.owner.shot_dmg;
  20 #else
  21     RadiusDamage (self, self.owner, self.owner.shot_dmg, 0, self.owner.shot_radius, world, self.owner.shot_force, DEATH_TURRET, world);
  22 #endif
  23     sound (self, CHAN_PROJECTILE, "weapons/electro_impact.wav", VOL_BASE, ATTN_NORM);
  24
  25     remove (self);
  26 }
  27
  28
  29 void ewheel_attack()
  30 {
  31     entity proj;
  32     float i;
  33
  34     for (i = 0; i < 1; ++i)
  35     {
  36         turret_do_updates(self);
  37
  38         sound (self, CHAN_WEAPON, "weapons/lasergun_fire.wav", VOL_BASE, ATTN_NORM);
  39         pointparticles(particleeffectnum("laser_muzzleflash"), self.tur_shotorg, self.tur_shotdir_updated * 1000, 1);
  40
  41         proj                    = spawn ();
  42         setorigin(proj, self.tur_shotorg);
  43         proj.classname       = "ewheel bolt";
  44         proj.owner           = self;
  45         proj.bot_dodge       = FALSE;
  46         proj.bot_dodgerating = self.shot_dmg;
  47         proj.think           = turret_ewheel_projectile_explode;
  48         proj.nextthink       = time + 9;
  49         proj.solid           = SOLID_BBOX;
  50         proj.movetype        = MOVETYPE_FLYMISSILE;
  51         proj.velocity        = normalize(self.tur_shotdir_updated + randomvec() * self.shot_spread) * self.shot_speed;
  52         //proj.angles          = vectoangles(proj.velocity);
  53         proj.touch           = turret_ewheel_projectile_explode;
  54         proj.enemy           = self.enemy;
  55         proj.flags           = FL_PROJECTILE | FL_NOTARGET;
  56
  57         CSQCProjectile(proj, TRUE, PROJECTILE_LASER, TRUE);
  58
  59         self.tur_head.frame += 2;
  60
  61         if (self.tur_head.frame > 3)
  62             self.tur_head.frame = 0;
  63     }
  64
  65 }
  66
  67 /*
  68 float ewheel_moveverb_roam(float eval)
  69 {
  70     switch (eval)
  71     {
  72     case VCM_EVAL:
  73
  74         if (!self.enemy)
  75             return verb.verb_static_value;
  76
  77         return VS_CALL_NO;
  78
  79     case VCM_DO:
  80         self.angles_z = 0;
  81         makevectors(self.angles);
  82         self.moveto = v_forward * 128;
  83         self.steerto = steerlib_beamsteer(v_forward,1024,32,36,128);
  84         self.frame += 1;
  85         movelib_move_simple(v_forward,cvar("g_turrets_unit_ewheel_speed_fast"),0.4);
  86
  87         return VS_CALL_YES_DOING;
  88
  89     case VCM_REMOVE:
  90
  91     }
  92
  93     return VS_CALL_YES_DONE;
  94 }
  95 */
  96
  97 void ewheel_move_path()
  98 {
  99     // Do we have a path?
 100     if not(self.pathcurrent)
 101         return;
 102     else
 103     {
 104         // Are we close enougth to a path node to switch to the next?
 105         if (vlen(self.origin  - self.pathcurrent.origin) < 64)
 106             if (self.pathcurrent.path_next == world)
 107             {
 108                 // Path endpoint reached
 109                 pathlib_deletepath(self.pathcurrent.owner);
 110                 self.pathcurrent = world;
 111
 112                 if (self.pathgoal)
 113                 {
 114                     if (self.pathgoal.use)
 115                         self.pathgoal.use();
 116
 117                     if (self.pathgoal.enemy)
 118                     {
 119                         self.pathcurrent = pathlib_astar(self.pathgoal.origin,self.pathgoal.enemy.origin);
 120                         self.pathgoal = self.pathgoal.enemy;
 121                     }
 122                 }
 123                 else
 124                     self.pathgoal = world;
 125             }
 126             else
 127                 self.pathcurrent = self.pathcurrent.path_next;
 128     }
 129
 130
 131     if (self.pathcurrent)
 132     {
 133
 134         self.moveto = self.pathcurrent.origin;
 135         self.steerto = steerlib_attract2(self.moveto,0.5,500,0.95);
 136
 137         movelib_move_simple(v_forward,cvar("g_turrets_unit_ewheel_speed_fast"),0.4);
 138
 139         return;
 140     }
 141 }
 142
 143 void  ewheel_move_enemy()
 144 {
 145
 146     self.steerto = steerlib_arrive(self.enemy.origin,self.target_range_optimal);
 147
 148     //self.steerto = steerlib_standoff(self.enemy.origin,self.target_range_optimal);
 149     //self.steerto = steerlib_beamsteer(self.steerto,1024,64,68,256);
 150     self.moveto  = self.origin + self.steerto * 128;
 151
 152     if (self.tur_dist_enemy > self.target_range_optimal)
 153     {
 154         if ( self.tur_head.spawnshieldtime < 1 )
 155         {
 156             self.frame = ewheel_amin_fwd_fast;
 157             movelib_move_simple(v_forward ,cvar("g_turrets_unit_ewheel_speed_fast"),0.4);
 158         }
 159         else if (self.tur_head.spawnshieldtime < 2)
 160         {
 161
 162             self.frame = ewheel_amin_fwd_slow;
 163             movelib_move_simple(v_forward,cvar("g_turrets_unit_ewheel_speed_slow"),0.4);
 164        }
 165         else
 166         {
 167             self.frame = ewheel_amin_fwd_slow;
 168             movelib_move_simple(v_forward,cvar("g_turrets_unit_ewheel_speed_slower"),0.4);
 169         }
 170     }
 171     else if (self.tur_dist_enemy < self.target_range_optimal - 10)
 172     {
 173         self.frame = ewheel_amin_bck_slow;
 174         movelib_move_simple(v_forward * -1,cvar("g_turrets_unit_ewheel_speed_slow"),0.4);
 175     }
 176     else
 177     {
 178         self.frame = ewheel_amin_stop;
 179         movelib_beak_simple(cvar("g_turrets_unit_ewheel_speed_stop"));
 180     }
 181
 182
 183 }
 184 /*
 185 float ewheel_moveverb_runaway(float eval)
 186 {
 187     switch (eval)
 188     {
 189     case VCM_EVAL:
 190         if (self.spawnflags & TSF_NO_PATHBREAK)
 191             if (self.pathcurrent)
 192                 return VS_CALL_NO;
 193
 194         if (self.enemy)
 195             if (self.health < 50)
 196                 return verb.verb_static_value;
 197
 198         return VS_CALL_NO;
 199
 200     case VCM_DO:
 201         self.steerto = (steerlib_push(self.enemy.origin) * 0.7) + (steerlib_traceavoid_flat(0.3, 500, '0 0 128') * 0.3);
 202         self.moveto  = self.origin + self.steerto * 1000;
 203
 204         self.frame += 2;
 205         movelib_move_simple(v_forward ,cvar("g_turrets_unit_ewheel_speed_fast"),0.4);
 206
 207         return VS_CALL_YES_DOING;
 208
 209     }
 210
 211     return VS_CALL_YES_DONE;
 212 }
 213 */
 214
 215 void ewheel_move_idle()
 216 {
 217     self.frame = 0;
 218     if (vlen(self.velocity))
 219         movelib_beak_simple(cvar("g_turrets_unit_ewheel_speed_stop"));
 220 }
 221
 222 void ewheel_postthink()
 223 {
 224     float vz;
 225     vector wish_angle,real_angle;
 226
 227     vz = self.velocity_z;
 228
 229     self.angles_x = anglemods(self.angles_x);
 230     self.angles_y = anglemods(self.angles_y);
 231
 232     self.angles_x *= -1;
 233     makevectors(self.angles);
 234     self.angles_x *= -1;
 235
 236     wish_angle = normalize(self.steerto);
 237     wish_angle = vectoangles(wish_angle);
 238     real_angle = wish_angle - self.angles;
 239     real_angle = shortangle_vxy(real_angle,self.tur_head.angles);
 240
 241     self.tur_head.spawnshieldtime = fabs(real_angle_y);
 242     real_angle_y  = bound(-self.tur_head.aim_speed,real_angle_y,self.tur_head.aim_speed);
 243     self.angles_y = (self.angles_y + real_angle_y);
 244
 245     // Simulate banking
 246     self.angles_z = bound(-45,real_angle_y * -2.5,45);
 247
 248     if(self.pathcurrent)
 249         ewheel_move_path();
 250     else if(self.enemy)
 251         ewheel_move_enemy();
 252     else
 253         ewheel_move_idle();
 254
 255     //verbstack_pop(self.verbs_move);
 256
 257     self.velocity_z = vz;
 258 }
 259
 260 void ewheel_respawnhook()
 261 {
 262     entity e;
 263
 264     setorigin(self,self.pos1);
 265
 266     if (self.target != "")
 267     {
 268         e = find(world,targetname,self.target);
 269         if (!e)
 270         {
 271             dprint("Initital waypoint for ewheel does NOT exsist, fix your map!\n");
 272             self.target = "";
 273         }
 274
 275         if (e.classname != "turret_checkpoint")
 276             dprint("Warning: not a turrret path\n");
 277         else
 278         {
 279             self.pathcurrent = WALKER_PATH(self.origin,e.origin);
 280             self.pathgoal = e;
 281         }
 282     }
 283 }
 284
 285 void ewheel_diehook()
 286 {
 287     turret_trowgib2(self.origin,self.velocity + v_up * 400,'-0.6 -0.2 -02',self,time + random() * 2 +3);
 288
 289     if (self.pathcurrent)
 290         pathlib_deletepath(self.pathcurrent.owner);
 291
 292     self.pathcurrent = world;
 293
 294     /*
 295     if (self.damage_flags & TFL_DMG_DEATH_NORESPAWN)
 296     {
 297         verbstack_flush(self.verbs_move);
 298         remove(self.verbs_move);
 299     }
 300     */
 301
 302 }
 303
 304 void turret_ewheel_dinit()
 305 {
 306     entity e;
 307
 308     if (self.netname == "")      self.netname     = "eWheel Turret";
 309
 310     if (self.target != "")
 311     {
 312         e = find(world,targetname,self.target);
 313         if (!e)
 314         {
 315             bprint("Warning! initital waypoint for ewheel does NOT exsist!\n");
 316             self.target = "";
 317         }
 318
 319         if (e.classname != "turret_checkpoint")
 320             dprint("Warning: not a turrret path\n");
 321         else
 322             self.goalcurrent = e;
 323     }
 324
 325     self.ammo_flags = TFL_AMMO_ENERGY | TFL_AMMO_RECHARGE | TFL_AMMO_RECIVE;
 326     self.turrcaps_flags = TFL_TURRCAPS_PLAYERKILL | TFL_TURRCAPS_MOVE | TFL_TURRCAPS_ROAM | TFL_TURRCAPS_HEADATTACHED;
 327
 328     self.turret_respawnhook = ewheel_respawnhook;
 329     self.turret_diehook = ewheel_diehook;
 330
 331     if (turret_stdproc_init("ewheel_std",0,"models/turrets/ewheel-base2.md3","models/turrets/ewheel-gun1.md3") == 0)
 332     {
 333         remove(self);
 334         return;
 335     }
 336
 337     self.target_select_flags   = TFL_TARGETSELECT_PLAYERS | TFL_TARGETSELECT_RANGELIMTS | TFL_TARGETSELECT_TEAMCHECK | TFL_TARGETSELECT_LOS;
 338     self.target_validate_flags = TFL_TARGETSELECT_PLAYERS | TFL_TARGETSELECT_RANGELIMTS | TFL_TARGETSELECT_TEAMCHECK;// | TFL_TARGETSELECT_LOS;
 339     self.damage_flags          |= TFL_DMG_DEATH_NOGIBS;
 340
 341     self.iscreature = TRUE;
 342     self.movetype   = MOVETYPE_WALK;
 343     self.solid      = SOLID_SLIDEBOX;
 344     self.takedamage = DAMAGE_AIM;
 345
 346     setattachment(self.tur_head,self,"tag_head");
 347     setsize(self,'-32 -32 0','32 32 48');
 348     setsize(self.tur_head,'0 0 0','0 0 0');
 349
 350     self.pos1 = self.origin;
 351
 352     self.idle_aim = '0 0 0';
 353
 354     // Our fire routine
 355     self.turret_firefunc  = ewheel_attack;
 356     self.turret_postthink = ewheel_postthink;
 357     self.tur_head.frame = 1;
 358
 359     //self.verbs_move = spawn();
 360     //self.verbs_move.owner = self;
 361
 362     //verbstack_push(self.verbs_move, ewheel_moveverb_roam,   WVM_IDLE,  0, self);
 363     //verbstack_push(self.verbs_move, ewheel_moveverb_idle,   WVM_IDLE,  0, self);
 364     //verbstack_push(self.verbs_move, ewheel_moveverb_enemy,  WVM_ENEMY, 0, self);
 365     //verbstack_push(self.verbs_move, ewheel_moveverb_path,   WVM_PATH,  0, self);
 366     //verbstack_push(self.verbs_move, ewheel_moveverb_runaway,WVM_PANIC,  0, self);
 367
 368     // Convert from dgr / sec to dgr / tic
 369     self.tur_head.aim_speed = cvar("g_turrets_unit_ewheel_turnrate");
 370     self.tur_head.aim_speed = self.tur_head.aim_speed / (1 / self.ticrate);
 371
 372     if (self.target != "")
 373     {
 374         e = find(world,targetname,self.target);
 375         if (!e)
 376         {
 377             dprint("Initital waypoint for ewheel does NOT exsist, fix your map!\n");
 378             self.target = "";
 379         }
 380
 381         if (e.classname != "turret_checkpoint")
 382             dprint("Warning: not a turrret path\n");
 383         else
 384         {
 385             self.pathcurrent = WALKER_PATH(self.origin,e.origin);
 386             self.pathgoal = e;
 387         }
 388     }
 389 }
 390
 391 void spawnfunc_turret_ewheel()
 392 {
 393     g_turrets_common_precash();
 394
 395     precache_model ("models/turrets/ewheel-base2.md3");
 396     precache_model ("models/turrets/ewheel-gun1.md3");
 397
 398     self.think = turret_ewheel_dinit;
 399     self.nextthink = time + 0.5;
 400 }