j2me学习七_翻译教程-牧羊犬游戏3

八．音效实现

SoundEffects class

利用MIDP2.0 的mediaAPI创建犬吠，绵羊叫，还有游戏结束音

1创建SoundEffects类

2.引入类

import javax.microedition.media.*;

import java.io.*;

3.创建参数

class SoundEffects

{

 private static SoundEffects instance;

 private Player sheepSoundPlayer;

 private Player dogSoundPlayer;

4.初始化

 private SoundEffects()

 {

 sheepSoundPlayer = createPlayer("/sheep.wav", "audio/x-wav");

 dogSoundPlayer = createPlayer("/dog.wav", "audio/x-wav");

 }

 static SoundEffects getInstance()

 {

 if (instance == null)

 {

 instance = new SoundEffects();

 }

 return instance;

}

5.创建声音播放方法

 void startSheepSound()

 {

 startPlayer(sheepSoundPlayer);

 }

void startDogSound()

 {

 startPlayer(dogSoundPlayer);

 }

 void startGameOverSound()

 {

 startPlayer(createPlayer("/gameover.mid", "audio/midi"));

 }

void startHighScoreSound()

 {

 startPlayer(createPlayer("/highscore.mid", "audio/midi"));

 }

6.创建音效控制方法

private void startPlayer(Player p)

 {

 if (p != null)

 {

 try

 {

 p.stop();

 p.setMediaTime(0L);

 p.start();

 }

 catch (MediaException me)

 {

 // ignore

 }

 }

}

7.创建createPlayer方法

private Player createPlayer(String filename, String format)

 {

 Player p = null;

 try

 {

 InputStream is = getClass().getResourceAsStream(filename);

 p = Manager.createPlayer(is, format);

 p.prefetch();

 }

 catch (IOException ioe)

 {

 // ignore

 }

 catch (MediaException me)

 {

 // ignore

 }

 return p;

 }

}

九．实现游戏功能

SheepdogCanvas class

1. 创建类

2. 引入类

import java.util.Random;

import java.util.Vector;

import javax.microedition.lcdui.*;

import javax.microedition.lcdui.game.*;

import javax.microedition.media.*;

import java.io.*;

3. SheepdogCanvas类继承GameCanvas类和Runable接口，GameCanvas是Canvas的一个子类，它提供了一些方便的游戏接口，还有一些特殊的游戏特性，例如帧缓冲，按键侦听。

class SheepdogCanvas

 extends GameCanvas

 implements Runnable

