liemanager.java

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

/*
 * Light And Shadow. A Persistent Universe based on Robert Jordan's Wheel of Time Books.
 * Copyright (C) 2001-2003 WOTLAS Team
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

package wotlas.server;

import wotlas.utils.Tools;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import wotlas.libs.persistence.*;

import java.util.Calendar;
import java.util.Date;

/** Wotlas Lie Manager.
 *
 * @author Petrus
 */

public class LieManager implements BackupReady{

    /** id used in Serialized interface.
     */
    private static final long serialVersionUID = 556565L;
 
 /*------------------------------------------------------------------------------------*/

  /** Number of player fake names 
   */
  public final static short FAKENAMES_NUMBER = 5;
  
  /** Number of meets to remember
   */
  public final static int MEETS_NUMBER = 50;
  
  /** when we leave an InteriorMap, we forget all players
   * that we met less than MEET_CHANGEINTERIORMAP times
   */
  public final static int MEET_CHANGEINTERIORMAP = 30;
  
  /** when we leave an TownMap, we forget all players
   * that we met less than MEET_CHANGEINTERIORMAP times
   */
  public final static int MEET_CHANGETOWNMAP = 90;
  
  /** when we leave an WorldMap, we forget all players
   * that we met less than MEET_CHANGEINTERIORMAP times
   */
  public final static int MEET_CHANGEWORLDMAP = 100;
  
  /** Simple meet (weight 2)
   */
  public final static int MEET_SIMPLE = 2;
  
  /** Chat meet (weight 1)
   */
  public final static int MEET_CHATMESSAGE = 1;
  
 /*------------------------------------------------------------------------------------*/

  /** Number of meetsNumber to forget when player leave an interiormap
   */
  public final static int FORGET_INTERIORMAP = 5;
  
  /** Number of meetsNumber to forget when player leave an interiormap
   */
  public final static int FORGET_TOWNMAP = 10;
  
  /** Number of meetsNumber to forget when player leave an interiormap
   */
  public final static int FORGET_WORLDMAP = 20;
  
  /** Number of meetsNumber to forget when player has not connected for a long time
   */
  public final static int FORGET_RECONNECT_LONG = 40;
  
  /** Number of meetsNumber to forget when player reconnect
   */
  public final static int FORGET_RECONNECT = 2;
  
 /*------------------------------------------------------------------------------------*/
  
  /** List of player's fake names
   */
  private String[] fakeNames = new String[FAKENAMES_NUMBER];
  
  /** List of other players current player has met
   * ascending order
   */
  private LieMemory[] memoriesArray = new LieMemory[0];
  
  transient LieMemoryIterator memories = new LieMemoryIterator();
  
  public LieMemoryIterator getMemoriesIterator() {
    return memories;
  }
  
  /** Index of current fake name
   */
  private short currentFakeNameIndex = 0;
  
 /*------------------------------------------------------------------------------------*/

  /** To get fake names
   */
  public String[] getFakeNames() {
    return fakeNames;
  }
  
  /** To set fake names
   * @param fakeNames array of fake names
   */
  public void setFakeNames(String[] fakeNames) {
    this.fakeNames = fakeNames;
  }
  
  /** To get current fake name index
   */
  public short getCurrentFakeNameIndex() {
    return currentFakeNameIndex;
  }
  
  /** To set current fake name index
   */
  public void setCurrentFakeNameIndex(short currentFakeNameIndex) {
    this.currentFakeNameIndex = currentFakeNameIndex;
  }
  
  /** To get memories
   */
  public LieMemory[] getMemoriesArray() {
    if (memories==null) {
      return null;
    }
    memories.resetIterator();
    LieMemory[] myMemoriesArray = new LieMemory[memories.getSize()];
    for (int k=0; k<memories.getSize(); k++) {
      myMemoriesArray[k] = memories.next();        
    }
    return myMemoriesArray;
  }
  
  /** To set memories
   */
  public void setMemoriesArray(LieMemory[] memoriesArr) {
    if (memories==null) {
      memories = new LieMemoryIterator();
    } else {
      memories.clear();
      memories.resetIterator();
    }
    for (int k=0; k<memoriesArr.length; k++) {
      memories.add(memoriesArr[k]);
    }
  }
  
 /*------------------------------------------------------------------------------------*/
  
  public String getFakeName(short index) {
    return fakeNames[index];
  }
  
