Button 我应该如何在starling设置触摸控制？

我正在开发一个有两个控件的starling游戏。一种是用户的左手拇指触摸屏幕左侧的任何位置，从而在y轴上下拖动角色。另一个我很难实现的控件是屏幕右下角的一个按钮，它会让角色发射子弹

我的问题是，当按下按钮时，如何在不让角色跳到屏幕底部的情况下进行设置

我是否需要使用multi-touch来运行此功能

我有一个更具体的问题，那就是如何为八哥中的精灵定义一个矩形？因为starling没有绘图API，所以我不能这么做

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

目前，我的角色拖动功能正常，但触摸在屏幕上随处可见（我不知道如何使它只出现在屏幕的左侧…）

任何建议都将不胜感激，谢谢

这是我的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"
    }
}

包屏幕
{
导入flash.geom.Point；
导入flash.geom.Rectangle；
导入flash.utils.getTimer；
进口物品。敌人；
导入objects.GameBackground；
输入物体。激光；
进口物品。鲜红；
导入objects.SnowBall；
导入starling.display.Button；
导入starling.display.Sprite；
导入starling.events.Event；
导入starling.events.Touch；
导入starling.events.TouchEvent；
导入starling.utils.RectangleUtil；
进口starling.utils.deg2rad；
公共类InGame扩展了Sprite
{
专用var startBtn：按钮；
私有var fireBtn：按钮；
私有变量bg：游戏背景；
斯佳丽：斯佳丽；
私人敌人：阵列；
专用var激光器：阵列；
地点：点；
私人激光层：雪碧；
私人杀手：精灵；
私人接触层：精灵；
私有var enemySpawnDelay:编号；
private var enemyspawincounter:Number；
私人var难度：数字；
私有var困难酸盐：数量；
private-var-timePrevious：编号；
专用var时间电流：数字；
私有变量：数字；
私有var游戏状态：字符串；
私人var播放器速度：数字；
私人施工最小速度：编号=650；
//私人距离：int；
私有区域：矩形；
私有区域：矩形；
私有变量形状：starling.display.Sprite=新的starling.display.Sprite（）；
私有var目标：点=新点（100100）；
私人触摸：触摸；
私有变量x：数字；
私有变量touchY：数字；
公共职能
{
超级（）；
此.addEventListener（starling.events.Event.ADDED_至_阶段，OnAddedStatage）；
}
AddedStatage上的私有函数（事件：事件）：void
{
此.removeEventListener（Event.ADDED_至_阶段，OnAddedStatage）；
drawGame（）；
}
私有函数drawGame（）：void
{
bg=新游戏背景（）；
这是addChild（bg）；
猩红色=新的猩红色；
scarlet.x=stage.stageWidth/2；
scarlet.y=stage.stageHeight/2；
这是addChild（scarlet）；
startBtn=new按钮（Assets.getTexture（“PlayBtn”）；
startBtn.x=舞台宽度*0.5-舞台宽度*0.5；
起始高度y=舞台高度*0.5-起始高度*0.5+35；
本.addChild（startBtn）；
fireBtn=新按钮（Assets.getTexture（“fireBtn”）；
fireBtn.x=675；
fireBtn.y=435；
这个.addChild（fireBtn）；
//定义scarlet可以飞入的区域
游戏区域=新矩形（0,15，stage.stageWidth，stage.stageHeight-150）；
}
公共函数临时处置（）：无效
{
可见=假；
}
公共函数初始化（）：void
{
可见=真实；
this.addEventListener（Event.ENTER_FRAME，checkAppeased）；
scarlet.x=-stage.stageWidth；
scarlet.y=舞台高度*0.5；
gameState=“空闲”；
playerSpeed=0；
硬脂酸盐=0.3；
难度=1；
enemySpawnDelay=enemySpawnCounter=100；
敌人=新阵列（）；
激光器=新阵列（）；
ScarlettLocation=新点（200400）；
addEventListener（Event.ENTER_FRAME，update）；
LaserLayer=新精灵（）；
enemiesLayer=新精灵（）；
touchLayer=新精灵（）；
addChild（激光层）；
addChild（敌人杀手）；
addChild（touchLayer）；
addEventListener（Event.ADDED_至_阶段，setupTouchLayer）；
touchLayer.addEventListener（事件触发，shootLaser）；
//得分距离=0；
startBtn.addEventListener（Event.TRIGGERED，onStartBtnClick）；
this.addEventListener（TouchEvent.TOUCH，onTouch）；
}
启动时的专用函数单击（事件：事件）：无效
{
startBtn.visible=假；
startBtn.removeEventListener（Event.TRIGGERED，onStartBtnClick）；
启动Scarlet（）；
}
私有函数launchScarlet（）：void
{
this.addEventListener（TouchEvent.TOUCH，onTouch）；
this.addEventListener（Event.ENTER_FRAME，onGameTick）；
}
私有函数onTouch（事件：TouchEvent）：无效
{
touch=event.getTouch（舞台）；
touchX=touch.globalX；
touchY=touch.globalY；
target.x=event.touchs[0].globalX；
target.y=event.touchs[0].globalY；
}
私有函数onGameTick（事件：事件）：无效
{
开关（游戏状态）
            Starling.multitouchEnabled = true;