Using Multidimensional Arrays

How to use multidimensional arrays in your code.

About this technique	Details
Category	Core Programming Techniques> Java
Description	You'll learn about: Using an array of labels to contain display characters Setting the array element specified by the user Obtaining array values to check for a winning pattern Using a timer before generating a move
	You can run this technique code from: Database: Examples3_Java Form: frmTicTacToe NOTE   First make sure that database is running on your localhost SilverStream Server
Related reading	See the chapter on coding Java for SilverStream applications in the Programmer's Guide

This example loads multidimensional arrays with objects and values, then navigates through them to retrieve values. It uses the game Tic Tac Toe.

The form also contains a timer to delay processing so that it appears the computer is thinking.

Using an array of labels to contain display characters   

The following code shows how the game's user moves and computer moves are stored. The display characters representing the moves are stored as text in the elements of an AgcLabel array.

  protected void formLoaded() 
  { 
     // Load each cell in the array with the appropriate label. 
     cell [0][0] = lblRow1Col1; 
     cell [0][1] = lblRow1Col2; 
     cell [0][2] = lblRow1Col3; 
     cell [1][0] = lblRow2Col1; 
     cell [1][1] = lblRow2Col2; 
     cell [1][2] = lblRow2Col3; 
     cell [2][0] = lblRow3Col1; 
     cell [2][1] = lblRow3Col2; 
     cell [2][2] = lblRow3Col3; 
  } 

Notes about the code

• Set each element of the array to the start value. cell is an array of AgcLabel objects.

• Each array element, for example, lblRow1Col1, is an AgcLabel object. When the form is loaded, set every element's display text to null by calling lblRow1Col1.setText("");

Setting the array element specified by the user   

In the following code, the user must have clicked on the cell in (row 1, column 1) for this event to occur. The code for the other events (generated from clicking the other cells in the form) is similar. The following code sets the text of a particular label element in the cell array, thereby displaying an "X" in the corresponding cell on the form. It also sets the corresponding element in the board array, which is used for pattern checking.

  private void handle_lblRow1Col1_mousePressed(MouseEvent mouseEvent) 
  { 
     // No move allowed, if game over 
     if (gbWin)  
        return; 
   
     if (lblRow1Col1.getText() == "") 
     { 
        lblRow1Col1.setText("X"); 
        board [0][0] = 'x'; 
        evaluateBoard (); 
     } 
  } 

Notes about the code

• Check that the text in the label is null.

• Set its display text to "X" by calling setText().

• Set the corresponding element in board to the character 'x'. board is a two-dimensional array of character elements. There is a one-to-one match between the elements of board and the elements of cell. It is used as a quicker way of evaluating as to whether there is a winning pattern on the board.

Obtaining array values to check for a winning pattern   

The following code uses board to check for the 8 possible winning patterns. If it identifies one of the winning patterns, it sets the gbWin flag to true. In this method, the input parameter ('x' or 'o') determines the player for which it evaluates the winning pattern.

  public boolean checkForWin(char charCode) 
  { 
     // Make sure the flag is false to begin with 
     gbWin = false; 
      
     // Check the top left to bottom right diagonal for a win 
     if ( (board[0][0] == charCode) &&  
           (board[1][1] == charCode) &&  
           (board[2][2] == charCode) ) 
        gbWin = true; 
   
     // Check the top right to bottom left diagonal for a win 
     else if ( (board[0][2] == charCode) &&  
              (board[1][1] == charCode) &&  
              (board[2][0] == charCode) ) 
        gbWin = true; 
   
     // Now check the rows 
     else for (int i = 0; i < 3; i++) 
     { 
        // Check rows across for a win 
        if ( (board[i][0] == charCode) &&  
              (board[i][1] == charCode) &&  
              (board[i][2] == charCode) ) 
        { 
           gbWin = true;  
           break; 
        } 
      
        // Check columns down for a win 
        if ( (board[0][i] == charCode) &&  
              (board[1][i] == charCode) &&  
              (board[2][i] == charCode) ) 
        { 
           gbWin = true;  
           break; 
        } 
     } 
   
     // Return the result of checking for a win 
     return gbWin; 
  } 

Notes about the code

• Set the flag that indicates a winning pattern to false.

• Check if the three cells along the upper-left-to-lower-right diagonal have the same character. If so, set gbWin to true.

• Perform the same for the three cells along the upper-right-to-lower-left diagonal.

• Use the for loop to check for row winning patterns and column winning patterns.

Using a timer before generating a move   

The following code checks if the user has made the winning move. If not, it uses a timer to pause the computer before it makes the next move.

  public void evaluateBoard() 
  { 
     // Check if the users last move won 
     if (checkForWin ('x')) 
     { 
        taMessage.setText (GS_YOU_WON); 
        return; 
     } 
   
     // Wait a little before making our move. 
     tmrWait.startTimer(); 
  } 

Notes about the code

• Check if the user has won by calling checkForWin() and providing 'x' as the parameter. The user always plays "X". This method returns true if the user has won. In this case, display a winning message.

• If the user did not make a winning move, pause the application by calling tmrWait.startTimer().

• tmrWait is an AgcTimer object. Its Interval property is set to 0.25 seconds. This causes the application to wait for 0.25 seconds before making the next move.