Grid System for Puzzle

[RotX18]

Objective: Create a dynamic way of instantiating a grid of objects

Grid system should:

• [x] Flexibility in terms of the dimensions of the grid (ie. Grid size can change case-by-case)
• [x] Allow different elements to be spawned per grid (eg. One grid can have cubes while another can have spheres)
• [x] Have each specific element uniquely identifiable and its position within the grid ascertainable
• [x] Parent every instantiated gridElement to its corresponding grid spawner

From #39:

• [x] Implement IPuzzle interface

[RotX18]

Started work on grid

Requirements for grid:

1. GridElement.cs script for identification of every element within each script and,
2. GridSpawner.cs script for the spawning of a grid using an object with a GridElement.cs component to it

Scripts: GridElement.cs, GridSpawner.cs

GridElement.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Class for every grid element
/// </summary>

public class GridElement : MonoBehaviour {
    #region PRIVATE VARS

    private int _id;
    private float _posX;
    private float _posY;

    #endregion

    #region PROPERTIES

    public int ID {
        get {
            return _id;
        }
        set {
            _id = value;
        }
    }

    public float GridX {
        get {
            return _posX;
        }
        set {
            _posX = value;
        }
    }

    public float GridY {
        get {
            return _posY;
        }
        set {
            _posY = value;
        }
    }

    #endregion
}

Description:

• Used as the identifier for each element in a given grid
  • ID property defines the specific id of the element within a grid
  • GridX and GridY properties define the specific position of the element within a grid
• Assignment of identifiers will be added later

GridSpawner.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Spawner for the grid that takes in a prefab and instantiates
/// it according to the given dimensions of the desired grid
/// </summary>

public class GridSpawner : MonoBehaviour
{
    [Header("Object to be instantiated")]
    public GameObject gridElement;

    [Header("Grid size of lenX * lenY")]
    public int lenX;
    public int lenY;

    [Header("X-axis spacing of spaceX, Y-axis spacing of spaceY")]
    public float spaceX;
    public float spaceY;

    private void Start() {
        for(int i = 0; i < lenY; i++){
            //for each column
            for(int j = 0; j < lenX; j++){
                //for each row in each column
                //instantiating each cube with space inbetween
                Instantiate(gridElement, new Vector3(transform.position.x + j + (j * spaceX), transform.position.y + i + (i * spaceY), transform.position.z), Quaternion.identity);

            }
        }
    }
}

Description:

• Used to spawn a grid with the following dimensions:
  • Grid size of lenX * lenY
  • Spacing of spaceX horizontally and spaceY vertically
• In Start(),
  • first for loop determines the current row, second determines current column
  • In 2nd for loop, we instantiate gridElement at positions relative to the spawning script's location[^spaceCalc]

Note:

• Will start on element identification and improve code later, ID will likely be a concatenation of each element's X and Y position in a grid
• Improvement can be having all cubes be childed to the spawning object for the convenience of the developer

[^spaceCalc]: [j + (j spaceX)] and [i + (i spaceY)] are due to the fact that we are instantiating relative to the spawner and NOT the previous cube; We are doing (iterationNumber) * (number of spaces between first and current cube)

[RotX18]

Improvements to Grid Spawner system

Improvements made include:

• Locally unique ID numbers and coordinates are now assigned for all individual elements of a grid
• Search function to find any individual element in a grid via its ID

Assignment of GridElement properties and implementation of search function

GridElement.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Class for every grid element
/// </summary>

public class GridElement : MonoBehaviour {
    #region PRIVATE VARS
    private float _posX;
    private float _posY;
    private int _id;
    #endregion

    #region PROPERTIES
    public float GridX {
        get {
            return _posX;
        }
        set {
            _posX = value;
        }
    }

    public float GridY {
        get {
            return _posY;
        }
        set {
            _posY = value;
        }
    }
    public int ID {
        get {
            return _id;
        }
        set {
            _id = value;
        }
    }
    #endregion
}

Edit:

• Changed:
  • Reordered variables for better readability when debugging (debugging by changing var accessors)

GridSpawner.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Spawner for the grid that takes in a prefab and instantiates
/// it according to the given dimensions of the desired grid
/// </summary>

public class GridSpawner : MonoBehaviour
{
    #region PUBLIC VARS
    //grid element that will be instantiated
    [Header("Object to be instantiated as elements of the grid")]
    public GameObject gridElement;

