Slitherlink. Supervisor: David Rydeheard. Date: 06/05/10. The University of Manchester. School of Computer Science. B.Sc.(Hons) Computer Science

Transcription

1 Slitherlink Student: James Rank Supervisor: David Rydeheard Date: 06/05/10 The University of Manchester School of Computer Science B.Sc.(Hons) Computer Science

2 Abstract Title: Slitherlink Author: James Rank Date: 06/05/10 Supervisor David Rydeheard Slitherlink also known as Loop-the-Loop is a Japanese puzzle like Sudoku. Unfortunately there is little information on these puzzles mainly due to the lack of popularity in the puzzle. Slitherlink is a lot more complex than Sudoku, like humans the puzzle is also a lot harder for a computer to solve. This report details the entire process of the project from the beginning, starting with research into the puzzle. The report goes through the designing of the system, as well as implementing the system including the problems I came across. We finish with the explanation of the finished result and the evaluation of the overall system and project. As well as describing what the project entailed we also go onto discuss the possible expansions for the system. This looks at improving the current system as well as extensions that could be implemented into the system. 1

3 Acknowledgements I would like to thank my tutor for the help and guidance he has given me throughout the entire project. This guidance has been essential to the completion of this project. I would like to thank my fellow computer scientist John Panteli for his help in debugging my system and helping me figure out different methods around problems I came across with the project. I would also like to help the people who tested my system as it has helped me to see problems in my system as well as possible improvements I could implement into the system. Also their feedback into what users like to see in a system will help in future projects. 2

4 Table Of Contents Introduction...4 The Puzzle...4 The System...5 Existing Software...5 Research...6 Other Slitherlink Systems...6 Programming Languages...7 Design...8 Slitherlink Grid...8 Solving Techniques...9 Generating Puzzles...10 Difficulty Rating...11 Tutorial System...11 Import And Export Of Puzzles...12 Graphical User Interface...12 Playing And Solving Puzzles...12 Implementation and Results...13 Programming Language Chosen...13 Grid Representation...13 Solvers...14 Generating Puzzles...15 Difficulty...16 Graphical User Interface...17 Tutorial System...23 Testing and Performance...25 Testing Of Solving Techniques...25 User Feedback From Testers...27 Evaluation...30 Unachieved Aims...30 Improvements For The Current System...30 Future Expansions Onto The System...31 Conclusion...32 Aims Of The Project...32 Overall Conclusion...32 References...33 Appendix

5 1. Introduction 1.1The Puzzle Slitherlink was invented in Japan by Nikoli Puzzles around 1989, it is also known as Sli-Lin; Fences; Loop the Loop and Dotty Dilemma. Slitherlink was based on an earlier 2-player game named Slither. This game involves two players competing against each other on a paper grid by linking grid-line segments one after the other without crossing, branching or closing the loop. The idea is to force the other player to cross the loop first making them lose the game. [1] Commonly named Sli-Lin by Nikoli's fans in Japan, Slitherlink puzzles made their début in June 1989, in issue 26 of Nikoli s Puzzle Times. Early versions of the puzzles contained clues in every square. Since then Slitherlink puzzles have been appearing in this quarterly magazine on a regular basis as well as in dedicated books. As of 2006, 17 books with over 90 Slitherlink puzzles each have been published by Nikoli. [2] Slitherlink require no maths to solve the puzzle unlike many other Japanese puzzles e.g. Sudoku and Karuro. The puzzle is made up of a rectangular lattice of dots. The idea of the puzzle is to make one single loop that does not overlap around the grid by connecting the dots together. Squares are formed by theses dots and some have numbers in them. The numbers in these squares relates to how many lines are around the square from 0 to 3. These numbers are used to solve the puzzle by rules that can be mapped to the grid. Figure 1 Figure 2 Figure 1 shows an unsolved puzzle where you can see the grid of dots and some squares that have dots. Figure 2 shows one complete loop round the grid which relate to the numbers and complete the puzzle. 4

6 1.2 The System The aim of this project is to create a system to solve and produce Slitherlink puzzles. There aren't many solvers for solving Slitherlink puzzles, most that are out there use the Brute Force approach. This approach tries every possible solution in order to solve the puzzle. This is very extensive as there are a lot of possible solutions (see Figure 3) which as the size of the grids grow the possible solutions grows exponentially. Slitherlink is a NP (non-deterministic polynomial) complete problem, a solution to the problem can be verified quickly in polynomial time, but there is no efficient way to locate a solution to the problem. If the problem can be solved quickly in polynomial time then so can every problem in NP. This is why we aim to come up with a new Slitherlink solver for the main use of solving larger grids quickly. Number of Possibilites=2 N N Number of Lines =Vertical Lines Horizontal Lines Vertical Lines= Height x Width 1 Horizontal Lines= Width x Height 1 Figure 3 The system should also provide a tutorial based guide to help the user solve puzzles as well as teach them to be able to solve the puzzles themselves. Other aims were to allow users to input puzzles they have found from other sources such as puzzle books or the internet and allow the system to solve the puzzles for them. Other aims were to look into rating puzzles on difficulty, this would involve looking at each puzzle differently and trying to match the right difficulty rating of the puzzle to how difficult it is to solve. The main aims of the functionality of the system are: 1. Measure the efficiencies of solving methods such as brute force. 2. Develop a more efficient solver using human logical thinking. 3. Develop a way to generate random puzzles. 4. Allow the users to try and solve puzzles as well as providing a helpful guide. 5. On completing these other objectives I intended to look into measuring puzzle difficulty. 1.3 Existing Software In my findings all I could find were websites with pre-generated puzzles, none seemed to be realtime generated. This meant that these Slitherlink applications already had the solutions prepared for the User instead of being produced at real-time. So when a User solves the puzzle their result is compared with the pre loaded solutions and if they match then the User is notified. From these applications I could not work out what solver they had used to create a puzzle and find the solutions, and ultimately they were not beneficial in helping me to produce solving techniques. Theses on-line applications seemed user friendly but did not offer any helpful guide during the game as to what move to do next and why. 5

