كود لعبة داما في j2me

اذهب الى الأسفل

كود لعبة داما في j2me Empty كود لعبة داما في j2me

مُساهمة من طرف أيمن الإبراهيم في الثلاثاء فبراير 04, 2014 8:31 pm

اهلا وسهلا بكم في منتدى مصر التقني 
-------------------------------------


لعبة داما رائعة للاذكياء  Very Happy



كود لعبة داما في j2me Egy-tech13915457751


كود التالي 



الكود:


import java.util.Vector;
import java.io.*;
import javax.microedition.io.*;
import javax.microedition.rms.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;


public class Checkers extends MIDlet implements CommandListener {

  private CheckersCanvas myCanvas;
  private Communicator myCommunicator;


  private Command myExitCommand = new Command("Exit", Command.EXIT, 99);


  public Checkers() {

    try { 


      myCanvas = new CheckersCanvas(Display.getDisplay(this));
      myCanvas.addCommand(myExitCommand);
      myCanvas.setCommandListener(this);
      CheckersGame game = myCanvas.getGame();
     myCommunicator = new Communicator(this, myCanvas, game);

      game.setCommunicator(myCommunicator);


    } catch(Exception e) {
      errorMsg(e);

    }


  }


  public void startApp() throws MIDletStateChangeException {

    if(myCanvas != null) {

      myCanvas.start();

   }


    if(myCommunicator != null) {

     myCommunicator.start();

    }

 }


  public void destroyApp(boolean unconditional) 


      throws MIDletStateChangeException {

    if(myCommunicator != null) {

      myCommunicator.endGame();

    }


    myCommunicator = null;

   myCanvas = null;

    System.gc();

  }


  public void pauseApp() {

    try {



      destroyApp(false);

      notifyDestroyed();

    } catch (MIDletStateChangeException ex) {

    }

  }






  public void commandAction(Command c, Displayable s) {

    if(c == myExitCommand) {

      try {

          destroyApp(false);

          notifyDestroyed();

      } catch (MIDletStateChangeException ex) {

   }

   }

 }



  void errorMsg(Exception e) {
    e.printStackTrace();
    if(e.getMessage() == null) {
      errorMsg(e.getClass().getName());

    } else {

      errorMsg(e.getMessage());
   }

  }


  void errorMsg(String msg) {

    Alert errorAlert = new Alert("error", 

         msg, null, AlertType.ERROR);

    errorAlert.setCommandListener(this);

    errorAlert.setTimeout(Alert.FOREVER);

    Display.getDisplay(this).setCurrent(errorAlert);

  }

}

class CheckersCanvas extends Canvas {


  public static final int BLACK = 0;

 public static final int WHITE = 0xffffff;

  public static final int RED = 0xf96868;

  public static final int GREY = 0xc6c6c6;
  public static final int LT_GREY = 0xe5e3e3;

  public static final int GRID_WIDTH = 8;


  private Image myBlackCrown;
  private Image myWhiteCrown;


  private Display myDisplay;
  private CheckersGame myGame;
  private int mySquareSize;
  private int myMinSquareSize = 15;

 private boolean myIsWaiting;



  CheckersGame getGame() {
    return(myGame);

  }


  void setWaitScreen(boolean wait) {

   myIsWaiting = wait;

  }


  CheckersCanvas(Display d) throws Exception {
    myDisplay = d;

   myGame = new CheckersGame();

   int width = getWidth();
  int height = getHeight();


    int screenSquareWidth = height;
  if(width < height) {

      screenSquareWidth = width;
    }


    mySquareSize = screenSquareWidth ;

    if(mySquareSize < myMinSquareSize) {

     throw(new Exception("Display too small"));

   }

    myBlackCrown = Image.createImage("/blackCrown.png");
    myWhiteCrown = Image.createImage("/whiteCrown.png");

  }


  void start() {


    myDisplay.setCurrent(this);

   myGame.start();

  }

