public GemGrid(GemSO gem, int x, int y)
        {
            this.gem = gem;
            this.x   = x;
            this.y   = y;

            isDestroyed = false;
        }
Esempio n. 2
0
        public void SetGemSO(GemSO gemSO)
        {
            spriteRenderer.sprite   = gemSO.sprite;
            levelGridPosition.gemSO = gemSO;
#if UNITY_EDITOR
            UnityEditor.EditorUtility.SetDirty(levelSO);
#endif
        }
Esempio n. 3
0
    private void Awake()
    {
        grid = new Grid <GridPosition>(levelSO.width, levelSO.height, 1f, Vector3.zero, (Grid <GridPosition> g, int x, int y) => new GridPosition(levelSO, g, x, y));

        levelText.text = levelSO.name;

        if (levelSO.levelGridPositionList == null || levelSO.levelGridPositionList.Count != levelSO.width * levelSO.height)
        {
            // Create new Level
            Debug.Log("Creating new level...");
            levelSO.levelGridPositionList = new List <LevelSO.LevelGridPosition>();

            for (int x = 0; x < grid.GetWidth(); x++)
            {
                for (int y = 0; y < grid.GetHeight(); y++)
                {
                    GemSO gem = levelSO.gemList[Random.Range(0, levelSO.gemList.Count)];

                    LevelSO.LevelGridPosition levelGridPosition = new LevelSO.LevelGridPosition {
                        x = x, y = y, gemSO = gem
                    };
                    levelSO.levelGridPositionList.Add(levelGridPosition);

                    CreateVisual(grid.GetGridObject(x, y), levelGridPosition);
                }
            }
        }
        else
        {
            // Load Level
            Debug.Log("Loading level...");
            for (int x = 0; x < grid.GetWidth(); x++)
            {
                for (int y = 0; y < grid.GetHeight(); y++)
                {
                    LevelSO.LevelGridPosition levelGridPosition = null;

                    foreach (LevelSO.LevelGridPosition tmpLevelGridPosition in levelSO.levelGridPositionList)
                    {
                        if (tmpLevelGridPosition.x == x && tmpLevelGridPosition.y == y)
                        {
                            levelGridPosition = tmpLevelGridPosition;
                            break;
                        }
                    }

                    if (levelGridPosition == null)
                    {
                        Debug.LogError("Error! Null!");
                    }

                    CreateVisual(grid.GetGridObject(x, y), levelGridPosition);
                }
            }
        }

        cameraTransform.position = new Vector3(grid.GetWidth() * .5f, grid.GetHeight() * .5f, cameraTransform.position.z);
    }
    public void SetLevelSO(LevelSO levelSO)
    {
        this.levelSO = levelSO;

        gridWidth  = levelSO.width;
        gridHeight = levelSO.height;
        grid       = new Grid <GemGridPosition>(gridWidth, gridHeight, 1f, Vector3.zero, (Grid <GemGridPosition> g, int x, int y) => new GemGridPosition(g, x, y));

        // Initialize Grid
        for (int x = 0; x < gridWidth; x++)
        {
            for (int y = 0; y < gridHeight; y++)
            {
                // Get Saved LevelGridPosition
                LevelSO.LevelGridPosition levelGridPosition = null;

                foreach (LevelSO.LevelGridPosition tmpLevelGridPosition in levelSO.levelGridPositionList)
                {
                    if (tmpLevelGridPosition.x == x && tmpLevelGridPosition.y == y)
                    {
                        levelGridPosition = tmpLevelGridPosition;
                        break;
                    }
                }

                if (levelGridPosition == null)
                {
                    // Couldn't find LevelGridPosition with this x, y!
                    Debug.LogError("Error! Null!");
                }

                GemSO   gem     = levelGridPosition.gemSO;
                GemGrid gemGrid = new GemGrid(gem, x, y);
                grid.GetGridObject(x, y).SetGemGrid(gemGrid);
                grid.GetGridObject(x, y).SetHasGlass(levelGridPosition.hasGlass);
            }
        }

        score     = 0;
        moveCount = levelSO.moveAmount;

        OnLevelSet?.Invoke(this, new OnLevelSetEventArgs {
            levelSO = levelSO, grid = grid
        });
    }
    public void SpawnNewMissingGridPositions()
    {
        for (int x = 0; x < gridWidth; x++)
        {
            for (int y = 0; y < gridHeight; y++)
            {
                GemGridPosition gemGridPosition = grid.GetGridObject(x, y);

                if (gemGridPosition.IsEmpty())
                {
                    GemSO   gem     = levelSO.gemList[UnityEngine.Random.Range(0, levelSO.gemList.Count)];
                    GemGrid gemGrid = new GemGrid(gem, x, y);

                    gemGridPosition.SetGemGrid(gemGrid);

                    OnNewGemGridSpawned?.Invoke(gemGrid, new OnNewGemGridSpawnedEventArgs {
                        gemGrid         = gemGrid,
                        gemGridPosition = gemGridPosition,
                    });
                }
            }
        }
    }
