public bool TryAddPiece(PieceController pc)
    {
        bool fits = PieceFits(pc.gameObject,pc.GetArray());

        if(!fits){
            Debug.Log ("didn't fit");
            return false;
        }

        int[,] pieceValues = pc.GetArray();
        //we've gone through and there've been no collisions
        //actually add the piece
        allPieces.Add(new PieceRecord(pc,xcounter,ycounter));
        UpdateReadout();
        for(int i = 0; i < pieceValues.GetLength(0); i++){
            for(int j = 0; j < pieceValues.GetLength(1); j++){
                Occupancy o = grid[ycounter + i,xcounter + j];
                int shapecode = pieceValues[i,j];
                if(shapecode == 0){
                    continue;
                }if(shapecode == 1){
                    o.north = pc;
                    o.east = pc;
                    o.south = pc;
                    o.west = pc;
                }if(shapecode == NORTHWEST_CODE){
                    o.north = pc;
                    o.west = pc;
                }if(shapecode == NORTHEAST_CODE){
                    o.north = pc;
                    o.east = pc;
                }if(shapecode == SOUTHEAST_CODE){
                    o.south = pc;
                    o.east = pc;
                }if(shapecode == SOUTHWEST_CODE){
                    o.south = pc;
                    o.west = pc;
                }

            }
        }
        //SpriteRenderer sr = pc.gameObject.GetComponent<SpriteRenderer>();

        PutThatThingBackWhereItCameFromOrSoHelpMe(pc,xcounter,ycounter);
        /*RectTransform prt = (RectTransform)pc.transform;
        RectTransform rt = (RectTransform)transform;
        UIRectTranslator translate = transform.gameObject.GetComponent<UIRectTranslator>();
        Vector3[] corners = new Vector3[4];
        rt.GetWorldCorners(corners);
        Vector3 gridTopCorner = corners[1];//new Vector3(gridCorner.x,gridCorner.y+gridLength,gridCorner.z);
        Vector3 extents = translate.WorldSize(prt)/2;
        pc.transform.position = new Vector3(xcounter*squareWidth + gridCorner.x + extents.x,
                                            gridCorner.y + gridLength - ((ycounter-1)*squareWidth) - extents.y,
                                            pc.transform.position.z);*/

        for(int i = 0; i < GRID_SIZE; i++){
            for(int j = 0; j < GRID_SIZE; j++){
                overlays[i,j].sprite = blank;
            }
        }
        Debug.Log ("it fit");
        return fits;
    }