7 2. Research 2.1 Other Slitherlink Systems Concept Is Puzzles [2] This website has a very informal guide into the background of Slitherlink. As well as this background into the puzzle it has a very impressive step-by-step tutorial into how to play Slitherlink puzzles. I found this tutorial great for teaching new users how to solve Slitherlink puzzles. As well as this very impressive introduction into Slitherlink it also has a great interface for solving puzzles, which also allows them to print and save the puzzles Puzzle-loop [3] This website had a very basic system, it allowed a user to solve and print puzzles. The best feature I found about this website is that the User can play puzzles of different sizes and difficulties Krazy Dad [4] This is a website I found that allowed users to download books of Slitherlink puzzles. The dissipointment of this system was that a User could not solve these puzzle within an online interface. As well as Puzzle-loop this website also has Slitherlink puzzles of different difficulties and size. The best feature of this website is that the User can print out different variations of Slitherlink puzzles, such as honey-combe tessellations. 6

8 2.2 Programming Languages As part of my research I looked into the different languages that I might possibly implement the system in. I researched into Java, C++ and C#, the following is what my research produced Java Java is the main language that I am used to programming in, it is very easy to write in. Another big plus is that it is a very easy program to debug in which would be very useful for my project, as I expect to come across a lot of errors when programming a system from scratch. I have already programmed some GUI functionality with Java, and would therefore be readily able to make a GUI for the system C/C++ C++ is similar to Java in some ways but is a lot more complicated to program. Through my course I have mainly been taught Java, so choosing to program in C++ would take more time to become familiarise myself with and to programme things I already knew how to program in Java. This system for solving Slitherlink puzzles would involve a lot of algorithms that would involve a lot of processing. C++ is found to be more efficient to program in for these situations. I have never programmed a GUI in C++ so this could make this part of the project very difficult if I decided to program in C C# C# is very easy to program in, it is very similar to both Java and C++. I have never programmed in C# so gain would take more time to familiarise myself with sufficient enough to programme in. Like C++, C# is meant to be very efficient for these situations, that is processing large amounts of data in these algorithms. As I have never programmed in this language obviously I have never programmed a GUI in the language which could be a problem, though through my research, I have discovered that Visual Studio would make this task less difficult as it has a user friendly IDE for creating Graphical systems with underlying functionality. 7

9 3 Design 3.1 Slitherlink Grid The grid is a rectangular lattice of dots. The dots can be connected to any other dot that is next to it horizontally or vertically, it cannot connect to another dot vertically. Connecting these dots form a line which is part of the loop. Also a cross can be placed in between the dots implying that these dots can't be connected that the loop does not connect through these dots. Two connected dots make up lines, if the dots are connected then they are said to be true, otherwise if it is a cross it is false. The Squares formed by these dots tell us how many of its sides are part of the loop segment, ranging from 0 to 3. So we need some sort of way to represent this grid in program, a way of representing each part of the grid and its state. So we will need to represent the grid as one data structure or possibly separate data structure representing the lines and squares of the grid. The grid we come up with should be easy for the program to interact with, as it will be accessed and altered many times within solving a puzzle. If we use separate data structures for representing the grid then these should be easily mappable to one another so as to have the right correlation of the grid. 3.2 Solving techniques Once we have a way of representing Slitherlink puzzles, the next step and most important part of the project is a way for the program to solve these puzzles correctly and efficiently. The Following are possible solvers for the system to find solutions to the puzzles input Sequential Solve (Brute Force) This method is a simple inefficient approach to solving the problem. We start at the first line and will cycle through all the lines sequentially till the end. The idea is to try every possibility of the of the lines as them being part of the loop or not and checking if its a correct solution. The way I intend to do this is to use recursion, I will set a line to be true then go onto the next line, when we get to the end we check to see if the solution is correct. Once this is done the the system will recursively call back to each line, set it to be false then carry onto the next line. By using this we will test every possibility of the grid which will mean that we find all the correct solutions to the puzzle Random Solve The idea of this Solve is to try find one solution quicker than the sequential solve. The idea is to randomly pick a different line each time and setting it to be true, checking the validity of the puzzle each time. This check is to see if the attempt so far is a correct solution or if there is something invalid in the grid e.g. three true lines round a square that has a 2 in it. If the attempt fails it will restart from the beginning not recording the previous attempt, so it either gets a correct solution or keeps failing till it gets a correct solution. This will only find one correct solution, which is not efficient when with have a puzzle with multiple correct solutions. 8

10 3.2.2 Random Sequential Solve Taking the idea into account that we want to find a solution in the quickest possible time. The sequential solve method always starts with the first line, the problem with this is if the first line has to be false, it will try every possible solution as it being true first which is wasted time. So to avoid wasting time, this method is to randomly pick a line at a time instead so it does each line in a random order which can sometimes be quicker in finding a solution but sometimes could also be slower. This method should find all solutions as well Rule Based Solve This is the main solver I am aiming to produce, it is the best approach for trying to solve Slitherlink puzzles. It solves puzzles like a human would solve them by applying rules to the grid. These are rules that I have found in my research, the idea is that the program will cycle through the grid trying to map the rules to the grid in order to solve the puzzle. This should solve the puzzle a lot quicker than the others because it does not need to check incorrect solutions. The changes that are made using the rules are changes that are correct for there to be a loop. Hence where the others try all possibilities including incorrect, which takes up more time. The only problem with the rule based approach is that it will not find a full solution if there are multiple solutions. The solver will find the correct solution up to where the multiple solutions differ from one another. 9

