jccomponent.java

非常好的java collapse游戏代码

/*
 * JCollapse - Java Collapse Game
 * Copyright (C) 2005 Erico Gon鏰lves Rimoli
 * 
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

package sourceforge.net.projects.jcollapse.game.components;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.VolatileImage;
import java.util.ArrayList;

import javax.swing.JComponent;

import sourceforge.net.projects.jcollapse.engine.block.Block;
import sourceforge.net.projects.jcollapse.engine.JCListener;
import sourceforge.net.projects.jcollapse.engine.JCModel;
import sourceforge.net.projects.jcollapse.game.blocks.DisplayableGraphic;
import sourceforge.net.projects.jcollapse.game.effects.Effect;
import sourceforge.net.projects.jcollapse.game.effects.EffectObserver;
import sourceforge.net.projects.jcollapse.game.levels.Level;

/**
 * This bean is a view for JCModel. With this component, you can add, roll and touch
 * Block objects to the board.<br><br>
 * This class is not thread safe!
 * 
 * @author erico
 *
 */
public class JCComponent extends JComponent implements Runnable, EffectObserver {
	private static final int SLEEP_TIME_IN_PAUSE_MODE = 250;
	
    private static final int DEFAULT_BOARD_WIDTH = 12;
    private static final int DEFAULT_BOARD_HEIGHT = 14;
    private static final Color TRANSPARENT_BLACK = new Color( 0, 0, 0, 130 );
	
    private VolatileImage m_VolatileImageBoard;
    private Graphics2D m_G2DBoard;
    private GraphicsConfiguration m_GraphicsConfiguration;
    
    private JCModel m_JCollapseModel;
    private Level m_Level;
    private Effect m_Effect;
    private Image m_ImageEffect;
    private ArrayList<JCComponentListener> m_JCComponentListener;
    private Thread m_RollThread;
    
    private boolean m_DrawEnabled = true;
    private boolean m_HideBoardOnPause = true;
    private boolean m_GameOver = true;
    private boolean m_Paused = false;
    
    private int m_HorizontalBlocksCount;
    
    /**
     * Constructor for this component
     */
    public JCComponent() {
        super();
        initializeComponents();
    }
    
    private void createGraphicsContext() {
    	//only create graphic context when width and height > 0
    	if( getWidth() > 0 && getHeight() > 0 ) {
	        //create image/graphic context to board
	    	try {
    			m_VolatileImageBoard = m_GraphicsConfiguration.createCompatibleVolatileImage( getWidth(), getHeight() );
    			
	    	} catch( Exception ex1 ) {
	    		ex1.printStackTrace();
	    	}
	    	
	    	m_G2DBoard = m_VolatileImageBoard.createGraphics();
	    	
	    	//number of bytes available in accelerated memory. A negative return value indicates that accelerated memory is unlimited.
	    	System.out.println( "Draw context created [" + m_G2DBoard.getDeviceConfiguration().getDevice().getAvailableAcceleratedMemory() + "]" );
    	}
    }
	
    private void initializeComponents() {
    	//CollapseModel
    	//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
        m_JCollapseModel = new JCModel( DEFAULT_BOARD_WIDTH, DEFAULT_BOARD_HEIGHT );
    	m_JCollapseModel.addJCollapseListener( new JCListener() {
        	public void gameOver() {
    			System.out.println( "Game over!" );
    			stop();
        	}
        	public void blockRolled( int remainder, boolean isBaseBoardFull ) {}
        	public void boardTouched( int removedBlocks, int blocksInStack, Block block ) {}
        });
    	
    	//JCComponentListener
    	//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
    	m_JCComponentListener = new ArrayList<JCComponentListener>(1);
    	
    	//GraphicsConfiguration
    	//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
    	m_GraphicsConfiguration = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();

    	//this
    	//----------------------------------------------------------------------------------------------------------------------------------------------------------------------
    	setIgnoreRepaint( true );
    	setOpaque( false );
    	addComponentListener( new ComponentAdapter() {
            public void componentResized( ComponentEvent e ) {
           		createGraphicsContext();
               	repaint();
            }
        });
        
        addMouseListener( new MouseAdapter() {
        	public void mousePressed(MouseEvent e) {
                float blockWidth = getWidth() / m_JCollapseModel.getGameBoard().getBoardWidth();
                float blockHeight = getHeight() / ( m_JCollapseModel.getGameBoard().getBoardHeight() + 1 );

                float offSetX = ( ( getWidth() % blockWidth ) / 2 );
                float offSetY = ( ( getHeight() % blockHeight ) );
                
                //calcule the position of clicked block
                //using the offset
                float x = ( e.getX() - offSetX ) / blockWidth;
                float y = ( ( getHeight() - e.getY() - blockHeight ) - offSetY ) / blockHeight;
                
                if( x >= 0 && x < m_JCollapseModel.getGameBoard().getBoardWidth() &&
                	y >= 0 && y < m_JCollapseModel.getGameBoard().getBoardHeight() &&
                	!m_GameOver && !m_Paused )
                {
                	m_JCollapseModel.touchBoard( (int)x, (int)y );
                	repaint();
                }
        	}
        });
    }
    
