home *** CD-ROM | disk | FTP | other *** search
/ Ice Age Fan CD 1 / CD1_Scrat.iso / flash / data / game.swf / scripts / asCode / playerBubbleCodeClass.as < prev    next >
Encoding:
Text File  |  2012-07-04  |  9.1 KB  |  289 lines
  1. package asCode
  2. {
  3.    import flash.display.*;
  4.    import flash.events.*;
  5.    import flash.filters.*;
  6.    import flash.geom.*;
  7.    
  8.    public class playerBubbleCodeClass
  9.    {
  10.       private static var BUBBLE_TYPE_PLAYER:int = 0;
  11.       
  12.       private static var BUBBLE_TYPE_ACORN:int = 5;
  13.       
  14.       private static var BUBBLE_TYPE_HEALTH_POWERUP:int = 10;
  15.       
  16.       private static var BUBBLE_TYPE_INVINCIBLE:int = 15;
  17.       
  18.       private static var BUBBLE_TYPE_SHRINK:int = 20;
  19.       
  20.       private static var BUBBLE_TYPE_REVERSE:int = 25;
  21.       
  22.       private var _gameClassRef:gameClipClass;
  23.       
  24.       private var dropShadow:GlowFilter;
  25.       
  26.       private var filtersArray:Array;
  27.       
  28.       private var playerScale:Number;
  29.       
  30.       private var bubbleSize:Number;
  31.       
  32.       private var bubble:MovieClip;
  33.       
  34.       private var scaleFactor:Number;
  35.       
  36.       private var currentDistort:Number = 0;
  37.       
  38.       private var level:int;
  39.       
  40.       private var bubbleColour:Number;
  41.       
  42.       private var powerUpActive:int;
  43.       
  44.       private var drawNodes:Boolean;
  45.       
  46.       private var i:int;
  47.       
  48.       private var centerPoint:Point;
  49.       
  50.       private var _point:Point;
  51.       
  52.       private var _point2:Point;
  53.       
  54.       private var firstPoint:Boolean;
  55.       
  56.       private var bubbleShape:Shape;
  57.       
  58.       private var bubbleShape2:Shape;
  59.       
  60.       private var bubbleRadius:Number = 60;
  61.       
  62.       private var bubbleSteps:Number = 12;
  63.       
  64.       private var bubbleStepRotationNumber:Number;
  65.       
  66.       private var radians:Number;
  67.       
  68.       private var n:int;
  69.       
  70.       private var bubbleType:int;
  71.       
  72.       private var nodeArray:Array;
  73.       
  74.       private var _bubbleNodeRef:bubbleNode;
  75.       
  76.       private var _destination:Point;
  77.       
  78.       private var xVelocity:Number;
  79.       
  80.       private var yVelocity:Number;
  81.       
  82.       private var dx:Number;
  83.       
  84.       private var dy:Number;
  85.       
  86.       private var dist:Number;
  87.       
  88.       private var _pointb:Point;
  89.       
  90.       private var bRad:Number;
  91.       
  92.       private var bubbleCycle:Number = 0;
  93.       
  94.       private var bubbleCycleCount:Number = 0;
  95.       
  96.       public function playerBubbleCodeClass(param1:MovieClip, param2:Number, param3:int, param4:Boolean, param5:gameClipClass)
  97.       {
  98.          var _loc7_:Number = NaN;
  99.          centerPoint = new Point(160,120);
  100.          _point = new Point();
  101.          _point2 = new Point();
  102.          super();
  103.          _gameClassRef = param5;
  104.          bubbleType = param3;
  105.          _pointb = new Point();
  106.          _point = new Point();
  107.          _point2 = new Point();
  108.          bubbleRadius = param2;
  109.          bubbleShape = new Shape();
  110.          bubble = param1;
  111.          bubbleShape2 = new Shape();
  112.          bubble.addChild(bubbleShape);
  113.          bubbleColour = _gameClassRef.playerBubbleRenderColour;
  114.          dropShadow = new GlowFilter(bubbleColour,0.25,20,20,2,1,true,true);
  115.          filtersArray = [dropShadow];
  116.          bubbleStepRotationNumber = 360 / bubbleSteps;
  117.          nodeArray = new Array();
  118.          var _loc6_:int = 0;
  119.          while(_loc6_ < bubbleSteps + 1)
  120.          {
  121.             _loc7_ = _loc6_ * bubbleStepRotationNumber;
  122.             radians = _loc7_ / 180 * Math.PI;
  123.             _point.x = Math.cos(radians) * bubbleRadius;
  124.             _point.y = Math.sin(radians) * bubbleRadius;
  125.             _bubbleNodeRef = new bubbleNode(_point);
  126.             nodeArray[_loc6_] = _bubbleNodeRef;
  127.             _loc6_++;
  128.          }
  129.          xVelocity = 0;
  130.          yVelocity = 0;
  131.          drawNodes = param4;
  132.          _destination = new Point();
  133.          bubbleCycle = Math.random() * 360;
  134.          param1.bubbleSheen.width = param1.bubbleSheen.height = param2 * 0.7;
  135.       }
  136.       
  137.       public function getBubbleRadius() : Number
  138.       {
  139.          return bubbleRadius;
  140.       }
  141.       
  142.       public function getClip() : MovieClip
  143.       {
  144.          return bubble;
  145.       }
  146.       
  147.       private function findDist(param1:Point, param2:Point) : Number
  148.       {
  149.          dx = param1.x - param2.x;
  150.          dy = param1.y - param2.y;
  151.          dist = Math.floor(Math.sqrt(dx * dx + dy * dy));
  152.          return dist;
  153.       }
  154.       
  155.       private function findAngle(param1:Point, param2:Point) : Number
  156.       {
  157.          dx = param1.x - param2.x;
  158.          dy = param1.y - param2.y;
  159.          radians = Math.atan2(dy,dx);
  160.          return radians;
  161.       }
  162.       
  163.       public function setLoc(param1:Point) : void
  164.       {
  165.          centerPoint.x = param1.x;
  166.          centerPoint.y = param1.y;
  167.       }
  168.       
  169.       public function getLoc() : Point
  170.       {
  171.          return centerPoint;
  172.       }
  173.       
  174.       public function drawBubble(param1:Point) : *
  175.       {
  176.          var _loc10_:Number = NaN;
  177.          var _loc11_:Number = NaN;
  178.          var _loc12_:Number = NaN;
  179.          var _loc13_:Number = NaN;
  180.          var _loc14_:* = undefined;
  181.          var _loc15_:* = undefined;
  182.          level = _gameClassRef.level;
  183.          playerScale = _gameClassRef.playerScale;
  184.          bubbleCycleCount += 5;
  185.          if(bubbleCycleCount > 360)
  186.          {
  187.             bubbleCycleCount -= 360;
  188.          }
  189.          bRad = bubbleCycleCount / 180 * Math.PI;
  190.          _destination.x = param1.x;
  191.          _destination.y = param1.y;
  192.          var _loc2_:Number = findAngle(_destination,centerPoint);
  193.          var _loc3_:Number = Math.cos(_loc2_) * bubbleRadius;
  194.          var _loc4_:Number = Math.sin(_loc2_) * bubbleRadius;
  195.          _point = new Point(param1.x,param1.y);
  196.          dist = findDist(_point,centerPoint);
  197.          dist *= 0.4 * (1 / playerScale);
  198.          xVelocity = Math.cos(_loc2_) * dist;
  199.          yVelocity = Math.sin(_loc2_) * dist;
  200.          firstPoint = true;
  201.          centerPoint.x += xVelocity;
  202.          centerPoint.y += yVelocity;
  203.          bubble.x = centerPoint.x + Math.cos(bRad) * 5;
  204.          bubble.y = centerPoint.y + Math.sin(bRad) * 5;
  205.          var _loc5_:Array = [];
  206.          var _loc6_:Array = [];
  207.          currentDistort += 0.05;
  208.          var _loc7_:Number = currentDistort / bubbleSteps * 360;
  209.          var _loc8_:Number = _loc7_ / 180 * Math.PI;
  210.          var _loc9_:int = 0;
  211.          while(_loc9_ < bubbleSteps)
  212.          {
  213.             _bubbleNodeRef = nodeArray[_loc9_];
  214.             _point = _bubbleNodeRef.getLoc();
  215.             _pointb = new Point(_destination.x - centerPoint.x,_destination.y - centerPoint.y);
  216.             _loc10_ = findDist(_point,_pointb);
  217.             _bubbleNodeRef = nodeArray[_loc9_ + 1];
  218.             _point2 = _bubbleNodeRef.getLoc();
  219.             _loc11_ = (_loc9_ + currentDistort) / (bubbleSteps * 2) * 360 / 180 * Math.PI;
  220.             _loc12_ = Math.cos(_loc8_) * 3;
  221.             _loc13_ = Math.sin(_loc8_) * 3;
  222.             xVelocity = Math.cos(_loc2_) * _loc10_ + _loc12_;
  223.             yVelocity = Math.sin(_loc2_) * _loc10_ + _loc13_;
  224.             _point.x -= xVelocity - _loc3_;
  225.             _point2.x -= xVelocity - _loc3_;
  226.             _point.y -= yVelocity - _loc4_;
  227.             _point2.y -= yVelocity - _loc4_;
  228.             _loc14_ = (_point.x + _point2.x) / 2;
  229.             _loc15_ = (_point.y + _point2.y) / 2;
  230.             _loc5_.push(_point);
  231.             _loc6_.push(new Point(_loc14_,_loc15_));
  232.             _loc9_++;
  233.          }
  234.          bubbleShape.graphics.clear();
  235.          bubbleShape.graphics.lineStyle(2,0,0.5);
  236.          bubbleShape.graphics.beginFill(0,1);
  237.          bubbleColour = _gameClassRef.playerBubbleRenderColour;
  238.          powerUpActive = _gameClassRef.powerUpActive;
  239.          if(powerUpActive == BUBBLE_TYPE_INVINCIBLE || powerUpActive == BUBBLE_TYPE_REVERSE || powerUpActive == BUBBLE_TYPE_SHRINK)
  240.          {
  241.             dropShadow = new GlowFilter(bubbleColour,0.5,30,30,2,1,true,true);
  242.          }
  243.          else
  244.          {
  245.             dropShadow = new GlowFilter(bubbleColour,0.5,20,20,2,1,true,true);
  246.          }
  247.          filtersArray = [dropShadow];
  248.          bubbleShape.graphics.beginFill(0,1);
  249.          _point = _loc6_[0];
  250.          bubbleShape.graphics.moveTo(_point.x,_point.y);
  251.          _loc9_ = 1;
  252.          while(_loc9_ < bubbleSteps)
  253.          {
  254.             _point = _loc5_[_loc9_];
  255.             _point2 = _loc6_[_loc9_];
  256.             bubbleShape.graphics.curveTo(_point.x,_point.y,_point2.x,_point2.y);
  257.             if(drawNodes)
  258.             {
  259.                drawNode(_point,_point2);
  260.             }
  261.             _loc9_++;
  262.          }
  263.          _point = _loc5_[0];
  264.          _point2 = _loc6_[0];
  265.          bubbleShape.graphics.curveTo(_point.x,_point.y,_point2.x,_point2.y);
  266.          bubbleShape.graphics.endFill();
  267.          if(drawNodes)
  268.          {
  269.             drawNode(_point,_point2);
  270.          }
  271.          bubbleShape.filters = filtersArray;
  272.       }
  273.       
  274.       private function drawNode(param1:Point, param2:Point) : void
  275.       {
  276.          bubbleShape2.graphics.beginFill(16776960,0.5);
  277.          bubbleShape2.graphics.drawCircle(param1.x,param1.y,5);
  278.          bubbleShape2.graphics.beginFill(16711680,0.5);
  279.          bubbleShape2.graphics.drawCircle(param2.x,param2.y,2);
  280.       }
  281.       
  282.       public function get getBubbleType() : int
  283.       {
  284.          return bubbleType;
  285.       }
  286.    }
  287. }
  288.  
  289.