harpooncanvas.java

fishgame手机游戏 运用工具netbean可以运行起来

package cn.zucc.mmf.harpoon;

import cn.zucc.mmf.harpoon.util.Clock;
import cn.zucc.mmf.harpoon.util.ImageFont;
import cn.zucc.mmf.harpoon.util.ImageUtilities;
import javax.microedition.lcdui.game.*;
import javax.microedition.lcdui.*;
import java.util.*;

public class HarpoonCanvas extends GameCanvas implements Runnable {
       
	public static final Random RANDOM = new Random();
	private static final int MILLISECS_PER_FRAME = 70;
	private Thread m_thread;
	private long m_startTime;
        
        ImageFont fontbig, fontsmall;
        
        private static final int P_MAX_FISHS = 5;        
	private Vector m_fishs = new Vector(P_MAX_FISHS);

	public boolean m_isStopped;
	public boolean m_isPaused;

	public static int m_width, m_height;
	private Graphics m_gOffscreen;
        private Clock clock=new Clock();

	private static final int LEVEL_1 = 100;
        private static final int LEVEL_2 = 200;
        private static final int LEVEL_3 = 300;
        
        private int levelScore=100;
        private static final int fish_move_rangH=200;
	                    
	private FishSprite m_fish;  
	private Fishman fishman;
	private Background m_background;
	private LayerManager m_layerManager;
        
       
        Image background;
        Image bomb_ico;
        boolean flag=true;
        int control_Fish_State=2;
        int FirePress_Control=1;
        int FishReset_Control=1;
        long FireTime_Control=0;
        static int fork_control=1;
       
        private int hasFish=0;
        private int idx,dir, x, y,fishHeight;
        
	//Initialization
	public HarpoonCanvas() {
		//Suppress events for game action keys
		super(true);
		setFullScreenMode(true);
		m_width = getWidth();
		m_height = getHeight();
                System.err.println("---getWidth----"+m_width+"-----getHeight----"+m_height);
		m_gOffscreen = getGraphics();
		try {
			m_fish = new FishSprite(m_width,ImageUtilities.createImage("/fish1.png"));
                        m_fishs.addElement(m_fish);
			fishman = new Fishman(m_width,m_height);
			m_background = new Background(m_width,m_height,ImageUtilities.createImage("/bg.png"));
                        //background=ImageUtilities.createImage("/bg.png");
			m_layerManager = new LayerManager();
                        fontbig = new ImageFont(ImageUtilities.createImage("/b_number.png"),10, 19, new char[] { '0', '1', '2', '3', '4', '5', '6', '7',
                        '8', '9' });
		}
		catch (Exception e) {
			System.err.println("ERROR creating game object:"+e.getMessage());
		}
                
	}

	public boolean start() {
		if (m_fish == null ||
			fishman == null ||
			m_background == null ||
			m_layerManager == null) {
			return false;
		}
		setCommandListener (HarpoonMidlet.m_midlet);
                m_layerManager.append(fishman.fork);
                m_layerManager.append(fishman);
		m_layerManager.append(m_fish);
		m_layerManager.append(m_background);

		//launch the game loop thread
		m_thread = new Thread(this);
		m_thread.start();
                clock.restart();
		m_startTime = System.currentTimeMillis();
		return true;
	}
	public void stop() {
		m_isStopped = true;
		m_thread = null;
	}
	public void exit() {
		stop();
	}

	//Runnable - the main game loop
	public void run () {
		while (!m_isStopped) {
			if (!m_isPaused) {
				readInput();
				simulateWorld();
				draw();
			}
			delayUntilNextFrame();
		}
	}

	private void readInput() {          
		int keyStates = getKeyStates();
		if ((keyStates & UP_PRESSED) != 0) {
		}
		else if ((keyStates & DOWN_PRESSED) != 0) {
			//m_fish.swim(FishSprite.DOWN);
		}

		if ((keyStates & LEFT_PRESSED) != 0) {
			fishman.swim(Fishman.LEFT);
		}
                if(FirePress_Control==0){
                    long newTime=System.currentTimeMillis();
                    if(newTime-FireTime_Control>100){
                        FirePress_Control=1;
                    }
                }
                if((keyStates & FIRE_PRESSED) != 0){                   
                   /*if(FirePress_Control==1){
                       FireTime_Control=System.currentTimeMillis();
                    if(m_fish.bombNum>0){
                        m_fish.bombNum--;
                        m_fish.rest.setVisible(true);
                        m_fish.RestState=true;
                        m_fish.changeState();
                        FirePress_Control=0;
                   } 
                  }*/
                   //fishman.fork.setVisible(true);
                    if(fork_control==1){
                     fork_control=0;
                     Fork.fork_down=1;
                     fishman.fork.changeState();
                    }
                }else if ((keyStates & RIGHT_PRESSED) != 0) {
			fishman.swim(Fishman.RIGHT);
		}
	}

