コード例 #1
0
ファイル: BuilderScript.cs プロジェクト: JohnLuigi/CubeCross
    // Update is called once per frame
    void Update()
    {
        // If the savingUI is being used, don't make the puzzle interactable.
        if (usingSaveUI)
        {
            return;
        }

        // If the clueEditor is being used, don't do anything
        // This is mostly because saving during clue edit mode will be a different
        // save function than the build saving mode.
        if (clueEditScript.editingClues)
        {
            return;
        }

        // Cast a ray every frame, in case we click on a cube or are hovering over a cube
        // that needs a face lit up.

        RaycastHit hit;
        Ray        ray = Camera.main.ScreenPointToRay(Input.mousePosition);

        // If the player does a single left click on a cube, make a new cube "attached" to its face
        if (Input.GetMouseButtonUp(0))
        {
            if (Physics.Raycast(ray, out hit, Mathf.Infinity))
            {
                if (hit.transform.gameObject.tag == "BuildCube")
                {
                    // if we are deleting cubes
                    if (deletingCubes)
                    {
                        //TODO
                        // Add possible undo queue adding of cubes that were deleted here.

                        // If there is only one cube left (if cubeCount is 0), don't delete the cube.
                        // AKA this if statement won't be reached.
                        if (cubeCount >= 1)
                        {
                            // Delete the cube
                            Destroy(hit.transform.gameObject);
                            // Reduce the count of cubes by 1 since a cube was deleted.
                            cubeCount--;
                        }


                        // TODO
                        // update puzzle bounds here

                        return;
                    }
                    // if we are set to add cubes (deleteCubes == false)
                    else if (!deletingCubes)
                    {
                        // This is one unit away from the clicked cube, in the direction of
                        // the normal of the face that was clicked on.
                        newSpot = hit.transform.position + (hit.normal.normalized * 1.0f);

                        newCube = Instantiate(originalCube, newSpot, hit.transform.rotation) as GameObject;

                        newCube.transform.parent = gameObject.transform;

                        // Icrement the number of cubes built by 1, and name the cube based on that number
                        cubeCount++;
                        newCube.name = "BuildCube" + cubeCount;

                        // TODO
                        // Set the Faces of the cube to be light or dark gray (alternating)


                        // TODO
                        // Store each cube that was made in a list.
                        // This list will eventually be saved as a puzzle solution.

                        // Get the face of the cube that was hit.
                        string faceHit = GetFaceHit(hit.triangleIndex);

                        // Get the indices of the cube that was clicked on.
                        CubeScript hitCubeScript = hit.transform.gameObject.GetComponent <CubeScript>();
                        PuzzleUnit hitUnit       = hitCubeScript.GetPuzzleUnit();

                        // Create an array of three integers that are the change in x,y,z.
                        int[] indexChange = ReturnDimensionChange(faceHit);

                        // Create indices for the new cube based on the face of the hitCube
                        // that was clicked on.
                        int newX = hitUnit.xIndex + indexChange[0];
                        int newY = hitUnit.yIndex + indexChange[1];
                        int newZ = hitUnit.zIndex + indexChange[2];

                        cubeID++;

                        //TODO
                        // Determine if I should just use this line instead.
                        // Possibly add this unit to the list
                        PuzzleUnit newUnit = new PuzzleUnit(newX, newY, newZ, cubeID);

                        // Add this newly made puzzleUnit to the puzzleSolution's list.
                        puzzleSolution.AddUnit(newUnit);

                        // Save the newly created PuzzleUnit to the newly created cube's CubeScript.
                        CubeScript newCubeScript = newCube.GetComponent <CubeScript>();
                        newCubeScript.SetPuzzleUnit(newX, newY, newZ, cubeID);


                        /*
                         * Debug.Log("OldX: " + hitUnit.xIndex + "\nOldY: " + hitUnit.yIndex
                         + "\nOldZ: " + hitUnit.zIndex + "\n\nNewX: " + newX +
                         +  "\nNewY: " + newY + "\nNewZ: " + newZ);
                         */
                    }
                } // end of if tag == "buildingCube"
            }     // end of if raycast
        }         // end of if GetMouseButtonUp(0)

        // If the player presses the Space key, change the status of the deletingCubes
        //variable to its opposite so it toggles between deleting cubes and adding cubes.
        if (Input.GetKeyUp(KeyCode.Space))
        {
            deletingCubes = !deletingCubes;

            // If set to deleting cubes, make the text show deleting.
            if (deletingCubes)
            {
                tempBuildText = "Deleting";
            }
            // If set to not deleting cubes, make the text show adding.
            else
            {
                tempBuildText = "Adding";
            }

            // Update the text of the build status object.
            buildStatusObject.text = tempBuildText;
        }

        // If the s key is pressed, save a JSON file
        if (Input.GetKeyUp(KeyCode.S))
        {
            // TODO
            // Call the method that shows a text input field to name the puzzle.
            uiManager.DisplayTextInputField(true);
            usingSaveUI = true;
            uiManager.SetInputStatus(true);
        }


        // if the RMB is being continuously held down, rotate the entire puzzle about the average center of itself
        if (Input.GetMouseButton(1))
        {
            RotatePuzzle();
        }

        // If the player is simply hovering over a cube, highlight its face,
        // specifically the face of the first cube hit by the raycast.
        if (Physics.Raycast(ray, out hit, Mathf.Infinity))
        {
            if (hit.transform.gameObject.tag == "BuildCube")
            {
                // Reference to previous face in case a new face is hovered over
                string oldFace = lastFace;

                // Reference to previous cube object in case a new cube is hovered over
                GameObject oldCubeHoveringOver = cubeHoveringOver;

                // Reference to the cube being currently hovered over
                cubeHoveringOver = hit.transform.gameObject;

                //TODO
                // Set light or dark gray here.
                // If we are hovering over a new cube, set the old cube to be its default gray.
                if (cubeHoveringOver != oldCubeHoveringOver && oldCubeHoveringOver != null)
                {
                    oldCubeHoveringOver.GetComponent <CubeFacesScript>().SetAllVertices(lightGrayFaceCoords);
                }

                /* Triangle indices for each cube face
                 * front = 4,5
                 * right = 10,11
                 * top = 2,3
                 * back = 0,1
                 * left = 8,9
                 * bottom = 6,7
                 */

                int hitTriangle = hit.triangleIndex;

                string faceHit = "";

                // WEIRD CODE
                // I had to switch the faces/triangles for front/back and left/right.
                // Not sure why. Face selection was working fine until this set of if statements.
                if (hitTriangle == 0 || hitTriangle == 1)
                {
                    faceHit = "front";
                }
                if (hitTriangle == 2 || hitTriangle == 3)
                {
                    faceHit = "top";
                }
                if (hitTriangle == 4 || hitTriangle == 5)
                {
                    faceHit = "back";
                }
                if (hitTriangle == 6 || hitTriangle == 7)
                {
                    faceHit = "bottom";
                }
                if (hitTriangle == 8 || hitTriangle == 9)
                {
                    faceHit = "right";
                }
                if (hitTriangle == 10 || hitTriangle == 11)
                {
                    faceHit = "left";
                }

                lastFace = faceHit;

                // If the lastFace hovered over is the same as the new face (no change in face
                // being hovered over) don't do anything.
                // If it's a new cube but the same face (moving along a row of cubes) continue,
                // but if its the same face on the same cube, don't do anything.
                if (lastFace.Equals(oldFace) && cubeHoveringOver == oldCubeHoveringOver)
                {
                    return;
                }

                // If a new face is being hovered over, set the last face to be its
                // respective gray again.

                // TODO set light/dark gray faces to gray here
                if (oldCubeHoveringOver != null)
                {
                    oldCubeHoveringOver.GetComponent <CubeFacesScript>().SetFace(oldFace, "LightGray");
                }


                // Now that we know which face was hit, set that face to be red while we are over it
                CubeFacesScript hitCubeScript = hit.transform.gameObject.GetComponent <CubeFacesScript>();
                hitCubeScript.SetFace(faceHit, "Red");

                // Set the color change tracker to true since a color on some cube was altered,
                // and thus needs to be undone if no cube is being hovered over in the future (else below).
                colorWasChanged = true;
            }
        } // end of raycast hit block

        // If the ray hasn't hit any cubes, set the faces of the last cube to be their original
        // shade of gray, then set the checker to update textures to false so it isn't constantly
        // trying to set a texture somewhere.
        else
        {
            // set faces of lastCube to be dark or light
            // If the color of a cube was changed but we are no longer over a cube, undo the
            // color change of the last hit cube.
            if (colorWasChanged)
            {
                // If the cube that was being hovered over no longer exists (was deleted) do no more.
                if (cubeHoveringOver == null)
                {
                    return;
                }

                // TODO set this to be light or dark gray
                cubeHoveringOver.GetComponent <CubeFacesScript>().SetAllVertices(lightGrayFaceCoords);

                //Reset all tracking values so as if it was selecting a cube for the first time.
                lastFace         = "";
                cubeHoveringOver = null;

                // Then make it so there are no cubes to have to change color
                colorWasChanged = false;
            }
        }



        // Camera zoom block
        // update cameraDistance based on how the scroll wheel is being used
        cameraDistance += Input.GetAxis("Mouse ScrollWheel") * scrollSpeed;
        cameraDistance  = Mathf.Clamp(cameraDistance, cameraDistanceMax, cameraDistanceMin);

        // set the camera's z value based on the updated cameraDistance
        Camera.main.transform.position = new Vector3(Camera.main.transform.position.x, Camera.main.transform.position.y,
                                                     cameraDistance);
    }