  protected void paint(Graphics g) {

   int width = getWidth();
    int height = getHeight();
    g.setColor(WHITE);



    g.fillRect(0, 0, width, height);


    if(myIsWaiting) {


     Font font = g.getFont();
   int fontHeight = font.getHeight();

      int fontWidth = font.stringWidth("waiting for another player");
      g.setColor(WHITE);

     g.fillRect((width - fontWidth)/2, (height - fontHeight)/2,

           fontWidth + 2, fontHeight);


      g.setColor(BLACK);
     g.setFont(font);

     g.drawString("waiting for another player", (width - fontWidth)/2, 

       (height - fontHeight)/2,

       g.TOP|g.LEFT);

     return;


   }



    byte offset = 0;





    for(byte i = 0; i < 4; i++) {





      for(byte j = 0; j < 8; j++) {



 if(j % 2 != 0) {





    offset = 1;





  } else {





    offset = 0;





  }



  if(myGame.isSelected(i, j)) {

    g.setColor(LT_GREY);
    g.fillRect((2*i + offset)*mySquareSize, j*mySquareSize, 

     mySquareSize, mySquareSize);

  } else {

       g.setColor(GREY);


    g.fillRect((2*i + offset)*mySquareSize, j*mySquareSize, 


         mySquareSize, mySquareSize);

 }



  g.setColor(RED);

  int piece = myGame.getPiece(i, j);

  int circleOffset = 2;
  int circleSize = mySquareSize - 2*circleOffset;

  if(piece < 0) {

    g.setColor(BLACK);



    g.fillRoundRect((2*i + offset)*mySquareSize + circleOffset, 





        j*mySquareSize + circleOffset, 





       circleSize, circleSize, circleSize, circleSize);





    // if the player is a king, draw a crown on:





    if(piece < -1) {





      g.drawImage(myWhiteCrown, 





          (2*i + offset)*mySquareSize + mySquareSize/2, 





          j*mySquareSize + 1 + mySquareSize/2, 





          Graphics.VCENTER|Graphics.HCENTER);





    }





  } else if(piece > 0) {





    // color the piece in red





    g.fillRoundRect((2*i + offset)*mySquareSize + circleOffset, 





        j*mySquareSize + circleOffset, 





       circleSize, circleSize, circleSize, circleSize);





    // if the player is a king, draw a crown on:





    if(piece > 1) {





      g.drawImage(myBlackCrown, 





          (2*i + offset)*mySquareSize + mySquareSize/2, 





          j*mySquareSize + 1 + mySquareSize/2, 





          Graphics.VCENTER|Graphics.HCENTER);





    }





  }





      }





    }





    // now the blank squares:





    // actually, this part is probably not necessary...





    g.setColor(WHITE);





    for(int i = 0; i < 4; i++) {





      for(int j = 0; j < 8; j++) {





  if(j % 2 == 0) {





    offset = 1;





  } else {





    offset = 0;





  }





  g.fillRect((2*i + offset)*mySquareSize, j*mySquareSize, 





       mySquareSize, mySquareSize);





      }





    }





    // if the player has reached the end of the game, 





    // we display the end message.





    if(myGame.getGameOver()) {





      // perform some calculations to place the text correctly:





      Font font = g.getFont();





      int fontHeight = font.getHeight();





      int fontWidth = font.stringWidth("Game Over");





      g.setColor(WHITE);





      g.fillRect((width - fontWidth)/2, (height - fontHeight)/2,





           fontWidth + 2, fontHeight);





      // write in black





      g.setColor(BLACK);





      g.setFont(font);





      g.drawString("Game Over", (width - fontWidth)/2, 





       (height - fontHeight)/2,





       g.TOP|g.LEFT);





    }





  }











  //-------------------------------------------------------





  //  handle keystrokes











  /**





   * Move the player.





   */





  public void keyPressed(int keyCode) {  





    if(myGame.isMyTurn()) {





      int action = getGameAction(keyCode);   





      switch (action) {





      case LEFT:





  myGame.leftPressed();





  break;





      case RIGHT:





  myGame.rightPressed();





  break;





      case UP:





  myGame.upPressed();





  break;





      case DOWN:





  myGame.deselect();





  break;





      }





      repaint();





      serviceRepaints();





    }





  }











}











/**





 * This class contacts a remote server in order to 





 * play a game of checkers against an opponent..





 *





 * @author Carol Hamer





 */





class Communicator extends Thread {











  //--------------------------------------------------------





  //  static fields











  /**





   * This is the URL to contact.





   * IMPORTANT: before compiling, the following URL





   * must be changed to the correct URL of the 





   * machine running the server code.





   */





  public static final String SERVER_URL 





    = "socket://malbec:8007";











  /**





   * The int to signal that the game is to begin.





   */





  public static final byte START_GAME_FLAG = -4;











  /**





   * The byte to signal that the game is to end.





   */





  public static final byte END_GAME_FLAG = -3;











  /**





   * The byte to signal the end of a turn.





   */





  public static final byte END_TURN_FLAG = -2;











  //--------------------------------------------------------





  //  game instance fields











  /**





   * The MIDlet subclass, used to set the Display 





   * in the case where an error message needs to be sent..





   */





  private Checkers myCheckers;











  /**





   * The Canvas subclass, used to set the Display 





   * in the case where an error message needs to be sent..





   */





  private CheckersCanvas myCanvas;











  /**





   * The game logic class that we send the opponent's 





   * moves to..





   */





  private CheckersGame myGame;











