Exemple #1
0
    public void move(Manager.Direction direction)
    {
        saveOldPositions();
        bool didCompress = compress(direction);

        if (!merge(direction, didCompress) && !didCompress)
        {
            afterMove(false);
            return;
        }
        else
        {
            playImpact();
        }

        afterMove(true);
    }
Exemple #2
0
    public bool compress(Manager.Direction direction)
    {
        bool change = true;
        bool looped = false;

        while (true)
        {
            change = false;

            foreach (GameObject gameObject in tiles)
            {
                Tile tile = gameObject.GetComponent <Tile>();
                if (tile.piece != null)
                {
                    GameObject neighbor = tile.neighbors[direction];
                    if (neighbor != null)
                    {
                        Tile neighborTile = neighbor.GetComponent <Tile>();
                        if (neighborTile.piece == null && !neighborTile.pieceExploded)
                        {
                            change = true;
                            GameObject piece = tile.piece;
                            tile.unsetPiece();
                            neighborTile.setPiece(piece);

                            Vector2 vector         = Manager.instance.directionVector(direction) * 0.1f;
                            Piece   pieceComponent = piece.GetComponent <Piece>();
                            pieceComponent.animationOffset = vector;
                        }
                    }
                }
            }

            if (!change)
            {
                return(looped);
            }

            looped = true;
        }
    }
Exemple #3
0
    public void keyboardControls()
    {
        if (Input.GetKeyDown(KeyCode.R))
        {
            direction  = Manager.Direction.UP_RIGHT;
            shouldMove = true;
        }

        if (Input.GetKeyDown(KeyCode.F))
        {
            direction  = Manager.Direction.RIGHT;
            shouldMove = true;
        }

        if (Input.GetKeyDown(KeyCode.C))
        {
            direction  = Manager.Direction.DOWN_RIGHT;
            shouldMove = true;
        }

        if (Input.GetKeyDown(KeyCode.X))
        {
            direction  = Manager.Direction.DOWN_LEFT;
            shouldMove = true;
        }

        if (Input.GetKeyDown(KeyCode.S))
        {
            direction  = Manager.Direction.LEFT;
            shouldMove = true;
        }

        if (Input.GetKeyDown(KeyCode.E))
        {
            direction  = Manager.Direction.UP_LEFT;
            shouldMove = true;
        }
    }
Exemple #4
0
    public void touchControlsDelta(Vector2 delta)
    {
        if (delta.magnitude < 16f)
        {
            return;
        }

        float angle = Mathf.Rad2Deg * Mathf.Atan2(delta.y, -delta.x);

        angle = Mathf.Floor((angle - 30f) / 60f);

        Manager.Direction direction = Manager.Direction.RIGHT;
        switch ((int)angle)
        {
        case 1:
            direction = Manager.Direction.UP_RIGHT;
            break;

        case 0:
            direction = Manager.Direction.UP_LEFT;
            break;

        case -1:
            direction = Manager.Direction.LEFT;
            break;

        case -2:
            direction = Manager.Direction.DOWN_LEFT;
            break;

        case -3:
            direction = Manager.Direction.DOWN_RIGHT;
            break;
        }

        this.direction = direction;
        shouldMove     = true;
    }
