Downloads containing CandionVex.j2as

Downloads
Name Author Game Mode Rating
JJ2+ Only: CandionVFeatured Download Violet CLM Tileset conversion 9.7 Download file

File preview

  1. const uint16 LollipopTileID = 390;
  2. array<uint16> tilesToTurnIntoSprites = {
  3.         585,625, //pickups
  4.         604,605,606,607,608, //lights
  5.         LollipopTileID
  6. };
  7. class Sprite {
  8.         Sprite(){}
  9.         float x, y;
  10.         uint age;
  11.         uint color;
  12.         Sprite(float xx, float yy, uint a, uint c = 0) {
  13.                 x = xx; y = yy; age = a; color = c;
  14.         }
  15. }
  16. uint firstSingleTileFrameID, firstMultiTileFrameID, firstCandyCaneFrameID;
  17. const uint levelWidth = jjLayerWidth[4];
  18. const uint levelHeight = jjLayerHeight[4];
  19.  
  20. array<Sprite> Lollipops, Spazzes, Jacks, CandyCanes;
  21. array<array<Sprite>> Lights(2);
  22. void onLevelLoad() {
  23.         array<jjLAYER@> layerOrder = {jjLayers[1], jjLayers[2], jjLayers[3], jjLayers[4], jjLayers[5]};
  24.        
  25.         //skip layer 6, it's just there to make vanilla people feel good about themselves
  26.        
  27.         for (uint i = 0; i < 5*2; ++i) {
  28.                 jjLAYER rocksInChocolate(4, 1);
  29.                 rocksInChocolate.tileWidth = true;
  30.                 rocksInChocolate.ySpeed = 0.24 - i * 0.003;
  31.                 rocksInChocolate.xSpeed = 0.7 - i * 0.04;
  32.                 rocksInChocolate.xOffset = jjRandom();
  33.                 rocksInChocolate.yOffset = -666 + int(i*20);
  34.                 rocksInChocolate.generateSettableTileArea();
  35.                 for (uint x = 0; x < 4; ++x)
  36.                         rocksInChocolate.tileSet(x, 0, 680 + 8 - (i & ~1) + (x & 1));
  37.                 layerOrder.insertLast(@rocksInChocolate);
  38.                
  39.         }
  40.        
  41.         {
  42.                 jjLAYER bigTrees(4, 8), smallTrees(4, 5);
  43.                 bigTrees.tileWidth = smallTrees.tileWidth = true;
  44.                 bigTrees.limitVisibleRegion = smallTrees.limitVisibleRegion = true;
  45.                 bigTrees.yOffset = -180; smallTrees.yOffset = -300;
  46.                 bigTrees.generateSettableTileArea();
  47.                 smallTrees.generateSettableTileArea();
  48.                 for (uint x = 0; x < 4; ++x) {
  49.                         for (int y = 0; y < bigTrees.height; ++y) {
  50.                                 if (y < 3) { if (!(y == 0 && x > 1))
  51.                                         bigTrees.tileSet(x, y, 578 + (x & 1) + (y - x/2) * 10);
  52.                                 } else
  53.                                         bigTrees.tileSet(x, y, 598 + (x & 1));
  54.                         }
  55.                         for (int y = 0; y < smallTrees.height; ++y) {
  56.                                 if (y < 2)
  57.                                         smallTrees.tileSet(x, y, 576 + (x & 1) + (y * 10));
  58.                                 else
  59.                                         smallTrees.tileSet(x, y, 586);
  60.                         }
  61.                 }
  62.                 for (uint i = 0; i < 8; ++i) {
  63.                         jjLAYER trees(i < 5 ? bigTrees : smallTrees);
  64.                         trees.ySpeed = 0.13 - i * 0.02;
  65.                         //if (i >= 3) trees.ySpeed -= 0.02;
  66.                         trees.xSpeed = 0.3 - i * 0.024;
  67.                         trees.xOffset = jjRandom();
  68.                         trees.yOffset += (i < 5) ? int(i*60) : (210 + int(i*30));
  69.                         layerOrder.insertLast(@trees);
  70.                 }
  71.         }
  72.        
  73.         layerOrder.insertLast(jjLayers[7]);
  74.         jjLAYER secondBackgroundMountains(jjLayers[7]);
  75.         secondBackgroundMountains.yOffset = 64;
  76.         secondBackgroundMountains.ySpeed *= 0.85;;
  77.         secondBackgroundMountains.xSpeed *= 0.7;
  78.         layerOrder.insertLast(@secondBackgroundMountains);
  79.        
  80.         layerOrder.insertLast(jjLayers[8]);
  81.         jjLayerOrderSet(layerOrder);
  82.        
  83.         firstSingleTileFrameID = jjAnimations[jjAnimSets[ANIM::CUSTOM[0]].allocate(array<uint> = {tilesToTurnIntoSprites.length, 2, 4})];
  84.         firstMultiTileFrameID = firstSingleTileFrameID + tilesToTurnIntoSprites.length;
  85.         firstCandyCaneFrameID = firstMultiTileFrameID + 2;
  86.         jjANIMFRAME@ frame;
  87.         for (uint i = 0; i < tilesToTurnIntoSprites.length; ++i) {
  88.                 @frame = jjAnimFrames[firstSingleTileFrameID + i];
  89.                 jjPIXELMAP(tilesToTurnIntoSprites[i]).save(frame);
  90.                 frame.hotSpotX = frame.hotSpotY = -16;
  91.         }
  92.        
  93.         jjObjectPresets[OBJECT::CHOCBAR].curFrame = jjAnimations[jjObjectPresets[OBJECT::CHOCBAR].curAnim].firstFrame = firstSingleTileFrameID; //candy cane
  94.         jjObjectPresets[OBJECT::ICECREAM].curFrame = jjAnimations[jjObjectPresets[OBJECT::ICECREAM].curAnim].firstFrame = firstSingleTileFrameID + 1; //ice cream
  95.        
  96.         @frame = jjAnimFrames[firstMultiTileFrameID]; //spaz
  97.         jjPIXELMAP(32, 0, 128,128).save(frame);
  98.         frame.hotSpotX = frame.hotSpotY = 0;
  99.         @frame = jjAnimFrames[firstMultiTileFrameID + 1]; //jackdevan
  100.         jjPIXELMAP(160, 0, 64,96).save(frame);
  101.         frame.hotSpotX = 0; frame.hotSpotY = -64;
  102.        
  103.         for (uint i = 0; i < 4; ++i) {
  104.                 @frame = jjAnimFrames[firstCandyCaneFrameID + i];
  105.                 jjPIXELMAP(7*32, i * 20, 12, 96 - i*20).save(frame);
  106.                 frame.hotSpotX = -6; frame.hotSpotY = 0;
  107.         }
  108.        
  109.        
  110.         for (uint x = 0; x < levelWidth; ++x) {
  111.                 for (uint y = 0; y < levelHeight; ++y) {
  112.                         const uint16 tileID1 = jjTileGet(4, x, y), tileID2 = jjTileGet(5, x, y);
  113.                         if (tileID1 == LollipopTileID || tileID2 == LollipopTileID)
  114.                                 Lollipops.insertLast(Sprite(x * 32 + 16, y * 32 + 16, jjRandom()));
  115.                         else if (tileID1 == 301) //top left of Spaz
  116.                                 Spazzes.insertLast(Sprite((x - 1) * 32, y * 32, 0));
  117.                         else if (tileID1 >= 340 && tileID1 <= 343) //spaz on bricks
  118.                                 jjTileSet(4, x,y, 56);
  119.                         else if (tileID1 >= 395 && tileID1 <= 398) //spaz on ice
  120.                                 jjTileSet(4, x,y, 5);
  121.                         else if (tileID1 == 334 || tileID1 == 335) { //top of box
  122.                                 jjTileSet(4, x,y, tileID1 - 30); //remove spring
  123.                                 if (tileID1 == 334)
  124.                                         Jacks.insertLast(Sprite(x * 32, y * 32, jjRandom()));
  125.                         }
  126.                         if (jjEventGet(x, y) == 255)
  127.                                 CandyCanes.insertLast(Sprite(x * 32 + 16, y * 32 + 16, jjRandom(), 3 - jjParameterGet(x, y, 0, 2)));
  128.                                
  129.                 }
  130.         }
  131.        
  132.         const uint16 firstTreeTileID = 592;
  133.         array<jjPIXELMAP@> foregroundTreeTileImages(679 - firstTreeTileID + 1, null);
  134.         for (uint i = 0; i < 2; ++i) {
  135.                 const jjLAYER@ layer = jjLayers[1 + i];
  136.                 for (int x = layer.width - 1; x >= 0; --x)
  137.                         for (int y = layer.height - 1; y >= 0; --y) {
  138.                                 const uint16 tileID = layer.tileGet(x, y);
  139.                                 if (tileID >= firstTreeTileID) {
  140.                                         const uint16 adjustedTileID = tileID - firstTreeTileID; //to fit it into the image array
  141.                                         if (foregroundTreeTileImages[adjustedTileID] is null)
  142.                                                 @foregroundTreeTileImages[adjustedTileID] = jjPIXELMAP(tileID);
  143.                                         const jjPIXELMAP@ tileImage = foregroundTreeTileImages[adjustedTileID];
  144.                                         uint8 xx, yy;
  145.                                         while (tileImage[xx = jjRandom() & 31, yy = jjRandom() & 31] == 0); //find a non-transparent pixel
  146.                                         Lights[i].insertLast(Sprite(x * 32 + xx, y * 32 + yy, jjRandom(), jjRandom() % 5));
  147.                                 }
  148.                         }
  149.         }
  150. }
  151.  
  152. void onDrawLayer4(jjPLAYER@ play, jjCANVAS@ screen) {
  153.         for (uint i = 0; i < Lollipops.length; ++i) {
  154.                 const Sprite@ sprite = Lollipops[i];
  155.                 screen.drawRotatedSpriteFromCurFrame(int(sprite.x), int(sprite.y), firstSingleTileFrameID + 7, sprite.age - (jjGameTicks << 4));
  156.         }
  157.         for (uint i = 0; i < Spazzes.length; ++i) {
  158.                 const Sprite@ sprite = Spazzes[i];
  159.                 screen.drawSpriteFromCurFrame(int(sprite.x), int(sprite.y), firstMultiTileFrameID, 1, SPRITE::PLAYER, play.playerID);
  160.         }
  161.         for (uint i = 0; i < CandyCanes.length; ++i) {
  162.                 const Sprite@ sprite = CandyCanes[i];
  163.                 screen.drawSwingingVineSpriteFromCurFrame(int(sprite.x), int(sprite.y), firstCandyCaneFrameID + sprite.color, 96 - sprite.color*20, int(jjSin(sprite.age + jjGameTicks * 6) * 0x4000));
  164.         }
  165. }
  166. void onDrawLayer5(jjPLAYER@, jjCANVAS@ screen) {
  167.         for (uint i = 0; i < Jacks.length; ++i) {
  168.                 const Sprite@ sprite = Jacks[i];
  169.                 screen.drawRotatedSpriteFromCurFrame(int(sprite.x), int(sprite.y), firstMultiTileFrameID + 1, int(jjSin(jjGameTicks << 2) * 28));
  170.         }
  171. }
  172. void drawLights(uint id, jjCANVAS@ screen) {
  173.         const array<Sprite>@ lights = @Lights[id];
  174.         for (uint i = 0; i < lights.length; ++i) {
  175.                 const Sprite@ sprite = lights[i];
  176.                 screen.drawSpriteFromCurFrame(int(sprite.x), int(sprite.y), firstSingleTileFrameID + 2 + sprite.color, 1, SPRITE::BRIGHTNESS, 128 + int(jjSin(sprite.age + (jjGameTicks << 3)) * 40));
  177.         }
  178. }
  179. void onDrawLayer1(jjPLAYER@, jjCANVAS@ screen) { drawLights(0, screen); }
  180. void onDrawLayer2(jjPLAYER@, jjCANVAS@ screen) { drawLights(1, screen); }
  181.