11 3.3 Generating puzzles As well as being able to solve input puzzles we want the system to be able to produce puzzles for the User to solve. We especially want to be able to produce puzzles with a unique solution. To do this we will need to use one of the solvers with this to check the puzzle produced is valid and to record all the possible solutions. The following are possible methods that I think could produce valid puzzles Fill Squares First Starting with an empty grid this will randomly decide which squares will have numbers in and randomly decide what numbers to be put in these squares. This will produce a puzzle but we need to check how many and if there are any solutions to the puzzle. If there are no solutions or too many solutions produced then we want to repeat the process of producing the grid until we get a valid puzzle. This is very inefficient because it doesn't always produce a valid puzzle and could take a bit of time until it does produce one. If we use the sequential solve to help in this process it will take a considerable more amount of time to produce a puzzle. This is due to the solver has to test every possibility, the problem is there may be no correct solutions Make Loop First This is a better method for producing a puzzle but will be a lot harder to implement. Like the other method we begin with a empty grid and we make a loop round the puzzle. This loop is produced by randomly starting with a line and setting it to true. From this line we then make a path from it and back to it setting lines to true. Once back at the starting line we should have one single none overlapping loop. From this loop we fill in the squares that relate to the loop. Then from this we remove the loop and cycle through all the squares removing the number if not needed. A number is not needed when without it the puzzle still produces the required number of solutions. We test this by solving the puzzle each time we remove the number. If the number is needed then we will fill it back in. Once this is completed we will have produced a valid grid ready for a User. This is more efficient than the other method as it will always produce a valid puzzle from the start. 10

12 3.4 Difficulty Rating As well as producing puzzles and solving them I want to be able to measure the puzzle and give it a difficulty rating to match this measure. It can be very difficult to give puzzles a difficulty rating without having human interaction to say how difficult they are. The following are possible ways of measuring difficulty. Amount of pre-filled squares The amount of squares filled in with a number can be a measure of difficulty, usually the more squares that are filled the easier the puzzle is to solve. So we could easily implement this measure into the system by putting a difficulty measure to the percentage of the pre-filled squares. Positioning of pre-filled squares The positioning of these squares can also change the difficulty of a puzzle. Usually when squares filled in are more spread out from each other this can make the puzzle a lot harder to see where the loop goes, so therefore makes the puzzle harder to solve. This could be very hard to implement, one possible way is to do an average of how many pre-filled squares have neighbouring pre-filled squares and applying a difficulty measure to this. Difficulty of rules A way to discover how hard a puzzle is to solve, is to measure the difficulty of the rules used to solve them. In the rule based solve there will be a lot of rules that can be applied. If when implementing these rules we also give it a difficulty measure for how hard it is to apply to a grid. Using all these measures together we can record how what rules were used to solve the puzzle and add them up. Taking this sum we could work out the average of the rules used to give the approximate difficulty of the puzzle. 3.5 Tutorial System Slitherlink isn't a well known puzzle unlike Sudoku, this might be due to its greater complexity. This is why we need the system to have a built in tutorial to help the User learn how to play the game. This involves teaching the basic rules of Slitherlink to the User, allowing them to understand the puzzle and how to solve them. As well as this start up tutorial there is the possibility of having a helpful in-game guide that would help the User solve the current puzzle and allow them to learn the methods for solving puzzles. A User should be able to decide whether to have this in-game help on or to just solve the puzzle on their own. The following are the in-games help options that I intend to produce: Auto-Complete This helps the User finish part of the puzzle, when a User sets a line to either true or false, the system will check the other lines next to it and set the others to what they must be in order to complete the puzzle. For example if two lines next to each other are true then the other two next to them will be set to false. Highlighting of Lines This will highlight all incorrect elements in different colour, probably red as red is a common colour for marking something to be incorrect. For example if there are three true lines next to each other, this is creating an overlap which is incorrect, so all three lines will be highlighted in red to the User. Next Move This is a button that can be selected at any time, probably when they are stuck on what move to do next. When clicked the system should take the current attempt and apply the solving technique to try and find the next correct move to show to the User. 11

13 3.6 Import And Export Of Puzzles Sometimes the User might want to input puzzles they have found from an external source to help them find the solutions to the puzzle. They might just want to input the puzzle into my system because they prefer solving puzzles using my system, or just want to use the help tools for solving the puzzle. Whatever the case may be my system needs to be able to allow a User to input puzzles of various sizes. From this my system should be able to find all solutions if any to the puzzle. Once input the User should be given the option to either play the puzzle or save it to local storage. I want my system to allow the User to save a puzzle at any time even during solving the puzzle. This means that the saving method will have to record the initial puzzle, the current attempt at solving it and the solutions. So as well as this saving we will need a method for loading a puzzle back into the system from a file. This could be quite difficult especially with there being multiple information stored in the file. 3.7 Graphical User Interface This is a very essential part of the system, it gives the User control over the functionality of the system, as well as allowing the User to play the game. To create this interface we need to look at what functionality is needed. Menus for navigation around the system. Menus for loading and saving puzzles. Window for inputting externally sourced puzzles. Window for playing and solving puzzles. Some sort of way to display hints. Graphical Tutorial For all parts of the interface it should be very user friendly, easy for the User to understand the functionality of the system and how to control the system. 3.8 Playing And Solving Puzzles We need a way to graphically display a grid as well as allowing for interaction with the User. The interaction from the User should alter the grid which means that the graphical representation should also be altered and updated to match these changes. There should be a check on the grid after each change to test if the grid is completed and is a correct solution, if it is indeed correct then the User should be informed. The User should also be allowed to click a button when they want to test if the solution is correct. 12