    //grid dimensions, lenX units by lenY units
    [Header("Grid size of lenX * lenY")]
    [Min(1)]
    public int lenX;
    [Min(1)]
    public int lenY;

    //spacing between each element along the X and Y axis
    [Header("X-axis spacing of spaceX, Y-axis spacing of spaceY")]
    [Min(0)]
    public float spaceX;
    [Min(0)]
    public float spaceY;
    #endregion

    #region PRIVATE VARS
    private GameObject _instantiatedObj;
    #endregion

    private void Start() {
        for(int i = 0; i < lenY; i++){
            //for each column
            for(int j = 0; j < lenX; j++){
                //for each row in each column
                //instantiating each gridElement with space inbetween
                _instantiatedObj = Instantiate(gridElement, new Vector3(transform.position.x + j + (j * spaceX), transform.position.y + i + (i * spaceY), transform.position.z), Quaternion.identity);

                //setting the X and Y position for the instantiated ibject
                _instantiatedObj.GetComponent<GridElement>().GridX = j;
                _instantiatedObj.GetComponent<GridElement>().GridY = i;

                //converting the gridX and gridY to strings, concatenating and converting value back to int and storing it as the ID
                //eg. if one of the obj is at position (1, 2), its id would be 12
                string idString = j.ToString() + i.ToString();
                _instantiatedObj.GetComponent<GridElement>().ID = int.Parse(idString);

                //setting the instantiated object as a child of the spawner
                _instantiatedObj.transform.parent = gameObject.transform;
            }
        }
    }

    public GameObject FindElementByID(int id){
        //getting all GridElement components from spawner's children
        GridElement[] children;
        children = gameObject.transform.GetComponentsInChildren<GridElement>();

        //iterating through the children array to find first element that has the same id as the query id
        foreach(GridElement ele in children){ 
            if(ele.ID == id){
                //returning gameObject if id matches
                return ele.gameObject;
            }
            else{
                continue;
            }
        }

        //returning null if none of the elements in children have the same id
        return null;
    }
}

Edits:

• Added:

  • Min attributes for length and space parameters so as to avoid issues with invalid numbers
  • Assignment of individual GridElement properties, done in inner for-loop
  • GridElement.GridX and GridElement.GridY are j and i values respectively
  • ID is done by concatenating j and i as strings before converting the concatenation into an int[^id]
  • FindByElementID(int id) [^searchFunction] :
  • Gets all GridElement components in children
  • Iterates through GridElement components, checking each element ID
  • if a specific GridElement's ID property matches the query, return that GridElement's game object
  • returns null if none of the children contain a GridElement with a matching ID

• Changed:

  • Spawned GridElement objects are now childed to their spawner for easy organisation

[^id]: Example: Given an element at position (12, 34), its ID will be "12" + "34" = 1234 [^searchFunction]: Could possibly be computationally expensive

Notes

• For now, all objectives have been completed, may reopen this issue again should there be improvements/enhancements added to it

• Demonstration of Grid System:

All objectives complete, issue can now be closed (closed with commit c34fe37cd9dad4fb723d5b40816fe89b8e4e4e87)

[RotX18]

Integration of VR and porting of existing code to use the Oculus API

• [x] Integrate VR
• [x] Add models for controller
• [x] Change code to use the Oculus API's Input

[RotX18]

Completed integration for grid input

Integration of VR

• Added OVRCameraRigPrefab to the scene to allow for the headset to interface with Unity
• Added Controller models and a visualising pointer to show the raycast

Changed the code to use Oculus API input

I copy-pasted the MouseInput.cs script into PlayerInput.cs as the naming was more appropriate

PlayerInput.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// This script gets the game object under the mouse position and changes it to different colours
/// </summary>

public class PlayerInput : MonoBehaviour {
    #region PUBLIC VARS

    //seletion vars
    public GameObject pointerOrigin;

    //grid vars
    public GameObject gridSpawnerObj;
    public GridManager gridManager;

    #endregion

    #region PRIVATE VARS

    //selection vars
    private Ray _pointerRay;
    private RaycastHit _hit;
    private GameObject _hitObj;

    //grid vars
    private List<GridElement> _elements = new();
    private Dictionary<int, GridElement> _correctEles = new();
    private Dictionary<int, GridElement> _wrongEles = new();

