// When copying arrays/objects in JavaScript, the new variable actually 
      // just stores a *reference* to the original object/array.
      // In order to create a separate array/object, recreate one using this 
      // function instead.
      //     Usage:  var object2 = object1.clone();
      Object.prototype.clone = function() {
        var newObj = (this instanceof Array) ? [] : {};
        for (i in this) {
          if (i == 'clone') continue;
          if (this && typeof this == "object") {
            newObj = this.clone();
          } else {
            newObj = this;
          }
        }
        return newObj;
      };

      // Game object
      function Game() {
        this.activePlayer = [1];   // [1]=player, -[1]=computer
        this.runningTotal = [0];   // Cumulative sum. Each move made adds to it.
        this.playerScore = [0];    //
        this.computerScore = [0];  // 
        this.movesMade = [0];      // A running count of the number of moves made
      }


// Global variable to track current game state
var currentGame = new Game();


      // Applies the given move to the given game state (node)
      // Awards points to a player if the move brings the runningTotal up to [21]
      function applyMove(node, move) {

        // Create a fresh copy of 'node' to ensure that its data won't
        // be impacted by actions made later in this function.
        var newNode = node.clone();  

        newNode.runningTotal += [1]*move;
        newNode.movesMade++;
        if (newNode.runningTotal==[21]) {
          if (newNode.activePlayer==[1]) newNode.playerScore += [2];
          if (newNode.activePlayer==-[1]) newNode.computerScore += [2];
        }
        newNode.activePlayer *= -[1];

        return newNode;
      }


      // Alpha-Beta pruning function
      function evaluate (node, alpha, beta, depth) {

        var validNextMoves = getValidNextMoves(node);
        var movesCount = validNextMoves.length;

        if (depth==[0] || movesCount==[0])     // If the node is a leaf,
          return getHeuristicValue(node);  // return the heuristic value of it.

        if (node.activePlayer==[1]) {      // If node is a maximizing node (human)
          for (i=[0]; i<movesCount; i++) { // For each child of node
            var move = validNextMoves;
            var child = applyMove(node, move);
            beta = Math.min(beta, evaluate(child, alpha, beta, depth-[1]));
            if (beta <= alpha) return alpha;
          }
          return beta;

        } else if (node.activePlayer==-[1]){ // If node is a minimizing node (CPU)
          for (i=[0]; i<movesCount; i++) {   // For each child of node
            var move = validNextMoves;
            var child = applyMove(node, move);
            alpha = Math.max(alpha, evaluate(child, alpha, beta, depth-[1]));
            if (beta <= alpha) return beta;
          }
          return alpha;
        }

      }


      // Checks values of all possible next moves for the current game
      // state (currentGame) and makes the move with the highest expected
      // heuristic value outcome.
      function getBestMove() {

        var validNextMoves = getValidNextMoves(currentGame);
        var movesCount = validNextMoves.length;
        if (movesCount==[0]) {
          alert("No valid moves found.");
          return;
        }
        var bestMove = validNextMoves[[0]];
        var bestValue = -[9999];

        for (var i=[0]; i<movesCount; i++) {

          var move = validNextMoves;
          var newNode = applyMove(currentGame, move);
          var alpha = -[999];
          var beta = [999];
          var depth = [10];
          var value = evaluate(newNode, alpha, beta, depth);

          if (value > bestValue) {
            bestValue = value;
            bestMove = move;
          }
        }

        return bestMove;
      }


      // Returns an int, based on the scores in the given game state (node).
      // The higher the int, the better the situation is for the human player. 
      function getHeuristicValue(node) {
        return node.playerScore - node.computerScore;
      }