  /**





   * Whether or not the MIDlet class has requested the 





   * game to end.





   */





  private boolean myShouldStop;











  //--------------------------------------------------------





  //  data exchange instance fields











  /**





   * The data from the local player that is to 





   * be sent to the opponent.





   */





  private byte[] myMove;











  /**





   * Whether or not the current turn is done and 





   * should be sent.





   */





  private boolean myTurnIsDone = true;











  //--------------------------------------------------------





  //  initialization











  /**





   * Constructor is used only when the program wants 





   * to spawn a data-fetching thread, not for merely 





   * reading local data with static methods.





   */





  Communicator(Checkers checkers, CheckersCanvas canvas, 





         CheckersGame game) {





    myCheckers = checkers;





    myCanvas = canvas;





    myGame = game;





  }











  //--------------------------------------------------------





  //  methods called by CheckersGame to send move





  //    information to the opponent.











  /**





   * Stop the game entirely.  Notify the servlet that 





   * the user is exiting the game.





   */





  synchronized void endGame() {





    myShouldStop = true;





    if(myGame != null) {





      myGame.setGameOver();





    }





    notify();





  }











  /**





   * This is called when the player moves a piece.





   */





  synchronized void move(byte sourceX, byte sourceY, byte destinationX, 





        byte destinationY) {





    myMove = new byte[4];





    myMove[0] = sourceX;





    myMove[1] = sourceY;





    myMove[2] = destinationX;





    myMove[3] = destinationY;





    myTurnIsDone = false;





    notify();





  }











  /**





   * This is called when the local player's turn is over.





   */





  synchronized void endTurn() {





    myTurnIsDone = true;





    notify();





  }











  //--------------------------------------------------------





  //  main communication method











  /**





   * Makes a connection to the server and sends and receives





   * information about moves.





   */





  public void run() {





    DataInputStream dis = null;





    DataOutputStream dos = null;





    SocketConnection conn = null;





    byte[] fourBytes = new byte[4];





    try {





      // tell the user that we're waiting for the other player to join:





      myCanvas.setWaitScreen(true);





      myCanvas.repaint();





      myCanvas.serviceRepaints();





      // now make the connection:





      conn = (SocketConnection)Connector.open(SERVER_URL);





      conn.setSocketOption(SocketConnection.KEEPALIVE, 1);





      dos = conn.openDataOutputStream();





      dis = conn.openDataInputStream();





      // we read four bytes to make sure the connection works...





      dis.readFully(fourBytes);





      if(fourBytes[0] != START_GAME_FLAG) {





  throw(new Exception("server-side error"));





      }





      // On this line it will block waiting for another 





      // player to join the game or make a move:





      dis.readFully(fourBytes);





      // if the server sends the start game flag again, 





      // that means that we start with the local player's turn.





      // Otherwise, we read the other player's first move from the 





      // stream:





      if(fourBytes[0] != START_GAME_FLAG) {





  // verify that the other player sent a move 





  // and not just a message ending the game...





  if(fourBytes[0] == END_GAME_FLAG) {





    throw(new Exception("other player quit"));





  }





  // we move the opponent on the local screen.





  // then we read from the opponent again, 





  // in case there's a double-jump:





  while(fourBytes[0] != END_TURN_FLAG) {





    myGame.moveOpponent(fourBytes);





    dis.readFully(fourBytes);





  }





      }





      // now signal the local game that the opponent is done





      // so the board must be updated and the local player 





      // prompted to make a move:





      myGame.endOpponentTurn();





      myCanvas.setWaitScreen(false);





      myCanvas.repaint();





      myCanvas.serviceRepaints();





      // begin main game loop:





      while(! myShouldStop) {





  // now it's the local player's turn.





  // wait for the player to move a piece:





  synchronized(this) {





    wait();





  }





  // after every wait, we check if the game 





  // ended while we were waiting...





  if(myShouldStop) {





    break;





  }





  while(! myTurnIsDone) {





    // send the current move:





    if(myMove != null) {





      dos.write(myMove, 0, myMove.length);





      myMove = null;





    }





    // If the player can continue the move with a double 





    // jump, we wait for the player to do it:





    synchronized(this) {





      // make sure the turn isn't done before we start waiting





      // (the end turn notify might accidentally be called 





      // before we start waiting...)





      if(! myTurnIsDone) {





        wait();





      } 





    }





  }





  // after every wait, we check if the game 





  // ended while we were waiting...





  if(myShouldStop) {





    break;





  }





  // now we tell the other player the this player's 





  // turn is over:





  fourBytes[0] = END_TURN_FLAG;





  dos.write(fourBytes, 0, fourBytes.length);





  // now that we've sent the move, we wait for a response:





  dis.readFully(fourBytes);





  while((fourBytes[0] != END_TURN_FLAG) && 





        (fourBytes[0] != END_GAME_FLAG) && (!myShouldStop)) {





    // we move the opponent on the local screen.





    // then we read from the opponent again, 





    // in case there's a double-jump:





    myGame.moveOpponent(fourBytes);





    dis.readFully(fourBytes);





  }





  // if the other player has left the game, we tell the 





  // local user that the game is over.





  if((fourBytes[0] == END_GAME_FLAG) || (myShouldStop)) {





    endGame();





    break;





  }





  myGame.endOpponentTurn();





  myCanvas.repaint();





  myCanvas.serviceRepaints();





      } // end while loop





    } catch(Exception e) {





      // if there's an error, we display its messsage and 





      // end the game.





      myCheckers.errorMsg(e.getMessage());





    } finally {





      // now we send the information that we're leaving the game,





      // then close up and delete everything.





      try {





  if(dos != null) {





    dos.write(END_GAME_FLAG);





    dos.close();





  }





  if(dis != null) {





    dis.close();





  }





  if(conn != null) {





    conn.close();





  }





  dis = null;





  dos = null;





  conn = null;





      } catch(Exception e) {





  // if this throws, at least we made our best effort 





  // to close everything up....





      }





    }





    // one last paint job to display the "Game Over"





    myCanvas.repaint();





    myCanvas.serviceRepaints();





  }





    





}

