コード例 #2
0
ファイル: BuilderScript.cs プロジェクト: JohnLuigi/CubeCross
    //TODO
    //CONTINUE FROM HERE
    // Set up the object that will contain the list of cubes/dimensions of puzzle
    // and update those values as cubes are added/deleted.



    void Start()
    {
        uiManager      = GameObject.Find("UIManager").GetComponent <UIManagerScript>();
        clueEditScript = GameObject.Find("ClueEditManager").GetComponent <ClueEditScript>();

        // the game starts at 1 cubes having been built (index 0)
        cubeCount = 0;
        lastFace  = "";

        colorWasChanged = false;

        //TODO might have to reset this every time build mode is started.
        cubeID = 0;               // Initialize the cubeID that will increment every time a cube is made.

        deletingCubes = false;    // The default for build mode is to add cubes.
        tempBuildText = "Adding"; // The default for build mode is to add cubes.

        usingSaveUI = false;      // The UI in build mode starts hidden, so it is initially not
                                  // being used.



        // Create the first cube at 0,0,0 and with 0 rotation.
        fullBuildCube = Instantiate(originalCube, Vector3.zero, Quaternion.identity) as GameObject;
        // Parent the starting cube to the manager so it can be rotated with the puzzle.
        fullBuildCube.transform.parent = gameObject.transform;
        // The first cube gets the name "BuildCube0"
        fullBuildCube.name = "BuildCube" + cubeCount;

        // Set the first cube's attached PuzzleUnit to be at 0,0,0 with ID 0.
        CubeScript firstCubeScript = fullBuildCube.gameObject.GetComponent <CubeScript>();

        firstCubeScript.SetPuzzleUnit(0, 0, 0, 0);


        // Initialize the puzzle solution that will be converted to a JSON file when saved.
        puzzleSolution = new PuzzleSolution();

        // Add the first cube to the puzzleSolution's list of PuzzleUnits.
        puzzleSolution.AddUnit(firstCubeScript.GetPuzzleUnit());

        CubeFacesScript faceScript = fullBuildCube.GetComponent <CubeFacesScript>();

        float div = faceScript.div;

        // Set the faces for the fullBuildCube to be all one color
        lightGrayFaceCoords = new Vector2[] {
            new Vector2(0f * div, 1f * div),
            new Vector2(1f * div, 1f * div),
            new Vector2(0f * div, 0f * div),
            new Vector2(1f * div, 0f * div)
        };

        darkGrayFaceCoords = new Vector2[] {
            new Vector2(1f * div, 1f * div),
            new Vector2(2f * div, 1f * div),
            new Vector2(1f * div, 0f * div),
            new Vector2(2f * div, 0f * div)
        };

        redFaceCoords = new Vector2[] {
            new Vector2(7f * div, 1f * div),
            new Vector2(8f * div, 1f * div),
            new Vector2(7f * div, 0f * div),
            new Vector2(8f * div, 0f * div)
        };

        faceScript.SetAllVertices(lightGrayFaceCoords);

        // set the reference to the buildStatusText object
        buildStatusObject      = GameObject.Find("FlagStatusText").GetComponent <Text>();
        buildStatusObject.text = tempBuildText;
    }
