Need help creating a boundless array for Arduino (c/c++)

Question 1

I'd recommend you look into std::vector.

On the first line after you check if (play = 1) your main play area, you run a for loop using sizeof(setOrder) without having put data into setOrder first. Even if this did compile, logically your code would always skip the loop. Once you figure out vectors (which I'm pretty sure is what you're looking for), you might want to change this to checking the size of your setOrder vector against a predefined maximum value (at which point the player wins?).

Here's a tutorial on vectors I found from google.

Also, a couple other possible mistakes/recommendations here:

break your loop down into several sub-functions that you can call, so that reading your code isn't one giant block. This will also make it easier to find errors, as you can check that each function works, one function at a time.
When you check if (play = 1), you're actually using the assignment = operator, not a conditional check ==. You're assigning the value of 1 to play, instead of checking to see if play is equal to 1.
You're using sizeof(setOrder) incorrectly. sizeof(X) returns the number of bytes X takes up, not necessarily the number of elements in X. If you use a vector, there's a vector.size() function that returns the number of elements in the vector
Whem you check for the player's action, you call analogRead(xAxis) four times - once for each direction. The player's first input will always be checked in the first call. If it's false, the player will need to give another input to make it to the second if statement.

Question 2

For the direction detection, you might look at something like this:

enum Directions {
    Center,
    Left,
    Right,
    Up,
    Down
}

const int threshold = 100;

int getJoyStick() 
{
    // get the X,Y coordinates with 0,0 the centre
    int x = analogRead(xAxis) - 500;
    int y = analogRead(yAxis) - 500;

    /check if we are in the middle.  Both X and Y need to be small for this to happen
    if (abs(x) < threshold && abs(y) < threshold) return Center;

    //to detect up, down, left, right draw diagonals at 45 degrees from the centre
    //if we are more to the right than we are up or down, then it is Right.  This
    //is to cope if it isn't exactly horizonal or vertical
    //so y big might mean up, but if x is bigger, than it is actually to the right
    if (x>y) {
      if (x>-y) return Right; else return Down;
    }
    else {
      if (x>-y) return Up; else return Left;
    }
}

The enum is just to show the nice way of doing it. You would just the same codes through all the code. But instead if it's simpler for you, you could just return numeric codes for each of the directions.

Question 3

If you are in c++ langage like the c++ tag in your post suggest so, use std::vector instead of array.

A vector is a list that can grow during program execution. Here is a documentation about vector.

Question 4

If you are going to use plain old C arrays, the easiest path would be an array of static length, long enough to accept your biggest number of entries. Then you keep a separate counter saying how much of the array you are using at the moment.

const int MAX_ORDER_LENGTH = 1024;
int setOrder[MAX_ORDER_LENGTH];
int setOrderSize = 0;  //the number of entries currently used

Then when you are adding entries, make sure that setOrderSize stays less than MAX_ORDER_LENGTH.

beware that sizeof(setOrder) doesn't give the number of entries in the array. It is actually the number of bytes that structure takes up.

the break; commands will drop you out of the innermost for loop, but not the outer one.