    #endregion

    private void Start() {
        _elements = gridSpawnerObj.GetComponent<GridSpawner>().AllElements;

        //sorting the elements in the grid to correct elements and wrong elements
        foreach(GridElement ele in _elements) {
            if(ele.Correct) {
                _correctEles.Add(ele.ID, ele);
            }
            else {
                _wrongEles.Add(ele.ID, ele);
            }
        }
    }

    private void Update() {
        if(OVRInput.GetDown(OVRInput.Button.SecondaryIndexTrigger)) {
            //when the right trigger is pressed
            if(_hitObj != null) {
                //if the raycast hit is not null
                if(_hitObj.GetComponent<GridElement>().Clickable) {
                    //if the element is clickable
                    _hitObj.GetComponent<GridElement>().Clicked = true;

                    //checking whether the element is correct
                    if(_hitObj.GetComponent<GridElement>().Correct) {
                        //if element is correct, set the colour to green
                        _hitObj.GetComponent<Renderer>().material.color = Color.green;
                    }
                    else {
                        //if element is not correct, reset all current colours
                        gridManager.ResetGrid();
                    }
                }

            }
        }
    }

    private void FixedUpdate() {
        //casting from the main camera to the point on screen where the mouse is
        _pointerRay = new Ray(pointerOrigin.transform.position, pointerOrigin.transform.forward);

        if(Physics.Raycast(_pointerRay, out _hit)) {
            //if the point where the player click contains a gameobject
            _hitObj = _hit.transform.gameObject;
        }
        else {
            _hitObj = null;
        }
    }
}

Edits:

• Added:
  • Variable
  • public GameObject pointerOrigin
• Changed:
  • Changed private Ray _camToScreen to private Ray _pointerRay to reflect the change of input
  • Update():
  • Changed if check to use OVRInput.GetDown(OVRInput.Button.SecondaryIndexTrigger) instead of Input.GetKeyDown(KeyCode.Mouse0) to check for right trigger down instead of left mouse down
  • FixedUpdate():
  • Changed to cast the ray from the right controller to it's positive Z position

Demonstration of changes:

https://user-images.githubusercontent.com/84174550/178666230-b6465eb8-775b-4608-afdb-01b6a655b5bc.mp4

Feature has been implemented, branches can now be merged

[RotX18]

Added ability to rotate the grid in the desired rotation

This simply involved adding 4 lines of code, changes as follows:

Code changes

Grid Spawner.cs (Modified code)

    //degrees to rotate the entire grid by
    [Header("Initial rotation of the grid")]
    public float rotX = 0;
    public float rotY = 0;
    public float rotZ = 0;

    private void Awake(){
        //rotating the grid after all elements have spawned
        transform.Rotate(new Vector3(rotX, rotY, rotZ));
    }

Edits:

• Added:
  • rotX, rotY and rotZ rotation variables to determine how to rotate the grid after elements have spawned in
• Changed:
  • Awake():
  • added transform.Rotate(new Vector3(rotX, rotY, rotZ)); to rotate the entire grid after spawning

Demonstration

With all rotations set to 0 (default)

With rotations set with random values

Enhancement complete, issue will now be closed

[RotX18]

Integrated IPuzzle interface into grid system + improvements

Implemented the new IPuzzle interface into the grid system for better streamlining of code

GridManager.cs

public class GridManager : MonoBehaviour, IPuzzle
{
    private int _totalCorrects = 0;
    private int _clickedCorrects = 0;

    public bool Completed {
        get;
        set;
    } = false;

    public void OnComplete(){
        //ADD COMPLETED EFFECTS HERE
        Debug.Log("GRID HAS BEEN COMPLETED");
    }

    private void Start() {
        foreach(GridElement ele in _elements){ 
            if(ele.Correct){
                //keeping count the total number of correct elements
                _totalCorrects++;
            }
        }
    }

    private void Update() {
        //completed check
        if(_clickedCorrects == _totalCorrects){
            //if the number of clicked correct elements = total number of correct elements
            Completed = true;
        }
    }

    public void ResetGrid() {
        _clickedCorrects = 0;
    }
}

Edits:

