qcsrc/common/weapons/weapon/crylink.qc

   1 #include "crylink.qh"
   2 #ifndef IMPLEMENTATION
   3 CLASS(Crylink, Weapon)
   4 /* ammotype  */ ATTRIB(Crylink, ammo_field, .int, ammo_cells);
   5 /* impulse   */ ATTRIB(Crylink, impulse, int, 6);
   6 /* flags     */ ATTRIB(Crylink, spawnflags, int, WEP_FLAG_NORMAL | WEP_FLAG_RELOADABLE | WEP_TYPE_SPLASH | WEP_FLAG_CANCLIMB);
   7 /* rating    */ ATTRIB(Crylink, bot_pickupbasevalue, float, 6000);
   8 /* color     */ ATTRIB(Crylink, wpcolor, vector, '1 0.5 1');
   9 /* modelname */ ATTRIB(Crylink, mdl, string, "crylink");
  10 #ifdef GAMEQC
  11 /* model     */ ATTRIB(Crylink, m_model, Model, MDL_CRYLINK_ITEM);
  12 #endif
  13 /* crosshair */ ATTRIB(Crylink, w_crosshair, string, "gfx/crosshaircrylink");
  14 /* crosshair */ ATTRIB(Crylink, w_crosshair_size, float, 0.5);
  15 /* wepimg    */ ATTRIB(Crylink, model2, string, "weaponcrylink");
  16 /* refname   */ ATTRIB(Crylink, netname, string, "crylink");
  17 /* wepname   */ ATTRIB(Crylink, m_name, string, _("Crylink"));
  18
  19 #define X(BEGIN, P, END, class, prefix) \
  20         BEGIN(class) \
  21                 P(class, prefix, ammo, float, BOTH) \
  22         P(class, prefix, animtime, float, BOTH) \
  23         P(class, prefix, bouncedamagefactor, float, BOTH) \
  24         P(class, prefix, bounces, float, BOTH) \
  25         P(class, prefix, damage, float, BOTH) \
  26         P(class, prefix, edgedamage, float, BOTH) \
  27         P(class, prefix, force, float, BOTH) \
  28         P(class, prefix, joindelay, float, BOTH) \
  29         P(class, prefix, joinexplode, float, BOTH) \
  30         P(class, prefix, joinexplode_damage, float, BOTH) \
  31         P(class, prefix, joinexplode_edgedamage, float, BOTH) \
  32         P(class, prefix, joinexplode_force, float, BOTH) \
  33         P(class, prefix, joinexplode_radius, float, BOTH) \
  34         P(class, prefix, joinspread, float, BOTH) \
  35         P(class, prefix, linkexplode, float, BOTH) \
  36         P(class, prefix, middle_fadetime, float, BOTH) \
  37         P(class, prefix, middle_lifetime, float, BOTH) \
  38         P(class, prefix, other_fadetime, float, BOTH) \
  39         P(class, prefix, other_lifetime, float, BOTH) \
  40         P(class, prefix, radius, float, BOTH) \
  41         P(class, prefix, refire, float, BOTH) \
  42         P(class, prefix, reload_ammo, float, NONE) \
  43         P(class, prefix, reload_time, float, NONE) \
  44         P(class, prefix, secondary, float, NONE) \
  45         P(class, prefix, shots, float, BOTH) \
  46         P(class, prefix, speed, float, BOTH) \
  47         P(class, prefix, spreadtype, float, SEC) \
  48         P(class, prefix, spread, float, BOTH) \
  49         P(class, prefix, switchdelay_drop, float, NONE) \
  50         P(class, prefix, switchdelay_raise, float, NONE) \
  51         P(class, prefix, weaponreplace, string, NONE) \
  52         P(class, prefix, weaponstartoverride, float, NONE) \
  53         P(class, prefix, weaponstart, float, NONE) \
  54         P(class, prefix, weaponthrowable, float, NONE) \
  55         END()
  56         W_PROPS(X, Crylink, crylink)
  57 #undef X
  58
  59 ENDCLASS(Crylink)
  60 REGISTER_WEAPON(CRYLINK, crylink, NEW(Crylink));
  61
  62 #ifdef SVQC
  63 .float gravity;
  64 .float crylink_waitrelease;
  65 .entity crylink_lastgroup;
  66
  67 .entity crylink_owner; // we can't use realowner, as that's subject to change
  68
  69 .entity queuenext;
  70 .entity queueprev;
  71 #endif
  72 #endif
  73 #ifdef IMPLEMENTATION
  74 #ifdef SVQC
  75 spawnfunc(weapon_crylink) { weapon_defaultspawnfunc(this, WEP_CRYLINK); }
  76
  77 void W_Crylink_CheckLinks(entity e)
  78 {
  79         float i;
  80         entity p;
  81
  82         if(e == NULL)
  83                 error("W_Crylink_CheckLinks: entity is NULL");
  84         if(e.classname != "spike" || wasfreed(e))
  85                 error(sprintf("W_Crylink_CheckLinks: entity is not a spike but a %s (freed: %d)", e.classname, wasfreed(e)));
  86
  87         p = e;
  88         for(i = 0; i < 1000; ++i)
  89         {
  90                 if(p.queuenext.queueprev != p || p.queueprev.queuenext != p)
  91                         error("W_Crylink_CheckLinks: queue is inconsistent");
  92                 p = p.queuenext;
  93                 if(p == e)
  94                         break;
  95         }
  96         if(i >= 1000)
  97                 error("W_Crylink_CheckLinks: infinite chain");
  98 }
  99
 100 void W_Crylink_Dequeue_Raw(entity own, entity prev, entity me, entity next)
 101 {
 102         W_Crylink_CheckLinks(next);
 103         .entity weaponentity = me.weaponentity_fld;
 104         if(me == own.(weaponentity).crylink_lastgroup)
 105                 own.(weaponentity).crylink_lastgroup = ((me == next) ? NULL : next);
 106         prev.queuenext = next;
 107         next.queueprev = prev;
 108         me.classname = "spike_oktoremove";
 109         if(me != next)
 110                 W_Crylink_CheckLinks(next);
 111 }
 112
 113 void W_Crylink_Dequeue(entity e)
 114 {
 115         W_Crylink_Dequeue_Raw(e.crylink_owner, e.queueprev, e, e.queuenext);
 116 }
 117
 118 void W_Crylink_Reset(entity this)
 119 {
 120         W_Crylink_Dequeue(this);
 121         delete(this);
 122 }
 123
 124 // force projectile to explode
 125 void W_Crylink_LinkExplode(entity e, entity e2, entity directhitentity)
 126 {
 127         float a;
 128
 129         if(e == e2)
 130                 return;
 131
 132         a = bound(0, 1 - (time - e.fade_time) * e.fade_rate, 1);
 133
 134         .entity weaponentity = e.weaponentity_fld;
 135         if(e == e.crylink_owner.(weaponentity).crylink_lastgroup)
 136                 e.crylink_owner.(weaponentity).crylink_lastgroup = NULL;
 137
 138         float isprimary = !(e.projectiledeathtype & HITTYPE_SECONDARY);
 139
 140         RadiusDamage(e, e.realowner, WEP_CVAR_BOTH(crylink, isprimary, damage) * a, WEP_CVAR_BOTH(crylink, isprimary, edgedamage) * a, WEP_CVAR_BOTH(crylink, isprimary, radius),
 141                                 NULL, NULL, WEP_CVAR_BOTH(crylink, isprimary, force) * a, e.projectiledeathtype, directhitentity);
 142
 143         W_Crylink_LinkExplode(e.queuenext, e2, directhitentity);
 144
 145         e.classname = "spike_oktoremove";
 146         delete(e);
 147 }
 148
 149 // adjust towards center
 150 // returns the origin where they will meet... and the time till the meeting is
 151 // stored in w_crylink_linkjoin_time.
 152 // could possibly network this origin and time, and display a special particle
 153 // effect when projectiles meet there :P
 154 // jspeed: joining speed (calculate this as join spread * initial speed)
 155 float w_crylink_linkjoin_time;
 156 vector W_Crylink_LinkJoin(entity e, float jspeed)
 157 {
 158         vector avg_origin, avg_velocity;
 159         vector targ_origin;
 160         float avg_dist, n;
 161         entity p;
 162
 163         // FIXME remove this debug code
 164         W_Crylink_CheckLinks(e);
 165
 166         w_crylink_linkjoin_time = 0;
 167
 168         avg_origin = e.origin;
 169         avg_velocity = e.velocity;
 170         n = 1;
 171         for(p = e; (p = p.queuenext) != e; )
 172         {
 173                 avg_origin += WarpZone_RefSys_TransformOrigin(p, e, p.origin);
 174                 avg_velocity += WarpZone_RefSys_TransformVelocity(p, e, p.velocity);
 175                 ++n;
 176         }
 177         avg_origin *= (1.0 / n);
 178         avg_velocity *= (1.0 / n);
 179
 180         if(n < 2)
 181                 return avg_origin; // nothing to do
 182
 183         // yes, mathematically we can do this in ONE step, but beware of 32bit floats...
 184         avg_dist = pow(vlen(e.origin - avg_origin), 2);
 185         for(p = e; (p = p.queuenext) != e; )
 186                 avg_dist += pow(vlen(WarpZone_RefSys_TransformOrigin(p, e, p.origin) - avg_origin), 2);
 187         avg_dist *= (1.0 / n);
 188         avg_dist = sqrt(avg_dist);
 189
 190         if(avg_dist == 0)
 191                 return avg_origin; // no change needed
 192
 193         if(jspeed == 0)
 194         {
 195                 e.velocity = avg_velocity;
 196                 UpdateCSQCProjectile(e);
 197                 for(p = e; (p = p.queuenext) != e; )
 198                 {
 199                         p.velocity = WarpZone_RefSys_TransformVelocity(e, p, avg_velocity);
 200                         UpdateCSQCProjectile(p);
 201                 }
 202                 targ_origin = avg_origin + 1000000000 * normalize(avg_velocity); // HUUUUUUGE
 203         }
 204         else
 205         {
 206                 w_crylink_linkjoin_time = avg_dist / jspeed;
 207                 targ_origin = avg_origin + w_crylink_linkjoin_time * avg_velocity;
 208
 209                 e.velocity = (targ_origin - e.origin) * (1.0 / w_crylink_linkjoin_time);
 210                 UpdateCSQCProjectile(e);
 211                 for(p = e; (p = p.queuenext) != e; )
 212                 {
 213                         p.velocity = WarpZone_RefSys_TransformVelocity(e, p, (targ_origin - WarpZone_RefSys_TransformOrigin(p, e, p.origin)) * (1.0 / w_crylink_linkjoin_time));
 214                         UpdateCSQCProjectile(p);
 215                 }
 216
 217                 // analysis:
 218                 //   jspeed -> +infinity:
 219                 //      w_crylink_linkjoin_time -> +0
 220                 //      targ_origin -> avg_origin
 221                 //      p->velocity -> HUEG towards center
 222                 //   jspeed -> 0:
 223                 //      w_crylink_linkjoin_time -> +/- infinity
 224                 //      targ_origin -> avg_velocity * +/- infinity
 225                 //      p->velocity -> avg_velocity
 226                 //   jspeed -> -infinity:
 227                 //      w_crylink_linkjoin_time -> -0
 228                 //      targ_origin -> avg_origin
 229                 //      p->velocity -> HUEG away from center
 230         }
 231
 232         W_Crylink_CheckLinks(e);
 233
 234         return targ_origin;
 235 }
 236
 237 void W_Crylink_LinkJoinEffect_Think(entity this)
 238 {
 239         // is there at least 2 projectiles very close?
 240         entity e, p;
 241         float n;
 242         .entity weaponentity = this.weaponentity_fld;
 243         e = this.owner.(weaponentity).crylink_lastgroup;
 244         n = 0;
 245         if(e)
 246         {
 247                 if(vlen2(e.origin - this.origin) < vlen2(e.velocity) * frametime)
 248                         ++n;
 249                 for(p = e; (p = p.queuenext) != e; )
 250                 {
 251                         if(vlen2(p.origin - this.origin) < vlen2(p.velocity) * frametime)
 252                                 ++n;
 253                 }
 254                 if(n >= 2)
 255                 {
 256                         float isprimary = !(e.projectiledeathtype & HITTYPE_SECONDARY);
 257
 258                         if(WEP_CVAR_BOTH(crylink, isprimary, joinexplode))
 259                         {
 260                                 n /= WEP_CVAR_BOTH(crylink, isprimary, shots);
 261                                 RadiusDamage(
 262                                         e,
 263                                         e.realowner,
 264                                         WEP_CVAR_BOTH(crylink, isprimary, joinexplode_damage) * n,
 265                                         WEP_CVAR_BOTH(crylink, isprimary, joinexplode_edgedamage) * n,
 266                                         WEP_CVAR_BOTH(crylink, isprimary, joinexplode_radius) * n,
 267                                         e.realowner,
 268                                         NULL,
 269                                         WEP_CVAR_BOTH(crylink, isprimary, joinexplode_force) * n,
 270                                         e.projectiledeathtype,
 271                                         NULL
 272                                 );
 273                                 Send_Effect(EFFECT_CRYLINK_JOINEXPLODE, this.origin, '0 0 0', n);
 274                         }
 275                 }
 276         }
 277         delete(this);
 278 }
 279
 280 float W_Crylink_Touch_WouldHitFriendly(entity projectile, float rad)
 281 {
 282         entity head = WarpZone_FindRadius((projectile.origin + (projectile.mins + projectile.maxs) * 0.5), rad + MAX_DAMAGEEXTRARADIUS, false);
 283         float hit_friendly = 0;
 284         float hit_enemy = 0;
 285
 286         while(head)
 287         {
 288                 if((head.takedamage != DAMAGE_NO) && (!IS_DEAD(head)))
 289                 {
 290                         if(SAME_TEAM(head, projectile.realowner))
 291                                 ++hit_friendly;
 292                         else
 293                                 ++hit_enemy;
 294                 }
 295
 296                 head = head.chain;
 297         }
 298
 299         return (hit_enemy ? false : hit_friendly);
 300 }
 301
 302 // NO bounce protection, as bounces are limited!
 303 void W_Crylink_Touch(entity this, entity toucher)
 304 {
 305         float finalhit;
 306         float f;
 307         float isprimary = !(this.projectiledeathtype & HITTYPE_SECONDARY);
 308         PROJECTILE_TOUCH(this, toucher);
 309
 310         float a;
 311         a = bound(0, 1 - (time - this.fade_time) * this.fade_rate, 1);
 312
 313         finalhit = ((this.cnt <= 0) || (toucher.takedamage != DAMAGE_NO));
 314         if(finalhit)
 315                 f = 1;
 316         else
 317                 f = WEP_CVAR_BOTH(crylink, isprimary, bouncedamagefactor);
 318         if(a)
 319                 f *= a;
 320
 321         float totaldamage = RadiusDamage(this, this.realowner, WEP_CVAR_BOTH(crylink, isprimary, damage) * f, WEP_CVAR_BOTH(crylink, isprimary, edgedamage) * f, WEP_CVAR_BOTH(crylink, isprimary, radius), NULL, NULL, WEP_CVAR_BOTH(crylink, isprimary, force) * f, this.projectiledeathtype, toucher);
 322
 323         if(totaldamage && ((WEP_CVAR_BOTH(crylink, isprimary, linkexplode) == 2) || ((WEP_CVAR_BOTH(crylink, isprimary, linkexplode) == 1) && !W_Crylink_Touch_WouldHitFriendly(this, WEP_CVAR_BOTH(crylink, isprimary, radius)))))
 324         {
 325                 .entity weaponentity = this.weaponentity_fld;
 326                 if(this == this.crylink_owner.(weaponentity).crylink_lastgroup)
 327                         this.crylink_owner.(weaponentity).crylink_lastgroup = NULL;
 328                 W_Crylink_LinkExplode(this.queuenext, this, toucher);
 329                 this.classname = "spike_oktoremove";
 330                 delete(this);
 331                 return;
 332         }
 333         else if(finalhit)
 334         {
 335                 // just unlink
 336                 W_Crylink_Dequeue(this);
 337                 delete(this);
 338                 return;
 339         }
 340         this.cnt = this.cnt - 1;
 341         this.angles = vectoangles(this.velocity);
 342         this.owner = NULL;
 343         this.projectiledeathtype |= HITTYPE_BOUNCE;
 344         // commented out as it causes a little hitch...
 345         //if(proj.cnt == 0)
 346         //      CSQCProjectile(proj, true, PROJECTILE_CRYLINK, true);
 347 }
 348
 349 void W_Crylink_Fadethink(entity this)
 350 {
 351         W_Crylink_Dequeue(this);
 352         delete(this);
 353 }
 354
 355 void W_Crylink_Attack(Weapon thiswep, entity actor, .entity weaponentity)
 356 {
 357         float counter, shots;
 358         entity proj, prevproj, firstproj;
 359         vector s;
 360         vector forward, right, up;
 361         float maxdmg;
 362
 363         W_DecreaseAmmo(thiswep, actor, WEP_CVAR_PRI(crylink, ammo), weaponentity);
 364
 365         maxdmg = WEP_CVAR_PRI(crylink, damage) * WEP_CVAR_PRI(crylink, shots);
 366         maxdmg *= 1 + WEP_CVAR_PRI(crylink, bouncedamagefactor) * WEP_CVAR_PRI(crylink, bounces);
 367         if(WEP_CVAR_PRI(crylink, joinexplode))
 368                 maxdmg += WEP_CVAR_PRI(crylink, joinexplode_damage);
 369
 370         W_SetupShot(actor, weaponentity, false, 2, SND_CRYLINK_FIRE, CH_WEAPON_A, maxdmg);
 371         forward = v_forward;
 372         right = v_right;
 373         up = v_up;
 374
 375         shots = WEP_CVAR_PRI(crylink, shots);
 376         Send_Effect(EFFECT_CRYLINK_MUZZLEFLASH, w_shotorg, w_shotdir * 1000, shots);
 377         proj = prevproj = firstproj = NULL;
 378         for(counter = 0; counter < shots; ++counter)
 379         {
 380                 proj = new(spike);
 381                 proj.reset = W_Crylink_Reset;
 382                 proj.realowner = proj.owner = actor;
 383                 proj.crylink_owner = actor;
 384                 proj.weaponentity_fld = weaponentity;
 385                 proj.bot_dodge = true;
 386                 proj.bot_dodgerating = WEP_CVAR_PRI(crylink, damage);
 387                 if(shots == 1) {
 388                         proj.queuenext = proj;
 389                         proj.queueprev = proj;
 390                 }
 391                 else if(counter == 0) { // first projectile, store in firstproj for now
 392                         firstproj = proj;
 393                 }
 394                 else if(counter == shots - 1) { // last projectile, link up with first projectile
 395                         prevproj.queuenext = proj;
 396                         firstproj.queueprev = proj;
 397                         proj.queuenext = firstproj;
 398                         proj.queueprev = prevproj;
 399                 }
 400                 else { // else link up with previous projectile
 401                         prevproj.queuenext = proj;
 402                         proj.queueprev = prevproj;
 403                 }
 404
 405                 prevproj = proj;
 406
 407                 set_movetype(proj, MOVETYPE_BOUNCEMISSILE);
 408                 PROJECTILE_MAKETRIGGER(proj);
 409                 proj.projectiledeathtype = WEP_CRYLINK.m_id;
 410                 //proj.gravity = 0.001;
 411
 412                 setorigin(proj, w_shotorg);
 413                 setsize(proj, '0 0 0', '0 0 0');
 414
 415
 416                 s = '0 0 0';
 417                 if(counter == 0)
 418                         s = '0 0 0';
 419                 else
 420                 {
 421                         makevectors('0 360 0' * (0.75 + (counter - 0.5) / (shots - 1)));
 422                         s.y = v_forward.x;
 423                         s.z = v_forward.y;
 424                 }
 425                 s = s * WEP_CVAR_PRI(crylink, spread) * g_weaponspreadfactor;
 426                 W_SetupProjVelocity_Explicit(proj, w_shotdir + right * s.y + up * s.z, v_up, WEP_CVAR_PRI(crylink, speed), 0, 0, 0, false);
 427                 settouch(proj, W_Crylink_Touch);
 428
 429                 setthink(proj, W_Crylink_Fadethink);
 430                 if(counter == 0)
 431                 {
 432                         proj.fade_time = time + WEP_CVAR_PRI(crylink, middle_lifetime);
 433                         proj.fade_rate = 1 / WEP_CVAR_PRI(crylink, middle_fadetime);
 434                         proj.nextthink = time + WEP_CVAR_PRI(crylink, middle_lifetime) + WEP_CVAR_PRI(crylink, middle_fadetime);
 435                 }
 436                 else
 437                 {
 438                         proj.fade_time = time + WEP_CVAR_PRI(crylink, other_lifetime);
 439                         proj.fade_rate = 1 / WEP_CVAR_PRI(crylink, other_fadetime);
 440                         proj.nextthink = time + WEP_CVAR_PRI(crylink, other_lifetime) + WEP_CVAR_PRI(crylink, other_fadetime);
 441                 }
 442                 proj.teleport_time = time + WEP_CVAR_PRI(crylink, joindelay);
 443                 proj.cnt = WEP_CVAR_PRI(crylink, bounces);
 444                 //proj.scale = 1 + 1 * proj.cnt;
 445
 446                 proj.angles = vectoangles(proj.velocity);
 447
 448                 //proj.glow_size = 20;
 449
 450                 proj.flags = FL_PROJECTILE;
 451                 IL_PUSH(g_projectiles, proj);
 452                 IL_PUSH(g_bot_dodge, proj);
 453                 proj.missile_flags = MIF_SPLASH;
 454
 455                 CSQCProjectile(proj, true, (proj.cnt ? PROJECTILE_CRYLINK_BOUNCING : PROJECTILE_CRYLINK), true);
 456
 457                 MUTATOR_CALLHOOK(EditProjectile, actor, proj);
 458         }
 459         if(WEP_CVAR_PRI(crylink, joinspread) != 0)
 460         {
 461                 actor.(weaponentity).crylink_lastgroup = proj;
 462                 W_Crylink_CheckLinks(proj);
 463                 actor.(weaponentity).crylink_waitrelease = 1;
 464         }
 465 }
 466
 467 void W_Crylink_Attack2(Weapon thiswep, entity actor, .entity weaponentity)
 468 {
 469         float counter, shots;
 470         entity proj, prevproj, firstproj;
 471         vector s;
 472         vector forward, right, up;
 473         float maxdmg;
 474
 475         W_DecreaseAmmo(thiswep, actor, WEP_CVAR_SEC(crylink, ammo), weaponentity);
 476
 477         maxdmg = WEP_CVAR_SEC(crylink, damage) * WEP_CVAR_SEC(crylink, shots);
 478         maxdmg *= 1 + WEP_CVAR_SEC(crylink, bouncedamagefactor) * WEP_CVAR_SEC(crylink, bounces);
 479         if(WEP_CVAR_SEC(crylink, joinexplode))
 480                 maxdmg += WEP_CVAR_SEC(crylink, joinexplode_damage);
 481
 482         W_SetupShot(actor, weaponentity, false, 2, SND_CRYLINK_FIRE2, CH_WEAPON_A, maxdmg);
 483         forward = v_forward;
 484         right = v_right;
 485         up = v_up;
 486
 487         shots = WEP_CVAR_SEC(crylink, shots);
 488         Send_Effect(EFFECT_CRYLINK_MUZZLEFLASH, w_shotorg, w_shotdir * 1000, shots);
 489         proj = prevproj = firstproj = NULL;
 490         for(counter = 0; counter < shots; ++counter)
 491         {
 492                 proj = new(spike);
 493                 proj.weaponentity_fld = weaponentity;
 494                 proj.reset = W_Crylink_Reset;
 495                 proj.realowner = proj.owner = actor;
 496                 proj.crylink_owner = actor;
 497                 proj.bot_dodge = true;
 498                 proj.bot_dodgerating = WEP_CVAR_SEC(crylink, damage);
 499                 if(shots == 1) {
 500                         proj.queuenext = proj;
 501                         proj.queueprev = proj;
 502                 }
 503                 else if(counter == 0) { // first projectile, store in firstproj for now
 504                         firstproj = proj;
 505                 }
 506                 else if(counter == shots - 1) { // last projectile, link up with first projectile
 507                         prevproj.queuenext = proj;
 508                         firstproj.queueprev = proj;
 509                         proj.queuenext = firstproj;
 510                         proj.queueprev = prevproj;
 511                 }
 512                 else { // else link up with previous projectile
 513                         prevproj.queuenext = proj;
 514                         proj.queueprev = prevproj;
 515                 }
 516
 517                 prevproj = proj;
 518
 519                 set_movetype(proj, MOVETYPE_BOUNCEMISSILE);
 520                 PROJECTILE_MAKETRIGGER(proj);
 521                 proj.projectiledeathtype = WEP_CRYLINK.m_id | HITTYPE_SECONDARY;
 522                 //proj.gravity = 0.001;
 523
 524                 setorigin(proj, w_shotorg);
 525                 setsize(proj, '0 0 0', '0 0 0');
 526
 527                 if(WEP_CVAR_SEC(crylink, spreadtype) == 1)
 528                 {
 529                         s = '0 0 0';
 530                         if(counter == 0)
 531                                 s = '0 0 0';
 532                         else
 533                         {
 534                                 makevectors('0 360 0' * (0.75 + (counter - 0.5) / (shots - 1)));
 535                                 s.y = v_forward.x;
 536                                 s.z = v_forward.y;
 537                         }
 538                         s = s * WEP_CVAR_SEC(crylink, spread) * g_weaponspreadfactor;
 539                         s = w_shotdir + right * s.y + up * s.z;
 540                 }
 541                 else
 542                 {
 543                         s = (w_shotdir + (((counter + 0.5) / shots) * 2 - 1) * v_right * WEP_CVAR_SEC(crylink, spread) * g_weaponspreadfactor);
 544                 }
 545
 546                 W_SetupProjVelocity_Explicit(proj, s, v_up, WEP_CVAR_SEC(crylink, speed), 0, 0, 0, false);
 547                 settouch(proj, W_Crylink_Touch);
 548                 setthink(proj, W_Crylink_Fadethink);
 549                 if(counter == (shots - 1) / 2)
 550                 {
 551                         proj.fade_time = time + WEP_CVAR_SEC(crylink, middle_lifetime);
 552                         proj.fade_rate = 1 / WEP_CVAR_SEC(crylink, middle_fadetime);
 553                         proj.nextthink = time + WEP_CVAR_SEC(crylink, middle_lifetime) + WEP_CVAR_SEC(crylink, middle_fadetime);
 554                 }
 555                 else
 556                 {
 557                         proj.fade_time = time + WEP_CVAR_SEC(crylink, other_lifetime);
 558                         proj.fade_rate = 1 / WEP_CVAR_SEC(crylink, other_fadetime);
 559                         proj.nextthink = time + WEP_CVAR_SEC(crylink, other_lifetime) + WEP_CVAR_SEC(crylink, other_fadetime);
 560                 }
 561                 proj.teleport_time = time + WEP_CVAR_SEC(crylink, joindelay);
 562                 proj.cnt = WEP_CVAR_SEC(crylink, bounces);
 563                 //proj.scale = 1 + 1 * proj.cnt;
 564
 565                 proj.angles = vectoangles(proj.velocity);
 566
 567                 //proj.glow_size = 20;
 568
 569                 proj.flags = FL_PROJECTILE;
 570                 IL_PUSH(g_projectiles, proj);
 571                 IL_PUSH(g_bot_dodge, proj);
 572         proj.missile_flags = MIF_SPLASH;
 573
 574                 CSQCProjectile(proj, true, (proj.cnt ? PROJECTILE_CRYLINK_BOUNCING : PROJECTILE_CRYLINK), true);
 575
 576                 MUTATOR_CALLHOOK(EditProjectile, actor, proj);
 577         }
 578         if(WEP_CVAR_SEC(crylink, joinspread) != 0)
 579         {
 580                 actor.(weaponentity).crylink_lastgroup = proj;
 581                 W_Crylink_CheckLinks(proj);
 582                 actor.(weaponentity).crylink_waitrelease = 2;
 583         }
 584 }
 585
 586 METHOD(Crylink, wr_aim, void(entity thiswep, entity actor, .entity weaponentity))
 587 {
 588     if(random() < 0.10)
 589         PHYS_INPUT_BUTTON_ATCK(actor) = bot_aim(actor, weaponentity, WEP_CVAR_PRI(crylink, speed), 0, WEP_CVAR_PRI(crylink, middle_lifetime), false);
 590     else
 591         PHYS_INPUT_BUTTON_ATCK2(actor) = bot_aim(actor, weaponentity, WEP_CVAR_SEC(crylink, speed), 0, WEP_CVAR_SEC(crylink, middle_lifetime), false);
 592 }
 593 METHOD(Crylink, wr_think, void(entity thiswep, entity actor, .entity weaponentity, int fire))
 594 {
 595     if(autocvar_g_balance_crylink_reload_ammo && actor.(weaponentity).clip_load < min(WEP_CVAR_PRI(crylink, ammo), WEP_CVAR_SEC(crylink, ammo))) { // forced reload
 596         thiswep.wr_reload(thiswep, actor, weaponentity);
 597     }
 598
 599     if(fire & 1)
 600     {
 601         if(actor.(weaponentity).crylink_waitrelease != 1)
 602         if(weapon_prepareattack(thiswep, actor, weaponentity, false, WEP_CVAR_PRI(crylink, refire)))
 603         {
 604             W_Crylink_Attack(thiswep, actor, weaponentity);
 605             weapon_thinkf(actor, weaponentity, WFRAME_FIRE1, WEP_CVAR_PRI(crylink, animtime), w_ready);
 606         }
 607     }
 608
 609     if((fire & 2) && autocvar_g_balance_crylink_secondary)
 610     {
 611         if(actor.(weaponentity).crylink_waitrelease != 2)
 612         if(weapon_prepareattack(thiswep, actor, weaponentity, true, WEP_CVAR_SEC(crylink, refire)))
 613         {
 614             W_Crylink_Attack2(thiswep, actor, weaponentity);
 615             weapon_thinkf(actor, weaponentity, WFRAME_FIRE2, WEP_CVAR_SEC(crylink, animtime), w_ready);
 616         }
 617     }
 618
 619     if((actor.(weaponentity).crylink_waitrelease == 1 && !(fire & 1)) || (actor.(weaponentity).crylink_waitrelease == 2 && !(fire & 2)))
 620     {
 621         if(!actor.(weaponentity).crylink_lastgroup || time > actor.(weaponentity).crylink_lastgroup.teleport_time)
 622         {
 623             // fired and released now!
 624             if(actor.(weaponentity).crylink_lastgroup)
 625             {
 626                 vector pos;
 627                 entity linkjoineffect;
 628                 float isprimary = (actor.(weaponentity).crylink_waitrelease == 1);
 629
 630                 pos = W_Crylink_LinkJoin(actor.(weaponentity).crylink_lastgroup, WEP_CVAR_BOTH(crylink, isprimary, joinspread) * WEP_CVAR_BOTH(crylink, isprimary, speed));
 631
 632                 linkjoineffect = new(linkjoineffect);
 633                 linkjoineffect.weaponentity_fld = weaponentity;
 634                 setthink(linkjoineffect, W_Crylink_LinkJoinEffect_Think);
 635                 linkjoineffect.nextthink = time + w_crylink_linkjoin_time;
 636                 linkjoineffect.owner = actor;
 637                 setorigin(linkjoineffect, pos);
 638             }
 639             actor.(weaponentity).crylink_waitrelease = 0;
 640             if(!thiswep.wr_checkammo1(thiswep, actor, weaponentity) && !thiswep.wr_checkammo2(thiswep, actor, weaponentity))
 641             if(!(actor.items & IT_UNLIMITED_WEAPON_AMMO))
 642             {
 643                 // ran out of ammo!
 644                 actor.cnt = WEP_CRYLINK.m_id;
 645                 actor.(weaponentity).m_switchweapon = w_getbestweapon(actor, weaponentity);
 646             }
 647         }
 648     }
 649 }
 650 METHOD(Crylink, wr_checkammo1, bool(entity thiswep, entity actor, .entity weaponentity))
 651 {
 652     // don't "run out of ammo" and switch weapons while waiting for release
 653     if(actor.(weaponentity).crylink_lastgroup && actor.(weaponentity).crylink_waitrelease)
 654         return true;
 655
 656     float ammo_amount = actor.(thiswep.ammo_field) >= WEP_CVAR_PRI(crylink, ammo);
 657     ammo_amount += actor.(weaponentity).(weapon_load[WEP_CRYLINK.m_id]) >= WEP_CVAR_PRI(crylink, ammo);
 658     return ammo_amount;
 659 }
 660 METHOD(Crylink, wr_checkammo2, bool(entity thiswep, entity actor, .entity weaponentity))
 661 {
 662     // don't "run out of ammo" and switch weapons while waiting for release
 663     if(actor.(weaponentity).crylink_lastgroup && actor.(weaponentity).crylink_waitrelease)
 664         return true;
 665
 666     float ammo_amount = actor.(thiswep.ammo_field) >= WEP_CVAR_SEC(crylink, ammo);
 667     ammo_amount += actor.(weaponentity).(weapon_load[WEP_CRYLINK.m_id]) >= WEP_CVAR_SEC(crylink, ammo);
 668     return ammo_amount;
 669 }
 670 METHOD(Crylink, wr_reload, void(entity thiswep, entity actor, .entity weaponentity))
 671 {
 672     W_Reload(actor, weaponentity, min(WEP_CVAR_PRI(crylink, ammo), WEP_CVAR_SEC(crylink, ammo)), SND_RELOAD);
 673 }
 674 METHOD(Crylink, wr_suicidemessage, Notification(entity thiswep))
 675 {
 676     return WEAPON_CRYLINK_SUICIDE;
 677 }
 678 METHOD(Crylink, wr_killmessage, Notification(entity thiswep))
 679 {
 680     return WEAPON_CRYLINK_MURDER;
 681 }
 682 #endif
 683 #ifdef CSQC
 684 METHOD(Crylink, wr_impacteffect, void(entity thiswep, entity actor))
 685 {
 686     vector org2;
 687     org2 = w_org + w_backoff * 2;
 688     if(w_deathtype & HITTYPE_SECONDARY)
 689     {
 690         pointparticles(EFFECT_CRYLINK_IMPACT2, org2, '0 0 0', 1);
 691         if(!w_issilent)
 692             sound(actor, CH_SHOTS, SND_CRYLINK_IMPACT2, VOL_BASE, ATTN_NORM);
 693     }
 694     else
 695     {
 696         pointparticles(EFFECT_CRYLINK_IMPACT, org2, '0 0 0', 1);
 697         if(!w_issilent)
 698             sound(actor, CH_SHOTS, SND_CRYLINK_IMPACT, VOL_BASE, ATTN_NORM);
 699     }
 700 }
 701 #endif
 702 #endif