home *** CD-ROM | disk | FTP | other *** search
/ Ice Age Fan CD 1 / CD1_Scrat.iso / flash / data / game.swf / scripts / asCode / particleManagerClass.as < prev    next >
Encoding:
Text File  |  2012-07-04  |  11.6 KB  |  341 lines
  1. package asCode
  2. {
  3.    import flash.display.*;
  4.    import flash.geom.*;
  5.    import flash.utils.*;
  6.    
  7.    internal class particleManagerClass
  8.    {
  9.       private static var EFFECTOR_PUSH_AWAY:int = 0;
  10.       
  11.       private static var EFFECTOR_PUSH_DIRECTION:int = 2;
  12.       
  13.       private static var EFFECTOR_MAGNET:int = 1;
  14.       
  15.       private var particleHolder:BitmapData;
  16.       
  17.       private var particleDict:Dictionary;
  18.       
  19.       private var tempParticleSprite:Sprite;
  20.       
  21.       private var newParticle:particleClass;
  22.       
  23.       private var renderMatrix:Matrix;
  24.       
  25.       private var gravityAngle:Number;
  26.       
  27.       private var gravitySpeed:Number;
  28.       
  29.       private var particleSize:Number;
  30.       
  31.       private var particleCounter:Number;
  32.       
  33.       private var _particleBitmapLoc:Point;
  34.       
  35.       private var _particleXSize:int;
  36.       
  37.       private var _particleYSize:int;
  38.       
  39.       private var particleSpriteSheet:BitmapData;
  40.       
  41.       private var alphaBitmap:BitmapData;
  42.       
  43.       private var _effectorClassRef:effectorClass;
  44.       
  45.       private var effectorArray:Array;
  46.       
  47.       private var radians:Number;
  48.       
  49.       private var newSpeed:Number;
  50.       
  51.       private var pushX:Number;
  52.       
  53.       private var pushY:Number;
  54.       
  55.       private var particleDetailsArray:Array;
  56.       
  57.       private var zeroPoint:Point;
  58.       
  59.       private var _particleSize:Point;
  60.       
  61.       private var copyRect:Rectangle;
  62.       
  63.       private var pCount:int;
  64.       
  65.       private var particleScale:Number;
  66.       
  67.       private var trot:Number;
  68.       
  69.       private var tempLoc:Point;
  70.       
  71.       private var cTransform:ColorTransform;
  72.       
  73.       private var P_ELECTRICAL:int = 1;
  74.       
  75.       private var P_WANDERING_LINE:int = 2;
  76.       
  77.       private var P_LINE:int = 3;
  78.       
  79.       private var P_FALLING:int = 4;
  80.       
  81.       private var P_WANDERING:int = 5;
  82.       
  83.       private var P_GROWING:int = 6;
  84.       
  85.       private var P_WHITE_SMOKE:int = 7;
  86.       
  87.       private var P_METEOR:int = 8;
  88.       
  89.       private var P_BLUE_FLASH:int = 9;
  90.       
  91.       private var P_FLASH:int = 10;
  92.       
  93.       private var P_FLICKER:int = 11;
  94.       
  95.       private var P_SNOW:int = 12;
  96.       
  97.       public function particleManagerClass(param1:BitmapData, param2:BitmapData)
  98.       {
  99.          renderMatrix = new Matrix();
  100.          _particleBitmapLoc = new Point();
  101.          zeroPoint = new Point();
  102.          _particleSize = new Point();
  103.          copyRect = new Rectangle(0,0,10,10);
  104.          tempLoc = new Point();
  105.          cTransform = new ColorTransform();
  106.          super();
  107.          particleHolder = param1;
  108.          particleDict = new Dictionary(true);
  109.          particleSize = 10;
  110.          particleCounter = 0;
  111.          particleSpriteSheet = param2;
  112.          effectorArray = new Array();
  113.       }
  114.       
  115.       public function clearEffectors() : void
  116.       {
  117.          var _loc2_:MovieClip = null;
  118.          var _loc1_:int = int(effectorArray.length);
  119.          while(_loc1_--)
  120.          {
  121.             _effectorClassRef = effectorArray[_loc1_];
  122.             _loc2_ = _effectorClassRef.getClip();
  123.             _loc2_.parent.removeChild(_loc2_);
  124.             effectorArray.splice(_loc1_,1);
  125.          }
  126.       }
  127.       
  128.       public function createEffector(param1:Number, param2:Number, param3:MovieClip, param4:int, param5:Number, param6:Number, param7:Number) : *
  129.       {
  130.          _effectorClassRef = new effectorClass(param1,param2,param3,param4,param5,param6,param7);
  131.          effectorArray.push(_effectorClassRef);
  132.       }
  133.       
  134.       public function applyEffector(param1:effectorClass, param2:Object) : void
  135.       {
  136.          var _loc3_:Point = param1.getLoc();
  137.          var _loc4_:Point = param2.getLoc();
  138.          var _loc5_:Number = _loc3_.x - _loc4_.x;
  139.          var _loc6_:Number = _loc3_.y - _loc4_.y;
  140.          var _loc7_:Number = Math.floor(Math.sqrt(_loc5_ * _loc5_ + _loc6_ * _loc6_));
  141.          var _loc8_:Number = param1.getRange();
  142.          if(_loc7_ < _loc8_)
  143.          {
  144.             switch(param1.getEffectorType())
  145.             {
  146.                case EFFECTOR_PUSH_AWAY:
  147.                   radians = Math.atan2(_loc6_,_loc5_);
  148.                   newSpeed = param1.getStrength() - param1.getStrength() / _loc7_;
  149.                   pushX = Math.cos(radians) * -newSpeed;
  150.                   pushY = Math.sin(radians) * -newSpeed;
  151.                   param2.effectParticle(pushX,pushY);
  152.                   break;
  153.                case EFFECTOR_MAGNET:
  154.                   radians = Math.atan2(_loc6_,_loc5_);
  155.                   newSpeed = param1.getStrength() - param1.getStrength() / _loc7_;
  156.                   pushX = Math.cos(radians) * newSpeed;
  157.                   pushY = Math.sin(radians) * newSpeed;
  158.                   param2.effectParticle(pushX,pushY);
  159.                   break;
  160.                case EFFECTOR_PUSH_DIRECTION:
  161.                   radians = param1.getRadians();
  162.                   newSpeed = param1.getStrength() - param1.getStrength() / _loc7_;
  163.                   pushX = Math.cos(radians) * newSpeed;
  164.                   pushY = Math.sin(radians) * newSpeed;
  165.                   param2.effectParticle(pushX,pushY);
  166.             }
  167.          }
  168.       }
  169.       
  170.       public function killAllParticles() : void
  171.       {
  172.          var _loc1_:Object = null;
  173.          for each(_loc1_ in particleDict)
  174.          {
  175.             delete particleDict[_loc1_];
  176.          }
  177.       }
  178.       
  179.       public function createParticles(param1:Number, param2:Number, param3:int, param4:int) : *
  180.       {
  181.          while(param3--)
  182.          {
  183.             generateParticle(param1,param2,param4);
  184.          }
  185.       }
  186.       
  187.       public function manageParticles(param1:Number) : int
  188.       {
  189.          var _loc2_:Object = null;
  190.          var _loc3_:int = 0;
  191.          var _loc4_:int = 0;
  192.          var _loc5_:int = 0;
  193.          var _loc6_:BitmapData = null;
  194.          var _loc7_:Number = NaN;
  195.          var _loc8_:Number = NaN;
  196.          var _loc9_:Number = NaN;
  197.          var _loc10_:Number = NaN;
  198.          var _loc11_:Number = NaN;
  199.          var _loc12_:Number = NaN;
  200.          var _loc13_:Number = NaN;
  201.          var _loc14_:Number = NaN;
  202.          var _loc15_:int = 0;
  203.          pCount = 0;
  204.          for each(_loc2_ in particleDict)
  205.          {
  206.             ++pCount;
  207.             if(!_loc2_.alive)
  208.             {
  209.                delete particleDict[_loc2_];
  210.             }
  211.             else
  212.             {
  213.                _loc2_.adjustParticleY(param1);
  214.                _loc2_.moveit();
  215.                _loc3_ = int(effectorArray.length);
  216.                while(_loc3_--)
  217.                {
  218.                   _effectorClassRef = effectorArray[_loc3_];
  219.                   _loc15_ = _effectorClassRef.getEffectorType();
  220.                   applyEffector(_effectorClassRef,_loc2_);
  221.                }
  222.                _particleSize = _loc2_.getSize();
  223.                _particleBitmapLoc = _loc2_.getSheetloc();
  224.                particleScale = _loc2_.getScale();
  225.                _loc4_ = Math.floor(_particleSize.x * particleScale);
  226.                _loc5_ = Math.floor(_particleSize.y * particleScale);
  227.                if(_loc4_ < 1)
  228.                {
  229.                   _loc4_ = 1;
  230.                }
  231.                if(_loc5_ < 1)
  232.                {
  233.                   _loc5_ = 1;
  234.                }
  235.                _loc6_ = new BitmapData(_particleSize.x,_particleSize.y,true,0);
  236.                copyRect.x = _particleBitmapLoc.x;
  237.                copyRect.y = _particleBitmapLoc.y;
  238.                copyRect.width = _particleSize.x;
  239.                copyRect.height = _particleSize.y;
  240.                _loc6_.copyPixels(particleSpriteSheet,copyRect,zeroPoint,null,null,true);
  241.                tempLoc = _loc2_.getLoc();
  242.                cTransform.alphaMultiplier = _loc2_.getAlpha();
  243.                renderMatrix.identity();
  244.                renderMatrix.scale(particleScale,particleScale);
  245.                trot = _loc2_.getRot() / 180 * Math.PI;
  246.                renderMatrix.rotate(trot);
  247.                _loc7_ = copyRect.width / 2 * particleScale;
  248.                _loc8_ = copyRect.height / 2 * particleScale;
  249.                _loc9_ = Math.cos(trot);
  250.                _loc10_ = Math.sin(trot);
  251.                _loc11_ = _loc9_ * _loc7_;
  252.                _loc12_ = _loc10_ * _loc7_;
  253.                _loc13_ = _loc10_ * _loc8_;
  254.                _loc14_ = _loc9_ * _loc8_;
  255.                renderMatrix.translate(tempLoc.x - (_loc11_ - _loc12_) + _loc7_,tempLoc.y - (_loc13_ + _loc14_) + _loc8_);
  256.                particleHolder.draw(_loc6_,renderMatrix,cTransform);
  257.             }
  258.          }
  259.          return pCount;
  260.       }
  261.       
  262.       internal function generateParticle(param1:Number, param2:Number, param3:int) : *
  263.       {
  264.          _particleBitmapLoc = new Point(0,0);
  265.          _particleXSize = 10;
  266.          _particleYSize = 10;
  267.          switch(param3)
  268.          {
  269.             case P_SNOW:
  270.                _particleBitmapLoc.x = Math.floor(Math.random() * 3) * 10;
  271.                _particleBitmapLoc.y = 0;
  272.                _particleXSize = 10;
  273.                _particleYSize = 10;
  274.                break;
  275.             case P_ELECTRICAL:
  276.                _particleBitmapLoc.x = 120 + Math.floor(Math.random() * 3) * 10;
  277.                _particleBitmapLoc.y = 0;
  278.                _particleXSize = 10;
  279.                _particleYSize = 6;
  280.                break;
  281.             case P_FALLING:
  282.                _particleBitmapLoc.x = 40 + Math.floor(Math.random() * 3) * 2;
  283.                _particleBitmapLoc.y = 0;
  284.                _particleYSize = _particleXSize = 4;
  285.                break;
  286.             case P_WANDERING:
  287.                _particleBitmapLoc.x = 40 + Math.floor(Math.random() * 3) * 2;
  288.                _particleBitmapLoc.y = 4;
  289.                _particleYSize = _particleXSize = 4;
  290.                break;
  291.             case P_GROWING:
  292.                _particleBitmapLoc.x = 60;
  293.                _particleBitmapLoc.y = 0;
  294.                _particleYSize = _particleXSize = 20;
  295.                break;
  296.             case P_BLUE_FLASH:
  297.                _particleBitmapLoc.x = 60;
  298.                _particleBitmapLoc.y = 20;
  299.                _particleYSize = _particleXSize = 20;
  300.                break;
  301.             case P_FLASH:
  302.                _particleBitmapLoc.x = 0;
  303.                _particleBitmapLoc.y = 30;
  304.                _particleYSize = _particleXSize = 40;
  305.                break;
  306.             case P_WANDERING_LINE:
  307.                _particleBitmapLoc.x = 100;
  308.                _particleBitmapLoc.y = 0;
  309.                _particleXSize = 20;
  310.                _particleYSize = 10;
  311.                break;
  312.             case P_LINE:
  313.                _particleBitmapLoc.x = 80;
  314.                _particleBitmapLoc.y = Math.floor(Math.random() * 3) * 7;
  315.                _particleXSize = 20;
  316.                _particleYSize = 7;
  317.                break;
  318.             case P_FLICKER:
  319.                _particleBitmapLoc.x = 0;
  320.                _particleBitmapLoc.y = 40;
  321.                _particleXSize = 40;
  322.                _particleYSize = 40;
  323.                break;
  324.             case P_WHITE_SMOKE:
  325.                _particleBitmapLoc.x = Math.floor(Math.random() * 3) * 20;
  326.                _particleBitmapLoc.y = 80;
  327.                _particleYSize = _particleXSize = 20;
  328.                break;
  329.             case P_METEOR:
  330.                _particleBitmapLoc.x = Math.floor(Math.random() * 3) * 20 + 60;
  331.                _particleBitmapLoc.y = 80;
  332.                _particleYSize = _particleXSize = 20;
  333.          }
  334.          newParticle = new particleClass(param1,param2,param3,_particleXSize,_particleYSize,_particleBitmapLoc.x,_particleBitmapLoc.y);
  335.          particleDict[newParticle] = newParticle;
  336.          ++particleCounter;
  337.       }
  338.    }
  339. }
  340.  
  341.