Downloads containing MLLE-DefaultWeapons.asc

Downloads
Name Author Game Mode Rating
Multi-Layer Level Editor...Featured Download Violet CLM Utility 9.6 Download file

File preview

  1. #include "MLLE-Weapons.asc"
  2. namespace DefaultWeapons {
  3.         class Blaster : MLLEWeapons::WeaponInterface {
  4.                 Blaster() {
  5.                         super(
  6.                                 regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  7.                                         xSpeed: 6,
  8.                                         xAcc: 0.125,
  9.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 80,
  10.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 17,
  11.                                         lightType: LIGHT::POINT2,
  12.                                         counterEnd: 35
  13.                                 ),
  14.                                 powerupObjectTemplate: MLLEWeapons::ObjectTemplate(
  15.                                         xSpeed: 7,
  16.                                         xAcc: 0.1875,
  17.                                         animSpeed: 2,
  18.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 80,
  19.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 20,
  20.                                         lightType: LIGHT::POINT,
  21.                                         counterEnd: 30
  22.                                 ),
  23.                                 pickupAnimation: jjAnimSets[ANIM::PICKUPS] + 29,
  24.                                 poweredUpPickupAnimation: jjAnimSets[ANIM::AMMO] + 18,
  25.                                 powerupAnimation: jjAnimSets[ANIM::PICKUPS] + 60,
  26.                                 behavior: function(obj, powerup) {
  27.                                         obj.behavior = BEHAVIOR::BULLET;
  28.                                         if (obj.eventID == OBJECT::ICEBULLET) obj.eventID = OBJECT::BLASTERBULLET;
  29.                                         DefaultSample(obj, WEAPON::BLASTER);
  30.                                 },
  31.                                 onDrawAmmo: function(player, canvas, ignore) { //character-specific animations:
  32.                                         if (player !is null && !player.noFire && player.charCurr != CHAR::FROG && player.charCurr != CHAR::BIRD) {
  33.                                                 const uint number = player.currWeapon;
  34.                                                 const bool powerup = player.powerup[WEAPON::CURRENT];
  35.                                                 const CHAR::Char charCurr = player.charCurr != CHAR::BIRD2 ? player.charCurr : player.charOrig;
  36.                                                 const ::jjANIMATION@ anim = jjAnimations[
  37.                                                         charCurr == CHAR::SPAZ ? (powerup ? (::jjAnimSets[ANIM::AMMO] + 19) : (::jjAnimSets[ANIM::PICKUPS] + 30)) :
  38.                                                         (::jjIsTSF && charCurr == CHAR::LORI) ? (powerup ? (::jjAnimSets[ANIM::PLUS_AMMO] + 6) : (::jjAnimSets[ANIM::PLUS_AMMO] + 5)) :
  39.                                                         (powerup ? (::jjAnimSets[ANIM::AMMO] + 18) : (::jjAnimSets[ANIM::PICKUPS] + 29))
  40.                                                 ];
  41.                                                 int x, y;
  42.                                                 STRING::Size font;
  43.                                                 ::string text;
  44.                                                 if (::jjSubscreenWidth > 400) {
  45.                                                         x = ::jjSubscreenWidth - 88;
  46.                                                         y = ::jjSubscreenHeight - 14;
  47.                                                         font = STRING::MEDIUM;
  48.                                                 } else {
  49.                                                         x = ::jjSubscreenWidth - 48;
  50.                                                         y = ::jjSubscreenHeight - 9;
  51.                                                         font = STRING::SMALL;
  52.                                                 }
  53.                                                 canvas.drawSpriteFromCurFrame(x, y, anim + (::jjGameTicks >> 2) % anim.frameCount);
  54.                                                 const ::jjWEAPON@ weapon = ::jjWeapons[number];
  55.                                                 if (weapon.infinite || weapon.replacedByShield && player.shieldTime > 0) {
  56.                                                         text = "x^";
  57.                                                 } else {
  58.                                                         const int ammo = player.ammo[number];
  59.                                                         text = "x" + (ammo > 0 ? ammo : 0);
  60.                                                 }
  61.                                                 canvas.drawString(x + 8, y, text, font);
  62.                                         }
  63.                                         return true;
  64.                                 }
  65.                         );
  66.                 }
  67.         }
  68.         class Bouncer : MLLEWeapons::WeaponInterface {
  69.                 bool ReverseBehaviors = false;
  70.                 bool BounceThroughWalls = true;
  71.                 Bouncer() {
  72.                         super(
  73.                                 regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  74.                                         xSpeed: 5,
  75.                                         ySpeed: 1,
  76.                                         xAcc: 0.25,
  77.                                         yAcc: 0.0915527344f,
  78.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 4,
  79.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 23,
  80.                                         lightType: LIGHT::POINT2,
  81.                                         counterEnd: (70*3)/2
  82.                                 ),
  83.                                 powerupObjectTemplate: MLLEWeapons::ObjectTemplate(
  84.                                         xSpeed: 5,
  85.                                         ySpeed: 1,
  86.                                         xAcc: 0.25,
  87.                                         yAcc: 0.0915527344f,
  88.                                         animSpeed: 2,
  89.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 4,
  90.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 26,
  91.                                         lightType: LIGHT::POINT2,
  92.                                         counterEnd: (70*3)/2
  93.                                 ),
  94.                                 pickupAnimation: jjAnimSets[ANIM::AMMO] + 25,
  95.                                 poweredUpPickupAnimation: jjAnimSets[ANIM::AMMO] + 24,
  96.                                 powerupAnimation: jjAnimSets[ANIM::PICKUPS] + 61,
  97.                                 ammoCrateAnimation: jjAnimSets[ANIM::PICKUPS] + 54,
  98.                                 traits: se::weapon_default_traits | se::weapon_goes_through_thin_walls,
  99.                                 behavior: MLLEWeapons::behaviorFunction(DetermineBehavior),
  100.                                 apply: MLLEWeapons::applyFunction(DetermineReversedness)
  101.                         );
  102.                 }
  103.                 void DetermineBehavior(jjOBJ@ obj, bool powerup) const {
  104.                         DefaultSample(obj, WEAPON::BOUNCER);
  105.                         if (BounceThroughWalls)
  106.                                 obj.behavior = (powerup != ReverseBehaviors) ? BEHAVIOR::BOUNCERBULLETPU : BEHAVIOR::BOUNCERBULLET;
  107.                         else
  108.                                 obj.behavior = (powerup != ReverseBehaviors) ? BouncerPUNoWallWrapper : BouncerNoWallWrapper;
  109.                 }
  110.                 bool DetermineReversedness(uint, se::WeaponHook@, jjSTREAM@ parameter) {
  111.                         if (parameter !is null && parameter.getSize() >= 2) {
  112.                                 parameter.pop(ReverseBehaviors);
  113.                                 parameter.pop(BounceThroughWalls);
  114.                         }
  115.                         return true;
  116.                 }
  117.         }
  118.         void BouncerNoWallWrapper(jjOBJ@ obj) {
  119.                 const bool right = obj.xSpeed >= 0;
  120.                 obj.behave(BEHAVIOR::BOUNCERBULLET);
  121.                 if (right != (obj.xSpeed >= 0))
  122.                         obj.var[7] = -obj.var[7];
  123.         }
  124.         void BouncerPUNoWallWrapper(jjOBJ@ obj) {
  125.                 const bool right = obj.xSpeed >= 0;
  126.                 obj.behave(BEHAVIOR::BOUNCERBULLETPU);
  127.                 if (right != (obj.xSpeed >= 0))
  128.                         obj.var[7] = -obj.var[7];
  129.         }
  130.         class Ice : MLLEWeapons::WeaponInterface {
  131.                 bool FiringUnfreezesFaster = true;
  132.                 Ice() {
  133.                         super(
  134.                                 regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  135.                                         xSpeed: 6,
  136.                                         xAcc: 0.125,
  137.                                         animSpeed: 2,
  138.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 82,
  139.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 27,
  140.                                         lightType: LIGHT::POINT2,
  141.                                         counterEnd: 35,
  142.                                         freeze: 200
  143.                                 ),
  144.                                 powerupObjectTemplate: MLLEWeapons::ObjectTemplate(
  145.                                         xSpeed: 7,
  146.                                         xAcc: 0.1875,
  147.                                         animSpeed: 2,
  148.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 82,
  149.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 30,
  150.                                         special: jjAnimSets[ANIM::AMMO].firstAnim + 32,
  151.                                         lightType: LIGHT::POINT2,
  152.                                         counterEnd: 30,
  153.                                         freeze: 254
  154.                                 ),
  155.                                 spread: SPREAD::ICE,
  156.                                 traits: se::weapon_is_effective_against_all_targets | se::weapon_supports_mouse_aim | se::weapon_works_in_all_modes | se::weapon_has_all_pickups | se::weapon_inflicts_status_condition | se::weapon_freezes_objects | se::weapon_melts_ice,
  157.                                 pickupAnimation: jjAnimSets[ANIM::AMMO] + 29,
  158.                                 poweredUpPickupAnimation: jjAnimSets[ANIM::AMMO] + 28,
  159.                                 powerupAnimation: jjAnimSets[ANIM::PICKUPS] + 62,
  160.                                 ammoCrateAnimation: jjAnimSets[ANIM::PICKUPS] + 55,
  161.                                 onPlayerInput: se::PlayerCallback(playerInput),
  162.                                 apply: MLLEWeapons::applyFunction(DetermineUnfreezing),
  163.                                 behavior: function(obj, powerup) {
  164.                                         DefaultSample(obj, WEAPON::ICE);
  165.                                         if (powerup) {
  166.                                                 if (obj.xSpeed == 0 || obj.ySpeed == 0) {
  167.                                                         obj.behavior = BEHAVIOR::ICEBULLETPU;
  168.                                                         obj.eventID = OBJECT::ICEBULLETPU;
  169.                                                 } else {
  170.                                                         obj.behavior = BEHAVIOR::BULLET;
  171.                                                         if (powerup) obj.curAnim = jjAnimSets[ANIM::AMMO].firstAnim + 30;
  172.                                                 }
  173.                                                 if (obj.xSpeed != 0) obj.counterEnd = 30;
  174.                                                 obj.var[0] = AlternatingPoweredUpIce ^= 512;
  175.                                         } else {
  176.                                                 obj.behavior = BEHAVIOR::BULLET;
  177.                                                 obj.eventID = OBJECT::ICEBULLET;
  178.                                         }
  179.                                 }
  180.                         );
  181.                 }
  182.                 uint getMaxDamage(bool powerup) const override { return 0; }
  183.                 bool DetermineUnfreezing(uint, se::WeaponHook@, jjSTREAM@ parameter) {
  184.                         if (parameter !is null && !parameter.isEmpty())
  185.                                 parameter.pop(FiringUnfreezesFaster);
  186.                         return true;
  187.                 }
  188.                 void playerInput(jjPLAYER@ play, int) {
  189.                         if (!FiringUnfreezesFaster && play.frozen != 0)
  190.                                 play.keyFire = false;
  191.                 }
  192.         }
  193.         int AlternatingPoweredUpIce = 0;
  194.         class Seeker : MLLEWeapons::WeaponInterface {
  195.                 Seeker() {
  196.                         super(
  197.                                 regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  198.                                         xSpeed: 2,
  199.                                         xAcc: 0.25,
  200.                                         yAcc: 0.00390625f,
  201.                                         animSpeed: 2,
  202.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 5,
  203.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 37,
  204.                                         lightType: LIGHT::POINT2,
  205.                                         counterEnd: 140
  206.                                 ),
  207.                                 powerupObjectTemplate: MLLEWeapons::ObjectTemplate(
  208.                                         xSpeed: 1.5,
  209.                                         xAcc: 0.25,
  210.                                         yAcc: 0.00390625f,
  211.                                         animSpeed: 3,
  212.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 5,
  213.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 42,
  214.                                         lightType: LIGHT::POINT2,
  215.                                         counterEnd: 140
  216.                                 ),
  217.                                 style: WEAPON::MISSILE,
  218.                                 pickupAnimation: jjAnimSets[ANIM::AMMO] + 34,
  219.                                 poweredUpPickupAnimation: jjAnimSets[ANIM::AMMO] + 33,
  220.                                 powerupAnimation: jjAnimSets[ANIM::PICKUPS] + 63,
  221.                                 ammoCrateAnimation: jjAnimSets[ANIM::PICKUPS] + 56,
  222.                                 behavior: function(obj, powerup) { obj.behavior = BEHAVIOR::SEEKERBULLET; DefaultSample(obj, WEAPON::SEEKER); }
  223.                         );
  224.                 }
  225.         }
  226.         class RFs : MLLEWeapons::WeaponInterface {
  227.                 RFs() {
  228.                         super(
  229.                                 regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  230.                                         xSpeed: 1,
  231.                                         xAcc: 0.1875,
  232.                                         animSpeed: 2,
  233.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 3,
  234.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 45,
  235.                                         lightType: LIGHT::POINT2,
  236.                                         counterEnd: 40
  237.                                 ),
  238.                                 powerupObjectTemplate: MLLEWeapons::ObjectTemplate(
  239.                                         xSpeed: 1.5,
  240.                                         xAcc: 0.1875,
  241.                                         animSpeed: 2,
  242.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 3,
  243.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 50,
  244.                                         lightType: LIGHT::POINT2,
  245.                                         counterEnd: 35
  246.                                 ),
  247.                                 isRFMissile: true,
  248.                                 spread: SPREAD::RF,
  249.                                 style: WEAPON::MISSILE,
  250.                                 pickupAnimation: jjAnimSets[ANIM::AMMO] + 49,
  251.                                 poweredUpPickupAnimation: jjAnimSets[ANIM::AMMO] + 48,
  252.                                 powerupAnimation: jjAnimSets[ANIM::PICKUPS] + 64,
  253.                                 ammoCrateAnimation: jjAnimSets[ANIM::PICKUPS] + 57,
  254.                                 traits: se::weapon_default_traits | se::weapon_causes_splash_damage | se::weapon_increases_mobility,
  255.                                 behavior: function(obj, powerup) { obj.behavior = BEHAVIOR::RFBULLET; DefaultSample(obj, WEAPON::RF); }
  256.                         );
  257.                 }
  258.         }
  259.         class Toaster : MLLEWeapons::WeaponInterface {
  260.                 Toaster() {
  261.                         super(
  262.                                 regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  263.                                         xSpeed: 1,
  264.                                         xAcc: 0.125,
  265.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 55,
  266.                                         var: array<int> = {0,0,0,0,0,0,2},
  267.                                         counterEnd: 35
  268.                                 ),
  269.                                 powerupObjectTemplate: MLLEWeapons::ObjectTemplate(
  270.                                         xSpeed: 1,
  271.                                         xAcc: 0.125,
  272.                                         animSpeed: 2,
  273.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 58,
  274.                                         var: array<int> = {0,0,0,0,0,0,2},
  275.                                         counterEnd: 35
  276.                                 ),
  277.                                 spread: SPREAD::TOASTER,
  278.                                 style: WEAPON::POPCORN,
  279.                                 pickupAnimation: jjAnimSets[ANIM::AMMO] + 57,
  280.                                 poweredUpPickupAnimation: jjAnimSets[ANIM::AMMO] + 56,
  281.                                 powerupAnimation: jjAnimSets[ANIM::PICKUPS] + 65,
  282.                                 ammoCrateAnimation: jjAnimSets[ANIM::PICKUPS] + 58,
  283.                                 replacedByBubbles: true,
  284.                                 multiplier: 32,
  285.                                 traits: se::weapon_default_traits | se::weapon_melts_ice | se::weapon_fails_underwater,
  286.                                 behavior: function(obj, powerup) { obj.behavior = BEHAVIOR::TOASTERBULLET; if (powerup) obj.eventID = OBJECT::TOASTERBULLETPU; DefaultSample(obj, WEAPON::TOASTER); }
  287.                         );
  288.                 }
  289.         }
  290.         class TNT : MLLEWeapons::WeaponInterface {
  291.                 bool IncludePowerup = true;
  292.                 TNT() {
  293.                         super(
  294.                                 regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  295.                                         energy: 1,
  296.                                         playerHandling: HANDLING::SPECIAL,
  297.                                         curAnim: jjAnimSets[ANIM::AMMO] + 59,
  298.                                         killAnim: jjAnimSets[ANIM::AMMO] + 77,
  299.                                         lightType: LIGHT::POINT,
  300.                                         counterEnd: 255
  301.                                 ),
  302.                                 style: WEAPON::MISSILE,
  303.                                 pickupAnimation: jjAnimSets[ANIM::AMMO] + 59,
  304.                                 ammoCrateAnimation: jjAnimSets[ANIM::PICKUPS] + 59,
  305.                                 traits: se::weapon_default_traits | se::weapon_causes_splash_damage | se::weapon_increases_mobility,
  306.                                 behavior: MLLEWeapons::behaviorFunction(DetermineBehavior),
  307.                                 apply: MLLEWeapons::applyFunction(DeterminePowerup)
  308.                         );
  309.                 }
  310.                 void DetermineBehavior(jjOBJ@ obj, bool powerup) const {
  311.                         obj.eventID = OBJECT::TNT; //use TNTdamage
  312.                         if (!IncludePowerup || !powerup || PoweredUpPickupAnimation <= 0)
  313.                                 obj.behavior = BEHAVIOR::TNT;
  314.                         else {
  315.                                 obj.behavior = TNTPowerupBehavior;
  316.                                 obj.counter = -256; //double lifetime
  317.                                 obj.curAnim = PoweredUpPickupAnimation;
  318.                         }
  319.                 }
  320.                 bool DeterminePowerup(uint, se::WeaponHook@, jjSTREAM@ parameter) {
  321.                         if (parameter !is null && !parameter.isEmpty())
  322.                                 parameter.pop(IncludePowerup);
  323.                         return true;
  324.                 }
  325.                 uint getMaxDamage(bool powerup) const override { return 1; }
  326.         }
  327.         void TNTPowerupBehavior(jjOBJ@ obj) {
  328.                 if (obj.state == STATE::EXPLODE && obj.counter == 0) //beginning of explosion sequence
  329.                         obj.blast(96*96, true); //hurt nearby players NOW, not just 20 ticks from now after they've already run far away
  330.                 obj.behave(BEHAVIOR::TNT);
  331.                 if (obj.light == 17) //just created an explosion object
  332.                         for (uint objectID = jjObjectCount; --objectID != 0;) {
  333.                                 jjOBJ@ obj2 = jjObjects[objectID];
  334.                                 if (obj2.eventID == OBJECT::EXPLOSION && obj2.curAnim == obj.killAnim && obj2.xPos == obj.xPos && obj2.yPos == obj.yPos) {
  335.                                         obj2.frameID = 4; //skip part where TNT is still visible (using the non-powerup colors)
  336.                                         break;
  337.                                 }
  338.                         }
  339.         }
  340.         class Gun8 : MLLEWeapons::WeaponInterface {
  341.                 Gun8() {
  342.                         super(
  343.                                 regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  344.                                         xSpeed: 11,
  345.                                         xAcc: 0.125,
  346.                                         animSpeed: 2,
  347.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 80,
  348.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 60,
  349.                                         var: array<int> = {0,0,0,0,0,0,16},
  350.                                         lightType: LIGHT::POINT2,
  351.                                         counterEnd: 45
  352.                                 ),
  353.                                 powerupObjectTemplate: MLLEWeapons::ObjectTemplate(
  354.                                         xSpeed: 11,
  355.                                         xAcc: 0.25,
  356.                                         animSpeed: 3,
  357.                                         killAnim: jjAnimSets[ANIM::AMMO].firstAnim + 80,
  358.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 63,
  359.                                         var: array<int> = {0,0,0,0,0,0,16},
  360.                                         lightType: LIGHT::POINT,
  361.                                         counterEnd: 70
  362.                                 ),
  363.                                 spread: SPREAD::NORMAL,
  364.                                 gradualAim: false,
  365.                                 pickupAnimation: jjAnimSets[ANIM::AMMO] + 62,
  366.                                 poweredUpPickupAnimation: jjAnimSets[ANIM::AMMO] + 61,
  367.                                 powerupAnimation: jjAnimSets[ANIM::PICKUPS] + 66,
  368.                                 ammoCrateAnimation: jjAnimSets[ANIM::PLUS_COMMON] + 0,
  369.                                 behavior: function(obj, powerup) {
  370.                                         obj.behavior = BEHAVIOR::BULLET;
  371.                                         if (obj.eventID == OBJECT::ICEBULLET)
  372.                                                 obj.eventID = OBJECT::FIREBALLBULLET;
  373.                                         DefaultSample(obj, WEAPON::GUN8);
  374.                                 },
  375.                                 apply: MLLEWeapons::applyFunction(DetermineSpread)
  376.                         );
  377.                 }
  378.                 bool DetermineSpread(uint, se::WeaponHook@, jjSTREAM@ parameter) {
  379.                         if (parameter !is null && !parameter.isEmpty()) {
  380.                                 GradualAim = true;
  381.                                 uint8 pbyte;
  382.                                 parameter.pop(pbyte);
  383.                 if (pbyte == 0)
  384.                     Spread = SPREAD::GUN8;
  385.                                 else if (pbyte == 1)
  386.                                         Spread = SPREAD::PEPPERSPRAY;
  387.                                 else if (pbyte >= 2) {
  388.                                         Spread = SPREAD::NORMAL;
  389.                                         if (pbyte == 2)
  390.                                                 GradualAim = false;
  391.                                 }
  392.                         }
  393.                         return true;
  394.                 }
  395.         }
  396.         class ElectroBlaster : MLLEWeapons::WeaponInterface {
  397.                 ElectroBlaster() {
  398.                         super(
  399.                                 regularObjectTemplate: MLLEWeapons::ObjectTemplate(
  400.                                         xSpeed: 4,
  401.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 75,
  402.                                         frameID: 4,
  403.                                         var: array<int> = {0,40,0,0,0,0,2},
  404.                                         lightType: LIGHT::POINT2,
  405.                                         counterEnd: 35
  406.                                 ),
  407.                                 powerupObjectTemplate: MLLEWeapons::ObjectTemplate(
  408.                                         xSpeed: 4,
  409.                                         animSpeed: 3,
  410.                                         curAnim: jjAnimSets[ANIM::AMMO].firstAnim + 75,
  411.                                         frameID: 4,
  412.                                         var: array<int> = {0,32,0,0,0,0,2},
  413.                                         lightType: LIGHT::POINT2,
  414.                                         counterEnd: 35
  415.                                 ),
  416.                                 pickupAnimation: jjAnimSets[ANIM::AMMO] + 68,
  417.                                 poweredUpPickupAnimation: jjAnimSets[ANIM::AMMO] + 67,
  418.                                 powerupAnimation: jjAnimSets[ANIM::PICKUPS] + 67,
  419.                                 ammoCrateAnimation: jjAnimSets[ANIM::PLUS_COMMON] + 1,
  420.                                 traits: se::weapon_default_traits | se::weapon_goes_through_walls | se::weapon_melts_ice,
  421.                                 behavior: function(obj, powerup) { obj.behavior = BEHAVIOR::ELECTROBULLET; if (powerup) obj.eventID = OBJECT::ELECTROBULLETPU; DefaultSample(obj, WEAPON::GUN9); }
  422.                         );
  423.                 }
  424.         }
  425. }