├── README.md
├── style.css
├── js
    ├── path
    │   ├── astar.js
    │   └── graph.js
    ├── placewall.js
    ├── board.js
    └── ai.js
└── display.html


/README.md:
--------------------------------------------------------------------------------
1 | <h2>Quoridor AI</h2>
2 | 
3 | A Quoridor AI written in JavaScript. Play against a computer right in the browser.
4 | 
5 | Demo: <a href='https://danielborowski.github.io/site/quoridor-ai/display.html'>danielborowski.com/quoridor-ai/</a>
6 | 


--------------------------------------------------------------------------------
/style.css:
--------------------------------------------------------------------------------
 1 | * {margin: 0; padding: 0; }
 2 | html {overflow-y: scroll;} 
 3 | ul { list-style: none inside; }
 4 | li { list-style: none inside; }
 5 | a:focus { outline: none; }
 6 | .clear { clear: both; }   /* <div class="clear"> </div> */
 7 | a { text-decoration: none; color: black;}
 8 | input, textarea { outline: none; }
 9 | fieldset { border: none; }
10 | table { border-collapse: collapse; border-spacing: 0; }
11 | ::-moz-selection{ background: pink; color: white; } 
12 | ::selection { background: pink; color: white; }   
13 | 
14 | /* BOARD SETUP */
15 | #board { margin-left: 20px; border: 9px solid #7da4b4; margin-top: 7px; margin-bottom: 7px;  
16 | -moz-box-shadow:    0px 0px 0px 3px #324f5a;
17 | -webkit-box-shadow: 0px 0px 0px 3px #324f5a;
18 | box-shadow:         0px 0px 0px 3px #324f5a; }
19 | #board td { width: 50px; height: 50px; border: 0px solid black; background: #fff; }
20 | #board td.wallPlacementVert,
21 | #board td.wallPlacementVert_NOHOVER { width: 11px; border: 0px; background: #7da4b4; }
22 | #board td.wallPlacementHoriz,
23 | #board td.wallPlacementHoriz_NOHOVER { height: 11px; border: 0px; background: #7da4b4; }     
24 | #board td.crossSpace { width: 11px; height: 11px; border: 0px; background: #7da4b4; }
25 | #board td.wallPlacementHoriz, #board td.wallPlacementVert { cursor: pointer; }
26 | #board td.movableGreenSpaces { background: #f3ff6a; }    
27 | textarea { visibility: hidden; }   
28 | 
29 | /* PIECES */
30 | .pieceComputer { border-radius: 50%; width: 39px; height: 39px; background: #bc2525; margin-left: 5px; border: 1px solid #a31d1d; }
31 | .piecePlayer { border-radius: 50%; width: 39px; height: 39px; background: #3ebc25; margin-left: 5px; border: 1px solid #34a51d; }
32 | 
33 | /* WALL PLACEMENT */
34 | #board td.possibleWall { background: #5f212d; }
35 | #board td.keepWall { background: #5f212d; }
36 | #showCompPieces, #showPlayerPieces { margin-top: 5px; }
37 | #showPlayerPieces span, #showCompPieces span { font-size: 17px; font-family: "Arial"; margin-left: 18px; }
38 | #showPlayerPieces span.wallVal, #showCompPieces span.wallVal { margin: 0; font-size: 24px; }
39 | 
40 | /* RULES */
41 | #play { float: left; overflow: auto; padding-right: 15px; margin-left: 10px; }
42 | #rules { float: left; overflow: auto; width: 520px; height: 400px; 
43 | font-size: 15px; margin-top: 28px; margin-left: 20px; font-family: "Helvetica"; }    
44 | #rules p:first-child { font-size: 26px; text-align: center; margin-bottom: 12px; }
45 | #rules a { color: #297598; }


--------------------------------------------------------------------------------
/js/path/astar.js:
--------------------------------------------------------------------------------
  1 | // javascript-astar
  2 | // http://github.com/bgrins/javascript-astar
  3 | // Freely distributable under the MIT License.
  4 | // Implements the astar search algorithm in javascript using a binary heap.
  5 | 
  6 | var astar = {
  7 |     init: function(grid) {
  8 |         for(var x = 0, xl = grid.length; x < xl; x++) {
  9 |             for(var y = 0, yl = grid[x].length; y < yl; y++) {
 10 |                 var node = grid[x][y];
 11 |                 node.f = 0;
 12 |                 node.g = 0;
 13 |                 node.h = 0;
 14 |                 node.cost = node.type;
 15 |                 node.visited = false;
 16 |                 node.closed = false;
 17 |                 node.parent = null;
 18 |             }
 19 |         }
 20 |     },
 21 |     heap: function() {
 22 |         return new BinaryHeap(function(node) { 
 23 |             return node.f; 
 24 |         });
 25 |     },
 26 |     search: function(grid, start, end, diagonal, heuristic) {
 27 |         astar.init(grid);
 28 |         heuristic = heuristic || astar.manhattan;
 29 |         diagonal = !!diagonal;
 30 | 
 31 |         var openHeap = astar.heap();
 32 | 
 33 |         openHeap.push(start);
 34 | 
 35 |         while(openHeap.size() > 0) {
 36 | 
 37 |             // Grab the lowest f(x) to process next.  Heap keeps this sorted for us.
 38 |             var currentNode = openHeap.pop();
 39 | 
 40 |             // End case -- result has been found, return the traced path.
 41 |             if(currentNode === end) {
 42 |                 var curr = currentNode;
 43 |                 var ret = [];
 44 |                 while(curr.parent) {
 45 |                     ret.push(curr);
 46 |                     curr = curr.parent;
 47 |                 }
 48 |                 return ret.reverse();
 49 |             }
 50 | 
 51 |             // Normal case -- move currentNode from open to closed, process each of its neighbors.
 52 |             currentNode.closed = true;
 53 | 
 54 |             // Find all neighbors for the current node. Optionally find diagonal neighbors as well (false by default).
 55 |             var neighbors = astar.neighbors(grid, currentNode, diagonal);
 56 | 
 57 |             for(var i=0, il = neighbors.length; i < il; i++) {
 58 |                 var neighbor = neighbors[i];
 59 | 
 60 |                 if(neighbor.closed || neighbor.isWall()) {
 61 |                     // Not a valid node to process, skip to next neighbor.
 62 |                     continue;
 63 |                 }
 64 | 
 65 |                 // The g score is the shortest distance from start to current node.
 66 |                 // We need to check if the path we have arrived at this neighbor is the shortest one we have seen yet.
 67 |                 var gScore = currentNode.g + neighbor.cost;
 68 |                 var beenVisited = neighbor.visited;
 69 | 
 70 |                 if(!beenVisited || gScore < neighbor.g) {
 71 | 
 72 |                     // Found an optimal (so far) path to this node.  Take score for node to see how good it is.
 73 |                     neighbor.visited = true;
 74 |                     neighbor.parent = currentNode;
 75 |                     neighbor.h = neighbor.h || heuristic(neighbor.pos, end.pos);
 76 |                     neighbor.g = gScore;
 77 |                     neighbor.f = neighbor.g + neighbor.h;
 78 | 
 79 |                     if (!beenVisited) {
 80 |                         // Pushing to heap will put it in proper place based on the 'f' value.
 81 |                         openHeap.push(neighbor);
 82 |                     }
 83 |                     else {
 84 |                         // Already seen the node, but since it has been rescored we need to reorder it in the heap
 85 |                         openHeap.rescoreElement(neighbor);
 86 |                     }
 87 |                 }
 88 |             }
 89 |         }
 90 | 
 91 |         // No result was found - empty array signifies failure to find path.
 92 |         return [];
 93 |     },
 94 |     manhattan: function(pos0, pos1) {
 95 |         // See list of heuristics: http://theory.stanford.edu/~amitp/GameProgramming/Heuristics.html
 96 | 
 97 |         var d1 = Math.abs (pos1.x - pos0.x);
 98 |         var d2 = Math.abs (pos1.y - pos0.y);
 99 |         return d1 + d2;
100 |     },
101 |     neighbors: function(grid, node, diagonals) {
102 |         var ret = [];
103 |         var x = node.x;
104 |         var y = node.y;
105 | 
106 |         // West
107 |         if(grid[x-1] && grid[x-1][y]) {
108 |             ret.push(grid[x-1][y]);
109 |         }
110 | 
111 |         // East
112 |         if(grid[x+1] && grid[x+1][y]) {
113 |             ret.push(grid[x+1][y]);
114 |         }
115 | 
116 |         // South
117 |         if(grid[x] && grid[x][y-1]) {
118 |             ret.push(grid[x][y-1]);
119 |         }
120 | 
121 |         // North
122 |         if(grid[x] && grid[x][y+1]) {
123 |             ret.push(grid[x][y+1]);
124 |         }
125 | 
126 |         if (diagonals) {
127 | 
128 |             // Southwest
129 |             if(grid[x-1] && grid[x-1][y-1]) {
130 |                 ret.push(grid[x-1][y-1]);
131 |             }
132 | 
133 |             // Southeast
134 |             if(grid[x+1] && grid[x+1][y-1]) {
135 |                 ret.push(grid[x+1][y-1]);
136 |             }
137 | 
138 |             // Northwest
139 |             if(grid[x-1] && grid[x-1][y+1]) {
140 |                 ret.push(grid[x-1][y+1]);
141 |             }
142 | 
143 |             // Northeast
144 |             if(grid[x+1] && grid[x+1][y+1]) {
145 |                 ret.push(grid[x+1][y+1]);
146 |             }
147 | 
148 |         }
149 | 
150 |         return ret;
151 |     }
152 | };


--------------------------------------------------------------------------------
/js/path/graph.js:
--------------------------------------------------------------------------------
  1 | // javascript-astar
  2 | // http://github.com/bgrins/javascript-astar
  3 | // Freely distributable under the MIT License.
  4 | // Includes Binary Heap (with modifications) from Marijn Haverbeke. 
  5 | // http://eloquentjavascript.net/appendix2.html
  6 | 
  7 | 
  8 | var GraphNodeType = { 
  9 |     OPEN: 1, 
 10 |     WALL: 0 
 11 | };
 12 | 
 13 | // Creates a Graph class used in the astar search algorithm.
 14 | function Graph(grid) {
 15 |     var nodes = [];
 16 | 
 17 |     for (var x = 0; x < grid.length; x++) {
 18 |         nodes[x] = [];
 19 |         
 20 |         for (var y = 0, row = grid[x]; y < row.length; y++) {
 21 |             nodes[x][y] = new GraphNode(x, y, row[y]);
 22 |         }
 23 |     }
 24 | 
 25 |     this.input = grid;
 26 |     this.nodes = nodes;
 27 | }
 28 | 
 29 | Graph.prototype.toString = function() {
 30 |     var graphString = "\n";
 31 |     var nodes = this.nodes;
 32 |     var rowDebug, row, y, l;
 33 |     for (var x = 0, len = nodes.length; x < len; x++) {
 34 |         rowDebug = "";
 35 |         row = nodes[x];
 36 |         for (y = 0, l = row.length; y < l; y++) {
 37 |             rowDebug += row[y].type + " ";
 38 |         }
 39 |         graphString = graphString + rowDebug + "\n";
 40 |     }
 41 |     return graphString;
 42 | };
 43 | 
 44 | function GraphNode(x,y,type) {
 45 |     this.data = { };
 46 |     this.x = x;
 47 |     this.y = y;
 48 |     this.pos = {
 49 |         x: x, 
 50 |         y: y
 51 |     };
 52 |     this.type = type;
 53 | }
 54 | 
 55 | GraphNode.prototype.toString = function() {
 56 |     return "[" + this.x + " " + this.y + "]";
 57 | };
 58 | 
 59 | GraphNode.prototype.isWall = function() {
 60 |     return this.type == GraphNodeType.WALL;
 61 | };
 62 | 
 63 | 
 64 | function BinaryHeap(scoreFunction){
 65 |     this.content = [];
 66 |     this.scoreFunction = scoreFunction;
 67 | }
 68 | 
 69 | BinaryHeap.prototype = {
 70 |     push: function(element) {
 71 |         // Add the new element to the end of the array.
 72 |         this.content.push(element);
 73 | 
 74 |         // Allow it to sink down.
 75 |         this.sinkDown(this.content.length - 1);
 76 |     },
 77 |     pop: function() {
 78 |         // Store the first element so we can return it later.
 79 |         var result = this.content[0];
 80 |         // Get the element at the end of the array.
 81 |         var end = this.content.pop();
 82 |         // If there are any elements left, put the end element at the
 83 |         // start, and let it bubble up.
 84 |         if (this.content.length > 0) {
 85 |              this.content[0] = end;
 86 |              this.bubbleUp(0);
 87 |         }
 88 |         return result;
 89 |     },
 90 |     remove: function(node) {
 91 |         var i = this.content.indexOf(node);
 92 |     
 93 |         // When it is found, the process seen in 'pop' is repeated
 94 |         // to fill up the hole.
 95 |         var end = this.content.pop();
 96 | 
 97 |         if (i !== this.content.length - 1) {
 98 |             this.content[i] = end;
 99 |             
100 |             if (this.scoreFunction(end) < this.scoreFunction(node)) {
101 |                 this.sinkDown(i);
102 |             }
103 |             else {
104 |                 this.bubbleUp(i);
105 |             }
106 |         }
107 |     },
108 |     size: function() {
109 |         return this.content.length;
110 |     },
111 |     rescoreElement: function(node) {
112 |         this.sinkDown(this.content.indexOf(node));
113 |     },
114 |     sinkDown: function(n) {
115 |         // Fetch the element that has to be sunk.
116 |         var element = this.content[n];
117 | 
118 |         // When at 0, an element can not sink any further.
119 |         while (n > 0) {
120 | 
121 |             // Compute the parent element's index, and fetch it.
122 |             var parentN = ((n + 1) >> 1) - 1,
123 |                 parent = this.content[parentN];
124 |             // Swap the elements if the parent is greater.
125 |             if (this.scoreFunction(element) < this.scoreFunction(parent)) {
126 |                 this.content[parentN] = element;
127 |                 this.content[n] = parent;
128 |                 // Update 'n' to continue at the new position.
129 |                 n = parentN;
130 |             }
131 | 
132 |             // Found a parent that is less, no need to sink any further.
133 |             else {
134 |                 break;
135 |             }
136 |         }
137 |     },
138 |     bubbleUp: function(n) {
139 |         // Look up the target element and its score.
140 |         var length = this.content.length,
141 |             element = this.content[n],
142 |             elemScore = this.scoreFunction(element);
143 |         
144 |         while(true) {
145 |             // Compute the indices of the child elements.
146 |             var child2N = (n + 1) << 1, child1N = child2N - 1;
147 |             // This is used to store the new position of the element,
148 |             // if any.
149 |             var swap = null;
150 |             // If the first child exists (is inside the array)...
151 |             if (child1N < length) {
152 |             // Look it up and compute its score.
153 |             var child1 = this.content[child1N],
154 |                 child1Score = this.scoreFunction(child1);
155 | 
156 |             // If the score is less than our element's, we need to swap.
157 |             if (child1Score < elemScore)
158 |                 swap = child1N;
159 |             }
160 | 
161 |             // Do the same checks for the other child.
162 |             if (child2N < length) {
163 |                 var child2 = this.content[child2N],
164 |                     child2Score = this.scoreFunction(child2);
165 |                 if (child2Score < (swap === null ? elemScore : child1Score)) {
166 |                     swap = child2N;
167 |                 }
168 |             }
169 | 
170 |             // If the element needs to be moved, swap it, and continue.
171 |             if (swap !== null) {
172 |                 this.content[n] = this.content[swap];
173 |                 this.content[swap] = element;
174 |                 n = swap;
175 |             }
176 | 
177 |             // Otherwise, we are done.
178 |             else {
179 |                 break;
180 |             }
181 |         }
182 |     }
183 | };


--------------------------------------------------------------------------------
/js/placewall.js:
--------------------------------------------------------------------------------
  1 | 
  2 | var boardWidth = 9;  
  3 | 
  4 | /*********************************************
  5 |         COMPUTER PLACING ACTUAL WALLS 
  6 | *********************************************/   
  7 | function placeHorizWall(thisWall) {
  8 |     var noWalls = ($("#nowalls").val()+",").split(',');
  9 |     var walls = $("#walls").val();  
 10 |     var thisWall = thisWall;
 11 |     var nextPart = $('#board td[data-pos='+(thisWall)+']').next().next().attr('data-pos');
 12 |     walls = walls+","+thisWall; 
 13 |     walls = walls+","+nextPart;  
 14 |     if (walls[0]==',') { walls = walls.substr(1); }
 15 |     // delete cross-intersection and directly prior walls that overlap
 16 |     var intersec = thisWall.substr(0,thisWall.indexOf('-'))+"-"+nextPart.substr(0,nextPart.indexOf('-'));
 17 |     var prior = parseInt(thisWall.substr(0,thisWall.indexOf('-')))-1;
 18 |     var prior_2 = parseInt(thisWall.substr(thisWall.indexOf('-')+1))-1;
 19 |     var priorWall = prior+"-"+prior_2;
 20 |     // take these wall possibilities away
 21 |     noWalls.splice(noWalls.indexOf(thisWall),1); 
 22 |     noWalls.splice(noWalls.indexOf(nextPart),1); 
 23 |     if (noWalls.indexOf(intersec) != -1) { noWalls.splice(noWalls.indexOf(intersec),1); $("td[data-pos='"+intersec+"']").removeClass("wallPlacementVert").addClass('wallPlacementVert_NOHOVER'); }
 24 |     if (noWalls.indexOf(priorWall) != -1) { noWalls.splice(noWalls.indexOf(priorWall),1); $("td[data-pos='"+priorWall+"']").removeClass("wallPlacementHoriz").addClass('wallPlacementHoriz_NOHOVER'); }
 25 |     // update textareas and display
 26 |     $("#nowalls").val(noWalls);
 27 |     $("#walls").val(walls);
 28 |     $("td[data-pos='"+thisWall+"']").removeClass('wallPlacementHoriz').addClass("wallPlacementHoriz_NOHOVER").addClass("keepWall");
 29 |     $("td[data-pos='"+thisWall+"']").next().addClass("keepWall"); 
 30 |     $("td[data-pos='"+nextPart+"']").removeClass('wallPlacementHoriz').addClass("wallPlacementHoriz_NOHOVER").addClass("keepWall"); 
 31 |     // update computer walls
 32 |     var compWallsLeft = $('#showCompPieces').children().next().text(); 
 33 |     compWallsLeft--;   
 34 |     $('#showCompPieces').children().next().text(compWallsLeft);  
 35 | }
 36 | 
 37 | function placeVertWall(thisWall) {
 38 |     var noWalls = ($("#nowalls").val()+",").split(',');
 39 |     var walls = $("#walls").val();
 40 |     var thisWall = thisWall;
 41 |     // get second part of wall for horiz
 42 |     var nvf = parseInt(thisWall.substr(0,thisWall.indexOf("-"))) + boardWidth;
 43 |     var nvs = parseInt(thisWall.substr(thisWall.indexOf("-")+1)) + boardWidth;
 44 |     var nextPart = nvf+"-"+nvs;  
 45 |     walls = walls+","+thisWall; 
 46 |     walls = walls+","+nextPart;  
 47 |     if (walls[0]==',') { walls = walls.substr(1); }
 48 |     // delete cross-intersection and directly prior walls that overlap
 49 |     var intersec = thisWall.substr(0,thisWall.indexOf('-'))+"-"+nextPart.substr(0,nextPart.indexOf('-'));
 50 |     var prior = parseInt(thisWall.substr(0,thisWall.indexOf('-')))-boardWidth;
 51 |     var prior_2 = parseInt(thisWall.substr(thisWall.indexOf('-')+1))-boardWidth;
 52 |     var priorWall = prior+"-"+prior_2;
 53 |     // take these wall possibilities away
 54 |     noWalls.splice(noWalls.indexOf(thisWall),1); 
 55 |     noWalls.splice(noWalls.indexOf(nextPart),1);   
 56 |     if (noWalls.indexOf(intersec) != -1) { noWalls.splice(noWalls.indexOf(intersec),1); $("td[data-pos='"+intersec+"']").removeClass("wallPlacementHoriz").addClass('wallPlacementHoriz_NOHOVER'); }
 57 |     if (noWalls.indexOf(priorWall) != -1) { noWalls.splice(noWalls.indexOf(priorWall),1); $("td[data-pos='"+priorWall+"']").removeClass("wallPlacementVert").addClass('wallPlacementVert_NOHOVER'); }
 58 |     // update textareas and display
 59 |     $("#nowalls").val(noWalls);
 60 |     $("#walls").val(walls);
 61 |     var cross = nvf-boardWidth+"-"+nvf; 
 62 |     $("td[data-pos='"+thisWall+"']").removeClass('wallPlacementVert').addClass("wallPlacementVert_NOHOVER").addClass("keepWall");
 63 |     $("td[data-pos='"+cross+"']").next().addClass("keepWall"); 
 64 |     $("td[data-pos='"+nextPart+"']").removeClass('wallPlacementVert').addClass("wallPlacementVert_NOHOVER").addClass("keepWall"); 
 65 |     // update computer walls
 66 |     var compWallsLeft = $('#showCompPieces').children().next().text(); 
 67 |     compWallsLeft--;   
 68 |     $('#showCompPieces').children().next().text(compWallsLeft);   
 69 | }
 70 | 
 71 | /**************************************************
 72 |         COMPUTER COMPUTING BOARD CHANGES
 73 | **************************************************/   
 74 | function placeHorizWall_COMPUTE(thisWall,noWalls,walls,playerWallsLeft,compWallsLeft,playerLoc,oppLoc,turn) {  
 75 |     var nextPart = $('#board td[data-pos='+(thisWall)+']').next().next().attr('data-pos');
 76 |     var possibleWalls = thisWall+","+nextPart;
 77 |     var checkLegal = pathToEndExists(possibleWalls,null,null);  
 78 |     if (turn=='c') { var cwa = compWallsLeft; }
 79 |     else { var cwa = playerWallsLeft; }
 80 |     if ((checkLegal) && (cwa>0)) {    
 81 |         walls = walls+","+thisWall; 
 82 |         walls = walls+","+nextPart;  
 83 |         if (walls[0]==',') { walls = walls.substr(1); }
 84 |         // delete cross-intersection and directly prior walls that overlap
 85 |         var intersec = thisWall.substr(0,thisWall.indexOf('-'))+"-"+nextPart.substr(0,nextPart.indexOf('-'));
 86 |         var prior = parseInt(thisWall.substr(0,thisWall.indexOf('-')))-1;
 87 |         var prior_2 = parseInt(thisWall.substr(thisWall.indexOf('-')+1))-1;
 88 |         var priorWall = prior+"-"+prior_2;
 89 |         // take these wall possibilities away
 90 |         noWalls.splice(noWalls.indexOf(thisWall),1); 
 91 |         noWalls.splice(noWalls.indexOf(nextPart),1); 
 92 |         if (noWalls.indexOf(intersec) != -1) { noWalls.splice(noWalls.indexOf(intersec),1); }
 93 |         if (noWalls.indexOf(priorWall) != -1) { noWalls.splice(noWalls.indexOf(priorWall),1); }
 94 |         // update number of walls
 95 |         playerWallsLeft = parseInt(playerWallsLeft); 
 96 |         compWallsLeft = parseInt(compWallsLeft);
 97 |         if (turn=='c') { compWallsLeft--; var turn = 'p'; }
 98 |         else { playerWallsLeft--; var turn = 'c'; }
 99 |         return new Array(noWalls,walls,playerWallsLeft,compWallsLeft,playerLoc,oppLoc,turn); 
100 |     } else {   
101 |         return 'illegal'; 
102 |     } 
103 | }                             
104 | 
105 | function placeVertWall_COMPUTE(thisWall,noWalls,walls,playerWallsLeft,compWallsLeft,playerLoc,oppLoc,turn) {   
106 |     var nvf = parseInt(thisWall.substr(0,thisWall.indexOf("-"))) + boardWidth;
107 |     var nvs = parseInt(thisWall.substr(thisWall.indexOf("-")+1)) + boardWidth;
108 |     var nextPart = nvf+"-"+nvs;    
109 |     var possibleWalls = thisWall+","+nextPart;  
110 |     var checkLegal = pathToEndExists(possibleWalls,null,null);      
111 |     if (turn=='c') { var cwa = compWallsLeft; }
112 |     else { var cwa = playerWallsLeft; }
113 |     if ((checkLegal) && (cwa>0)) { 
114 |         walls = walls+","+thisWall; 
115 |         walls = walls+","+nextPart;  
116 |         if (walls[0]==',') { walls = walls.substr(1); }
117 |         // delete cross-intersection and directly prior walls that overlap
118 |         var intersec = thisWall.substr(0,thisWall.indexOf('-'))+"-"+nextPart.substr(0,nextPart.indexOf('-'));
119 |         var prior = parseInt(thisWall.substr(0,thisWall.indexOf('-')))-boardWidth;
120 |         var prior_2 = parseInt(thisWall.substr(thisWall.indexOf('-')+1))-boardWidth;
121 |         var priorWall = prior+"-"+prior_2;
122 |         // take these wall possibilities away        
123 |         noWalls.splice(noWalls.indexOf(thisWall),1);                                                                                                                        
124 |         noWalls.splice(noWalls.indexOf(nextPart),1);   
125 |         if (noWalls.indexOf(intersec) != -1) { noWalls.splice(noWalls.indexOf(intersec),1); }
126 |         if (noWalls.indexOf(priorWall) != -1) { noWalls.splice(noWalls.indexOf(priorWall),1); } 
127 |         // update number of walls
128 |         playerWallsLeft = parseInt(playerWallsLeft); 
129 |         compWallsLeft = parseInt(compWallsLeft);
130 |         if (turn=='c') { compWallsLeft--; var turn = 'p'; }
131 |         else { playerWallsLeft--; var turn = 'c'; }
132 |         return new Array(noWalls,walls,playerWallsLeft,compWallsLeft,playerLoc,oppLoc,turn); 
133 |     } else {            
134 |         return 'illegal'; 
135 |     }
136 | }


--------------------------------------------------------------------------------
/js/board.js:
--------------------------------------------------------------------------------
  1 | 
  2 | var boardWidth = 9; 
  3 | var lastSpace = (boardWidth-1)*(boardWidth+1);
  4 | 
  5 | /****************************************************
  6 |     RETURN POSSIBLE MOVEMENTS FROM CURRENT SPACE
  7 | ****************************************************/
  8 | function possibleMoves(loc,compTesting,opponentLoc,possibleWalls) { 
  9 |     // determine all directional moves
 10 |     loc = parseInt(loc);
 11 |     oppLoc = parseInt(opponentLoc);
 12 |     var moves = new Array(loc-1,loc+1,loc+boardWidth,loc-boardWidth); 
 13 |     var possibleJumps = new Array();  
 14 |     var removeSpaces = new Array(); 
 15 |     var removeOverlaps_col_first = new Array(8,17,26,35,44,53,62,71,80);
 16 |     var removeOverlaps_col_last  = new Array(0,9,18,27,36,45,54,63,72);
 17 |     // remove overlapping and OOB moves
 18 |     for (var x=0;x<moves.length;x++) {
 19 |         if (moves[x]<0 || moves[x]>lastSpace) { removeSpaces.push(moves[x]); }   
 20 |         for (var c1=0;c1<removeOverlaps_col_last.length;c1++) {
 21 |             if (loc==removeOverlaps_col_last[c1]) {
 22 |                 if (removeOverlaps_col_first.indexOf(moves[x]) != -1) {
 23 |                      if (removeSpaces.indexOf(moves[x]) == -1) { removeSpaces.push(moves[x]); }
 24 |                 }    
 25 |             }    
 26 |         }
 27 |         for (var c2=0;c2<removeOverlaps_col_first.length;c2++) {
 28 |             if (loc==removeOverlaps_col_first[c2]) {
 29 |                 if (removeOverlaps_col_last.indexOf(moves[x]) != -1) {
 30 |                      if (removeSpaces.indexOf(moves[x]) == -1) { removeSpaces.push(moves[x]); }
 31 |                 }    
 32 |             }    
 33 |         }
 34 |     }        
 35 |     // prevent jumping over walls
 36 |     var walls = $("#walls").val() + ','; 
 37 |     if (possibleWalls!=null) { walls = walls + possibleWalls + ","; } 
 38 |     var walS = walls.split(",");  
 39 |     for (var c=0;c<moves.length;c++) {  
 40 |         if (loc<moves[c]) { var check = loc+"-"+moves[c]; }    
 41 |         else { var check = moves[c]+"-"+loc; }   
 42 |         if ((walS.indexOf(check) != -1) && (removeSpaces.indexOf(moves[c]) == -1)) { 
 43 |             removeSpaces.push(moves[c]); 
 44 |         }
 45 |     }   
 46 |     // 1) if no wall in front of player allow jumping over opponent piece 2) cannot move to same space as opponent  
 47 |     for (var x=0;x<moves.length;x++) {
 48 |         if ((moves[x]==oppLoc) && (possibleJumps.indexOf(moves[x]) == -1) && (removeSpaces.indexOf(moves[x]) == -1)) { possibleJumps.push(moves[x]); } 
 49 |         if (possibleWalls==null) { if ((moves[x]==oppLoc) && (removeSpaces.indexOf(moves[x]) == -1)) { removeSpaces.push(moves[x]); } } 
 50 |     } 
 51 |     // add actual space where player will jump over opponent
 52 |     for (var j=0;j<possibleJumps.length;j++) {
 53 |         if (loc<possibleJumps[j]) { var jump = ((possibleJumps[j]-loc)*2); }    
 54 |         else { var jump = ((loc-possibleJumps[j])*2)*-1; } 
 55 |         if (moves.indexOf(loc+jump) == -1) { moves.push(loc+jump); }        
 56 |     }  
 57 |     // prevent jumping over opponent with wall behind them   
 58 |     var jcheck = false
 59 |     for (var a=0;a<moves.length;a++) {
 60 |         if (moves.indexOf(oppLoc) != -1) {
 61 |             if (oppLoc<moves[a]) { var check = oppLoc+"-"+moves[a]; }    
 62 |             else { var check = moves[a]+"-"+oppLoc; }      
 63 |             if (walls.indexOf(check) != -1) { 
 64 |                 removeSpaces.push(moves[a]); 
 65 |                 jcheck = true;
 66 |             }   
 67 |         }         
 68 |     }   
 69 |     // add actual spaces where player will jump to the side of opponent
 70 |     if (jcheck) {
 71 |         for (var j=0;j<4;j++) {
 72 |             if (j==0 && oppLoc-1!=loc && moves.indexOf(oppLoc-1)==-1) { moves.push(oppLoc-1); }    
 73 |             else if (j==1 && oppLoc+1!=loc && moves.indexOf(oppLoc+1)==-1) { moves.push(oppLoc+1); }  
 74 |             else if (j==2 && oppLoc+9!=loc && moves.indexOf(oppLoc+9)==-1) { moves.push(oppLoc+9); }  
 75 |             else if (j==3 && oppLoc-9!=loc && moves.indexOf(oppLoc-9)==-1) { moves.push(oppLoc-9); }      
 76 |         }
 77 |     }
 78 |     for (var x=0;x<moves.length;x++) {
 79 |         if ((moves[x]<0 || moves[x]>lastSpace) && removeSpaces.indexOf(moves[x]) == -1) { removeSpaces.push(moves[x]); }   
 80 |         for (var c1=0;c1<removeOverlaps_col_last.length;c1++) {
 81 |             if (loc==removeOverlaps_col_last[c1]) {
 82 |                 if (removeOverlaps_col_first.indexOf(moves[x]) != -1) {
 83 |                      if (removeSpaces.indexOf(moves[x]) == -1) { removeSpaces.push(moves[x]); }
 84 |                 }    
 85 |             }    
 86 |         }
 87 |         for (var c2=0;c2<removeOverlaps_col_first.length;c2++) {
 88 |             if (loc==removeOverlaps_col_first[c2]) {
 89 |                 if (removeOverlaps_col_last.indexOf(moves[x]) != -1) {
 90 |                      if (removeSpaces.indexOf(moves[x]) == -1) { removeSpaces.push(moves[x]); }
 91 |                 }    
 92 |             }    
 93 |         }
 94 |     }    
 95 |     for (var a=0;a<moves.length;a++) {
 96 |         if (moves.indexOf(oppLoc) != -1) {
 97 |             if (oppLoc<moves[a]) { var check = oppLoc+"-"+moves[a]; }    
 98 |             else { var check = moves[a]+"-"+oppLoc; }      
 99 |             if (walls.indexOf(check) != -1 && removeSpaces.indexOf(moves[a]) == -1) { removeSpaces.push(moves[a]); }   
100 |         }         
101 |     }         
102 |     // check if the placement of a possible (not placed yet) wall is legal by checking path to end
103 |     if (possibleWalls==null) { var possibleWalls = $("#possibleWalls").val(); } 
104 |     else { var possibleWalls = possibleWalls; }
105 |     for (var c=0;c<moves.length;c++) {
106 |         if (loc<moves[c]) { var check = loc+"-"+moves[c]; }    
107 |         else { var check = moves[c]+"-"+loc; }    
108 |         if (possibleWalls.indexOf(check) != -1 && (removeSpaces.indexOf(moves[c]) == -1)) { removeSpaces.push(moves[c]); }
109 |     }      
110 |     // check if jumping over piece overlaps to other side 
111 |     var removeOverlaps_col_secLast = new Array(7,16,25,34,43,52,61,70,79);   
112 |     var removeOverlaps_col_secFirst = new Array(1,10,19,28,37,46,55,64,73);
113 |     for (var x=0;x<moves.length;x++) { 
114 |         for (var c1=0;c1<removeOverlaps_col_secLast.length;c1++) {
115 |             if (loc==removeOverlaps_col_secLast[c1]) {
116 |                 if (removeOverlaps_col_last.indexOf(moves[x]) != -1) {
117 |                      if (removeSpaces.indexOf(moves[x]) == -1) { removeSpaces.push(moves[x]); }
118 |                 }    
119 |             }    
120 |         }
121 |         for (var c2=0;c2<removeOverlaps_col_secFirst.length;c2++) {
122 |             if (loc==removeOverlaps_col_secFirst[c2]) {
123 |                 if (removeOverlaps_col_first.indexOf(moves[x]) != -1) {
124 |                      if (removeSpaces.indexOf(moves[x]) == -1) { removeSpaces.push(moves[x]); }
125 |                 }    
126 |             }    
127 |         }
128 |     }
129 |     // remove negative and OOB moves from jump calculations
130 |     for (var x=0;x<moves.length;x++) { 
131 |         if ((moves[x]<0 || moves[x]>lastSpace) && (removeSpaces.indexOf(moves[x]) == -1)) { removeSpaces.push(moves[x]); }      
132 |     }     
133 |     // remove all illegal spaces
134 |     for (var i=0;i<removeSpaces.length;i++) {
135 |         moves.splice(moves.indexOf(removeSpaces[i]),1); 
136 |     }       
137 |     // display where moves are possible to player
138 |     if (!compTesting) {
139 |         for (var i=0;i<moves.length;i++) { $("#board td[data-pos="+(moves[i])+"]").addClass('movableGreenSpaces'); } 
140 |         console.log("-------------------------"); 
141 |         console.log(loc + " can go to " + moves);
142 |     }              
143 |     return new Array(loc,moves);
144 | }
145 | 
146 | /**********************************
147 |     MOVE PIECE TO A NEW SPACE
148 | **********************************/
149 | function movePiece(curLoc,newLoc) {
150 |     var whatPiece = $('#board td[data-pos='+(curLoc)+']').children('div').attr('class');
151 |     $('#board td[data-pos='+(curLoc)+']').children('div').remove();
152 |     $('#board td[data-pos='+(newLoc)+']').append("<div class='"+whatPiece+"'></div>");
153 |     $("#board td").removeClass('movableGreenSpaces'); 
154 |     var cw = checkWin();   
155 |     if (whatPiece=='piecePlayer' && cw==-1) { computerMove(); }
156 | }
157 | 
158 | /*********************************
159 |         CHECK FOR WINNERS
160 | *********************************/
161 | function checkWin() {
162 |     var computer = $('.pieceComputer').parent().attr("data-pos");
163 |     var player = $('.piecePlayer').parent().attr("data-pos"); 
164 |     if (player>=0 && player<=8) { alert("YOU WIN!!!!!!!!!!!!"); return 'pwins'; } 
165 |     if (computer>=72 && computer<=80) { alert("COMPUTER WINS!!!!!!!!!!!!"); return 'cwins'; }
166 |     else { return -1; }   
167 | }
168 | 
169 | /*****************************************************
170 |     CHECK FOR ILLEGAL WALLS THAT TRAP PLAYER/COMP
171 | *****************************************************/
172 | function pathToEndExists(possibleWalls,playerLoc,oppLoc) {
173 |     var possibleWalls = possibleWalls; 
174 |     if (playerLoc==null) { var player = $('.piecePlayer').parent().attr("data-pos"); }  
175 |     else { var player = playerLoc; }
176 |     player = parseInt(player);    
177 |     var p_visited = new Array(); p_visited.push(player); 
178 |     var p_path = false;
179 |     if (oppLoc==null) { var computer = $('.pieceComputer').parent().attr("data-pos"); } 
180 |     else { var computer = oppLoc; }
181 |     computer = parseInt(computer);
182 |     var p_moves = possibleMoves(player,true,computer,possibleWalls);  
183 |     var c_moves = possibleMoves(computer,true,player,possibleWalls);
184 |     var c_visited = new Array(); c_visited.push(computer);
185 |     var c_path = false;
186 |     // recursive path functions  
187 |     function followPathPlayer(loc,loop) {  
188 |         if ((loc>=0)&&(loc<=8)) { p_path = true; }
189 |         if (!p_path || loop<8000) { 
190 |             p_visited.push(parseInt(loc));   
191 |             var nextMoves = possibleMoves(loc,true,computer,possibleWalls);
192 |             loop++;
193 |             for (var c1=0;c1<nextMoves[1].length;c1++) {
194 |                 if (p_visited.indexOf(nextMoves[1][c1]) == -1) { followPathPlayer(nextMoves[1][c1],loop); }  
195 |             }
196 |         }
197 |     }
198 |     function followComputerPlayer(loc,loop) {
199 |         if ((loc>=72)&&(loc<=80)) { c_path = true; }
200 |         if (!c_path || loop<8000) { 
201 |             c_visited.push(parseInt(loc));
202 |             var nextMoves = possibleMoves(loc,true,player,possibleWalls);
203 |             loop++;
204 |             for (var c1=0;c1<nextMoves[1].length;c1++) {
205 |                 if (c_visited.indexOf(nextMoves[1][c1]) == -1) { followComputerPlayer(nextMoves[1][c1],loop); }  
206 |             }
207 |         }
208 |     }
209 |     // make sure player and computer have path to the end 
210 |     for (var c1=0;c1<p_moves[1].length;c1++) { followPathPlayer(p_moves[1][c1],0); }
211 |     for (var c2=0;c2<c_moves[1].length;c2++) { followComputerPlayer(c_moves[1][c2],0); }                   
212 |     var doubleCheck = shortestPath($("#walls").val() + ','+possibleWalls,null,null);       
213 |     if (!c_path && doubleCheck[1]==0) { return false; } 
214 |     if (!p_path) { return false; }
215 |     return true;   
216 |     
217 | }
218 | 
219 | /*****************************************************
220 |      FIND SHORTEST PATH FOR EVALUATION FUNCTION
221 | *****************************************************/
222 | function shortestPath(possibleWalls,compLoc,playerLoc) {       
223 |     if (playerLoc==null) { var player = $('.piecePlayer').parent().attr("data-pos");   }
224 |     else { var player = playerLoc; } 
225 |     player = parseInt(player); 
226 |     if (compLoc==null) { var computer = $('.pieceComputer').parent().attr("data-pos"); }
227 |     else { var computer = compLoc; }   
228 |     computer = parseInt(computer);
229 |     if (possibleWalls==null) { var walls = $("#walls").val() + ','; }
230 |     else { var walls = possibleWalls + ','; }
231 |     walls = walls.split(",");
232 |     // construct matrix
233 |     var mat = new Array(
234 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
235 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
236 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
237 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
238 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
239 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
240 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
241 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
242 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0], 
243 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
244 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
245 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
246 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
247 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
248 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
249 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
250 |         [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0],
251 |         [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
252 |     );
253 |     // add wall boundaries to matrix
254 |     for (var x=0;x<walls.length;x++) {
255 |         var f = parseInt(walls[x].substr(0,walls[x].indexOf('-')));
256 |         var s = parseInt(walls[x].substr(walls[x].indexOf('-')+1));
257 |         var fVal = 0;
258 |         var sVal = 0;
259 |         // if horiz wall
260 |         if (s==f+9) { 
261 |             if (f>=0 && f<=8) { fVal = 1; } 
262 |             else if (f>=9 && f<=17) { fVal = 3; } 
263 |             else if (f>=18 && f<=26) { fVal = 5; } 
264 |             else if (f>=27 && f<=35) { fVal = 7; }
265 |             else if (f>=36 && f<=44) { fVal = 9; } 
266 |             else if (f>=45 && f<=53) { fVal = 11; } 
267 |             else if (f>=54 && f<=62) { fVal = 13; }  
268 |             else if (f>=63 && f<=71) { fVal = 15; } 
269 |             sVal = (s%9)*2;
270 |             mat[fVal][sVal] = 0;
271 |             mat[fVal][sVal+1] = 0; 
272 |         }
273 |         // if vert wall
274 |         else { 
275 |             if (f>=0 && f<=8) { fVal = 0; } 
276 |             else if (f>=9 && f<=17) { fVal = 2; } 
277 |             else if (f>=18 && f<=26) { fVal = 4; } 
278 |             else if (f>=27 && f<=35) { fVal = 6; }
279 |             else if (f>=36 && f<=44) { fVal = 8; } 
280 |             else if (f>=45 && f<=53) { fVal = 10; } 
281 |             else if (f>=54 && f<=62) { fVal = 12; }  
282 |             else if (f>=63 && f<=71) { fVal = 14; } 
283 |             if (f>=0&&f<=71) {
284 |                 sVal = (s%9)*2-1;
285 |                 mat[fVal][sVal] = 0;
286 |                 mat[fVal+1][sVal] = 0;  
287 |             }        
288 |         } 
289 |     }          
290 |     // get shortest path in graph with walls
291 |     var graph = new Graph(mat); 
292 |     var start_p = graph.nodes[Math.floor(player/9)*2][player%9*2];
293 |     var end_p_c_array = new Array(0,2,4,6,8,10,12,14,16); 
294 |     var s_path_player = 200;
295 |     for (var i=0;i<end_p_c_array.length;i++) { 
296 |         var result = astar.search(graph.nodes, start_p, graph.nodes[0][end_p_c_array[i]]);  
297 |         if (result.length < s_path_player && result.length>0) { s_path_player = result.length; }  
298 |     }
299 |     var start_c = graph.nodes[Math.floor(computer/9)*2][computer%9*2];
300 |     var s_path_computer = 200;
301 |     for (var i=0;i<end_p_c_array.length;i++) {    
302 |         var result = astar.search(graph.nodes, start_c, graph.nodes[16][end_p_c_array[i]]);  
303 |         if (Math.floor(computer/9)==8) { if (result.length < s_path_computer) { s_path_computer = result.length; } } 
304 |         else { if (result.length < s_path_computer && result.length>0) { s_path_computer = result.length; } }   
305 |     }            
306 |     if (s_path_player==200) { s_path_player = 0; }
307 |     if (s_path_computer==200) { s_path_computer = 0; } 
308 |     return new Array(Math.ceil(s_path_player/2),Math.ceil(s_path_computer/2));
309 | }


--------------------------------------------------------------------------------
/display.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head> 
  4 | <title> Quoridor AI </title>  
  5 | <meta name="author" content="Daniel Borowski" /> 
  6 | <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />      
  7 | <link type="text/css" rel="stylesheet" href="style.css" />   
  8 | <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript" charset="utf-8"></script>
  9 | <script src='js/path/graph.js' type='text/javascript'></script>
 10 | <script src='js/path/astar.js' type='text/javascript'></script> 
 11 | <script src="js/board.js" type="text/javascript" charset="utf-8"></script>
 12 | <script src="js/ai.js" type="text/javascript" charset="utf-8"></script>  
 13 | <script src="js/placewall.js" type="text/javascript" charset="utf-8"></script> 
 14 |  
 15 | <script>
 16 | $(document).ready(function() {
 17 |     
 18 |     // game variables
 19 |     var boardWidth = 9;
 20 |     var piece_moves;
 21 |     var playerWalls = 10;
 22 |     var computerWalls = 10;
 23 |     
 24 |     // player moving 
 25 |     $('.piecePlayer').live('click',function() {  
 26 |         piece_moves = possibleMoves($(this).parent().attr('data-pos'),false,$('.pieceComputer').parent().attr('data-pos'),null);    
 27 |     });
 28 |     $('.movableGreenSpaces').live('click',function() {      
 29 |         movePiece(piece_moves[0],$(this).attr('data-pos'));    
 30 |     }); 
 31 |     $('.pieceComputer').live('click',function() { alert("Please don't touch the computer."); });   
 32 |     
 33 |     /*************************************************
 34 |              GUI FOR PLAYER TO PLACE WALLS
 35 |          WALL PLACEMENT AND ARRAY UPDATING BELOW
 36 |     *************************************************/
 37 |     
 38 |     // display remaining walls
 39 |     $('#showCompPieces').children().next().text(computerWalls);
 40 |     $('#showPlayerPieces').children().next().text(playerWalls);     
 41 |     
 42 |     // show wall placement to player     
 43 |     $('.wallPlacementHoriz').live({
 44 |     mouseenter: function () {
 45 |         if (playerWalls>0) { 
 46 |             $(this).addClass("possibleWall");  
 47 |             $(this).next().addClass("possibleWall");  
 48 |             $(this).next().next().addClass("possibleWall"); 
 49 |         }
 50 |     }, mouseleave: function () {
 51 |         $(this).removeClass("possibleWall");  
 52 |         $(this).next().removeClass("possibleWall");  
 53 |         $(this).next().next().removeClass("possibleWall");     
 54 |     }});
 55 |     $('.wallPlacementVert').live({ 
 56 |     mouseenter: function () {
 57 |         if (playerWalls>0) {
 58 |             var nextVert = $(this).attr('data-pos');
 59 |             var nvf = parseInt(nextVert.substr(0,nextVert.indexOf("-"))) + boardWidth;
 60 |             var nvs = parseInt(nextVert.substr(nextVert.indexOf("-")+1)) + boardWidth;   
 61 |             var cross = nvf-boardWidth+"-"+nvf; nextVert = nvf+"-"+nvs;            
 62 |             $(this).addClass("possibleWall");   
 63 |             $("td[data-pos='"+nextVert+"']").addClass("possibleWall"); 
 64 |             $("td[data-pos='"+cross+"']").next().addClass("possibleWall");
 65 |         }
 66 |     }, mouseleave: function () { 
 67 |         var nextVert = $(this).attr('data-pos');
 68 |         var nvf = parseInt(nextVert.substr(0,nextVert.indexOf("-"))) + boardWidth;
 69 |         var nvs = parseInt(nextVert.substr(nextVert.indexOf("-")+1)) + boardWidth;
 70 |         var cross = nvf-boardWidth+"-"+nvf; nextVert = nvf+"-"+nvs;   
 71 |         $(this).removeClass("possibleWall");   
 72 |         $("td[data-pos='"+nextVert+"']").removeClass("possibleWall"); 
 73 |         $("td[data-pos='"+cross+"']").next().removeClass("possibleWall");    
 74 |     }});   
 75 |     
 76 |     // player actually placing wall
 77 |     $('.possibleWall').live('click',function() { 
 78 |         var thisWall = $(this).attr("data-pos");   
 79 |         var whichDir = $(this).attr('class'); 
 80 |         whichDir = whichDir.substr(0,whichDir.indexOf(" "));
 81 |         console.log("-------------------------");
 82 |         if (whichDir=="wallPlacementHoriz") {
 83 |             var noWalls = ($("#nowalls").val()+",").split(',');
 84 |             var walls = $("#walls").val();  
 85 |             // get second part of wall for horiz
 86 |             var nextPart = $(this).next().next().attr('data-pos');
 87 |             // add new walls if pieces are not trapped   
 88 |             $('#possibleWalls').val(thisWall+","+nextPart);
 89 |             var pw = $('#possibleWalls').val();
 90 |             var checkLegal = pathToEndExists(pw,null,null);
 91 |             if (checkLegal) {
 92 |                 walls = walls+","+thisWall; 
 93 |                 walls = walls+","+nextPart;  
 94 |                 if (walls[0]==',') { walls = walls.substr(1); }
 95 |                 // delete cross-intersection and directly prior walls that overlap
 96 |                 var intersec = thisWall.substr(0,thisWall.indexOf('-'))+"-"+nextPart.substr(0,nextPart.indexOf('-'));
 97 |                 var prior = parseInt(thisWall.substr(0,thisWall.indexOf('-')))-1;
 98 |                 var prior_2 = parseInt(thisWall.substr(thisWall.indexOf('-')+1))-1;
 99 |                 var priorWall = prior+"-"+prior_2;
100 |                 // take these wall possibilities away
101 |                 noWalls.splice(noWalls.indexOf(thisWall),1); 
102 |                 noWalls.splice(noWalls.indexOf(nextPart),1); 
103 |                 if (noWalls.indexOf(intersec) != -1) { noWalls.splice(noWalls.indexOf(intersec),1); $("td[data-pos='"+intersec+"']").removeClass("wallPlacementVert").addClass('wallPlacementVert_NOHOVER'); }
104 |                 if (noWalls.indexOf(priorWall) != -1) { noWalls.splice(noWalls.indexOf(priorWall),1); $("td[data-pos='"+priorWall+"']").removeClass("wallPlacementHoriz").addClass('wallPlacementHoriz_NOHOVER'); }
105 |                 // update textareas and display
106 |                 $("#nowalls").val(noWalls);
107 |                 $("#walls").val(walls);
108 |                 $("td[data-pos='"+thisWall+"']").removeClass('wallPlacementHoriz').addClass("wallPlacementHoriz_NOHOVER").addClass("keepWall");
109 |                 $("td[data-pos='"+thisWall+"']").next().addClass("keepWall"); 
110 |                 $("td[data-pos='"+nextPart+"']").removeClass('wallPlacementHoriz').addClass("wallPlacementHoriz_NOHOVER").addClass("keepWall"); 
111 |                 playerWalls--;
112 |                 computerMove();   
113 |             } else { alert('ILLEGAL WALL'); } 
114 |             $('#possibleWalls').val(''); 
115 |         } 
116 |         else if (whichDir=="wallPlacementVert") {
117 |             var noWalls = ($("#nowalls").val()+",").split(',');
118 |             var walls = $("#walls").val();
119 |             // get second part of wall for horiz
120 |             var nvf = parseInt(thisWall.substr(0,thisWall.indexOf("-"))) + boardWidth;
121 |             var nvs = parseInt(thisWall.substr(thisWall.indexOf("-")+1)) + boardWidth;
122 |             var nextPart = nvf+"-"+nvs;
123 |             // add new walls if pieces are not trapped   
124 |             $('#possibleWalls').val(thisWall+","+nextPart); 
125 |             var pw = $('#possibleWalls').val();   
126 |             var checkLegal = pathToEndExists(pw,null,null);
127 |             if (checkLegal) {
128 |                 walls = walls+","+thisWall; 
129 |                 walls = walls+","+nextPart;  
130 |                 if (walls[0]==',') { walls = walls.substr(1); }
131 |                 // delete cross-intersection and directly prior walls that overlap
132 |                 var intersec = thisWall.substr(0,thisWall.indexOf('-'))+"-"+nextPart.substr(0,nextPart.indexOf('-'));
133 |                 var prior = parseInt(thisWall.substr(0,thisWall.indexOf('-')))-boardWidth;
134 |                 var prior_2 = parseInt(thisWall.substr(thisWall.indexOf('-')+1))-boardWidth;
135 |                 var priorWall = prior+"-"+prior_2;
136 |                 // take these wall possibilities away
137 |                 noWalls.splice(noWalls.indexOf(thisWall),1); 
138 |                 noWalls.splice(noWalls.indexOf(nextPart),1);   
139 |                 if (noWalls.indexOf(intersec) != -1) { noWalls.splice(noWalls.indexOf(intersec),1); $("td[data-pos='"+intersec+"']").removeClass("wallPlacementHoriz").addClass('wallPlacementHoriz_NOHOVER'); }
140 |                 if (noWalls.indexOf(priorWall) != -1) { noWalls.splice(noWalls.indexOf(priorWall),1); $("td[data-pos='"+priorWall+"']").removeClass("wallPlacementVert").addClass('wallPlacementVert_NOHOVER'); }
141 |                 // update textareas and display
142 |                 $("#nowalls").val(noWalls);
143 |                 $("#walls").val(walls);
144 |                 var cross = nvf-boardWidth+"-"+nvf;
145 |                 $("td[data-pos='"+thisWall+"']").removeClass('wallPlacementVert').addClass("wallPlacementVert_NOHOVER").addClass("keepWall");
146 |                 $("td[data-pos='"+cross+"']").next().addClass("keepWall"); 
147 |                 $("td[data-pos='"+nextPart+"']").removeClass('wallPlacementVert').addClass("wallPlacementVert_NOHOVER").addClass("keepWall"); 
148 |                 playerWalls--; 
149 |                 computerMove();  
150 |             } else { alert('ILLEGAL WALL'); }
151 |             $('#possibleWalls').val('');            
152 |         }
153 |         $("#board td").removeClass('movableGreenSpaces');
154 |         $('#showPlayerPieces').children().next().text(playerWalls);
155 |     });
156 |     
157 | });
158 | </script>
159 | 
160 | </head>
161 | <body>
162 | 
163 | <div id='play'>
164 | <div id='showCompPieces'><span>Walls: </span><span class='wallVal'></span></div>
165 | <table id='board'>
166 |     <!-- ROW 1 -->
167 |     <tr>
168 |         <td data-pos='0'></td>
169 |             <td data-pos='0-1' class='wallPlacementVert'></td>  
170 |         <td data-pos='1'></td> 
171 |             <td data-pos='1-2' class='wallPlacementVert'></td>
172 |         <td data-pos='2'> </td> 
173 |             <td data-pos='2-3' class='wallPlacementVert'></td>
174 |         <td data-pos='3'></td> 
175 |             <td data-pos='3-4' class='wallPlacementVert'></td>
176 |         <td data-pos='4'> <div class='pieceComputer'></div> </td>
177 |             <td data-pos='4-5' class='wallPlacementVert'></td> 
178 |         <td data-pos='5'></td>
179 |             <td data-pos='5-6' class='wallPlacementVert'></td>  
180 |         <td data-pos='6'></td> 
181 |             <td data-pos='6-7' class='wallPlacementVert'></td>
182 |         <td data-pos='7'></td> 
183 |             <td data-pos='7-8' class='wallPlacementVert'></td>
184 |         <td data-pos='8'></td> 
185 |     </tr>
186 |     <tr>
187 |         <td data-pos='0-9' class='wallPlacementHoriz'></td>  
188 |         <td class='crossSpace'></td>  
189 |         <td data-pos='1-10' class='wallPlacementHoriz'></td>  
190 |         <td class='crossSpace'></td>  
191 |         <td data-pos='2-11' class='wallPlacementHoriz'></td>  
192 |         <td class='crossSpace'></td>  
193 |         <td data-pos='3-12' class='wallPlacementHoriz'></td> 
194 |         <td class='crossSpace'></td>  
195 |         <td data-pos='4-13' class='wallPlacementHoriz'></td> 
196 |         <td class='crossSpace'></td>  
197 |         <td data-pos='5-14' class='wallPlacementHoriz'></td> 
198 |         <td class='crossSpace'></td>  
199 |         <td data-pos='6-15' class='wallPlacementHoriz'></td> 
200 |         <td class='crossSpace'></td>  
201 |         <td data-pos='7-16' class='wallPlacementHoriz'></td> 
202 |         <td class='crossSpace'></td>  
203 |         <td data-pos='8-17' class='wallPlacementHoriz_NOHOVER'></td> 
204 |     </tr>
205 |     <!-- ROW 2 -->
206 |     <tr>
207 |         <td data-pos='9'></td>
208 |             <td data-pos='9-10' class='wallPlacementVert'></td>  
209 |         <td data-pos='10'></td> 
210 |             <td data-pos='10-11' class='wallPlacementVert'></td>
211 |         <td data-pos='11'></td> 
212 |             <td data-pos='11-12' class='wallPlacementVert'></td>
213 |         <td data-pos='12'></td> 
214 |             <td data-pos='12-13' class='wallPlacementVert'></td>
215 |         <td data-pos='13'></td>
216 |             <td data-pos='13-14' class='wallPlacementVert'></td> 
217 |         <td data-pos='14'></td>
218 |             <td data-pos='14-15' class='wallPlacementVert'></td>  
219 |         <td data-pos='15'></td> 
220 |             <td data-pos='15-16' class='wallPlacementVert'></td>
221 |         <td data-pos='16'></td> 
222 |             <td data-pos='16-17' class='wallPlacementVert'></td>
223 |         <td data-pos='17'></td> 
224 |     </tr>
225 |     <tr>
226 |         <td data-pos='9-18' class='wallPlacementHoriz'></td>  
227 |         <td class='crossSpace'></td>  
228 |         <td data-pos='10-19' class='wallPlacementHoriz'></td>  
229 |         <td class='crossSpace'></td>  
230 |         <td data-pos='11-20' class='wallPlacementHoriz'></td>  
231 |         <td class='crossSpace'></td>  
232 |         <td data-pos='12-21' class='wallPlacementHoriz'></td> 
233 |         <td class='crossSpace'></td>  
234 |         <td data-pos='13-22' class='wallPlacementHoriz'></td> 
235 |         <td class='crossSpace'></td>  
236 |         <td data-pos='14-23' class='wallPlacementHoriz'></td> 
237 |         <td class='crossSpace'></td>  
238 |         <td data-pos='15-24' class='wallPlacementHoriz'></td> 
239 |         <td class='crossSpace'></td>  
240 |         <td data-pos='16-25' class='wallPlacementHoriz'></td> 
241 |         <td class='crossSpace'></td>  
242 |         <td data-pos='17-26' class='wallPlacementHoriz_NOHOVER'></td> 
243 |     </tr>
244 |     <!-- ROW 3 -->
245 |     <tr>
246 |         <td data-pos='18'></td>
247 |             <td data-pos='18-19' class='wallPlacementVert'></td>  
248 |         <td data-pos='19'></td> 
249 |             <td data-pos='19-20' class='wallPlacementVert'></td>
250 |         <td data-pos='20'></td> 
251 |             <td data-pos='20-21' class='wallPlacementVert'></td>
252 |         <td data-pos='21'></td> 
253 |             <td data-pos='21-22' class='wallPlacementVert'></td>
254 |         <td data-pos='22'></td>
255 |             <td data-pos='22-23' class='wallPlacementVert'></td> 
256 |         <td data-pos='23'></td>
257 |             <td data-pos='23-24' class='wallPlacementVert'></td>  
258 |         <td data-pos='24'></td> 
259 |             <td data-pos='24-25' class='wallPlacementVert'></td>
260 |         <td data-pos='25'></td> 
261 |             <td data-pos='25-26' class='wallPlacementVert'></td>
262 |         <td data-pos='26'></td> 
263 |     </tr>
264 |     <tr>
265 |         <td data-pos='18-27' class='wallPlacementHoriz'></td>  
266 |         <td class='crossSpace'></td>  
267 |         <td data-pos='19-28' class='wallPlacementHoriz'></td>  
268 |         <td class='crossSpace'></td>  
269 |         <td data-pos='20-29' class='wallPlacementHoriz'></td>  
270 |         <td class='crossSpace'></td>  
271 |         <td data-pos='21-30' class='wallPlacementHoriz'></td> 
272 |         <td class='crossSpace'></td>  
273 |         <td data-pos='22-31' class='wallPlacementHoriz'></td> 
274 |         <td class='crossSpace'></td>  
275 |         <td data-pos='23-32' class='wallPlacementHoriz'></td> 
276 |         <td class='crossSpace'></td>  
277 |         <td data-pos='24-33' class='wallPlacementHoriz'></td> 
278 |         <td class='crossSpace'></td>  
279 |         <td data-pos='25-34' class='wallPlacementHoriz'></td> 
280 |         <td class='crossSpace'></td>  
281 |         <td data-pos='26-35' class='wallPlacementHoriz_NOHOVER'></td> 
282 |     </tr>
283 |     <!-- ROW 4 -->
284 |     <tr>
285 |         <td data-pos='27'></td>
286 |             <td data-pos='27-28' class='wallPlacementVert'></td>  
287 |         <td data-pos='28'></td> 
288 |             <td data-pos='28-29' class='wallPlacementVert'></td>
289 |         <td data-pos='29'></td> 
290 |             <td data-pos='29-30' class='wallPlacementVert'></td>
291 |         <td data-pos='30'></td> 
292 |             <td data-pos='30-31' class='wallPlacementVert'></td>
293 |         <td data-pos='31'></td>
294 |             <td data-pos='31-32' class='wallPlacementVert'></td> 
295 |         <td data-pos='32'></td>
296 |             <td data-pos='32-33' class='wallPlacementVert'></td>  
297 |         <td data-pos='33'></td> 
298 |             <td data-pos='33-34' class='wallPlacementVert'></td>
299 |         <td data-pos='34'></td> 
300 |             <td data-pos='34-35' class='wallPlacementVert'></td>
301 |         <td data-pos='35'></td> 
302 |     </tr>
303 |     <tr>
304 |         <td data-pos='27-36' class='wallPlacementHoriz'></td>  
305 |         <td class='crossSpace'></td>  
306 |         <td data-pos='28-37' class='wallPlacementHoriz'></td>  
307 |         <td class='crossSpace'></td>  
308 |         <td data-pos='29-38' class='wallPlacementHoriz'></td>  
309 |         <td class='crossSpace'></td>  
310 |         <td data-pos='30-39' class='wallPlacementHoriz'></td> 
311 |         <td class='crossSpace'></td>  
312 |         <td data-pos='31-40' class='wallPlacementHoriz'></td> 
313 |         <td class='crossSpace'></td>  
314 |         <td data-pos='32-41' class='wallPlacementHoriz'></td> 
315 |         <td class='crossSpace'></td>  
316 |         <td data-pos='33-42' class='wallPlacementHoriz'></td> 
317 |         <td class='crossSpace'></td>  
318 |         <td data-pos='34-43' class='wallPlacementHoriz'></td> 
319 |         <td class='crossSpace'></td>  
320 |         <td data-pos='35-44' class='wallPlacementHoriz_NOHOVER'></td> 
321 |     </tr>
322 |     <!-- ROW 5 -->
323 |     <tr>
324 |         <td data-pos='36'></td>
325 |             <td data-pos='36-37' class='wallPlacementVert'></td>  
326 |         <td data-pos='37'></td> 
327 |             <td data-pos='37-38' class='wallPlacementVert'></td>
328 |         <td data-pos='38'></td> 
329 |             <td data-pos='38-39' class='wallPlacementVert'></td>
330 |         <td data-pos='39'></td> 
331 |             <td data-pos='39-40' class='wallPlacementVert'></td>
332 |         <td data-pos='40'></td>
333 |             <td data-pos='40-41' class='wallPlacementVert'></td> 
334 |         <td data-pos='41'></td>
335 |             <td data-pos='41-42' class='wallPlacementVert'></td>  
336 |         <td data-pos='42'></td> 
337 |             <td data-pos='42-43' class='wallPlacementVert'></td>
338 |         <td data-pos='43'></td> 
339 |             <td data-pos='43-44' class='wallPlacementVert'></td>
340 |         <td data-pos='44'></td> 
341 |     </tr>
342 |     <tr>
343 |         <td data-pos='36-45' class='wallPlacementHoriz'></td>  
344 |         <td class='crossSpace'></td>  
345 |         <td data-pos='37-46' class='wallPlacementHoriz'></td>  
346 |         <td class='crossSpace'></td>  
347 |         <td data-pos='38-47' class='wallPlacementHoriz'></td>  
348 |         <td class='crossSpace'></td>  
349 |         <td data-pos='39-48' class='wallPlacementHoriz'></td> 
350 |         <td class='crossSpace'></td>  
351 |         <td data-pos='40-49' class='wallPlacementHoriz'></td> 
352 |         <td class='crossSpace'></td>  
353 |         <td data-pos='41-50' class='wallPlacementHoriz'></td> 
354 |         <td class='crossSpace'></td>  
355 |         <td data-pos='42-51' class='wallPlacementHoriz'></td> 
356 |         <td class='crossSpace'></td>  
357 |         <td data-pos='43-52' class='wallPlacementHoriz'></td> 
358 |         <td class='crossSpace'></td>  
359 |         <td data-pos='44-53' class='wallPlacementHoriz_NOHOVER'></td> 
360 |     </tr>
361 |     <!-- ROW 6 -->
362 |     <tr>
363 |         <td data-pos='45'></td>
364 |             <td data-pos='45-46' class='wallPlacementVert'></td>  
365 |         <td data-pos='46'></td> 
366 |             <td data-pos='46-47' class='wallPlacementVert'></td>
367 |         <td data-pos='47'></td> 
368 |             <td data-pos='47-48' class='wallPlacementVert'></td>
369 |         <td data-pos='48'></td> 
370 |             <td data-pos='48-49' class='wallPlacementVert'></td>
371 |         <td data-pos='49'></td>
372 |             <td data-pos='49-50' class='wallPlacementVert'></td> 
373 |         <td data-pos='50'></td>
374 |             <td data-pos='50-51' class='wallPlacementVert'></td>  
375 |         <td data-pos='51'></td> 
376 |             <td data-pos='51-52' class='wallPlacementVert'></td>
377 |         <td data-pos='52'></td> 
378 |             <td data-pos='52-53' class='wallPlacementVert'></td>
379 |         <td data-pos='53'></td> 
380 |     </tr>
381 |     <tr>
382 |         <td data-pos='45-54' class='wallPlacementHoriz'></td>  
383 |         <td class='crossSpace'></td>  
384 |         <td data-pos='46-55' class='wallPlacementHoriz'></td>  
385 |         <td class='crossSpace'></td>  
386 |         <td data-pos='47-56' class='wallPlacementHoriz'></td>  
387 |         <td class='crossSpace'></td>  
388 |         <td data-pos='48-57' class='wallPlacementHoriz'></td> 
389 |         <td class='crossSpace'></td>  
390 |         <td data-pos='49-58' class='wallPlacementHoriz'></td> 
391 |         <td class='crossSpace'></td>  
392 |         <td data-pos='50-59' class='wallPlacementHoriz'></td> 
393 |         <td class='crossSpace'></td>  
394 |         <td data-pos='51-60' class='wallPlacementHoriz'></td> 
395 |         <td class='crossSpace'></td>  
396 |         <td data-pos='52-61' class='wallPlacementHoriz'></td> 
397 |         <td class='crossSpace'></td>  
398 |         <td data-pos='53-62' class='wallPlacementHoriz_NOHOVER'></td> 
399 |     </tr>
400 |     <!-- ROW 7 -->
401 |     <tr>
402 |         <td data-pos='54'></td>
403 |             <td data-pos='54-55' class='wallPlacementVert'></td>  
404 |         <td data-pos='55'></td> 
405 |             <td data-pos='55-56' class='wallPlacementVert'></td>
406 |         <td data-pos='56'></td> 
407 |             <td data-pos='56-57' class='wallPlacementVert'></td>
408 |         <td data-pos='57'></td> 
409 |             <td data-pos='57-58' class='wallPlacementVert'></td>
410 |         <td data-pos='58'></td>
411 |             <td data-pos='58-59' class='wallPlacementVert'></td> 
412 |         <td data-pos='59'></td>
413 |             <td data-pos='59-60' class='wallPlacementVert'></td>  
414 |         <td data-pos='60'></td> 
415 |             <td data-pos='60-61' class='wallPlacementVert'></td>
416 |         <td data-pos='61'></td> 
417 |             <td data-pos='61-62' class='wallPlacementVert'></td>
418 |         <td data-pos='62'></td> 
419 |     </tr>
420 |     <tr>
421 |         <td data-pos='54-63' class='wallPlacementHoriz'></td>  
422 |         <td class='crossSpace'></td>  
423 |         <td data-pos='55-64' class='wallPlacementHoriz'></td>  
424 |         <td class='crossSpace'></td>  
425 |         <td data-pos='56-65' class='wallPlacementHoriz'></td>  
426 |         <td class='crossSpace'></td>  
427 |         <td data-pos='57-66' class='wallPlacementHoriz'></td> 
428 |         <td class='crossSpace'></td>  
429 |         <td data-pos='58-67' class='wallPlacementHoriz'></td> 
430 |         <td class='crossSpace'></td>  
431 |         <td data-pos='59-68' class='wallPlacementHoriz'></td> 
432 |         <td class='crossSpace'></td>  
433 |         <td data-pos='60-69' class='wallPlacementHoriz'></td> 
434 |         <td class='crossSpace'></td>  
435 |         <td data-pos='61-70' class='wallPlacementHoriz'></td> 
436 |         <td class='crossSpace'></td>  
437 |         <td data-pos='62-71' class='wallPlacementHoriz_NOHOVER'></td> 
438 |     </tr>
439 |     <!-- ROW 8 -->
440 |     <tr>
441 |         <td data-pos='63'></td>
442 |             <td data-pos='63-64' class='wallPlacementVert'></td>  
443 |         <td data-pos='64'></td> 
444 |             <td data-pos='64-65' class='wallPlacementVert'></td>
445 |         <td data-pos='65'></td> 
446 |             <td data-pos='65-66' class='wallPlacementVert'></td>
447 |         <td data-pos='66'></td> 
448 |             <td data-pos='66-67' class='wallPlacementVert'></td>
449 |         <td data-pos='67'></td>
450 |             <td data-pos='67-68' class='wallPlacementVert'></td> 
451 |         <td data-pos='68'></td>
452 |             <td data-pos='68-69' class='wallPlacementVert'></td>  
453 |         <td data-pos='69'></td> 
454 |             <td data-pos='69-70' class='wallPlacementVert'></td>
455 |         <td data-pos='70'></td> 
456 |             <td data-pos='70-71' class='wallPlacementVert'></td>
457 |         <td data-pos='71'></td> 
458 |     </tr>
459 |     <tr>
460 |         <td data-pos='63-72' class='wallPlacementHoriz'></td>  
461 |         <td class='crossSpace'></td>  
462 |         <td data-pos='64-73' class='wallPlacementHoriz'></td>  
463 |         <td class='crossSpace'></td>  
464 |         <td data-pos='65-74' class='wallPlacementHoriz'></td>  
465 |         <td class='crossSpace'></td>  
466 |         <td data-pos='66-75' class='wallPlacementHoriz'></td> 
467 |         <td class='crossSpace'></td>  
468 |         <td data-pos='67-76' class='wallPlacementHoriz'></td> 
469 |         <td class='crossSpace'></td>  
470 |         <td data-pos='68-77' class='wallPlacementHoriz'></td> 
471 |         <td class='crossSpace'></td>  
472 |         <td data-pos='69-78' class='wallPlacementHoriz'></td> 
473 |         <td class='crossSpace'></td>  
474 |         <td data-pos='70-79' class='wallPlacementHoriz'></td> 
475 |         <td class='crossSpace'></td>  
476 |         <td data-pos='71-80' class='wallPlacementHoriz_NOHOVER'></td> 
477 |     </tr>
478 |     <!-- ROW 9 -->
479 |     <tr>
480 |         <td data-pos='72'></td>
481 |             <td data-pos='72-73' class='wallPlacementVert_NOHOVER'></td>  
482 |         <td data-pos='73'></td> 
483 |             <td data-pos='73-74' class='wallPlacementVert_NOHOVER'></td>
484 |         <td data-pos='74'></td> 
485 |             <td data-pos='74-75' class='wallPlacementVert_NOHOVER'></td>
486 |         <td data-pos='75'></td> 
487 |             <td data-pos='75-76' class='wallPlacementVert_NOHOVER'></td>
488 |         <td data-pos='76'> <div class='piecePlayer'></div> </td>
489 |             <td data-pos='76-77' class='wallPlacementVert_NOHOVER'></td> 
490 |         <td data-pos='77'></td>
491 |             <td data-pos='77-78' class='wallPlacementVert_NOHOVER'></td>  
492 |         <td data-pos='78'></td> 
493 |             <td data-pos='78-79' class='wallPlacementVert_NOHOVER'></td>
494 |         <td data-pos='79'></td> 
495 |             <td data-pos='79-80' class='wallPlacementVert_NOHOVER'></td>
496 |         <td data-pos='80'></td> 
497 |     </tr>
498 | </table>
499 | <div id='showPlayerPieces'><span>Walls: </span><span class='wallVal'></span></div>  
500 | </div>
501 | 
502 | <div id='rules'>
503 | <p>Quoridor AI</p>
504 | Quoridor is a game played on a 9x9 board where your objective is to get your piece to the opposite side of the board from where it begins. You play as green and on
505 | each turn you can either press on your piece and move it or you can place one of your available walls on the board.
506 | <br><br>
507 | <b>></b> <a href='http://en.wikipedia.org/wiki/Quoridor'>Click here</a> to view the full rules.
508 | <br>
509 | <b>></b> The AI was written in JavaScript by Daniel Borowski. See the <a href='https://github.com/danielborowski/quoridor-ai/'>code on GitHub</a>.  
510 | </div>
511 | 
512 | <textarea id='nowalls'>
513 | 0-1,1-2,2-3,3-4,4-5,5-6,6-7,7-8,0-9,1-10,2-11,3-12,4-13,5-14,6-15,7-16,9-10,10-11,11-12,12-13,13-14,14-15,15-16,16-17,9-18,10-19,11-20,12-21,13-22,14-23,15-24,16-25,18-19,19-20,20-21,21-22,22-23,23-24,24-25,25-26,18-27,19-28,20-29,21-30,22-31,23-32,24-33,25-34,27-28,28-29,29-30,30-31,31-32,32-33,33-34,34-35,27-36,28-37,29-38,30-39,31-40,32-41,33-42,34-43,36-37,37-38,38-39,39-40,40-41,41-42,42-43,43-44,36-45,37-46,38-47,39-48,40-49,41-50,42-51,43-52,45-46,46-47,47-48,48-49,49-50,50-51,51-52,52-53,45-54,46-55,47-56,48-57,49-58,50-59,51-60,52-61,54-55,55-56,56-57,57-58,58-59,59-60,60-61,61-62,54-63,55-64,56-65,57-66,58-67,59-68,60-69,61-70,63-64,64-65,65-66,66-67,67-68,68-69,69-70,70-71,63-72,64-73,65-74,66-75,67-76,68-77,69-78,70-79</textarea>
514 | <br>
515 | <textarea id='walls'></textarea>
516 | <br>
517 | <textarea id='possibleWalls'></textarea>   
518 | 
519 | </body>
520 | </html>


--------------------------------------------------------------------------------
/js/ai.js:
--------------------------------------------------------------------------------
  1 | 
  2 | var boardWidth = 9;  
  3 | 
  4 | /***********************************************
  5 |       COMPUTER AI WILL BEGIN CALCULATIONS
  6 | ***********************************************/
  7 | function computerMove() {
  8 |     
  9 |     // get possible computer moves
 10 |     var compMoves = possibleMoves($('.pieceComputer').parent().attr('data-pos'),true,$('.piecePlayer').parent().attr('data-pos'),null);  
 11 |     
 12 |     // get possible wall placements
 13 |     var noWalls = $("#nowalls").val();
 14 |     noWalls = noWalls.split(',');   
 15 |     
 16 |     // begin simulation              
 17 |     simulation(noWalls,compMoves[1]);
 18 |     
 19 |     function simulation(wallSimulations,moveSimulations) {
 20 |         var playerWallsLeft = $('#showPlayerPieces').children().next().text();
 21 |         var compWallsLeft = $('#showCompPieces').children().next().text();
 22 |         var playerLoc = parseInt($('.piecePlayer').parent().attr('data-pos'));     
 23 |         var oppLoc = parseInt($('.pieceComputer').parent().attr('data-pos'));  
 24 |         var walls = $("#walls").val();       
 25 |         var noWalls = $("#nowalls").val().split(',');  
 26 |         var arrWins_moves = new Array(0,0,0,0,0,0);  
 27 |         var arrShortestMoves_b = shortestPath(null,null,null);
 28 |         var arrShortestMoves_a = new Array();       
 29 |         for (var p=0;p<wallSimulations.length;p++) {  
 30 |             if (wallSimulations[p]=='') { break; }
 31 |             var limit = 0;       
 32 |             // place current wall down and update board
 33 |             var whatWallPlace = $('#board td[data-pos='+wallSimulations[p]+']').attr('class');
 34 |             if (whatWallPlace=="wallPlacementHoriz") {     
 35 |                 var wallDown = placeHorizWall_COMPUTE(wallSimulations[p],noWalls,walls,playerWallsLeft,compWallsLeft,playerLoc,oppLoc,'c'); 
 36 |                 if (wallDown!='illegal') { var passW  = wallDown[1].split(",").join(","); }   
 37 |             } 
 38 |             else if (whatWallPlace=="wallPlacementVert") {   
 39 |                 var wallDown = placeVertWall_COMPUTE(wallSimulations[p],noWalls,walls,playerWallsLeft,compWallsLeft,playerLoc,oppLoc,'c');
 40 |                 if (wallDown!='illegal') { var passW  = wallDown[1].split(",").join(","); } 
 41 |             }                                
 42 |             // update shortest path for player and computer with each wall  
 43 |             if (wallDown=='illegal') { var sp_a = new Array(0,0); }   
 44 |             else { var sp_a = shortestPath(passW,null,null); } 
 45 |             arrShortestMoves_a.push(sp_a);
 46 |         }  
 47 |         var bestWall_sp = null; 
 48 |         var worstLen = 0;
 49 |         var worstWallForComp = null;
 50 |         var wallPreventTrap = null;
 51 |         var doublePlaceWall = null;
 52 |         var doubleWallPathLen = 0;
 53 |         var futureWall = false;  
 54 |         var high_change_player = arrShortestMoves_b[0]; 
 55 |         var low_change_computer = arrShortestMoves_b[1]; 
 56 |         var ranChancePlace = Math.random();   
 57 |         // determine if computer might fall into trap
 58 |         for (var q=0;q<arrShortestMoves_a.length;q++) { 
 59 |             if (arrShortestMoves_a[q][1]>=low_change_computer+2 && wallSimulations[q]!='' && arrShortestMoves_a[q][1]>=worstLen) {
 60 |                 worstWallForComp=q;
 61 |                 worstLen = arrShortestMoves_a[q][1]; 
 62 |             }    
 63 |         }                           
 64 |         // find SINGLE wall that can trap computer and prevent it
 65 |         var walls_t = $("#walls").val();       
 66 |         var noWalls_t = $("#nowalls").val().split(',');
 67 |         if (worstWallForComp!=null && parseInt($('#showPlayerPieces').children().next().text())>1 && parseInt($('#showCompPieces').children().next().text())>0) {
 68 |             var whatWallBlocker = $('#board td[data-pos='+wallSimulations[worstWallForComp]+']').attr('class');          
 69 |             if (whatWallBlocker=="wallPlacementHoriz") { 
 70 |                 var nextPart = $('#board td[data-pos='+(wallSimulations[worstWallForComp])+']').next().next().attr('data-pos');  
 71 |                 var walls_with_blocker = wallSimulations[worstWallForComp] + "," + nextPart;
 72 |                 var inNo = placeHorizWall_COMPUTE(wallSimulations[worstWallForComp],noWalls_t,walls_t,10,10,playerLoc,oppLoc,'c'); 
 73 |             }
 74 |             else if (whatWallBlocker=="wallPlacementVert") {
 75 |                 var nvf = parseInt(wallSimulations[worstWallForComp].substr(0,wallSimulations[worstWallForComp].indexOf("-"))) + boardWidth;
 76 |                 var nvs = parseInt(wallSimulations[worstWallForComp].substr(wallSimulations[worstWallForComp].indexOf("-")+1)) + boardWidth;
 77 |                 var nextPart = nvf+"-"+nvs;  
 78 |                 var walls_with_blocker = wallSimulations[worstWallForComp] + "," + nextPart;  
 79 |                 var inNo = placeVertWall_COMPUTE(wallSimulations[worstWallForComp],noWalls_t,walls_t,10,10,playerLoc,oppLoc,'c');
 80 |             }          
 81 |             for (var t=0;t<wallSimulations.length;t++) {  
 82 |                 if (inNo[0].indexOf(wallSimulations[t])!=-1) {
 83 |                     var whatWallPlace = $('#board td[data-pos='+wallSimulations[t]+']').attr('class');
 84 |                     if (whatWallPlace=="wallPlacementHoriz") {  
 85 |                         var test_wall_1 = wallSimulations[t];
 86 |                         var test_wall_2 = $('#board td[data-pos='+(test_wall_1)+']').next().next().attr('data-pos');   
 87 |                         var checkLegal = shortestPath(inNo[1]+","+test_wall_1+","+test_wall_2,null,null);
 88 |                         if (checkLegal[1]==0) { 
 89 |                             wallPreventTrap = wallSimulations[t]; 
 90 |                             var actuallyLegal = pathToEndExists(wallPreventTrap+","+test_wall_2,null,null);  
 91 |                             if (!actuallyLegal) { wallPreventTrap = null; }
 92 |                             else { console.log("SINGLE TRAP: "+wallSimulations[worstWallForComp]+","+wallSimulations[t]); break; }    
 93 |                         }  
 94 |                     } 
 95 |                     else if (whatWallPlace=="wallPlacementVert") {     
 96 |                         var test_wall_1 = wallSimulations[t];
 97 |                         var nvf = parseInt(test_wall_1.substr(0,test_wall_1.indexOf("-"))) + boardWidth;
 98 |                         var nvs = parseInt(test_wall_1.substr(test_wall_1.indexOf("-")+1)) + boardWidth;
 99 |                         var test_wall_2 = nvf+"-"+nvs;       
100 |                         var checkLegal = shortestPath(inNo[1]+","+test_wall_1+","+test_wall_2,null,null);
101 |                         if (checkLegal[1]==0) { 
102 |                             wallPreventTrap = wallSimulations[t]; 
103 |                             var actuallyLegal = pathToEndExists(wallPreventTrap+","+test_wall_2,null,null);
104 |                             if (!actuallyLegal) { wallPreventTrap = null; }
105 |                             else { console.log("SINGLE TRAP: "+wallSimulations[worstWallForComp]+","+wallSimulations[t]); break; }      
106 |                         }     
107 |                     }       
108 |                 }    
109 |             }    
110 |         }   
111 |         // find DOUBLE wall that can trap computer and (try to) prevent it (takes ~ 4 seconds)                                                                               
112 |         var walls_td = $("#walls").val();       
113 |         var noWalls_td = $("#nowalls").val().split(',');      
114 |         var countD = 0;                  
115 |         if (wallPreventTrap==null && parseInt($('#showPlayerPieces').children().next().text())>1 && parseInt($('#showCompPieces').children().next().text())>0 && 
116 |         arrShortestMoves_b[1]-arrShortestMoves_b[0]<=-2) {   
117 |             var compLoc = parseInt($('.pieceComputer').parent().attr('data-pos'));
118 |             var finalLocToCheck = null;
119 |             var fromLoc = wallSimulations.indexOf(compLoc-1+"-"+compLoc); 
120 |             if (fromLoc==-1) {
121 |                 var nextLoc = wallSimulations.indexOf(compLoc+"-"+compLoc+1);
122 |                 if (nextLoc==-1) {
123 |                     nextLoc = wallSimulations.indexOf(compLoc-9+"-"+compLoc); 
124 |                     if (nextLoc==-1) { finalLocToCheck = null; } 
125 |                     else { finalLocToCheck = nextLoc;  }           
126 |                 } else { finalLocToCheck = nextLoc; }
127 |             } else { finalLocToCheck = fromLoc; } 
128 |             // find player double blocking walls
129 |             for (var t=finalLocToCheck+35;t>finalLocToCheck-35;t--) {  
130 |                 if (wallPreventTrap==null && typeof wallSimulations[t]!='undefined') {  
131 |                     var whatWallPlace_0 = $('#board td[data-pos='+wallSimulations[t]+']').attr('class');    
132 |                     if (whatWallPlace_0=="wallPlacementHoriz") {  
133 |                         var test_wall_1 = wallSimulations[t];
134 |                         var test_wall_2 = $('#board td[data-pos='+(test_wall_1)+']').next().next().attr('data-pos');  
135 |                         var checkLegal = placeHorizWall_COMPUTE(test_wall_1,noWalls_td,walls_td,10,10,playerLoc,oppLoc,'c'); 
136 |                     } else if (whatWallPlace_0=="wallPlacementVert") {  
137 |                         var test_wall_1 = wallSimulations[t];
138 |                         var nvf = parseInt(test_wall_1.substr(0,test_wall_1.indexOf("-"))) + boardWidth;
139 |                         var nvs = parseInt(test_wall_1.substr(test_wall_1.indexOf("-")+1)) + boardWidth;
140 |                         var test_wall_2 = nvf+"-"+nvs;      
141 |                         var checkLegal = placeVertWall_COMPUTE(test_wall_1,noWalls_td,walls_td,10,10,playerLoc,oppLoc,'c');     
142 |                     }           
143 |                     if (checkLegal!='illegal' && typeof checkLegal!='undefined' && typeof checkLegal[0]!='undefined' && checkLegal[0]!='' && checkLegal[0]!=' ') {  
144 |                         for (var a=finalLocToCheck+35;a>finalLocToCheck-35;a--) {   
145 |                             if (test_wall_1!=wallSimulations[a] && test_wall_2!=wallSimulations[a] && wallPreventTrap==null &&
146 |                                 checkLegal[0].toString().indexOf(wallSimulations[a])!=-1 && typeof wallSimulations[a]!='undefined') {
147 |                                 var whatWallPlace_2 = $('#board td[data-pos='+wallSimulations[a]+']').attr('class');    
148 |                                 if (whatWallPlace_2=="wallPlacementHoriz") {
149 |                                     var test_wall_1_1 = wallSimulations[a];
150 |                                     var test_wall_2_2 = $('#board td[data-pos='+(test_wall_1_1)+']').next().next().attr('data-pos');  
151 |                                     var checkLegal_2 = placeHorizWall_COMPUTE(test_wall_1_1,checkLegal[0].join(",").split(","),checkLegal[1],10,10,playerLoc,oppLoc,'c'); 
152 |                                 }
153 |                                 else if (whatWallPlace_2=="wallPlacementVert") { 
154 |                                     var test_wall_1_1 = wallSimulations[a];
155 |                                     var nvf = parseInt(test_wall_1_1.substr(0,test_wall_1_1.indexOf("-"))) + boardWidth;
156 |                                     var nvs = parseInt(test_wall_1_1.substr(test_wall_1_1.indexOf("-")+1)) + boardWidth;
157 |                                     var test_wall_2_2 = nvf+"-"+nvs;     
158 |                                     var checkLegal_2 = placeVertWall_COMPUTE(test_wall_1_1,checkLegal[0].join(",").split(","),checkLegal[1],10,10,playerLoc,oppLoc,'c');    
159 |                                 }                   
160 |                                 if (checkLegal_2!='illegal' && typeof checkLegal_2!='undefined') {        
161 |                                     var sp_t = shortestPath($("#walls").val()+","+test_wall_1+","+test_wall_2+","+test_wall_1_1+","+test_wall_2_2,null,null);
162 |                                     if (sp_t[1]>=low_change_computer+5) {
163 |                                         // find one wall computer can place to make it all illegal   
164 |                                         for (var z=finalLocToCheck-35;z<finalLocToCheck+35;z++) { 
165 |                                             if (wallPreventTrap==null && test_wall_1!=wallSimulations[z] && test_wall_2!=wallSimulations[z] && 
166 |                                                 test_wall_1_1!=wallSimulations[z] && test_wall_2_2!=wallSimulations[z] && typeof wallSimulations[z]!='undefined' &&
167 |                                                 checkLegal_2[0].toString().indexOf(wallSimulations[z])!=-1) {
168 |                                                 var whatWallPlace_5 = $('#board td[data-pos='+wallSimulations[z]+']').attr('class');    
169 |                                                 if (whatWallPlace_5=="wallPlacementHoriz") {
170 |                                                     var test_wall_1_z = wallSimulations[z];
171 |                                                     var test_wall_2_z = $('#board td[data-pos='+(test_wall_1_z)+']').next().next().attr('data-pos');   
172 |                                                 }
173 |                                                 else if (whatWallPlace_5=="wallPlacementVert") { 
174 |                                                     var test_wall_1_z = wallSimulations[z];
175 |                                                     var nvf = parseInt(test_wall_1_z.substr(0,test_wall_1_z.indexOf("-"))) + boardWidth;
176 |                                                     var nvs = parseInt(test_wall_1_z.substr(test_wall_1_z.indexOf("-")+1)) + boardWidth;
177 |                                                     var test_wall_2_z = nvf+"-"+nvs;     
178 |                                                 }
179 |                                                 var checkLegal_5 = pathToEndExists(test_wall_1+","+test_wall_2+","+test_wall_1_1+","+test_wall_2_2+","+test_wall_1_z+","+test_wall_2_z,null,null);  
180 |                                                 if (!checkLegal_5) {  
181 |                                                     wallPreventTrap = wallSimulations[z]; 
182 |                                                     var actuallyLegal = pathToEndExists(wallPreventTrap+","+test_wall_2_z,null,null);
183 |                                                     if (!actuallyLegal) { wallPreventTrap = null; }
184 |                                                     else { wallPreventTrap = "tempfake"; }      
185 |                                                 } 
186 |                                             }
187 |                                         }
188 |                                         // find two walls computer can place to make it all illegal
189 |                                         for (var b=finalLocToCheck-90;b<finalLocToCheck+10;b++) {  
190 |                                             if (wallPreventTrap==null && test_wall_1!=wallSimulations[b] && test_wall_2!=wallSimulations[b] && 
191 |                                             test_wall_1_1!=wallSimulations[b] && test_wall_2_2!=wallSimulations[b] && typeof wallSimulations[b]!='undefined') {  
192 |                                                 var whatWallPlace_3 = $('#board td[data-pos='+wallSimulations[b]+']').attr('class');    
193 |                                                 if (whatWallPlace_3=="wallPlacementHoriz") {  
194 |                                                     var test_wall_1_b = wallSimulations[b];
195 |                                                     var test_wall_2_b = $('#board td[data-pos='+(test_wall_1_b)+']').next().next().attr('data-pos');   
196 |                                                     var checkLegal_3 = placeHorizWall_COMPUTE(test_wall_1_b,checkLegal_2[0].join(",").split(","),checkLegal_2[1]+","+test_wall_1_1+","+test_wall_2_2,10,10,playerLoc,oppLoc,'c');
197 |                                                 } else if (whatWallPlace_3=="wallPlacementVert") {  
198 |                                                     var test_wall_1_b = wallSimulations[b];
199 |                                                     var nvf = parseInt(test_wall_1_b.substr(0,test_wall_1_b.indexOf("-"))) + boardWidth;
200 |                                                     var nvs = parseInt(test_wall_1_b.substr(test_wall_1_b.indexOf("-")+1)) + boardWidth;
201 |                                                     var test_wall_2_b = nvf+"-"+nvs;      
202 |                                                     var checkLegal_3 = placeVertWall_COMPUTE(test_wall_1_b,checkLegal_2[0].join(",").split(","),checkLegal_2[1]+","+test_wall_1_1+","+test_wall_2_2,10,10,playerLoc,oppLoc,'c');   
203 |                                                 }
204 |                                                 if (checkLegal_3!='illegal' && typeof checkLegal_3!='undefined') { 
205 |                                                     for (var c=finalLocToCheck-90;c<finalLocToCheck+10;c++) { 
206 |                                                         if (wallPreventTrap==null && test_wall_1!=wallSimulations[c] && test_wall_2!=wallSimulations[c] && 
207 |                                                             test_wall_1_1!=wallSimulations[c] && test_wall_2_2!=wallSimulations[c] && test_wall_1_b!=wallSimulations[c] &&
208 |                                                             test_wall_2_b!=wallSimulations[c] && typeof wallSimulations[c]!='undefined' 
209 |                                                             && checkLegal_3[0].toString().indexOf(wallSimulations[c])!=-1) {
210 |                                                             var whatWallPlace_4 = $('#board td[data-pos='+wallSimulations[c]+']').attr('class');    
211 |                                                             if (whatWallPlace_4=="wallPlacementHoriz") {
212 |                                                                 var test_wall_1_c = wallSimulations[c];
213 |                                                                 var test_wall_2_c = $('#board td[data-pos='+(test_wall_1_c)+']').next().next().attr('data-pos');   
214 |                                                             }
215 |                                                             else if (whatWallPlace_4=="wallPlacementVert") { 
216 |                                                                 var test_wall_1_c = wallSimulations[c];
217 |                                                                 var nvf = parseInt(test_wall_1_c.substr(0,test_wall_1_c.indexOf("-"))) + boardWidth;
218 |                                                                 var nvs = parseInt(test_wall_1_c.substr(test_wall_1_c.indexOf("-")+1)) + boardWidth;
219 |                                                                 var test_wall_2_c = nvf+"-"+nvs;     
220 |                                                             }
221 |                                                             var checkLegal_4 = pathToEndExists(test_wall_1+","+test_wall_2+","+test_wall_1_1+","+test_wall_2_2+","+test_wall_1_b+","+test_wall_2_b+","+test_wall_1_c+","+test_wall_2_c,null,null);  
222 |                                                             if (!checkLegal_4) {      
223 |                                                                 wallPreventTrap = wallSimulations[b];   
224 |                                                                 var actuallyLegal = pathToEndExists(test_wall_1_b+","+test_wall_2_b+","+test_wall_1_c+","+test_wall_2_c,null,null);  
225 |                                                                 if (!actuallyLegal) { wallPreventTrap = null; }   
226 |                                                                 console.log(test_wall_1+","+test_wall_2+","+test_wall_1_1+","+test_wall_2_2+","+test_wall_1_b+","+test_wall_2_b+","+test_wall_1_c+","+test_wall_2_c);  
227 |                                                                 //countD++; if (countD>5000) { wallPreventTrap='tempfake'; } 
228 |                                                                 console.log("DOUBLE TRAP");
229 |                                                             } 
230 |                                                         }
231 |                                                     }
232 |                                                 } 
233 |                                             }
234 |                                         }    
235 |                                     }        
236 |                                 } 
237 |                             }
238 |                         }    
239 |                     } 
240 |                 }
241 |             }
242 |         }    
243 |         if (wallPreventTrap=='tempfake') { wallPreventTrap=null; }    
244 |         // determine SINGLE wall that slows player            
245 |         for (var k=0;k<arrShortestMoves_a.length;k++) {    
246 |             if (arrShortestMoves_a[k][0]>=high_change_player) {            
247 |                 bestWall_sp=k; 
248 |                 high_change_player = arrShortestMoves_a[k][0];  
249 |             }    
250 |         }    
251 |         // play N=2 moves into future and see if SINGLE wall should wait (only if player has no walls)  
252 |         var pMoves = possibleMoves($('.piecePlayer').parent().attr('data-pos'),true,$('.pieceComputer').parent().attr('data-pos'),null);
253 |         if (parseInt($('#showPlayerPieces').children().next().text())==0 && parseInt($('#showCompPieces').children().next().text())>0 && 
254 |         pMoves[1].indexOf(0)==-1 && pMoves[1].indexOf(1)==-1 && pMoves[1].indexOf(2)==-1 && pMoves[1].indexOf(3)==-1 &&
255 |         pMoves[1].indexOf(4)==-1 && pMoves[1].indexOf(5)==-1 && pMoves[1].indexOf(6)==-1 && pMoves[1].indexOf(7)==-1 && pMoves[1].indexOf(8)==-1) {
256 |             var playerMoves_1 = possibleMoves($('.piecePlayer').parent().attr('data-pos'),true,$('.pieceComputer').parent().attr('data-pos'),null); 
257 |             var move_sp = 100;
258 |             var tempLoc_1 = null;
259 |             for (var p=0;p<playerMoves_1[1].length;p++) { 
260 |                 var temp_sp = shortestPath(null,null,playerMoves_1[1][p]);
261 |                 if (temp_sp[0]<move_sp) {
262 |                     move_sp = temp_sp[0]; 
263 |                     tempLoc_1 = p;       
264 |                 }
265 |             }
266 |             var playerMoves_2 = possibleMoves(playerMoves_1[1][tempLoc_1],true,$('.pieceComputer').parent().attr('data-pos'),null); 
267 |             var move_sp = 100;
268 |             var tempLoc_2 = null;
269 |             for (var p=0;p<playerMoves_2[1].length;p++) { 
270 |                 var temp_sp = shortestPath(null,null,playerMoves_2[1][p]);
271 |                 if (temp_sp[0]<move_sp) {
272 |                     move_sp = temp_sp[0]; 
273 |                     tempLoc_2 = p;       
274 |                 }
275 |             }
276 |             var walls_f = $("#walls").val();       
277 |             var noWalls_f = $("#nowalls").val().split(',');
278 |             for (var p=0;p<wallSimulations.length;p++) {  
279 |                 if (wallSimulations[p]!='') {     
280 |                     var whatWallPlace = $('#board td[data-pos='+wallSimulations[p]+']').attr('class');
281 |                     if (whatWallPlace=="wallPlacementHoriz") {     
282 |                         var wallDown_1 = placeHorizWall_COMPUTE(wallSimulations[p],noWalls_f,walls_f,playerWallsLeft,compWallsLeft,playerMoves_1[1][tempLoc_1],oppLoc,'c'); 
283 |                         if (wallDown_1!='illegal') { 
284 |                             var passW_1  = wallDown_1[1].split(",").join(","); 
285 |                             var sp_a_1 = shortestPath(passW_1,null,playerMoves_1[1][tempLoc_1]);
286 |                         }   
287 |                         var wallDown_2 = placeHorizWall_COMPUTE(wallSimulations[p],noWalls_f,walls_f,playerWallsLeft,compWallsLeft,playerMoves_2[1][tempLoc_2],oppLoc,'c'); 
288 |                         if (wallDown_2!='illegal') { 
289 |                             var passW_2  = wallDown_2[1].split(",").join(","); 
290 |                             var sp_a_2 = shortestPath(passW_2,null,playerMoves_2[1][tempLoc_2]);
291 |                         }    
292 |                     } 
293 |                     else if (whatWallPlace=="wallPlacementVert") {   
294 |                         var wallDown_1 = placeVertWall_COMPUTE(wallSimulations[p],noWalls_f,walls_f,playerWallsLeft,compWallsLeft,playerMoves_1[1][tempLoc_1],oppLoc,'c'); 
295 |                         if (wallDown_1!='illegal') { 
296 |                             var passW_1  = wallDown_1[1].split(",").join(","); 
297 |                             var sp_a_1 = shortestPath(passW_1,null,playerMoves_1[1][tempLoc_1]);
298 |                         }   
299 |                         var wallDown_2 = placeVertWall_COMPUTE(wallSimulations[p],noWalls_f,walls_f,playerWallsLeft,compWallsLeft,playerMoves_2[1][tempLoc_2],oppLoc,'c'); 
300 |                         if (wallDown_2!='illegal') { 
301 |                             var passW_2  = wallDown_2[1].split(",").join(","); 
302 |                             var sp_a_2 = shortestPath(passW_2,null,playerMoves_2[1][tempLoc_2]);
303 |                         }   
304 |                     }          
305 |                     if (wallDown_1!='illegal') {                      
306 |                         if (sp_a_1[0]>high_change_player) {
307 |                             futureWall = true;
308 |                             console.log("WALL WILL BE BETTER IN THE FUTURE");  
309 |                         }
310 |                     }
311 |                     if (wallDown_2!='illegal') {
312 |                         if (sp_a_2[0]>high_change_player) {
313 |                             futureWall = true;
314 |                             console.log("WALL WILL BE BETTER IN THE FUTURE");     
315 |                         }
316 |                     }
317 |                 }  
318 |             }                         
319 |         }
320 |         var playerLoc = parseInt($('.piecePlayer').parent().attr('data-pos'));
321 |         var compWallsLeft = $('#showCompPieces').children().next().text();
322 |         var finalLocToCheck = null;
323 |         var fromLoc = wallSimulations.indexOf(playerLoc-1+"-"+playerLoc); 
324 |         if (fromLoc==-1) {
325 |             var nextLoc = wallSimulations.indexOf(playerLoc+"-"+playerLoc+1);
326 |             if (nextLoc==-1) {
327 |                 nextLoc = wallSimulations.indexOf(playerLoc-9+"-"+playerLoc); 
328 |                 if (nextLoc==-1) {  
329 |                     nextLoc = wallSimulations.indexOf(playerLoc+"-"+playerLoc+9);
330 |                     if (nextLoc==-1) {
331 |                         finalLocToCheck = null; 
332 |                         console.log("CANT ATTEMPT DOUBLE WALL");        
333 |                     } 
334 |                 } else { finalLocToCheck = nextLoc; }     
335 |             } else { finalLocToCheck = nextLoc; }
336 |         } else { finalLocToCheck = fromLoc; } 
337 |         var walls_d = $("#walls").val();       
338 |         var noWalls_d = $("#nowalls").val().split(',');
339 |         // determine DOUBLE wall that slows player if computer is behind at least 2 spaces (takes ~ 4 seconds)
340 |         if (finalLocToCheck!=null) {
341 |             for (var t=finalLocToCheck-25;t<finalLocToCheck+25;t++) {  
342 |                 if (doublePlaceWall==null && compWallsLeft>1 && typeof wallSimulations[t] != 'undefined' && playerWallsLeft-compWallsLeft<4 && 
343 |                 arrShortestMoves_b[1]-arrShortestMoves_b[0]>=2) {     
344 |                     var whatWallPlace = $('#board td[data-pos='+wallSimulations[t]+']').attr('class');    
345 |                     if (whatWallPlace=="wallPlacementHoriz") {  
346 |                         var test_wall_1 = wallSimulations[t];
347 |                         var test_wall_2 = $('#board td[data-pos='+(test_wall_1)+']').next().next().attr('data-pos');
348 |                         var checkLegal = placeHorizWall_COMPUTE(test_wall_1,noWalls_d,walls_d,10,10,playerLoc,oppLoc,'c');     
349 |                     } else if (whatWallPlace=="wallPlacementVert") {  
350 |                         var test_wall_1 = wallSimulations[t];
351 |                         var nvf = parseInt(test_wall_1.substr(0,test_wall_1.indexOf("-"))) + boardWidth;
352 |                         var nvs = parseInt(test_wall_1.substr(test_wall_1.indexOf("-")+1)) + boardWidth;
353 |                         var test_wall_2 = nvf+"-"+nvs;        
354 |                         var checkLegal = placeVertWall_COMPUTE(test_wall_1,noWalls_d,walls_d,10,10,playerLoc,oppLoc,'c');   
355 |                     }
356 |                     if (checkLegal!='illegal') { 
357 |                         for (var a=finalLocToCheck-25;a<finalLocToCheck+25;a++) {  
358 |                             if (checkLegal[0].indexOf(wallSimulations[a])!=-1) {
359 |                                 var whatWallPlace_2 = $('#board td[data-pos='+wallSimulations[a]+']').attr('class');    
360 |                                 if (whatWallPlace_2=="wallPlacementHoriz") {
361 |                                     var test_wall_1_1 = wallSimulations[a];
362 |                                     var test_wall_2_2 = $('#board td[data-pos='+(test_wall_1_1)+']').next().next().attr('data-pos');   
363 |                                 }
364 |                                 else if (whatWallPlace_2=="wallPlacementVert") { 
365 |                                     var test_wall_1_1 = wallSimulations[a];
366 |                                     var nvf = parseInt(test_wall_1_1.substr(0,test_wall_1_1.indexOf("-"))) + boardWidth;
367 |                                     var nvs = parseInt(test_wall_1_1.substr(test_wall_1_1.indexOf("-")+1)) + boardWidth;
368 |                                     var test_wall_2_2 = nvf+"-"+nvs;     
369 |                                 }
370 |                                 var checkLegal_2 = pathToEndExists(test_wall_1+","+test_wall_2+","+test_wall_1_1+","+test_wall_2_2,null,null);
371 |                                 if (checkLegal_2) {          
372 |                                     // if placing both walls are legal and both walls together slow player down
373 |                                     var checkSP2walls = shortestPath($("#walls").val()+","+test_wall_1+","+test_wall_2+","+test_wall_1_1+","+test_wall_2_2,null,null);
374 |                                     if (checkSP2walls[0]>high_change_player/*+1*/ && checkSP2walls[1]<=low_change_computer+1) { 
375 |                                         doublePlaceWall = a; 
376 |                                         doubleWallPathLen = checkSP2walls[0];
377 |                                         break; 
378 |                                     }            
379 |                                 } 
380 |                             }
381 |                         }
382 |                     }  
383 |                 }     
384 |             }
385 |         }
386 |         // find best move with shortest path
387 |         var fm_pos = 0;
388 |         var fastestMove = 100; 
389 |         for (var p=0;p<moveSimulations.length;p++) { 
390 |             var fm = shortestPath(null,moveSimulations[p]);
391 |             if (fm[1]<fastestMove) { 
392 |                 fastestMove = fm[1]; 
393 |                 fm_pos = p; 
394 |             }
395 |         }      
396 |         
397 |         console.log("---------------------------");
398 |         var ranWallMove = Math.random(); 
399 |         var bestWall = wallSimulations[bestWall_sp]; 
400 |         var bestMove = moveSimulations[fm_pos]; 
401 |         if (typeof arrShortestMoves_a[bestWall_sp]!='undefined' && arrShortestMoves_a[bestWall_sp]!='' && arrShortestMoves_a[bestWall_sp]!=' ' &&
402 |             typeof bestWall!='undefined' && bestWall!='' && bestWall!=' ') { 
403 |             console.log("WALL "+wallSimulations[bestWall_sp] + " slows player from " +arrShortestMoves_b[0]+ " to " +high_change_player); 
404 |             console.log("WALL "+wallSimulations[bestWall_sp]+ " slows computer from " +arrShortestMoves_b[1]+ " to " + arrShortestMoves_a[bestWall_sp][1]); 
405 |         }
406 |         console.log("BEST WALL: "+bestWall); 
407 |         console.log("BEST MOVE: "+bestMove);
408 |         console.log("SHORTEST PATHS: "+arrShortestMoves_b);  
409 |         
410 |         // split board up - heuristic-ish for stopping long paths
411 |         if (ranWallMove<0.3 && (wallSimulations.indexOf("21-22")!=-1 && wallSimulations.indexOf("22-23")!=-1 && 
412 |                                 wallSimulations.indexOf("39-40")!=-1 && wallSimulations.indexOf("40-41")!=-1)) {      
413 |             var r = Math.random();
414 |             if (r<0.25) { var p = "21-22"; } 
415 |             else if (r<0.5) { var p ="22-23"; } 
416 |             else if (r<0.75) { var p = "39-40"; } 
417 |             else { var p = "40-41"; }   
418 |             placeVertWall(p);         
419 |         }
420 |         // decide what move to make out of best options      
421 |         else if (doublePlaceWall!=null && typeof wallSimulations[doublePlaceWall]!='undefined' && wallPreventTrap==null && 
422 |         high_change_player-arrShortestMoves_b[0]<7 && !futureWall) {
423 |             console.log("DOUBLE PLACE WALL: "+wallSimulations[doublePlaceWall]);      
424 |             var whatWallPlace = $('#board td[data-pos='+(wallSimulations[doublePlaceWall])+']').attr('class'); 
425 |             if (whatWallPlace=="wallPlacementHoriz") { var wall = placeHorizWall(wallSimulations[doublePlaceWall]); }
426 |             else if (whatWallPlace=="wallPlacementVert") { var wall = placeVertWall(wallSimulations[doublePlaceWall]); } 
427 |         }
428 |         // only check for traps if computer is losing by at most 4 spaces and if winning at all
429 |         else if (wallPreventTrap!=null && arrShortestMoves_b[1]-arrShortestMoves_b[0]<=2 && high_change_player-arrShortestMoves_b[0]<6 && playerWallsLeft-compWallsLeft<3) {
430 |             console.log("COMPUTER TRAP WALL: "+wallPreventTrap); 
431 |             var whatWallPlace = $('#board td[data-pos='+(wallPreventTrap)+']').attr('class'); 
432 |             if (whatWallPlace=="wallPlacementHoriz") { var wall = placeHorizWall(wallPreventTrap); }
433 |             else if (whatWallPlace=="wallPlacementVert") { var wall = placeVertWall(wallPreventTrap); }     
434 |         }                    
435 |         else if ((typeof bestWall!='undefined' && bestWall!='' && bestWall!=' ' && !futureWall) && 
436 |                  (high_change_player-arrShortestMoves_b[0]>=3 || 
437 |                  (arrShortestMoves_b[0]<8 && ranWallMove<0.3) ||
438 |                  (arrShortestMoves_b[0]<7 && compMoves[0]>8 && ranWallMove<0.6) ||
439 |                  (arrShortestMoves_b[0]<6 && compMoves[0]>8)) && 
440 |                   high_change_player-arrShortestMoves_b[0]>0 && 
441 |                  (playerWallsLeft-compWallsLeft<3 || arrShortestMoves_b[0]<4 || high_change_player-arrShortestMoves_b[0]>=4)) {  
442 |                  
443 |             // if losing dont slow down computer only player
444 |             var getDiff = high_change_player-arrShortestMoves_b[0];  
445 |             if (arrShortestMoves_b[1]-arrShortestMoves_b[0]>=3 && arrShortestMoves_a[bestWall_sp][1]-arrShortestMoves_b[1]<=getDiff) {
446 |                 console.log("WALL IS OK FOR COMPUTER (LOSING)");
447 |                 var whatWallPlace = $('#board td[data-pos='+(bestWall)+']').attr('class'); 
448 |                 if (whatWallPlace=="wallPlacementHoriz") { var wall = placeHorizWall(bestWall); }
449 |                 else if (whatWallPlace=="wallPlacementVert") { var wall = placeVertWall(bestWall); } 
450 |             } else if (arrShortestMoves_b[1]-arrShortestMoves_b[0]<3) {
451 |                 console.log("WALL IS OK FOR COMPUTER (NOT LOSING)")
452 |                 var whatWallPlace = $('#board td[data-pos='+(bestWall)+']').attr('class'); 
453 |                 if (whatWallPlace=="wallPlacementHoriz") { var wall = placeHorizWall(bestWall); }
454 |                 else if (whatWallPlace=="wallPlacementVert") { var wall = placeVertWall(bestWall); }     
455 |             } else {
456 |                 console.log("WALL NOT HELPFUL FOR COMPUTER");
457 |                 movePiece(compMoves[0],bestMove);     
458 |             }
459 |             
460 |         } 
461 |         else {  
462 |             movePiece(compMoves[0],bestMove);
463 |         }       
464 |     }            
465 | }
466 | 
467 | 


--------------------------------------------------------------------------------