Beispiel #2
0
    public void LoadTower(string filename)
    {
        towerFileName = filename;
        //Debug.Log(towerFileName);

        FileLoader fl = new FileLoader(Application.persistentDataPath, "Towers", filename);
        //FileLoader fl = new FileLoader ("JSONData" + Path.DirectorySeparatorChar + "Towers",filename);
        string json = fl.Read();
        Dictionary <string, System.Object> data = (Dictionary <string, System.Object>)Json.Deserialize(json);

        towerName     = (string)data["towerName"];
        decalFilename = (string)data["decalFilename"];
        towerType     = (string)data["towerType"];

        List <System.Object> pieces = data["pieces"] as List <System.Object>;

        foreach (System.Object pObj in pieces)
        {
            Dictionary <string, System.Object> pdata = pObj as Dictionary <string, System.Object>;
            int  x       = (int)(long)pdata["anchorX"];
            int  y       = (int)(long)pdata["anchorY"];
            int  rot     = (int)(long)pdata["rotation"];
            bool flipped = false;
            int  fliprot = 0;
            if (pdata.ContainsKey("flipped"))
            {
                flipped = (bool)pdata["flipped"];
                fliprot = (int)(long)pdata["flipRotation"];
            }
            string piecefile = (string)pdata["pieceFilename"];

            GameObject go = Instantiate(Resources.Load("Prefabs/ExistingPiece")) as GameObject;
            go.transform.SetParent(EditorController.piecesLayer, false);
            PieceController p = go.GetComponent <PieceController>();
            p.SetGridLock(true);
            p.ConfigureFromJSON(piecefile);
            p.SetRotation(rot);
            p.SetFlippedLoadOnly(flipped);
            p.SetFlipRotationLoadOnly(fliprot);
            if (flipped)
            {
                p.CalibrateFlip();
            }
            allPieces.Add(new PieceRecord(p, x, y));

            //SpriteRenderer sr = go.GetComponent<SpriteRenderer>();
            //PutThatThingBackWhereItCameFromOrSoHelpMe(go.GetComponent<PieceController>());
            RectTransform    prt       = (RectTransform)go.transform;
            RectTransform    rt        = (RectTransform)transform;
            UIRectTranslator translate = transform.gameObject.GetComponent <UIRectTranslator>();
            Vector3[]        corners   = new Vector3[4];
            rt.GetWorldCorners(corners);
            Vector3 gridTopCorner = corners[1];            //new Vector3(gridCorner.x,gridCorner.y+gridLength,gridCorner.z);
            Vector3 extents       = translate.WorldSize(prt) / 2;
            go.transform.position = gridTopCorner + new Vector3(squareWidth * x + extents.x,
                                                                -squareWidth * (y) - extents.y,
                                                                go.transform.position.z);


            int[,] values = p.GetArray();             //we assume all pieces fit- no error checking
            for (int i = 0; i < values.GetLength(0); i++)
            {
                for (int j = 0; j < values.GetLength(1); j++)
                {
                    int       value = values[i, j];
                    Occupancy o     = grid[y + i, x + j];
                    if (value == 1)
                    {
                        o.north = p;
                        o.east  = p;
                        o.south = p;
                        o.west  = p;
                    }
                    else if (value == PieceController.NORTHWEST_CODE)
                    {
                        o.north = p;
                        o.west  = p;
                    }
                    else if (value == PieceController.NORTHEAST_CODE)
                    {
                        o.north = p;
                        o.east  = p;
                    }
                    else if (value == PieceController.SOUTHEAST_CODE)
                    {
                        o.east  = p;
                        o.south = p;
                    }
                    else if (value == PieceController.SOUTHWEST_CODE)
                    {
                        o.south = p;
                        o.west  = p;
                    }
                }
            }
        }
        UpdateReadout();
    }
Beispiel #3
0
    public bool TryAddPiece(PieceController pc)
    {
        bool fits = PieceFits(pc.gameObject, pc.GetArray());

        if (!fits)
        {
            Debug.Log("didn't fit");
            return(false);
        }

        int[,] pieceValues = pc.GetArray();
        //we've gone through and there've been no collisions
        //actually add the piece
        allPieces.Add(new PieceRecord(pc, xcounter, ycounter));
        UpdateReadout();
        for (int i = 0; i < pieceValues.GetLength(0); i++)
        {
            for (int j = 0; j < pieceValues.GetLength(1); j++)
            {
                Occupancy o         = grid[ycounter + i, xcounter + j];
                int       shapecode = pieceValues[i, j];
                if (shapecode == 0)
                {
                    continue;
                }
                if (shapecode == 1)
                {
                    o.north = pc;
                    o.east  = pc;
                    o.south = pc;
                    o.west  = pc;
                }
                if (shapecode == NORTHWEST_CODE)
                {
                    o.north = pc;
                    o.west  = pc;
                }
                if (shapecode == NORTHEAST_CODE)
                {
                    o.north = pc;
                    o.east  = pc;
                }
                if (shapecode == SOUTHEAST_CODE)
                {
                    o.south = pc;
                    o.east  = pc;
                }
                if (shapecode == SOUTHWEST_CODE)
                {
                    o.south = pc;
                    o.west  = pc;
                }
            }
        }
        //SpriteRenderer sr = pc.gameObject.GetComponent<SpriteRenderer>();

        PutThatThingBackWhereItCameFromOrSoHelpMe(pc, xcounter, ycounter);

        /*RectTransform prt = (RectTransform)pc.transform;
         * RectTransform rt = (RectTransform)transform;
         * UIRectTranslator translate = transform.gameObject.GetComponent<UIRectTranslator>();
         * Vector3[] corners = new Vector3[4];
         * rt.GetWorldCorners(corners);
         * Vector3 gridTopCorner = corners[1];//new Vector3(gridCorner.x,gridCorner.y+gridLength,gridCorner.z);
         * Vector3 extents = translate.WorldSize(prt)/2;
         * pc.transform.position = new Vector3(xcounter*squareWidth + gridCorner.x + extents.x,
         *                                  gridCorner.y + gridLength - ((ycounter-1)*squareWidth) - extents.y,
         *                                  pc.transform.position.z);*/

        for (int i = 0; i < GRID_SIZE; i++)
        {
            for (int j = 0; j < GRID_SIZE; j++)
            {
                overlays[i, j].sprite = blank;
            }
        }
        Debug.Log("it fit");
        return(fits);
    }
