Purge hardcoded slot 0 weapon entity use from most of the bot AI
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / weapons / weapon / electro.qc
1 #include "electro.qh"
2 #ifndef IMPLEMENTATION
3 CLASS(Electro, Weapon)
4 /* ammotype  */ ATTRIB(Electro, ammo_field, .int, ammo_cells);
5 /* impulse   */ ATTRIB(Electro, impulse, int, 5);
6 /* flags     */ ATTRIB(Electro, spawnflags, int, WEP_FLAG_NORMAL | WEP_FLAG_RELOADABLE | WEP_FLAG_CANCLIMB | WEP_TYPE_SPLASH);
7 /* rating    */ ATTRIB(Electro, bot_pickupbasevalue, float, BOT_PICKUP_RATING_MID);
8 /* color     */ ATTRIB(Electro, wpcolor, vector, '0 0.5 1');
9 /* modelname */ ATTRIB(Electro, mdl, string, "electro");
10 #ifdef GAMEQC
11 /* model     */ ATTRIB(Electro, m_model, Model, MDL_ELECTRO_ITEM);
12 #endif
13 /* crosshair */ ATTRIB(Electro, w_crosshair, string, "gfx/crosshairelectro");
14 /* crosshair */ ATTRIB(Electro, w_crosshair_size, float, 0.6);
15 /* wepimg    */ ATTRIB(Electro, model2, string, "weaponelectro");
16 /* refname   */ ATTRIB(Electro, netname, string, "electro");
17 /* wepname   */ ATTRIB(Electro, m_name, string, _("Electro"));
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, bouncefactor, float, SEC) \
24                 P(class, prefix, bouncestop, float, SEC) \
25                 P(class, prefix, comboradius, float, PRI) \
26                 P(class, prefix, combo_comboradius, float, NONE) \
27                 P(class, prefix, combo_comboradius_thruwall, float, NONE) \
28                 P(class, prefix, combo_damage, float, NONE) \
29                 P(class, prefix, combo_edgedamage, float, NONE) \
30                 P(class, prefix, combo_force, float, NONE) \
31                 P(class, prefix, combo_radius, float, NONE) \
32                 P(class, prefix, combo_safeammocheck, float, NONE) \
33                 P(class, prefix, combo_speed, float, NONE) \
34                 P(class, prefix, count, float, SEC) \
35                 P(class, prefix, damagedbycontents, float, SEC) \
36                 P(class, prefix, damageforcescale, float, SEC) \
37                 P(class, prefix, damage, float, BOTH) \
38                 P(class, prefix, edgedamage, float, BOTH) \
39                 P(class, prefix, force, float, BOTH) \
40                 P(class, prefix, health, float, SEC) \
41                 P(class, prefix, lifetime, float, BOTH) \
42                 P(class, prefix, midaircombo_explode, float, PRI) \
43                 P(class, prefix, midaircombo_interval, float, PRI) \
44                 P(class, prefix, midaircombo_radius, float, PRI) \
45                 P(class, prefix, radius, float, BOTH) \
46                 P(class, prefix, refire2, float, SEC) \
47                 P(class, prefix, refire, float, BOTH) \
48                 P(class, prefix, reload_ammo, float, NONE) \
49                 P(class, prefix, reload_time, float, NONE) \
50                 P(class, prefix, speed, float, BOTH) \
51                 P(class, prefix, speed_up, float, SEC) \
52                 P(class, prefix, speed_z, float, SEC) \
53                 P(class, prefix, spread, float, BOTH) \
54                 P(class, prefix, stick, float, SEC) \
55                 P(class, prefix, switchdelay_drop, float, NONE) \
56                 P(class, prefix, switchdelay_raise, float, NONE) \
57                 P(class, prefix, touchexplode, float, SEC) \
58                 P(class, prefix, weaponreplace, string,NONE) \
59                 P(class, prefix, weaponstartoverride, float, NONE) \
60                 P(class, prefix, weaponstart, float, NONE) \
61                 P(class, prefix, weaponthrowable, float, NONE) \
62         END()
63         W_PROPS(X, Electro, electro)
64 #undef X
65
66 ENDCLASS(Electro)
67 REGISTER_WEAPON(ELECTRO, electro, NEW(Electro));
68
69
70 #ifdef SVQC
71 .float electro_count;
72 .float electro_secondarytime;
73 void W_Electro_ExplodeCombo(entity this);
74 #endif
75 #endif
76 #ifdef IMPLEMENTATION
77 #ifdef SVQC
78 spawnfunc(weapon_electro) { weapon_defaultspawnfunc(this, WEP_ELECTRO); }
79
80 void W_Electro_TriggerCombo(vector org, float rad, entity own)
81 {
82         entity e = WarpZone_FindRadius(org, rad, !WEP_CVAR(electro, combo_comboradius_thruwall));
83         while(e)
84         {
85                 if(e.classname == "electro_orb")
86                 {
87                         // do we allow thruwall triggering?
88                         if(WEP_CVAR(electro, combo_comboradius_thruwall))
89                         {
90                                 // if distance is greater than thruwall distance, check to make sure it's not through a wall
91                                 if(vdist(e.WarpZone_findradius_dist, >, WEP_CVAR(electro, combo_comboradius_thruwall)))
92                                 {
93                                         WarpZone_TraceLine(org, e.origin, MOVE_NOMONSTERS, e);
94                                         if(trace_fraction != 1)
95                                         {
96                                                 // trigger is through a wall and outside of thruwall range, abort
97                                                 e = e.chain;
98                                                 continue;
99                                         }
100                                 }
101                         }
102
103                         // change owner to whoever caused the combo explosion
104                         e.realowner = own;
105                         e.takedamage = DAMAGE_NO;
106                         e.classname = "electro_orb_chain";
107
108                         // now set the next one to trigger as well
109                         setthink(e, W_Electro_ExplodeCombo);
110
111                         // delay combo chains, looks cooler
112                         e.nextthink =
113                                 (
114                                         time
115                                         +
116                                         (WEP_CVAR(electro, combo_speed) ?
117                                                 (vlen(e.WarpZone_findradius_dist) / WEP_CVAR(electro, combo_speed))
118                                                 :
119                                                 0
120                                         )
121                                 );
122                 }
123                 e = e.chain;
124         }
125 }
126
127 void W_Electro_ExplodeCombo(entity this)
128 {
129         W_Electro_TriggerCombo(this.origin, WEP_CVAR(electro, combo_comboradius), this.realowner);
130
131         this.event_damage = func_null;
132
133         RadiusDamage(
134                 this,
135                 this.realowner,
136                 WEP_CVAR(electro, combo_damage),
137                 WEP_CVAR(electro, combo_edgedamage),
138                 WEP_CVAR(electro, combo_radius),
139                 NULL,
140                 NULL,
141                 WEP_CVAR(electro, combo_force),
142                 WEP_ELECTRO.m_id | HITTYPE_BOUNCE, // use THIS type for a combo because primary can't bounce
143                 NULL
144         );
145
146         delete(this);
147 }
148
149 void W_Electro_Explode(entity this, entity directhitentity)
150 {
151         if(directhitentity.takedamage == DAMAGE_AIM)
152                 if(IS_PLAYER(directhitentity))
153                         if(DIFF_TEAM(this.realowner, directhitentity))
154                                 if(!IS_DEAD(directhitentity))
155                                         if(IsFlying(directhitentity))
156                                                 Send_Notification(NOTIF_ONE, this.realowner, MSG_ANNCE, ANNCE_ACHIEVEMENT_ELECTROBITCH);
157
158         this.event_damage = func_null;
159         this.takedamage = DAMAGE_NO;
160
161         if(this.move_movetype == MOVETYPE_BOUNCE || this.classname == "electro_orb") // TODO: classname is more reliable anyway?
162         {
163                 RadiusDamage(
164                         this,
165                         this.realowner,
166                         WEP_CVAR_SEC(electro, damage),
167                         WEP_CVAR_SEC(electro, edgedamage),
168                         WEP_CVAR_SEC(electro, radius),
169                         NULL,
170                         NULL,
171                         WEP_CVAR_SEC(electro, force),
172                         this.projectiledeathtype,
173                         directhitentity
174                 );
175         }
176         else
177         {
178                 W_Electro_TriggerCombo(this.origin, WEP_CVAR_PRI(electro, comboradius), this.realowner);
179                 RadiusDamage(
180                         this,
181                         this.realowner,
182                         WEP_CVAR_PRI(electro, damage),
183                         WEP_CVAR_PRI(electro, edgedamage),
184                         WEP_CVAR_PRI(electro, radius),
185                         NULL,
186                         NULL,
187                         WEP_CVAR_PRI(electro, force),
188                         this.projectiledeathtype,
189                         directhitentity
190                 );
191         }
192
193         delete(this);
194 }
195
196 void W_Electro_Explode_use(entity this, entity actor, entity trigger)
197 {
198         W_Electro_Explode(this, trigger);
199 }
200
201 void W_Electro_TouchExplode(entity this, entity toucher)
202 {
203         PROJECTILE_TOUCH(this, toucher);
204         W_Electro_Explode(this, toucher);
205 }
206
207
208 void sys_phys_update_single(entity this);
209
210 void W_Electro_Bolt_Think(entity this)
211 {
212         // sys_phys_update_single(this);
213         if(time >= this.ltime)
214         {
215                 this.use(this, NULL, NULL);
216                 return;
217         }
218
219         if(WEP_CVAR_PRI(electro, midaircombo_radius))
220         {
221                 float found = 0;
222                 entity e = WarpZone_FindRadius(this.origin, WEP_CVAR_PRI(electro, midaircombo_radius), true);
223
224                 // loop through nearby orbs and trigger them
225                 while(e)
226                 {
227                         if(e.classname == "electro_orb")
228                         {
229                                 // change owner to whoever caused the combo explosion
230                                 e.realowner = this.realowner;
231                                 e.takedamage = DAMAGE_NO;
232                                 e.classname = "electro_orb_chain";
233
234                                 // now set the next one to trigger as well
235                                 setthink(e, W_Electro_ExplodeCombo);
236
237                                 // delay combo chains, looks cooler
238                                 e.nextthink =
239                                         (
240                                                 time
241                                                 +
242                                                 (WEP_CVAR(electro, combo_speed) ?
243                                                         (vlen(e.WarpZone_findradius_dist) / WEP_CVAR(electro, combo_speed))
244                                                         :
245                                                         0
246                                                 )
247                                         );
248
249                                 ++found;
250                         }
251                         e = e.chain;
252                 }
253
254                 // if we triggered an orb, should we explode? if not, lets try again next time
255                 if(found && WEP_CVAR_PRI(electro, midaircombo_explode))
256                         { this.use(this, NULL, NULL); }
257                 else
258                         { this.nextthink = min(time + WEP_CVAR_PRI(electro, midaircombo_interval), this.ltime); }
259         }
260         else { this.nextthink = this.ltime; }
261         // this.nextthink = time;
262 }
263
264 void W_Electro_Attack_Bolt(Weapon thiswep, entity actor, .entity weaponentity)
265 {
266         entity proj;
267
268         W_DecreaseAmmo(thiswep, actor, WEP_CVAR_PRI(electro, ammo), weaponentity);
269
270         W_SetupShot_ProjectileSize(
271                 actor,
272                 weaponentity,
273                 '0 0 -3',
274                 '0 0 -3',
275                 false,
276                 2,
277                 SND_ELECTRO_FIRE,
278                 CH_WEAPON_A,
279                 WEP_CVAR_PRI(electro, damage)
280         );
281
282         Send_Effect(EFFECT_ELECTRO_MUZZLEFLASH, w_shotorg, w_shotdir * 1000, 1);
283
284         proj = new(electro_bolt);
285         proj.owner = proj.realowner = actor;
286         proj.bot_dodge = true;
287         proj.bot_dodgerating = WEP_CVAR_PRI(electro, damage);
288         proj.use = W_Electro_Explode_use;
289         setthink(proj, W_Electro_Bolt_Think);
290         proj.nextthink = time;
291         proj.ltime = time + WEP_CVAR_PRI(electro, lifetime);
292         PROJECTILE_MAKETRIGGER(proj);
293         proj.projectiledeathtype = WEP_ELECTRO.m_id;
294         setorigin(proj, w_shotorg);
295
296         // if (IS_CSQC)
297         set_movetype(proj, MOVETYPE_FLY);
298         W_SetupProjVelocity_PRI(proj, electro);
299         proj.angles = vectoangles(proj.velocity);
300         settouch(proj, W_Electro_TouchExplode);
301         setsize(proj, '0 0 -3', '0 0 -3');
302         proj.flags = FL_PROJECTILE;
303         IL_PUSH(g_projectiles, proj);
304         IL_PUSH(g_bot_dodge, proj);
305         proj.missile_flags = MIF_SPLASH;
306
307         CSQCProjectile(proj, true, PROJECTILE_ELECTRO_BEAM, true);
308
309         MUTATOR_CALLHOOK(EditProjectile, actor, proj);
310         // proj.com_phys_pos = proj.origin;
311         // proj.com_phys_vel = proj.velocity;
312 }
313
314 void W_Electro_Orb_Stick(entity this, entity to)
315 {
316         entity newproj = spawn();
317         newproj.classname = this.classname;
318
319         newproj.bot_dodge = this.bot_dodge;
320         newproj.bot_dodgerating = this.bot_dodgerating;
321
322         newproj.owner = this.owner;
323         newproj.realowner = this.realowner;
324         setsize(newproj, this.mins, this.maxs);
325         setorigin(newproj, this.origin);
326         setmodel(newproj, MDL_PROJECTILE_ELECTRO);
327         newproj.angles = vectoangles(-trace_plane_normal); // face against the surface
328
329         newproj.takedamage = this.takedamage;
330         newproj.damageforcescale = this.damageforcescale;
331         newproj.health = this.health;
332         newproj.event_damage = this.event_damage;
333         newproj.spawnshieldtime = this.spawnshieldtime;
334         newproj.damagedbycontents = true;
335
336         set_movetype(newproj, MOVETYPE_NONE); // lock the orb in place
337         newproj.projectiledeathtype = this.projectiledeathtype;
338
339         settouch(newproj, func_null);
340         setthink(newproj, getthink(this));
341         newproj.nextthink = this.nextthink;
342         newproj.use = this.use;
343         newproj.flags = this.flags;
344         IL_PUSH(g_projectiles, newproj);
345         IL_PUSH(g_bot_dodge, newproj);
346
347         delete(this);
348
349         if(to)
350                 SetMovetypeFollow(this, to);
351 }
352
353 void W_Electro_Orb_Touch(entity this, entity toucher)
354 {
355         PROJECTILE_TOUCH(this, toucher);
356         if(toucher.takedamage == DAMAGE_AIM)
357                 { if(WEP_CVAR_SEC(electro, touchexplode)) { W_Electro_Explode(this, toucher); } }
358         else
359         {
360                 //UpdateCSQCProjectile(this);
361                 spamsound(this, CH_SHOTS, SND(ELECTRO_BOUNCE), VOL_BASE, ATTEN_NORM);
362                 this.projectiledeathtype |= HITTYPE_BOUNCE;
363
364                 if(WEP_CVAR_SEC(electro, stick))
365                         W_Electro_Orb_Stick(this, toucher);
366         }
367 }
368
369 void W_Electro_Orb_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
370 {
371         if(this.health <= 0)
372                 return;
373
374         // note: combos are usually triggered by W_Electro_TriggerCombo, not damage
375         float is_combo = (inflictor.classname == "electro_orb_chain" || inflictor.classname == "electro_bolt");
376
377         if(!W_CheckProjectileDamage(inflictor.realowner, this.realowner, deathtype, (is_combo ? 1 : -1)))
378                 return; // g_projectiles_damage says to halt
379
380         this.health = this.health - damage;
381         if(this.health <= 0)
382         {
383                 this.takedamage = DAMAGE_NO;
384                 this.nextthink = time;
385                 if(is_combo)
386                 {
387                         // change owner to whoever caused the combo explosion
388                         this.realowner = inflictor.realowner;
389                         this.classname = "electro_orb_chain";
390                         setthink(this, W_Electro_ExplodeCombo);
391                         this.nextthink = time +
392                                 (
393                                         // bound the length, inflictor may be in a galaxy far far away (warpzones)
394                                         min(
395                                                 WEP_CVAR(electro, combo_radius),
396                                                 vlen(this.origin - inflictor.origin)
397                                         )
398                                         /
399                                         // delay combo chains, looks cooler
400                                         WEP_CVAR(electro, combo_speed)
401                                 );
402                 }
403                 else
404                 {
405                         this.use = W_Electro_Explode_use;
406                         setthink(this, adaptor_think2use); // not _hittype_splash, as this runs "immediately"
407                 }
408         }
409 }
410
411 void W_Electro_Attack_Orb(Weapon thiswep, entity actor, .entity weaponentity)
412 {
413         W_DecreaseAmmo(thiswep, actor, WEP_CVAR_SEC(electro, ammo), weaponentity);
414
415         W_SetupShot_ProjectileSize(
416                 actor,
417                 weaponentity,
418                 '-4 -4 -4',
419                 '4 4 4',
420                 false,
421                 2,
422                 SND_ELECTRO_FIRE2,
423                 CH_WEAPON_A,
424                 WEP_CVAR_SEC(electro, damage)
425         );
426
427         w_shotdir = v_forward; // no TrueAim for grenades please
428
429         Send_Effect(EFFECT_ELECTRO_MUZZLEFLASH, w_shotorg, w_shotdir * 1000, 1);
430
431         entity proj = new(electro_orb);
432         proj.owner = proj.realowner = actor;
433         proj.use = W_Electro_Explode_use;
434         setthink(proj, adaptor_think2use_hittype_splash);
435         proj.bot_dodge = true;
436         proj.bot_dodgerating = WEP_CVAR_SEC(electro, damage);
437         proj.nextthink = time + WEP_CVAR_SEC(electro, lifetime);
438         PROJECTILE_MAKETRIGGER(proj);
439         proj.projectiledeathtype = WEP_ELECTRO.m_id | HITTYPE_SECONDARY;
440         setorigin(proj, w_shotorg);
441
442         //proj.glow_size = 50;
443         //proj.glow_color = 45;
444         set_movetype(proj, MOVETYPE_BOUNCE);
445         W_SetupProjVelocity_UP_SEC(proj, electro);
446         settouch(proj, W_Electro_Orb_Touch);
447         setsize(proj, '-4 -4 -4', '4 4 4');
448         proj.takedamage = DAMAGE_YES;
449         proj.damageforcescale = WEP_CVAR_SEC(electro, damageforcescale);
450         proj.health = WEP_CVAR_SEC(electro, health);
451         proj.event_damage = W_Electro_Orb_Damage;
452         proj.flags = FL_PROJECTILE;
453         IL_PUSH(g_projectiles, proj);
454         IL_PUSH(g_bot_dodge, proj);
455         proj.damagedbycontents = (WEP_CVAR_SEC(electro, damagedbycontents));
456
457         proj.bouncefactor = WEP_CVAR_SEC(electro, bouncefactor);
458         proj.bouncestop = WEP_CVAR_SEC(electro, bouncestop);
459         proj.missile_flags = MIF_SPLASH | MIF_ARC;
460
461 #if 0
462         entity p2;
463         p2 = spawn();
464         copyentity(proj, p2);
465         setmodel(p2, MDL_PROJECTILE_ELECTRO);
466         setsize(p2, proj.mins, proj.maxs);
467 #endif
468
469         CSQCProjectile(proj, true, PROJECTILE_ELECTRO, false); // no culling, it has sound
470
471         MUTATOR_CALLHOOK(EditProjectile, actor, proj);
472 }
473
474 void W_Electro_CheckAttack(Weapon thiswep, entity actor, .entity weaponentity, int fire)
475 {
476         if(actor.(weaponentity).electro_count > 1)
477         if(PHYS_INPUT_BUTTON_ATCK2(actor))
478         if(weapon_prepareattack(thiswep, actor, weaponentity, true, -1))
479         {
480                 W_Electro_Attack_Orb(WEP_ELECTRO, actor, weaponentity);
481                 actor.(weaponentity).electro_count -= 1;
482                 weapon_thinkf(actor, weaponentity, WFRAME_FIRE2, WEP_CVAR_SEC(electro, animtime), W_Electro_CheckAttack);
483                 return;
484         }
485         // WEAPONTODO: when the player releases the button, cut down the length of refire2?
486         w_ready(thiswep, actor, weaponentity, fire);
487 }
488
489 .float bot_secondary_electromooth;
490
491 METHOD(Electro, wr_aim, void(entity thiswep, entity actor, .entity weaponentity))
492 {
493     PHYS_INPUT_BUTTON_ATCK(actor) = PHYS_INPUT_BUTTON_ATCK2(actor) = false;
494     if(vdist(actor.origin - actor.enemy.origin, >, 1000)) { actor.bot_secondary_electromooth = 0; }
495     if(actor.bot_secondary_electromooth == 0)
496     {
497         float shoot;
498
499         if(WEP_CVAR_PRI(electro, speed))
500             shoot = bot_aim(actor, WEP_CVAR_PRI(electro, speed), 0, WEP_CVAR_PRI(electro, lifetime), false);
501         else
502             shoot = bot_aim(actor, 1000000, 0, 0.001, false);
503
504         if(shoot)
505         {
506             PHYS_INPUT_BUTTON_ATCK(actor) = true;
507             if(random() < 0.01) actor.bot_secondary_electromooth = 1;
508         }
509     }
510     else
511     {
512         if(bot_aim(actor, WEP_CVAR_SEC(electro, speed), WEP_CVAR_SEC(electro, speed_up), WEP_CVAR_SEC(electro, lifetime), true))
513         {
514             PHYS_INPUT_BUTTON_ATCK2(actor) = true;
515             if(random() < 0.03) actor.bot_secondary_electromooth = 0;
516         }
517     }
518 }
519 METHOD(Electro, wr_think, void(entity thiswep, entity actor, .entity weaponentity, int fire))
520 {
521     if(autocvar_g_balance_electro_reload_ammo) // forced reload // WEAPONTODO
522     {
523         float ammo_amount = 0;
524         if(actor.(weaponentity).clip_load >= WEP_CVAR_PRI(electro, ammo))
525             ammo_amount = 1;
526         if(actor.(weaponentity).clip_load >= WEP_CVAR_SEC(electro, ammo))
527             ammo_amount += 1;
528
529         if(!ammo_amount)
530         {
531             thiswep.wr_reload(thiswep, actor, weaponentity);
532             return;
533         }
534     }
535
536     if(fire & 1)
537     {
538         if(weapon_prepareattack(thiswep, actor, weaponentity, false, WEP_CVAR_PRI(electro, refire)))
539         {
540                 W_Electro_Attack_Bolt(thiswep, actor, weaponentity);
541                 weapon_thinkf(actor, weaponentity, WFRAME_FIRE1, WEP_CVAR_PRI(electro, animtime), w_ready);
542         }
543     }
544     else if(fire & 2)
545     {
546         if(time >= actor.(weaponentity).electro_secondarytime)
547         if(weapon_prepareattack(thiswep, actor, weaponentity, true, WEP_CVAR_SEC(electro, refire)))
548         {
549             W_Electro_Attack_Orb(thiswep, actor, weaponentity);
550             actor.(weaponentity).electro_count = WEP_CVAR_SEC(electro, count);
551             weapon_thinkf(actor, weaponentity, WFRAME_FIRE2, WEP_CVAR_SEC(electro, animtime), W_Electro_CheckAttack);
552             actor.(weaponentity).electro_secondarytime = time + WEP_CVAR_SEC(electro, refire2) * W_WeaponRateFactor(actor);
553         }
554     }
555 }
556 METHOD(Electro, wr_checkammo1, bool(entity thiswep, entity actor, .entity weaponentity))
557 {
558     float ammo_amount = actor.(thiswep.ammo_field) >= WEP_CVAR_PRI(electro, ammo);
559     ammo_amount += actor.(weaponentity).(weapon_load[WEP_ELECTRO.m_id]) >= WEP_CVAR_PRI(electro, ammo);
560     return ammo_amount;
561 }
562 METHOD(Electro, wr_checkammo2, bool(entity thiswep, entity actor, .entity weaponentity))
563 {
564     float ammo_amount;
565     if(WEP_CVAR(electro, combo_safeammocheck)) // true if you can fire at least one secondary blob AND one primary shot after it, otherwise false.
566     {
567         ammo_amount = actor.(thiswep.ammo_field) >= WEP_CVAR_SEC(electro, ammo) + WEP_CVAR_PRI(electro, ammo);
568         ammo_amount += actor.(weaponentity).(weapon_load[WEP_ELECTRO.m_id]) >= WEP_CVAR_SEC(electro, ammo) + WEP_CVAR_PRI(electro, ammo);
569     }
570     else
571     {
572         ammo_amount = actor.(thiswep.ammo_field) >= WEP_CVAR_SEC(electro, ammo);
573         ammo_amount += actor.(weaponentity).(weapon_load[WEP_ELECTRO.m_id]) >= WEP_CVAR_SEC(electro, ammo);
574     }
575     return ammo_amount;
576 }
577 METHOD(Electro, wr_resetplayer, void(entity thiswep, entity actor))
578 {
579     for(int slot = 0; slot < MAX_WEAPONSLOTS; ++slot)
580     {
581         .entity weaponentity = weaponentities[slot];
582         actor.(weaponentity).electro_secondarytime = time;
583     }
584 }
585 METHOD(Electro, wr_reload, void(entity thiswep, entity actor, .entity weaponentity))
586 {
587     W_Reload(actor, weaponentity, min(WEP_CVAR_PRI(electro, ammo), WEP_CVAR_SEC(electro, ammo)), SND_RELOAD);
588 }
589 METHOD(Electro, wr_suicidemessage, Notification(entity thiswep))
590 {
591     if(w_deathtype & HITTYPE_SECONDARY)
592         return WEAPON_ELECTRO_SUICIDE_ORBS;
593     else
594         return WEAPON_ELECTRO_SUICIDE_BOLT;
595 }
596 METHOD(Electro, wr_killmessage, Notification(entity thiswep))
597 {
598     if(w_deathtype & HITTYPE_SECONDARY)
599     {
600         return WEAPON_ELECTRO_MURDER_ORBS;
601     }
602     else
603     {
604         if(w_deathtype & HITTYPE_BOUNCE)
605             return WEAPON_ELECTRO_MURDER_COMBO;
606         else
607             return WEAPON_ELECTRO_MURDER_BOLT;
608     }
609 }
610
611 #endif
612 #ifdef CSQC
613
614 METHOD(Electro, wr_impacteffect, void(entity thiswep, entity actor))
615 {
616     vector org2;
617     org2 = w_org + w_backoff * 6;
618     if(w_deathtype & HITTYPE_SECONDARY)
619     {
620         pointparticles(EFFECT_ELECTRO_BALLEXPLODE, org2, '0 0 0', 1);
621         if(!w_issilent)
622             sound(actor, CH_SHOTS, SND_ELECTRO_IMPACT, VOL_BASE, ATTEN_NORM);
623     }
624     else
625     {
626         if(w_deathtype & HITTYPE_BOUNCE)
627         {
628             // this is sent as "primary (w_deathtype & HITTYPE_BOUNCE)" to distinguish it from (w_deathtype & HITTYPE_SECONDARY) bounced balls
629             pointparticles(EFFECT_ELECTRO_COMBO, org2, '0 0 0', 1);
630             if(!w_issilent)
631                 sound(actor, CH_SHOTS, SND_ELECTRO_IMPACT_COMBO, VOL_BASE, ATTEN_NORM);
632         }
633         else
634         {
635             pointparticles(EFFECT_ELECTRO_IMPACT, org2, '0 0 0', 1);
636             if(!w_issilent)
637                 sound(actor, CH_SHOTS, SND_ELECTRO_IMPACT, VOL_BASE, ATTEN_NORM);
638         }
639     }
640 }
641
642 #endif
643 #endif