C# FTouch类代码示例

    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;
                    }
                }
            }
        }
    }