/**





 * This class is a set of simple utility functions that 





 * can be used to convert standard data types to bytes 





 * and back again.  It is used especially for data storage, 





 * but also for sending and receiving data.





 * 





 * @author Carol Hamer





 */





class DataConverter {











  //--------------------------------------------------------





  //  utilities to encode small, compactly-stored small ints.











  /**





   * Encodes a coordinate pair into a byte.





   * @param coordPair a pair of integers to be compacted into





   * a single byte for storage.





   * WARNING: each of the two values MUST BE 





   * between 0 and 15 (inclusive).  This method does not 





   * verify the length of the array (which must be 2!) 





   * nor does it verify that the ints are of the right size.





   */





  public static byte encodeCoords(int[] coordPair) {





    // get the byte value of the first coordinate:





    byte retVal = (new Integer(coordPair[0])).byteValue();





    // move the first coordinate's value up to the top 





    // half of the storage byte:





    retVal = (new Integer(retVal << 4)).byteValue();





    // store the second coordinate in the lower half





    // of the byte:





    retVal += (new Integer(coordPair[1])).byteValue();





    return(retVal);





  }











  /**





   * Encodes eight ints into a byte.





   * This could be easily modified to encode eight booleans.





   * @param eight an array of at least eight ints.





   * WARNING: all values must be 0 or 1!  This method does 





   * not verify that the values are in the correct range 





   * nor does it verify that the array is long enough.





   * @param offset the index in the array eight to start





   * reading data from.  (should usually be 0)





   */





  public static byte encode8(int[] eight, int offset) {





    // get the byte value of the first int:





    byte retVal = (new Integer(eight[offset])).byteValue();





    // progressively move the data up one bit in the 





    // storage byte and then record the next int in





    // the lowest spot in the storage byte:





    for(int i = offset + 1; i < 8 + offset; i++) {





      retVal = (new Integer(retVal << 1)).byteValue();





      retVal += (new Integer(eight[i])).byteValue();





    }





    return(retVal);





  }











  //--------------------------------------------------------





  //  utilities to decode small, compactly-stored small ints.











  /**





   * Turns a byte into a pair of coordinates.





   */





  public static int[] decodeCoords(byte coordByte) {





    int[] retArray = new int[2];





    // we perform a bitwise and with the value 15 





    // in order to just get the bits of the lower





    // half of the byte:





    retArray[1] = coordByte & 15;





    // To get the bits of the upper half of the 





    // byte, we perform a shift to move them down:





    retArray[0] = coordByte >> 4;





    // bytes in Java are generally assumed to be 





    // signed, but in this coding algorithm we 





    // would like to treat them as unsigned: 





    if(retArray[0] < 0) {





      retArray[0] += 16;





    }





    return(retArray);





  }











  /**





   * Turns a byte into eight ints.





   */





  public static int[] decode8(byte data) {





    int[] retArray = new int[8];





    // The flag allows us to look at each bit individually





    // to determine if it is 1 or 0.  The number 128 





    // corresponds to the highest bit of a byte, so we 





    // start with that one.





    int flag = 128;





    // We use a loop that checks 





    // the data bit by bit by performing a bitwise 





    // and (&) between the data byte and a flag:





    for(int i = 0; i < 8; i++) {





      if((flag & data) != 0) {





  retArray[i] = 1;





      } else {





  retArray[i] = 0;





      }





      // move the flag down one bit so that we can 





      // check the next bit of data on the next pass





      // through the loop:





      flag = flag >> 1;





    }





    return(retArray);





  }

