14 4. Implementation And Results 4.1 Programming Language Chosen At first I started programming in C++, as I believed this to be the best choice for getting the greatest efficiency for the program. I first began to program the data structure for the actual representation of the Slitherlink grid. When I started to test the data structure I found when trying to set part of the grid that it would alter other parts of the grid. I spent a while problem solving this and even sought advice on the problem, but could not seem to find the solution, this then lead me to believe the project might be too hard to program in C++ with my limited knowledge. From this I then went to start programming in Java as I was more confident in programming data structure using Java. I persevered with Java for a while but found it very sluggish when solving a puzzle by brutal force. Frustrated with the slowness of the program in Java I proceeded to converting the program to C#. The change went well and ran the solver quickly and much more efficiently. From this point I stuck with C# throughout the project, programming in Microsoft Visual Studio 2008 for Windows and Mono Develop for Linux. 4.2 Grid Representation In my first attempt at producing a coded representation of a Slitherlink grid I came up with using three multi-dimensional integer arrays. One of the arrays was for storing the squares of the grid, and the other two were used to store the horizontal and vertical lines of the grid. At first this seemed to be efficient enough I could store the values and easily represent grids. The problem was that the mapping of elements to one another was very tedious and in checking lots of lines next to each added a lot more time than wanted, this is why I proceeded to make a more efficient way of representing Slitherlink grids. Grid2 is the main class file used throughout the system, it is the internal representation of a Slitherlink grid, as well as methods for altering the grid. The grid is represented as a twodimensional array of integers. Each integer can be represented using the class file Element.cs, an element is made up by 3 integers, a x co-ordinate, a y co-ordinate and a value. We use these coordinates to map the element to the position of the integer in the array, as well as this the coordinates are used to get the element type. As stated previously a Slitherlink grid is made up of a rectangular lattice of dots, these dots are represented in my grid as integers but have no significance besides making it easier to represent the grid as on a single array. A Dots x and y co-ordinates are both even, so we do not care for the value of the integers that have even x and y co-ordinates. Squares are formed by these dots and have both odd x and y co-ordinates within the grid. The value of this integer is the number within the square, if it is -1 this means the square is empty otherwise it will be one of the set {0,1,2,3}. The left over integers have one odd co-ordinate and one even coordinate, these are the lines used to make the loop. The horizontal lines have an odd y co-ordinate where the vertical lines have an odd x co-ordinate. If the value of these lines are -1 then then the lines aren't set, if it is a 0 then it is false otherwise it'll be a 1 meaning it is true and part of the loop segment. 13

15 4.3 Solvers At first when I programmed my solvers I had them all in the one grid class, once I had finished writing the basic solvers the grid class was thousand of lines. This was very inefficient and very difficult to search through the class in order to debug or improve the code. This is why I then went on to program the solvers in a more efficient way. I implemented my solvers as separate classes to the grid class, we have each solver as a separate class that inherits from one abstract solver class. This abstract class has methods that all the solvers need to use in order to solve a puzzle. The main methods in this class are used for checking if a solution is correct by traversing the path of the loop making sure it is one single loop as well as checking each part of the loop is valid and breaks none of the rules of Slitherlink Sequential Solve As intended this method uses recursive methods to cycle through the lines to test every possibility. Once at the last line it will use the inherited methods to check if the solution is correct. If it finds a correct solution then it will add it to an array of correct solutions. To improve quickness and efficiency of the solver I came up with methods in the grid class to allow the system to check if a line can be set to true or false. This improves quickness because if it cant be a certain value it will skip test all possibilities of it as this value Random Solve This method of solving also uses recursive methods to set each line. Every time it chooses a random line to set to be true by checking it can be true using the methods in the grid class. If it can be true it will check if the solution is correct, otherwise it'll go onto the next randomly chosen line. If the line can not be true then it will start from the beginning trying to find a correct solution to the puzzle. I was going to implement a time out function to stop the solver after so long but believed this not to be best as the solver would keep timing out on larger grids Random Sequential Solve I implemented this solver in a very similar way to sequential solve. It uses 2 arrays to store used lines and unused lines. For each line it will set it to be true and remove it from unused line into used lines, then go onto the next randomly picked line. Once it has done this it will set it to be false and then go onto the next line again. When it returns back again it will remove it from used lines into unused lines and setting the line to be empty. When unused lines is empty it will check if the current solution is correct, if so it will add it to the array of correct solutions. 14

16 4.3.4 Rule Based Solve Like the other solvers this is also a separate class that inherits from the basic solve class. As well as this class the solver uses rule classes in order to solve the puzzle. The rules classes also have an abstract rule class that the different types of rules inherit from. The basic rule class has methods for mapping a rule to the grid at different positions and records if the grid is altered in any way. This method is called from the other rule classes as well as taking positioning of elements and their values in order to alter the grid. The rules are in different classes according to how many squares the rule applies to. We map a rule to the grid by taking the positions and values of the elements in relation to each others positions and altering the other elements in correspondence to them. The main rule based solve class cycles through the grid mapping each rule to the grid and altering where required. We then repeat this process but alter the grid either by flipping or rotating the grid, trying every possible variation that relates to the puzzles original layout. The solver keeps repeating this process until no alterations are made to the grid, which means that we have a solution or there are multiple solutions. When we have a case of multiple solutions the solver will use the sequential solve to finish of the puzzle and find every solution. This does not mean rule based is slower than sequential because it may have to use it because it only needs to finish a small percentage of the lines, not the whole grid. This solver is used mainly in the system to solve puzzle as well to help generate them. Originally I started to program all the rules in one set, but when it came to coding the larger rules I realised I had to put in a check for the system to not to go out of bounds which would add a lot more checks when solving a puzzle. This is why I separated the rules into different rule sets of set sizes. When applying a rule set of a set size, the solver will only go up to a set point of the grid so it does not try to check elements that are out of bounds. 4.4 Generating Puzzles Generating puzzles, especially unique ones can be very tricky. Both my methods of creating puzzles require a solver, either the Sequential Solver or the Rule Based Solver. The solver is used to test that the generated puzzle is valid, as in their are solutions to the puzzle. The solver can also be used to make sure that the puzzle is unique i.e. one solution. Generating grids takes quite a bit of time especially when generating larger grids. This is due to the grids taking some initial time to be generated before having to be solved which adds a lot more time on Fill Squares First This method starts with an empty grid having no squares filled with numbers and no lines pre-set. Each square is cycled through and has a random number inserted into it, this number can be one of the set {0, 1, 2, 3, empty}. Once completed this will give a grid with some squares filled with numbers. We the use or solver to find all solutions if any to this puzzle. If no solutions are found we empty the grid and repeat the process. If multiple solutions are produced then we only require a unique solution then we empty the grid and start again as well. This method quite often has to repeat in order to find a solvable puzzle, mainly due to too many squares filled or incorrect numbers next to each other that relate to an impossible loop. 15

