Пример #1
0
    void Update()
    {
        if (Network.isServer)
        {
            //Every X frames
            if (Time.frameCount % 15 == 0)
            {
                //pick a random wall
                int r = rng.Next() % mazeSize;
                int c = rng.Next() % mazeSize;

                //get the wallscript
                WallScript ws     = WallArray[r][c].GetComponent <WallScript>();
                float      height = ws.GetHeight();

                if (height == 1.0f)
                {
                    ws.SetHeight(0.0f);
                    //Debug.Log("raising wall at row " + r + ", col "+c);
                }
                else if (height == 0.0f)
                {
                    ws.SetHeight(1.0f);
                    //Debug.Log("lowering wall at row " + r + ", col "+c);
                }

                networkView.RPC("moveWall", RPCMode.Others, r, c, (int)ws.GetHeight());
            }
        }
    }
Пример #2
0
    void setMaze(string data)
    {
        //Debug.Log ("setmaze called");

        //This will be sent by the server when it has sent all its data.
        if (data.Equals("DONE"))
        {
            requestingData = false;
        }
        else
        {
            //This prevents unnecessary calculations for players who already have map data.
            if (requestingData)
            {
                //Debug.Log("Recieving data: " + data);

                string[] allDataSplit = data.Split('|');
                foreach (string str in allDataSplit)
                {
                    string[] finalSplit = str.Split(',');             //0 = row, 1 = col, 2 = raised/lowered.
                    int      r          = int.Parse(finalSplit[0]);
                    int      c          = int.Parse(finalSplit[1]);
                    int      val        = int.Parse(finalSplit[2]);


                    WallScript ws = WallArray[r][c].GetComponent <WallScript>();
                    ws.SetHeight(val);
                }
            }
        }
    }
Пример #3
0
    void moveWall(int r, int c, int val)
    {
        WallScript ws = WallArray[r][c].GetComponent <WallScript>();

        ws.SetHeight(val);
    }
