1 package cz.cuni.amis.pogamut.ut2004.communication.translator.itemdescriptor;
2
3 import cz.cuni.amis.pogamut.ut2004.communication.messages.ItemType;
4
5 /**
6 * Weapon descriptor describes all characteristics of a weapon.
7 *
8 * @author Ondrej, knight
9 */
10 public class WeaponDescriptor extends ItemDescriptor {
11
12 public WeaponDescriptor() {
13 }
14
15 // Attributes
16 @ItemDescriptorField
17 private boolean melee = false;
18 @ItemDescriptorField
19 private boolean sniping = false;
20 @ItemDescriptorField
21 private boolean usesAltAmmo = false;
22
23 // Primary firing mode
24 @ItemDescriptorField
25 private String priFireModeType;
26 @ItemDescriptorField
27 private boolean priSplashDamage = false;
28 @ItemDescriptorField
29 private boolean priSplashJump = false;
30 @ItemDescriptorField
31 private boolean priRecomSplashDamage = false;
32 @ItemDescriptorField
33 private boolean priTossed = false;
34 @ItemDescriptorField
35 private boolean priLeadTarget = false;
36 @ItemDescriptorField
37 private boolean priInstantHit = false;
38 @ItemDescriptorField
39 private boolean priFireOnRelease = false; // fire when released
40 @ItemDescriptorField
41 private boolean priWaitForRelease = false; // if we want to refire, we need
42 // to stop pushing, push again
43 @ItemDescriptorField
44 private boolean priModeExclusive = false;
45 @ItemDescriptorField
46 private double priFireRate = 0; // how fast the weapon fire
47 @ItemDescriptorField
48 private double priBotRefireRate = 0; // when stoped shooting, how fast we
49 // can resume
50 @ItemDescriptorField
51 private int priAmmoPerFire = 0;
52 @ItemDescriptorField
53 private int priAmmoClipSize = 0;
54 @ItemDescriptorField
55 private double priAimError = 0; // 0=none 1000=quite a bit
56 @ItemDescriptorField
57 private double priSpread = 0; // rotator units. no relation to AimError
58 @ItemDescriptorField
59 private int priSpreadStyle = 0; // is enum in fact
60 @ItemDescriptorField
61 private int priFireCount = 0;
62 @ItemDescriptorField
63 private double priDamageAtten = 0; // attenuate instant-hit/projectile
64 // damage by this multiplier
65
66 // Primary firing mode ammo
67 @ItemDescriptorField
68 private String priAmmoType;
69 @ItemDescriptorField
70 private int priInitialAmount = 0;
71 @ItemDescriptorField
72 private int priMaxAmount = 0;
73 @ItemDescriptorField
74 private double priMaxRange = 0;
75
76 // Primary firing mode ammo damage type
77 @ItemDescriptorField
78 private String priDamageType;
79 @ItemDescriptorField
80 private boolean priArmorStops = true;
81 @ItemDescriptorField
82 private boolean priAlwaysGibs = false;
83 @ItemDescriptorField
84 private boolean priSpecial = false;
85 @ItemDescriptorField
86 private boolean priDetonatesGoop = false;
87 @ItemDescriptorField
88 private boolean priSuperWeapon = false;
89 @ItemDescriptorField
90 private boolean priExtraMomZ = false;
91
92 // Primary firing mode projectile
93 @ItemDescriptorField
94 private String priProjType;
95 @ItemDescriptorField
96 private double priDamage = 0;
97 @ItemDescriptorField
98 private double priSpeed = 0;
99 @ItemDescriptorField
100 private double priMaxSpeed = 0;
101 @ItemDescriptorField
102 private double priLifeSpan = 0;
103 @ItemDescriptorField
104 private double priDamageRadius = 0;
105 @ItemDescriptorField
106 private double priTossZ = 0;
107 @ItemDescriptorField
108 private double priMaxEffectDistance = 0;
109
110 // Secondary firing mode
111 @ItemDescriptorField
112 private String secFireModeType;
113 @ItemDescriptorField
114 private boolean secSplashDamage = false;
115 @ItemDescriptorField
116 private boolean secSplashJump = false;
117 @ItemDescriptorField
118 private boolean secRecomSplashDamage = false;
119 @ItemDescriptorField
120 private boolean secTossed = false;
121 @ItemDescriptorField
122 private boolean secLeadTarget = false;
123 @ItemDescriptorField
124 private boolean secInstantHit = false;
125 @ItemDescriptorField
126 private boolean secFireOnRelease = false; // fire when released
127 @ItemDescriptorField
128 private boolean secWaitForRelease = false; // if we want to refire, we need
129 // to stop pushing, push again
130 @ItemDescriptorField
131 private boolean secModeExclusive = false;
132 @ItemDescriptorField
133 private double secFireRate = 0; // how fast the weapon fire
134 @ItemDescriptorField
135 private double secBotRefireRate = 0; // when stoped shooting, how fast we
136 // can resume
137 @ItemDescriptorField
138 private int secAmmoPerFire = 0;
139 @ItemDescriptorField
140 private int secAmmoClipSize = 0;
141 @ItemDescriptorField
142 private double secAimError = 0; // 0=none 1000=quite a bit
143 @ItemDescriptorField
144 private double secSpread = 0; // rotator units. no relation to AimError
145 @ItemDescriptorField
146 private int secSpreadStyle = 0; // is enum in fact
147 @ItemDescriptorField
148 private int secFireCount = 0;
149 @ItemDescriptorField
150 private double secDamageAtten = 0; // attenuate instant-hit/projectile
151 // damage by this multiplier
152
153 // Secondary firing mode ammo
154 @ItemDescriptorField
155 private String secAmmoType;
156 @ItemDescriptorField
157 private int secInitialAmount = 0;
158 @ItemDescriptorField
159 private int secMaxAmount = 0;
160 @ItemDescriptorField
161 private double secMaxRange = 0;
162
163 // Secondary firing mode ammo damage type
164 @ItemDescriptorField
165 private String secDamageType;
166 @ItemDescriptorField
167 private boolean secArmorStops = true;
168 @ItemDescriptorField
169 private boolean secAlwaysGibs = false;
170 @ItemDescriptorField
171 private boolean secSpecial = false;
172 @ItemDescriptorField
173 private boolean secDetonatesGoop = false;
174 @ItemDescriptorField
175 private boolean secSuperWeapon = false;
176 @ItemDescriptorField
177 private boolean secExtraMomZ = false;
178
179 // Secondary firing mode projectile
180 @ItemDescriptorField
181 private String secProjType;
182 @ItemDescriptorField
183 private double secDamage = 0;
184 @ItemDescriptorField
185 private double secSpeed = 0;
186 @ItemDescriptorField
187 private double secMaxSpeed = 0;
188 @ItemDescriptorField
189 private double secLifeSpan = 0;
190 @ItemDescriptorField
191 private double secDamageRadius = 0;
192 @ItemDescriptorField
193 private double secTossZ = 0;
194 @ItemDescriptorField
195 private double secMaxEffectDistance = 0;
196
197 @Override
198 public String toString() {
199 return "WeaponDescriptor[pickupType="+ getPickupType() + ", inventoryType=" + getInventoryType() + ", itemCategory=" + getItemCategory() + "]";
200 }
201
202 /**
203 * UT engine informs us, if this weapon is known as melee (short range,
204 * close combat).
205 *
206 * @return melee
207 */
208 public boolean isMelee() {
209 return melee;
210 }
211
212 /**
213 * UT engine infroms us, if this weapon is a sniper weapon (long range, high
214 * damage).
215 *
216 * @return sniping
217 */
218 public boolean isSniping() {
219 return sniping;
220 }
221
222 /**
223 * Whether this weapon uses two separate ammo classes - first for primary
224 * firing mode, second for secondary.
225 *
226 * @return usesAltAmmo
227 */
228 public boolean isUsesAltAmmo() {
229 return usesAltAmmo;
230 }
231
232 /**
233 * Returns the class of primary firing mode. If none, the weapon has NOT
234 * primary firing mode that means all information for primary firing mode
235 * are not relevant and will have default values.
236 *
237 * @return priFireModeType
238 */
239 public String getPriFireModeType() {
240 return priFireModeType;
241 }
242
243 /**
244 * If our weapons primary firing mode does splash damage - area effect.
245 * Weapon will damage everything in certain raidus.
246 *
247 * @return priSplashDamage
248 */
249 public boolean isPriSplashDamage() {
250 return priSplashDamage;
251 }
252
253 /**
254 * If this weapon can be used to boost jumping height.
255 *
256 * @return priSplashJump
257 */
258 public boolean isPriSplashJump() {
259 return priSplashJump;
260 }
261
262 /**
263 * If the engine recomends us to use splash damage. For AI?
264 *
265 * @return priRecomSplashDamage
266 * @todo Find correct information about this.
267 */
268 public boolean isPriRecomSplashDamage() {
269 return priRecomSplashDamage;
270 }
271
272 /**
273 * If the weapon in this firing mode is tossing projectiles. The projectiles
274 * will usually fall down to the ground slowly (they won't fly in a line).
275 *
276 * @return priTossed
277 */
278 public boolean isPriTossed() {
279 return priTossed;
280 }
281
282 /**
283 * If this firing mode is capable of shooting projectiles that will lead the
284 * target.
285 *
286 * @return priLeadTarget
287 * @todo Find correct info about this.
288 */
289 public boolean isPriLeadTarget() {
290 return priLeadTarget;
291 }
292
293 /**
294 * If this firing mode does instant hits - will hit the target at the moment
295 * it is fired. Usually true for weapon like machine gun. False for slow
296 * projectiles.
297 *
298 * @return priInsantHit
299 */
300 public boolean isPriInstantHit() {
301 return priInstantHit;
302 }
303
304 /**
305 * If to fire this firing mode you need to press shooting button (start
306 * shooting) and then release it (stop shooting). Usually true for charged
307 * weapons. You'll first charge your weapon and when decided you've charged
308 * the weapon enough, you release the key and the weapon fires.
309 *
310 * @return priFireOnRelease
311 */
312 public boolean isPriFireOnRelease() {
313 return priFireOnRelease;
314 }
315
316 /**
317 * If to fire this mode you need to stop pressing shooting button between
318 * two shots to shoot. You will fire once when pressing the button, then you
319 * need to press it again to fire again.
320 *
321 * @return priWaitForRelease
322 */
323 public boolean isPriWaitForRelease() {
324 return priWaitForRelease;
325 }
326
327 /**
328 * If true you are unable to fire both firing modes of this weapon at the
329 * same time.
330 *
331 * @return priModeExlusive
332 */
333 public boolean isPriModeExclusive() {
334 return priModeExclusive;
335 }
336
337 /**
338 * How fast this weapon fires. Delay between two shots, when shooting
339 * continuously.
340 *
341 * @return priFireRate
342 */
343 public double getPriFireRate() {
344 return priFireRate;
345 }
346
347 /**
348 * How fast we can refire the weapon. Delay between when we stop shooting
349 * and when we can start shooting again.
350 *
351 * @return priBotRefireRate
352 */
353 public double getPriBotRefireRate() {
354 return priBotRefireRate;
355 }
356
357 /**
358 * How much ammo this weapon consumes for one shot.
359 *
360 * @return priAmmoPerFire
361 */
362 public int getPriAmmoPerFire() {
363 return priAmmoPerFire;
364 }
365
366 /**
367 * If this mode has clips how big they are.
368 *
369 * @return priAmmoClipSize
370 * @todo Find correct info.
371 */
372 public int getPriAmmoClipSize() {
373 return priAmmoClipSize;
374 }
375
376 /**
377 * How big aiming error this firing mode has. 0 - none, 1000 quite a bit.
378 *
379 * @return priAimError
380 */
381 public double getPriAimError() {
382 return priAimError;
383 }
384
385 /**
386 * When the weapon is spreading some projectiles, here is how big the spread
387 * is. In UT rotator units. No relation to AimError.
388 *
389 * @return priSpread
390 */
391 public double getPriSpread() {
392 return priSpread;
393 }
394
395 /**
396 * The style of weapon spread. Is in fact enum. Definition below (starts
397 * from 0 and goes up).
398 *
399 * var() enum ESpreadStyle { SS_None, SS_Random, // spread is max random
400 * angle deviation SS_Line, // spread is angle between each projectile
401 * SS_Ring } SpreadStyle;
402 *
403 * @return priSpreadStyle
404 */
405 public int getPriSpreadStyle() {
406 return priSpreadStyle;
407 }
408
409 /**
410 * Firing mode fire count.
411 *
412 * @return priFireCount
413 * @todo Find out what this is.
414 */
415 public int getPriFireCount() {
416 return priFireCount;
417 }
418
419 /**
420 * Attenuate instant-hit/projectile damage by this multiplier.
421 *
422 * @return priDamageAtten
423 */
424 public double getPriDamageAtten() {
425 return priDamageAtten;
426 }
427
428 /**
429 * The class of primary firing mode ammunition type. If none, then the
430 * firing mode does not use any ammunition. That means all ammo specific
431 * information is not relevant and will have default values (ammo specific
432 * information starts from this attribute and ends at priProjType attribute -
433 * that is not ammo specific).
434 *
435 * @return priAmmoType
436 */
437 public String getPriAmmoType() {
438 return priAmmoType;
439 }
440
441 private ItemType priAmmoItemType = null;
442
443 /**
444 * @return ammo type as {@link ItemType}, null if not exist or uses primary ammo
445 */
446 public ItemType getPriAmmoItemType() {
447 if (getPriAmmoType() == null) return null;
448 if (priAmmoItemType != null) return priAmmoItemType;
449 priAmmoItemType = ItemType.getItemType(getPriAmmoType());
450 return priAmmoItemType;
451 }
452
453 /**
454 * Initial amount of ammunition. We get this if we pick up the item for the
455 * first time.
456 *
457 * @return priInitialAmount
458 */
459 public int getPriInitialAmount() {
460 return priInitialAmount;
461 }
462
463 /**
464 * Maximum amount of this ammunition we can hold in our inventory.
465 *
466 * @return priMaxAmount
467 */
468 public int getPriMaxAmount() {
469 return priMaxAmount;
470 }
471
472 /**
473 * Maximum firing range. 0 if not limited - probably.
474 *
475 * @return priMaxRange
476 * @todo Find out how this works.
477 */
478 public double getPriMaxRange() {
479 return priMaxRange;
480 }
481
482 /**
483 * Class of this ammunitions damage type. If ammo is not none, then this
484 * shouldn't be none either.
485 *
486 * @return priDamageType
487 */
488 public String getPriDamageType() {
489 return priDamageType;
490 }
491
492 /**
493 * If this damage can be stopped by an armor.
494 *
495 * @return priArmorStops
496 */
497 public boolean isPriArmorStops() {
498 return priArmorStops;
499 }
500
501 /**
502 * If this damage will kill us instantly.
503 *
504 * @return priAlwaysGibs
505 */
506 public boolean isPriAlwaysGibs() {
507 return priAlwaysGibs;
508 }
509
510 /**
511 * If this damage is special.
512 *
513 * @return priSpecial
514 * @todo find out what it is.
515 */
516 public boolean isPriSpecial() {
517 return priSpecial;
518 }
519
520 /**
521 * If this damage can detonate goop created by bio rifle (not sure).
522 *
523 * @return priDetonatesGoop
524 * @todo Find out correct info.
525 */
526 public boolean isPriDetonatesGoop() {
527 return priDetonatesGoop;
528 }
529
530 /**
531 * If this damage is caused by super weapon and will damage also team mates
532 * even if friendly fire is off.
533 *
534 * @return priSuperWeapon
535 */
536 public boolean isPriSuperWeapon() {
537 return priSuperWeapon;
538 }
539
540 /**
541 * If the hit by this damage will add some speed to the target (will "push"
542 * the target a bit).
543 *
544 * @return priExtraMomZ
545 */
546 public boolean isPriExtraMomZ() {
547 return priExtraMomZ;
548 }
549
550 /**
551 * Holds the class of the projectile of this firing mode. If none, then the
552 * mode does not spawn projectiles. all the info below is then not relevant
553 * and will have default values on.
554 *
555 * @return priProjType
556 */
557 public String getPriProjType() {
558 return priProjType;
559 }
560
561 /**
562 * Damage of the projectile.
563 *
564 * @return priDamage
565 */
566 public double getPriDamage() {
567 return priDamage;
568 }
569
570 /**
571 * Default speed of the projectile - probably the projectile has this speed
572 * when fired.
573 *
574 * @return priSpeed
575 */
576 public double getPriSpeed() {
577 return priSpeed;
578 }
579
580 /**
581 * Maximum possible speed of this projectile.
582 *
583 * @return priMaxSpeed
584 */
585 public double getPriMaxSpeed() {
586 return priMaxSpeed;
587 }
588
589 /**
590 * Life span of this projectile. How long the projectile lasts in the
591 * environment. If 0 than probably unlimited.
592 *
593 * @return priLifeSpan
594 */
595 public double getPriLifeSpan() {
596 return priLifeSpan;
597 }
598
599 /**
600 * If the projectile does splash damage, the value here won't be zero and
601 * will specify the radius of the splash damage in ut units.
602 *
603 * @return priDamageRadius
604 */
605 public double getPriDamageRadius() {
606 return priDamageRadius;
607 }
608
609 /**
610 * Probably the amount of speed added to Z velocity vector when this
611 * projectile is fired. In UT units.
612 *
613 * @return priTossZ
614 * @todo Find out correct info.
615 */
616 public double getPriTossZ() {
617 return priTossZ;
618 }
619
620 /**
621 * Maximum effective distance of the projectile. Probably 0 if not limited.
622 *
623 * @return priMaxEffectDistance
624 * @todo Find out correct info.
625 */
626 public double getPriMaxEffectDistance() {
627 return priMaxEffectDistance;
628 }
629
630 /**
631 * Returns the class of secondary firing mode. If none, the weapon has NOT
632 * secondary firing mode that means all information for secondary firing
633 * mode are not relevant and will have default values.
634 *
635 * @return secFireModeType
636 */
637 public String getSecFireModeType() {
638 return secFireModeType;
639 }
640
641 /**
642 * If our weapons secondary firing mode does splash damage - area effect.
643 * Weapon will damage everything in certain raidus.
644 *
645 * @return secSplashDamage
646 */
647 public boolean isSecSplashDamage() {
648 return secSplashDamage;
649 }
650
651 /**
652 * If this weapon can be used to boost jumping height.
653 *
654 * @return secSplashJump
655 */
656 public boolean isSecSplashJump() {
657 return secSplashJump;
658 }
659
660 /**
661 * If the engine recomends us to use splash damage. For AI?
662 *
663 * @return secRecomSplashDamage
664 * @todo Find correct information about this.
665 */
666 public boolean isSecRecomSplashDamage() {
667 return secRecomSplashDamage;
668 }
669
670 /**
671 * If the weapon in this firing mode is tossing projectiles. The projectiles
672 * will usually fall down to the ground slowly (they won't fly in a line).
673 *
674 * @return secTossed
675 */
676 public boolean isSecTossed() {
677 return secTossed;
678 }
679
680 /**
681 * If this firing mode is capable of shooting projectiles that will lead the
682 * target.
683 *
684 * @return secLeadTarget
685 * @todo Find correct info about this.
686 */
687 public boolean isSecLeadTarget() {
688 return secLeadTarget;
689 }
690
691 /**
692 * If this firing mode does instant hits - will hit the target at the moment
693 * it is fired. Usually true for weapon like machine gun. False for slow
694 * projectiles.
695 *
696 * @return secInsantHit
697 */
698 public boolean isSecInstantHit() {
699 return secInstantHit;
700 }
701
702 /**
703 * If to fire this firing mode you need to press shooting button (start
704 * shooting) and then release it (stop shooting). Usually true for charged
705 * weapons. You'll first charge your weapon and when decided you've charged
706 * the weapon enough, you release the key and the weapon fires.
707 *
708 * @return secFireOnRelease
709 */
710 public boolean isSecFireOnRelease() {
711 return secFireOnRelease;
712 }
713
714 /**
715 * If to fire this mode you need to stop pressing shooting button between
716 * two shots to shoot. You will fire once when pressing the button, then you
717 * need to press it again to fire again.
718 *
719 * @return secWaitForRelease
720 */
721 public boolean isSecWaitForRelease() {
722 return secWaitForRelease;
723 }
724
725 /**
726 * If true you are unable to fire both firing modes of this weapon at the
727 * same time.
728 *
729 * @return secModeExlusive
730 */
731 public boolean isSecModeExclusive() {
732 return secModeExclusive;
733 }
734
735 /**
736 * How fast this weapon fires. Delay between two shots, when shooting
737 * continuously.
738 *
739 * @return secFireRate
740 */
741 public double getSecFireRate() {
742 return secFireRate;
743 }
744
745 /**
746 * How fast we can refire the weapon. Delay between when we stop shooting
747 * and when we can start shooting again.
748 *
749 * @return secBotRefireRate
750 */
751 public double getSecBotRefireRate() {
752 return secBotRefireRate;
753 }
754
755 /**
756 * How much ammo this weapon consumes for one shot.
757 *
758 * @return secAmmoPerFire
759 */
760 public int getSecAmmoPerFire() {
761 return secAmmoPerFire;
762 }
763
764 /**
765 * If this mode has clips how big they are.
766 *
767 * @return secAmmoClipSize
768 * @todo Find correct info.
769 */
770 public int getSecAmmoClipSize() {
771 return secAmmoClipSize;
772 }
773
774 /**
775 * How big aiming error this firing mode has. 0 - none, 1000 quite a bit.
776 *
777 * @return secAimError
778 */
779 public double getSecAimError() {
780 return secAimError;
781 }
782
783 /**
784 * When the weapon is spreading some projectiles, here is how big the spread
785 * is. In UT rotator units. No relation to AimError.
786 *
787 * @return secSpread
788 */
789 public double getSecSpread() {
790 return secSpread;
791 }
792
793 /**
794 * The style of weapon spread. Is in fact enum. Definition below (starts
795 * from 0 and goes up).
796 *
797 * var() enum ESpreadStyle { SS_None, SS_Random, // spread is max random
798 * angle deviation SS_Line, // spread is angle between each projectile
799 * SS_Ring } SpreadStyle;
800 *
801 * @return secSpreadStyle
802 */
803 public int getSecSpreadStyle() {
804 return secSpreadStyle;
805 }
806
807 /**
808 * Firing mode fire count.
809 *
810 * @return secFireCount
811 * @todo Find out what this is.
812 */
813 public int getSecFireCount() {
814 return secFireCount;
815 }
816
817 /**
818 * Attenuate instant-hit/projectile damage by this multiplier.
819 *
820 * @return secDamageAtten
821 */
822 public double getSecDamageAtten() {
823 return secDamageAtten;
824 }
825
826 /**
827 * The class of secondary firing mode ammunition type. If none, then the
828 * firing mode does not use any ammunition. That means all ammo specific
829 * information is not relevant and will have default values (ammo specific
830 * informaton starts from this attribute and ends at secProjType attribute -
831 * that is not ammo specific).
832 *
833 * @return secAmmoType
834 */
835 public String getSecAmmoType() {
836 return secAmmoType;
837 }
838
839 private ItemType secAmmoItemType = null;
840
841 /**
842 * @return secondary ammo type as {@link ItemType}, null if not exist or uses primary ammo
843 */
844 public ItemType getSecAmmoItemType() {
845 if (getSecAmmoType() == null || getSecAmmoType().equals("None")) return null;
846 if (secAmmoItemType != null) return secAmmoItemType;
847 secAmmoItemType = ItemType.getItemType(getSecAmmoType());
848 return secAmmoItemType;
849 }
850
851
852 /**
853 * Initial amount of ammunition. We get this if we pick up the item for the
854 * first time.
855 *
856 * @return secInitialAmount
857 */
858 public int getSecInitialAmount() {
859 return secInitialAmount;
860 }
861
862 /**
863 * Maximum amount of this ammunition we can hold in our inventory.
864 *
865 * @return secMaxAmount
866 */
867 public int getSecMaxAmount() {
868 return secMaxAmount;
869 }
870
871 /**
872 * Maximum firing range. 0 if not limited - probably.
873 *
874 * @return secMaxRange
875 * @todo Find out how this works.
876 */
877 public double getSecMaxRange() {
878 return secMaxRange;
879 }
880
881 /**
882 * Class of this ammunitions damage type. If ammo is not none, then this
883 * shouldn't be none either.
884 *
885 * @return secDamageType
886 */
887 public String getSecDamageType() {
888 return secDamageType;
889 }
890
891 /**
892 * If this damage can be stopped by an armor.
893 *
894 * @return secArmorStops
895 */
896 public boolean isSecArmorStops() {
897 return secArmorStops;
898 }
899
900 /**
901 * If this damage will kill us instantly.
902 *
903 * @return secAlwaysGibs
904 */
905 public boolean isSecAlwaysGibs() {
906 return secAlwaysGibs;
907 }
908
909 /**
910 * If this damage is special.
911 *
912 * @return secSpecial
913 * @todo find out what it is.
914 */
915 public boolean isSecSpecial() {
916 return secSpecial;
917 }
918
919 /**
920 * If this damage can detonate goop created by bio rifle (not sure).
921 *
922 * @return secDetonatesGoop
923 * @todo Find out correct info.
924 */
925 public boolean isSecDetonatesGoop() {
926 return secDetonatesGoop;
927 }
928
929 /**
930 * If this damage is caused by super weapon and will damage also team mates
931 * even if friendly fire is off.
932 *
933 * @return secSuperWeapon
934 */
935 public boolean isSecSuperWeapon() {
936 return secSuperWeapon;
937 }
938
939 /**
940 * If the hit by this damage will add some speed to the target (will "push"
941 * the target a bit).
942 *
943 * @return secExtraMomZ
944 */
945 public boolean isSecExtraMomZ() {
946 return secExtraMomZ;
947 }
948
949 /**
950 * Holds the class of the projectile of this firing mode. If none, then the
951 * mode does not spawn projectiles. all the info below is then not relevant
952 * and will have default values on.
953 *
954 * @return secProjType
955 */
956 public String getSecProjType() {
957 return secProjType;
958 }
959
960 /**
961 * Damage of the projectile.
962 *
963 * @return secDamage
964 */
965 public double getSecDamage() {
966 return secDamage;
967 }
968
969 /**
970 * Default speed of the projectile - probably the projectile has this speed
971 * when fired.
972 *
973 * @return secSpeed
974 */
975 public double getSecSpeed() {
976 return secSpeed;
977 }
978
979 /**
980 * Maximum possible speed of this projectile.
981 *
982 * @return secMaxSpeed
983 */
984 public double getSecMaxSpeed() {
985 return secMaxSpeed;
986 }
987
988 /**
989 * Life span of this projectile. How long the projectile lasts in the
990 * environment. If 0 than probably unlimited.
991 *
992 * @return secLifeSpan
993 */
994 public double getSecLifeSpan() {
995 return secLifeSpan;
996 }
997
998 /**
999 * If the projectile does splash damage, the value here won't be zero and
1000 * will specify the radius of the splash damage in ut units.
1001 *
1002 * @return secDamageRadius
1003 */
1004 public double getSecDamageRadius() {
1005 return secDamageRadius;
1006 }
1007
1008 /**
1009 * Probably the amount of speed added to Z velocity vector when this
1010 * projectile is fired. In UT units.
1011 *
1012 * @return secTossZ
1013 * @todo Find out correct info.
1014 */
1015 public double getSecTossZ() {
1016 return secTossZ;
1017 }
1018
1019 /**
1020 * Maximum effective distance of the projectile. Probably 0 if not limited.
1021 *
1022 * @return secMaxEffectDistance
1023 * @todo Find out correct info.
1024 */
1025 public double getSecMaxEffectDistance() {
1026 return secMaxEffectDistance;
1027 }
1028
1029 }