Advertisement
Guest User

GameSceneClip.as

a guest
Apr 21st, 2011
115
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package {
  2.     //импорт пакетов
  3.     import Box2D.Collision.Shapes.b2CircleShape;
  4.     import Box2D.Collision.Shapes.b2PolygonShape;
  5.     import Box2D.Common.Math.b2Vec2;
  6.     import Box2D.Common.Math.b2Vec3;
  7.     import Box2D.Dynamics.b2Body;
  8.     import Box2D.Dynamics.b2BodyDef;
  9.     import Box2D.Dynamics.b2DebugDraw;
  10.     import Box2D.Dynamics.b2FilterData;
  11.     import Box2D.Dynamics.b2FixtureDef;
  12.     import Box2D.Dynamics.b2World;
  13.     import Box2D.Dynamics.Joints.b2DistanceJoint;
  14.     import Box2D.Dynamics.Joints.b2DistanceJointDef;
  15.     import flash.display.MovieClip;
  16.     import flash.display.Sprite;
  17.     import flash.events.Event;
  18.     import flash.events.KeyboardEvent;
  19.     import flash.events.MouseEvent;
  20.     //класс игровой сцены
  21.     public class GameSceneClip extends MovieClip {
  22.         //константы сцены
  23.         const GAME_PLAY:Boolean = true;//состояние сцены "в игре"
  24.         const GAME_PAUSE:Boolean = false;//состояние сцены "в паузе"
  25.         const GAME_INSLEEP:uint = 0;//состояние игры "простой"
  26.         const GAME_INAIR:uint = 1;//состояние игры "в воздухе"
  27.         const GAME_INRUBBER:uint = 2;//состояние игры "на резинке"
  28.         const PIXELS_TO_METRE:Number = 30;//метр в пикселях
  29.         //свойства сценны
  30.         private var sceneWidth:uint = 600;//длина сценны
  31.         private var sceneHeight:uint = 500; //ширина сцены
  32.         private var _sceneState:Boolean;//состояние сцены
  33.         private var _gameState:uint;
  34.         private var _maxDistance:Number = 3;
  35.         private var _maxDistanceForJoint:Number;
  36.         private var _inRubberZone:Boolean = false;
  37.         private var _inRubberJoint:Boolean = false;
  38.         private var _maxRubberDistance:Number;
  39.         private var _thisRubberDistance:Number;
  40.         private var _pointsArray:Array = null;
  41.         private var _playerState:Boolean = false;
  42.         private var _maxDeadDistance:Number = 25;
  43.         private var _cameraPosX:Number = 0;
  44.         private var _cameraPosY:Number = 0;
  45.         private var _cameraMove:Boolean = false;
  46.         //свойства-клипы (графические элементы и т.д)
  47.         private var _bg:MovieClip;//клип заднего фона
  48.         private var _borderClip:MovieClip;//клип рамки
  49.         private var _playerClip:MovieClip;//клип игрока
  50.         private var _rubberClip:MovieClip;//клип резинки
  51.         private var _pointAClip:MovieClip;//клип начальной точки
  52.         private var _pointBClip:MovieClip;//клип конечной точки
  53.         private var _blocksClipsArray:Array = null;
  54.         private var _debugSprite:Sprite;
  55.         //box2d свойства игрока и различные флаги игрока
  56.         private var _blockBodysArray:Array = null;
  57.         private var _world:b2World;//физический мир
  58.         private var _worldGravitation:Number = 10;
  59.         private var _worldSleep:Boolean = true;
  60.         private var _playerBody:b2Body = null;//тело игрока
  61.         private var _playerBodyDef:b2BodyDef = null;//деф для тела игрока
  62.         private var _playerBodyShape:b2CircleShape = null;//фигура тела игрока
  63.         private var _playerBodyFixtureDef:b2FixtureDef = null;//фиксдеф для тела игрока
  64.         private var _playerDistanceJoint:b2DistanceJoint = null;//дистанционное соединие между игроком и точкой
  65.         private var _centerBody:b2Body = null;
  66.         private var _centerBodyDef:b2BodyDef = null;
  67.         private var _centerBodyShape:b2CircleShape = null;
  68.         private var _centerBodyFixture:b2FixtureDef = null;
  69.         /*private var _blockBodyDef:b2BodyDef = null;
  70.         private var _blockBodyShape:b2PolygonShape;
  71.         private var _blockBodyFixture:b2FixtureDef;*/
  72.         private var _thisPoint:b2Vec2 = null;  
  73.         private var _nextPoint:b2Vec2 = null;
  74.         private var _oldPoint:b2Vec2;
  75.         public function  GameSceneClip() { // конструктор класса
  76.             Init();//инициализируем данные класса
  77.         }
  78.         //методы инициализации данных
  79.         private function Init():void {//метод инициализации данных в конструкторе
  80.             _bg = new GameBgClip();//создаем клип заднего фона
  81.             addChild(_bg);//добавлем его на сцену
  82.            
  83.             _maxRubberDistance = _maxDistance * 2 * PIXELS_TO_METRE;
  84.            
  85.            
  86.            
  87.             SetPosClipToCustomPoint(_bg);//устанавливаем его в позицию (0,0)
  88.             _rubberClip = new RubberClip;//создвем клип резинки
  89.             addChild(_rubberClip);//добавляем его на сцену
  90.             SetPosClipToOverCamera(_rubberClip);//убираем его из области отображения камеры
  91.             _pointAClip = new PointAClip();//создает клип начальной точки
  92.             addChild(_pointAClip);//добавляем его на сцену
  93.             SetPosClipToOverCamera(_pointAClip);//убираем его из области отображения камеры
  94.             _pointBClip = new PointBClip();//создаем клип конечной точки
  95.             addChild(_pointBClip);//добавляем его на сцену
  96.             SetPosClipToOverCamera(_pointBClip);//убираем его из области отображения камеры
  97.             _playerClip = new PlayerClip();//создаем клип игрока
  98.             addChild(_playerClip);//добавляем его на сцену
  99.             SetPosClipToOverCamera(_playerClip);//убираем его из области отображения камеры
  100.            
  101.             _world = new b2World(new b2Vec2(0, _worldGravitation), _worldSleep);//создаем физический мир
  102.             addEventListener(Event.ADDED_TO_STAGE, onAddedToStageBehaviour);//добавляем обработчик события ADDED_TO_STAGE
  103.             _blockBodysArray = new Array();
  104.             _blocksClipsArray = new Array();
  105.             addBlockToScene(coordToB2Vec2(300, 1500), 7);
  106.             addBlockToScene(coordToB2Vec2(630, 1700), 7);
  107.             addBlockToScene(coordToB2Vec2(900, 1460), 7);
  108.             addBlockToScene(coordToB2Vec2(540, 960), 7);
  109.             addBlockToScene(coordToB2Vec2(340, 710), 7);
  110.             addBlockToScene(coordToB2Vec2(930, 590), 7);
  111.             addBlockToScene(coordToB2Vec2(1200, 210), 7);
  112.             addBlockToScene(coordToB2Vec2(1460, 400), 7);
  113.             addBlockToScene(coordToB2Vec2(1610, 1040), 7);
  114.             addBlockToScene(coordToB2Vec2(1500, 1440), 7);
  115.            
  116.             addBlockToScene(coordToB2Vec2(840, 1600), 3);
  117.             addBlockToScene(coordToB2Vec2(1100, 1650), 3);
  118.             addBlockToScene(coordToB2Vec2(1460, 1590), 3);
  119.             addBlockToScene(coordToB2Vec2(1650,1210), 3);
  120.             addBlockToScene(coordToB2Vec2(1610, 1110), 3);
  121.             addBlockToScene(coordToB2Vec2(1720, 820), 3);
  122.             addBlockToScene(coordToB2Vec2(1620, 510), 3);
  123.             addBlockToScene(coordToB2Vec2(920, 540), 3);
  124.             addBlockToScene(coordToB2Vec2(680, 200), 3);
  125.            
  126.             addBlockToScene(coordToB2Vec2(1170, 1240), 1);
  127.             addBlockToScene(coordToB2Vec2(880, 660), 1);
  128.             addBlockToScene(coordToB2Vec2(470, 850), 1);
  129.             addBlockToScene(coordToB2Vec2(230, 630), 1);
  130.             addBlockToScene(coordToB2Vec2(240, 350), 1);
  131.             addBlockToScene(coordToB2Vec2(330, 100), 1);
  132.             //
  133.             _pointsArray = new Array();
  134.             _pointsArray.push(coordToB2Vec2(640 , 700 ));
  135.             _pointsArray.push(coordToB2Vec2(400 , 500 ));
  136.             _pointsArray.push(coordToB2Vec2(440 , 330 ));
  137.             _pointsArray.push(coordToB2Vec2(690 , 420 ));
  138.             _pointsArray.push(coordToB2Vec2(920 , 320 ));
  139.             _pointsArray.push(coordToB2Vec2(1150 , 420 ));
  140.             _pointsArray.push(coordToB2Vec2(1400 , 620 ));
  141.             _pointsArray.push(coordToB2Vec2(1480 , 820 ));
  142.             _pointsArray.push(coordToB2Vec2(1250 , 640 ));
  143.             _pointsArray.push(coordToB2Vec2(1134 , 830 ));
  144.             _pointsArray.push(coordToB2Vec2(1300 , 1030 ));
  145.             _pointsArray.push(coordToB2Vec2(1370 , 1230 ));
  146.             _pointsArray.push(coordToB2Vec2(1200 , 1430 ));
  147.             _pointsArray.push(coordToB2Vec2(970 , 1250 ));
  148.             _pointsArray.push(coordToB2Vec2(1165 , 1050 ));
  149.             _pointsArray.push(coordToB2Vec2(1000 , 850 ));
  150.             _pointsArray.push(coordToB2Vec2(820 , 1050 ));
  151.             _pointsArray.push(coordToB2Vec2(600 , 1170 ));
  152.             _pointsArray.push(coordToB2Vec2(388 , 1300 ));
  153.             _pointsArray.push(coordToB2Vec2(588 , 1500 ));
  154.             _pointsArray.push(coordToB2Vec2(340 , 1700 ));
  155.  
  156.             /*_pointsArray.push(coordToB2Vec2(90, 90));
  157.             _pointsArray.push(coordToB2Vec2(sceneWidth / 2, sceneHeight / 2));
  158.             _pointsArray.push(coordToB2Vec2(90, 90));
  159.             _pointsArray.push(coordToB2Vec2(sceneWidth / 2, sceneHeight / 2));
  160.             _pointsArray.push(coordToB2Vec2(90, 90));
  161.             _pointsArray.push(coordToB2Vec2(sceneWidth / 2, sceneHeight / 2));
  162.             _pointsArray.push(coordToB2Vec2(90, 90));
  163.             _pointsArray.push(coordToB2Vec2(sceneWidth / 2, sceneHeight / 2));
  164.             _pointsArray.push(coordToB2Vec2(90, 90));
  165.             _pointsArray.push(coordToB2Vec2(sceneWidth / 2, sceneHeight / 2));
  166.             _pointsArray.push(coordToB2Vec2(90, 90));
  167.             _pointsArray.push(coordToB2Vec2(sceneWidth / 2, sceneHeight / 2));
  168.             _pointsArray.push(coordToB2Vec2(90, 90));
  169.             _pointsArray.push(coordToB2Vec2(sceneWidth / 2, sceneHeight / 2));*/
  170.             //createFloor();
  171.            
  172.             _debugSprite = new Sprite();
  173.             addChild(_debugSprite);
  174.             var debugDraw:b2DebugDraw = new b2DebugDraw();
  175.             debugDraw.SetSprite(_debugSprite);
  176.             debugDraw.SetDrawScale(PIXELS_TO_METRE);
  177.             debugDraw.SetLineThickness( 1.0);
  178.             debugDraw.SetAlpha(1);
  179.             debugDraw.SetFillAlpha(0.4);
  180.             debugDraw.SetFlags(b2DebugDraw.e_shapeBit);
  181.            
  182.             _world.SetDebugDraw(debugDraw);
  183.            
  184.            
  185.             _borderClip = new GameBorderClip();
  186.             addChild(_borderClip);
  187.             SetPosClipToCustomPoint(_borderClip);
  188.         }
  189.         //методы обработки камеры
  190.         private function cameraSetMove():void {
  191.             _cameraMove = true;
  192.         }
  193.         private function cameraSetPos():void {
  194.             trace("set camera");
  195.             _cameraPosX = _thisPoint.x * PIXELS_TO_METRE - sceneWidth / 2;
  196.             _cameraPosY = _thisPoint.y * PIXELS_TO_METRE - sceneHeight / 2;
  197.             cameraRender();
  198.         }
  199.         private function cameraSetToPos(pos:b2Vec2):void {
  200.             _cameraPosX = pos.x * PIXELS_TO_METRE - sceneWidth / 2;
  201.             _cameraPosY = pos.y * PIXELS_TO_METRE - sceneHeight / 2;
  202.             cameraRender();
  203.         }
  204.         private function cameraMoveTo(x:Number, y:Number):void {
  205.             _cameraPosX += x;
  206.             _cameraPosY += y;
  207.             if (_cameraPosX < 0) {
  208.                 _cameraPosX = 0;
  209.             }
  210.             if (_cameraPosY < 0) {
  211.                 _cameraPosY = 0;
  212.             }
  213.             cameraRender();
  214.         }
  215.         private function cameraRender(moveX:Number = 0, moveY:Number=0):void {
  216.             //trace("cameraPosX=" + _cameraPosX + ", cameraPosY=" + _cameraPosY);
  217.             //move bg
  218.             _bg.x = -_cameraPosX;
  219.             _bg.y = -_cameraPosY;
  220.             //move debug
  221.             _debugSprite.x = -_cameraPosX;
  222.             _debugSprite.y = -_cameraPosY;
  223.             SetPosClipToVec2(_pointAClip, _thisPoint);
  224.             SetPosClipToVec2(_pointBClip, _nextPoint);
  225.             for (var i:Number = 0; i < _blocksClipsArray.length; i++) {
  226.                 SetPosClipToVec2(_blocksClipsArray[i], _blockBodysArray[i].GetWorldCenter());
  227.             }
  228.         }
  229.         //методы обработчики событий
  230.         private function onKeyDownBehaviour(e:KeyboardEvent) {
  231.             if (e.keyCode == 37) {
  232.                 cameraMoveTo(-15, 0);
  233.             }
  234.             if (e.keyCode == 39) {
  235.                 cameraMoveTo(15, 0);
  236.             }
  237.             if (e.keyCode == 38) {
  238.                 cameraMoveTo(0, -15);
  239.             }
  240.             if (e.keyCode == 40) {
  241.                 cameraMoveTo(0, 15);
  242.             }
  243.         }
  244.         private function StartBehaviour():void {//метод запускает поведение игровой сцены (использовать только после добавления на сцену)
  245.             _sceneState = GAME_PLAY;//ставим состояние сцены в GAME_PLAY
  246.             _gameState = GAME_INSLEEP;//ставим состояние игры в "простой"
  247.             addEventListener(Event.ENTER_FRAME, onEnterFrameBehaviour);//добавляем обработчик события ENTER_FRAME
  248.             //stage.addEventListener(KeyboardEvent.KEY_DOWN, onKeyDownBehaviour);
  249.             trace("SET");
  250.             //addEventListener(MouseEvent.MOUSE_DOWN, onMouseDownbehaviour);//добавляем обработчик события MOUSE_DOWN
  251.             //cameraSetToPos(coordToB2Vec2(340 , 1700 ));
  252.             _cameraPosX = 36;
  253.             _cameraPosY = 1448;
  254.             setToThisPoint();          
  255.         }
  256.         private function onMouseDownbehaviour(e:MouseEvent):void {//обработчик события MOUSE_DOWN
  257.             _gameState = GAME_INAIR;
  258.             //trace(mouseX + " " + mouseY);
  259.             destroyPlayerBody();
  260.             destroyCenterBody();
  261.             createPlayerBody(coordToB2Vec2(mouseX, mouseY));
  262.         }
  263.         private function onAddedToStageBehaviour(e:Event):void {//обработчик события ADDED_TO_STAGE
  264.             removeEventListener(Event.ADDED_TO_STAGE, onAddedToStageBehaviour);//удаляем обработчик
  265.             StartBehaviour();//запускаем сцену
  266.         }
  267.         private function onMouseDownToPlayer(e:MouseEvent):void {
  268.             removeAllDynamicsObject();
  269.             _playerState = true;
  270.             _playerClip.gotoAndStop(2);
  271.         }
  272.         private function onMouseUpToPlayer(e:MouseEvent):void {
  273.             if (!_playerState) {
  274.                 return;
  275.             }
  276.             _playerState = false;
  277.             SetPosClipToOverCamera(_rubberClip);
  278.             _playerState = false;
  279.             _oldPoint = _thisPoint;
  280.             //trace("dist ="+_thisRubberDistance + " maxdist=" + _maxDistance);
  281.             if (_thisRubberDistance / PIXELS_TO_METRE < _maxDistance) {
  282.                 _pointsArray.push(_thisPoint);
  283.                 setToThisPoint(coordToB2Vec2(_playerClip.x,_playerClip.y));
  284.             }else {
  285.                 var newx:Number = (_thisPoint.x - ((_cameraPosX + _playerClip.x) / PIXELS_TO_METRE)) * 4;
  286.                 var newy:Number = (_thisPoint.y - ((_cameraPosY + _playerClip.y) / PIXELS_TO_METRE)) * 4;
  287.                 setToThisPoint(coordToB2Vec2(_playerClip.x, _playerClip.y),new b2Vec2(newx, newy));
  288.                 //setToThisPoint(coordToB2Vec2(_playerClip.x, _playerClip.y), new b2Vec2((_thisPoint.x - (_playerClip.x / PIXELS_TO_METRE))* 4, (_thisPoint.y - (_playerClip.y / PIXELS_TO_METRE))*4));//new b2Vec2((_nextPoint.x - _thisPoint.x) * 3, (_nextPoint.y - _thisPoint.y) * 3));
  289.             }
  290.             _gameState = GAME_INAIR;
  291.             removeListenerToPlayerClip();
  292.         }
  293.         private function onMouseMoveToPlayer(e:MouseEvent):void {
  294.             trace("move");
  295.         }
  296.         private function onEnterFrameBehaviour(e:Event):void {//обработчик события ENTER_FRAME
  297.             if (_sceneState) {//если находимся "в игре", то...
  298.                 if (_gameState == GAME_INAIR) {
  299.                     var point1:b2Vec2 = _playerBody.GetWorldCenter();
  300.                     var point2:b2Vec2 = _thisPoint;
  301.                     var dx:Number = point2.x - point1.x;
  302.                     var dy:Number = point2.y - point1.y;
  303.                     var xx:Number = Math.abs(dx);
  304.                     var yy:Number = Math.abs(dy);
  305.                     var dist:Number = Math.sqrt(xx * xx + yy * yy);
  306.                     var radians:Number = Math.atan2(dy, dx);
  307.                     var degress:Number = radians / (Math.PI / 180);
  308.                     SetPosClipToVec2(_playerClip, point1);
  309.                     if (dist < _maxDistance) {
  310.                         if(!_inRubberZone){
  311.                             _inRubberZone = true;
  312.                             if (_pointsArray.length == 0) {
  313.                                 //gameState = GAME_INSLEEP;
  314.                                 //_sceneState = GAME_PAUSE;
  315.                                 var endClip:MovieClip = new EndBorderClip();
  316.                                 addChild(endClip);
  317.                                 SetPosClipToCustomPoint(endClip, sceneWidth / 2 ,sceneHeight / 2);
  318.                             }else
  319.                             {
  320.                                
  321.                             addListenerToPlayerClip();
  322.                            
  323.                             }
  324.                             SetPosPointB();
  325.                             cameraSetMove();
  326.                             //cameraSetPos();
  327.                         }
  328.                         /*SetPosClipToVec2(_rubberClip, point2);
  329.                         _rubberClip.scaleX = dist/_maxDistance;
  330.                         _rubberClip.rotation = degress;*/
  331.                     }else {
  332.                         if (_inRubberZone) {
  333.                              if (!_inRubberJoint) {
  334.                                 _inRubberJoint = true;
  335.                                 createCenterBody(point2);
  336.                                 var distanceJointDef: b2DistanceJointDef = new b2DistanceJointDef();
  337.                                 distanceJointDef.Initialize(_playerBody, _centerBody, _playerBody.GetWorldCenter(), _centerBody.GetWorldCenter());
  338.                                 distanceJointDef.frequencyHz = 1;
  339.                                 distanceJointDef.dampingRatio = 0;
  340.                                 _playerDistanceJoint = _world.CreateJoint(distanceJointDef) as b2DistanceJoint;
  341.                                 //trace("dist = " + dist);
  342.                                 _maxDistanceForJoint = _playerDistanceJoint.GetLength();
  343.                             } else {
  344.                                 //if (point1.y < point2.y) {
  345.                                     if(dist<_maxDistanceForJoint){
  346.                                         //trace("dist =" + dist + " maxDis =" + _maxDistanceForJoint);
  347.                                         destroyCenterBody();
  348.                                         destroyDistanceJoint();
  349.                                         //_world.DestroyJoint(_playerDistanceJoint);
  350.                                         _inRubberJoint = false;
  351.                                     }
  352.                                     if (point1.y < point2.y) {
  353.                                         _playerBody.ApplyForce(new b2Vec2(0, 6), _playerBody.GetWorldCenter());
  354.                                         //trace("apply");
  355.                                     }
  356.                                     //_inRubberZone = false;
  357.                                 //}
  358.                             }
  359.                             /*var velocity:b2Vec2 = _playerBody.GetLinearVelocity();
  360.                             //velocity.NegativeSelf();
  361.                             trace(velocity.Length());
  362.                             var add:Number = velocity.Length() / 2 / 1.5;
  363.                             _playerBody.SetLinearVelocity(new b2Vec2((point2.x - point1.x) * add, (point2.y - point1.y) * add));*/
  364.                         }else {
  365.                             if (dist > _maxDeadDistance) {
  366.                                 deadPlayer();
  367.                             }
  368.                         }
  369.                     }
  370.                     if (_inRubberZone) {
  371.                         SetPosClipToVec2(_rubberClip, point2);
  372.                         _rubberClip.scaleX = dist / _maxDistance;
  373.                         _rubberClip.rotation = degress;
  374.                     }
  375.                 }else {
  376.                     if (_gameState == GAME_INRUBBER) {
  377.                         var dxr:Number = _pointAClip.x - mouseX;
  378.                         var dyr:Number = _pointAClip.y - mouseY;
  379.                         var distr:Number = Math.sqrt(dxr * dxr + dyr * dyr);
  380.                         //dxr = Math.abs(dxr);
  381.                         //dyr = Math.abs(dyr);
  382.                         var radians1:Number = Math.atan2(dyr, dxr);
  383.                         var degress1:Number = radians1 / (Math.PI / 180);
  384.                         _rubberClip.rotation = degress1;
  385.                         _rubberClip.x = _pointAClip.x;
  386.                         _rubberClip.y = _pointAClip.y;
  387.                         if (distr < _maxRubberDistance) {
  388.                             _playerClip.x = mouseX;
  389.                             _playerClip.y = mouseY;
  390.                             _rubberClip.scaleX = (distr / PIXELS_TO_METRE) / (_maxDistance);
  391.                         }else {
  392.                             distr = _maxRubberDistance;
  393.                             _rubberClip.scaleX = 2;
  394.                             _playerClip.x = _rubberClip.x - Math.cos(radians1) * _maxRubberDistance;
  395.                             _playerClip.y = _rubberClip.y - Math.sin(radians1) * _maxRubberDistance;
  396.                         }
  397.                         _thisRubberDistance = distr;
  398.                         //trace(distr);
  399.                     }
  400.                 }
  401.                
  402.                
  403.             }else {//...иначе (если находимся "в паузе")..
  404.             }
  405.             if (_cameraMove) {
  406.                 var smovex:Boolean = false;
  407.                 var smovey:Boolean = false;
  408.                 var ddx:Number = (_thisPoint.x * PIXELS_TO_METRE - sceneWidth / 2) - _cameraPosX;
  409.                 var ddy:Number = (_thisPoint.y * PIXELS_TO_METRE - sceneHeight / 2) - _cameraPosY;
  410.                 if(!smovey){
  411.                     if (ddy > 4) {
  412.                         cameraMoveTo(0, 4);
  413.                     }else {
  414.                         if (ddy < -4) {
  415.                             cameraMoveTo(0, -4);
  416.                         }else {
  417.                             smovey = true;
  418.                         }
  419.                     }
  420.                 }
  421.                 if(!smovex){
  422.                     if (ddx > 4) {
  423.                         cameraMoveTo(4, 0);
  424.                     }else {
  425.                         if (ddx < -4) {
  426.                             cameraMoveTo(-4, 0);
  427.                         }else {
  428.                             smovex = true;
  429.                         }
  430.                     }
  431.                 }
  432.                 if ((smovey == true) && (smovex == true)) {
  433.                     trace(_cameraPosX + " " + _cameraPosY);
  434.                     trace("stop move camera");
  435.                     cameraSetPos();
  436.                     _cameraMove = false;
  437.                 }
  438.             }
  439.             var timeStep:Number = 1 / 30;
  440.             var velocityIterations:int = 6;
  441.             var positionIterations:int = 2;
  442.             _world.Step(timeStep,velocityIterations,positionIterations);
  443.             _world.ClearForces();
  444.             //_world.DrawDebugData();
  445.         }
  446.         //методы игрока
  447.         private function deadPlayer():void {
  448.             _pointsArray.push(_thisPoint);
  449.             _pointsArray.push(_oldPoint);
  450.             setToThisPoint();
  451.         }
  452.         private function setToThisPoint(newPoint:b2Vec2 = null, newVelocity:b2Vec2 = null):void {
  453.             _playerClip.gotoAndStop(1);
  454.             _thisPoint = _pointsArray.pop();
  455.             _gameState = GAME_INAIR;
  456.             //trace(mouseX + " " + mouseY);
  457.             destroyPlayerBody();
  458.             destroyCenterBody();
  459.             if(!newPoint){
  460.                 createPlayerBody(_thisPoint,newVelocity);
  461.                 trace("create array point");
  462.                 //cameraSetPos(_thisPoint);
  463.             }else {
  464.                 createPlayerBody(newPoint, newVelocity);
  465.                 trace("create new point");
  466.                 //cameraSetPos(_thisPoint);
  467.             }
  468.             //cameraSetPos();
  469.             setPosPointA();
  470.         }
  471.         private function setPosPointA():void {
  472.             SetPosClipToVec2(_pointAClip, _thisPoint);
  473.         }
  474.         private function SetPosPointB():void {
  475.             _nextPoint = _pointsArray.pop();
  476.             if (_nextPoint) {
  477.                 SetPosClipToVec2(_pointBClip,_nextPoint);
  478.             }else
  479.             {
  480.                 _nextPoint = _thisPoint;
  481.             }
  482.             _pointsArray.push(_nextPoint);
  483.         }
  484.         private function addListenerToPlayerClip():void {
  485.             _playerClip.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDownToPlayer);
  486.             addEventListener(MouseEvent.MOUSE_UP, onMouseUpToPlayer);
  487.         }
  488.         private function removeListenerToPlayerClip():void {
  489.             _playerClip.removeEventListener(MouseEvent.MOUSE_DOWN, onMouseDownToPlayer);
  490.             removeEventListener(MouseEvent.MOUSE_UP, onMouseUpToPlayer);
  491.         }
  492.         //методы создания объектов Box2D
  493.         private function createBlockBody(pos:b2Vec2,size:Number):b2Body {
  494.             var _blockBodyDef:b2BodyDef = new b2BodyDef();
  495.             _blockBodyDef.type = b2Body.b2_staticBody;
  496.             _blockBodyDef.position = pos;
  497.             var _blockBody:b2Body = _world.CreateBody(_blockBodyDef);
  498.             var _blockBodyShape:b2PolygonShape = new b2PolygonShape;
  499.             _blockBodyShape.SetAsBox(size / 2, 0.5)
  500.             var _blockBodyFixture:b2FixtureDef = new b2FixtureDef();
  501.             _blockBodyFixture.shape = _blockBodyShape;
  502.             _blockBodyFixture.friction = 1.0;
  503.             _blockBodyFixture.density = 1.0;
  504.             _blockBody.CreateFixture(_blockBodyFixture);
  505.             return _blockBody;
  506.         }
  507.         private function removeAllDynamicsObject():void {
  508.             _gameState = GAME_INRUBBER;
  509.             _inRubberJoint = false;
  510.             _inRubberZone = false;
  511.             destroyDistanceJoint();
  512.             destroyCenterBody();
  513.             destroyPlayerBody();
  514.         }
  515.         private function createPlayerBody(pos:b2Vec2,vel:b2Vec2 = null):void {
  516.             _inRubberZone = false;
  517.             _inRubberJoint = false;
  518.             if(!_playerBodyDef){
  519.                 _playerBodyDef = new b2BodyDef();
  520.                 _playerBodyDef.type = b2Body.b2_dynamicBody;
  521.             }
  522.             _playerBodyDef.position = pos;
  523.             _playerBody = _world.CreateBody(_playerBodyDef);
  524.             if (!_playerBodyShape) {
  525.                 _playerBodyShape = new b2CircleShape(0.5);
  526.             }
  527.             if (!_playerBodyFixtureDef) {
  528.                 _playerBodyFixtureDef = new b2FixtureDef();
  529.                 _playerBodyFixtureDef.shape = _playerBodyShape;
  530.                 _playerBodyFixtureDef.density = 1;
  531.                 _playerBodyFixtureDef.friction = 1;
  532.                 _playerBodyFixtureDef.restitution = 0.8;
  533.                 _playerBodyFixtureDef.filter.groupIndex = -1;
  534.             }
  535.             _playerBody.CreateFixture(_playerBodyFixtureDef);
  536.             if(vel){
  537.                 _playerBody.SetLinearVelocity(vel);
  538.             }
  539.            
  540.         }
  541.         private function createCenterBody(pos:b2Vec2):void {
  542.             if (!_centerBodyDef) {
  543.                 _centerBodyDef = new b2BodyDef;
  544.                 _centerBodyDef.type = b2Body.b2_staticBody;
  545.             }
  546.             _centerBodyDef.position = pos;
  547.             _centerBody = _world.CreateBody(_centerBodyDef);
  548.             if (!_centerBodyShape) {
  549.                 _centerBodyShape = new b2CircleShape(0.1);
  550.             }
  551.             if (!_centerBodyFixture) {
  552.                 _centerBodyFixture = new b2FixtureDef();
  553.                 _centerBodyFixture.shape = _centerBodyShape;
  554.                 _centerBodyFixture.density = 1;
  555.                 _centerBodyFixture.friction = 1;
  556.                 _centerBodyFixture.restitution = 0.8;
  557.                 _centerBodyFixture.filter.groupIndex = -1;
  558.             }
  559.             _centerBody.CreateFixture(_playerBodyFixtureDef);
  560.         }
  561.         private function destroyDistanceJoint():void {
  562.             if (_playerDistanceJoint) {
  563.                 _world.DestroyJoint(_playerDistanceJoint);
  564.             }
  565.             _playerDistanceJoint = null;
  566.         }
  567.         private function destroyPlayerBody() {
  568.             if (_playerBody) {
  569.                 _world.DestroyBody(_playerBody);
  570.             }
  571.             _playerBody = null;
  572.         }
  573.         private function destroyCenterBody():void {
  574.             if (_centerBody) {
  575.                 _world.DestroyBody(_centerBody);
  576.             }
  577.             _centerBody = null;
  578.         }
  579.         //методы для отладки
  580.         private function SetPosClipToVec2(clip:MovieClip, pos:b2Vec2):void {
  581.             clip.x = pos.x * PIXELS_TO_METRE - (_cameraPosX);
  582.             clip.y = pos.y * PIXELS_TO_METRE - (_cameraPosY);
  583.         }
  584.         private function SetPosClipToCameraCenter(clip:MovieClip):void {//метод устанавливает положение клипа за сценной (используется для отладки и для объектов которые уже созданные но не используются в игровом процессе)
  585.             clip.x = sceneWidth / 2;//позиция клипа по оси х
  586.             clip.y = sceneHeight / 2;//позиция клипа по оси у
  587.         }
  588.         private function SetPosClipToOverCamera(clip:MovieClip):void {//метод устанавливает положение клипа за сценной (используется для отладки и для объектов которые уже созданные но не используются в игровом процессе)
  589.             clip.x = -100;//позиция клипа по оси х
  590.             clip.y = -100;//позиция клипа по оси у
  591.         }
  592.         private function SetPosClipToCustomPoint(clip:MovieClip, x:Number=0, y:Number=0):void {//метод устанавливает позицию клипа в зависимости от введенных координат
  593.             clip.x = x;//позиция клипа по оси х
  594.             clip.y = y;//позиция клипа по оси у
  595.         }
  596.         //другие методы
  597.         private function addBlockToScene(pos:b2Vec2, size:Number):void {
  598.             var _blockBody:b2Body = createBlockBody(pos, size);
  599.             var _blockClip:MovieClip = createBlockClip(pos, size);
  600.             _blockBodysArray.push(_blockBody);
  601.             _blocksClipsArray.push(_blockClip);
  602.         }
  603.         private function createBlockClip(pos:b2Vec2, size:Number):BlockClip {
  604.             var newBlock:BlockClip = new BlockClip(size);
  605.             addChild(newBlock);
  606.             SetPosClipToVec2(newBlock,pos);
  607.             return newBlock;
  608.         }
  609.         private function coordToB2Vec2(x:Number, y:Number):b2Vec2 {
  610.             var xx:Number = (_cameraPosX + x) / PIXELS_TO_METRE;
  611.             var yy:Number = (_cameraPosY + y) / PIXELS_TO_METRE;
  612.             //trace("x= " + xx + " y=" + yy);
  613.             return new b2Vec2(xx, yy);
  614.         }
  615.         private function createFloor():void {
  616.             var floorDef:b2BodyDef = new b2BodyDef();
  617.             floorDef.type = b2Body.b2_staticBody;
  618.             floorDef.position.Set((sceneWidth / 2) / PIXELS_TO_METRE, (sceneHeight - 20) / PIXELS_TO_METRE);
  619.             var floorBody = _world.CreateBody(floorDef);
  620.             var floorShape:b2PolygonShape = new b2PolygonShape();
  621.             floorShape.SetAsBox(sceneWidth / PIXELS_TO_METRE, 1);
  622.             var floorFixtureDef:b2FixtureDef = new b2FixtureDef();
  623.             floorFixtureDef.shape = floorShape;
  624.             floorFixtureDef.friction = 1;
  625.             floorFixtureDef.density = 1;
  626.             floorBody.CreateFixture(floorFixtureDef);
  627.         }
  628.     }
  629. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement