liemanager.java

Vyger offers a D & D and Rogue-like environment in a graphical online roleplay game.

      LieMemory memory;
      memories.resetIterator();      
      while ( memories.hasNext() ) {
        memory = memories.next();
        memory.meetsNumber -= meetType;
        if (memory.meetsNumber<0)
          memories.remove();
      }
    }
  }
  
  /** To forget players we don't meet often
   *
   * @param meetType minium of meetsNumber to remember
   */
  public void forget(int meetType) {  
    if (ServerDirector.SHOW_DEBUG)
      System.out.println("LieManager::forget(meetType="+meetType+")");
    if (memories==null)
      return;
    synchronized(memories) {
      LieMemory memory;
      memories.resetIterator();      
      while ( memories.hasNext() ) {
        memory = memories.next();
        if (memory.meetsNumber < meetType) {
          memories.remove();
        } else {
          return;
        }
      }
    }    
  }

 /*------------------------------------------------------------------------------------*/

  /** To set a fake name
   *
   * @param index index of fake name
   * @param fakeName fake name ot set
   */
  public boolean setFakeName(short index, String fakeName) {
    if ( (index<0) || (index>FAKENAMES_NUMBER) )
      return false;
      
    if (fakeNames[index].length() == 0) {      
      fakeNames[index] = fakeName;
      return true;
    } else {
      return false;
    }
  }
  
  /** To set full player name
   */
  public boolean setFullPlayerName(String fakeName) {
    fakeNames[(short)0] = fakeName;
    return true;    
  }

  /** To create a new fake name
   * @param fakeName new fake name
   * @return index of new fake name
   */
  public short createFakeName(String fakeName) {    
    for (short i=0; i<FAKENAMES_NUMBER;) {
      if (fakeNames[i].length() == 0) {
        fakeNames[i] = fakeName;        
        return i;
      } else {
        i++;
      }
    }
    return -1;
  }
 
  /** To update last time we meet another player
   */
  public void setLastMeetPlayer(PlayerImpl otherPlayer) {
    if (ServerDirector.SHOW_DEBUG)
      System.out.println("LieManager::setLastMeetPlayer(otherPlayer="+otherPlayer+")");
    if (memories==null)
      return;
    String otherPlayerKey = otherPlayer.getPrimaryKey();
    synchronized(memories) {
      LieMemory memory;
      memories.resetIterator();      
      while ( memories.hasNext() ) {
        memory = memories.next();
        if (memory.otherPlayerKey.equals(otherPlayerKey)) {
          memory.lastMeetTime = System.currentTimeMillis();
          return;
        }
      }
    }
  }
  
  public String getLastMeetPlayer(PlayerImpl otherPlayer) {
    if (ServerDirector.SHOW_DEBUG)
      System.out.println("LieManager::getLastMeetPlayer(otherPlayer="+otherPlayer+")");
    if (memories==null)
      return "player never met\n";
    String otherPlayerKey = otherPlayer.getPrimaryKey();
    synchronized(memories) {
      LieMemory memory;
      memories.resetIterator();      
      while ( memories.hasNext() ) {
        memory = memories.next();
        if (memory.otherPlayerKey.equals(otherPlayerKey)) {      
          Calendar lastTime = Calendar.getInstance();
          lastTime.setTime(new Date(memory.lastMeetTime));             
          return "player already met on " + Tools.getLexicalDate(lastTime) + "\n";
        }
      }
      return "player never met\n";
    }
  }
  
 /*------------------------------------------------------------------------------------*/
 
  /** To show debug information
   */
  public String toString() {
    String result;
    result = "LieManager::toString for player "+fakeNames[0]+"\n";
    if (memories==null) {
      result += " \tmemories null\n";
      return result;
    }
    synchronized(memories) {
      memories.resetIterator();
      int k=0;
      LieMemory memory;
      while ( memories.hasNext() ) {        
        memory = memories.next();
        result += "\tk = " + k + " meetsNumber = " + memory.meetsNumber + " otherPlayerKey = " + memory.otherPlayerKey + " otherPlayerFakeNameIndex = " + memory.otherPlayerFakeNameIndex + "\n";
        k++;
      }    
      return result;
    }
  }
 
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

  /** This is where we put your message data on the stream. You don't need
   * to invoke this method yourself, it's done automatically.
   *
   * @param ostream data stream where to put your data (see java.io.DataOutputStream)
   * @exception IOException if the stream has been closed or is corrupted.
   */
    public void encode( DataOutputStream ostream ) throws IOException {     
      int fakeNamesLength = fakeNames.length;
      // Transfering fakeNames  
      ostream.writeInt(fakeNamesLength);       
      for (int i=0; i<fakeNamesLength; i++) {
        ostream.writeUTF(fakeNames[i]);
      }
      
      // Transfering currentFakeNameIndex
      ostream.writeShort(currentFakeNameIndex);
      
      // Transfering memories 
      if (memories==null) {
        ostream.writeInt(0);
      } else {
        ostream.writeInt(memories.getSize());
        LieMemory memory;
        synchronized(memories) {
          memories.resetIterator();
          while (memories.hasNext()) {
            memory = memories.next();
            ostream.writeUTF(memory.otherPlayerKey);
            ostream.writeShort(memory.otherPlayerFakeNameIndex);
            ostream.writeInt(memory.meetsNumber);
            ostream.writeLong(memory.lastMeetTime);
          }
        }
      }
       
    }

 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

  /** This is where we retrieve our message data from the stream. You don't need
   * to invoke this method yourself, it's done automatically.
   *
   * @param istream data stream where you retrieve your data (see java.io.DataInputStream)
   * @param myPlayer player who owns this lieManager
   * @exception IOException if the stream has been closed or is corrupted.
   */
    public void decode( DataInputStream istream , PlayerImpl myPlayer ) throws IOException {
      //LieManager myLieManager = new LieManager();      
      LieManager myLieManager = myPlayer.getLieManager();
      
      int fakeNamesLength = istream.readInt();      
      for (int i=0; i<fakeNamesLength; i++) {
        myLieManager.fakeNames[i] = istream.readUTF();
      }
      
      currentFakeNameIndex = istream.readShort();
      
      int myMemoriesSize = istream.readInt();
      
      if (myMemoriesSize==0) {
        ;
      } else {
        LieMemoryIterator myMemories = myLieManager.getMemoriesIterator();
        myMemories.resetIterator();
        LieMemory myMemory;
        for (int i=0; i<myMemoriesSize; i++) {
          myMemory = new LieMemory(istream.readUTF(), istream.readShort(), istream.readInt(), istream.readLong());
          myMemories.add(myMemory);
        }          
      }       
    }
  
 /*------------------------------------------------------------------------------------*/
  
  /** Constructor.
   */
  public LieManager() {
    for (short i=0;i<FAKENAMES_NUMBER;i++) {
      fakeNames[i] = "";      
    }
    currentFakeNameIndex = 0;
  }

  /** write object data with serialize.
   */
    public void writeExternal(java.io.ObjectOutput objectOutput)
    throws java.io.IOException {
        objectOutput.writeInt( ExternalizeGetVersion() );
        int fakeNamesLength = fakeNames.length;
        // Transfering fakeNames  
        objectOutput.writeInt(fakeNamesLength);       
        for (int i=0; i<fakeNamesLength; i++) {
            objectOutput.writeUTF(fakeNames[i]);
        }
        // Transfering currentFakeNameIndex
        objectOutput.writeShort(currentFakeNameIndex);
        // Transfering memories 
        if (memories==null) {
            objectOutput.writeInt(0);
        } else {
            objectOutput.writeInt(memories.getSize());
            LieMemory memory;
            synchronized(memories) {
                memories.resetIterator();
                while (memories.hasNext()) {
                    memory = memories.next();
                    objectOutput.writeUTF(memory.otherPlayerKey);
                    objectOutput.writeShort(memory.otherPlayerFakeNameIndex);
                    objectOutput.writeInt(memory.meetsNumber);
                    objectOutput.writeLong(memory.lastMeetTime);
                }
            }
        }
    }
    
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

  /** read object data with serialize.
   */
    public void readExternal(java.io.ObjectInput objectInput)
    throws java.io.IOException, java.lang.ClassNotFoundException {
        int IdTmp = objectInput.readInt();
        if( IdTmp == ExternalizeGetVersion() ){
            int fakeNamesLength = objectInput.readInt();      
            for (int i=0; i<fakeNamesLength; i++) {
                fakeNames[i] = objectInput.readUTF();
            }
            currentFakeNameIndex = objectInput.readShort();
            int myMemoriesSize = objectInput.readInt();
            if (myMemoriesSize==0) {
                ;
            } else {
                LieMemoryIterator myMemories = getMemoriesIterator();
                myMemories.resetIterator();
                LieMemory myMemory;
                for (int i=0; i<myMemoriesSize; i++) {
                    myMemory = new LieMemory(objectInput.readUTF(), objectInput.readShort(), objectInput.readInt(), objectInput.readLong());
                    myMemories.add(myMemory);
                }
            }       
        } else {
            // to do.... when new version
        }
    }

 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

  /** id version of data, used in serialized persistance.
   */
    public int ExternalizeGetVersion(){
        return 1;
    }
}