  //--------------------------------------------------------





  //  standard integer interpretation











  /**





   * Uses an input stream to convert an array of bytes to an int.





   */





  public static int parseInt(byte[] data) throws IOException {





    DataInputStream stream 





      = new DataInputStream(new ByteArrayInputStream(data));





    int retVal = stream.readInt();





    stream.close();





    return(retVal);





  }











  /**





   * Uses an output stream to convert an int to four bytes.





   */





  public static byte[] intToFourBytes(int i) throws IOException {





    ByteArrayOutputStream baos = new ByteArrayOutputStream(4);





    DataOutputStream dos = new DataOutputStream(baos);





    dos.writeInt(i);





    baos.close();





    dos.close();





    byte[] retArray = baos.toByteArray();





    return(retArray);





  }











  //--------------------------------------------------------





  //  integer interpretation illustrated











  /**





   * Java appears to treat a byte as being signed when





   * returning it as an int--this function converts from





   * the signed value to the corresponding unsigned value.





   * This method is used by nostreamParseInt.





   */





  public static int unsign(int signed) {





    int retVal = signed;





    if(retVal < 0) {





      retVal += 256;





    }





    return(retVal);





  }











  /**





   * Takes an array of bytes and returns an int.





   * This version will return the same value as the 





   * method parseInt above.  This version is included 





   * in order to illustrate how Java encodes int values





   * in terms of bytes.





   * @param data an array of 1, 2, or 4 bytes.





   */





  public static int nostreamParseInt(byte[] data) {





    // byte 0 is the high byte which is assumed 





    // to be signed.  As we add the lower bytes 





    // one by one, we unsign them because because 





    // a single byte alone is interpreted as signed, 





    // but in an int only the top byte should be signed.





    // (note that the high byte is the first one in the array)





    int retVal = data[0];





    for(int i = 1; i < data.length; i++) {





      retVal = retVal << 8;





      retVal += unsign(data[i]);





    }





    return(retVal);





  }











  /**





   * Takes an arbitrary int and returns





   * an array of four bytes.





   * This version will return the same byte array 





   * as the method intToFourBytes above.  This version 





   * is included in order to illustrate how Java encodes 





   * int values in terms of bytes.





   */





  public static byte[] nostreamIntToFourBytes(int i) {





    byte[] fourBytes = new byte[4];





    // when you take the byte value of an int, it





    // only gives you the lowest byte.  So we 





    // get all four bytes by taking the lowest 





    // byte four times and moving the whole int 





    // down by one byte between each one.





    // (note that the high byte is the first one in the array)





    fourBytes[3] = (new Integer(i)).byteValue();





    i = i >> 8;





    fourBytes[2] = (new Integer(i)).byteValue();





    i = i >> 8;





    fourBytes[1] = (new Integer(i)).byteValue();





    i = i >> 8;





    fourBytes[0] = (new Integer(i)).byteValue();





    return(fourBytes);





  }

















  /**





   * Takes an int between -32768 and 32767 and returns





   * an array of two bytes.  This does not verify that 





   * the argument is of the right size.  If the absolute





   * value of i is too high, it will not be encoded 





   * correctly.





   */





  public static byte[] nostreamIntToTwoBytes(int i) {





    byte[] twoBytes = new byte[2];





    // when you take the byte value of an int, it





    // only gives you the lowest byte.  So we 





    // get the lower two bytes by taking the lowest 





    // byte twice and moving the whole int 





    // down by one byte between each one.





    twoBytes[1] = (new Integer(i)).byteValue();





    i = i >> 8;





    twoBytes[0] = (new Integer(i)).byteValue();





    return(twoBytes);





  }











}























/**





 * This class takes care of the underlying logic and data of 





 * the checkers game being played.  That includes where 





 * all of the pieces are on the board and where it is okay 





 * for them to move to.  





 *





 * @author Carol Hamer





 */





class CheckersGame {











  //-------------------------------------------------------





  //   static fields











  /**





   * The length of the checkerboard in the x-direction.





   */





  public static final byte X_LENGTH = 4;











  /**





   * The length of the checkerboard in the y-direction.





   */





  public static final byte Y_LENGTH = 8;











  //-------------------------------------------------------





  //   instance fields











  /**





   * a handle to the communications class that exchanges





   * data with the server.





   */





  private Communicator myCommunicator;











