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;
}
}