www.pudn.com > Bluegammon蓝牙的应用编程.rar > GameRecord.java

// Copyright (c) 2005 Sony Ericsson Mobile Communications AB 
// 
// This software is provided "AS IS," without a warranty of any kind.  
// ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,  
// INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A  
// PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.  
// 
// THIS SOFTWARE IS COMPLEMENTARY OF JAYWAY AB (www.jayway.se) 
 
package bluegammon.logic; 
 
import java.util.Date; 
import java.util.Vector; 
 
import bluegammon.Bluegammon; 
import bluegammon.RmsFacade; 
 
/** 
 * 
 
 * A game record represents one or multiple games between an opponent, keeping 
 * track of scores and such. GameRecords are stored in the RMS. 
 * 
 
 * The static interface of this class provides a hash table like functionality 
 * and also contains logic for keeping the limit of maximum allowed game 
 * records. 
 * 
 
 * @author Peter Andersson 
 */ 
public class GameRecord 
{ 
  /** Id of the opponent belonging to this game record */ 
  protected int m_opponentId; 
  /** Name of the opponent belonging to this game record */ 
  protected char[] m_opponentName; 
  /** Number of games played against opponent belonging to this game record */ 
  protected int m_gameCount; 
  /** Total score in all games played against opponent belonging to this game record */ 
  protected int m_playerScore; 
  /** Total opponent score in all games played against opponent belonging to this game record */ 
  protected int m_opponentScore; 
  /** Timestamp for latest change in this game record */ 
  protected long m_timestamp; 
   
  /** Game record index in RmsFacade */ 
  protected int m_gameRecordIndex; 
   
  /** 
   * Returns the time of the latest change to this record. 
   * @return	The timestamp. 
   */ 
  public long getTimestamp() 
  { 
    return m_timestamp; 
  } 
   
  /** 
   * Returns the id of the opponent represented in this record. 
   * @return	The opponent id. 
   */ 
  public int getOpponentId() 
  { 
    return m_opponentId; 
  } 
   
  /** 
   * Returns the name of the opponent represented in this record. 
   * @return	The opponent name. 
   */ 
  public char[] getOpponentName() 
  { 
    return m_opponentName; 
  } 
   
  /** 
   * Returns the score of the opponent represented in this record. 
   * @return	The opponent score. 
   */ 
  public int getOpponentScore() 
  { 
    return m_opponentScore; 
  } 
   
  /** 
   * Returns the score of the player represented in this record. 
   * @return	The player score. 
   */ 
  public int getPlayerScore() 
  { 
    return m_playerScore; 
  } 
   
  /** 
   * Returns number of games played agains opponent represented in this record. 
   * @return	Number of games against opponent. 
   */ 
  public int getGameCount() 
  { 
    return m_gameCount; 
  } 
   
  /** 
   * Returns the index in rms that this record occupies. 
   * @return	The rms index. 
   */ 
  public int getIndex() 
  { 
    return m_gameRecordIndex; 
  } 
   
  /** 
   * Updates this game record with data from a new game. 
   * @param localWinner	If this game was won by local player. 
   * @param score		The score. 
   */ 
  protected void registerGame(boolean localWinner, int score) 
  { 
    m_playerScore += localWinner ? score :0; 
    m_opponentScore += localWinner ? 0 : score; 
    m_gameCount++; 
  } 
 
  /** 
   * Sets the index of this game record. 
   * @param index	The index to set. 
   */ 
  protected void setIndex(int index) 
  { 
    m_gameRecordIndex = index; 
  } 
   
  /** 
   * Saves this game record to rms. 
   */ 
  protected void save() 
  { 
    m_timestamp = new Date().getTime(); 
    RmsFacade.setInt(Bluegammon.GAMEREC_OP_ID + m_gameRecordIndex, 
        m_opponentId); 
    RmsFacade.setChars(Bluegammon.GAMEREC_OP_NAME + m_gameRecordIndex, 
        m_opponentName); 
    RmsFacade.setInt(Bluegammon.GAMEREC_MY_SCORE + m_gameRecordIndex, 
        m_playerScore); 
    RmsFacade.setInt(Bluegammon.GAMEREC_OP_SCORE + m_gameRecordIndex, 
        m_opponentScore); 
    RmsFacade.setInt(Bluegammon.GAMEREC_GAME_COUNT + m_gameRecordIndex, 
        m_gameCount); 
    RmsFacade.setLong(Bluegammon.GAMEREC_TIMESTAMP + m_gameRecordIndex, 
        m_timestamp); 
  } 
 
  /** 
   * Creates a gamerecord from existing entry in rms. 
   * @param index	The index of the game record in rms. 
   */ 
  protected GameRecord(int index) 
  { 
    m_opponentId = RmsFacade.getInt(Bluegammon.GAMEREC_OP_ID + index); 
    m_opponentName = RmsFacade.getChars(Bluegammon.GAMEREC_OP_NAME + index); 
    m_playerScore = RmsFacade.getInt(Bluegammon.GAMEREC_MY_SCORE + index); 
    m_opponentScore = RmsFacade.getInt(Bluegammon.GAMEREC_OP_SCORE + index); 
    m_gameCount = RmsFacade.getInt(Bluegammon.GAMEREC_GAME_COUNT + index); 
    m_timestamp = RmsFacade.getLong(Bluegammon.GAMEREC_TIMESTAMP + index); 
    m_gameRecordIndex = index; 
  } 
 
