LGame-0.2.9版二次修正(LGame-0.2.95，新增塔防示例，已提供下载)

2011-02-01

http://loon-simple.googlecode.com/files/LGame-0.2.95%28Graphics%20Optimization%29.7z

农历新年前做一个额外更新，此文件中附带了目前最新的LGame打包jar及源码（累计不足15行代码的小修正），主要修正了一个对于Android环境来说不合理的图像刷新方法（JavaSE版无此问题），此修正能让标准Screen（即最基础的，自动刷新模式的那个Screen） 显示速度获得约3 ~ 7 fps 的上升（视真机而定）。

另外，此次附带的最新LGame-Core-0.2.95(指Android与JavaSE两版)基本等价于0.3版LGame主体（剩下那0.5是独立的SLG模块，以及一个webview的内部封装），非必要不会再有变动，至多会改进一些旧有的低效实现，添加两三个新的ActionEvent。当然，假如获得新的BUG反馈小弟也会及时修正。

最后，祝愿大家农历新年快乐，宏“兔”大展，万事如意～

PS:有网友要下面这个塔防示例的JavaSE版，小弟这次也顺便加上了（源码在jar中），解压后可以看到代码除输入接口API及启动程序部分外与Android版完全一致。



_________________________________________

下载地址(内含示例，源码及jar):

http://loon-simple.googlecode.com/files/LGame-0.2.95.7z

此版继续修正0.2.9版(及0.2.94)中所发现的问题并有所扩展。

为Screen增加了runFirstScreen、runLastScreen、runPreviousScreen、runNextScreen、runIndexScreen、addScreen、getScreens、getScreenCount等Screen管理接口，以简化多Screen运行时的处理流程。

增加ActionEvent管理器，并提供了MoveTo、FireTo、JumpTo、FadeTo、RotateTo、CircleTo等自动化事件类，它们是对常用角色行为的封装(就是处理一些固定的事件执行，比如用MoveTo随便指定一个坐标就可以让角色八方向或四方向行走到该处，用FireTo可以直接让角色向指定位置如子弹一样发射出去，以此类推)，具体使用方式可见下例。

修正了所有获得用户反馈的前版BUG（准确的说，是小弟上上周来博客所看到的那些……），对一些函数的具体实现有所改进。

下面有一个非常简单的塔防示例，演示了LGame-0.2.95改进后的Layer及新增的ActionEvent机制使用。



示例代码如下（直接拖拽Layer即可显示不同区域画面）：