Пример #4
0
    void Start()
    {
        rng    = new System.Random();
        parent = GameObject.Find("WallManagerGO");

        //------------------------------------------//
        //-------------Wall generation--------------//
        //------------------------------------------//

        WallArray = new GameObject[mazeSize][];
        wallState = new float[mazeSize][];
        for (int i = 0; i < mazeSize; i++)
        {
            WallArray[i] = new GameObject[mazeSize];
            wallState[i] = new float[mazeSize];

            for (int j = 0; j < mazeSize; j++)
            {
                WallArray[i][j] = (GameObject)Object.Instantiate
                                      (WallGO, new Vector3(i * wallSize, wallSize / 2, j * wallSize), Quaternion.identity);
                WallArray[i][j].transform.parent = parent.transform;         //sets the GO neatly in heiarchy.


                //Editing the script component
                WallScript currentWall = WallArray[i][j].GetComponent <WallScript>();
                currentWall.Setup(i, j, -wallSize / 2, wallSize / 2); //gives the wall info about itself, like its location, max/min height.
                currentWall.SetParent(WallArray[i][j]);               // lets the object know about itself.
                currentWall.SetHeight(1);                             //All walls start raised.
                wallState[i][j] = 1;                                  // keep track of the value in wallState.
                currentWall.SetSize(wallSize);                        // sets the cube's size.
            }
        }


        //---------------------------------------//
        //-------------Outside Walls-------------//
        //---------------------------------------//

        //GameObject floor = GameObject.CreatePrimitive(PrimitiveType.Cube);
        GameObject zMaxWall = GameObject.CreatePrimitive(PrimitiveType.Cube);
        GameObject zMinWall = GameObject.CreatePrimitive(PrimitiveType.Cube);
        GameObject xMaxWall = GameObject.CreatePrimitive(PrimitiveType.Cube);
        GameObject xMinWall = GameObject.CreatePrimitive(PrimitiveType.Cube);

        float fullDist       = (mazeSize * wallSize);
        float halfDist       = (fullDist) / 2;
        float permWallHeight = wallSize * 2;

        //floor - Might not even be necessary? - Wait yes it is. - WAIT NO ITS NOT.

        /*
         * floor.transform.position = new Vector3(halfDist,-.5f,halfDist);
         * floor.transform.localScale = new Vector3(fullDist,1,fullDist);
         */

        //other walls - should be working!
        zMaxWall.transform.position   = new Vector3(halfDist, permWallHeight / 2, fullDist);
        zMaxWall.transform.localScale = new Vector3(fullDist + wallSize, permWallHeight, wallSize);
        zMaxWall.name = "zMaxWall";
        zMaxWall.renderer.material.SetTexture("_MainTex", wallTexture);
        zMaxWall.renderer.material.mainTextureScale = new Vector2(mazeSize, 2);

        zMinWall.transform.position   = new Vector3(halfDist, permWallHeight / 2, -wallSize);
        zMinWall.transform.localScale = new Vector3(fullDist + wallSize, permWallHeight, wallSize);
        zMinWall.name = "zMinWall";
        zMinWall.renderer.material.SetTexture("_MainTex", wallTexture);
        zMinWall.renderer.material.mainTextureScale = new Vector2(mazeSize, 2);

        xMaxWall.transform.position   = new Vector3(fullDist, permWallHeight / 2, halfDist);
        xMaxWall.transform.localScale = new Vector3(wallSize, permWallHeight, fullDist + wallSize);
        xMaxWall.name = "xMaxWall";
        xMaxWall.renderer.material.SetTexture("_MainTex", wallTexture);
        xMaxWall.renderer.material.mainTextureScale = new Vector2(mazeSize, 2);


        xMinWall.transform.position   = new Vector3(-wallSize, permWallHeight / 2, halfDist);
        xMinWall.transform.localScale = new Vector3(wallSize, permWallHeight, fullDist + wallSize);
        xMinWall.name = "xMinWall";
        xMinWall.renderer.material.SetTexture("_MainTex", wallTexture);
        xMinWall.renderer.material.mainTextureScale = new Vector2(mazeSize, 2);

        //---------------------------------------//
        //----------------Towers-----------------//
        //---------------------------------------//

        float wallAdjustment = 2.0f;

        Object.Instantiate(RedTorch, new Vector3(fullDist, permWallHeight + wallAdjustment, fullDist), Quaternion.identity);
        Object.Instantiate(YellowTorch, new Vector3(fullDist, permWallHeight + wallAdjustment, -wallSize), Quaternion.identity);
        Object.Instantiate(GreenTorch, new Vector3(-wallSize, permWallHeight + wallAdjustment, fullDist), Quaternion.identity);
        Object.Instantiate(BlueTorch, new Vector3(-wallSize, permWallHeight + wallAdjustment, -wallSize), Quaternion.identity);
    }