17 4.4.2 Make Loop First This is the best method I came up with for generating grids. Similar with the other one, we start with a empty grid, no squares filled in or any lines set. We then start with a random line somewhere on the grid and set it to true. From this line we then randomly choose an adjoining line and set this to true. From this line we do the same thing randomly choosing an adjoining line, setting it to be true. This process is repeated until we reach the initial line is reached completing the loop. Each time we go to an adjoining line we check to make sure that this line does not adjoin onto the loop so far, if it does we go back a line and randomly choose another path. This part of the process ensures that we get one single correct loop, a loop that does not overlap or crossover itself. Once we have this complete loop we cycle through each square, filling in the correct number which relates to how many of the squares sides are segments of the loop. Once this part is done we can set all of the lines in the loop to be empty, this will leave us with a grid with all its number filled in and no lines set. This gives us a unique Slitherlink puzzle but not a very challenging one due to all the squares being filled in, this is why we do the next step of the process to produce a better puzzle. We cycle through each square storing the number that is there, then setting the square to be empty. After we have removed the number we use one of our solvers to find the number of solutions. The number of solutions may not match the number that we require, for example it may produce more than one solution when we want only one solution. If this is the case then we set the squares number back to the stored number before advancing onto the next square. At the end of this step only the numbers that are required to get the right solution will be left. This gives the User a more challenging puzzle than we previously had generated. On larger grids the initial step of generating the loop can take time, because we have to find a single connecting path back to the starting line an on large grids this step of the process typically has to go through a lot of lines in the grid. This is what was the hardest part of this method of producing grids, was making a single non-overlapping loop. It was difficult to come up with a way to program a way of it finding its own path, especially back to its self without overlapping. The method I came up with is the quickest way I could think off but can take some time on larger grids to make a random path back to itself, especially depending on the position of the starting line. 4.5 Difficulty I intended to implement 3 types of methods and test to see which gave the best result for measuring puzzle difficulty. Unfortunately within the time frame I could only implement one of the methods, the method being the number of pre-filled squares. This function for acquiring the difficulty of a puzzle is done by counting the number of filled squares and working out what percentage are filled. From this we give the puzzle a difficulty rating, if the puzzle has over 70% filled then it is easy, under 30% rated as hard, otherwise it has a medium difficulty. 16

18 4.6 Graphical User Interface I decided to use Microsoft Visual Studio as it is very simple to use in order to produce a GUI. We can easily make graphical windows and forms an select what type of objects to put on the forms as well as alter their properties and positioning. Producing a GUI in this way also speeds up the time of programming instead of writing everything line by line which is tedious and also very error prone Navigation Menus To make the GUI simple to use and get around the system I have produced navigation menus allowing the User to chose what they want to do. I have implemented in each window a form with a menu bar at the top which have different choices depending on which window. These menus are used to navigate through the different windows or to exit the program. As well as these menus there are also buttons on the windows to navigate to other windows Main Menu On start up of the system we have a main menu which gives the User the option to input a puzzle, load a saved puzzle or to play a random puzzle. From this menu there is also the option to load up the tutorial on how to play Slitherlink puzzles. Figure 4 Figure 4 This is what the Main Menu of the system looks like. 17

19 4.6.3 Slitherlink Grid Display When trying to implement a Slitherlink grid using Visual C# I found it very tedious and quite hard to produce dynamically at run time for different size grids. So when I reached this point of representing the grid graphically I did some more research. From my research I established the best way for representing the grid and allowing interaction was to have an OpenGL window plugged into the Visual C# window. In one window of a set size we can create different size grids by applying algorithms to draw the grids at runtime. We can easily make alteration to the grid by changing the grid itself then redrawing the the grid with the new alterations. OpenGL is very useful for the User interaction as well, we can get the position of the mouse click on the window and calculate the position of this click on the grid to alter the correct element. The OpenGL representation of the grid also looks nicer than it would in Visual C#, easier to understand and interact with. Figure 5 Figure 6 Figure 5 - This shows how a Slitherlink puzzle is represented in my system using an OpenGL window. Figure 6 This shows how a solved Slitherlink puzzle is represented using in my system using an OpenGl window. 18

20 4.6.3 Inputting Of Grids We have a separate window for the inputting of grids from an external source. The grids have to be input manually. The User has the option to change the size of the grid they are inputting at any time as well as the option to clear the squares input so far. We use an OpenGL window for displaying the initial grid and the User has to only quick on the square they want to input a number into, in order to change the squares value. When the User is happy with the grid they can either save the puzzle or go onto play the puzzle, with either option the puzzle will be solved to find all solutions. Figure 7 Figure 7 This is the window interface for inputting grid into the system. As you can see the numbers in the height and width box represent the size of the grid displayed, so if these figures were to change so would the grid display. There is a little help guide to explain what everything does on this screen. 19

21 4.6.4 Playing And Solving Puzzles There is one main window for playing and solving puzzles, which also has an OpenGL windows for displaying and interacting with the grid. As well as this window we have buttons used during the solving of a puzzle. Some of these buttons are used for the tutorial help guide. The User at any time can check if their attempt is correct or to finish of the puzzle for them if they want to give up, alternatively they can open up a separate window that will display all possible solutions. The User can also save their attempt at any time from this window, they just have to simply click a button and enter a file name for their puzzle. Figure 8 Figure 8 this window is the main game window that the users would be presented with when solving a puzzle. As you can see with have the OpenGL window used for playing the game and buttons for other operations, the text next to these buttons describes what the buttons do. 20