{

4. 定义和初始化参数

static final int NONE = -1;

static final int UP = 0;

static final int LEFT = 1;

static final int DOWN = 2;

static final int RIGHT = 3;

private static final int MILLIS_PER_TICK = 50;

private static final int NUM_SHEEP = 5;

private final SheepdogMIDlet midlet;

private final Field field;

private final Sheepdog sheepdog;

private final Vector sheep = new Vector();

private final LayerManager layerManager;

private final Graphics graphics;

private long gameDuration;

private long startTime;

private volatile Thread animationThread = null;

5．创建SheepdogCanvas对象，getGraphic方法用于获得Graphics对象来渲染GameCanvas，LayerManager类用于管理一系列的图层

SheepdogCanvas(SheepdogMIDlet midlet)

{

super(true); // suppress key events for game keys

this.midlet = midlet;

setFullScreenMode(true);

graphics = getGraphics();

layerManager = new LayerManager();

field = new Field();

sheepdog = new Sheepdog(this);

layerManager.append(sheepdog);

for (int i = 0; i < NUM_SHEEP; ++i)

{

Sheep newSheep = new Sheep(this);

layerManager.append(newSheep);

sheep.addElement(newSheep);

}

layerManager.append(field); // last layer, behind sprites

init();

}

6.创建用于按键侦听的方法，如果按了一个负数按键码的按键了，则跳出菜单

public void keyPressed(int keyCode)

{

// The constructor suppresses key events for game keys, so we'll

// only get key events for non-game keys. The number keys, * & #

// have positive keyCodes, so negative keyCodes mean non-game

// special keys like soft-keys. We'll use key-presses on special

// keys to take us to the menu.

if (keyCode < 0)

{

stop();

midlet.sheepdogCanvasMenu();

}

}

7.初见初始化函数，getWidth和getHeight方法用于获得当前画布的宽和高，setPosition方法用于设定层得位置（左上角为基准点）

void init()

{

sheepdog.setPosition(field.getSheepdogStartX(),

field.getSheepdogStartY());

for (int i = 0; i < sheep.size(); ++i)

{

Sheep sh = (Sheep)(sheep.elementAt(i));

// find a valid position for the sheep

do

{

int x = midlet.random(field.getWidth() - Sheep.WIDTH);

int y = midlet.random(field.getHeight() - Sheep.HEIGHT);

sh.setPosition(x, y);

} while (field.containsImpassableArea(sh.getX(),

sh.getY(),

sh.getWidth(),

sh.getHeight()) ||

overlapsSheepdog(sh) ||

overlapsSheep(sh, i) ||

field.inFold(sh));

}

}

8.创建用于开始和终止游戏的方法

public synchronized void start()

{

animationThread = new Thread(this);

animationThread.start();

startTime = System.currentTimeMillis() - gameDuration;

}

public synchronized void stop()

{

gameDuration = System.currentTimeMillis() - startTime;

animationThread = null;

}

9.创建run方法，FlushGraphics方法用于将缓冲区的图像在屏幕上显示

public void run()

{

Thread currentThread = Thread.currentThread();

try

{

// This ends when animationThread is set to null, or when

// it is subsequently set to a new thread; either way, the

// current thread should terminate

while (currentThread == animationThread)

{

long startTime = System.currentTimeMillis();

// Don't advance game or draw if canvas is covered by

// a system screen.

if (isShown())

{

tick();

draw();

flushGraphics();

}

long timeTaken = System.currentTimeMillis() - startTime;

if (timeTaken < MILLIS_PER_TICK)

{

synchronized (this)

{

wait(MILLIS_PER_TICK - timeTaken);

}

}

else

{

currentThread.yield();

}

}

}

catch (InterruptedException e)

{

// won't be thrown

}

}

10.创建用于监视多按键同时按下的情况，用到了getKeyStates方法来获得当前按键情况

private void tick()

{

// If player presses two or more direction buttons, we ignore them

// all. But pressing fire is independent. The code below also ignores

// direction buttons if GAME_A..GAME_D are pressed.

int keyStates = getKeyStates();

boolean bark = (keyStates & FIRE_PRESSED) != 0;

keyStates &= ~FIRE_PRESSED;

int direction = (keyStates == UP_PRESSED) ? UP :

(keyStates == LEFT_PRESSED) ? LEFT:

(keyStates == DOWN_PRESSED) ? DOWN :

(keyStates == RIGHT_PRESSED) ? RIGHT : NONE;

sheepdog.tick(direction, bark);

for (int i = 0; i < sheep.size(); ++i)

{

Sheep sh = (Sheep)(sheep.elementAt(i));

sh.tick();

}

field.tick();

}

11.创建多个方法用于提取对象和控制犬吠

Field getField()

{

return field;

}

Sheepdog getSheepdog()

{

return sheepdog;

}

Vector getSheep()

{

return sheep;

}

void handleDogBark()

{

for (int i = 0; i < sheep.size(); ++i)

{

Sheep sh = (Sheep)(sheep.elementAt(i));

sh.handleDogBark();

}

}

12.创建精灵的碰撞控制方法，一个精灵是一个基本的视觉对象，它储存在一个图像中，并能变化；不同的帧能够显示精灵的运动，一些变换，如旋转，缩放也能应用到精灵上，用于进一步改变他们的显示。collidesWith方法用于检测精灵碰撞。

boolean overlapsSheepdog(Sprite sprite)

{

return sprite.collidesWith(sheepdog, false); // false -> not pixelLevel

}

boolean overlapsSheep(Sprite sprite)

{

return overlapsSheep(sprite, sheep.size());

}

// whether the sprite overlaps the first 'count' sheep

boolean overlapsSheep(Sprite sprite, int count)

{

for (int i = 0; i < count; ++i)

{

Sheep sh = (Sheep)(sheep.elementAt(i));

if (sprite.collidesWith(sh, false)) // false -> not pixelLevel

{

return true;

}

}

return false;

}

boolean overlapsOtherSheep(Sprite sprite)

{

for (int i = 0; i < sheep.size(); ++i)

{

Object obj = sheep.elementAt(i);

if (obj != sprite)

{

Sheep sh = (Sheep)obj;

if (sprite.collidesWith(sh, false)) // false -> not pixelLevel

{

return true;

}

}

}

return false;

}

void vibrate(int millis)

{

midlet.vibrate(millis);

}

13.创建方法用于画出游戏中可视的对象。getX方法获取x值，getY获取y之。

// draw game

private void draw()

{

int width = getWidth();

int height = getHeight();

// clear screen to grey

graphics.setColor(0x00888888);

graphics.fillRect(0, 0, width, height);

// clip and translate to centre

int dx = origin(sheepdog.getX() + sheepdog.getWidth() / 2,

field.getWidth(),

width);

int dy = origin(sheepdog.getY() + sheepdog.getHeight() / 2,

field.getHeight(),

height);

graphics.setClip(dx, dy, field.getWidth(), field.getHeight());

graphics.translate(dx, dy);

The paint method paints this Layer if it is visible.

For more information, see paint in the MIDP 2.0 API specification.

// draw background and sprites

layerManager.paint(g, 0, 0);

// undo clip & translate

graphics.translate(-dx, -dy);

graphics.setClip(0, 0, width, height);

// display time & score

long time = (System.currentTimeMillis() - startTime) / 1000;

int score = numSheepInFold();

graphics.setColor(0x00FFFFFF); // white

graphics.drawString(Integer.toString(score),

1,

1,

Graphics.TOP | Graphics.LEFT);

graphics.drawString(Long.toString(time),

width - 2,

1,

Graphics.TOP | Graphics.RIGHT);

if (score == sheep.size())

{

midlet.sheepdogCanvasGameOver(time);

}

}

14.创建用于计算场景大小的方法

// If the screen is bigger than the field, we center the field

// in the screen. Otherwise we center the screen on the focus, except

// that we don't scroll beyond the edges of the field.

private int origin(int focus, int fieldLength, int screenLength)

{

int origin;

if (screenLength >= fieldLength)

{

origin = (screenLength - fieldLength) / 2;

}

else if (focus <= screenLength / 2)

{

origin = 0;

}

else if (focus >= (fieldLength - screenLength / 2))

{

origin = screenLength - fieldLength;

}

else

{

origin = screenLength / 2 - focus;

}

return origin;

}

15.创建用于计算羊的数目的方法

int numSheepInFold()

{

int count = 0;

for (int i = 0; i < sheep.size(); ++i)

{

Sheep sh = (Sheep)(sheep.elementAt(i));

if (field.inFold(sh))

{

count++;

}

}

return count;

}

}