Beispiel #4
0
    public void Update()
    {
        /*if(test.TimeElapsedSecs() >= 20){
         *      test.Restart();
         *      SaveTower();
         * }*/
        PieceController p = EditorController.GetFloatingPiece();

        if (p == null)
        {
            if (cleared)
            {
                return;
            }
            for (int i = 0; i < GRID_SIZE; i++)
            {
                for (int j = 0; j < GRID_SIZE; j++)
                {
                    overlays[i, j].sprite = blank;
                }
            }
            cleared = true;
            return;
        }
        else
        {
            RectTransform prt = (RectTransform)p.gameObject.transform;
            RectTransform rt  = (RectTransform)transform;
            if (!prt.rect.Overlaps(rt.rect))
            {
                if (cleared)
                {
                    return;
                }
                else
                {
                    for (int i = 0; i < GRID_SIZE; i++)
                    {
                        for (int j = 0; j < GRID_SIZE; j++)
                        {
                            overlays[i, j].sprite = blank;
                        }
                    }
                    cleared = true;
                    return;
                }
            }
            else
            {
                cleared = false;
            }
        }
        int[,] pieceValues = p.GetArray();         //do it here so we only have to call this once
        if (PieceFits(p.gameObject, pieceValues))
        {
            //xcounter and ycounter should be the grid coordinates of the piece drop location
            for (int i = 0; i < GRID_SIZE; i++)
            {
                for (int j = 0; j < GRID_SIZE; j++)
                {
                    int blockType = PieceBlockHelper(i, j, ycounter, xcounter, pieceValues);
                    if (blockType == 0)
                    {
                        overlays[i, j].sprite = blank;
                    }
                    else if (blockType == 1)
                    {
                        overlays[i, j].sprite = full;
                    }
                    else if (blockType == NORTHWEST_CODE)
                    {
                        overlays[i, j].sprite = nw;
                    }
                    else if (blockType == NORTHEAST_CODE)
                    {
                        overlays[i, j].sprite = ne;
                    }
                    else if (blockType == SOUTHEAST_CODE)
                    {
                        overlays[i, j].sprite = se;
                    }
                    else if (blockType == SOUTHWEST_CODE)
                    {
                        overlays[i, j].sprite = sw;
                    }
                    overlays[i, j].color = Color.green;
                }
            }
        }
        else
        {
            for (int i = 0; i < GRID_SIZE; i++)
            {
                for (int j = 0; j < GRID_SIZE; j++)
                {
                    int blockType = PieceBlockHelper(i, j, ycounter, xcounter, pieceValues);
                    if (blockType == 0)
                    {
                        overlays[i, j].sprite = blank;
                    }
                    else if (blockType == 1)
                    {
                        overlays[i, j].sprite = full;
                    }
                    else if (blockType == NORTHWEST_CODE)
                    {
                        overlays[i, j].sprite = nw;
                    }
                    else if (blockType == NORTHEAST_CODE)
                    {
                        overlays[i, j].sprite = ne;
                    }
                    else if (blockType == SOUTHEAST_CODE)
                    {
                        overlays[i, j].sprite = se;
                    }
                    else if (blockType == SOUTHWEST_CODE)
                    {
                        overlays[i, j].sprite = sw;
                    }
                    overlays[i, j].color = Color.red;
                }
            }
        }
    }