Downloads containing xlmyou.j2as

Downloads
Name Author Game Mode Rating
JJ2+ Only: You Arena Superjazz Battle N/A Download file

File preview

  1. const bool MLLESetupSuccessful = MLLE::Setup(); ///@MLLE-Generated
  2. #include "MLLE-Include-1.5.asc" ///@MLLE-Generated
  3. #pragma require "SpaceWarbase.j2t" ///@MLLE-Generated
  4. #pragma require "xlmyou.j2l" ///@MLLE-Generated
  5.  
  6. const int8 ENERGY_FIELD_ENERGY = 10;
  7.  
  8. jjANIMSET@ customSpringSprite;
  9. array<int> fastCustomSpringSpeeds(jjLocalPlayerCount);
  10.  
  11. class CannotBeShotDown : jjBEHAVIORINTERFACE {
  12.         CannotBeShotDown(const jjBEHAVIOR &in behavior) {
  13.                 originalBehavior = behavior;
  14.         }
  15.         void onBehave(jjOBJ@ obj) {
  16.                 obj.behave(originalBehavior);
  17.                 if (obj.state == STATE::FLOATFALL)
  18.                         obj.state = STATE::FLOAT;
  19.         }
  20.         bool onObjectHit(jjOBJ@ obj, jjOBJ@ bullet, jjPLAYER@ player, int force) {
  21.                 if (bullet is null) {
  22.                         obj.behavior = originalBehavior;
  23.                         if (player.objectHit(obj, force, obj.playerHandling))
  24.                                 return true;
  25.                         obj.behavior = this;
  26.                 }
  27.                 return false;
  28.         }
  29.         private jjBEHAVIOR originalBehavior;
  30. }
  31.  
  32. class EnergyField : jjBEHAVIORINTERFACE {
  33.         int elapsedDelayedStart = 0;
  34.         int16 xTile = 0;
  35.         int16 yTile = 0;
  36.        
  37.         void onBehave(jjOBJ@ obj) override {
  38.                 if (obj.state == STATE::START) {
  39.                         obj.energy = ENERGY_FIELD_ENERGY;
  40.                         xTile = int16(obj.xOrg) >> 5;
  41.                         yTile = int16(obj.yOrg) >> 5;
  42.                         if (jjParameterGet(xTile, yTile, 0, 1) == 0) {
  43.                                 jjParameterSet(xTile, yTile, 0, 1, 1);
  44.                                
  45.                                 jjPIXELMAP energyFieldSprite(uint(obj.xOrg) - 12, uint(obj.yOrg) - 6, 8, 192);
  46.                                 jjANIMFRAME@ frame = jjAnimFrames[jjAnimations[jjAnimSets[ANIM::PICKUPS].firstAnim + 2].firstFrame];
  47.                                 energyFieldSprite.save(frame);
  48.                                
  49.                                 jjGenerateSettableTileArea(4, xTile, yTile, 1, 6);
  50.                                 deactivateEnergyField();
  51.                         }
  52.                         elapsedDelayedStart = 0;
  53.                         obj.state = STATE::DELAYEDSTART;
  54.                 } else if (obj.state == STATE::DELAYEDSTART) {
  55.                         if (elapsedDelayedStart < 140) {
  56.                                 elapsedDelayedStart++;
  57.                                 if (jjGameTicks % 10 == 0) {
  58.                                         setParticleProps(obj, jjAddParticle(PARTICLE::PIXEL), true);
  59.                                         setParticleProps(obj, jjAddParticle(PARTICLE::PIXEL), false);
  60.                                 }
  61.                         } else {
  62.                                 activateEnergyField();
  63.                                 obj.state = STATE::IDLE;
  64.                         }
  65.                 } else if (obj.state == STATE::KILL) {
  66.                         deactivateEnergyField();
  67.                 }
  68.                 obj.behave(BEHAVIOR::EVA, false);
  69.         }
  70.        
  71.         // Draw justHit effects artificially, since animated tiles are being used instead of sprites
  72.         void onDraw(jjOBJ@ obj) {
  73.                 if (obj.justHit > 0) {
  74.                         jjDrawRectangle(uint(obj.xOrg) - 10, uint(obj.yOrg) - 6, 4, 176, 15);
  75.                 }
  76.         }
  77.        
  78.         bool onObjectHit(jjOBJ@ obj, jjOBJ@ bullet, jjPLAYER@ player, int force) {
  79.                 if (obj.state != STATE::IDLE) {
  80.                         return true;
  81.                 }
  82.                 if (bullet !is null) {
  83.                         bullet.state = STATE::EXPLODE;
  84.                         obj.justHit = 5;
  85.                         if (obj.energy > 1) {
  86.                                 --obj.energy;
  87.                         } else {
  88.                                 obj.state = STATE::KILL;
  89.                         }
  90.                 } else if (player !is null) {
  91.                         player.hurt();
  92.                        
  93.                         // Artificial measure to prevent players from getting stuck in the energy field when it's respawning
  94.                         if (player.xPos >= obj.xPos) {
  95.                                 player.xPos += 1;
  96.                         } else {
  97.                                 player.xPos -= 1;
  98.                         }
  99.                 }
  100.                 return true;
  101.         }
  102.        
  103.         private void activateEnergyField() {
  104.                 jjTileSet(4, xTile, yTile, 16 + TILE::ANIMATED);
  105.                 jjTileSet(4, xTile, yTile + 1, 17 + TILE::ANIMATED);
  106.                 jjTileSet(4, xTile, yTile + 2, 18 + TILE::ANIMATED);
  107.                 jjTileSet(4, xTile, yTile + 3, 17 + TILE::ANIMATED);
  108.                 jjTileSet(4, xTile, yTile + 4, 18 + TILE::ANIMATED);
  109.                 jjTileSet(4, xTile, yTile + 5, 19 + TILE::ANIMATED);
  110.         }
  111.        
  112.         private void deactivateEnergyField() {
  113.                 jjTileSet(4, xTile, yTile, 609);
  114.                 jjTileSet(4, xTile, yTile + 1, 0);
  115.                 jjTileSet(4, xTile, yTile + 2, 0);
  116.                 jjTileSet(4, xTile, yTile + 3, 0);
  117.                 jjTileSet(4, xTile, yTile + 4, 0);
  118.                 jjTileSet(4, xTile, yTile + 5, 629);
  119.         }
  120.        
  121.         private void setParticleProps(jjOBJ@ obj, jjPARTICLE@ particle, bool isUpperHead) {
  122.                 if (particle !is null) {
  123.                         particle.xPos = obj.xPos - 8;
  124.                         particle.yPos = isUpperHead ? obj.yPos : obj.yPos + 144;
  125.                         particle.ySpeed = isUpperHead ? 1 : -1;
  126.                         particle.pixel.color[1] = 40;
  127.                         particle.pixel.size = 1;
  128.                 }
  129.         }
  130. }
  131.  
  132. class WarpOrb : jjBEHAVIORINTERFACE {
  133.         void onBehave(jjOBJ@ obj) {
  134.                 obj.behave(BEHAVIOR::PICKUP, false);
  135.                 if (obj.state == STATE::FLOATFALL) obj.state = STATE::FLOAT;
  136.         }
  137.         void onDraw(jjOBJ@ obj) {
  138.                 int frame = obj.objectID * 8 + jjGameTicks;
  139.                 frame = (frame + int(obj.xPos) + int(obj.yPos) * 256)*16;
  140.                 jjDrawTile(obj.xPos - 16, (obj.yPos + jjSin(frame) * 4) - 16, 118);
  141.         }
  142.         bool onObjectHit(jjOBJ@ obj, jjOBJ@ bullet, jjPLAYER@ player, int force) {
  143.                 player.warpToID(0);
  144.                 jjSample(player.xPos, player.yPos, SOUND::COMMON_PICKUP1, 63, 17500);
  145.                 obj.frameID = 0;
  146.                 obj.behavior = BEHAVIOR::EXPLOSION2;
  147.                 return true;
  148.         }
  149. }
  150.  
  151. bool generateCustomSpringSprites(jjANIMSET@ anim, const array<uint> &in colors) {
  152.         int length = colors.length();
  153.         bool success = (@customSpringSprite = anim).allocate(array<uint>(length * 3, 5)) !is null;
  154.         if (success) {
  155.                 uint srcSet = jjAnimSets[ANIM::SPRING];
  156.                 for (int i = 0; i < length; i++) {
  157.                         uint color = colors[i];
  158.                         uint destAnimOffset = anim + i * 3;
  159.                         for (int j = 0; j < 3; j++) {
  160.                                 uint srcAnim = jjAnimations[srcSet + j];
  161.                                 uint destAnim = jjAnimations[destAnimOffset + j];
  162.                                 for (int k = 0; k < 5; k++) {
  163.                                         jjPIXELMAP image(jjAnimFrames[destAnim + k] = jjAnimFrames[srcAnim + k]);
  164.                                         int width = image.width;
  165.                                         int height = image.height;
  166.                                         for (int l = 0; l < height; l++) {
  167.                                                 for (int m = 0; m < width; m++) {
  168.                                                         int pixel = image[m, l];
  169.                                                         if (pixel >= 32 && pixel < 40)
  170.                                                                 image[m, l] = color + (pixel & 7);
  171.                                                 }
  172.                                         }
  173.                                         if (!image.save(jjAnimFrames[destAnim + k]))
  174.                                                 return false;
  175.                                 }
  176.                         }
  177.                 }
  178.         }
  179.         return success;
  180. }
  181.  
  182. void handleFastCustomSpringSpeeds(jjPLAYER@ play) {
  183.         if (play.ySpeed < -32.f) {
  184.                 fastCustomSpringSpeeds[play.localPlayerID] = int(ceil((play.ySpeed + 32.f) / -0.125f));
  185.         } else if (fastCustomSpringSpeeds[play.localPlayerID] != 0) {
  186.                 if (play.ySpeed < -31.f) {
  187.                         fastCustomSpringSpeeds[play.localPlayerID]--;
  188.                         play.ySpeed = -32.f;
  189.                 } else {
  190.                         fastCustomSpringSpeeds[play.localPlayerID] = 0;
  191.                 }
  192.         }
  193. }
  194.  
  195. void initializeCustomSpring(jjOBJ@ obj) {
  196.         int anim = obj.curAnim;
  197.         obj.behave(obj.behavior = BEHAVIOR::SPRING, false);
  198.         if (obj.curAnim != anim) {
  199.                 obj.curAnim = anim + 2;
  200.                 obj.determineCurFrame();
  201.         }
  202.         obj.draw();
  203. }
  204.  
  205. void onLevelBegin() {
  206.         for (int i = 1; i < 255; i++) {
  207.                 jjOBJ@ preset = jjObjectPresets[i];
  208.                 if (preset.playerHandling == HANDLING::PICKUP) {
  209.                         preset.behavior = CannotBeShotDown(preset.behavior);
  210.                 }
  211.         }
  212. }
  213.  
  214. void onLevelLoad() {
  215.         jjUseLayer8Speeds = true;
  216.         jjObjectPresets[OBJECT::APPLE].behavior = WarpOrb();
  217.         jjObjectPresets[OBJECT::APPLE].lightType = LIGHT::FLICKER;
  218.         jjObjectPresets[OBJECT::APPLE].scriptedCollisions = true;
  219.         jjObjectPresets[OBJECT::BANANA].behavior =  function(obj){obj.behavior = EnergyField();};
  220.         jjObjectPresets[OBJECT::BANANA].lightType = LIGHT::FLICKER;
  221.         jjObjectPresets[OBJECT::BANANA].scriptedCollisions = true;
  222.         jjObjectPresets[OBJECT::BANANA].bulletHandling = HANDLING::DETECTBULLET;
  223.         jjObjectPresets[OBJECT::BANANA].playerHandling = HANDLING::SPECIAL;
  224.         generateCustomSpringSprites(jjAnimSets[ANIM::CUSTOM[0]], array<uint> = {88, 40});
  225.         turnIntoCustomSpring(jjObjectPresets[OBJECT::FROZENSPRING], 0, 36.0f, false);
  226.         turnIntoCustomSpring(jjObjectPresets[OBJECT::HORREDSPRING], 1, 19.0f, false);
  227. }
  228.  
  229. void onPlayer(jjPLAYER@ play) {
  230.         handleFastCustomSpringSpeeds(play);
  231. }
  232.  
  233. void turnIntoCustomSpring(jjOBJ@ obj, uint color, float power, bool horizontal) {
  234.         if (horizontal) {
  235.                 obj.xSpeed = power;
  236.                 obj.ySpeed = 0.f;
  237.         } else {
  238.                 obj.xSpeed = 0.f;
  239.                 obj.ySpeed = -power;
  240.                 if (obj.state == STATE::START && obj.creatorType == CREATOR::LEVEL) {
  241.                         int x = int(obj.xPos) >> 5;
  242.                         int y = int(obj.yPos) >> 5;
  243.                         if (jjParameterGet(x, y, 0, 1) != 0) {
  244.                                 jjParameterSet(x, y, 0, 1, 0);
  245.                                 obj.yPos -= 4.f;
  246.                                 obj.ySpeed = power;
  247.                         }
  248.                 }
  249.         }
  250.         obj.behavior = initializeCustomSpring;
  251.         obj.curAnim = customSpringSprite + color * 3 + (horizontal ? 1 : 0);
  252.         obj.energy = obj.frameID = obj.freeze = obj.justHit = obj.light = obj.points = 0;
  253.         obj.causesRicochet = obj.isTarget = obj.scriptedCollisions = obj.triggersTNT = false;
  254.         obj.isBlastable = false;
  255.         obj.deactivates = true;
  256.         obj.isFreezable = true;
  257.         obj.bulletHandling = HANDLING::IGNOREBULLET;
  258.         obj.playerHandling = HANDLING::SPECIAL;
  259.         obj.lightType = LIGHT::NORMAL;
  260.         obj.determineCurFrame();
  261. }
  262.