22 Figure 9 Figure 9 This is still the game window but show what a solution would look like when solved by the user. Figure 10 Figure 10 This window is brought up when the User selects to few the solutions to the current puzzle, it allows the user to cycle through every solution. 21

23 4.6.5 Random Puzzles From the main menu of the program we can navigate to a new window to decide on the grid options. In this window we can state the size of the grid we want to produce as well as the minimum and maximum number of solutions we want for the puzzle. When the options are input this will call our function for creating grids, when a grid is made it will then load up the grid window with the new puzzle ready to solve, were the User can either solve or save the puzzle. Figure 11 Figure 11 This is the window that will appear when the User wishes to create a random puzzle, they simply have to enter the height and width as well as the minimum and maximum number of solutions. 22

24 4.7 Tutorial System Tutorial Screen I implemented the tutorial as a window that can be loaded up from the main menu at any time. This contains a step by step guide introducing the User to the Slitherlink puzzle. It informs the User of the Slitherlink rules about how to solve puzzles and what makes a valid solution. It does not teach the User the different rules that are used in the rule based solve because there are over a hundred, which is too much for most Users to remember. It is a simple tutorial that displays the Slitherlink grids using an OpenGL window like the ones used in the rest of the system, I thought this best option so that the User is familiar with the display when playing the game. Figure 12 Figure 12 This window show the first window of the tutorial system. The User has to simply click next or previous to cycle through the step-by-step guide. 23

25 4.7.2 In-game Help The in-game help options can be selected from the game windows at any point in the process of solving a puzzle. Auto-Completing and Highlighting of Lines can be turned on by the User by a drop down menu, the options are to have either one on, none on or both on. The following is how they work. Auto-Complete When this option is selected it will only actually help the User when they alter the grid. When they click to set a line to be true or false the system will check this against the lines next to altered line, and were possible will change the lines if the right value or them can be figured out using the new altered line. Highlighting of Lines When this option is selected it will refresh the grid straight away highlighting all the incorrect parts. It does this by every time the grid is refreshed it checks the validity of each element before drawing. If it finds the element to be invalid, it will draw it in red to show to the User that it is possibly incorrect in accordance with the other elements values. Next Move This is a button that can be selected at any time. When clicked the system will use the rule based approach to find the next move possible if any and apply them, Sometimes this will not work, say the User has set one of the elements to be incorrect, or that there are multiple solutions in which the rule based approach can not solve. Figure 13 Figure 13 - This window shows the game window with the highlighting option turned on. As you can see some of the elements are highlighted in red, this is because they are invalid in conjunction with neighbouring elements. 24

26 5 Testing And Performance 5.1 Testing Of Solving Techniques To test my solvers I used my program to input puzzles of different sizes and difficulty, these puzzles were externally sourced from the websites I discovered from my research Sequential Solve Sequential Solve managed to solve everyone of the smaller puzzles, even the ones of harder difficulty. It would find every possible solution to the puzzle because it tries every possibility, this is the reason why it did not solve the larger puzzles because I stopped it mid-process. As stated in my introduction the number of possibilities per puzzle is 2^N where N is equal to the number of lines in the puzzle. So the number of possibilities increases exponentially as the size of the puzzle increases. The solver makes sure it finds every solution to the puzzle, so carries on after it finds the first one. This is why I had to stop it half way through because I did not have the time to wait for the solver to finish, this said I know that the solver would find all the correct solutions to any puzzle Random Solve When testing this solve it only managed to solve the grids of size 3 by 3, unfortunately it could not solve any of the larger grids than this. The problem with the random solve is when solving it needs to find all the segments of the loop randomly, if it randomly chooses one line that is not part of the loop then it will fail. Say we had a puzzle and half of its lines were part of the loop and the other half weren't, than on the first randomly chosen line we have a fifty percent chance to get one of the loop segments, and if we do then the chance of randomly picking another line of the loop next has decreased, and will keep decreasing as we pick more of the loop segments, and increasing the chance of failing to solve the puzzle. When it fails the solver does not remember its previous attempt, so in fact it could do the exact same attempt as the last one and obviously failing again, not only that it could do the same attempt over and over not accomplishing anything which is the problem with it choosing lines randomly. If we had infinite time to solve a puzzle then this solver would solve it, but unfortunately this is not efficient enough to be used to solve Slitherlink puzzles Random Sequential Solve This is the exact same as Sequential Solve with the time to solve puzzles increasing exponentially as we increase the size of the puzzle. The plus side to this solve is sometimes it can be quicker than sequential solve depending on which lines it picks. Unfortunately the picking of lines is random, if we get lucky and randomly select lines of the loop at first it will find solutions quicker than sequential but there is also the chance we will select none loop lines increasing the time to solve. Overall this is as efficient as sequential solve and will indeed find all solutions to a puzzle but could take a considerable amount of time. 25