    private void fireBlockRolled( int remainder, boolean isBaseBoardFull ) {
    	for( JCComponentListener l : m_JCComponentListener )
    		l.blockRolled( remainder, isBaseBoardFull );
    }
    
    private void fireLevelLoaded( Level level ) {
    	for( JCComponentListener l : m_JCComponentListener )
    		l.levelLoaded( level );
    }
    
    private void fireLevelEnd( Level level ) {
    	for( JCComponentListener l : m_JCComponentListener )
    		l.levelEnd( level );
    }
    
    private void fireGameStarted() {
    	for( JCComponentListener l : m_JCComponentListener )
    		l.gameStarted();
    }
    
    private void fireGamePaused( boolean paused ) {
    	for( JCComponentListener l : m_JCComponentListener )
    		l.gamePaused( paused );
    }
    
    private void fireGameStoped() {
    	for( JCComponentListener l : m_JCComponentListener )
    		l.gameStoped();
    }
    
    /**
     * Add a JCComponentListener that listener event from this object
     * @param jCollapseComponentListener JCComponentListener object that listener event from this object
     */
    public void addJCollapseComponentListener( JCComponentListener jCollapseComponentListener ) {
    	m_JCComponentListener.add( jCollapseComponentListener );
    }
    
    /**
     * Remove a JCComponentListener
     * @param jCollapseComponentListener the JCComponentListener object
     * @return true if component are removed
     */
    public boolean removeJCollapseComponentListener( JCComponentListener jCollapseComponentListener ) {
    	return m_JCComponentListener.remove( jCollapseComponentListener );
    }
    
    /**
     * Remove all JCComponentListener
     */
    public void removeAllJCollapseComponentListener() {
    	m_JCComponentListener.clear();
    }
    
    /**
     * Return the JCModel object
     * @return the JCModel object
     * @see sourceforge.net.projects.jcollapse.engine.board.GameBoard 
     * @see sourceforge.net.projects.jcollapse.engine.board.Board
     */
    public JCModel getJCollapseModel() {
    	return m_JCollapseModel;
    }
    
    /**
     * Get Level information
     * @return the Level object
     */
    public Level getLevel() {
    	return m_Level;
    }
    
    /**
     * Get accelerated Graphic context object 
     * @return accelerated Graphic context object
     */
    public Graphics getGraphicsContext() {
    	return m_G2DBoard;
    }

    /**
     * Hide Board if game are paused
     * @return return true if property are enabled
     */
    public boolean isHideBoardOnPause() {
    	return m_HideBoardOnPause;
    }
    
    /**
     * Set true if you wish to hide Board when game is paused
     * @param hide if true the Board don't be displayed
     */
    public void setHideBoardOnPause( boolean hide ) {
    	m_HideBoardOnPause = hide;
    }
    
    /**
     * Get draw status this component. If true, this component reflect the GameModel object
     * @return draw status this component. If true, this component reflect the GameModel object
     */
    public boolean isDrawEnabled() {
    	return m_DrawEnabled;
    }
    
    /**
     * Enable draw process. If false, the board don't draw any object from GameModel
     * @param enabled disable draw of GameModel object
     */
    public void setDrawEnabled( boolean enabled ) {
    	m_DrawEnabled = enabled;
    }
    
    /**
     * Load level from Level object
     * @param level The Level object containing definitions for game level
     */
    public void loadLevel( Level level ) {
    	m_Level = level;
    	m_HorizontalBlocksCount = m_Level.getWidth();