  /** To get player fake name
   *
   * @param otherPlayer player who requested the fake name
   */
  public String getFakeName(PlayerImpl otherPlayer) {  
    if (ServerDirector.SHOW_DEBUG)
      System.out.println("LieManager::getFakeName(otherPlayer="+otherPlayer.getPrimaryKey()+")");
    String otherPlayerKey = otherPlayer.getPrimaryKey();
    return addMeet(otherPlayer, MEET_SIMPLE);
  }
  
  /** To get current fake name
   */
  public String getCurrentFakeName() {    
    return fakeNames[currentFakeNameIndex];
  }
  
  /** To add a player to our memory
   *
   * @param otherPlayer other player we want to remember
   * @return other player fake name
   */
  public String addMeet(PlayerImpl otherPlayer) {
    return addMeet(otherPlayer, MEET_SIMPLE);
  }
  
  /** To add a player to our memory
   *
   * @param otherPlayer other player we want to remember
   * @param meetType type of meet
   * @return other player fake name
   */
  public String addMeet(PlayerImpl otherPlayer, int meetType) {
    if (ServerDirector.SHOW_DEBUG)
      System.out.println("\naddMeet(otherPlayer="+otherPlayer.getPrimaryKey()+", meetType="+meetType+")");
    String otherPlayerKey = otherPlayer.getPrimaryKey();
    LieMemory memory;
    int k;
    synchronized(memories) {
      k=0;
      memories.resetIterator();      
      while ( memories.hasNext() ) {
        k++;
        memory = memories.next();
        if (memory.otherPlayerKey.equals(otherPlayerKey)) {           
          // player already met
          if (ServerDirector.SHOW_DEBUG)
            System.out.println("\tplayer already met");
          if (k>MEETS_NUMBER) {            
            // should never happen
            return null; 
          } else {
            // 
            int newMeetsNumber = memory.meetsNumber + meetType;            
            short oldOtherPlayerFakeNameIndex = memory.otherPlayerFakeNameIndex;
            if (ServerDirector.SHOW_DEBUG)
              System.out.println("\tremoving entry");            
            k--;
            memories.remove();
                                      
            while ( memories.hasNext() ) {
              k++;
              memory = memories.next();              
              if (memory.meetsNumber<newMeetsNumber) {
                LieMemory myMemory = new LieMemory(otherPlayerKey, oldOtherPlayerFakeNameIndex, newMeetsNumber);
                if (ServerDirector.SHOW_DEBUG)
                  System.out.println("\tinserting new entry");
                memories.insert(myMemory);
                if (k>MEETS_NUMBER) {
                  // must remove the first element
                  memories.resetIterator();
                  memories.remove();
                }           
                return otherPlayer.getLieManager().getFakeName(oldOtherPlayerFakeNameIndex);                                
              }
            }
            // Add player at the end of the LieMemoryIterator
            if (ServerDirector.SHOW_DEBUG)
              System.out.println("\tadding new entry");            
            LieMemory myMemory = new LieMemory(otherPlayerKey, oldOtherPlayerFakeNameIndex, newMeetsNumber);
            memories.add(myMemory);   
            if (k>MEETS_NUMBER) {
              // must remove the first element
              memories.resetIterator();
              memories.remove();
            }  
            return otherPlayer.getLieManager().getFakeName(oldOtherPlayerFakeNameIndex);                                
          }
        }
      }
      
      // Player not found in the LieMemoryIterator
      if (ServerDirector.SHOW_DEBUG)
        System.out.println("\tplayer never met");      
      if (k>MEETS_NUMBER) {
        // not enough place to remember player
        return otherPlayer.getLieManager().getCurrentFakeName();
      } 
      // Add player at the beginning of the LieMemoryIterator
      if (ServerDirector.SHOW_DEBUG)
        System.out.println("\tinserting player");      
      memories.resetIterator();
      LieMemory myMemory = new LieMemory(otherPlayerKey, otherPlayer.getLieManager().getCurrentFakeNameIndex(), 0);
      memories.insert(myMemory);         
      return addMeet(otherPlayer, meetType);
    }
  }
    
  /** To forget players
   *
   * @param meetType number of meetsNumber to forget
   */
  public void removeMeet(int meetType) {
    if (ServerDirector.SHOW_DEBUG)
      System.out.println("LieManager::removeMeet(meetType="+meetType+")");
    if (memories==null)
      return;
    synchronized(memories) {