27 5.1.4 Rule Based Solve The Rule Based Solver managed to solve every one of the puzzles, including the larger grids. It did take a considerable amount of time to solve grids of size greater than 7 by 7 but no where near the same time as the other solvers. The main reason I can think why Rule Based Solve is quicker and a lot more efficient is it will only alter the grid when it knows the alterations to be part of the correct solution. The only time it does not do this is when it implements the Sequential Solve to finish of for multiple solutions. When testing grid with multiple solutions the Sequential Solve did not add much time on, even with larger grids. This will be because when it needs the Sequential Solve to finish off there aren't many lines left to solve because multiple solutions do not vary that much from one another. Puzzles of different difficulty did not add on any extra time to solving the puzzle as every rule is checked throughout the grid so will always take around the same amount of time to solve any grid of the same size Comparison When comparing the solver to one another for overall solving efficiency it is clear that the Rule Based solve is far superior for solving puzzles in the quickest time. However if we were to compare them solving smaller grids the time difference is minuscule, as they all take less than a second to come up with all the solutions. Random Solve is the only one that could in fact take infinite time to solve smaller grids as it could randomly choose the wrong lines every time it attempts to solve the puzzle, although it could also solve the puzzle the quickest by finding a solution straight away if it chooses to loop segments straight away. Comparing the solvers for their solving technique Rule Based solve wins again as it will not try every possible solution but will only try correct solutions of the puzzle. Random Solves technique is very inefficient as it might not find a solution ever, by repeating the same failed attempts over and over. As well as the possibility of never finding a solution, the random solve only finds one solution where the others will find every solution. Although Rule Based solve is the better solver it can not solve puzzles with multiple solutions, not even finding one solution as it needs one of the other solvers to finish of the rest of the puzzle, if we could come up with a way for solving multiple solutions without brute forcing it then Rule Based Solve would be very efficient. 26

28 5.2 User Feedback From Testing The following is feedback that I have received back from anonymous users that have tested all the functions of my system. I had three users test the system and have summarised their general impression for each part of the system. Two of the testers used computers quite often, were as the other tester was not very computer literate. Only one of the testers knew how to play Slitherlink puzzles before the testing process Main Menu And Navigation All the users managed to use the main menu and navigate round the system easily. They all said that it was very User friendly, and found no problems with the functionality of system. Two of the users said that the system wasn't graphically pleasing and very basic. They suggested to improve the look of the system to make it more exciting for the User than just having a boring basic feel to the system Slitherlink Grid Display Overall the testers found the OpenGL window representation of the grid easy to understand. The feedback I received was that the users could see the puzzle clearly and understand it. They found the smaller grids to be too stretched, made too large on the screen and that the larger grids were not stretched or enlarged enough. This problem aside, they could still use the display for inputting and solving grids. The reason for this scaling problem is because I have a set window size that dynamically draws the grids at runtime, so needs to be able to fit grids of different size within the window Inputting Of Puzzles The users found the interface for inputting Slitherlink puzzles to be very gritty and tedious. They especially found it frustrating for inputting larger grids as they had to make sure they set every number correctly and in the right place. To input a number a User has to click the position to increase the value of the number there, so one click would input a 0 and four clicks would input a 3. The testers suggested that they would prefer a box to come in for them to input the squares number instead of having to click so much Saving And Loading Of Puzzles The testers didn't have much to say on this function other than it worked and was very quick for both saving and loading. They all tried saving a puzzle half way through solving and loaded the puzzle back up again. When loaded back up they were taken to the game window again and their attempt they had saved was fully loaded back up without any errors. 27

29 5.2.5 Random Puzzles The users had the same impression of the random puzzles screen as they did with the main menu screen. They found easy to use but very basic and nothing spectacular about it. They tried inputting different variations of options, including different sizes for grids and different amount of solutions. The feedback given back was that it seemed quite quick on producing smaller grids, but took too long for larger grids, that it was too long a time to wait for a grid. The one tester that had played Slitherlink before found that the grids produced to be great puzzles to play, that you couldn't tell the difference from ones externally sourced and the ones generated Playing The Game Each tester tried solving multiple puzzles of different sizes. The puzzles they were solving were randomly generated puzzles from my system as they were easily sufficient for testing the playing of the game. They found interfacing with the grid fairly simple but just didn't like the scaling of the grids in the window as previously stated. They found it a bit difficult clicking on different lines on the large grids. Overall they could solve the puzzles understanding the representation of the grid. They seemed to like the idea of being able to see the solutions in a separate window from the game window and being able to finish the puzzle at any time or save it to come back to. Overall the users enjoyed using the my system for solving puzzles finding it simple to use. The tester who had played Slitherlink before preferred the way my system highlighted the loop while solving, making it easier to solve the puzzle, were on other system he had used were hard to see the full loop Tutorial And Help Guide The tester who already know how to play Slitherlink puzzles, quickly went though my tutorial to see if it covered everything about how to play the puzzle. The feedback I received from them was it covered all the major rules of the puzzles to give a new User the know-how for them to start solving puzzles. They suggested I could have implemented a hard coded puzzle and gone through step-bystep with the User showing them how a person would solve the puzzle, but overall believed my tutorial was sufficient. The two testers who did not know how to play said it was very precise and informative about how to play Slitherlink. They said after they had gone through it that they believe they could go away from the system and solve the puzzles for themselves. They also mentioned the step-by-step guide through solving a puzzle would help them to grasp the rules after the tutorial. The tester that had played Slitherlink before gave great feedback for the in-game help options. They had seen highlighting of incorrect input in other systems and found it to be exactly the same and easy to comprehend. They liked the idea of auto-complete but found it a bit touch and go at times when guessing at solutions, mainly because when they put in a guessed line it filled in other lines to go with this even though it might have been incorrect. He found the same problem with the next move help, the next move it would put in goes off the current attempt which may be incorrect so would not help solve the puzzle. The other two testers found all the in-game help options useful and had no complaints, this might be due to them not being experienced Slitherlink players and not guessing at certain parts of the puzzle were some players will. They both managed to use the ingame help options when they got stuck on what move to do next. 28

30 5.2.8 Overall Impression Of The System Tester 1 Overall I liked the system it was very easy to use and get around the program. Playing the game was very user friendly and I found the in-game help very useful when I became stuck within the puzzles. The inputting of puzzles was not brilliant but served its purpose, it could do with improvement. Saving and loading puzzle seemed to work quickly and effectively with no errors. The tutorial could be a bit more helpful with getting new User use to playing Slitherlink. I would of liked to of seen an option for producing puzzles of different difficulty. Another feature to of seen was timing and measuring of a User skill level as they solve puzzles. Tester 2 I found this system to work very efficiently and very user friendly. There seemed to be no errors with navigating through the system. I found the tutorial helped me understand how to solve Slitherlink puzzles and the in-game help helped me to get used to solving puzzles first hand. Inputting puzzles seemed a bit rubbish but could easily be improved. Tester 3 Not being very used to computer systems I found this one to be easy to use and understand. The tutorial was very helpful in teaching me how to play this puzzle game and I managed to solve a few of the smaller one on my own. I liked the in-game help options as they helped with the solving of bigger puzzles. I'd like to see something more exciting about the system though because it seemed quite basic. 29