	private void simulateWorld() {
            //fishman.fork.setPosition(fishman.getRefPixelX()-2, fishman.getRefPixelY()+5);
            if(fishman.fork.getRefPixelY()<=fishman.getRefPixelY()+2){
                fishman.fork.setRefPixelPosition(fishman.getRefPixelX()-3, fishman.getRefPixelY()+5);
            }
            
            if ((RANDOM.nextInt() % 20 == 0) &&
			(m_fishs.size() < P_MAX_FISHS)) {
                        FishSprite fish;  
			fish = new FishSprite(m_width,ImageUtilities.createImage("/fish1.png"));
			m_fishs.addElement(fish);
			m_layerManager.insert(fish,0);
		}
            
             if(fork_control==0){
                            fishman.fork.fall();
                            if(this.hasFish==0){
                            if(fishman.fork.getY()>=this.getHeight()/2){
                                 Fork.m_fallY--;
                                 //isBack=1;
                                 if(Fork.m_fallY<=0){
                                        Fork.fork_up=1;
                                        fishman.fork.changeState();
                                 }
                            }                           
                            }
                            if(this.hasFish==1){
                                if(fishman.fork.getY()>=fishHeight+5){
                                 Fork.m_fallY--;
                                 //isBack=1;
                                 if(Fork.m_fallY<=0){
                                        Fork.fork_up=1;
                                        fishman.fork.changeState();
                                 }
                            } 
                            }
                        }else 
                            fishman.fork.setRefPixelPosition(fishman.getRefPixelX()-3, fishman.getRefPixelY()+5);
		fishman.move();

		for ( idx=m_fishs.size()-1;idx>=0; --idx) {
			m_fish = (FishSprite) m_fishs.elementAt(idx);
                        
		    if (!m_fish.isVisible() && RANDOM.nextInt() % 50 == 0) {
			m_fish.setVisible(true);

			
			if (RANDOM.nextInt() > 0) {
				dir = FishSprite.RIGHT;
				x = -m_fish.getWidth()/2;
			}
			else {
				dir = FishSprite.LEFT;
				x = m_width - m_fish.getWidth()/2;
			}
			y = 50 +
				(Math.abs(RANDOM.nextInt()) %
				 (fish_move_rangH - m_fish.getHeight()));                       
			m_fish.init(x, y, dir);
		}

		//check for collision with manta ray
		if (m_fish.isVisible()) {		
                        if(fork_control==0){
                           if(m_fish.collidesWith(fishman.fork, true)&&Fork.fork_down>=1){
                               if(this.hasFish==0)
                                 fishHeight=m_fish.getY();
                                 this.hasFish=1;
                                 m_fish.isShot=1; 
                                 m_fish.changeState();
                           }
                           if(m_fish.isShot>=1){
                                m_fish.setRefPixelPosition(fishman.fork.getRefPixelX(),fishman.fork.getRefPixelY()+fishman.fork.getHeight()/2);
                                this.m_layerManager.insert(m_fish, 0);
                           }
                           if(fishman.fork.getY()<=30&&Fork.fork_up>=1){                               
                               fishman.fork.setVisible(true);
                               System.out.println("fish.isShot-------------:"+m_fish.isShot);
                                if(m_fish.isShot>=1){                                                  
                                   m_fish.setVisible(false); 
                                  // m_fish.flag=0;
                                   m_fishs.removeElement(m_fish);  
                                   fishman.currScore+=10;
                                }
                               if(idx==0){   
                                  
                                  fork_control=1;
                                  this.hasFish=0;
                               }
                                  
                            }
                           
                        }
                        m_fish.swim();                       
		}
                }		
	}

	private void eraseBackground(Graphics g) {
		g.setColor(0xc6a344);
		g.fillRect(0,  0, getWidth(), getHeight());
                
	}

	private void draw() {
              
		eraseBackground(m_gOffscreen);        
                
               
		m_layerManager.paint(m_gOffscreen,0,0);
                m_gOffscreen.drawLine(fishman.getRefPixelX()-3,30,fishman.fork.getRefPixelX(), fishman.fork.getRefPixelY()-fishman.fork.getHeight()/2);               
                fontbig.drawString(m_gOffscreen, new Integer((int)fishman.currScore).toString(), 50,this.getHeight()-20);
                fontbig.drawString(m_gOffscreen, new Integer((int)fishman.totalMoney).toString(), this.getWidth()-40,this.getHeight()-20);
                fontbig.drawString(m_gOffscreen, new Integer((int)levelScore).toString(), 10,this.getHeight()-20);
                if(clock.getTime()>900){
                    m_isStopped = true;         
                   // Sprite gameover=new Sprite(ImageUtilities.createImage("/Turtles.png"));
                    //m_layerManager.insert(gameover,0);
                    m_gOffscreen.drawImage(ImageUtilities.createImage("/flash.png"),this.getWidth()/2,this.getHeight()/2,Graphics.HCENTER);
                    
                }
		flushGraphics();
	}

	private void delayUntilNextFrame() {
		long elapsed = m_startTime;
		m_startTime = System.currentTimeMillis();
		elapsed = m_startTime - elapsed;
		if (elapsed < MILLISECS_PER_FRAME) {
			try {
				m_thread.sleep(MILLISECS_PER_FRAME - elapsed);
			}
			catch (Exception e) {
			}
		}
		else {
			//We consumed all our allotted time so don抰 sleep, but before
			//exiting, yield to allow another thread a chance to process.
			m_thread.yield();
		}
	}
}