  /**





   * This array represents the black squares of the 





   * checkerboard.  The two dimensions of the array 





   * represent the two dimensions of the checkerboard.





   * The value represents what type of piece is on 





   * the square.





   * 0 = empty





   * 1 = local player's piece





   * 2 = local player's king





   * -1 = remote player's piece





   * -2 = remote player's king





   */





  private byte[][] myGrid;











  /**





   * If the user has currently selected a piece to move, 





   * this is its X grid coordinate. (-1 if none selected)





   */





  private byte mySelectedX = -1;











  /**





   * If the user has currently selected a piece to move, 





   * this is its Y grid coordinate.(-1 if none selected)





   */





  private byte mySelectedY = -1;











  /**





   * If the user has currently selected a possible 





   * destination square for a move, this is its X coordinate..





   * (-1 if none selected)





   */





  private byte myDestinationX = -1;











  /**





   * If the user has currently selected a possible 





   * destination square for a move, this is its Y coordinate..





   * (-1 if none selected)





   */





  private byte myDestinationY = -1;











  /**





   * This Vector contains the coordinates of all of the 





   * squares that the player could currently move to.





   */





  private Vector myPossibleMoves = new Vector(4);











  /**





   * Whether or not the currently displayed checkers has 





   * been completed.





   */





  private boolean myGameOver = false;











  /**





   * Whether or not it is currently this player's turn.





   */





  private boolean myTurn = false;











  /**





   * This is true if the player has just jumped and can 





   * jump again.





   */





  private boolean myIsJumping = false;











  //-------------------------------------------------------





  //   get/set data





  





  /**





   * get the piece on the given grid square.





   */





  byte getPiece(byte x, byte y) {





    return(myGrid[x][y]);





  }











  /**





   * This is callsed by CheckersCanvas to determine if 





   * the square is currently selected (as containing 





   * a piece to move or a destination square).





   */





  boolean isSelected(byte x, byte y) {





    boolean retVal = false;





    if((x == mySelectedX) && (y == mySelectedY)) {





      retVal = true;





    } else if((x == myDestinationX) && (y == myDestinationY)) {





      retVal = true;





    }





    return(retVal);





  }











  /**





   * This tells whether or not the keystrokes should currently





   * be taken into account.





   */





  boolean isMyTurn() {





    boolean retVal = false;





    if((!myGameOver) && ((myTurn) || (myIsJumping))) {





      retVal = true;





    }





    return(retVal);





  }











  /**





   * This tells whether or not the game has ended.





   */





  boolean getGameOver() {





    boolean retVal = false;





    if(myGameOver) {





      retVal = true;





    }





    return(retVal);





  }











  /**





   * tell the CheckersGame that the other player has ended the game.





   */





  void setGameOver() {





    myGameOver = true;





  }











  /**





   * set the communicator object.





   */





  void setCommunicator(Communicator comm) {





    myCommunicator = comm;





  }











  //-------------------------------------------------------





  //   initialization











  /**





   * Constructor puts the pieces in their initial positions:





   */





  CheckersGame() {





    myGrid = new byte[X_LENGTH][];





    for(byte i = 0; i < myGrid.length; i++) {





      myGrid[i] = new byte[Y_LENGTH];





      for(byte j = 0; j < myGrid[i].length; j++) {





  if(j < 3) {





    // fill the top of the board with remote players





    myGrid[i][j] = -1;





  } else if(j > 4) {





    // fill the bottom of the board with local players





    myGrid[i][j] = 1;





  }





      }





    }





  }











  /**





   * This is called just before the player makes the 





   * first move.





   */





  void start() {





    mySelectedX = 0;





    mySelectedY = 5;





    myTurn = true;





    getMoves(mySelectedX, mySelectedY, myPossibleMoves, false);





  }











  //-------------------------------------------------------





  //   move the opponent





  // to be called by Communicator











  /**





   * This is called when the opponent wants to move





   * its piece.





   * @param moveData an array of four bytes:





   * moveData[0] = opponent's initial X coordinate





   * moveData[1] = opponent's initial Y coordinate





   * moveData[2] = opponent's destination X coordinate





   * moveData[3] = opponent's destination Y coordinate





   */





