When referencing GameObjects that I created, the compiler can't find variables of the given names

Question

I'm making a puzzle game, and the basic puzzle mechanics seem to work fine.

However, after coding the core mechanics, I tried to implement a randomizer function so the puzzle wasn't already solved when you first loaded it up. I did the thing that made most sense in my mind, and that was to give each quad a unique name, and there after made them switch positions with the transform.positions command.

When trying to execute this function all I got was an CS0103 error that tells me that the unique assigned names didn't exist in the current context, which makes sense since the quads first will be created when the script is executed.

I just want to know if this is actually possible with my code:

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

public class Puzzle : MonoBehaviour {

    public Texture2D image;

    //Amount of blocks per line(can be changed inside of unity)
    public int blocksPerLine = 4;

    Block emptyBlock;

    //The function that calls the CreatePuzzle function
    void Start()
    {
        CreatePuzzle();
        Randomizer();
    }

    //CreatePuzzle function
    void CreatePuzzle()
    {
        Texture2D[,] imageSlices = ImageSlicer.GetSlices(image, blocksPerLine);
        //Everytime y is equal to 0 and less than the blocksPerLine it will postfix y, meaning it will create another block until it is at its limit.
        for (int y = 0; y < blocksPerLine; y++)
        {
            for(int x = 0; x < blocksPerLine; x++)
            {
                //This creates the gameobject as the primitive type: Quad.
                GameObject blockObject = GameObject.CreatePrimitive(PrimitiveType.Quad);
                blockObject.name = "Piece" + x;
                blockObject.transform.position = -Vector2.one * (blocksPerLine - 1) * .5f + new Vector2(x, y);
                blockObject.transform.parent = transform;

                Block block = blockObject.AddComponent<Block>();
                block.OnBlockPressed += PlayerMoveBlockInput;
                block.Init(new Vector2Int(x, y), imageSlices[x, y]);

                //Creates an empty block, so that you're able to slide the puzzle around
                if(y == 0 && x == blocksPerLine - 1)
                {
                    blockObject.SetActive(false);
                    emptyBlock = block;
                }
            }
        }
        //Sets the sixe of the block to match the Camera view
        Camera.main.orthographicSize = blocksPerLine * .55f;
    }


    void Randomizer()
    {
        Piece0.transform.positions = Piece1.transform.positions;
    }

    //The function that makes the player available to move the blocks
    void PlayerMoveBlockInput(Block blockToMove)
    {
        if ((blockToMove.coord - emptyBlock.coord).sqrMagnitude == 1)
        {
            Vector2Int targetCoord = emptyBlock.coord;
            emptyBlock.coord = blockToMove.coord;
            blockToMove.coord = targetCoord;

            Vector2 targetPosition = emptyBlock.transform.position;
            emptyBlock.transform.position = blockToMove.transform.position;
            blockToMove.transform.position = targetPosition;
        }
    }
}

Answer 1

Store all the blocks you create in a list.

To do that, declare a List at the top:

private List<GameObject> blocks;

And initialize it in createPuzzle() like this:

blocks = new List<GameObject>();

Then fill it like this:

blocks.Add(block);

Then in the randomize function, shuffle the list, for instance, with a method like this one:

private static Random rng = new Random();  

public static void Shuffle<T>(this IList<T> list)  
{  
    int n = list.Count;  
    while (n > 1) {  
        n--;  
        int k = rng.Next(n + 1);  
        T value = list[k];  
        list[k] = list[n];  
        list[n] = value;  
    }  
}

Suggested by @grenade in this answer

Once the list is shuffle, take elements one by one and assign positions in order, like you do now on object creation

Answer 2

The Problem

The exception is thrown because you're trying to reference the created blocks incorrectly. When you execute:

Piece0.transform.positions = Piece1.transform.positions;

What you're telling your program to do is to find a variable named Piece0, find a variable named Piece1, and do things with their transform.positions [sic] value. But here's the problem: You don't actually have any variables named Piece0 or Piece1. So the compiler can't resolve those references!

The Solution

What you do have are GameObjects that you placed into the scene, with the attribute name set to "Piece0" and "Piece1". (This is not the same as creating variables with those names.) So to get references to those objects, before you can access their members, you'll need to take a different approach. Something like GameObject.Find(). As per its description, it:

Finds a GameObject by name and returns it.

So use GameObject.Find() to retrieve references to the two GameObjects, then reassign their positions. Your current code also doesn't really do a switch; rather, it just places one object in the same place as the other, so the logic needs to be improved. And you'll need some intermediate variable to store the original position of one of the objects, before assigning it to the other object.

Here's what all the changes might look like in practice:

void Randomizer()
{
    // Get the references
    GameObject piece0 = GameObject.Find("Piece0");
    GameObject piece1 = GameObject.Find("Piece1");

    // Store the position so it isn't lost
    Vector3 piece0OriginalPos = piece0.transform.position;

    // Switch the positions
    piece0.transform.position = piece1.transform.position;
    piece1.transform.position = piece0OriginalPos;
}