Ejemplo n.º 1
0
    public LifeStoneInfo CreateLifeStoneInfo(LifeStoneInfo lifeStoneInfo)
    {
        Vector2Int size = lifeStoneInfo.getSize();
        Vector2Int newSize;
        string     fill     = lifeStoneInfo.getFill();
        string     newFill  = "";
        Vector2Int maxPoint = new Vector2Int(-1, -1);
        Vector2Int minPoint = new Vector2Int(size.x + 1, size.y + 1);

        for (int j = 0; j < size.y; j++)
        {
            for (int i = 0; i < size.x; i++)
            {
                if (fill[j * size.x + i] != ' ')
                {
                    maxPoint.x = Mathf.Max(i, maxPoint.x);
                    maxPoint.y = Mathf.Max(j, maxPoint.y);
                    minPoint.x = Mathf.Min(i, minPoint.x);
                    minPoint.y = Mathf.Min(j, minPoint.y);
                }
            }
        }
        newSize = maxPoint - minPoint + Vector2Int.one;

        for (int j = minPoint.y; j <= maxPoint.y; j++)
        {
            newFill += fill.Substring(j * size.x + minPoint.x, newSize.x);
        }


        return(new LifeStoneInfo(newSize, newFill));
    }
Ejemplo n.º 2
0
    public void Init(LifeStoneInfo _info, Vector3 pos)
    {
        info     = _info;
        rb2D     = GetComponent <Rigidbody2D>();
        bc2D     = GetComponent <BoxCollider2D>();
        unitSize = unitSprite.GetComponent <SpriteRenderer>().bounds.size.x;
        Vector2Int inSize = info.getSize();
        string     inFill = info.getFill();

        unitObj = new GameObject[inSize.x * inSize.y];
        highObj = new GameObject[inSize.x * inSize.y];

        transform.position = pos - new Vector3(inSize.x * unitSize / 2f, 0, 0);

        for (int i = 0; i < inSize.x * inSize.y; i++)
        {
            if (inFill[i] != ' ')
            {
                unitObj[i] = Instantiate(unitSprite, transform);
                unitObj[i].transform.localPosition = new Vector3((i % inSize.x) * unitSize, ((int)(i / inSize.x)) * unitSize, 0);
                unitObj[i].GetComponent <SpriteRenderer>().sprite = sprites[inFill[i] - 'A'];

                highObj[i] = Instantiate(highlightSprite, transform);
                highObj[i].transform.localPosition = unitObj[i].transform.localPosition;
                highObj[i].SetActive(false);
            }
        }
        bc2D.offset = new Vector2(unitSize * inSize.x / 2f, unitSize * inSize.y / 2f);
        bc2D.size   = new Vector2(unitSize * inSize.x, unitSize * inSize.y);
    }
Ejemplo n.º 3
0
    public void HighlightSwitch(bool enabled)
    {
        Vector2Int inSize = info.getSize();
        string     inFill = info.getFill();

        for (int i = 0; i < inSize.x * inSize.y; i++)
        {
            if (inFill[i] != ' ')
            {
                highObj[i].SetActive(enabled);
                highObj[i].GetComponent <SpriteRenderer>().sortingOrder = -1 + (enabled ? 2 : 0);
                unitObj[i].GetComponent <SpriteRenderer>().sortingOrder = (enabled ? 2 : 0);
            }
        }
    }
Ejemplo n.º 4
0
    /// <summary>
    /// push LifeStone in LifeStoneFrame
    /// </summary>
    /// <param name="pushInfo"></param>
    public bool PushLifeStone(LifeStoneInfo pushInfo)
    {
        System.Random rnd   = new System.Random();
        Vector2Int    pSize = pushInfo.getSize();
        string        pFill = pushInfo.getFill();

        int[]     minRow = new int[] { lifeStoneRowNum, lifeStoneRowNum, lifeStoneRowNum };
        int       selectedCol = 0, selectedRow = lifeStoneRowNum;
        ArrayList selColCand = new ArrayList();

        {
            int i, j, pi, pj;
            for (i = 0; i <= 3 - pSize.x; i++)
            {
                for (j = lifeStoneRowNum - 1; j >= 0; j--)
                {
                    for (pi = 0; pi < pSize.x; pi++)
                    {
                        for (pj = 0; pj < pSize.y; pj++)
                        {
                            if (pFill[pj * pSize.x + pi] != ' ' && lifeStoneArray[j + pj, i + pi] != 0)
                            {
                                break;
                            }
                        }
                        if (pj != pSize.y)
                        {
                            break;
                        }
                    }
                    if (pi != pSize.x)
                    {
                        break;
                    }
                    minRow[i] = j;
                }
            }
        }

        for (int i = 0; i <= 3 - pSize.x; i++)
        {
            if (minRow[i] < selectedRow)
            {
                selectedRow = minRow[i];
            }
        }

        if (selectedRow == lifeStoneRowNum)
        {
            GameManager.Instance.DisplayText("생명석 자리가 없습니다!");
            return(false);
        }

        for (int i = 0; i <= 3 - pSize.x; i++)
        {
            if (minRow[i] == selectedRow)
            {
                selColCand.Add(i);
            }
        }


        selectedCol = (int)selColCand[rnd.Next(selColCand.Count)];

        float vibration = pushInfo.getAmount() * vibrationVariable * lifeStoneSize;
        int   cutRow    = pSize.y;

        for (int pj = 0; pj < pSize.y; pj++)
        {
            if (cutRow == pSize.y && selectedRow + pj >= lifeStoneRowNum)
            {
                cutRow = pj;
                //break;
            }
            for (int pi = 0; pi < pSize.x; pi++)
            {
                if (pFill[pj * pSize.x + pi] != ' ')
                {
                    int        xtmp = selectedCol + pi, ytmp = selectedRow + pj;
                    GameObject tmpObj;
                    tmpObj = Instantiate(lifeUnitPrefab, stoneSuper.transform);

                    if (pj < cutRow)
                    {
                        lifeStoneArray[ytmp, xtmp] = pFill[pj * pSize.x + pi] - 'A' + 1;
                        lifeStoneUnit[ytmp, xtmp]  = tmpObj;
                    }

                    tmpObj.GetComponent <LifeUnitInFrame>().Init(
                        pFill[pj * pSize.x + pi] - 'A' + 1,
                        lifeStoneSize,
                        new Vector2Int(xtmp, ytmp),
                        new Vector2Int(xtmp, lifeStoneRowNum + pj),
                        new Vector2(frameBorder * lifeStoneSize, frameBorder * lifeStoneSize),
                        true,
                        vibration);
                    vibration = 0;
                }
            }
        }

        stoneCut = false;
        if (cutRow < pSize.y)
        {
            StartCoroutine(CutCoroutine(cutRow, pSize, pFill));
        }
        return(true);
    }