llkcanvas.java

这是我买的一本J2me手机游戏设计的一本书里的例子

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.Timer;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.media.Manager;
import javax.microedition.media.Player;
import javax.microedition.media.control.VolumeControl;
public class LLKCanvas extends GameCanvas
{
    public boolean HASTEST = true;
    private int CanvasHeight = getHeight(); 
    private int CanvasWidth = getWidth(); 
    private int X = 1;
    private int Y = 1;
    private int XX =  - 1;
    private int YY =  - 1;
    private int X1 =  - 1;
    private int X2 =  - 1;
    private int Y1 =  - 1;
    private int Y2 =  - 1;
    private int VStep = 1;
    private int HStep = 1;
    private int VCounts[] =
    {
        8, 10, 12
    };
    public int VSize = 25;
    public int HSize = 25;
    private int VCount = 8;
    private int HCount = 8;
    private int SeedCounts[] =
    {
        20, 27, 35
    };
    public int SeedCount = 35;


    private int XMargin = 4;
    private int YMargin = 4;
    private int HintOffset = 100;
    private int LineSize = 2;
    private int LineColor = 0xffffff;
    private int BackColor = 0;
    private int RectColor = 0xff0000;
    private int SeleColor = 65280;
    private int OuterColor = 0xffffff;
    private int HintColor = 0x2200ff;
    private int TimeColor = 65280;
    private Player player;
    private VolumeControl vc;
    private byte bs_error[];
    private byte bs_clear[];
    private byte bs_shuffle[];
    private byte bs_global[];
    private String s_win;
    private String s_gameover;
    private int SoundVolume = 100;
    public Image SoundImages[];
    private int round = 1;
    private int Score = 0;
    private int ScoreColor = 0x7777ff;
    private LLKMIDlet midlet;
    private MainMenu mainmenu;
    private int RestShuffle = 4;
    private int RestHint = 6;
    private int TimeLeft;
    private int TimeTotal = 360;
    private int TimeWidth = 60;
    private TimerTask timertask;
    private Timer timer;
    public int level = 0;
    public boolean isPaused = false;
    public boolean isEnded = false;
    public Image images[];
    public Image HintImage;
    public Image ShuffleImage;
    public Image PauseImage;
    private LLKMatrix matrix;
    private GameWinCanvas gamewin;
    public LLKCanvas(LLKMIDlet midlet, MainMenu mainmenu, int lvl)
    {
        super(false);
        timertask = new TimerTask(this);
        timer = new Timer();
        setFullScreenMode(true);
        CanvasHeight = getHeight();
        this.midlet = midlet;
        this.mainmenu = mainmenu;
        level = lvl;
        VCount = VCounts[level];
        SeedCount = SeedCounts[level];
        init();
        matrix = new LLKMatrix(HCount, VCount, SeedCount);
        TimeLeft = TimeTotal;
        timer.schedule(timertask, 0L, 1000L);
    }
    private void init()
    {
        bs_error = new byte[8470];
        bs_clear = new byte[8470];
        bs_shuffle = new byte[8470];
        bs_global = new byte[20000];
        try
        {
            InputStream is = getClass().getResourceAsStream("/1.wav");
            is.read(bs_clear);
            is.close();
            is = getClass().getResourceAsStream("/3.wav");
            is.read(bs_error);
            is.close();
            is = getClass().getResourceAsStream("/5.wav");
            is.read(bs_shuffle);
            is.close();
            s_gameover = "/6.wav";
            s_win = "/2.wav";
        }
        catch (Exception pe)
        {
            pe.printStackTrace();
        }
        images = new Image[SeedCount];
        try
        {
            Image img = Image.createImage("/figures.png");
            for (int i = 1; i <= SeedCount; i++)
            {
                images[i - 1] = Image.createImage(HSize - 2, VSize - 2);
                Graphics g = images[i - 1].getGraphics();
                g.drawImage(img, (1-i) * (HSize - 2), 0, 0);
            }
        }
        catch (Exception ee)
        {
            ee.printStackTrace();
        }
        SoundImages = new Image[5];
        for (int i = 0; i <= 4; i++)
        {
            try
            {
                SoundImages[i] = Image.createImage("/sound" + i + ".png");
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        try
        {
            HintImage = Image.createImage("/Hint.png");
            ShuffleImage = Image.createImage("/Shuffle.png");
            PauseImage = Image.createImage("/pause.png");
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    public void TimeDown()
    {

        if (isPaused)
        {
            return ;
        }
        TimeLeft--;
        if (TimeLeft <= 0)
        {
            timer.cancel();
            GameEnd();
        }
        repaint();
    }
    private void plays(String s)
    {
        try
        {
            InputStream is = getClass().getResourceAsStream(s);
            is.read(bs_global);
            is.close();
            playbs(bs_global);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    private void playbs(byte bs[])
    {
        if (SoundVolume == 0)
        {
            return ;
        }
        try
        {
            if (player != null)
            {
                player.close();
            }
            ByteArrayInputStream bis = new ByteArrayInputStream(bs);
            player = Manager.createPlayer(bis, "audio/x-wav");
            player.realize();
            vc = (VolumeControl)player.getControl("VolumeControl");
            vc.setLevel(SoundVolume);
            player.start();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    public void GameEnd()
    {
  
        timertask.cancel();
        isEnded = true;
        repaint();
    }

    public void goMainMenu()
    {

        if (gamewin != null)
        {
            gamewin.stop();
        }
        gamewin = null;
        Display.getDisplay(midlet).setCurrent(mainmenu);
    }
    private void Success()
    {
        isPaused = true;
        round++;
        plays(s_win);
        if (round >= 13)
        {

            timer.cancel();
            if (gamewin == null)
            {
                gamewin = new GameWinCanvas(this, level);
            }
            Display.getDisplay(midlet).setCurrent(gamewin);
            gamewin.start();
        }
        RestShuffle++;
        RestHint++;
        matrix.initMatrix(HCount, VCount);
        TimeLeft = TimeTotal;
        isPaused = false;
    }
    private void ShowHint()
    {
        int i = matrix.find();
        if (i > 0)
        { 
            X1 = (i / 1000) % HCount;
            Y1 = (i /1000) / HCount;
            X2 = i % 1000 % HCount;
            Y2 = (i % 1000) / HCount;
        }
    }
    protected void keyRepeated(int keyCode)
    {
        int j = getGameAction(keyCode);
        switch (j)
        {
            case 1:
            case 2:
            case 5:
            case 6:
                keyPressed(keyCode);
            case 3:
            case 4:
            default:
                return ;
        }
    }
    public void goPause()
    {
        isPaused = true;
        repaint();
    }
    public void goActive(boolean resume)
    {
        isPaused = !resume;
        repaint();
    }
    public void keyPressed(int keyCode)
    {
        if (isPaused)
        {
            if (getGameAction(keyCode) == 8)
            {
                goActive(true);
            }
            return ;
        }
        switch (keyCode)
        {
            default:
                break;
            case 48:
                
                if (HASTEST)
                {
                    round = 12;
                    Success();
                }
                break;
            case 49:
               
                if (HASTEST)
                {
                    GameEnd();
                }
                break;
            case 42:
             
                goPause();
                break;
            case 35:
                
                if (X1 >= 0)
                {
                    break;
                }
                if (RestHint > 0)
                {
                    ShowHint();
                    RestHint--;
                }
                repaint();
                break;
            case 57:
                
                if (RestShuffle > 0)
                {
                    do
                    {
                        matrix.shuffleMatrix();
                    }
                    while (matrix.find() == 0);
                    RestShuffle--;
                    matrix.rearrange(round)
                        ;
                    playbs(bs_shuffle);
                }
                repaint();
                break;
            case 55:
               
                SoundVolume = SoundVolume - 25;
                if (SoundVolume < 0)
                {
                    SoundVolume = 100;
                }
                repaint();
                break;
        }
        keyCode = getGameAction(keyCode);
        switch (keyCode)
        {
            case 3:
               
            case 4:
            case 7:
            case 8:
              
                if (isEnded)
                {
                    goMainMenu();
                    return ;
                }
                if (matrix.getAt(X, Y) >= 0)
                {
                    int j;
                    if (XX == X && YY == Y)
                    {
                        XX =  - 1;
                        YY =  - 1;
                    }
                    else
                    if (XX < 0 || YY < 0)
                    {
                        XX = X;
                        YY = Y;
                        playbs(bs_error);
                    }
                    else
                    if ((j = matrix.judge(X, Y, XX, YY, true)) > 0)
                    {
                        Score += j;
                        repaint();
                        serviceRepaints();
                        j = 0;
                        playbs(bs_clear);
                        if (SoundVolume == 0)
                        {
                            for (int i = 0; i < 0x3ffff; i++)
                            {
                                j++;
                            }
                        }
                        matrix.setAt(X, Y,  - 1);
                        matrix.setAt(XX, YY,  - 1);
                        if (X == X1 + 1 && Y == Y1 + 1 || X == X2 + 1 && Y ==
                            Y2 + 1 || XX == X1 + 1 && YY == Y1 + 1 || XX == X2
                            + 1 && YY == Y2 + 1)