home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Diversos / Beez.swf / scripts / core / Level.as < prev    next >
Encoding:
Text File  |  2008-09-03  |  13.4 KB  |  501 lines
  1. package core
  2. {
  3.    import core.events.CoreEvent;
  4.    import core.objects.BaseObjectDef;
  5.    import core.objects.BonusBall;
  6.    import core.objects.BonusDef;
  7.    import core.objects.Circle;
  8.    import core.objects.CircleBig;
  9.    import core.objects.CircleBigDef;
  10.    import core.objects.CircleDef;
  11.    import core.objects.Meteor;
  12.    import core.objects.MeteorDef;
  13.    import core.objects.Rect;
  14.    import core.objects.RectDef;
  15.    import core.objects.StarDef;
  16.    import flash.events.EventDispatcher;
  17.    
  18.    public class Level extends EventDispatcher
  19.    {
  20.        
  21.       
  22.       private var engine:CoreEngine;
  23.       
  24.       public var num:uint;
  25.       
  26.       public var meteors:uint;
  27.       
  28.       public var endTime:int;
  29.       
  30.       private var defs:Array;
  31.       
  32.       private var badBonuses:Array;
  33.       
  34.       public var balls:uint;
  35.       
  36.       public var startTime:int;
  37.       
  38.       private var goodBonuses:Array;
  39.       
  40.       private var currentTime:int;
  41.       
  42.       public var rects:uint;
  43.       
  44.       private var boss:Boss;
  45.       
  46.       public function Level()
  47.       {
  48.          super();
  49.          init();
  50.       }
  51.       
  52.       private function updateHandler(e:CoreEvent) : void
  53.       {
  54.          currentTime = e.data as int;
  55.          checkDefs();
  56.       }
  57.       
  58.       public function createBonusBallDef(bonusName:String, time:int) : BonusDef
  59.       {
  60.          var r:Number = 30;
  61.          var dx:Number = 100;
  62.          var x:Number = 320 - dx + Math.random() * dx * 2;
  63.          var bonusDef:BonusDef = new BonusDef(x,-r,currentTime + time,r,bonusName);
  64.          defs.push(bonusDef);
  65.          return bonusDef;
  66.       }
  67.       
  68.       public function createBigCircleDef(time:int) : CircleBigDef
  69.       {
  70.          var r:Number = (40 + Math.random() * 30) / 2;
  71.          var dx:Number = 200;
  72.          var x:Number = 320 - dx + Math.random() * dx * 2;
  73.          var circleBigDef:CircleBigDef = new CircleBigDef(x,-r,currentTime + time,r);
  74.          defs.push(circleBigDef);
  75.          return circleBigDef;
  76.       }
  77.       
  78.       public function createMeteorDef(time:int) : void
  79.       {
  80.          var r:Number = 20;
  81.          var dx:Number = 200;
  82.          var x:Number = 320 - dx + Math.random() * dx * 2;
  83.          var norm:Number = (x - 100) / 400;
  84.          var impulseX:Number = 50 * (Math.random() - norm);
  85.          var meteorDef:MeteorDef = new MeteorDef(x,-r,currentTime + time,r,impulseX,60);
  86.          defs.push(meteorDef);
  87.       }
  88.       
  89.       private function getGoodBonusName() : String
  90.       {
  91.          var index:uint = Math.floor(Math.random() * goodBonuses.length);
  92.          var bonusName:String = String(goodBonuses[index]);
  93.          goodBonuses.splice(index,1);
  94.          if(goodBonuses.length == 0)
  95.          {
  96.             initGoodBonuses();
  97.          }
  98.          return bonusName;
  99.       }
  100.       
  101.       public function createRectDef(time:int) : RectDef
  102.       {
  103.          var width:Number = 20 + Math.random() * 50;
  104.          var height:Number = 20 + Math.random() * 50;
  105.          var rotation:Number = Math.round(Math.random() * 180);
  106.          var dx:Number = 200;
  107.          var x:Number = 320 - dx + Math.random() * dx * 2;
  108.          var y:Number = -Math.sqrt(width * width + height * height);
  109.          var rectDef:RectDef = new RectDef(x,y,currentTime + time,width,height,rotation);
  110.          defs.push(rectDef);
  111.          return rectDef;
  112.       }
  113.       
  114.       private function initGoodBonuses() : void
  115.       {
  116.          goodBonuses = [BonusBall.POWERUP,BonusBall.PUSH_FIELD,BonusBall.ATTACH,BonusBall.ELASTIC];
  117.       }
  118.       
  119.       private function init() : void
  120.       {
  121.          engine = CoreEngine.getInstance();
  122.          engine.dispatcher.addEventListener(CoreEvent.UPDATE,updateHandler);
  123.          num = 0;
  124.          endTime = 0;
  125.          defs = [];
  126.          balls = 5;
  127.          rects = 0;
  128.          meteors = 0;
  129.          initGoodBonuses();
  130.          initBadBonuses();
  131.          boss = new Boss(this);
  132.       }
  133.       
  134.       private function checkDefs() : void
  135.       {
  136.          var def:BaseObjectDef = null;
  137.          var createDef:BaseObjectDef = null;
  138.          var circle:Circle = null;
  139.          var rect:Rect = null;
  140.          var meteor:Meteor = null;
  141.          var circleBig:CircleBig = null;
  142.          var defsToCreate:Array = [];
  143.          for(var i:uint = 0; i < defs.length; i++)
  144.          {
  145.             def = defs[i];
  146.             if(currentTime >= def.bornTime)
  147.             {
  148.                defsToCreate.push(def);
  149.             }
  150.          }
  151.          while(defsToCreate.length > 0)
  152.          {
  153.             createDef = defsToCreate[0];
  154.             if(createDef is BonusDef)
  155.             {
  156.                engine.bonusesManager.createBonusBall(createDef as BonusDef);
  157.             }
  158.             else if(createDef is CircleDef)
  159.             {
  160.                circle = new Circle(createDef as CircleDef);
  161.             }
  162.             else if(createDef is RectDef)
  163.             {
  164.                rect = new Rect(createDef as RectDef);
  165.             }
  166.             else if(createDef is MeteorDef)
  167.             {
  168.                meteor = new Meteor(createDef as MeteorDef);
  169.             }
  170.             else if(createDef is CircleBigDef)
  171.             {
  172.                circleBig = new CircleBig(createDef as CircleBigDef);
  173.             }
  174.             else if(createDef is StarDef)
  175.             {
  176.                engine.bonusesManager.createStar(createDef as StarDef);
  177.             }
  178.             defs.splice(defs.indexOf(createDef),1);
  179.             defsToCreate.splice(0,1);
  180.          }
  181.       }
  182.       
  183.       public function createStarDef(time:int) : StarDef
  184.       {
  185.          var dx:Number = 200;
  186.          var x:Number = 320 - dx + Math.random() * dx * 2;
  187.          var minY:Number = 50;
  188.          var maxY:Number = 300;
  189.          var y:Number = minY + Math.random() * (maxY - minY);
  190.          var r:Number = Math.round((2 - y / maxY) * 20);
  191.          var starDef:StarDef = new StarDef(x,y,currentTime + time,r);
  192.          defs.push(starDef);
  193.          return starDef;
  194.       }
  195.       
  196.       private function initBadBonuses() : void
  197.       {
  198.          badBonuses = [BonusBall.FREEZE,BonusBall.INVERSE];
  199.       }
  200.       
  201.       public function createCircleDef(time:int) : CircleDef
  202.       {
  203.          var r:Number = (40 + Math.random() * 30) / 2;
  204.          var dx:Number = 200;
  205.          var x:Number = 320 - dx + Math.random() * dx * 2;
  206.          var circleDef:CircleDef = new CircleDef(x,-r,currentTime + time,r);
  207.          defs.push(circleDef);
  208.          return circleDef;
  209.       }
  210.       
  211.       public function next() : void
  212.       {
  213.          var i:uint = 0;
  214.          var rand:uint = 0;
  215.          var dt:Number = NaN;
  216.          var goodBonusesNum:uint = 0;
  217.          var badBonusesNum:uint = 0;
  218.          startTime = currentTime;
  219.          var levelTime:int = 40 * 12;
  220.          if(num < 3)
  221.          {
  222.             rand = 0;
  223.          }
  224.          else
  225.          {
  226.             rand = Math.floor(Math.random() * 3);
  227.          }
  228.          switch(rand)
  229.          {
  230.             case 0:
  231.                ++balls;
  232.                break;
  233.             case 1:
  234.                ++rects;
  235.                break;
  236.             case 2:
  237.                ++meteors;
  238.          }
  239.          dt = levelTime / (balls + 1);
  240.          for(i = 1; i <= balls; i++)
  241.          {
  242.             createCircleDef(i * dt);
  243.          }
  244.          dt = levelTime / (rects + 1);
  245.          for(i = 1; i <= rects; i++)
  246.          {
  247.             createRectDef(i * dt);
  248.          }
  249.          dt = levelTime / (meteors + 1);
  250.          for(i = 1; i <= meteors; i++)
  251.          {
  252.             createMeteorDef(i * dt);
  253.          }
  254.          if(num < 2)
  255.          {
  256.             goodBonusesNum = 1;
  257.          }
  258.          else
  259.          {
  260.             goodBonusesNum = 2;
  261.          }
  262.          for(i = 1; i <= goodBonusesNum; i++)
  263.          {
  264.             dt = Math.random() * levelTime;
  265.             createBonusBallDef(getGoodBonusName(),i * dt);
  266.          }
  267.          if(num < 2)
  268.          {
  269.             badBonusesNum = 0;
  270.          }
  271.          else
  272.          {
  273.             badBonusesNum = 1;
  274.          }
  275.          for(i = 1; i <= badBonusesNum; i++)
  276.          {
  277.             dt = Math.random() * levelTime;
  278.             createBonusBallDef(getBadBonusName(),dt);
  279.          }
  280.          var stars:int = 10 - engine.bonusesManager.starsNum;
  281.          if(stars > 0)
  282.          {
  283.             for(i = 0; i < stars; i++)
  284.             {
  285.                dt = Math.random() * levelTime;
  286.                createStarDef(dt);
  287.             }
  288.          }
  289.          var bossTime:int = 0;
  290.          if(num > 0 && (num + 1) % 3 == 0)
  291.          {
  292.             bossTime = boss.setBoss(levelTime);
  293.          }
  294.          endTime = currentTime + levelTime + bossTime;
  295.          ++num;
  296.       }
  297.       
  298.       private function getBadBonusName() : String
  299.       {
  300.          var index:uint = Math.floor(Math.random() * badBonuses.length);
  301.          var bonusName:String = String(badBonuses[index]);
  302.          badBonuses.splice(index,1);
  303.          if(badBonuses.length == 0)
  304.          {
  305.             initBadBonuses();
  306.          }
  307.          return bonusName;
  308.       }
  309.    }
  310. }
  311.  
  312. import core.Level;
  313. import core.objects.BonusBall;
  314. import core.objects.BonusDef;
  315. import core.objects.CircleBigDef;
  316. import core.objects.CircleDef;
  317. import core.objects.RectDef;
  318.  
  319. class Boss
  320. {
  321.    
  322.    private static var CIRCLE_BIG:String = "CircleBig";
  323.    
  324.    private static var FILL_RECTS:String = "FillRects";
  325.    
  326.    private static var FILL_CIRCLES:String = "FillCircles";
  327.    
  328.    private static var FILL_FREEZE:String = "FillFreeze";
  329.     
  330.    
  331.    private var level:Level;
  332.    
  333.    private var bossLevel:uint;
  334.    
  335.    private var types:Array;
  336.    
  337.    private var bossTime:int;
  338.    
  339.    private var counter:uint;
  340.    
  341.    public function Boss(level:Level)
  342.    {
  343.       super();
  344.       this.level = level;
  345.       init();
  346.    }
  347.    
  348.    private function fillCircles(startTime:int) : void
  349.    {
  350.       var circles:uint = 0;
  351.       var i:uint = 0;
  352.       var dt:Number = NaN;
  353.       var def:CircleDef = null;
  354.       bossTime = 40 * 4;
  355.       switch(bossLevel)
  356.       {
  357.          case 0:
  358.             circles = 7;
  359.             break;
  360.          case 1:
  361.             circles = 12;
  362.             break;
  363.          case 2:
  364.             circles = 17;
  365.       }
  366.       dt = bossTime / (circles + 1);
  367.       var baseX:Number = Math.random() < 0.5 ? 320 + 190 : 320 - 190;
  368.       for(i = 1; i <= circles; i++)
  369.       {
  370.          def = level.createCircleDef(startTime + i * dt);
  371.          def.x = baseX - 30 + Math.random() * 60;
  372.       }
  373.    }
  374.    
  375.    private function fillFreeze(startTime:int) : void
  376.    {
  377.       var freezes:uint = 0;
  378.       var i:uint = 0;
  379.       var dt:Number = NaN;
  380.       var def:BonusDef = null;
  381.       bossTime = 40 * 2;
  382.       switch(bossLevel)
  383.       {
  384.          case 0:
  385.             freezes = 3;
  386.             break;
  387.          case 1:
  388.             freezes = 4;
  389.             break;
  390.          case 2:
  391.             freezes = 5;
  392.       }
  393.       dt = bossTime / (freezes + 1);
  394.       var dx:Number = 380 / (freezes + 1);
  395.       for(i = 1; i <= freezes; i++)
  396.       {
  397.          def = level.createBonusBallDef(BonusBall.FREEZE,startTime + i * dt);
  398.          def.x = 130 + i * dx;
  399.       }
  400.    }
  401.    
  402.    private function initTypes() : void
  403.    {
  404.       types = [FILL_CIRCLES,FILL_RECTS,CIRCLE_BIG,FILL_FREEZE];
  405.    }
  406.    
  407.    private function fillRects(startTime:int) : void
  408.    {
  409.       var rects:uint = 0;
  410.       var i:uint = 0;
  411.       var dt:Number = NaN;
  412.       var def:RectDef = null;
  413.       bossTime = 40 * 4;
  414.       switch(bossLevel)
  415.       {
  416.          case 0:
  417.             rects = 7;
  418.             break;
  419.          case 1:
  420.             rects = 12;
  421.             break;
  422.          case 2:
  423.             rects = 17;
  424.       }
  425.       dt = bossTime / (rects + 1);
  426.       var baseX:Number = Math.random() < 0.5 ? 320 + 190 : 320 - 190;
  427.       for(i = 1; i <= rects; i++)
  428.       {
  429.          def = level.createRectDef(startTime + i * dt);
  430.          def.x = baseX - 30 + Math.random() * 60;
  431.       }
  432.    }
  433.    
  434.    public function setBoss(startTime:int) : int
  435.    {
  436.       var type:String = String(getType());
  437.       switch(type)
  438.       {
  439.          case FILL_CIRCLES:
  440.             fillCircles(startTime);
  441.             break;
  442.          case FILL_RECTS:
  443.             fillRects(startTime);
  444.             break;
  445.          case CIRCLE_BIG:
  446.             circleBig(startTime);
  447.             break;
  448.          case FILL_FREEZE:
  449.             fillFreeze(startTime);
  450.       }
  451.       ++counter;
  452.       if(counter == 4)
  453.       {
  454.          ++bossLevel;
  455.          counter = 0;
  456.       }
  457.       return bossTime;
  458.    }
  459.    
  460.    private function init() : void
  461.    {
  462.       bossTime = 0;
  463.       initTypes();
  464.       counter = 0;
  465.    }
  466.    
  467.    private function getType() : String
  468.    {
  469.       var index:uint = Math.floor(Math.random() * types.length);
  470.       var type:String = String(types[index]);
  471.       types.splice(index,1);
  472.       if(types.length == 0)
  473.       {
  474.          initTypes();
  475.       }
  476.       return type;
  477.    }
  478.    
  479.    private function circleBig(startTime:int) : void
  480.    {
  481.       bossTime = 40 * 3;
  482.       var dt:Number = bossTime / 2;
  483.       var baseX:Number = Math.random() < 0.5 ? 320 + 190 : 320 - 190;
  484.       var def:CircleBigDef = level.createBigCircleDef(startTime + dt);
  485.       def.x = baseX - 30 + Math.random() * 60;
  486.       switch(bossLevel)
  487.       {
  488.          case 0:
  489.             def.r = 60;
  490.             break;
  491.          case 1:
  492.             def.r = 90;
  493.             break;
  494.          case 2:
  495.             def.r = 120;
  496.       }
  497.       def.r = 50;
  498.       def.y = -def.r;
  499.    }
  500. }
  501.