groupofgraphics.java

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

   */
    public int ExternalizeGetVersion(){
        return 1;
    }

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

  /** write object data with serialize.
   */
    public void writeExternal(java.io.ObjectOutput objectOutput)
    throws java.io.IOException {
        objectOutput.writeInt( ExternalizeGetVersion() );
        objectOutput.writeByte( Id );
        objectOutput.writeObject( tileDim );
        objectOutput.writeByte( tileType );
        objectOutput.writeObject( tileImageSet );
        objectOutput.writeBoolean( freeWalk );
    }
    
 /*------------------------------------------------------------------------------------*/

  /** 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() ){
            Id =  objectInput.readByte();
            tileDim = ( Dimension ) objectInput.readObject();
            tileType =  objectInput.readByte();
            tileImageSet = ( String ) objectInput.readObject();
            freeWalk =  objectInput.readBoolean();
        } else {
            // to do.... when new version
        }
    }

    protected void ComputePos(BufferedImage allTile){
        Xlen = allTile.getWidth() / tileDim.width;
        Ylen = allTile.getHeight() / tileDim.height;
        Pos = new int[ Xlen * Ylen ][ 4 ];
        for(int b=0;b<Ylen;b++){
            for(int a=0;a<Xlen;a++){
                Pos[a+(b*Xlen)][0] = tileDim.width * a;
                Pos[a+(b*Xlen)][1] = tileDim.height * b;
                Pos[a+(b*Xlen)][2] = tileDim.width + ( tileDim.width * a );
                Pos[a+(b*Xlen)][3] = tileDim.height + ( tileDim.height * b );
            }
        }
    }

    public void drawMe( java.awt.Graphics2D gc, int myX, int myY, int internalTile, BufferedImage theTile ) {
        if(Pos==null){
            ComputePos(theTile);
            // if( tileType == TileMap.TILE )
                // do nothing;
            if( tileType == TileMap.WALLX )
                ComputePosWall( true );
            else if( tileType == TileMap.WALLY )
                ComputePosWall( false );
        }
        if( tileType == TileMap.WALLX )
            gc.drawImage( theTile
            , myX+Offset[internalTile][0]-30
            , myY+Offset[internalTile][1]+10
            , myX+tileDim.width-30, myY+tileDim.height+10
            ,Pos[internalTile][0],Pos[internalTile][1]
            ,Pos[internalTile][2],Pos[internalTile][3]
            ,null);
        else if( tileType == TileMap.WALLY )
            gc.drawImage( theTile
            , myX+Offset[internalTile][0]+10
            , myY+Offset[internalTile][1]-30
            , myX+tileDim.width+10, myY+tileDim.height-30
            ,Pos[internalTile][0],Pos[internalTile][1]
            ,Pos[internalTile][2],Pos[internalTile][3]
            ,null);
        else 
            gc.drawImage( theTile, myX, myY, myX+tileDim.width, myY+tileDim.height
            ,Pos[internalTile][0],Pos[internalTile][1]
            ,Pos[internalTile][2],Pos[internalTile][3]
            ,null);
    }

    public ImageIdentifier getImage() {
        return image;
    }

    public void ComputePosWall(boolean isOrizzontal){
        Offset = new short[ Xlen * Ylen ][ 2 ];
        /* THIS OPERATIONS ARE DONE TO CHECK THAT THE LESS POSSIBLE TRANSPARENT AREA
         * IS COPIED DURING VIDEO OPERATIONS */
        try{
            if(isOrizzontal){
                Pos[1][1] += 20 ;
                Offset[1][1] = 20;
                for(int index=2;index<6;index++){
                    Offset[index][0] = new Integer(10*(index-1)).shortValue();
                    Pos[index][0] += 10*(index-1);
                }
            } 
            else {
                Pos[1][0] += 20 ;
                Offset[1][0] = 20;
                for(int index=2;index<6;index++){
                    Offset[index][1] = new Integer(10*(index-1)).shortValue();
                    Pos[index][1] += 10*(index-1);
                }
            }
        } catch (Exception e){
            e.printStackTrace();
            System.err.println( "GraphicWall ComputeposWall Filename" + tileImageSet );
        }
    }
    
    /*
    public void ComputePosDoor(boolean isOrizzontal){
        try{
            Xlen = new Integer(icon.getIconWidth() / XSinglePic).shortValue();
            Ylen = new Integer(icon.getIconHeight() / YSinglePic).shortValue();
            Images = new Integer(Xlen*Ylen).shortValue();
            Offset = null;
            Pos = new short[Images][4];
            for(int b=0;b<Ylen;b++){
                for(int a=0;a<Xlen;a++){
                    Pos[a+(b*Xlen)][0] = new Integer(0+(XSinglePic*a)).shortValue();
                    Pos[a+(b*Xlen)][1] = new Integer(0+(YSinglePic*b)).shortValue();
                    Pos[a+(b*Xlen)][2] = new Integer(XSinglePic+(XSinglePic*a)).shortValue();
                    Pos[a+(b*Xlen)][3] = new Integer(YSinglePic+(YSinglePic*b)).shortValue();
                }
            }
        } catch (Exception e){
            e.printStackTrace();
            System.err.println("GraphicWall ComputeposWall Filename"+FileName);
        }
    }
     public void externalPaint(Graphics g,int startX,int startY
    ,int imageNumber,JComponent here) {
        switch (Type){
            case XWALL_THIN:
                g.drawImage(icon.getImage()
                ,startX+Offset[imageNumber][0]-30,startY+Offset[imageNumber][1]+10
                ,startX+XSinglePic-30,startY+YSinglePic+10
                ,Pos[imageNumber][0],Pos[imageNumber][1]
                ,Pos[imageNumber][2],Pos[imageNumber][3]
                ,here);
                break;
            case YWALL_THIN:
                g.drawImage(icon.getImage()
                ,startX+Offset[imageNumber][0]+10,startY+Offset[imageNumber][1]-30
                ,startX+XSinglePic+10,startY+YSinglePic-30
                ,Pos[imageNumber][0],Pos[imageNumber][1]
                ,Pos[imageNumber][2],Pos[imageNumber][3]
                ,here);
                break;
            case DOOR_X:
                g.drawImage(icon.getImage()
                ,startX-20,startY+15
                ,startX+XSinglePic-20,startY+YSinglePic+15
                ,Pos[imageNumber][0],Pos[imageNumber][1]
                ,Pos[imageNumber][2],Pos[imageNumber][3]
                ,here);
                break;
        }
    }
   */
    
    public ImageIcon getAsIcon( int internalTile, ImageLibrary imageLib ) {
        if( image == null )
           image = new ImageIdentifier(tileImageSet);
        imageLib.loadImage( image );
        BufferedImage theTile = imageLib.getImage( image );
        if(Pos==null)
            ComputePos(theTile);
        BufferedImage subImage;
        subImage = theTile.getSubimage( Pos[internalTile][0]
        ,Pos[internalTile][1]
        ,tileDim.width
        ,tileDim.height
        );
        return new ImageIcon(subImage);
    }
    
    public int totalImage(){
        return Xlen*Ylen;
    }

    static public void initGroupOfGraphics( GraphicsDirector gDirector
    , GroupOfGraphics[] groupOfGraphics) {
        for( int index=0; index < groupOfGraphics.length; index++ )
            groupOfGraphics[index].init( gDirector );
        return ;
    }
    
    public boolean getFreeStatus(){
        return freeWalk;
    }
}