Esempio n. 6
0
    public override int GetCellType(int row, int col)
    {
        GemSO gemSO = match3.GetGemSO(col, row);

        return(levelSO.gemList.IndexOf(gemSO));
    }
    public List <GemGridPosition> GetMatch3Links(int x, int y)
    {
        GemSO gemSO = GetGemSO(x, y);

        if (gemSO == null)
        {
            return(null);
        }

        int rightLinkAmount = 0;

        for (int i = 1; i < gridWidth; i++)
        {
            if (IsValidPosition(x + i, y))
            {
                GemSO nextGemSO = GetGemSO(x + i, y);
                if (nextGemSO == gemSO)
                {
                    // Same Gem
                    rightLinkAmount++;
                }
                else
                {
                    // Not same Gem
                    break;
                }
            }
            else
            {
                // Invalid position
                break;
            }
        }

        int leftLinkAmount = 0;

        for (int i = 1; i < gridWidth; i++)
        {
            if (IsValidPosition(x - i, y))
            {
                GemSO nextGemSO = GetGemSO(x - i, y);
                if (nextGemSO == gemSO)
                {
                    // Same Gem
                    leftLinkAmount++;
                }
                else
                {
                    // Not same Gem
                    break;
                }
            }
            else
            {
                // Invalid position
                break;
            }
        }

        int horizontalLinkAmount = 1 + leftLinkAmount + rightLinkAmount; // This Gem + left + right

        if (horizontalLinkAmount >= 3)
        {
            // Has 3 horizontal linked gems
            List <GemGridPosition> linkedGemGridPositionList = new List <GemGridPosition>();
            int leftMostX = x - leftLinkAmount;
            for (int i = 0; i < horizontalLinkAmount; i++)
            {
                linkedGemGridPositionList.Add(grid.GetGridObject(leftMostX + i, y));
            }
            return(linkedGemGridPositionList);
        }


        int upLinkAmount = 0;

        for (int i = 1; i < gridHeight; i++)
        {
            if (IsValidPosition(x, y + i))
            {
                GemSO nextGemSO = GetGemSO(x, y + i);
                if (nextGemSO == gemSO)
                {
                    // Same Gem
                    upLinkAmount++;
                }
                else
                {
                    // Not same Gem
                    break;
                }
            }
            else
            {
                // Invalid position
                break;
            }
        }

        int downLinkAmount = 0;

        for (int i = 1; i < gridHeight; i++)
        {
            if (IsValidPosition(x, y - i))
            {
                GemSO nextGemSO = GetGemSO(x, y - i);
                if (nextGemSO == gemSO)
                {
                    // Same Gem
                    downLinkAmount++;
                }
                else
                {
                    // Not same Gem
                    break;
                }
            }
            else
            {
                // Invalid position
                break;
            }
        }

        int verticalLinkAmount = 1 + downLinkAmount + upLinkAmount; // This Gem + down + up

        if (verticalLinkAmount >= 3)
        {
            // Has 3 vertical linked gems
            List <GemGridPosition> linkedGemGridPositionList = new List <GemGridPosition>();
            int downMostY = y - downLinkAmount;
            for (int i = 0; i < verticalLinkAmount; i++)
            {
                linkedGemGridPositionList.Add(grid.GetGridObject(x, downMostY + i));
            }
            return(linkedGemGridPositionList);
        }

        // No links
        return(null);
    }
Esempio n. 8
0
    public void SetLevelSO(LevelSO levelSO)
    {
        this.levelSO = levelSO;

        gridWidth  = levelSO.width;
        gridHeight = levelSO.height;
        grid       = new Grid <GemGridPosition>(gridWidth, gridHeight, 1f, Vector3.zero, (Grid <GemGridPosition> g, int x, int y) => new GemGridPosition(g, x, y));

        // Initialize Grid
        for (int x = 0; x < gridWidth; x++)
        {
            for (int y = 0; y < gridHeight; y++)
            {
                // Get Saved LevelGridPosition
                LevelSO.LevelGridPosition levelGridPosition = null;

                foreach (LevelSO.LevelGridPosition tmpLevelGridPosition in levelSO.levelGridPositionList)
                {
                    if (tmpLevelGridPosition.x == x && tmpLevelGridPosition.y == y)
                    {
                        levelGridPosition = tmpLevelGridPosition;
                        break;
                    }
                }

                if (levelGridPosition == null)
                {
                    // Couldn't find LevelGridPosition with this x, y!
                    Debug.LogError("Error! Null!");
                }

                GemSO   gem     = levelGridPosition.gemSO;
                GemGrid gemGrid = new GemGrid(gem, x, y);
                grid.GetGridObject(x, y).SetGemGrid(gemGrid);
                grid.GetGridObject(x, y).SetHasGlass(levelGridPosition.hasGlass);
            }
        }

        if (randomGlass.enabled)
        {
            // Remove all glass
            for (int x = 0; x < gridWidth; x++)
            {
                for (int y = 0; y < gridHeight; y++)
                {
                    grid.GetGridObject(x, y).SetHasGlass(false);
                }
            }
            // Add Random Glass
            while (GetGlassAmount() < randomGlass.glassAmount)
            {
                int glassX = UnityEngine.Random.Range(0, gridWidth);
                int glassY = UnityEngine.Random.Range(0, gridHeight);
                grid.GetGridObject(glassX, glassY).SetHasGlass(true);
            }
        }

        score     = 0;
        moveCount = levelSO.moveAmount;

        OnLevelSet?.Invoke(this, new OnLevelSetEventArgs {
            levelSO = levelSO, grid = grid
        });
    }