API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 24th, 2017
79
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
ActionScript 3 15.39 KB | None | 0 0
raw download clone embed print report
  1. package {
  2.        
  3.     //import the external files you need
  4.     import com.phillippevk.utils.Stretcher;
  5.     import flash.filters.BlurFilter;
  6.     import flash.display.*;
  7.     import flash.geom.*;
  8.     import flash.events.Event;
  9.  
  10.    
  11.     public class CardFlip extends MovieClip{
  12.         //it is recommended that you only edit these two vars
  13.         private var initBlurValue:Number=15; //adjust higher if you want more blur per flip
  14.         private var easingResolve:Number = .2; //controls the default speed of the ease in the last flip (lower=slower)
  15.        
  16.         //no need to touch the private var below this point
  17.        
  18.         //blur private variables
  19.         private var initBlur:Number;
  20.         private var blurX:Number = 0;
  21.         private var blurY:Number = 0;
  22.         private var quality:Number = 3;
  23.        
  24.         //shadow variables
  25.         private var matrix:Matrix;
  26.         private var fillType:String = "linear";
  27.         private var colors:Array = [0x000000, 0x000000];
  28.         private var alphas:Array = [100, 0];
  29.         private var ratios:Array= [30,255];
  30.        
  31.         //values used in positioning card
  32.         private var mcWIDTH:Number;
  33.         private var mcHEIGHT:Number;
  34.    
  35.         //private variables used in building your card instance
  36.         private var easing:Number;
  37.         private var dir:String;
  38.         private var turns:Number;
  39.         private var setAlt:Boolean = true;
  40.  
  41.         private var _mc:MovieClip;
  42.         private var _axis:String;
  43.         private var _seg:Number;
  44.         private var _persp:Number;
  45.         private var _useBlur:Boolean;
  46.         private var _shadLimit:Number;
  47.         private var _useShad:Boolean = true;
  48.         private var _startX:Number;
  49.         private var _startY:Number;
  50.    
  51.         private var front:MovieClip;
  52.         private var back:MovieClip;
  53.         private var shad_mask:MovieClip;
  54.         private var shad_mc:MovieClip;
  55.         private var img1:MovieClip;
  56.         private var img2:MovieClip;
  57.         private var shad_holder:MovieClip;
  58.        
  59.         // FLIP GOALS VARS
  60.         private var currFront:Number;
  61.         private var frontSet:Boolean;
  62.         private var dx_start:Number;
  63.         private var scaleNum:Number;
  64.         private var flipNum:Number;
  65.         private var masterEase:Number;
  66.  
  67.    
  68.         public function CardFlip(front_img:MovieClip, back_img:MovieClip, axis:String, per:Number, seg:Number, blur:Boolean, shad:Number) {
  69.  
  70.         //per is the perspective value of yoru card (0-3),
  71.         //seg is the number of segments you want to youse (0-3) to reduce distortion - higher equals heavier file;
  72.         //blur is true/false;
  73.         //shadow is (0-1) representing the max alpha you want your shadow to have;
  74.             img1 = front_img;
  75.             img2 = back_img;
  76.  
  77.             _mc = new MovieClip();
  78.             addChild(_mc);
  79.  
  80.             _startX = 0;
  81.             _startY = 0;
  82.             _useBlur = blur;
  83.             _shadLimit = shad;
  84.             if (_shadLimit == 0) _useShad = false;
  85.             _persp = per;
  86.             _seg = seg;
  87.             _axis = axis;
  88.  
  89.  
  90.             front = new MovieClip();
  91.             back = new MovieClip();
  92.  
  93.             img1 = new MovieClip();
  94.             img2 = new MovieClip();
  95.  
  96.  
  97.             _mc.addChild(back);
  98.             _mc.addChild(front);
  99.             _mc.addChild(img1);
  100.             _mc.addChild(img2);
  101.  
  102.             _mc.visible=false;
  103.  
  104.             if (_useShad){
  105.                 shad_mask = new MovieClip();
  106.                 shad_mc = new MovieClip();
  107.                 shad_holder = new MovieClip();
  108.             }
  109.  
  110.             loadImage(back_img,back,img2);
  111.             loadImage(front_img,front,img1);
  112.         }
  113.         //this function applies the blur to the current flipped state
  114.         private function blurit(mc:MovieClip):void {
  115.             var filter:BlurFilter = new BlurFilter(blurX, blurY, quality);
  116.             mc.filters = [filter];
  117.         }
  118.        
  119.         private function createShadow():void {
  120.                
  121.                 _mc.addChild(shad_holder);
  122.                 shad_holder.addChild(shad_mc);
  123.                 _mc.addChild(shad_mask);
  124.                
  125.                 shad_holder.mouseEnabled = false;
  126.                 shad_holder.mouseChildren = false;
  127.                 shad_mask.mouseEnabled = false;
  128.                        
  129.                 shad_mc.graphics.beginGradientFill(fillType, colors, alphas, ratios, matrix);
  130.                 shad_mc.graphics.drawRect(0,0,mcWIDTH,mcHEIGHT);
  131.                 shad_mc.graphics.endFill();
  132.                 shad_holder.scaleY = 2;
  133.                
  134.                 /*shad_mask.graphics.beginFill(0xFF0000);
  135.                 shad_mask.graphics.drawRect(0,0,mcWIDTH,mcHEIGHT);
  136.                 shad_mask.graphics.endFill();*/
  137.                    
  138.                 if (_axis=="y-axis"){
  139.                     shad_holder.graphics.moveTo(0, 0);
  140.                 }else if (_axis=="x-axis"){
  141.                     shad_holder.rotation = 90;
  142.                 }
  143.                 shad_holder.mask = shad_mask;
  144.                 shad_mc.alpha = 0;
  145.         }
  146.        
  147.         //center the individual card faces in the card mc and then position the card to the x and y coordinates you specified.
  148.         private function positionCard():void {
  149.            
  150.             _mc.x = _startX;
  151.             _mc.y = _startY;
  152.             front.x -= mcWIDTH/2;
  153.             front.y -= mcHEIGHT/2;
  154.             back.x -= mcWIDTH/2;
  155.             back.y -= mcHEIGHT/2;      
  156.            
  157.             _mc.visible = true;
  158.            
  159.            
  160.             if (_useShad){
  161.                 shad_mc.x -= mcWIDTH/2;
  162.                 shad_mc.y -= mcHEIGHT/2;
  163.                
  164.                 shad_mask.x -= mcWIDTH/2;
  165.                 shad_mask.y -= mcHEIGHT/2;
  166.                
  167.                 matrix = new Matrix();
  168.                 matrix.createGradientBox(mcWIDTH, mcHEIGHT, 0, 0, 0);
  169.                 createShadow();
  170.             }
  171.         }
  172.         //load the clips
  173.         private function loadImage(clip:MovieClip, tar:MovieClip, img:MovieClip):void {
  174.             trace(clip.width);
  175.             trace(clip.height);
  176.             trace("---");
  177.             var bmd:BitmapData = new BitmapData(clip.width, clip.height, true, 0x00000000);
  178.             bmd.draw(clip);
  179.             var bm:Bitmap = new Bitmap(bmd);
  180.             //addChild(bm);
  181.             //bm.x = 200;
  182.             //bm.y = 200;
  183.             img.addChild(bm);
  184.             var d:Stretcher = new Stretcher(tar, img, _seg, _seg);
  185.             d._smoothing = true;
  186.             img.visible = false;
  187.             if (isNaN(mcWIDTH)) {
  188.                 mcWIDTH = img.width;
  189.                 mcHEIGHT = img.height;
  190.             } else {
  191.                 positionCard();
  192.             }
  193.             d.setTransform(0,0,mcWIDTH,0,0,mcHEIGHT,mcWIDTH,mcHEIGHT);
  194.         }
  195.        
  196.         //set the values, return to front
  197.         public function flipToFront(direct:String = "cw", ease:Number = 0):void {
  198.             if (isNaN(ease)){
  199.                 initBlur = ease*initBlurValue;
  200.             }else{
  201.                 initBlur = initBlurValue;
  202.             }
  203.             if (_axis == "y-axis"){
  204.                 blurX = initBlur;
  205.             } else if (_axis == "x-axis"){
  206.                 blurY = initBlur;
  207.             }
  208.             dir = direct;
  209.             if (front.alpha != 1) {
  210.                 flipScript(1, ease);
  211.             }
  212.         }
  213.        
  214.         //set the values, return to back
  215.         public function flipToBack(direct:String = "cw", ease:Number = 0):void {
  216.             if (isNaN(ease)){
  217.                 initBlur = ease*initBlurValue;
  218.             }else{
  219.                 initBlur = initBlurValue;
  220.             }
  221.             if (_axis == "y-axis"){
  222.                 blurX = initBlur;
  223.             } else if (_axis == "x-axis"){
  224.                 blurY = initBlur;
  225.             }
  226.             dir = direct;
  227.             if (front.alpha == 1) {
  228.                 flipScript(1, ease);
  229.             }
  230.         }
  231.         //set the values, start the flip
  232.         public function startFlip(direct:String, turns:Number, ease:Number = 0):void {
  233.             if (isNaN(ease)){
  234.                 initBlur = ease*initBlurValue;
  235.             }else{
  236.                 initBlur = initBlurValue;
  237.             }
  238.             if (_axis == "y-axis"){
  239.                 blurX = initBlur;
  240.             } else if (_axis == "x-axis"){
  241.                 blurY = initBlur;
  242.             }
  243.             dir = direct;
  244.             flipScript(turns, ease);
  245.         }
  246.         //these next two are called during every frame of the flip.
  247.         //they set the values of the images as your card turns.
  248.         private function goals_v1():void {
  249.             if (_axis=="y-axis"){
  250.                 _mc.x0_goal = 0;
  251.                 _mc.x1_goal = mcWIDTH;
  252.                 _mc.x2_goal = mcWIDTH;
  253.                 _mc.x3_goal = 0;
  254.        
  255.                 _mc.x0_pt = mcWIDTH;
  256.                 _mc.x1_pt = 0;
  257.                 _mc.x2_pt = 0;
  258.                 _mc.x3_pt = mcWIDTH;
  259.             } else if (_axis=="x-axis"){
  260.                 _mc.y0_goal = 0;
  261.                 _mc.y1_goal = mcHEIGHT;
  262.                 _mc.y2_goal = mcHEIGHT;
  263.                 _mc.y3_goal = 0;
  264.        
  265.                 _mc.y0_pt = mcHEIGHT;
  266.                 _mc.y1_pt = 0;
  267.                 _mc.y2_pt = 0;
  268.                 _mc.y3_pt = mcHEIGHT;
  269.             }
  270.         }
  271.         private function goals_v2():void {
  272.             if (_axis=="y-axis"){
  273.                 _mc.x0_goal = mcWIDTH;
  274.                 _mc.x1_goal = 0;
  275.                 _mc.x2_goal = 0;
  276.                 _mc.x3_goal = mcWIDTH;
  277.        
  278.                 _mc.x0_pt = 0;
  279.                 _mc.x1_pt = mcWIDTH;
  280.                 _mc.x2_pt = mcWIDTH;
  281.                 _mc.x3_pt = 0;
  282.             } else if (_axis=="x-axis"){
  283.                 _mc.y0_goal = mcHEIGHT;
  284.                 _mc.y1_goal = 0;
  285.                 _mc.y2_goal = 0;
  286.                 _mc.y3_goal = mcHEIGHT;
  287.        
  288.                 _mc.y0_pt = 0;
  289.                 _mc.y1_pt = mcHEIGHT;
  290.                 _mc.y2_pt = mcHEIGHT;
  291.                 _mc.y3_pt = 0;
  292.             }
  293.         }
  294.         //the function that calls the previous functions
  295.         private function setGoals(num:Number):void {
  296.                 if (front.alpha == 0) {
  297.                     goals_v1();
  298.                 } else {
  299.                     goals_v2();
  300.                 }
  301.         }
  302.    
  303.         //set the final ease, the goal (depending on which turn you are on), and call the engine
  304.         private function flipScript(turnsVar:Number, ease:Number):void {
  305.             //set turns
  306.             if (isNaN(turnsVar)){
  307.                 turns = 1;
  308.                 }else{
  309.                     turns = turnsVar;
  310.                 }
  311.             //set ease
  312.             if (turns >= 1){
  313.                 easing = (turns>1) ? .6+(turns/100) : easingResolve;
  314.             }else{
  315.                 easing = easingResolve
  316.             }
  317.             masterEase = easing;
  318.            
  319.             //this is run only once
  320.             if (setAlt) {
  321.                 if (_axis=="y-axis"){
  322.                     _mc.y0_goal = 0;
  323.                     _mc.y1_goal = 0;
  324.                     _mc.y2_goal = mcHEIGHT;
  325.                     _mc.y3_goal = mcHEIGHT;
  326.                     _mc.y0_pt = 0;
  327.                     _mc.y1_pt = 0;
  328.                     _mc.y2_pt = mcHEIGHT;
  329.                     _mc.y3_pt = mcHEIGHT;
  330.                     setAlt = false;
  331.                 }else if (_axis=="x-axis"){
  332.                     _mc.x0_goal = mcWIDTH;
  333.                     _mc.x1_goal = mcWIDTH;
  334.                     _mc.x2_goal = 0;
  335.                     _mc.x3_goal = 0;
  336.                     _mc.x0_pt = mcWIDTH;
  337.                     _mc.x1_pt = mcWIDTH;
  338.                     _mc.x2_pt = 0;
  339.                     _mc.x3_pt = 0;
  340.                     setAlt = false;
  341.                 }
  342.             }
  343.             //set goal
  344.             setGoals(turns);
  345.            
  346.             //call engine
  347.             flipGoals(masterEase);
  348.         }
  349.         //the actual flipping engine
  350.         private function flipGoals(ease:Number):void {
  351.            
  352.             frontSet = true;
  353.             currFront = front.alpha;
  354.             scaleNum = 1;
  355.             flipNum = 0;
  356.            
  357.             if (_useShad){
  358.                 if (_axis=="y-axis"){
  359.                     if (mcWIDTH > mcHEIGHT) scaleNum = mcWIDTH/mcHEIGHT;
  360.                     if (dir=="ccw"){
  361.                         shad_holder.scaleX = scaleNum
  362.                     }else{
  363.                         shad_holder.scaleX= -scaleNum
  364.                     }
  365.                 }
  366.                 if (_axis == "x-axis"){
  367.                     if (mcHEIGHT > mcWIDTH) scaleNum = mcHEIGHT/mcWIDTH;
  368.                     if (dir == "ccw"){
  369.                         shad_holder.scaleX = scaleNum
  370.                     }else{
  371.                         shad_holder.scaleX = -scaleNum
  372.                     }
  373.                 }
  374.             }
  375.             //create and start engine
  376.             _mc.addEventListener(Event.ENTER_FRAME,flipEngine);
  377.         }
  378.                                                                        
  379.         private function flipEngine(e:Event):void{
  380.             //set and use blur                             
  381.             if (_useBlur) {
  382.                 if (turns == 1) {
  383.                     if (_axis=="y-axis"){
  384.                         blurX += (0-blurX)*.1;
  385.                         if (blurX<2) {
  386.                             blurX = 0;
  387.                         }
  388.                     }else if (_axis=="x-axis"){
  389.                         blurY += (0-blurY)*.1;
  390.                         if (blurY<2) {
  391.                             blurY = 0;
  392.                         }
  393.                     }
  394.                 }
  395.                 blurit(_mc);
  396.             }
  397.            
  398.             //set x and y values of your distorted cards
  399.             var i:uint = 0;
  400.             for (i; i<=3; i++) {
  401.                 if (_axis=="y-axis"){
  402.                     _mc["x"+i+"_pt"] += (_mc["x"+i+"_goal"]-_mc["x"+i+"_pt"])*easing;
  403.                    
  404.                     if (dir == "ccw") {
  405.                         if (i<2) {
  406.                             _mc["y"+i+"_pt"] += ((((_mc["x"+i+"_goal"]-_mc["x"+i+"_pt"])*easing)*_persp)+(_mc["y"+i+"_goal"]-_mc["y"+i+"_pt"]))*easing;
  407.                         } else {
  408.                             _mc["y"+i+"_pt"] += ((((_mc["x"+i+"_goal"]-_mc["x"+i+"_pt"])*easing)*-_persp)+(_mc["y"+i+"_goal"]-_mc["y"+i+"_pt"]))*easing;
  409.                         }
  410.                     } else {
  411.                         if (i>1) {
  412.                             _mc["y"+i+"_pt"] += ((((_mc["x"+i+"_goal"]-_mc["x"+i+"_pt"])*easing)*_persp)+(_mc["y"+i+"_goal"]-_mc["y"+i+"_pt"]))*easing;
  413.                         } else {
  414.                             _mc["y"+i+"_pt"] += ((((_mc["x"+i+"_goal"]-_mc["x"+i+"_pt"])*easing)*-_persp)+(_mc["y"+i+"_goal"]-_mc["y"+i+"_pt"]))*easing;
  415.                         }
  416.                     }
  417.                 }else if (_axis=="x-axis"){
  418.                     _mc["y"+i+"_pt"] += (_mc["y"+i+"_goal"]-_mc["y"+i+"_pt"])*easing;
  419.                    
  420.                     if (dir == "ccw") {
  421.                         if (i==2||i==3) {
  422.                             _mc["x"+i+"_pt"] += ((((_mc["y"+i+"_goal"]-_mc["y"+i+"_pt"])*easing)*_persp)+(_mc["x"+i+"_goal"]-_mc["x"+i+"_pt"]))*easing;
  423.                         } else {
  424.                             _mc["x"+i+"_pt"] += ((((_mc["y"+i+"_goal"]-_mc["y"+i+"_pt"])*easing)*-_persp)+(_mc["x"+i+"_goal"]-_mc["x"+i+"_pt"]))*easing;
  425.                         }
  426.                     } else {
  427.                         if (i==2||i==3) {
  428.                             _mc["x"+i+"_pt"] += ((((_mc["y"+i+"_goal"]-_mc["y"+i+"_pt"])*easing)*-_persp)+(_mc["x"+i+"_goal"]-_mc["x"+i+"_pt"]))*easing;
  429.                         } else {
  430.                             _mc["x"+i+"_pt"] += ((((_mc["y"+i+"_goal"]-_mc["y"+i+"_pt"])*easing)*_persp)+(_mc["x"+i+"_goal"]-_mc["x"+i+"_pt"]))*easing;
  431.                         }
  432.                     }
  433.                 }
  434.             }
  435.            
  436.             //create and distort the front and back of the card
  437.             var d:Stretcher = new Stretcher(front, img1, _seg, _seg);
  438.             d._smoothing = true;
  439.             var d_back:Stretcher = new Stretcher(back, img2, _seg, _seg);
  440.             d_back._smoothing = true;
  441.            
  442.             if (_axis=="y-axis"){
  443.                 d.setTransform(_mc.x0_pt,_mc.y0_pt,_mc.x1_pt,_mc.y1_pt,_mc.x3_pt,_mc.y3_pt,_mc.x2_pt,_mc.y2_pt);
  444.                 d_back.setTransform(_mc.x1_pt,_mc.y1_pt,_mc.x0_pt,_mc.y0_pt,_mc.x2_pt,_mc.y2_pt,_mc.x3_pt,_mc.y3_pt);
  445.             }if (_axis=="x-axis"){
  446.                 d.setTransform(_mc.x3_pt,_mc.y3_pt,_mc.x0_pt,_mc.y0_pt,_mc.x2_pt,_mc.y2_pt,_mc.x1_pt,_mc.y1_pt);
  447.                 d_back.setTransform(_mc.x2_pt,_mc.y2_pt,_mc.x1_pt,_mc.y1_pt,_mc.x3_pt,_mc.y3_pt,_mc.x0_pt,_mc.y0_pt);
  448.             }
  449.            
  450.             //if using shadow, create and distort the mask
  451.             if (_useShad){
  452.                 var d_shadow:Stretcher = new Stretcher(shad_mask, img1, 2, 2);
  453.                 d_shadow._smoothing = true;
  454.                 if (_axis=="y-axis"){
  455.                     d_shadow.setTransform(_mc.x0_pt,_mc.y0_pt,_mc.x1_pt,_mc.y1_pt,_mc.x3_pt,_mc.y3_pt,_mc.x2_pt,_mc.y2_pt);
  456.                 }if (_axis=="x-axis"){
  457.                     d_shadow.setTransform(_mc.x3_pt,_mc.y3_pt,_mc.x0_pt,_mc.y0_pt,_mc.x2_pt,_mc.y2_pt,_mc.x1_pt,_mc.y1_pt);
  458.                 }
  459.             }          
  460.            
  461.             //hide or show the front of the card, depending on the turn
  462.             if (_axis=="y-axis"){
  463.                 if (_mc.x1_pt<(mcWIDTH/2)) {
  464.                     front.alpha = 0;           
  465.                 } else {
  466.                     front.alpha = 1;
  467.                 }
  468.             }else if (_axis=="x-axis"){
  469.                 if (_mc.y1_pt>(mcHEIGHT/2)) {
  470.                     front.alpha = 1;           
  471.                 } else {
  472.                     front.alpha = 0;
  473.                 }
  474.             }
  475.            
  476.             //animate shadow
  477.             if (currFront!=front.alpha){
  478.                 if (_useShad){
  479.                     shad_holder.scaleX = shad_holder.scaleX*-1;
  480.                 }
  481.                 currFront=front.alpha;
  482.             }else if (_useShad){
  483.                 flipNum++;
  484.                 var dx:Number;
  485.                 if (_axis=="y-axis"){
  486.                     dx_start=_mc.x0_pt;
  487.                     dx = (Math.sin((Math.round(Math.abs((dx_start-_mc.x1_pt)/mcWIDTH)*360)) * Math.PI/360));
  488.                 }else if (_axis=="x-axis"){
  489.                     dx_start=_mc.x1_pt;
  490.                     dx = (Math.sin((Math.round(Math.abs((dx_start-_mc.x0_pt)/mcHEIGHT)*360)) * Math.PI/360));
  491.                 }
  492.                
  493.                 if (dx>_shadLimit) dx = _shadLimit * ((100 - flipNum)/100);
  494.                 if (dx<.07) dx=0;
  495.                 //trace(dx);
  496.                 shad_mc.alpha = dx;
  497.             }
  498.             var endCalc:Number;
  499.             if (_axis=="y-axis"){
  500.                 endCalc=_mc.x1_pt-_mc.x1_goal
  501.             }else if (_axis=="x-axis"){
  502.                 endCalc=_mc.y1_pt-_mc.y1_goal
  503.             }
  504.             //if finished.. end engine, if there are more turns...call the function again.
  505.             if (Math.abs(endCalc)<.5+(turns-1)) {
  506.                 turns--;
  507.                 if (turns == 0) {
  508.                     i = 0;
  509.                     for (i; i<=3; i++) {
  510.                         if (_axis=="y-axis"){
  511.                             _mc["y"+i+"_pt"] = _mc["y"+i+"_goal"];
  512.                         } else if (_axis=="x-axis"){
  513.                             _mc["x"+i+"_pt"] = _mc["x"+i+"_goal"]
  514.                         }
  515.                     }
  516.                     if (_axis == "y-axis"){
  517.                         blurX = 0;
  518.                         blurit(_mc);
  519.                         d.setTransform(_mc.x0_pt,_mc.y0_pt,_mc.x1_pt,_mc.y1_pt,_mc.x3_pt,_mc.y3_pt,_mc.x2_pt,_mc.y2_pt);
  520.                         d_back.setTransform(_mc.x1_pt,_mc.y1_pt,_mc.x0_pt,_mc.y0_pt,_mc.x2_pt,_mc.y2_pt,_mc.x3_pt,_mc.y3_pt);
  521.                         if (_useShad) d_shadow.setTransform(_mc.x0_goal,_mc.y0_goal,_mc.x1_goal,_mc.y1_goal,_mc.x3_goal,_mc.y3_goal,_mc.x2_goal,_mc.y2_goal);
  522.                     } else if (_axis == "x-axis"){
  523.                         blurY = 0;
  524.                         blurit(_mc);
  525.                         d.setTransform(_mc.x3_pt,_mc.y3_pt,_mc.x0_pt,_mc.y0_pt,_mc.x2_pt,_mc.y2_pt,_mc.x1_pt,_mc.y1_pt);
  526.                         d_back.setTransform(_mc.x2_pt,_mc.y2_pt,_mc.x1_pt,_mc.y1_pt,_mc.x3_pt,_mc.y3_pt,_mc.x0_pt,_mc.y0_pt);
  527.                         if (_useShad) d_shadow.setTransform(_mc.x3_pt,_mc.y3_pt,_mc.x0_pt,_mc.y0_pt,_mc.x2_pt,_mc.y2_pt,_mc.x1_pt,_mc.y1_pt);
  528.                     }              
  529.                     _mc.removeEventListener(Event.ENTER_FRAME,flipEngine);
  530.                    
  531.                 } else {
  532.                     _mc.removeEventListener(Event.ENTER_FRAME,flipEngine);
  533.                     flipScript(turns, masterEase);
  534.                    
  535.                 }
  536.             }
  537.         }
  538.     }
  539. }
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!