亚洲AV无码之日韩精品,亚洲欧洲AV无码专区,亚洲高清中文字幕免费

J2ME�|�络�E�序中判断一�ơ数据发送的�l�束

�|�明 — Sun, 19 Mar 2006 13:30:00 GMT

如果服务器发来的字节��没有作��M��标记�Q�只是在发完一�ơ数据后flush()�Q�则在客��L��可以用inputStream.available()来判断流的长度，但一定要在调用read()臛_��一�ơ之后，不然��只能得到零倹{�?br />
如下代码所�C�：

//��接收到的数据存到字节数�l�array
int firstChar = inputStream.read();
int length = inputStream.available();
byte[] array = new byte[length+1];
array[0] = (byte)firstChar;
inputStream.read(array,1,length);

�|�明 2006-03-19 21:30 发表评论

J2ME Tutorial, Part 3: 探究MIDP 2.0的游戏API(�?

�|�明 — Fri, 16 Dec 2005 11:58:00 GMT

构徏J2ME游戏�Q�用TiledLayer构造背�?/b>

在这一节中�Q�我们要使用TiledLayer�c�Mؓ游戏��d��一个背景。游戏界面分��Z��个区域：�剙��表示天空�Q�couple��精灉|��在的中部是地面，底部是大��每个区域分别��用一�?2*32像素的不同颜色图片进行填充，填充的工作由TiledLayer�c�d��成�?br />
首先��屏�q�分�?2*32的小�Ҏ��Q�行和列的烦引都�?开始，如图4�?br />

           �?4. 均匀分割屏幕

(0,0)�?1,4)的方��D��C�天�I�，(2,0)�?2,4)表示地面�Q?3,0)�?4,4)表示��面。我们用�?中的囄��填充对应�Ҏ��?br />

�?5. 背景囄��

背景囄��的第一部分(32*32)表示地面�Q�第二部分表�C�大��P��W�三部分表示天空。��用TiledLayer�Ӟ��囄��的烦引是�?开始的�Q�不�?�Q�所以地面图像的位置�?�Q�大��h��2�Q�天�I�是3�Q�。TiledLayer�c�d��以将�?分割成三张图片，然后用每张图片填充对应的�Ҏ��。在�q�里�Q�我们用三个 32*32大小囄��填充5�?列的背景�Q�部分代码如下：

// 加蝲囄��
backgroundImg = Image.createImage("/tiledLayer1.gif");

// 创徏TiledLayer背景
background = new TiledLayer(5, 5, backgroundImg, 32, 32);

TiledLayer构造器的前两个参数表示背景大小�Q�第三个是图像，最后两个是每个格子的长和宽。TiledLayer�c�d��Ҏ��格子的大��切割图像，然后攑ֈ�背景的对应方��g��?br />
最后剩下的��是讄��每个�Ҏ��里放�|�的囑փ�了。创��景的所有代码都在createBackground()�Ҏ��里，如下所�C�。在MyGameCanvas �cȝ��start()里调用这个方法，然后在buildGameScreen()�Ҏ��的最后添加background.paint(g)�Q�这使得 TiledLayer实例��自��q��制到屏幕上�?br />
// 使用TiledLayer创徏背景
private void createBackground() throws IOException
{
    // 加蝲囄��
    backgroundImg = Image.createImage("/tiledLayer1.gif");

    // 创徏tiledLayer背景
    background = new TiledLayer(5, 5, backgroundImg, 32, 32);

    // 布置囑փ�的数�l?/span>
    int[] cells = {
        3, 3, 3, 3, 3,  // 天空
        3, 3, 3, 3, 3,  // 天空
        1, 1, 1, 1, 1,  // 地面
        2, 2, 2, 2, 2,  // 大�v
        2, 2, 2, 2, 2   // 大�v
    };

    // 讄��背景
    for(int i = 0; i < cells.length; i++)
    {
        int column = i % 5;
        int row = (i - column) / 5;
        background.setCell(column, row, cells[i]);
    }

    // 讄��背景位置
    background.setPosition(GAME_ORIGIN_X, GAME_ORIGIN_Y);
}

最�l�效果如�?�?br />

    �?6. ��d��了背景的游戏截屏

原文见：http://today.java.net/pub/a/today/2005/07/07/j2me3.html?page=4

�|�明 2005-12-16 19:58 发表评论

