public void HandleMultiTouch(FTouch[] touches)
    {
        foreach(FTouch touch in touches)
        {
            if(touch.phase == TouchPhase.Began)
            {

                //we go reverse order so that if we remove a banana it doesn't matter
                //and also so that that we check from front to back

                for (int b = _bananas.Count-1; b >= 0; b--)
                {
                    BBanana banana = _bananas[b];

                    Vector2 touchPos = banana.GlobalToLocal(touch.position);

                    if(banana.textureRect.Contains(touchPos))
                    {
                        HandleGotBanana(banana);
                        break; //break so that a touch can only hit one banana at a time
                    }
                }
            }
        }
    }

 public void HandleMultiTouch(FTouch[] touches)
 {
     foreach(FTouch touch in touches)
     {
         if (touch.phase == TouchPhase.Ended) {
             if (_draw!=null) {
                 _draw.RemoveFromContainerAnimated();
                 _draw=null;
             }
         } else if (touch.phase == TouchPhase.Began) {
             if (_draw==null) {
                 float c0=RXRandom.Float();
                 float c1=RXRandom.Float();
                 float c2=RXRandom.Float();
                 float c3=RXRandom.Float();
                 float c4=RXRandom.Float();
                 float c5=RXRandom.Float();
                 _draw = new FMotionStreakWithBorderSprite("Futile_White", // texture name
                     10+RXRandom.Int(20),  //Number of quads in the trail
                     x => 15.0f*(float)Math.Sin (1.0f*x*x*x*Math.PI),  // width of the band function, x represents the offset in the band and 0<= x <=1
                     x => new Color(c0,c1,c2,(float)Math.Sin (1.0f*x*Math.PI)),  //color of the band function, x represents the offset in the band and 0<= x <=1
                     x => 10f*(float)Math.Sin (1.0f*x*Math.PI),
                     x => new Color(c3,c4,c5,(float)Math.Sin (1.0f*x*Math.PI))
                     );
                 AddChild(_draw);
             }
             _draw.PushPosition(touch.position);
         } else if (touch.phase == TouchPhase.Moved) {
             if (_draw!=null) _draw.PushPosition(touch.position);
         }
     }
 }

 public void HandleMultiTouch(FTouch[] touches)
 {
     foreach(FTouch touch in touches){
         if(touch.phase == TouchPhase.Ended){
         }
     }
 }

 public void HandleMultiTouch(FTouch[] touches)
 {
     if (touches.Length > 0){
         touchPos = touches[0].position;
     }
     if (touches.Length > 1){
         shoot();
     }
 }

 public void HandleMultiTouch(FTouch[] touches)
 {
     foreach(FTouch touch in touches)
     {
         if (touch.phase == TouchPhase.Ended) {
             TestSpeechBubbles(touch.position);
         }
     }
 }

 public void HandleMultiTouch(FTouch[] touches)
 {
     foreach(FTouch touch in touches)
     {
         if (touch.phase == TouchPhase.Ended) {
             //Click(touch.position);
         }
     }
 }

 public void HandleMultiTouch(FTouch[] touches)
 {
     foreach(FTouch touch in touches)
     {
         if (touch.phase == TouchPhase.Ended) {
             ChangeSplitRatio(touch.position);
         } else if (touch.phase == TouchPhase.Moved) {
             ChangeSplitRatio(touch.position);
         }
     }
 }

 public bool HandleSingleTouchBegan(FTouch touch)
 {
     if (this.selectedActor != null && this.selectedActor.TurnState == ActorState.AwaitingCommand)
     {
         return false;
     }
     else
     {
         return true;
     }
 }

    public void HandleSingleTouchMoved(FTouch touch)
    {
        rejector++;

        if(rejector > 0) // Nevermind this. I'm trying to figure out why touches cause lag on android
        {
            float xPos = mBombaNode.GlobalToLocal(touch.position).x;

            mPepper.setPosition(xPos);
            rejector = 0;
        }
    }

    public bool HandleSingleTouchBegan(FTouch touch)
    {
        foreach (FSprite sprite in compartmentSprites) {
            /*if (sprite.textureRect.Contains(sprite.GlobalToLocal(touch.position))) {
                if (sprite.color == Color.blue) sprite.color = Color.red;
                else sprite.color = Color.blue;
            }*/
            Debug.Log(sprite.textureRect);
            //Debug.Log(sprite.element.atlas.texture.GetPixel((int)touch.position.x, (int)touch.position.y));
        }

        return true;
    }

    public virtual bool HandleSingleTouchBegan(FTouch touch)
    {
        Vector2 touchPos = base.GetLocalTouchPosition(touch);

        if (_hitRect.Contains(touchPos))
        {
            indicatorValue = Mathf.Abs((base.x - _hitRect.width / 2) - _movableIndicator.x) / _hitRect.width;
            _movableIndicator.x = Mathf.Clamp(LocalToGlobal(touchPos).x, (base.x - _hitRect.width / 2) + _movableIndicator.width / 2, (base.x + _hitRect.width / 2) - _movableIndicator.width / 2);
            return true;
        }

        return false;
    }

    public void HandleMultiTouch(FTouch[] touches)
    {
        foreach(FTouch touch in touches)
        {
            {

                //we go reverse order so that if we remove a banana it doesn't matter
                //and also so that that we check from front to back
                terrain.Update((this.GetLocalTouchPosition(touch)));
            terrain.RemoveTiles();

            }
        }
    }

    public void HandleSingleTouchEnded(FTouch touch)
    {
        var gridVector = this.map.GlobalToGrid(touch.position);
        Debug.Log("Touch at: " + touch.position + ", map grid: " + gridVector);

        if (this.selectedActor != null)
        {
            var actorState = this.selectedActor.TurnState;
            if (actorState == ActorState.SelectingDestination)
            {
                if (this.pathfindResults != null && this.pathfindResults.VisitablePoints.Contains(gridVector))
                {
                    this.selectedActor.HasMovedThisTurn = true;
                    this.selectedActor.TurnState = ActorState.AwaitingCommand;
                    this.map.UpdateLocation(this.selectedActor, gridVector);

                    // Recompute the set of attackable points, since the actor has moved.
                    var tempEnum = MoveAndAttackHelper.GetAttackablePoints(this.map, gridVector, 1, 6);
                    this.localAttackablePoints = new HashSet<Vector2i>(tempEnum);
                    this.showButtonStrip(this.selectedActor);
                    this.clearHighlights();
                }
            }
            else if(actorState == ActorState.SelectingEnemy)
            {
                if (this.localAttackablePoints.Contains(gridVector))
                {
                    Debug.Log("Attacking point: " + gridVector);
                    Vector2 source = new Vector2(this.selectedActor.x, this.selectedActor.y);
                    Vector2 dest = this.map.GridToGlobal(gridVector);
                    this.ShootLaser(source, dest);
                }
            }
        }
        else if (this.map.TryGetActor(gridVector, out this.selectedActor))
        {
            var actorState = this.selectedActor.TurnState;
            if (actorState == ActorState.TurnStart)
            {
                this.selectedActor.TurnState = ActorState.AwaitingCommand;
                this.pathfindResults = MoveAndAttackHelper.Pathfind(this.map, this.selectedActor);
                var tempEnum = MoveAndAttackHelper.GetAttackablePoints(this.map, gridVector, 1, 6);
                this.localAttackablePoints = new HashSet<Vector2i>(tempEnum);
                this.showButtonStrip(this.selectedActor);
            }
        }
    }

    public virtual void HandleTouch(FTouch touch)
    {
        Vector2 touchPos = this.GlobalToLocal(touch.position);

        Rect expandedRect = _hitRect.CloneWithExpansion(expansionAmount);

        if (expandedRect.Contains(touchPos))
        {
            if (!continuousTouch) {
                if (touch.phase != TouchPhase.Began) {
                    return;
                }
            }
            if (SignalPress != null) SignalPress();
            alpha = 1f;
        }
    }

    public void HandleMultiTouch(FTouch[] touches)
    {
        foreach(FTouch touch in touches) {
            if (touch.phase == TouchPhase.Began) {
                for (int i = thingies.Count - 1; i >= 0; i--) {
                    Thingy thingy = thingies[i];
                    FSprite sprite = thingy.GetChildAt(0) as FSprite;
                    Vector2 touchPos = sprite.GlobalToLocal(touch.position);
                    Rect rect = sprite.textureRect;

                    if (rect.Contains(touchPos)) {
                        HandleGotThingy(thingy);
                        break;
                    }
                }
            }
        }
    }

    public void HandleMultiTouch(FTouch[] touches)
    {
        foreach(FTouch touch in touches)
        {
            {

                if((this.localRect.CloneAndMultiply(4)).Contains(this.GetLocalTouchPosition(touch))) {
                    p = touch.position;
                    p = Vector3.Max(p, new Vector3(-Futile.screen.halfWidth+32, -Futile.screen.halfHeight + 32, 0));
                    p = Vector3.Min(p, new Vector3(Futile.screen.halfWidth-32, Futile.screen.halfHeight - 32, 0));
                    float dist = Vector2.Distance(new Vector2(this.x, this.y), new Vector2(p.x, p.y));

                    Go.killAllTweensWithTarget(this);
                    Go.to(this, 1.0f / dist, new TweenConfig().floatProp("x", p.x).floatProp("y", p.y));
                    break;
                }

            }
        }
    }

    public virtual void HandleSingleTouchEnded(FTouch touch)
    {
        Vector2 touchPos = base.GetLocalTouchPosition(touch);

        //expand the hitrect so that it has more error room around the edges
        //this is what Apple does on iOS and it makes for better usability
        Rect expandedRect = _hitRect.CloneWithExpansion(expansionAmount);

        if (expandedRect.Contains(touchPos))
        {
            if (SignalRelease != null) SignalRelease();
            indicatorValue = Mathf.Abs((base.x - _hitRect.width / 2) - _movableIndicator.x) / _hitRect.width;
            _movableIndicator.x = Mathf.Clamp(LocalToGlobal(touchPos).x, (base.x - _hitRect.width / 2) + _movableIndicator.width / 2, (base.x + _hitRect.width / 2) - _movableIndicator.width / 2);
            indicatorValue = indicatorValue >= 0.92 ? indicatorValue + 0.1f : indicatorValue;
            indicatorValue = Mathf.Clamp(indicatorValue, 0, 1);
        }
        else
        {
        }
    }

    public void HandleMultiTouch(FTouch[] touches)
    {
        foreach(FTouch touch in touches)
        {
            if (touch.phase == TouchPhase.Ended) {
                if (_draw!=null) {
                    _draw.Flush();
                }
            } else if (touch.phase == TouchPhase.Began) {
                if (_draw!=null) {
                    _draw.RemoveFromContainer();
                    _draw=null;
                }
                _draw=new FDrawingSprite("Futile_White");
                AddChild(_draw);

                _draw.SetLineThickness(RXRandom.Range(4f,10f));
                Color color=RandomUtils.RandomColor();
                color.a=1f;
                _draw.SetLineColor(color);

                _draw.PushBorder (RXRandom.Range(2f,5f),RandomUtils.RandomColor(),RXRandom.Float()<0.5f?true:false);
                _draw.PushTopBorder (RXRandom.Range(2f,5f),RandomUtils.RandomColor(),RXRandom.Float()<0.5f?true:false);
                //_draw.PushBorder (4,new Color(1f,1f,0f,1f),false);
                if (RXRandom.Float()<0.5f) {
                    _draw.PushBorder (RXRandom.Range(1f,4f),RandomUtils.RandomColor(),RXRandom.Float()<0.5f?true:false);
                    if (RXRandom.Float()<0.5f) {
                        _draw.PushBorder (RXRandom.Range(1f,4f),RandomUtils.RandomColor(),RXRandom.Float()<0.5f?true:false);
                        if (RXRandom.Float()<0.5f) {
                            _draw.PushBorder (RXRandom.Range(1f,4f),RandomUtils.RandomColor(),RXRandom.Float()<0.5f?true:false);
                        }
                    }
                }

                _draw.MoveTo(touch.position.x,touch.position.y);
            } else if (touch.phase == TouchPhase.Moved) {
                if (_draw==null) return;
                _draw.LineTo(touch.position.x,touch.position.y);
            }
        }
    }

    public override void onUpdate(FTouch[] touches)
    {
        //If not starting
        if (m_StartTime > START_DURATION) {
            //Manage blinking
            m_Time -= Time.deltaTime;
            m_Instruction1.isVisible = m_Time > BLINK_DURATION;
            if (m_Time < 0) m_Time += BLINK_DURATION * 2;

            //if game exist
            if (m_Game != null) {
                //For each touch,
                for (int i = 0; i < touches.Length; i++) {
                    //If released
                    if (touches[i].phase == TouchPhase.Ended) {
                        //SFX
                        FSoundManager.PlaySound("success");

                        //Start
                        m_StartTime = START_DURATION;
                        RemoveAllChildren();
                        AddChild(m_Title);
                    }
                }
            }
        } else {
            //Reduce start duration
            m_StartTime -= Time.deltaTime;
            if (m_StartTime < 0) {
                //Start game
                m_Active = false;
                m_Game.start();
            } else {
                //Move
                m_Title.y = Futile.screen.height * 0.6f;
                m_Title.y += ((Futile.screen.height * 0.4f) + (m_Title.textureRect.height / 2)) * (START_DURATION - m_StartTime) / START_DURATION;
            }
        }
    }

        void UpdateWithTouch( FTouch touch )
        {
            if (touchId == -1 && TouchIsBegan( touch ) && TouchIsWithinRange( touch ))
            {
                touchId = touch.fingerId;
                SetPosition( touch.position );
            }

            if (touchId == touch.fingerId)
            {
                if (TouchIsEnded( touch ))
                {
                    delta = Vector2.zero;
                    value = Vector2.zero;
                    touchId = -1;
                    return;
                }

                delta = Vector2.ClampMagnitude( touch.position - GetPosition(), 64.0f );
                value = delta / 64.0f;

                return;
            }
        }