  void moveOpponent(byte[] moveData) {





    // since both players appear on their own screens 





    // as the red side (bottom of the screen), we need 





    // to invert the opponent's move:





    moveData[0] = (new Integer(X_LENGTH - moveData[0] - 1)).byteValue();





    moveData[2] = (new Integer(X_LENGTH - moveData[2] - 1)).byteValue();





    moveData[1] = (new Integer(Y_LENGTH - moveData[1] - 1)).byteValue();





    moveData[3] = (new Integer(Y_LENGTH - moveData[3] - 1)).byteValue();





    myGrid[moveData[2]][moveData[3]] 





      = myGrid[moveData[0]][moveData[1]];





    myGrid[moveData[0]][moveData[1]] = 0;





    // deal with an opponent's jump:





    if((moveData[1] - moveData[3] > 1) || 





       (moveData[3] - moveData[1] > 1)) {





      int jumpedY = (moveData[1] + moveData[3])/2;





      int jumpedX = moveData[0];





      int parity = moveData[1] % 2;





      if((parity > 0) && (moveData[2] > moveData[0])) {





  jumpedX++;





      } else if((parity == 0) && (moveData[0] > moveData[2])) {





  jumpedX--;





      }





      myGrid[jumpedX][jumpedY] = 0;





    }





    // if the opponent reaches the far side, 





    // make him a king:





    if(moveData[3] == Y_LENGTH - 1) {





      myGrid[moveData[2]][moveData[3]] = -2;





    }





  }











  /**





   * This is called when the opponent's turn is over.





   * Note that the turn doesn't automatically end after 





   * the opponent moves because the opponent may make 





   * a double or triple jump.





   */





  void endOpponentTurn() {





    myTurn = true;





    // Now begin the local player's turn: 





    // First select the first local piece that can be 





    // moved. (rightPressed will select an appropriate 





    // piece or end the game if the local player has 





    // no possible moves to make)





    mySelectedX = 0;





    mySelectedY = 0;





    myDestinationX = -1;





    myDestinationY = -1;





    rightPressed();





    // the local player's thread has been waiting 





    // for the opponent's turn to end.  





    synchronized(this) {





      notify();





    }





  }











  //-------------------------------------------------------





  //   handle keystrokes





  // to be called by CheckersCanvas











  /**





   * if the left button is pressed, this method takes 





   * the correct course of action depending on the situation.





   */





  void leftPressed() {





    // in the first case the user has not yet selected a 





    // piece to move:





    if(myDestinationX == -1) {





      // find the next possible piece (to the left) 





      // that can move:





      selectPrevious();





      // if selectPrevious fails to fill myPossibleMoves, that 





      // means that the local player cannot move, so the game





      // is over:





      if(myPossibleMoves.size() == 0) {





  myCommunicator.endGame();





      }





    } else {





      // if the user has already selected a piece to move, 





      // we give the options of where the piece can move to:





      for(byte i = 0; i < myPossibleMoves.size(); i++) {





  byte[] coordinates = (byte[])myPossibleMoves.elementAt(i);





  if((coordinates[0] == myDestinationX) && 





     (coordinates[1] == myDestinationY)) {





    i++;





    i = (new Integer(i % myPossibleMoves.size())).byteValue();





    coordinates = (byte[])myPossibleMoves.elementAt(i);





    myDestinationX = coordinates[0];





    myDestinationY = coordinates[1];





    break;





  }





      }





    }





  }











  /**





   * if the left button is pressed, this method takes 





   * the correct course of action depending on the situation.





   */





  void rightPressed() {





    // in the first case the user has not yet selected a 





    // piece to move:





    if(myDestinationX == -1) {





      // find the next possible piece that can 





      // move:





      selectNext();





      // if selectNext fails to fill myPossibleMoves, that 





      // means that the local player cannot move, so the game





      // is over:





      if(myPossibleMoves.size() == 0) {





  myCommunicator.endGame();





      }





    } else {





      // if the user has already selected a piece to move, 





      // we give the options of where the piece can move to:





      for(byte i = 0; i < myPossibleMoves.size(); i++) {





  byte[] coordinates = (byte[])myPossibleMoves.elementAt(i);





  if((coordinates[0] == myDestinationX) && 





     (coordinates[1] == myDestinationY)) {





    i++;





    i = (new Integer(i % myPossibleMoves.size())).byteValue();





    coordinates = (byte[])myPossibleMoves.elementAt(i);





    myDestinationX = coordinates[0];





    myDestinationY = coordinates[1];





    break;





  }





      }





    }





  }











  /**





   * If no piece is selected, we select one.  If a piece 





   * is selected, we move it.





   */





  void upPressed() {





    // in the first case the user has not yet selected a 





    // piece to move:





    if(myDestinationX == -1) {





      fixSelection();





    } else {





      // if the source square and destination square 





      // have been chosen, we move the piece:





      move();





    }





  }











  /**





   * If the user decided not to move the selected piece 





   * (and instead wants to select again), this undoes 





   * the selection. This corresponds to pressing the 





   * DOWN key.





   */





