calculateHeuristic2

gistfile1.txt

// 6.1 calculateHeuristic2 function for Open^Computer - Open^Player

function calculateHeuristic2(possiblerow, possiblecolumn):void {
    // heurist function 2 = OpenX - OpenO
    // the computer (player X) looks for the max value
    // extra check for choices with 2 Os
    // when 2 Os are found, chosen move will stop it
    // results saved into optimalmove[]
    var row:int, column:int;
    var you:int, computer:int;
    var boardtest:Array = new Array(3);
    var OpenX:int, OpenO:int;
    
    boardtest[0] = board[0].slice();
    boardtest[1] = board[1].slice();
    boardtest[2] = board[2].slice();
    
    // needs slice() to independant copy of original board array
    // with 2D arrays, slice only works for 1D-arrays
    
    boardtest[possiblerow][possiblecolumn] = "O";
    
    var openX:int = 0;
    var openO:int = 0;
    
    // check rows
    for (row:int = 0; row < 3; row++) {
        you = 0;
        computer = 0;
        
        for (column = 0; column < n; column++) {
            player = boardtest[row][column];
            
            switch (player) {
                case "-":
                    you++;
                    computer++;
                    break;
                case "X":
                    you++;
                    break;
                case "O":
                    computer++;
                    break;
            }
        }
        
        if (you == 3) {
            openX++;
        }
        
        if (computer == 3) {
            openO++;
        }
    }
    
    // check columns
    for (column = 0; column < 3; column++) {
        you = 0;
        computer = 0;
        for (row = 0; row < 3; row++) {
            player = boardtest[row][column];
            
            switch (player) {
                case "-":
                    you++;
                    computer++;
                    break;
                case "X":
                    you++;
                    break;
                case "O":
                    computer++
                    break;
            }
        }
        
        if (you == 3) {
            openX++;
        }
        if (computer == 3) {
            openO++;
        }
    }
    
    // check 1st diagonal
    you=0; 
    computer=0; 
    
    for (index=0; index<3; index++) {
        player=boardtest[index][index]; 
        
        switch (player) {
                case "-": 
                    you++;
                    computer++;
                    break; 
                case "X" :
                    you++;
                    break; 
                case "O" :
                    computer++;
                    break;
        } 
        
        if (you==3) {
            openX++;
        }
        if (computer==3) {
            openO++;
        }
    }
    
    // check 2nd diagonal
    you = 0;
    computer = 0;
    
    for (index = 0; index < n; index++) {
        player = boardtest[index][2-index];
        switch (player) {
            case "-":
                you++;
                computer++;
                break;
            case "X":
                you++;
                break;
            case "O":
                computer++;
                break;
        }
    }
    
    if (you == 3) {
        openX++;
    }
    if (computer == 3) {
        openO++;
    }
    
    if ((openO - openX) > optimalmove[2]) {
        // move better than previous
        optimalmove[0] = possiblerow;
        optimalmove[1] = possiblecolumn;
        optimalmove[2] = openO - openX;
    }
}