J2ME Tutorial, Part 3: 探究MIDP 2.0的游戏API(�?

�|�明 — Mon, 12 Dec 2005 03:39:00 GMT

原文�? http://today.java.net/pub/a/today/2005/07/07/j2me3.html?page=3

定义游戏的角色和特征

一个只能将囄��左右�U�d��的游戏是没有意思的。我们现在要�Ҏ��?的代码作一些改动，让它变得更有��些。首先我们要定义游戏昄��的边界，�q�样能保证在所有设备上的大��一��_��先定义一些常量，如下代码所�C�：

//游戏边界
public static final int GAME_WIDTH = 160;
public static final int GAME_HEIGHT = 160;

// 游戏屏幕的原点坐标（左上角）
public final int GAME_ORIGIN_X = (getWidth() - GAME_WIDTH) / 2;
public final int GAME_ORIGIN_Y = (getHeight() - GAME_HEIGHT) / 2;

// couple��精灵上下区域的高度
public final int SECTION_HEIGHT = 64;

// couple��精灉|��回移动的基准位（base�Q?/SPAN>
public final int BASE = GAME_ORIGIN_Y + GAME_HEIGHT - SECTION_HEIGHT;

// couple��精灵蟩跃的最大高�?/SPAN>
public final int MAX_HEIGHT = 32;

(注意�Q�我们这里引入了一�?EM>游戏特征�Q�couple��精灵很快就可以在屏�q�上跛_��?

在游戏屏�q�上定义的这些常量规定了游戏的边界，如图2所�C��?BR>

                        �?2. 用常量定义游戏边�?BR>
当然�Q�我们现在需要修改代码来使用�q�些帔R��。在清单1的代码中��d��一个buildGameScreen(Graphics g)�Ҏ��Q�如下代码所�C�：

private void buildGameScreen(Graphics g)
{
    // 讄��ȝ��为黑�?/SPAN>
    g.setColor(0x000000);

    // �l�制游戏边界
    g.drawRect(GAME_ORIGIN_X, GAME_ORIGIN_Y, GAME_WIDTH, GAME_HEIGHT);

    // �l�制基准�U?/SPAN>
    g.drawLine(GAME_ORIGIN_X, BASE, GAME_ORIGIN_X + GAME_WIDTH, BASE);

    //标出couple��精灵能跛_��的最高位�|?/SPAN>
    g.drawLine(GAME_ORIGIN_X, BASE - MAX_HEIGHT, GAME_ORIGIN_X + GAME_WIDTH, BASE - MAX_HEIGHT);
}

再在updateGameScreen()�Ҏ��里绘制couple之前��d��一个该�Ҏ��的调用，�q�要��couple��精�늚�开始位�|�由CENTER_Y改�ؓBASE�Q�在start()�Ҏ��里设�|�coupleY = BASE�Q��?/P>
couple��精灵可以左右移动，我们要限制它走出边界�Q�更改calculateCoupleX()�Ҏ��里左右移动的代码�Q�避免坐标超��界。修改后的代码如下：

private void calculateCoupleX(int keyState)
{
    // �Ҏ��U�d��方向改变x坐标
    if((keyState & LEFT_PRESSED) != 0)
    {
        coupleX = Math.max(
            GAME_ORIGIN_X + coupleImg.getWidth() / 2,
            coupleX - dx);
    }
    else if((keyState & RIGHT_PRESSED) != 0)
    {
        coupleX = Math.min(
            GAME_ORIGIN_X + GAME_WIDTH - coupleImg.getWidth() / 2,
            coupleX + dx);
    }
}

�Ҏ��使用Math.max()和min()函数使图片显�C�在游戏边界内。注意我们在计算中还考虑了图片的大小�?/P>
我们刚才说过要实现couple��精灵在屏幕上蟩跃的功能�Q�我们现在增加一个方法��囄��在Y轴上�U�d��Q�蟩跃时�U�d��的具体�\径将不受玩家影响�?/P>
在清�?的代码中��d��三个新的实例变量�Q�up、jumpHeight 和random。如下所�C�：

// 表示couple��精�늧�动方向的标识
private boolean up = true;

// 跌��高度�Q�蟩跃时随机生成
private int jumpHeight = MAX_HEIGHT;

// 随机��C�生器
public Random random = new Random();

jumpHeight初始��D��设�ؓMAX_HEIGHT。jumpHeight变量会在couple��精灉|��ơ蟩跃时动态设为随机��|��新增的calculateCoupleY()�Ҏ��如下�Q?/P>
private void calculateCoupleY(int keyState)
{
    // ��查couple��精灉|��否在跌��
    if(up)
    {
        // ��查小�_��是否跛_��了最大高�?/SPAN>
        if((coupleY > (BASE - jumpHeight + coupleImg.getHeight())))
        {
            //没达到最大高度，�l�箋上升
            coupleY -= dy;
        }
        else if(coupleY == (BASE - jumpHeight + coupleImg.getHeight()))
        {
            // ��C��最大高度，开始下�?/SPAN>
            coupleY += dy;

            // 修改方向标识
            up = false;
        }
    }
    else
    {
        // ��精灉|��在下降，��查是否到地面了？
        if(coupleY < BASE)
        {
            // �q�没有，�l�箋下降
            coupleY += dy;
        }
        else if(coupleY == BASE)
        {
            // 到达地面�Q�算一个新的随机高度（��于�{�于最大高度）
            int hyper = random.nextInt(MAX_HEIGHT + 1);

            // 保证跌��高度大于囑փ�高度
            if(hyper > coupleImg.getHeight())
            {
                jumpHeight = hyper;
            }

            // 往上蟩
            coupleY -= dy;

            // 重置方向标识
            up = true;
        }
    }
}

你可能已�l�发觉，�q�个�Ҏ��不依赖于用户的按键，传入的keyState信息也没有用到。传入这个值是��Z��与calculateCoupleX()�Ҏ��保持一致。方法刚开始时通过渐增coupleY变量��g��couple��精灵上升，直到辑ֈ��q�次的蟩跃高度（刚开始是MAX_HEIGHT�Q�。达到这个高度后�Q�小�_��开始往下降�Q�降到BASE后又随机生成一个介于MAX_HEIGHT和图像高度之间的数��|��按这个高度开始下一�ơ蟩跃�?/P>
游戏的整个效果是一个以随机高度跌��的couple��精灵，它可以在用户的操�U�下左右�U�d��。图3是游戏的一个截屏：

                   �?3. 游戏截屏

�|�明 2005-12-12 11:39 发表评论

J2ME Tutorial, Part 3: 探究MIDP 2.0的游戏API(�?

�|�明 — Thu, 08 Dec 2005 10:01:00 GMT

原文见：http://today.java.net/pub/a/today/2005/07/07/j2me3.html?page=2

构徏一个J2ME游戏�Q�从GameCanvas�c�d��?/STRONG>

GameCanvas�cȝ��承自Canvas�Q�提供了一个屏�q�后端的�~�冲区，所有的�l�制操作都先在这个缓冲区里进行。当所有绘制操作完成后�Q�我们调用flushGraphics()�Ҏ��缓冲区内容输出到屏�q�。这�U�双�~�冲机制可以使图像的�U�d��更加�q�x��Q�避免图像的闪烁。缓冲区大小�{�于屏幕的大��，而且每一个GameCanvas实例有且仅有一个缓冲区�?/P>
GameCanvas�c�L��供一�U�存储按键状态的机制�Q�我们可以通过它方便的了解用户与游戏的交互。这�U�机制可以跟�t�用��h��Ҏ��键的�ơ数�Q�调用getKeyStates()�Ҏ��q�回所有游戏键按键状态的二进制表�C�，1代表上次调用�Ҏ��后按�q�该键，0表示上次调用后还没有按过该键。我们可以跟�t�的游戏状态有�Q�这里的键都是在Canvas�c�里定义的）�Q�DOWN_PRESSED, UP_PRESSED, RIGHT_PRESSED, LEFT_PRESSED, FIRE_PRESSED, GAME_A_PRESSED, GAME_B_PRESSED, GAME_C_PRESSED和GAME_D_PRESSED�?/P>
首先扩展GameCanvas�c�，定制一个游戏画布，代码见清�?。清�?是运行例子的MIDlet�?BR>

package com.j2me.part3;

import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.Display;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.game.GameCanvas;

import java.io.IOException;

public class MyGameCanvas
    extends GameCanvas
    implements Runnable
{
    public MyGameCanvas()
    {
        super(true);
    }

    public void start()
    {
        try
        {
            //导入couple囄��Q�坐标定位在屏幕中央
            coupleImg = Image.createImage("/couple.gif");
            coupleX = CENTER_X;
            coupleY = CENTER_Y;
        }
        catch(IOException ioex)
        {
            System.err.println(ioex);
        }

        Thread runner = new Thread(this);
        runner.start();
    }

    public void run()
    {
        //获取��d��的graphics对象
        Graphics g = getGraphics();

        while(true) //无穷循环
        {
            //��Z��上一个代码清单列出的�l�构

            //首先��查游戏状�?/SPAN>
            verifyGameState();

            //��查用戯��?/SPAN>
            checkUserInput();

            //更新屏幕
            updateGameScreen(getGraphics());

            //休息一下，控制��h��频率
            try
            {
                Thread.currentThread().sleep(30);
            }
            catch(Exception e)
            {}
        }
    }

    private void verifyGameState()
    {
        //现在先不做�Q何操�?/SPAN>
    }

    private void checkUserInput()
    {
        //获取按键信息
        int keyState = getKeyStates();

        //计算x轴位�|?/SPAN>
        calculateCoupleX(keyState);
    }

    private void updateGameScreen(Graphics g)
    {
        //清空屏幕背景
        g.setColor(0xffffff);
        g.fillRect(0, 0, getWidth(), getHeight());

        //��couple囄��l�制到当前坐标位�|?/SPAN>
        g.drawImage(
            coupleImg, coupleX, coupleY, Graphics.HCENTER |
            Graphics.BOTTOM);

        flushGraphics();
    }

    private void calculateCoupleX(int keyState)
    {
        //判断�U�d��方向
        if((keyState & LEFT_PRESSED) != 0)
        {
            coupleX -= dx;
        }
        else if((keyState & RIGHT_PRESSED) != 0)
        {
            coupleX += dx;
        }
    }

    private Image coupleImg;
    private int coupleX;
    private int coupleY;
    private int dx = 1; //�U�d��?BR>
    //屏幕中心
    public final int CENTER_X = getWidth() / 2;
    public final int CENTER_Y = getHeight() / 2;
}

清单 1. MyGameCanvas�Q�游戏画布的�W�一个版�?/P>
清单 2 是��用这个游戏画布的MIDlet:

package com.j2me.part3;

import javax.microedition.lcdui.Display;
import javax.microedition.midlet.MIDlet;

public class GameMIDlet extends MIDlet
{
    MyGameCanvas gCanvas;

    public GameMIDlet()
    {
        gCanvas = new MyGameCanvas();
    }

    public void startApp()
    {
        Display d = Display.getDisplay(this);
        gCanvas.start();

        d.setCurrent(gCanvas);
    }

    public void pauseApp()
    {}

    public void destroyApp(boolean unconditional)
    {}
}

清单 2. �q�行游戏�C�Z��的MIDlet�c?/P>
使用Wireless工具建立一个工�E�，导入�q�两个类�Q�然后生成�ƈ�q�行工程。确保你的工�E�目录res中有�q�个囄��文�g�Q��ƈ保证名称为couple.gif, �?是运行结果�?BR>

�?. 构徏一个游戏：使用GameCanvas�c?/P>
使用讑֤�的方向键可以左右�U�d��屏幕中的��图像，�q�是通过从checkUserInput()里取得按键状态，然后调用calculateCoupleX()�Q�通过��按键状态与GameCanvas里预定义的按键��D��行与操作(&)�Q�得到用户当前按的键�Q�然后将实例变量更新�Q�最�l�反映到讑֤�屏幕上�?/P>
囑փ�是在updateGameScreen()�Ҏ��里被�l�制到屏�q�上的。这个方法��用传入的Graphics对象�q�行�l�制�Q�每一个GameCanvas只有一个Graphics对象。方法首先擦除上�ơ绘制的囑փ��Q�然后基于当前的coupleX��|��q�有一直不变的coupleY��|��l�制couple.gif囑փ�,最后将�~�冲区的数据输出到屏�q��?/P>
run()�Ҏ��里的循环体遵循我们刚开始提出的游戏�l�构。��@环每30毫秒��查一�ơ用戯��入�ƈ��h��屏幕。你可以试着��这个值改变一下，�q�会改变��h��的频率�?/P>
最后，注意MyGameCanvas的构造器里调用了父类GameCanvas的构造方法，传入的参��Cؓtrue�Q�这表示从Canvas�cȝ��承的按键事�g机制被抑制了�Q�因为我们的代码不需要这些通知机制。我们的游戏状态用GameCanvas里自带的按键信息�Q�由getKeyStates()�Ҏ��取得�Q�来处理已经��_��了。通过抑制“keyPressed”、“keyReleased”和“keyRepeated”等通知机制�Q�可以提高游戏的性能�?/P>

�|�明 2005-12-08 18:01 发表评论

J2ME Tutorial, Part 3: 探究MIDP 2.0的游戏API (一)

�|�明 — Wed, 07 Dec 2005 12:40:00 GMT

原文见：http://today.java.net/pub/a/today/2005/07/07/j2me3.html

J2ME是一个很��行的用于移动设备游戏开发的�q�_��。J2ME中的MIDP 2.0引入了一个新的API包，它提供了一些定义好的游戏结构，�q�在以前�?.0版中要通过很多累赘代码来实现。在�q�部分tutorial中，我们会学习这个API包，然后用它开发一个小游戏�Q��ؓ了学习需要，我们会用到包中所有的�c�）。这个包是javax.microedition.lcdui.game. 它的建立��Z��我们前两�ơ学的J2ME概念�?/P>
J2ME游戏API�Q�摘�?/STRONG>
javax.microedition.lcdui.game包只�?个类�Q�GameCanvas, Layer, Sprite, TiledLayer和LayerManager. �q?个类提供了开发各�U�游戏应用的�q�_��?/P>
Layer�?STRONG>Sprite�?STRONG>TiledLayer的父�c�R��这个类��装了游戏中可视化元素的行�ؓ。可视化元素可以是小�_��Q�sprite�Q?代表一个可以在屏幕上来回移动的独立囑�Ş�Q�或�l�成动画的一�l�图形）�Q?BR>或是一个背景层�Q�通过很少的图片，��可以生成庞大游戏中的背景。我们可以用Layer来布�|�图形和�q�行可视化操作。Layer的子�c�通过重写paint(Graphics g)�Ҏ��元素绘制到屏幕上�?/P>
LayerManager�c�d��以控制各层的�l�制及绘刉��序，因此我们可以更方便地��理游戏中的可视化元素（包括��精灵和背景层）�?/P>
GameCanvas�c�L��展了上两节我们讲�q�的Canvas�c�（��d��Q�，提供一个在屏幕后端�q�行(off-screen)的缓冲区�Q�所有绘制操作都先在�q�个�~�冲��Z��q�行�Q�然后再昄��到屏�q�。它�q�提供了得到用户按键信息的快��h��法�?/P>
最好的学习�Ҏ��应该是写一个完整的��游戏，通过�q�个��游戏我们可以了解游戏制作的�Ҏ��面面。我们在介绍完这个小游戏的构造后�Q�针对目前还没有游戏开发经验的�Q�，会在开发游戏的�q�程中具体介�l�包中的每个�c�R�?/P>
构徏游戏的简短入�?

游戏和动��L��建立在重复执行某�D�代码的机制上的。这�D�代码跟�t�实例变量的��|��然后更新相应状态。基于当前游戏状态，代码��游戏元素绘制到屏幕上。实例变量值是随着用户交互和游戏内部行��改变的�?/P>
代码的重复执行是通过��这�D�代码放入��@环中实现的。在�q�入循环前，先检查一下实例变量，看是否要�l�箋游戏�Q�否则退出��@环。�ؓ了控制实例变量的更新频率�Q�其实是屏幕��h��的频率）�Q��@环体中的代码应该每次休眠一�D�|��_��毫秒计）�?/P>
游戏的结构如下列代码所�C�：

// �ȝ��
public class MainClass
{
  private GameCanvas canvas = new MyGameCanvas();

  public MainClass()
  {
    // 开始一个线�E?/SPAN>
    canvas.start();
  }

  // 其他代码
}

// 实际�q�行�l�制的类
public class MyGameCanvas extends GameCanvas implements Runnable
{
  public MyGameCanvas()
  {
    // 初始�?/SPAN>
  }

  public void start()
  {
    // 初始�?BR>
    // 执行�l�制�U�程
    Thread runner = new Thread(this);
    runner.start();
  }

  private void run()
  {

    // 或者��?keeprunning = true)
    // keeprunning是一个控制游戏状态的实例变量

    while(true)
    {

      // ��查游戏是否达�?nbsp;
      // 某个边界值或�Ҏ��条�g

      verifyGameState();

      // 从用户那里得到输入，然后更新描述游戏元素状态的变量�?nbsp;

        checkUserInput();

      // 使用Graphics对象��当前游戏状态绘制到屏幕�?/SPAN>

      updateGameScreen(getGraphics());

      // 控制屏幕更新的频�?nbsp;

      Thread.sleep(milliseconds);
    }
  }
}

我们��在以下几节中��用这个结构来开发一个游戏�?/P>

�|�明 2005-12-07 20:40 发表评论