コード例 #3
0
    // This will make the cube GameObject in the parameter have its corresponding faces
    // toggled between blank and numbered.
    public void ToggleCubeFace(GameObject cubeObj, string facesToChange)
    {
        //CubeScript tempScript = cubeObj.GetComponent<CubeScript>();

        //PuzzleUnit puzzUnit = tempScript.GetPuzzleUnit();

        CubeFacesScript tempFacesScript = cubeObj.GetComponent <CubeFacesScript>();

        //TODO
        // Get the color to set the cube to be light or dark gray to
        // maintain the checkerboard pattern.

        // This will be the status of the faces to hide before being clicked on.
        // Default to false.
        bool facesToHideStatus = false;

        // Determine which pair of faces need to be checked to see if they
        // have their clues shown or not.
        if (facesToChange.Equals("front") || facesToChange.Equals("back"))
        {
            facesToHideStatus = tempFacesScript.frontBackClueHidden;
        }
        if (facesToChange.Equals("top") || facesToChange.Equals("bottom"))
        {
            facesToHideStatus = tempFacesScript.topBottomClueHidden;
        }
        if (facesToChange.Equals("left") || facesToChange.Equals("right"))
        {
            facesToHideStatus = tempFacesScript.leftRightClueHidden;
        }



        // If the cube face is currently set to be hidden (within the context of the
        // clue editor mode being active), show the original puzzle faces.
        if (facesToHideStatus)
        {
            // If the faces are numbered, set the faces to gray
            // and set the corresponding facePairClueHidden value in the CubeFacesScript
            // to false.
            if (facesToChange.Equals("front") || facesToChange.Equals("back"))
            {
                tempFacesScript.SetFace("front", tempFacesScript.frontBack);
                tempFacesScript.SetFace("back", tempFacesScript.frontBack);

                tempFacesScript.frontBackClueHidden = false;
                tempFacesScript.SetFacesHidden("frontback", false);
            }
            if (facesToChange.Equals("top") || facesToChange.Equals("bottom"))
            {
                tempFacesScript.SetFace("top", tempFacesScript.topBottom);
                tempFacesScript.SetFace("bottom", tempFacesScript.topBottom);

                tempFacesScript.topBottomClueHidden = false;
                tempFacesScript.SetFacesHidden("topbottom", false);
            }
            if (facesToChange.Equals("left") || facesToChange.Equals("right"))
            {
                tempFacesScript.SetFace("left", tempFacesScript.leftRight);
                tempFacesScript.SetFace("right", tempFacesScript.leftRight);

                tempFacesScript.leftRightClueHidden = false;
                tempFacesScript.SetFacesHidden("leftright", false);
            }
        }
        // Otherwise if the clues on this face are set to be shown, set the faces
        // to be hidden (blank).
        else
        {
            // Set the gray for a face to be set as light or dark gray.
            string grayType = "LightGray";
            if (tempFacesScript.dark)
            {
                grayType = "DarkGray";
            }

            // If the faces are numbered, set the faces to gray
            // and set the corresponding facePairClueHidden value in the CubeFacesScript
            // to true.
            if (facesToChange.Equals("front") || facesToChange.Equals("back"))
            {
                tempFacesScript.SetFace("front", grayType);
                tempFacesScript.SetFace("back", grayType);

                tempFacesScript.frontBackClueHidden = true;
                tempFacesScript.SetFacesHidden("frontback", true);
            }
            if (facesToChange.Equals("top") || facesToChange.Equals("bottom"))
            {
                tempFacesScript.SetFace("top", grayType);
                tempFacesScript.SetFace("bottom", grayType);

                tempFacesScript.topBottomClueHidden = true;
                tempFacesScript.SetFacesHidden("topbottom", true);
            }
            if (facesToChange.Equals("left") || facesToChange.Equals("right"))
            {
                tempFacesScript.SetFace("left", grayType);
                tempFacesScript.SetFace("right", grayType);

                tempFacesScript.leftRightClueHidden = true;
                tempFacesScript.SetFacesHidden("leftright", true);
            }
        }



        // TODO
        // Figure out if I need to save the entire 3D array of cubes
        // that have clues hidden/shown, or to have an array of cubes in
        // the outermost layers that can be used to determine which cubes
        // have their faces hidden/shown.
    }