package org.loon.test;
import java.util.HashMap;
import java.util.List;
import org.loon.framework.android.game.action.ActionListener;
import org.loon.framework.android.game.action.FadeTo;
import org.loon.framework.android.game.action.MoveTo;
import org.loon.framework.android.game.action.map.Field2D;
import org.loon.framework.android.game.action.sprite.StatusBar;
import org.loon.framework.android.game.core.LSystem;
import org.loon.framework.android.game.core.graphics.LColor;
import org.loon.framework.android.game.core.graphics.LImage;
import org.loon.framework.android.game.core.graphics.Screen;
import org.loon.framework.android.game.core.graphics.device.LGraphics;
import org.loon.framework.android.game.core.graphics.window.LPaper;
import org.loon.framework.android.game.core.graphics.window.actor.Actor;
import org.loon.framework.android.game.core.graphics.window.actor.ActorLayer;
import org.loon.framework.android.game.core.graphics.window.actor.Layer;
import android.view.MotionEvent;
public class TD extends Screen {
private int selectTurret = -1;
private Field2D field;
private String[] turrets = new String[] { "assets/bulletTurret.png",
"assets/bombTurret.png", "assets/poisonTurret.png",
"assets/laserTurret.png", "assets/bullet.png" };
/**
* 子弹用类
*
*/
class Bullet extends Actor {
private int dir;
private int damage;
private double x, y;
private boolean removeFlag;
public Bullet(String fileName, int dir, int damage) {
this.dir = dir;
this.damage = damage;
this.setImage(fileName);
this.setDelay(50);
}
protected void addLayer(ActorLayer layer) {
this.x = this.getX();
this.y = this.getY();
}
public void action(long t) {
if (removeFlag) {
return;
}
Object o = null;
for (int i = 0; i < 12; i++) {
// 矫正弹道位置
double angle = Math.toRadians((double) this.dir);
this.x += Math.cos(angle);
this.y += Math.sin(angle);
this.setLocation((int) this.x
+ (field.getTileWidth() - this.getWidth()) / 2,
(int) this.y
+ (field.getTileHeight() - this.getHeight())
/ 2);
o = this.getOnlyCollisionObject(Enemy.class);
}
// 当与敌相撞时
if (o != null) {
Enemy e = (Enemy) o;
// 减少敌方HP
e.hp -= this.damage;
e.hpBar.setUpdate(e.hp);
removeFlag = true;
// 从Layer中删除自身
getLayer().removeObject(this);
return;
// 超出游戏画面时删除自身
} else if (this.getX() <= 12
|| this.getX() >= this.getLayer().getWidth() - 96
|| this.getY() <= 12
|| this.getY() >= this.getLayer().getHeight() - 96) {
removeFlag = true;
this.getLayer().removeObject(this);
}
}
}
/**
* 炮塔用类
*
*/
class Turret extends Actor {
private int range = 50;
private int delay = 10;
boolean selected;
public Turret(String fileName) {
setImage(fileName);
setDelay(100);
setAlpha(0);
}
public void addLayer(ActorLayer layer) {
// 让角色渐进式出现
FadeTo fade = fadeOut();
// 监听渐进淡出事件
fade.setActionListener(new ActionListener() {
public void process(Actor o) {
}
public void start(Actor o) {
}
// 当渐进完毕时
public void stop(Actor o) {
// 旋转90度
rotateTo(90);
}
});
}
public void draw(LGraphics g) {
if (selected) {
g.setColor(255, 0, 0, 100);
g.fillOval(-(range*2-field.getTileWidth())/2, -(range*2-field.getTileHeight())/2, this.range * 2 - 1, this.range * 2 - 1);
g.setColor(LColor.red);
g.drawOval(-(range*2-field.getTileWidth())/2,-(range*2-field.getTileHeight())/2, this.range * 2 - 1, this.range * 2 - 1);
}
}
public void action(long t) {
// 遍历指定半径内所有Enemy类
List<?> es = this.getCollisionObjects(this.range, Enemy.class);
// 当敌人存在
if (!es.isEmpty()) {
Enemy target = (Enemy) es.get(0);
// 旋转炮台对准Enemy坐标
setRotation((int) Math.toDegrees(Math.atan2(
(target.getY() - this.getY()), (target.getX() - this
.getX()))));
}
// 延迟炮击
if (this.delay > 0) {
--this.delay;
} else if (!es.isEmpty()) {
// 构造炮弹
Bullet bullet = new Bullet(turrets[4], this.getRotation(), 2);
// 计算炮击点
int x = (int) Math.round(Math.cos(Math.toRadians(this
.getRotation()))
* (double) bullet.getWidth() * 2)
+ this.getX();
int y = (int) Math.round(Math.sin(Math.toRadians(this
.getRotation()))
* (double) bullet.getHeight() * 2)
+ this.getY();
// 注入炮弹到Layer
this.getLayer().addObject(bullet, x, y);
this.delay = 10;
}
}
}
/**
* 敌兵用类
*
*/
class Enemy extends Actor {
private int startX, startY;
private int endX, endY;
private int speed, hp;
private boolean removeFlag;
// 使用精灵StatusBar充当血槽
protected StatusBar hpBar;
public Enemy(String fileName, int sx, int sy, int ex, int ey,
int speed, int hp) {
this.setDelay(300);
this.setImage(fileName);
this.hpBar = new StatusBar(hp, hp, -5, 18, 25, 5);
this.startX = sx;
this.startY = sy;
this.endX = ex;
this.endY = ey;
this.speed = speed;
this.hp = hp;
}
public void draw(LGraphics g) {
// 绘制精灵
hpBar.createUI(g);
}
public void action(long t) {
// 触发精灵事件
hpBar.update(t);
if (hp <= 0 && !removeFlag) {
// 设定死亡时渐变
FadeTo fade = fadeIn();
// 渐变时间为30毫秒
fade.setSpeed(30);
// 监听渐变过程
fade.setActionListener(new ActionListener() {
public void process(Actor o) {
}
public void start(Actor o) {
}
public void stop(Actor o) {
Enemy.this.removeActionEvents();
Enemy.this.getLayer().removeObject(Enemy.this);
}
});
this.removeFlag = true;
}
}
// 首次注入Layer时调用此函数
public void addLayer(final ActorLayer layer) {
// 坐标矫正，用以让角色居于瓦片中心
final int offsetX = (getLayer().getField2D().getTileWidth() - this
.getWidth()) / 2;
final int offsetY = (getLayer().getField2D().getTileWidth() - this
.getHeight()) / 2;
// 初始化角色在Layer中坐标
setLocation(startX + offsetX, startY + offsetY);
// 命令角色向指定坐标(参数为false为四方向寻径，为true时八方向)自动移动，并返回移动控制器
// PS:endX与endY非显示位置，所以不必矫正
final MoveTo move = moveTo(endX, endY, false);
// 启动角色事件监听
move.setActionListener(new ActionListener() {
// 截取事件进行中数据
public void process(Actor o) {
// 矫正坐标，让角色居中
o.setLocation(o.getX() + offsetX, o.getY() + offsetY);
// 获得角色移动方向
switch (move.getDirection()) {
case Field2D.TUP:
// 根据当前移动方向，变更角色旋转方向（以下同）
o.setRotation(270);
break;
case Field2D.TLEFT:
o.setRotation(180);
break;
case Field2D.TRIGHT:
o.setRotation(0);
break;
case Field2D.TDOWN:
o.setRotation(90);
break;
default:
break;
}
}
public void start(Actor o) {
}
// 当角色移动完毕时
public void stop(Actor o) {
// 从Layer中删除此角色
layer.removeObject(o);
}
});
// 设定移动速度
move.setSpeed(speed);
}
}
// 起始点
class Begin extends Actor {
public Begin(String fileName) {
setImage(fileName);
}
}
// 结束点
class End extends Actor {
public End(String fileName) {
setImage(fileName);
}
}
/**
* 拖拽用菜单
*
*/
class Menu extends Layer {
public Menu() {
super(128, 240);
// 设定menu层级高于MapLayer
setLayer(101);
// 不锁定menu移动
setLocked(false);
setLimitMove(false);
// 锁定Actor拖拽
setActorDrag(false);
setDelay(500);
// 设定Menu背景
LImage image = LImage.createImage(this.getWidth(),
this.getHeight(), false);
LGraphics g = image.getLGraphics();
g.setColor(LColor.black);
g.fillRect(0, 0, getWidth(), getHeight());
g.setColor(LColor.white);
g.setFont(15);
g.drawString("我是可拖拽菜单", 12, 25);
g.dispose();
setBackground(image);
LPaper bulletTurret = new LPaper(turrets[0]) {
// 当选中当前按钮时，为按钮绘制选中框(以下同)
public void paint(LGraphics g) {
if (selectTurret == 0) {
g.setColor(LColor.red);
g.drawRect(0, 0, this.getWidth() - 2,
this.getHeight() - 2);
}
}
public void downClick() {
selectTurret = 0;
}
};
bulletTurret.setLocation(18, 64);
LPaper bombTurret = new LPaper(turrets[1]) {
public void paint(LGraphics g) {
if (selectTurret == 1) {
g.setColor(LColor.red);
g.drawRect(0, 0, this.getWidth() - 2,
this.getHeight() - 2);
}
}
public void downClick() {
selectTurret = 1;
}
};
bombTurret.setLocation(78, 64);
LPaper poisonTurret = new LPaper(turrets[2]) {
public void paint(LGraphics g) {
if (selectTurret == 2) {
g.setColor(LColor.red);
g.drawRect(0, 0, this.getWidth() - 2,
this.getHeight() - 2);
}
}
public void downClick() {
selectTurret = 2;
}
};
poisonTurret.setLocation(18, 134);
LPaper laserTurret = new LPaper(turrets[3]) {
public void paint(LGraphics g) {
if (selectTurret == 3) {
g.setColor(LColor.red);
g.drawRect(0, 0, this.getWidth() - 2,
this.getHeight() - 2);
}
}
public void downClick() {
selectTurret = 3;
}
};
laserTurret.setLocation(78, 134);
// 用LPaper制作敌人增加按钮
LPaper button = new LPaper("assets/button.png") {
public void paint(LGraphics g) {
g.setColor(LColor.white);
g.drawString("增加敌人", 15, 15);
}
public void downClick() {
// 获得MapLayer
MapLayer layer = (MapLayer) getBottomLayer();
// 开始游戏演算
layer.doStart();
}
};
button.setLocation(27, 196);
// 复合LPaper到Layer
add(bulletTurret);
add(bombTurret);
add(poisonTurret);
add(laserTurret);
add(button);
setAlpha(0.5F);
}
public void downClick(int x, int y) {
selectTurret = -1;
}
}
/**
* 大地图用Layer
*/
class MapLayer extends Layer {
private boolean start;
private int startX, startY, endX, endY;
private int index, count;
@SuppressWarnings("unchecked")
public MapLayer() {
super(576, 480, true);
// 不锁定MapLayer拖拽
setLocked(false);
// 锁定MapLayer中角色拖拽
setActorDrag(false);
// 设置MapLayer背景元素(键值需要与map.txt文件中标识相对应)
HashMap pathMap = new HashMap(10);
pathMap.put(new Integer(0), new LImage("assets/sand.png"));
pathMap.put(new Integer(1), new LImage("assets/sandTurn1.png"));
pathMap.put(new Integer(2), new LImage("assets/sandTurn2.png"));
pathMap.put(new Integer(3), new LImage("assets/sandTurn3.png"));
pathMap.put(new Integer(4), new LImage("assets/sandTurn4.png"));
pathMap.put(new Integer(5), new Begin("assets/base.png"));
pathMap.put(new Integer(6), new End("assets/castle.png"));
// 为Layer加入简单的2D地图背景，瓦片大小32x32，以rock图片铺底
setField2DBackground(new Field2D("assets/map.txt", 32, 32),
pathMap, "assets/rock.png");
TD.this.field = getField2D();
// 敌人出现坐标
this.startX = 64;
this.startY = 416;
// 敌人消失坐标
this.endX = 480;
this.endY = 416;
// 设定MapLayer每隔2秒执行一次内部Action
setDelay(LSystem.SECOND * 2);
}
public void action(long t) {
// 当启动标识为true时执行以下操作
if (start) {
if (index < 3) {
Enemy enemy = null;
// 根据点击next(增加敌人)的次数变换敌人样式
switch (count) {
case 0:
enemy = new Enemy("assets/enemy.png", startX, startY,
endX, endY, 2, 4);
break;
case 1:
enemy = new Enemy("assets/fastEnemy.png", startX,
startY, endX, endY, 4, 6);
break;
case 2:
enemy = new Enemy("assets/smallEnemy.png", startX,
startY, endX, endY, 3, 10);
break;
case 3:
enemy = new Enemy("assets/bigEnemy.png", startX,
startY, endX, endY, 1, 16);
break;
default:
count = 0;
enemy = new Enemy("assets/enemy.png", startX, startY,
endX, endY, 2, 2);
break;
}
addObject(enemy);
index++;
// 否则复位
} else {
start = false;
index = 0;
count++;
}
}
}
private Actor o = null;
public void downClick(int x, int y) {
// 转换鼠标点击区域为数组地图坐标
int newX = x / field.getTileWidth();
int newY = y / field.getTileHeight();
// 当选中炮塔(参数不为-1)且数组地图参数为-1(不可通过)并且无其它角色在此时
if ((o = getOnlyCollisionObjectsAt(x, y)) == null
&& selectTurret != -1 && field.getType(newY, newX) == -1) {
// 添加炮塔
addObject(new Turret(turrets[selectTurret]), newX
* field.getTileWidth(), newY * field.getTileHeight());
}
if (o != null) {
((Turret) o).selected = true;
}
}
public void upClick(int x, int y) {
if (o != null) {
((Turret) o).selected = false;
}
}
public void doStart() {
this.start = true;
}
}
public void onLoad() {
// 构建地图用Layer
MapLayer layer = new MapLayer();
// 居中
centerOn(layer);
// 添加MapLayer到Screen
add(layer);
// 构建菜单用Layer
Menu menu = new Menu();
// 让menu居于屏幕右侧
rightOn(menu);
menu.setY(0);
// 添加menu到Screen
add(menu);
}
public void draw(LGraphics g) {
}
public void onTouchDown(MotionEvent e) {
}
public void onTouchMove(MotionEvent e) {
}
public void onTouchUp(MotionEvent e) {
}
}

运行画面如下所示：







以上已实现部分待0.3版发布时还会有更进一步的改进，不过目前最主要的还是修订SLG模块，另外在0.2.95遇到BUG的话希望大家能吼一声，小弟争取在0.3中全部改好。

下载地址(内含示例，源码及jar):

http://loon-simple.googlecode.com/files/LGame-0.2.95.7z

——————————————

2011-01-27

不好意思让大家久等了，小弟保险起见等Google维护过了才上传（以前吃过一次亏，那次害小弟倒时差的邮件联系了管理员两天，后来变得不见维护结束不踏实|||），此版本是针对LGame-0.2.9的最终修订版，绝大部分0.2.9的BUG在此版中已不复存在（好吧，小弟承认刚才看留言又发现两个漏网BUG，不过对程序主干没有影响，都是一、二行搞定的细节问题，且不是常用项……）。

应该说0.2.95版至少在易用性上又上了一个台阶，不是小弟自夸，单就开发效率和学习难度而言，绝大多数Android游戏引擎都应该从此版起被Loon甩在了后面——包括某些引擎的Android移植版在内。