  /** 
   * Creates a new game record to be added to rms. 
   * @param opponent	The opponent player. 
   */ 
  protected GameRecord(Player opponent) 
  { 
    m_opponentId = opponent.getId(); 
    m_opponentName = opponent.getName(); 
    m_playerScore = 0; 
    m_opponentScore = 0; 
    m_gameCount = 0; 
  } 
 
  // Static methods 
   
  /** 
   * Returns the data of a saved game. 
   * @param id	The opponent id. 
   * @return	The saved game data or null if there is no 
   * 			saved game data for an opponent with specified 
   * 			id. 
   */ 
  public static byte[] getSavedGame(int id) 
  { 
    byte[] data = null; 
    int index = getIndexForOpponentId(id); 
    if (index >= 0) 
    { 
      data = RmsFacade.get(Bluegammon.GAMEREC_SAVED_GAME_DATA + index); 
    } 
    return data; 
  } 
   
  /** 
   * Saves the state of an ongoing game against specified opponents. 
   * @param opponent	The opponent player. 
   * @param savedGame	The saved game data. 
   */ 
  public static void saveGame(Player opponent, byte[] savedGame) 
  { 
    GameRecord rec = getRecordForce(opponent); 
    RmsFacade.set(Bluegammon.GAMEREC_SAVED_GAME_DATA + rec.getIndex(), savedGame); 
    rec.save(); 
  } 
   
  /** 
   * Returns number of records saved in the rms. 
   * @return	Number of stored game records. 
   */ 
  public static int countRecords() 
  { 
    int res = 0; 
    for (int index = 0; index < Bluegammon.GAMERECORDS_SIZE; index++) 
    { 
      int id = RmsFacade.getInt(Bluegammon.GAMEREC_OP_ID + index); 
      if (id != 0) res++; 
    } 
    return res; 
  } 
   
  /** 
   * Returns a vector of GameRecords, containing 
   * all stored game records. 
   * @return All stored game records. 
   */ 
  public static Vector getAllRecords() 
  { 
    Vector res = new Vector(); 
    for (int index = 0; index < Bluegammon.GAMERECORDS_SIZE; index++) 
    { 
      int id = RmsFacade.getInt(Bluegammon.GAMEREC_OP_ID + index); 
      if (id != 0) 
      { 
        GameRecord record = new GameRecord(index); 
        res.addElement(record); 
      } 
    } 
    return res; 
  } 
   
  /** 
   * Returns record for a specific opponent. If the player has 
   * not played against this opponent before, null is returned. 
   * @param opponent	The opponent. 
   * @return	The GameRecord for this opponent, or null 
   * 			if it does not exist. 
   */ 
  public static GameRecord getRecord(Player opponent) 
  { 
    int refId = opponent.getId(); 
    int index = getIndexForOpponentId(refId);  
    return index >= 0 ? new GameRecord(index) : null; 
  } 
   
  /** 
   * Updates the game results with a new game.   
   * @param opponent	The opponent player. 
   * @param localWinner	If this game was won by local player. 
   * @param score		The score. 
   */ 
  public static void updateGameResult(Player opponent, boolean localWinner, int score) 
  { 
    GameRecord rec = getRecordForce(opponent); 
    rec.registerGame(localWinner, score); 
    rec.save(); 
  } 
   
  /** 
   * Returns a game record for specified opponent. If no such 
   * game record exists, it is created. 
   * @param opponent	The opponent player. 
   * @return A game record for opponent. Creates a record if needed. 
   */ 
  protected static GameRecord getRecordForce(Player opponent) 
  { 
    int index = 0; 
    GameRecord rec = getRecord(opponent); 
    if (rec == null) 
    { 
      // New game record 
      rec = new GameRecord(opponent); 
      int size = countRecords(); 
      Vector records = getAllRecords(); 
      if (size >= Bluegammon.GAMERECORDS_SIZE) 
      { 
        // The rms is full, need to remove an old game record 
        long minTime = Long.MAX_VALUE; 
        // Find oldest game record 
        for (int i = 0; i < size; i++) 
        { 
          long rTime = ((GameRecord)records.elementAt(i)).getTimestamp(); 
          if (minTime > rTime) 
          { 
            index = ((GameRecord)records.elementAt(i)).getIndex(); 
            minTime = rTime; 
          } 
        } 
      } 
      else 
      { 
        for (index = 0; index < Bluegammon.GAMERECORDS_SIZE; index++) 
        { 
          int id = RmsFacade.getInt(Bluegammon.GAMEREC_OP_ID + index); 
          if (id == 0) break; 
        } 
        System.out.println("                              got index " + index); 
      } 
    } 
    else 
    { 
      // Existing game record, update 
      index = rec.getIndex(); 
      System.out.println("                              existing record, index " + index); 
    } 
    rec.setIndex(index); 
    return rec; 
  } 
   
  /** 
   * Returns the RMS index for specified opponent id. 
   * @param refId	The opponent id. 
   * @return		The index, or -1 if opponent is not saved in RMS. 
   */ 
  protected static int getIndexForOpponentId(int refId) 
  { 
    int res = -1; 
    for (int index = 0; index < Bluegammon.GAMERECORDS_SIZE; index++) 
    { 
      int id = RmsFacade.getInt(Bluegammon.GAMEREC_OP_ID + index); 
      if (id == refId) 
      { 
        res = index; 
        break; 
      } 
    } 
    return res; 
  } 
}