API tools faq
paste
Advertisement
SpoOkyMagician

messy but works

SpoOkyMagician
Nov 28th, 2017
80
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Lua 12.54 KB | None | 0 0
raw download clone embed print report
  1. function red_star()
  2.     return LoadActor("red_star")..{
  3.         OnCommand=function(self)
  4.             self:diffusealpha(1);
  5.             local ran_x = math.random(-16, 16);
  6.             local ran_y = math.random(-16, 16);
  7.             local varient = math.random(-1, 1);
  8.             self:Center();
  9.             self:sleep(0.01);
  10.             ran_x = (ran_x * 1) + varient;
  11.             ran_y = (ran_y * 1) + 0.1;
  12.             self:addx(ran_x);
  13.             self:addy(ran_y);
  14.             self:diffusealpha(0.9);
  15.             self:sleep(0.02);
  16.             ran_x = (ran_x * 0.9) + varient;
  17.             ran_y = (ran_y * 0.9) + 0.2;
  18.             self:addx(ran_x);
  19.             self:addy(ran_y);
  20.             self:diffusealpha(0.8);
  21.             self:sleep(0.03);
  22.             ran_x = (ran_x * 0.8) + varient;
  23.             ran_y = (ran_y * 0.8) + 0.3;
  24.             self:addx(ran_x);
  25.             self:addy(ran_y);
  26.             self:diffusealpha(0.7);
  27.             self:sleep(0.04);
  28.             ran_x = (ran_x * 0.7) + varient;
  29.             ran_y = (ran_y * 0.7) + 0.4;
  30.             self:addx(ran_x);
  31.             self:addy(ran_y);
  32.             self:diffusealpha(0.6);
  33.             self:sleep(0.05);
  34.             ran_x = (ran_x * 0.6) + varient;
  35.             ran_y = (ran_y * 0.6) + 0.5;
  36.             self:addx(ran_x);
  37.             self:addy(ran_y);
  38.             self:diffusealpha(0.5);
  39.             self:sleep(0.06);
  40.             ran_x = (ran_x * 0.5) + varient;
  41.             ran_y = (ran_y * 0.5) + 0.6;
  42.             self:addx(ran_x);
  43.             self:addy(ran_y);
  44.             self:diffusealpha(0.4);
  45.             self:sleep(0.07);
  46.             ran_x = (ran_x * 0.4) + varient;
  47.             ran_y = (ran_y * 0.4) + 0.7;
  48.             self:addx(ran_x);
  49.             self:addy(ran_y);
  50.             self:diffusealpha(0.3);
  51.             self:sleep(0.08);
  52.             ran_x = (ran_x * 0.3) + varient;
  53.             ran_y = (ran_y * 0.3) + 0.8;
  54.             self:addx(ran_x);
  55.             self:addy(ran_y);
  56.             self:diffusealpha(0.2);
  57.             self:sleep(0.09);
  58.             ran_x = (ran_x * 0.2) + varient;
  59.             ran_y = (ran_y * 0.2) + 0.9;
  60.             self:addx(ran_x);
  61.             self:addy(ran_y);
  62.             self:diffusealpha(0.1);
  63.             self:sleep(0.1);
  64.             ran_x = (ran_x * 0.1) + varient;
  65.             ran_y = (ran_y * 0.1) + 1;
  66.             self:addx(ran_x);
  67.             self:addy(ran_y);
  68.             self:diffusealpha(0);
  69.         end;
  70.     }
  71. end;
  72.  
  73. function green_star()
  74.     return LoadActor("green_star")..{
  75.         OnCommand=function(self)
  76.             self:diffusealpha(1);
  77.             local ran_x = math.random(-16, 16);
  78.             local ran_y = math.random(-16, 16);
  79.             local varient = math.random(-1, 1);
  80.             self:Center();
  81.             self:sleep(0.01);
  82.             ran_x = (ran_x * 1) + varient;
  83.             ran_y = (ran_y * 1) + 0.1;
  84.             self:addx(ran_x);
  85.             self:addy(ran_y);
  86.             self:diffusealpha(0.9);
  87.             self:sleep(0.02);
  88.             ran_x = (ran_x * 0.9) + varient;
  89.             ran_y = (ran_y * 0.9) + 0.2;
  90.             self:addx(ran_x);
  91.             self:addy(ran_y);
  92.             self:diffusealpha(0.8);
  93.             self:sleep(0.03);
  94.             ran_x = (ran_x * 0.8) + varient;
  95.             ran_y = (ran_y * 0.8) + 0.3;
  96.             self:addx(ran_x);
  97.             self:addy(ran_y);
  98.             self:diffusealpha(0.7);
  99.             self:sleep(0.04);
  100.             ran_x = (ran_x * 0.7) + varient;
  101.             ran_y = (ran_y * 0.7) + 0.4;
  102.             self:addx(ran_x);
  103.             self:addy(ran_y);
  104.             self:diffusealpha(0.6);
  105.             self:sleep(0.05);
  106.             ran_x = (ran_x * 0.6) + varient;
  107.             ran_y = (ran_y * 0.6) + 0.5;
  108.             self:addx(ran_x);
  109.             self:addy(ran_y);
  110.             self:diffusealpha(0.5);
  111.             self:sleep(0.06);
  112.             ran_x = (ran_x * 0.5) + varient;
  113.             ran_y = (ran_y * 0.5) + 0.6;
  114.             self:addx(ran_x);
  115.             self:addy(ran_y);
  116.             self:diffusealpha(0.4);
  117.             self:sleep(0.07);
  118.             ran_x = (ran_x * 0.4) + varient;
  119.             ran_y = (ran_y * 0.4) + 0.7;
  120.             self:addx(ran_x);
  121.             self:addy(ran_y);
  122.             self:diffusealpha(0.3);
  123.             self:sleep(0.08);
  124.             ran_x = (ran_x * 0.3) + varient;
  125.             ran_y = (ran_y * 0.3) + 0.8;
  126.             self:addx(ran_x);
  127.             self:addy(ran_y);
  128.             self:diffusealpha(0.2);
  129.             self:sleep(0.09);
  130.             ran_x = (ran_x * 0.2) + varient;
  131.             ran_y = (ran_y * 0.2) + 0.9;
  132.             self:addx(ran_x);
  133.             self:addy(ran_y);
  134.             self:diffusealpha(0.1);
  135.             self:sleep(0.1);
  136.             ran_x = (ran_x * 0.1) + varient;
  137.             ran_y = (ran_y * 0.1) + 1;
  138.             self:addx(ran_x);
  139.             self:addy(ran_y);
  140.             self:diffusealpha(0);
  141.         end;
  142.     }
  143. end;
  144.  
  145. function blue_star()
  146.     return LoadActor("blue_star")..{
  147.         OnCommand=function(self)
  148.             self:diffusealpha(1);
  149.             local ran_x = math.random(-16, 16);
  150.             local ran_y = math.random(-16, 16);
  151.             local varient = math.random(-1, 1);
  152.             self:Center();
  153.             self:sleep(0.01);
  154.             ran_x = (ran_x * 1) + varient;
  155.             ran_y = (ran_y * 1) + 0.1;
  156.             self:addx(ran_x);
  157.             self:addy(ran_y);
  158.             self:diffusealpha(0.9);
  159.             self:sleep(0.02);
  160.             ran_x = (ran_x * 0.9) + varient;
  161.             ran_y = (ran_y * 0.9) + 0.2;
  162.             self:addx(ran_x);
  163.             self:addy(ran_y);
  164.             self:diffusealpha(0.8);
  165.             self:sleep(0.03);
  166.             ran_x = (ran_x * 0.8) + varient;
  167.             ran_y = (ran_y * 0.8) + 0.3;
  168.             self:addx(ran_x);
  169.             self:addy(ran_y);
  170.             self:diffusealpha(0.7);
  171.             self:sleep(0.04);
  172.             ran_x = (ran_x * 0.7) + varient;
  173.             ran_y = (ran_y * 0.7) + 0.4;
  174.             self:addx(ran_x);
  175.             self:addy(ran_y);
  176.             self:diffusealpha(0.6);
  177.             self:sleep(0.05);
  178.             ran_x = (ran_x * 0.6) + varient;
  179.             ran_y = (ran_y * 0.6) + 0.5;
  180.             self:addx(ran_x);
  181.             self:addy(ran_y);
  182.             self:diffusealpha(0.5);
  183.             self:sleep(0.06);
  184.             ran_x = (ran_x * 0.5) + varient;
  185.             ran_y = (ran_y * 0.5) + 0.6;
  186.             self:addx(ran_x);
  187.             self:addy(ran_y);
  188.             self:diffusealpha(0.4);
  189.             self:sleep(0.07);
  190.             ran_x = (ran_x * 0.4) + varient;
  191.             ran_y = (ran_y * 0.4) + 0.7;
  192.             self:addx(ran_x);
  193.             self:addy(ran_y);
  194.             self:diffusealpha(0.3);
  195.             self:sleep(0.08);
  196.             ran_x = (ran_x * 0.3) + varient;
  197.             ran_y = (ran_y * 0.3) + 0.8;
  198.             self:addx(ran_x);
  199.             self:addy(ran_y);
  200.             self:diffusealpha(0.2);
  201.             self:sleep(0.09);
  202.             ran_x = (ran_x * 0.2) + varient;
  203.             ran_y = (ran_y * 0.2) + 0.9;
  204.             self:addx(ran_x);
  205.             self:addy(ran_y);
  206.             self:diffusealpha(0.1);
  207.             self:sleep(0.1);
  208.             ran_x = (ran_x * 0.1) + varient;
  209.             ran_y = (ran_y * 0.1) + 1;
  210.             self:addx(ran_x);
  211.             self:addy(ran_y);
  212.             self:diffusealpha(0);
  213.         end;
  214.     }
  215. end;
  216.  
  217. function gold_star()
  218.     return LoadActor("gold_star")..{
  219.         OnCommand=function(self)
  220.             self:diffusealpha(1);
  221.             local ran_x = math.random(-16, 16);
  222.             local ran_y = math.random(-16, 16);
  223.             local varient = math.random(-1, 1);
  224.             self:Center();
  225.             self:sleep(0.01);
  226.             ran_x = (ran_x * 1) + varient;
  227.             ran_y = (ran_y * 1) + 0.1;
  228.             self:addx(ran_x);
  229.             self:addy(ran_y);
  230.             self:diffusealpha(0.9);
  231.             self:sleep(0.02);
  232.             ran_x = (ran_x * 0.9) + varient;
  233.             ran_y = (ran_y * 0.9) + 0.2;
  234.             self:addx(ran_x);
  235.             self:addy(ran_y);
  236.             self:diffusealpha(0.8);
  237.             self:sleep(0.03);
  238.             ran_x = (ran_x * 0.8) + varient;
  239.             ran_y = (ran_y * 0.8) + 0.3;
  240.             self:addx(ran_x);
  241.             self:addy(ran_y);
  242.             self:diffusealpha(0.7);
  243.             self:sleep(0.04);
  244.             ran_x = (ran_x * 0.7) + varient;
  245.             ran_y = (ran_y * 0.7) + 0.4;
  246.             self:addx(ran_x);
  247.             self:addy(ran_y);
  248.             self:diffusealpha(0.6);
  249.             self:sleep(0.05);
  250.             ran_x = (ran_x * 0.6) + varient;
  251.             ran_y = (ran_y * 0.6) + 0.5;
  252.             self:addx(ran_x);
  253.             self:addy(ran_y);
  254.             self:diffusealpha(0.5);
  255.             self:sleep(0.06);
  256.             ran_x = (ran_x * 0.5) + varient;
  257.             ran_y = (ran_y * 0.5) + 0.6;
  258.             self:addx(ran_x);
  259.             self:addy(ran_y);
  260.             self:diffusealpha(0.4);
  261.             self:sleep(0.07);
  262.             ran_x = (ran_x * 0.4) + varient;
  263.             ran_y = (ran_y * 0.4) + 0.7;
  264.             self:addx(ran_x);
  265.             self:addy(ran_y);
  266.             self:diffusealpha(0.3);
  267.             self:sleep(0.08);
  268.             ran_x = (ran_x * 0.3) + varient;
  269.             ran_y = (ran_y * 0.3) + 0.8;
  270.             self:addx(ran_x);
  271.             self:addy(ran_y);
  272.             self:diffusealpha(0.2);
  273.             self:sleep(0.09);
  274.             ran_x = (ran_x * 0.2) + varient;
  275.             ran_y = (ran_y * 0.2) + 0.9;
  276.             self:addx(ran_x);
  277.             self:addy(ran_y);
  278.             self:diffusealpha(0.1);
  279.             self:sleep(0.1);
  280.             ran_x = (ran_x * 0.1) + varient;
  281.             ran_y = (ran_y * 0.1) + 1;
  282.             self:addx(ran_x);
  283.             self:addy(ran_y);
  284.             self:diffusealpha(0);
  285.         end;
  286.     }
  287. end;
  288.  
  289. function silver_star()
  290.     return LoadActor("silver_star")..{
  291.         OnCommand=function(self)
  292.             self:diffusealpha(1);
  293.             local ran_x = math.random(-16, 16);
  294.             local ran_y = math.random(-16, 16);
  295.             local varient = math.random(-1, 1);
  296.             self:Center();
  297.             self:sleep(0.01);
  298.             ran_x = (ran_x * 1) + varient;
  299.             ran_y = (ran_y * 1) + 0.1;
  300.             self:addx(ran_x);
  301.             self:addy(ran_y);
  302.             self:diffusealpha(0.9);
  303.             self:sleep(0.02);
  304.             ran_x = (ran_x * 0.9) + varient;
  305.             ran_y = (ran_y * 0.9) + 0.2;
  306.             self:addx(ran_x);
  307.             self:addy(ran_y);
  308.             self:diffusealpha(0.8);
  309.             self:sleep(0.03);
  310.             ran_x = (ran_x * 0.8) + varient;
  311.             ran_y = (ran_y * 0.8) + 0.3;
  312.             self:addx(ran_x);
  313.             self:addy(ran_y);
  314.             self:diffusealpha(0.7);
  315.             self:sleep(0.04);
  316.             ran_x = (ran_x * 0.7) + varient;
  317.             ran_y = (ran_y * 0.7) + 0.4;
  318.             self:addx(ran_x);
  319.             self:addy(ran_y);
  320.             self:diffusealpha(0.6);
  321.             self:sleep(0.05);
  322.             ran_x = (ran_x * 0.6) + varient;
  323.             ran_y = (ran_y * 0.6) + 0.5;
  324.             self:addx(ran_x);
  325.             self:addy(ran_y);
  326.             self:diffusealpha(0.5);
  327.             self:sleep(0.06);
  328.             ran_x = (ran_x * 0.5) + varient;
  329.             ran_y = (ran_y * 0.5) + 0.6;
  330.             self:addx(ran_x);
  331.             self:addy(ran_y);
  332.             self:diffusealpha(0.4);
  333.             self:sleep(0.07);
  334.             ran_x = (ran_x * 0.4) + varient;
  335.             ran_y = (ran_y * 0.4) + 0.7;
  336.             self:addx(ran_x);
  337.             self:addy(ran_y);
  338.             self:diffusealpha(0.3);
  339.             self:sleep(0.08);
  340.             ran_x = (ran_x * 0.3) + varient;
  341.             ran_y = (ran_y * 0.3) + 0.8;
  342.             self:addx(ran_x);
  343.             self:addy(ran_y);
  344.             self:diffusealpha(0.2);
  345.             self:sleep(0.09);
  346.             ran_x = (ran_x * 0.2) + varient;
  347.             ran_y = (ran_y * 0.2) + 0.9;
  348.             self:addx(ran_x);
  349.             self:addy(ran_y);
  350.             self:diffusealpha(0.1);
  351.             self:sleep(0.1);
  352.             ran_x = (ran_x * 0.1) + varient;
  353.             ran_y = (ran_y * 0.1) + 1;
  354.             self:addx(ran_x);
  355.             self:addy(ran_y);
  356.             self:diffusealpha(0);
  357.         end;
  358.     }
  359. end;
  360.  
  361. function yellow_star()
  362.     return LoadActor("yellow_star")..{
  363.         OnCommand=function(self)
  364.             self:diffusealpha(1);
  365.             local ran_x = math.random(-16, 16);
  366.             local ran_y = math.random(-16, 16);
  367.             local varient = math.random(-1, 1);
  368.             self:Center();
  369.             self:sleep(0.01);
  370.             ran_x = (ran_x * 1) + varient;
  371.             ran_y = (ran_y * 1) + 0.1;
  372.             self:addx(ran_x);
  373.             self:addy(ran_y);
  374.             self:diffusealpha(0.9);
  375.             self:sleep(0.02);
  376.             ran_x = (ran_x * 0.9) + varient;
  377.             ran_y = (ran_y * 0.9) + 0.2;
  378.             self:addx(ran_x);
  379.             self:addy(ran_y);
  380.             self:diffusealpha(0.8);
  381.             self:sleep(0.03);
  382.             ran_x = (ran_x * 0.8) + varient;
  383.             ran_y = (ran_y * 0.8) + 0.3;
  384.             self:addx(ran_x);
  385.             self:addy(ran_y);
  386.             self:diffusealpha(0.7);
  387.             self:sleep(0.04);
  388.             ran_x = (ran_x * 0.7) + varient;
  389.             ran_y = (ran_y * 0.7) + 0.4;
  390.             self:addx(ran_x);
  391.             self:addy(ran_y);
  392.             self:diffusealpha(0.6);
  393.             self:sleep(0.05);
  394.             ran_x = (ran_x * 0.6) + varient;
  395.             ran_y = (ran_y * 0.6) + 0.5;
  396.             self:addx(ran_x);
  397.             self:addy(ran_y);
  398.             self:diffusealpha(0.5);
  399.             self:sleep(0.06);
  400.             ran_x = (ran_x * 0.5) + varient;
  401.             ran_y = (ran_y * 0.5) + 0.6;
  402.             self:addx(ran_x);
  403.             self:addy(ran_y);
  404.             self:diffusealpha(0.4);
  405.             self:sleep(0.07);
  406.             ran_x = (ran_x * 0.4) + varient;
  407.             ran_y = (ran_y * 0.4) + 0.7;
  408.             self:addx(ran_x);
  409.             self:addy(ran_y);
  410.             self:diffusealpha(0.3);
  411.             self:sleep(0.08);
  412.             ran_x = (ran_x * 0.3) + varient;
  413.             ran_y = (ran_y * 0.3) + 0.8;
  414.             self:addx(ran_x);
  415.             self:addy(ran_y);
  416.             self:diffusealpha(0.2);
  417.             self:sleep(0.09);
  418.             ran_x = (ran_x * 0.2) + varient;
  419.             ran_y = (ran_y * 0.2) + 0.9;
  420.             self:addx(ran_x);
  421.             self:addy(ran_y);
  422.             self:diffusealpha(0.1);
  423.             self:sleep(0.1);
  424.             ran_x = (ran_x * 0.1) + varient;
  425.             ran_y = (ran_y * 0.1) + 1;
  426.             self:addx(ran_x);
  427.             self:addy(ran_y);
  428.             self:diffusealpha(0);
  429.         end;
  430.     }
  431. end;
  432.  
  433. local t = Def.ActorFrame{
  434.     red_star(),
  435.     red_star(),
  436.     red_star(),
  437.     red_star(),
  438.     red_star(),
  439.     red_star(),
  440.     red_star(),
  441.     red_star(),
  442.     red_star(),
  443.     red_star(),
  444.     red_star(),
  445.     red_star(),
  446.     red_star(),
  447.     red_star(),
  448.     red_star(),
  449.     red_star(),
  450.     red_star(),
  451.     red_star(),
  452.     red_star(),
  453.     red_star(),
  454.     green_star(),
  455.     green_star(),
  456.     green_star(),
  457.     green_star(),
  458.     green_star(),
  459.     green_star(),
  460.     green_star(),
  461.     green_star(),
  462.     green_star(),
  463.     green_star(),
  464.     green_star(),
  465.     green_star(),
  466.     green_star(),
  467.     green_star(),
  468.     green_star(),
  469.     green_star(),
  470.     green_star(),
  471.     green_star(),
  472.     green_star(),
  473.     green_star(),
  474.     blue_star(),
  475.     blue_star(),
  476.     blue_star(),
  477.     blue_star(),
  478.     blue_star(),
  479.     blue_star(),
  480.     blue_star(),
  481.     blue_star(),
  482.     blue_star(),
  483.     blue_star(),
  484.     blue_star(),
  485.     blue_star(),
  486.     blue_star(),
  487.     blue_star(),
  488.     blue_star(),
  489.     blue_star(),
  490.     blue_star(),
  491.     blue_star(),
  492.     blue_star(),
  493.     blue_star(),
  494.     yellow_star(),
  495.     yellow_star(),
  496.     yellow_star(),
  497.     yellow_star(),
  498.     yellow_star(),
  499.     yellow_star(),
  500.     yellow_star(),
  501.     yellow_star(),
  502.     yellow_star(),
  503.     yellow_star(),
  504.     gold_star(),
  505.     gold_star(),
  506.     gold_star(),
  507.     gold_star(),
  508.     gold_star(),
  509.     gold_star(),
  510.     gold_star(),
  511.     gold_star(),
  512.     gold_star(),
  513.     gold_star(),
  514.     silver_star(),
  515.     silver_star(),
  516.     silver_star(),
  517.     silver_star(),
  518.     silver_star(),
  519.     silver_star(),
  520.     silver_star(),
  521.     silver_star(),
  522.     silver_star(),
  523.     silver_star()
  524. };
  525.  
  526. return t;
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!