31 6 Evaluation The following is my own evaluation of my project and the work I have put into it. It covers aims I had that I did not achieve, things that I might of changed if I had time as well as improvements and expansions that could be done to the system. 6.1 Unachieved Aims The main aim I did not manage to meet was a logical difficulty rating that was measured by the difficulty of the different rules. Unfortunately I ran out of time to implement this difficulty so was stuck with the basic difficulty measure that was worked out by the percentage of pre-filled squares. Another part of the system that I intended to implement was, when the User wants to generate a random puzzle, it should be able to produce puzzles of different difficulty. I did not implement this into the system mainly because I did not think the difficulty measure I had implemented was a sufficient measure so the puzzles that would be produced, difficulty might not match the difficulty measure I applied. 6.2 Improvements For The Current System Taking into account the User testing as well as my own testing, I believe that I could improve the current system in many ways. So looking back over the system these are the following improvements I would make to the system Inputting Of Puzzles From the testers feedback the main part of the system they suggest to improve was the inputting of puzzles from an external source. There are two changes I believe would improve this interface. The first is instead of the User having to click on each square to increment the number, they simply would have to click on the square they want to input a number, a box will appear for them to input a number. The User will then just have to enter the number wanted and press enter for the number to be input. If the User wants to alter this number at any time they just have to simply click back on the square. The other way I believe to be a good way to input grids is to teach a User how to convert an external grid to a string and then for them to input this string into the system. This would be quite quick for the User to input and when they get used to the system they would know how to convert grids themselves quite easily. 30

32 6.2.2 Slitherlink Grid Display In addition, the testers also said that the grid display were not the greatest at displaying larger puzzles. The reason for this was the algorithm for dynamically drawing grids of different size in the same size window. I could produce a better algorithm for dynamically producing grids of different sizes, or better yet hard code in the different sizes. The only problem with this solution is it is less space efficient than the previous attempt Tutorial System The improvement I would make to the tutorial system, is when a User has been showed the basic rules of Slitherlink, they will be taken to a new screen that will take them through solving a puzzle to help them get use to the rules in-game. 6.3 Future Expansions Onto The System D Puzzles A possible expansion for the system is to look into expanding Slitherlink itself. I thought it would be interesting to make a puzzle three dimensional and have a single loop traversing around this loop. This could be quite hard to implement as the rules from Rule Based solve could not be applied to this grid, as well as this the number of lines would be increased, so the brute force solving time would be increased as well Different Tessellations Another expansion for the Slitherlink puzzles is to look into different tessellations. This means where we have squares formed by dots, we look into forming different shapes such as triangles or hexagons. As with three dimensional puzzles we have the problem of the rules not applying to these grids, so would have to use the brute force approaches or come up with new rules for these grids. 31

33 7 Conclusion 7.1 Aims Of The Project Create Solving techniques for Slitherlink puzzles and measure their efficiencies. I managed to implement three types of basic solvers that could solve Slitherlink puzzles. In my testing I have measured the efficiencies of each of the solver explaining the good and bad functionality of each solver. Develop a more efficient solver using human logical thinking. I have produced a solver that takes into account solving methods that a human player would use in order to solve Slitherlink puzzles. It works logically like a human trying to spot theses rules within a puzzle and altering where needed. The only point the solver becomes stuck at is when their are multiple solutions which it can not solve, were a human player would be able to spot this and just choose one solution to solve the puzzle Develop away to generate random puzzles. I have produced 2 methods for generating random puzzles, each time the methods are ran they produce different puzzles to the ones before. These puzzles generated are playable grids that a User can try to solve, they are just the same as puzzles the User would find from external sources. Allow the users to try and solve puzzles as well as providing a helpful guide. I have created an interface for the User to interact with the system, allowing them to play and solve puzzles. The puzzles can be randomly generated or input by the User. As well as this interface a helpful guide has been implemented to help the users solve puzzles. From the results of my testing it is obvious that the users find the users found this guide to be very helpful. There is also a tutorial to teach users the basic rules of Slitherlink which is sufficient enough to get any User on their way to solving Slitherlink puzzles. On completing these other objectives I intended to look into measuring puzzle difficulty. In my system I have managed to apply a simple difficulty measure to the puzzles that have been input into the system. This is not the difficulty measure I intended to implement originally but unfortunately I did not have enough time in which to complete the extra feature. 7.2 Overall Conclusion My overall conclusion is that the project has gone quite well, I have successfully completed the aims of the project, as well as matching some of my own aims. I would of liked to of produced a better system than what I have, but what I've made is very efficient and fits the purpose it was intended for. If I had more time, and no other call on my time for producing the project I believe I could of done an overall greater job on this project as well achieving the extra aims of expanding the system to have different puzzle. I am happy with what I have achieved within the time I had and look forward to a project like this in the real world. 32

34 8 References The information I required for the project all came from these websites, I learnt how to play and solve Slitherlink puzzle and gather all the knowledge I need to produce the required system. [1] Wikipedia page on Slitherlink [2] Concept Is Puzzles Website [3] Puzzle Loop Website [4] Krazy Dad Puzzle Website [5] Jason Wan, Logical Slitherlink, University Of Manchester,

35 9 Appendix Appendix A Main Menu Appendix B Random Puzzle Menu 34

36 Appendix C Save And Load Menus 35

37 Appendix D Tutorial Window 36