Is your program going to be checking that each entry is correct or not, or just checking the end result of the solve? The end result check should be simple enough -- in that all the clues must be satisfied (just check that). If checking along the way, then the solution should be stored in memory to see that each entry in correct (checking entry with correct value). Obviously, if the solution is stored, then, either way, you can check cell by cell.

I'm aiming to have it so that every time a square is clicked, it checks to see if the current state of the puzzle aligns with the solution. I currently have it so that when the image for a square is filled, its state is true and if the image is unfilled, its state is false but am struggling to implement a good way to store and check it against the solution.

An array of ones and zeros would be sufficient: Just need to keep it updated as things changes

Maybe I should ask how the solution is stored. Plus, how the clues are given.

The clues are just images on the side of the grid. At the moment I have the solution in the square class like this: Thanks :'] edit: just realised there was a typo

A better way to assign the entries is like this: Furthermore, it should not be in your square class -- it should be in your game world class. Also, as above, you should be able to visually see the solution within the entries. If the rows and columns are mixed up and the visual looks tipped on its side, then switch the rows and columns. That is, use the following to assign the entire array in one statementrr: (I always have the entries as such:That is only in code block because brackets are being used here (which will not work well in standard text. Anyway, it is easier to check that you entered the solution properly when everything is aligned. As far as the clues -- you might want to represent them among your data as values. That way, your world can accept (as parameters) as two 2-D arrays (a 3-D array which contains two 2-D arrays for (1) row clues and (2) column clues. Then you can write an algorithm that compares the current solve state with what the clues should produce to verify correctness of the solve. You must already have a way to determine whether a square is filled or not -- otherwise, you would not be able to change its state. So, you should be able to check each squares state against the solution.

Of course, it is possible. Let me make a correction first. The entries as I prefer to give them are in the form: Anyway, you will need to provide the Square class codes along with your world class codes. Cannot fix unseen codes.

Hi, thanks for all the help. My world and square classes are a bit of a mess at the moment since I've tried a bunch of different things. Some code I've temporarily made into comments while I'm testing other things out so it's all a bit jumbled. MyWorld: square:

Your square class can be reduced to the following, for which I removed all unnecessary items. I also capitalized the name of the class as this is how classes are named (by convention). Note that the class only deals with the square objects themselves. Nothing "worldly" should be dealt with here. The world is what controls the game and any checks for game over is done there in the world. Here is the simplified Square class: In your world class, you can combine all the solutions into one array set where the index will refer to the level number itself (minus one): "grid" is the current grid, doesn't matter, first, second, whatever. The "level" value starts at zero ('0'), so when displaying, use "1+level" as the level number. The only thing that needs done when changing levels is adjusting the "level" counter and loading the new grid (plus other resetting stuff not dealing with level or grid). The "top" and "left" clues can also be combined separately using the same index value for corresponding grids.

Just need some code to load a new level to be added to the loadLevel method. You know, whatever needs done to update the display, mainly (displaying the new level number, etc).

Why would you check input with the solution? You should only need to check that the complete solution coincides with the clues. Doing this check can be limited to when the proper number of "on" cells is achieved. This also can be limited to when the solver submits the current solve state as a possible solution (where upon the number of "on" cells is checked first).