Downloads containing PipeDreamExample.j2as

Downloads
Name Author Game Mode Rating
JJ2+ Only: Pipe DreamFeatured Download Obi1mcd Tileset 8.8 Download file

File preview

  1. //Yeah I'm just going to apologise in advance for the likely scenario of this not being ideal angelscript
  2. //Deadlines and such.
  3.  
  4. jjPAL initialPalette;
  5.  
  6. float liquidPoolGlowProgress = 0;
  7. float rocksGlowProgress = 0;
  8. float crystalGlowProgress = 0;
  9. float cloudGlowProgress = 0;
  10.  
  11. int liquidPoolRippleProgress = 0;
  12. int crystalRippleProgress = 0;
  13. int cloudRippleProgress = 0;
  14.  
  15. bool liquidGlowing = true;
  16. bool rocksGlowing = true;
  17. bool crystalGlowing = true;
  18. bool cloudGlowing = true;
  19.  
  20. void onLevelLoad() {
  21.        
  22.         //Store the initial palette for the stage
  23.         //Could use jjBackupPalette for this one but if you change the palette beforehand then you'd want this I assume
  24.         initialPalette = jjPalette;
  25.        
  26.         //Set the water gradient to the default values
  27.         jjSetWaterGradient();
  28.        
  29.         jjSetWaterLevel(2464, true);
  30.        
  31.         jjWaterLayer = 3;
  32.        
  33. }
  34.  
  35. void onMain() {
  36.        
  37.         //Every other tick cycle the liquid section of the palette
  38.         //There is probably a far better way to do timing but I sort of ran out of time before the contest deadline.
  39.         if (jjGameTicks % 2 == 1) {
  40.                
  41.                 cycleLiquid();
  42.                
  43.         }
  44.        
  45.         if (jjGameTicks % 8 == 1) {
  46.        
  47.                 liquidPoolGlow();
  48.         }
  49.        
  50.         if (jjGameTicks % 4 == 1) {
  51.        
  52.         crystalGlow();
  53.         }
  54.        
  55.         //Rock glowing disabled because it looks bad
  56.         /*
  57.         if (jjGameTicks % 2 == 1) {
  58.        
  59.         rocksGlow();
  60.         }
  61.         */
  62.        
  63.         if (jjGameTicks % 4 == 1) {
  64.        
  65.         liquidPoolRipple();
  66.         }
  67.  
  68.         if (jjGameTicks % 4 == 1) {
  69.        
  70.         crystalRipple();
  71.         }
  72.  
  73.         if (jjGameTicks % 4 == 1) {
  74.        
  75.         cloudsGlow();
  76.         }
  77.        
  78.         //Trigger crates tied to water level
  79.         if (jjTriggers[1] && jjWaterLevel > 1952) {
  80.                 jjSetWaterLevel(1952, false);
  81.         }
  82.        
  83.         if (jjTriggers[2] && jjWaterLevel > 960) {
  84.         jjSetWaterLevel(960, false);
  85.         }
  86.  
  87. }
  88.  
  89. void cycleLiquid() {
  90.        
  91.         //Make a temporary palette
  92.         jjPAL newPal = jjPalette;
  93.        
  94.         //The liquid colours range from 208-223. See PipeDreamREADME.txt for all the palette stuff
  95.        
  96.         //Grab the last 15 colours from the main palette and shift them one spot to the left in the new one
  97.         newPal.copyFrom(208, 15, 209, jjPalette, 1.0);
  98.        
  99.         //Then grab the first colour from the old palette and put it in the last spot
  100.         newPal.copyFrom(223, 1, 208, jjPalette, 1.0);
  101.        
  102.         newPal.apply();
  103.        
  104. }
  105.  
  106. void liquidPoolGlow() {
  107.  
  108.         //Make a temporary palette
  109.         jjPAL newPal = jjPalette;
  110.        
  111.         //Random number; very arbitrary, used for opacity, should be less than 1. Higher it is the faster the glow is
  112.         float random = ((jjRandom()%3) + 1)/ 20.0;
  113.        
  114.         //If we're going from default colours to bright
  115.         if (liquidGlowing) {
  116.                
  117.                 //Apply the brightened colour at a random rate
  118.                 newPal.gradient(245, 135, 245, 77, 13, 77, 128, 8, random);
  119.  
  120.                 liquidPoolGlowProgress += random;
  121.  
  122.                 if (liquidPoolGlowProgress >= 1) {
  123.                
  124.                         liquidGlowing = false;
  125.                         liquidPoolGlowProgress = 0;
  126.                 }
  127.                
  128.                 newPal.apply();
  129.         }
  130.         else {
  131.  
  132.                 //Copy the default colours for the set back at a random opacity
  133.                 newPal.copyFrom(128, 8, 128, initialPalette, random);
  134.  
  135.                 liquidPoolGlowProgress += random;
  136.  
  137.                 if (liquidPoolGlowProgress >= 1) {
  138.                
  139.                         liquidGlowing = true;
  140.                         liquidPoolGlowProgress = 0;
  141.                 }
  142.                
  143.                 newPal.apply();
  144.         }
  145. }
  146.  
  147. void crystalGlow() {
  148.        
  149.         //Make a temporary palette
  150.         jjPAL newPal = jjPalette;
  151.        
  152.         //Random number; very arbitrary, used for opacity, should be less than 1. Higher it is the faster the glow is
  153.         float random = ((jjRandom()%3) + 1)/ 20.0;
  154.        
  155.         //If we're going from default colours to bright
  156.         if (crystalGlowing) {
  157.                
  158.                 //Apply the brightened colour at a random rate
  159.                 newPal.gradient(0, 255, 19, 0, 130, 19, 104, 8, random);
  160.  
  161.                 crystalGlowProgress += random;
  162.  
  163.                 if (crystalGlowProgress >= 1) {
  164.                
  165.                         crystalGlowing = false;
  166.                         crystalGlowProgress = 0;
  167.                 }
  168.                
  169.                 newPal.apply();
  170.         }
  171.         else {
  172.  
  173.                 //Copy the default colours for the set back at a random opacity
  174.                 newPal.copyFrom(104, 8, 104, initialPalette, random);
  175.  
  176.                 crystalGlowProgress += random;
  177.  
  178.                 if (crystalGlowProgress >= 1) {
  179.                
  180.                         crystalGlowing = true;
  181.                         crystalGlowProgress = 0;
  182.                 }
  183.                
  184.                 newPal.apply();
  185.         }
  186. }
  187.  
  188. void rocksGlow() {
  189.        
  190.         //If you uncomment this the rocks will glow, but it looks kind of terrible to have absolutely everything glowing
  191.         /*
  192.         //Make a temporary palette
  193.         jjPAL newPal = jjPalette;
  194.        
  195.         //Random number; very arbitrary, used for opacity, should be less than 1. Higher it is the faster the glow is
  196.         float random = ((jjRandom()%3) + 1)/ 20.0;
  197.        
  198.         //If we're going from default colours to bright
  199.         if (rocksGlowing) {
  200.                
  201.                 //Apply the brightened colour at a random rate
  202.                 newPal.gradient(52, 202, 45, 86, 38, 86, 136, 8, random);
  203.  
  204.                 rocksGlowProgress += random;
  205.  
  206.                 if (rocksGlowProgress >= 1) {
  207.                
  208.                         rocksGlowing = false;
  209.                         rocksGlowProgress = 0;
  210.                 }
  211.                
  212.                 newPal.apply();
  213.         }
  214.         else {
  215.  
  216.                 //Copy the default colours for the set back at a random opacity
  217.                 newPal.copyFrom(136, 8, 136, initialPalette, random);
  218.  
  219.                 rocksGlowProgress += random;
  220.  
  221.                 if (rocksGlowProgress >= 1) {
  222.                
  223.                         rocksGlowing = true;
  224.                         rocksGlowProgress = 0;
  225.                 }
  226.                
  227.                 newPal.apply();
  228.         }
  229.         */
  230. }
  231.  
  232. void cloudsGlow() {
  233.        
  234.         //Make a temporary palette
  235.         jjPAL newPal = jjPalette;
  236.        
  237.         //Random number; very arbitrary, used for opacity, should be less than 1. Higher it is the faster the glow is
  238.         float random = ((jjRandom()%3) + 1)/ 30.0;
  239.        
  240.         //If we're going from default colours to bright
  241.         if (cloudGlowing) {
  242.                
  243.                 //Apply the brightened colour at a random rate
  244.                 newPal.gradient(238, 70, 238, 30, 4, 30, 176, 32, random);
  245.  
  246.                 cloudGlowProgress += random;
  247.  
  248.                 if (cloudGlowProgress >= 1) {
  249.                
  250.                         cloudGlowing = false;
  251.                         cloudGlowProgress = 0;
  252.                 }
  253.                
  254.                 newPal.apply();
  255.         }
  256.         else {
  257.  
  258.                 //Copy the default colours for the set back at a random opacity
  259.                 newPal.copyFrom(176, 32, 176, initialPalette, random);
  260.  
  261.                 cloudGlowProgress += random;
  262.  
  263.                 if (cloudGlowProgress >= 1) {
  264.                
  265.                         cloudGlowing = true;
  266.                         cloudGlowProgress = 0;
  267.                 }
  268.                
  269.                 newPal.apply();
  270.         }
  271. }
  272.  
  273. void liquidPoolRipple() {
  274.        
  275.         //Make a temporary palette
  276.         jjPAL newPal = jjPalette;
  277.        
  278.         if (liquidPoolRippleProgress == 0) {
  279.        
  280.                 //Random number, chance of a ripple effect starting per tick
  281.                 int random = (jjRandom()%100);
  282.                
  283.                 if (random == 1) {
  284.                
  285.                         newPal.copyFrom(128, 6, 128, initialPalette, 1.0);
  286.  
  287.                         newPal.fill(255, 255, 255, 128 + liquidPoolRippleProgress, 1, 0.25);
  288.                        
  289.                         liquidPoolRippleProgress++;
  290.                        
  291.                         newPal.apply();
  292.                 }
  293.         }
  294.         else {
  295.        
  296.                 newPal.copyFrom(128, 6, 128, initialPalette, 1.0);
  297.  
  298.                 newPal.fill(255, 255, 255, 128 + liquidPoolRippleProgress, 1, 0.25);
  299.                
  300.                 liquidPoolRippleProgress++;
  301.                
  302.                 if (liquidPoolRippleProgress >= 6) {
  303.                
  304.                         liquidPoolRippleProgress = 0;
  305.                        
  306.                         newPal.copyFrom(128, 6, 128, initialPalette, 1.0);
  307.                
  308.                 }
  309.                
  310.                 newPal.apply();
  311.                
  312.         }
  313. }
  314.  
  315. void crystalRipple() {
  316.         //Make a temporary palette
  317.         jjPAL newPal = jjPalette;
  318.        
  319.         if (crystalRippleProgress == 0) {
  320.        
  321.                 //Random number, chance of a ripple effect starting per tick
  322.                 int random = (jjRandom()%50);
  323.                
  324.                 if (random == 1) {
  325.                
  326.                         newPal.copyFrom(105, 6, 105, initialPalette, 1.0);
  327.  
  328.                         newPal.fill(255, 255, 255, 105 + crystalRippleProgress, 1, 0.25);
  329.                        
  330.                         crystalRippleProgress++;
  331.                        
  332.                         newPal.apply();
  333.                 }
  334.         }
  335.         else {
  336.        
  337.                 newPal.copyFrom(105, 6, 105, initialPalette, 1.0);
  338.  
  339.                 newPal.fill(255, 255, 255, 105 + crystalRippleProgress, 1, 0.25);
  340.                
  341.                 crystalRippleProgress++;
  342.                
  343.                 if (crystalRippleProgress >= 6) {
  344.                
  345.                         crystalRippleProgress = 0;
  346.                        
  347.                         newPal.copyFrom(105, 6, 105, initialPalette, 1.0);
  348.                
  349.                 }
  350.                
  351.                 newPal.apply();
  352.                
  353.         }
  354. }
  355.