• Added:
  • _totalCorrects and _clickedCorrects integers to keep track of the ratio of clicked correct elements to total correct elements
  • Completed property and OnComplete() method from IPuzzle
  • OnComplete() has a placeholder Debug.Log() for now, it should be replaced at a later date
  • In Start():
  • New foreach loop iterates through all elements tof ind the correct elements in the total, increments _totalCorrects if the current element is correct
  • In Update():
  • Sets Completed to true if the number of clicked correct elements equals the total number of total correct elements
  • In ResetGrid():
  • Now resets _clickedCorrects back to 0

Notes

• Further improvement of the grid is possible; Make it so that the grid is sequential horizontally as well, will work on this in the coming weeks

[RotX18]

Bug fix: Grid throwing NullReferenceError when pressing right trigger

Issue:

Did not account for whether the raycast hit object had a GridElement component.

Solution:

Add a check to test whether the hit object contained a GridElement component

Code changes

In GridInput.cs (Modified code)

if(_hitObj.GetComponent<GridElement>() != null){
    //if the hit object has a GridElement component
    //CODE HERE
}

Description:

• If statement checks using Object.GetComponent() to see whether the object has a GridElement component.

Fixed issue with Grid throwing NullReferenceError when pressing right trigger

[RotX18]

Bug Fix: Grid completing before all correct elements were clicked

Issue:

Did not check whether corrects were clicked before incrementing ClickedCorrects

Solution:

Account for whether the correct being clicked has been clicked prior via GridElement.Clicked

Code changes

GridInput.cs (Modified code)

//checking whether the element is correct
if(_hitObj.GetComponent<GridElement>().Correct) {
    //if element is correct, set the colour to green
    _hitObj.GetComponent<Renderer>().material.color = Color.green;

    if(!_hitObj.GetComponent<GridElement>().Clicked){
        //if the current object has not yet been clicked prior
        gridManager.ClickedCorrects++;
        _hitObj.GetComponent<GridElement>().Clicked = true;
    }
}

Edits:

• Added:
  • if statement in correct check to test for whether the current hit object has been clicked prior, if not previously clicked, increment gridManager.ClickedCorrects and set the object's GridElement.Clicked to true

Bug has been fixed

[RotX18]

Improved grid system; Correct elements have to be clicked in order

Previously, all correct elements in a given row could be clicked in any order, with the grid progressing as long as all correct elements within that row were clicked. With this change, that is no longer the case, now even if the clicked element within the row is correct, if it is not the next element in the sequence, it will reset the entire grid.

Code changes + Description

Changes can be found in GridInput.cs

GridInput.cs (Modified code)

private int _intendedCorrectIndex = 0;

//CORRECT ELEMENT CHECK IN Update(); Start line 62

//get current correct's index in gridManager
int currentCorrectIndex = Array.IndexOf(gridManager.correctElementIDs, gridSpawner.FindElementByID(_hitObj.GetComponent<GridElement>().ID).GetComponent<GridElement>().ID);

//CLICKED ELEMENT CHECK FOUND IN Update(); Start line 70

//comparing the current correct's index to the next correct in sequence
if(currentCorrectIndex == _intendedCorrectIndex){
    //if the currentCorrectIndex is the same as the _intendedCorrectIndex, increment _intendedCorrectIndex
    _intendedCorrectIndex++;
}
else{
    //if the currentCorrectIndex is not the next one in sequence, reset
    gridManager.ResetGrid();
    _intendedCorrectIndex = 0;
}

Edits:

• Added:
  • _intendedCorrectIndex int to keep track of the next correct element in sequence
  • _currentCorrectIndex int to store the index of the current index
• Notes:
  • The script now checks for the current correct element's index in the gridManager's correct ID array
  • If the current element's index is the same as that of the intended current correct element from gridManager's , it increments and continues, if not it resets the grid

[RabbitKazma]

Changes on grid Code

_instantiatedObj = Instantiate(gridElement, new Vector3(transform.position.x + j + (j * (spaceX -(1-gridElement.transform.localScale.x))), transform.position.y + i + (i * (spaceY - (1 - gridElement.transform.localScale.y))), transform.position.z), Quaternion.identity);

• We realized that we need to account for the extra space the prefab creates when is scaled down. When the default is scale is 1 there is no issues but when the prefab is smaller, there will be extra space even though spaceX/spaceY is 0. To account for this, each time we create space we deduce the extra area the grid elment creates every loop, (spaceX -). Then, to get the amount of extra space we do (1-gridElement.transform.localScale.x). We repeat this for Y.