Random "Path" Generation Code - wolfram-mathematica

Question

I am currently working on generating a random path for a game I am recreating. It is based off of the "Thin Ice" game in Club Penguin where you play as a fire character, walk across a path of ice, and get to the exit, melting as many ice blocks as possible along the way. (Link to play: http://justdoodiecp.weebly.com/play-thin-ice.html)
This game has preset boards. The game I am making will have random board generation. I have run into many issues with this.
I am currently coding in Mathematica, but would appreciate any input.
So far, I have been creating a "random walk" in a square grid. The grid is a two dimensional list of {},{0},{1},{2},{3}. The walk moves either up, down, left or right, never diagonally and never staying in the same place. It also cannot walk back on itself.The walk replaces {} with {0} at the positions it goes to and cannot go to any spot with 0,1,2, or 3 currently in place. It starts at 2. The goal is to get it to eventually stop at 3, but I'm thinking I may do away with the value of three until the walk is complete. It can travel adjacent to another section of the path, with no wall in between them. This walk continues on until it traps itself OR the amount of {0} is equal to the dimensions minus the amount of obstacles that should be placed. The amount of obstacles is inputted when calling the function. However, I do not want the function to trap itself but instead fill up the board with {0} until the amount of {0} is equal to the dimensions minus the amount of obstacles that should be placed. Once the path is generated, all obstacles will be placed in any blank spots, replacing them with {1}.
Here is my code so far:
gameboard2[dim_, obs_] :=
(*0 = blank, 1= obstacles, 2 = start, 3 = exit, 4 = water*)
Module[{i, j, board = {}, boardPts = {}, x = 1, y = 1, endx = 1,
endy = 1, prevx = 1, prevy = 1, possibleValues = {}, pt = {},
blankspc = dim^2 - 2 - obs},
board = Table[{}, {i, 1, dim + 2}, {j, 1, dim + 2}];
(*Generation of border*)
Table[board[[1, i]] = {1}, {i, 1, dim + 2}];
Table[board[[dim + 2, i]] = {1}, {i, 1, dim + 2}];
For[i = 1, i <= Length[board], i++,
board[[i, 1]] = {1};
board[[i, dim + 2]] = {1};
];
(*Random start point placement*)
While[Count[board, {2}, 2] != 1,
x = RandomChoice[Table[i, {i, 1, dim + 2}]];
y = RandomChoice[Table[i, {i, 1, dim + 2}]];
If[board[[x, y]] != {1}, board[[x, y]] = {2}];
];
(*Random exit point placement*)
While[Count[board, {3}, 2] != 1,
endx = RandomChoice[Table[i, {i, 1, dim + 2}]];
endy = RandomChoice[Table[i, {i, 1, dim + 2}]];
If[board[[endx, endy]] != {1}, board[[endx, endy]] = {3}];
];
(*Random path generation*)
(*x needs to be between 2 and dim+1 and y needs to be between 2 and dim+1*)
For[i = 1, i <= blankspc, i++,
prevx = x; prevy = y;
possibleValues = {};
(*Testing position of x and y, making sure they are not on the side or the corner of the board*)
If[x == 2,
If[y == 2, (*bottom left*) possibleValues = {{x, y + 1}, {x + 1, y}},
If[y == dim + 1, (*top left*)
possibleValues = {{x, y - 1}, {x + 1, y}},
(*left side*) possibleValues = {{x, y + 1}, {x, y - 1}, {x + 1, y}}]],
If[x == dim + 1,
If[y == 2, (*bottom right*) possibleValues = {{x, y + 1}, {x - 1, y}},
If[y == dim + 1, (*top right*)
possibleValues = {{x, y - 1}, {x - 1, y}},
(*right side*)
possibleValues = {{x, y + 1}, {x, y - 1}, {x - 1, y}}]],
If[y == 2, (*bottom*)
possibleValues = {{x, y - 1}, {x - 1, y}, {x + 1, y}},
If[y == dim + 1,(*top*)
possibleValues = {{x, y + 1}, {x - 1, y}, {x + 1,
y}},(*Not on any side or corner*)
If[x > 2 && x < dim + 1 && y > 2 && y < dim + 1,
possibleValues = {{x, y + 1}, {x, y - 1}, {x + 1, y}, {x - 1,
y}}, possibleValues = {{x, y}}]
]
]
]
];
(*Ensure every position in possibleValues is equal to {} on the board*)
For[j = 1, j <= Length[possibleValues], j++,
If[board[[possibleValues[[j, 1]], possibleValues[[j, 2]]]] != {},
possibleValues[[j]] = {}];
];
possibleValues =
Delete[possibleValues, Position[possibleValues, {}]];
(*Random choosing of a point to move to*)
pt = RandomChoice[possibleValues];
x = pt[[1]];
y = pt[[2]];
If[board[[x, y]] == {}, board[[x, y]] = {0}];
];
(*Prints amount of {} and the length of the path to see if it became the right length*)
Print[blankspc];
Print[Count[board, {0}, 2]];
Return[TableForm[board]]
]
Output:
In[30]:= gameboard2[10, 30]
(*Note how many errors there are. This occurs when the path gets trapped and cannot move to any squares around it*)
During evaluation of In[30]:= RandomChoice::lrwl: The items for choice {} should be a list or a rule weights -> choices. >>
During evaluation of In[30]:= Part::partw: Part 2 of RandomChoice[{}] does not exist. >>
During evaluation of In[30]:= Part::pkspec1: The expression RandomChoice[{}][[2]] cannot be used as a part specification. >>
During evaluation of In[30]:= RandomChoice::argt: RandomChoice called with 0 arguments; 1 or 2 arguments are expected. >>
During evaluation of In[30]:= Part::partw: Part 1 of RandomChoice[] does not exist. >>
During evaluation of In[30]:= Part::partw: Part 2 of RandomChoice[] does not exist. >>
During evaluation of In[30]:= General::stop: Further output of Part::partw will be suppressed during this calculation. >>
During evaluation of In[30]:= Part::pkspec1: The expression RandomChoice[][[1]] cannot be used as a part specification. >>
During evaluation of In[30]:= RandomChoice::argt: RandomChoice called with 0 arguments; 1 or 2 arguments are expected. >>
During evaluation of In[30]:= Part::pkspec1: The expression RandomChoice[][[1]] cannot be used as a part specification. >>
During evaluation of In[30]:= General::stop: Further output of Part::pkspec1 will be suppressed during this calculation. >>
During evaluation of In[30]:= RandomChoice::argt: RandomChoice called with 0 arguments; 1 or 2 arguments are expected. >>
During evaluation of In[30]:= General::stop: Further output of RandomChoice::argt will be suppressed during this calculation. >>
During evaluation of In[30]:= 68
(*This is how many {0} there should be*)
During evaluation of In[30]:= 45
(*This is how many there are*)
{{{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}},
{{1}, {}, {}, {}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, {1}},
{{1}, {}, {}, {}, {0}, {0}, {0}, {0}, {}, {}, {0}, {1}},
{{1}, {}, {}, {}, {0}, {0}, {0}, {0}, {}, {}, {0}, {1}},
{{1}, {}, {}, {}, {0}, {0}, {0}, {0}, {}, {}, {0}, {1}},
{{1}, {}, {}, {}, {0}, {0}, {0}, {0}, {}, {}, {0}, {1}},
{{1}, {}, {}, {}, {0}, {0}, {}, {}, {}, {}, {0}, {1}},
{{1}, {}, {}, {}, {}, {3}, {}, {0}, {0}, {}, {0}, {1}},
{{1}, {}, {}, {}, {}, {0}, {0}, {0}, {0}, {0}, {0}, {1}},
{{1}, {}, {}, {}, {}, {0}, {}, {2}, {0}, {}, {}, {1}},
{{1}, {}, {}, {}, {}, {0}, {0}, {0}, {0}, {}, {}, {1}},
{{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}}}]
I've looked all over the internet for various path generation tips and tricks, but none have been what I am looking for. Most allow the path to go back on itself, or move diagonally, or generate a maze. These will not work.
Can anyone help me uncover the correct logic? If I was not clear, please ask questions! :)
Thanks!