2013-04-05 1 views
0

두 가지 컨트롤이있는 starling 게임을 개발 중입니다. 하나는 화면의 왼쪽에있는 아무 곳이나 손을 대고있는 왼쪽 사용자 들이며, 문자는 y 축을 위아래로 드래그합니다. 구현에 어려움을 겪고있는 다른 컨트롤은 화면의 오른쪽 하단에있는 하나의 버튼으로 캐릭터의 총알이 총알이됩니다.starling에서 터치 컨트롤을 어떻게 설정해야합니까?

제 질문은 버튼을 누를 때마다 문자가 화면 맨 아래로 뛰어 오르지 않고 어떻게 설정해야합니까?

이 기능을 사용하려면 멀티 터치를해야합니까?

더 구체적인 질문은 starling에 스프라이트에 대한 사각형을 정의하는 방법입니다. 찌르레기는 더 드로잉 API가 없기 때문에, 그냥

 touchLayer.graphics.beginFill(0x000000, 0); 
     touchLayer.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight); 
     touchLayer.graphics.endFill(); 

가 현재 내 캐릭터 드래그 노력하고 있습니다 ...이 작업을 수행 할 수 있지만 터치는 그냥 왼쪽 확인하지 않는 방법 화면 (IM 곳곳에 등록 화면의 측면 ...)

아무쪼록 잘 부탁드립니다. 감사합니다.

다음은 InGame 클래스의 전체 코드입니다.