Exemple #5
0
    public bool merge(Manager.Direction direction, bool didCompress)
    {
        foreach (GameObject gameObject in tiles)
        {
            Tile tile = gameObject.GetComponent <Tile>();
            if (tile.piece != null)
            {
                GameObject piece          = tile.piece;
                Piece      pieceComponent = piece.GetComponent <Piece>();
                pieceComponent.merge = 0;
            }
        }

        bool change = true;
        bool looped = false;

        while (change)
        {
            change = false;

            foreach (GameObject gameObject in tiles)
            {
                Tile tile = gameObject.GetComponent <Tile>();
                if (tile.piece != null)
                {
                    Piece             piece     = tile.piece.GetComponent <Piece>();
                    Manager.PieceType pieceType = piece.pieceType;

                    GameObject neighborAhead     = tile.neighbors[direction];
                    Tile       neighborAheadTile = neighborAhead != null?neighborAhead.GetComponent <Tile>() : null;

                    Piece neighborAheadPiece = neighborAheadTile != null && neighborAheadTile.piece != null?neighborAheadTile.piece.GetComponent <Piece>() : null;

                    Manager.PieceType neighborAheadPieceType = neighborAheadPiece != null ? neighborAheadPiece.pieceType : null;
                    GameObject        neighborBehind         = tile.neighbors[Manager.instance.opposite(direction)];
                    Tile neighborBehindTile = neighborBehind != null?neighborBehind.GetComponent <Tile>() : null;

                    Piece neighborBehindPiece = neighborBehindTile != null && neighborBehindTile.piece != null?neighborBehindTile.piece.GetComponent <Piece>() : null;

                    Manager.PieceType neighborBehindPieceType = neighborBehindPiece != null ? neighborBehindPiece.pieceType : null;

                    if (neighborAheadTile != null && neighborAheadPiece != null && canMerge(pieceType, neighborAheadPieceType) && (neighborBehindTile == null || neighborBehindPiece == null || !canMerge(pieceType, neighborBehindPieceType)))
                    {
                        change = true;

                        neighborAheadPiece.merge            = piece.merge + 1;
                        neighborAheadPiece.combo            = pieceType.contribuesToCombo() ? 1 : 0;
                        neighborAheadPiece.scoreAccumulator = piece.scoreAccumulator + piece.pieceType.getPointsForMerge();
                        List <Manager.PieceType> mergingPieceTypes = new List <Manager.PieceType>();
                        mergingPieceTypes.AddRange(piece.mergingPieceTypes);
                        mergingPieceTypes.Add(neighborAheadPiece.pieceType);
                        neighborAheadPiece.mergingPieceTypes = mergingPieceTypes;
                        GameObject pieceObject    = tile.piece;
                        Piece      pieceToAnimate = pieceObject.GetComponent <Piece>();
                        tile.unsetPiece();

                        Vector3 position     = piece.oldPosition;
                        Vector3 tilePosition = tile.transform.localPosition;
                        float   scaleBy      = transform.localScale.x;
                        Vector2 vector       = Manager.instance.directionVector(direction) * 0.4f * scaleBy;
                        pieceToAnimate.clearAnimations();
                        pieceToAnimate.moveWhenMergeAnimation = TweenFactory.Tween(null, new Vector3(0, 0, -3) + position * scaleBy, new Vector3(vector.x, vector.y, -3) + position * scaleBy, 0.25f, TweenScaleFunctions.CubicEaseOut, t =>
                        {
                            if (pieceObject == null)
                            {
                                return;
                            }

                            pieceObject.transform.localPosition = t.CurrentValue;
                        }, t =>
                        {
                            Destroy(pieceObject);
                        });

                        pieceToAnimate.scaleOutWhenMergeAnimation = TweenFactory.Tween(null, new Vector3(Manager.instance.tileScale, Manager.instance.tileScale, Manager.instance.tileScale), new Vector3(0, 0, 0), 0.25f, TweenScaleFunctions.CubicEaseOut, t =>
                        {
                            if (pieceObject == null)
                            {
                                return;
                            }

                            pieceObject.transform.localScale = t.CurrentValue * scaleBy;
                        });
                    }
                }
            }

            if (!change && !looped)
            {
                animateOffset();

                return(false);
            }

            looped = true;
        }

        float toAddScore = 0;
        int   maxCombo   = 0;

        Dictionary <Tile, GameObject> newPieces      = new Dictionary <Tile, GameObject>();
        List <MergeBehaviorPair>      mergeBehaviors = new List <MergeBehaviorPair>();

        foreach (GameObject gameObject in tiles)
        {
            Tile tile = gameObject.GetComponent <Tile>();
            if (tile.piece != null)
            {
                GameObject piece          = tile.piece;
                Piece      pieceComponent = piece.GetComponent <Piece>();
                int        combo          = pieceComponent.combo;
                int        merge          = pieceComponent.merge;

                if (combo > maxCombo)
                {
                    maxCombo = combo;
                }

                toAddScore += pieceComponent.scoreAccumulator;
                if (merge > 0)
                {
                    Manager.PieceType pieceType = pieceComponent.mergingPieceTypes[0];
                    for (int i = 1; i < pieceComponent.mergingPieceTypes.Count; i++)
                    {
                        pieceType = pieceComponent.mergingPieceTypes[i].mergeResult(pieceType);
                    }

                    GameObject newPiece          = createPiece(pieceType);
                    Piece      newPieceComponent = newPiece.GetComponent <Piece>();
                    newPieceComponent.scaleIn.Stop(TweenStopBehavior.Complete);

                    tile.unsetPiece();
                    newPieces[tile]        = newPiece;
                    newPieceComponent.tile = tile;

                    for (int i = 0; i < pieceComponent.mergingPieceTypes.Count; i++)
                    {
                        mergeBehaviors.Add(new MergeBehaviorPair(pieceComponent.mergingPieceTypes[i], newPieceComponent));
                    }

                    Destroy(piece);

                    newPieceComponent.clearAnimations();
                    newPieceComponent.mergeAnimation = TweenFactory.Tween(null, new Vector3(1.15f, 1.15f, 1.15f), new Vector3(1f, 1f, 1f), 0.2f, TweenScaleFunctions.QuadraticEaseIn, t =>
                    {
                        if (newPiece == null)
                        {
                            return;
                        }

                        Vector3 scale = t.CurrentValue;
                        if (newPieceComponent.tile == null)
                        {
                            scale *= Manager.instance.tileScale;
                        }

                        newPiece.transform.localScale = scale;
                    });
                }
            }
        }

        foreach (Tile tile in newPieces.Keys)
        {
            tile.setPiece(newPieces[tile]);
        }

        foreach (MergeBehaviorPair behavior in mergeBehaviors)
        {
            behavior.execute();
        }

        comboManager.addCombo(maxCombo);
        toAddScore *= comboManager.getComboMultiplier();
        score      += (int)Mathf.Floor(toAddScore);

        compress(direction);
        animateOffset();

        return(true);
    }