Пример #5
0
    void OnServerInitialized()
    {
        //---------------------------------------//
        //-----------------Prims-----------------//
        //---------------------------------------//

        //Everything in here is only done by the server.



        //Having some problems, this was to work-around some dumb error.
        space fakeSpace;

        fakeSpace.col               = 1000;
        fakeSpace.row               = 1000;
        fakeSpace.weight            = 1000000;
        fakeSpace.numAdjacentInPath = 0;
        fakeSpace.partOfPath        = false;

        //all spaces and possible starting Loc for algorithm.
        space[][]    allSpaces;
        List <space> possibleStarts = new List <space>(); // List containing all the nodes that can be started from.


        //create a randomly generated weighted graph.
        allSpaces = new space[mazeSize][];
        for (int i = 0; i < mazeSize; i++)
        {
            allSpaces[i] = new space[mazeSize];
            for (int j = 0; j < mazeSize; j++)
            {
                allSpaces[i][j].weight            = rng.Next() % 100;
                allSpaces[i][j].numAdjacentInPath = 0;
                allSpaces[i][j].partOfPath        = false;
                allSpaces[i][j].row = i;
                allSpaces[i][j].col = j;
            }
        }

        //Generation Loop.
        bool isGenerated = false;
        int  numRuns     = 0;
        int  curRow      = 0;
        int  curCol      = 0;

        List <space> avaliableMoves = new List <space>(); //list for possible moves THIS turn. (used later).

        //Kinda cheating I guess. First move is made automatically.
        //Add the starting move to the list of starting moves.
        possibleStarts.Add(allSpaces[0][0]);

        allSpaces[0][0].partOfPath = true;
        allSpaces[0][1].numAdjacentInPath++;
        allSpaces[1][0].numAdjacentInPath++;

        while (!isGenerated)
        {
            numRuns++;     //Debug

            //Debug.Log("running loop number " + numRuns );+
            //Debug.Log("++++++ running loop number " + numRuns + ", avaliable starts: " + possibleStarts.Count+" ++++++");


            //Choose a starting space.
            int choice = rng.Next() % possibleStarts.Count;
            curRow = possibleStarts[choice].row;
            curCol = possibleStarts[choice].col;


            //Debug.Log("starting at row "+ curRow + ", col "+ curCol);

            //Add all possible points to path.
            for (int i = 1; i < 5; i++)    // this for loop gets all nearby points.
            {
                int row = 0;
                int col = 0;

                //Sloppy I know.
                switch (i)
                {
                case 1: row = curRow; col = curCol + 1; break;

                case 2: row = curRow; col = curCol - 1; break;

                case 3: row = curRow + 1; col = curCol; break;

                case 4: row = curRow - 1; col = curCol; break;
                }

                if (row >= 0 && row < mazeSize && col >= 0 && col < mazeSize)                          //make sure its in bounds.
                {
                    if (allSpaces[row][col].numAdjacentInPath == 1 && !allSpaces[row][col].partOfPath) //This means it is near only one other used space! (which is what we want)
                    {
                        //Debug.Log("adding space at row" + row + ", col "+ col + "to possible moves.");
                        avaliableMoves.Add(allSpaces[row][col]);                 // adds the space onto a list of possible spaces
                    }
                }
            }    //All possible moves have been added.


            //dumb error work-around.
            space moveChoice = fakeSpace;

            //If there are moves avaliable...
            if (avaliableMoves.Count != 0)
            {
                //Debug.Log ("There are moves avaliable");
                //choose one by weight and make the move.
                for (int i = 0; i < avaliableMoves.Count; i++)        // count should be 1-3
                {
                    if (avaliableMoves[i].weight < moveChoice.weight)
                    {
                        moveChoice = avaliableMoves[i];
                    }
                }

                //Debug.Log("chose to move to space at row "+moveChoice.row + "and col "+moveChoice.col + ", added it to graph");
                //Move has been chosen. Add it to graph.
                possibleStarts.Add(moveChoice);


                for (int i = 1; i < 5; i++)        // this for loop gets all nearby points.
                {
                    int r = moveChoice.row;
                    int c = moveChoice.col;
                    allSpaces[r][c].partOfPath = true;             // move choice becomes part of graph

                    switch (i)
                    {
                    case 1: r++; break;

                    case 2: r--; break;

                    case 3: c++; break;

                    case 4: c--; break;
                    }

                    //Not going out of bounds...
                    if (c >= 0 && c < mazeSize && r >= 0 && r < mazeSize)
                    {
                        allSpaces[r][c].numAdjacentInPath++;                 // spaces near choice have numAdjacent incremented.
                    }
                }

                if ((avaliableMoves.Count - 1) == 0)
                {
                    //Debug.Log("after moving there were no more moves, removing row " + curRow +", col "+curCol +" from possible starts");
                    //that was our last move from this spot.
                    //Remove used space from starting list.
                    possibleStarts.RemoveAt(choice);
                }
            }
            else     // No moves?
            {
                //Debug.Log("no moves, removing space at row "+curRow + ",col " + curCol+ " from possible starts");
                //Remove used space from starting list.
                possibleStarts.RemoveAt(choice);
            }


            //If there are no more moves, end generation.
            if (possibleStarts.Count == 0)    //possibleStarts.Count == 0
            {
                //GGWP generation
                //Debug.Log("finished with " + numRuns + "runs!");
                isGenerated = true;         // ends loop.
            }

            avaliableMoves.Clear();
        }//End while. At this point, all spaces that are used have the "partofpath" bool set to true.



        foreach (space[] ss in allSpaces)
        {
            foreach (space s in ss)
            {
                if (s.partOfPath)
                {
                    WallScript ws = WallArray[s.row][s.col].GetComponent <WallScript>();
                    wallState[s.row][s.col] = 1; // keep track of state.
                    ws.SetHeight(1);             //Set wall down.
                }
                else
                {
                    WallScript ws = WallArray[s.row][s.col].GetComponent <WallScript>();
                    wallState[s.row][s.col] = 0; // keep track of state.
                    ws.SetHeight(0);             //Set wall down.
                }
            }
        }
    }