  void deselect() {





    // if the player has just completed a jump and 





    // could possibly jump again but decides not to 





    // (i.e. deselects), then the turn ends:





    if(myIsJumping) {





      mySelectedX = -1;





      mySelectedY = -1;





      myDestinationX = -1;





      myDestinationY = -1;





      myIsJumping = false;





      myTurn = false;





      myCommunicator.endTurn();





    } else {





      // setting the destination coordinates to -1 





      // is the signal that the the choice of which 





      // piece to move can be modified:





      myDestinationX = -1;





      myDestinationY = -1;





    }





  }











  //-------------------------------------------------------





  //   internal square selection methods











  /**





   * When the player has decided that the currently selected





   * square contains the piece he really wants to move, this 





   * is called. This method switches to the mode where 





   * the player selects the destination square of the move.





   */





  private void fixSelection() {





    byte[] destination = (byte[])myPossibleMoves.elementAt(0);





    // setting the destination coordinates to valid 





    // coordinates is the signal that the user is done 





    // selecting the piece to move and now is choosing 





    // the destination square:





    myDestinationX = destination[0];





    myDestinationY = destination[1];





  }











  /**





   * This method starts from the currently selected square 





   * and finds the next square that contains a piece that 





   * the player can move.





   */





  private void selectNext() {





    // Test the squares one by one (starting from the 





    // currently selected square) until we find a square 





    // that contains one of the local player's pieces 





    // that can move:





    byte testX = mySelectedX;





    byte testY = mySelectedY;





    while(true) {





      testX++;





      if(testX >= X_LENGTH) {





  testX = 0;





  testY++;





  testY = (new Integer(testY % Y_LENGTH)).byteValue();





      }





      getMoves(testX, testY, myPossibleMoves, false);





      if((myPossibleMoves.size() != 0) || 





     ((testX == mySelectedX) && (testY == mySelectedY))) {





  mySelectedX = testX;





  mySelectedY = testY;





  break;





      }





    }





  }











  /**





   * This method starts from the currently selected square 





   * and finds the next square (to the left) that contains 





   * a piece that the player can move.





   */





  private void selectPrevious() {





    // Test the squares one by one (starting from the 





    // currently selected square) until we find a square 





    // that contains one of the local player's pieces 





    // that can move:





    byte testX = mySelectedX;





    byte testY = mySelectedY;





    while(true) {





      testX--;





      if(testX < 0) {





  testX += X_LENGTH;





  testY--;





  if(testY < 0) {





    testY += Y_LENGTH;





  }





      }





      getMoves(testX, testY, myPossibleMoves, false);





      if((myPossibleMoves.size() != 0) || 





   ((testX == mySelectedX) && (testY == mySelectedY))) {





  mySelectedX = testX;





  mySelectedY = testY;





  break;





      }





    }





  }











  //-------------------------------------------------------





  //   internal utilities











  /**





   * Once the user has selected the move to make, this 





   * updates the data accordingly.





   */





  private void move() {





    // the piece that was on the source square is 





    // now on the destination square:





    myGrid[myDestinationX][myDestinationY] 





      = myGrid[mySelectedX][mySelectedY];





    // the source square is emptied:





    myGrid[mySelectedX][mySelectedY] = 0;





    if(myDestinationY == 0) {





      myGrid[myDestinationX][myDestinationY] = 2;





    }





    // tell the communicator to inform the other player 





    // of this move:





    myCommunicator.move(mySelectedX, mySelectedY, 





      myDestinationX, myDestinationY);





    // deal with the special rules for jumps::





    if((mySelectedY - myDestinationY > 1) || 





       (myDestinationY - mySelectedY > 1)) {





      int jumpedY = (mySelectedY + myDestinationY)/2;





      int jumpedX = mySelectedX;





      int parity = mySelectedY % 2;





      // the coordinates of the jumped square depend on 





      // what row we're in:





      if((parity > 0) && (myDestinationX > mySelectedX)) {





          jumpedX++;





      } else if((parity == 0) && (mySelectedX > myDestinationX)) {





          jumpedX--;





      }





      // remove the piece that was jumped over:





      myGrid[jumpedX][jumpedY] = 0;






      mySelectedX = myDestinationX;


      mySelectedY = myDestinationY;


      myDestinationX = -1;
      myDestinationY = -1;



عدل سابقا من قبل أحمد مناع في الأربعاء فبراير 05, 2014 9:24 am عدل 1 مرات (السبب : للتنسيق)
أيمن الإبراهيم
أيمن الإبراهيم
........
........

تاريخ التسجيل : 19/03/2013
المساهمات : 251
النقاط : 397
التقيم : 0
الدولة : سوريا
الجنس : ذكر

الرجوع الى أعلى الصفحة اذهب الى الأسفل

الرجوع الى أعلى الصفحة

ََ

مواضيع ذات صلة


 
صلاحيات هذا المنتدى:
لاتستطيع الرد على المواضيع في هذا المنتدى