package screens 
{ 
    import flash.geom.Point; 
    import flash.geom.Rectangle; 
    import flash.utils.getTimer; 

    import objects.Enemy; 
    import objects.GameBackground; 
    import objects.Laser; 
    import objects.Scarlet; 
    import objects.SnowBall; 

    import starling.display.Button; 
    import starling.display.Sprite; 
    import starling.events.Event; 
    import starling.events.Touch; 
    import starling.events.TouchEvent; 
    import starling.utils.RectangleUtil; 
    import starling.utils.deg2rad; 

    public class InGame extends Sprite 
    { 
     private var startBtn:Button; 
     private var fireBtn:Button; 
     private var bg:GameBackground; 
     private var scarlet:Scarlet; 

     private var enemies:Array; 
     private var lasers:Array; 
     private var scarletLocation:Point; 

     private var lasersLayer:Sprite; 
     private var enemiesLayer:Sprite; 
     private var touchLayer:Sprite; 

     private var enemySpawnDelay:Number; 
     private var enemySpawnCounter:Number; 

     private var difficulty:Number; 
     private var difficultyRate:Number; 

     private var timePrevious:Number; 
     private var timeCurrent:Number; 
     private var elapsed:Number; 

     private var gameState:String; 
     private var playerSpeed:Number; 
     private const MIN_SPEED:Number = 650; 

     //private var scoreDistance:int; 

     private var gameArea:Rectangle; 
     private var touchArea:Rectangle; 
     private var shape:starling.display.Sprite = new starling.display.Sprite(); 

     private var target:Point = new Point(100, 100); 

     private var touch:Touch; 
     private var touchX:Number; 
     private var touchY:Number; 

     public function InGame() 
     { 
      super(); 
      this.addEventListener(starling.events.Event.ADDED_TO_STAGE, onAddedToStage); 
     } 

     private function onAddedToStage(event:Event):void 
     { 
      this.removeEventListener(Event.ADDED_TO_STAGE, onAddedToStage); 
      drawGame(); 
     } 

     private function drawGame():void 
     { 
      bg = new GameBackground(); 
      this.addChild(bg); 

      scarlet = new Scarlet; 
      scarlet.x = stage.stageWidth/2; 
      scarlet.y = stage.stageHeight/2; 
      this.addChild(scarlet); 

      startBtn = new Button(Assets.getTexture("PlayBtn")); 
      startBtn.x = stage.stageWidth * 0.5 - startBtn.width * 0.5; 
      startBtn.y = stage.stageHeight * 0.5 - startBtn.height * 0.5 + 35; 
      this.addChild(startBtn); 

      fireBtn = new Button(Assets.getTexture("FireBtn")); 
      fireBtn.x = 675; 
      fireBtn.y = 435; 
      this.addChild(fireBtn); 

      //defines area scarlet can fly in 
      gameArea = new Rectangle(0, 15, stage.stageWidth, stage.stageHeight - 150); 
     } 

     public function disposeTemporarily():void 
     { 
      this.visible = false; 
     } 

     public function initialize():void 
     { 
      this.visible = true; 

      this.addEventListener(Event.ENTER_FRAME, checkElapsed); 

      scarlet.x = -stage.stageWidth; 
      scarlet.y = stage.stageHeight * 0.5; 

      gameState = "idle"; 

      playerSpeed = 0; 

      difficultyRate = 0.3; 
      difficulty = 1; 
      enemySpawnDelay = enemySpawnCounter = 100; 

      enemies = new Array(); 
      lasers = new Array(); 

      scarletLocation = new Point(200, 400); 

      addEventListener(Event.ENTER_FRAME, update); 

      lasersLayer = new Sprite(); 
      enemiesLayer = new Sprite(); 
      touchLayer = new Sprite(); 

      addChild(lasersLayer); 
      addChild(enemiesLayer); 
      addChild(touchLayer); 

      addEventListener(Event.ADDED_TO_STAGE, setupTouchLayer); 
      touchLayer.addEventListener(Event.TRIGGERED, shootLaser); 

      //scoreDistance = 0; 

      startBtn.addEventListener(Event.TRIGGERED, onStartBtnClick); 

      this.addEventListener(TouchEvent.TOUCH, onTouch); 
     } 

     private function onStartBtnClick(event:Event):void 
     { 
      startBtn.visible = false; 
      startBtn.removeEventListener(Event.TRIGGERED, onStartBtnClick); 

      launchScarlet(); 
     } 

     private function launchScarlet():void 
     { 
      this.addEventListener(TouchEvent.TOUCH, onTouch); 
      this.addEventListener(Event.ENTER_FRAME, onGameTick); 
     } 

     private function onTouch(event:TouchEvent):void 
     { 
      touch = event.getTouch(stage); 

      touchX = touch.globalX; 
      touchY = touch.globalY; 

      target.x = event.touches[0].globalX; 
      target.y = event.touches[0].globalY; 
     } 

     private function onGameTick(event:Event):void 
     { 
      switch(gameState) 
      { 
       case"idle": 
        //Take off 
        if (scarlet.x < stage.stageWidth * 0.5 * 0.5) 
        { 
         scarlet.x += ((stage.stageWidth * 0.5 * 0.5 + 10) - scarlet.x) * 0.5; 
         scarlet.y = stage.stageHeight * 0.5; 

         playerSpeed += (MIN_SPEED - playerSpeed) * 0.05; 
        } 
        else 
        { 
         gameState = "flying"; 
        } 
        break; 
       case"flying": 
        playerSpeed -= (playerSpeed - MIN_SPEED) * 0.01; 

        scarlet.y -= (scarlet.y - touchY) * 0.1; 

        if (-(scarlet.y - touchY) < 150 && -(scarlet.y - touchY) > -150) 
        { 
         scarlet.rotation = deg2rad(-(scarlet.y - touchY) * 0.075); 
        } 

        if (scarlet.y > gameArea.bottom - scarlet.height * 0.5) 
        { 
         scarlet.y = gameArea.bottom - scarlet.height * 0.5; 
         scarlet.rotation = deg2rad(0); 
        } 
        if (scarlet.y < gameArea.top + scarlet.height * 0.5) 
        { 
         scarlet.y = gameArea.top + scarlet.height * 0.5; 
         scarlet.rotation = deg2rad(0); 
        } 

        //scoreDistance += (playerSpeed * elapsed) * 0.1; 
        //trace(scoreDistance); 

        break; 
       case"over": 
        break; 
      } 
     } 

     //addapted from "Shoot" 
     private function setupTouchLayer(event:Event):void 
     { 
      touchLayer.graphics.beginFill(0x000000, 0); 
      touchLayer.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight); 
      touchLayer.graphics.endFill(); 

      touchArea = new Rectangle(0, 0, stage.stageWidth, stage.stageHeight); 
     } 

     private function shootLaser(event:TouchEvent):void 
     { 
      makeLaser(scarletLocation); 
     } 

     private function makeLaser(scarletLocation:Point):void 
     { 
      var newLaser:Laser = new Laser(); 

      newLaser.x = scarletLocation.x; 
      newLaser.y = scarletLocation.y; 

      newLaser.xVel = 5; 
      newLaser.yVel = 5; 

      newLaser.addEventListener(Laser.PURGE_EVENT, purgeLaserHandler); 

      lasersLayer.addChild(newLaser); 
      lasers.push(newLaser); 
     } 

     private function purgeLaserHandler(event:Event):void 
     { 
      var targetLaser:Laser = Laser(event.target); 
      purgeLaser(targetLaser); 
     } 

     private function purgeLaser(targetLaser:Laser):void 
     { 
      targetLaser.removeEventListener(Laser.PURGE_EVENT, purgeLaserHandler); 
      try 
      { 
       var i:int; 
       for (i = 0; i < lasers.length; i++) 
       { 
        if (lasers[i].name == targetLaser.name) 
        { 
         lasers.splice(i, 1); 
         lasersLayer.removeChild(targetLaser); 
         i = lasers.length; 
        } 
       } 
      } 
      catch(e:Error) 
      { 
       trace("Failed to delete laser!", e); 
      } 
     } 

     private function makeEnemies():void 
     { 
      enemySpawnCounter++; 

      if (enemySpawnCounter > enemySpawnDelay) 
      { 
       enemySpawnCounter = 0; 
       enemySpawnDelay -= difficultyRate; 
       difficulty += difficultyRate; 
       makeEnemy(); 
      } 
     } 

     private function makeEnemy():void 
     { 

      var i:int; 
      for (i = 0; i < Math.floor(difficulty); i++) 
      { 
       var newEnemy:Enemy = new SnowBall(); 

       newEnemy.x = 925; 
       newEnemy.y = Math.random() * 375 + 50; 
       //trace(newEnemy.x); trace(newEnemy.y); 
       newEnemy.xVel = (-Math.random() * difficulty) - 5; 
       newEnemy.sinMeter = Math.random() * 10; 
       newEnemy.bobValue = Math.random() * difficulty; 

       newEnemy.addEventListener(Enemy.PURGE_EVENT, purgeEnemyHandler); 

       enemiesLayer.addChild(newEnemy); 
       enemies.push(newEnemy); 
      } 
     } 

     private function purgeEnemyHandler(event:Event):void 
     { 
      var targetEnemy:Enemy = Enemy(event.target); 
      purgeEnemy(targetEnemy); 
     } 

     private function purgeEnemy(targetEnemy:Enemy):void 
     { 
      targetEnemy.removeEventListener(Enemy.PURGE_EVENT, purgeLaserHandler); 
      try 
      { 
       var i:int; 
       for (i = 0; i < enemies.length; i++) 
       { 
        if (enemies[i].name == targetEnemy.name) 
        { 
         enemies.splice(i, 1); 
         enemiesLayer.removeChild(targetEnemy); 
         i = enemies.length; 
        } 
       } 
      } 
      catch(e:Error) 
      { 
       trace("Failed to delete enemy!", e); 
      } 
     } 

     private function newHitTest(laser:Laser):void 
     { 
      for each (var enemy:Enemy in enemies) 
      { 
       if (enemy.status != "Dead" && enemy.hitTest(new Point(laser.x, laser.y))) 
       { 
        enemy.destroy(); 
        purgeLaser(laser); 
       } 
      } 
     } 

     private function checkElapsed(event:Event):void 
     { 
      timePrevious = timeCurrent; 
      timeCurrent = getTimer(); 
      elapsed = (timeCurrent - timePrevious) * 0.001; 
     } 

     private function update():void 
     { 
      //trace(enemies.length, lasers.length); 

      for each (var enemy:Enemy in enemies) 
      { 
       enemy.update(); 
      } 

      for each (var laser:Laser in lasers) 
      { 
       laser.update(); 
       newHitTest(laser); 
      } 

      makeEnemies(); 
     } 
     //addapted from "Shoot" 
    } 
} 
+0

코드를 붙여주세요. 조금 혼란 스럽습니다. – Vipul

+0

확실, 내 게시물을 업데이트했습니다. – user2113538

답변

0

오 와우,이 문제를 해결하는 아주 간단한 방법은 단순히 멀티 터치를 가능하게하는 것입니다.

  Starling.multitouchEnabled = true; 

그러나이 아직도 내가 ... 캐릭터를 제어하기 위해 이미 진짜로을 화면을하지 닿지 않도록하고 만약 내가 오른쪽 하단에있는 버튼을 누르면 화면 하단에 뛰어 내 캐릭터의 문제를 잎 큰 일이지만 이런 일이 발생하지 않으면 더 나아질 것입니다.