tilemap.java

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

  /** To init this tilemap for message routing. We create an appropriate message router
   *  for the tilemap via the provided factory.
   *
   *  Don't call this method yourself it's called via the WorldManager !
   *
   * @param msgRouterFactory our router factory
   */
    public void initMessageRouting( MessageRouterFactory msgRouterFactory, WorldManager wManager ){
       // build/get our router
          messageRouter = msgRouterFactory.createMsgRouterForTileMap( this, wManager );

       // we transmit the call to other layers
       // diego:actually no others layers
    }

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

  /** String Info.
   */
    public String toString(){
         return "TileMap - "+fullName;
    }

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

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

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

  /** write object data with serialize.
   */
    public void writeExternal(java.io.ObjectOutput objectOutput)
    throws java.io.IOException {
        if( loadStatus != LOAD_ALL){
            System.out.println( "Map ["+this.fullName+"] damaged, cause status of data before saving : "+ this.loadStatus );
            return;
//            throw new PreloaderException(loadStatus);
        }
        objectOutput.writeInt( ExternalizeGetVersion() );
        super.writeExternal( objectOutput );
        objectOutput.writeInt( tileMapID );
        objectOutput.writeObject( areaName );
        objectOutput.writeObject( fullName );
        objectOutput.writeObject( shortName );
        objectOutput.writeObject( insertionPoint );
        objectOutput.writeByte( manager.getMapType() );
        objectOutput.writeObject( smallTileMapImage );
        objectOutput.writeObject( musicName );
        objectOutput.writeObject( mapTileDim );
        objectOutput.writeByte( graphicSet );
        objectOutput.writeObject( mapSize );
        objectOutput.writeObject( manager );
        objectOutput.writeObject( encounterSchedules ); 
    }
    
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

  /** read object data with serialize.
   */
    public void readExternal(java.io.ObjectInput objectInput)
    throws java.io.IOException, java.lang.ClassNotFoundException {
        int IdTmp = objectInput.readInt();
        loadStatus = setClassPreloader;
        if( IdTmp == ExternalizeGetVersion() ){
            super.readExternal(objectInput);
            tileMapID= objectInput.readInt();
            areaName = ( String ) objectInput.readObject();
            fullName = ( String ) objectInput.readObject();
            shortName = ( String ) objectInput.readObject();
            insertionPoint = ( ScreenPoint ) objectInput.readObject();
            mapType = objectInput.readByte();
            smallTileMapImage = ( ImageIdentifier ) objectInput.readObject();
            musicName = ( String ) objectInput.readObject();
            if( setClassPreloader == LOAD_MINIMUM_DATA)
                return;
            mapTileDim = ( Dimension ) objectInput.readObject();
            graphicSet = objectInput.readByte();
            mapSize = ( Dimension ) objectInput.readObject();
            manager = ( TileMapManager ) objectInput.readObject();
            manager.setTileMap(this);
            if( setClassPreloader == LOAD_CLIENT_DATA)
                return;
            if( setClassPreloader == LOAD_SERVER_DATA){
                manager.freeMapBackGroundData();
            }
            encounterSchedules = ( EncounterSchedule[] ) objectInput.readObject();
       } else {
            // to do.... when new version
        }
    }

    public byte getMapType(){
        return mapType;
    }

    public void setManager( TileMapManager manager ){
        this.manager = manager;
        this.manager.setTileMap(this);
        mapType = manager.getMapType();
    }

    public TileMapManager getManager(){
        return manager;
    }

    public Dimension getMapTileDim(){
        return mapTileDim;
    }

    public Dimension getMapFullSize() {
        Dimension mapFullSize = new Dimension();
        mapFullSize.width  = mapSize.width * mapTileDim.width;
        mapFullSize.height = mapSize.height * mapTileDim.height;
        return mapFullSize;
    }
    
    public void selectGraphicSet( byte graphicSet ) {
        this.graphicSet = graphicSet;
    }

    public void initGraphicSet( GraphicsDirector gDirector ) {
        EnvironmentManager.initGraphics( gDirector, graphicSet );
        return ;
    }

    public byte getGraphicSet() {
        return graphicSet;
    }

    public void drawAllLayer( GraphicsDirector gDirector ) {
        manager.drawAllLayer( gDirector );
    }
    
    public void initNewTileMap( WorldMap myWorldMap ) {
        this.myWorldMap = myWorldMap;
    }
 /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/

  /** Returns the eventual MapExit the given player is intersecting.
   *
   * @param rCurrent rectangle containing the player's current position, width & height
   * @return the Building the player is heading to (if he has reached it, or if there
   *         are any), null if none.
   */
    public MapExit isIntersectingMapExit( int destX, int destY, Rectangle rCurrent ) {
        return manager.isIntersectingMapExit( destX, destY, rCurrent );
    }

    public MapExit[] getMapExits(){
        return manager.getMapExits();
    }
    
    public EncounterSchedule[] getEncounterSchedule(){
        return encounterSchedules;
    }   

    public EncounterSchedule addEncounterSchedule() {
        EncounterSchedule my = new EncounterSchedule();

        if (encounterSchedules == null) {
            encounterSchedules = new EncounterSchedule[1];
            my.setId(0);
            encounterSchedules[0] = my;
        } else {
            EncounterSchedule[] myEncounterSchedules = new EncounterSchedule[encounterSchedules.length+1];
            my.setId(encounterSchedules.length);
            System.arraycopy(encounterSchedules, 0, myEncounterSchedules, 0, encounterSchedules.length);
            myEncounterSchedules[encounterSchedules.length] = my;
            encounterSchedules = myEncounterSchedules;
        }
        return my;
    }
    
    public void readObject(java.io.ObjectInputStream objectInput)
    throws java.io.IOException, java.lang.ClassNotFoundException {
        int IdTmp = objectInput.readInt();
        if( IdTmp == ExternalizeGetVersion() ){
            loadStatus = objectInput.readByte();
            super.readObject(objectInput);
            tileMapID= objectInput.readInt();
            areaName = ( String ) objectInput.readObject();
            fullName = ( String ) objectInput.readObject();
            shortName = ( String ) objectInput.readObject();
            insertionPoint = ( ScreenPoint ) objectInput.readObject();
            mapType = objectInput.readByte();
            smallTileMapImage = ( ImageIdentifier ) objectInput.readObject();
            musicName = ( String ) objectInput.readObject();
            if( loadStatus == LOAD_MINIMUM_DATA)
                return;
            mapTileDim = ( Dimension ) objectInput.readObject();
            graphicSet = objectInput.readByte();
            // groupOfGraphics = ( GroupOfGraphics[] ) objectInput.readObject();
            mapSize = ( Dimension ) objectInput.readObject();
            manager = ( TileMapManager ) objectInput.readObject();
            manager.setTileMap(this);
            if( loadStatus == LOAD_CLIENT_DATA)
                return;
            if( loadStatus == LOAD_SERVER_DATA){
                manager.freeMapBackGroundData();
            }
            encounterSchedules = ( EncounterSchedule[] ) objectInput.readObject();
        } else {
            // ERORR IN THE STREAM : DIFFERENT VERSION OF CLIENT/SERVER
            // to do.... when new version
        }
    }
    
    public void writeObject(java.io.ObjectOutputStream objectOutput) 
    throws java.io.IOException {
        objectOutput.writeInt( ExternalizeGetVersion() );
        objectOutput.writeByte( loadStatus );
        super.writeExternal( objectOutput );
        objectOutput.writeInt( tileMapID );
        objectOutput.writeObject( areaName );
        objectOutput.writeObject( fullName );
        objectOutput.writeObject( shortName );
        objectOutput.writeObject( insertionPoint );
        objectOutput.writeByte( manager.getMapType() );
        objectOutput.writeObject( smallTileMapImage );
        objectOutput.writeObject( musicName );
        if( loadStatus == LOAD_MINIMUM_DATA)
            return;
        objectOutput.writeObject( mapTileDim );
        objectOutput.writeByte( graphicSet );
//        objectOutput.writeObject( groupOfGraphics );
        objectOutput.writeObject( mapSize );
        objectOutput.writeObject( manager );
        if( loadStatus == LOAD_CLIENT_DATA)
            return;
        objectOutput.writeObject( encounterSchedules ); 
    }
    
    public StoreTileMapBackground getStoreBackground(){
        return (new StoreTileMapBackground( manager.getMapBackGroundData()
        , manager.getMapMask()
        , manager.getMapExits()
        , mapSize
        , fileName
        , areaName
        , fullName        
        , shortName
        ));
    }

    public void setStoreBackground( StoreTileMapBackground data ){
        manager.replaceMask(data.mask);
        manager.replaceGraphics(data.graphic);
        manager.replaceExits(data.exits);
        this.mapSize = data.mapSize;
        this.fileName = data.fileName;
        this.areaName = data.areaName;
        this.shortName = data.shortName;
        this.fullName = data.fullName;
    }
}