SurfaceView开发[捉小猪]手机游戏 (二)
时间：2022-04-01 09:44:51 | 栏目：Android代码 | 点击：次
我们在上一回(Android使用SurfaceView开发《捉小猪》小游戏 (一))搞懂了这个模式的基本实现思路,小猪如何找出最短的逃跑路线和如何播放路径动画. 还封装了我们自己的PathAnimation和Drawable。
还差下面树桩出现的效果:
哈哈，记得植物大战僵尸里面有个关卡的道具出现也是这种效果的。
本来做这个效果的时候，想着用一个方便快捷的方法：一个新线程中，不断遍历已出现的树桩，然后判断是否已到达目标位置，如果未到达就直接 x - -
后来发现，用这个方法存在三个问题：
1. 某个任务，假设在配置一般的手机上面运行，需要1秒，那么在一些配置较高的手机上，可能0.2秒就完成了，试想一下我们的这个方法，如果运行在高配置的手机上，那偏移的速度，你懂的。
2. 因为每次只是向左偏移1个像素点，所以在屏幕分辨率较高的手机上面，移动的就会比小屏的手机慢，哈哈，当然了，解决这个问题可以用动态调整偏移量的方法，比如现在在720*1280的手机上面，每次的偏移量是2，那么在1440*2560的手机上面就是4了，这样的话，即使屏幕分辨率相差很远，树桩偏移的时间也差不多是一样的。
3. 还记不记得多线程在单核cpu上面是怎么工作的？哈哈，虽然现在的手机都不是单核的，但是也会出现cpu满载的情况，当cpu比较忙碌时，可能一些优先级比较低的线程，就会得不到照顾。想一下，因为我们用的是每次偏移一定距离的方法，也就是它每偏移一次，都是建立在线程争取到cpu时间片的基础上，才能更新位置，当cpu任务较多时，线程获取到时间片的周期也会变长，周期一长，那么树桩的位置更新，也会变慢。
所以这种方法不可取，那么我们用哪种方法呢？
记不记得我们在上一回中，自己封装了个动画类，动画进度的更新，是根据当前动画已执行时间和动画时长来计算的。
我们也可以用这个方法来做树桩的偏移动画，不过首先，肯定不能每个树桩对应一个线程的，这样无疑会增大cpu的开销，正确的方法应该只开一个线程来控制全部的树桩。
我们来新建一个辅助类PropOffsetHelper:
里面维护一个PropData的list，这个PropData里面有一个我们自定义的drawable, 还有记录上一次更新的时间:
public class PropData {
public MyDrawable drawable;
public long lastUpdateTime;
public PropData(MyDrawable drawable) {
this.drawable = drawable;
lastUpdateTime = SystemClock.uptimeMillis();
}
public void draw(Canvas canvas) {
drawable.draw(canvas);
}
public float getX() {
return drawable.getX();
}
public void setX(float x) {
drawable.setX(x);
}
public float getY() {
return drawable.getY();
}
public void setY(float y) {
drawable.setY(y);
}
public void release() {
if (drawable != null) {
drawable.release();
}
}
@Override
public String toString() {
return String.format(Locale.getDefault(), "%f, %f", drawable.getX(), drawable.getY());
}
}
我们的PropOffsetHelper声明以下成员变量：
private float mPropOffsetSpeed;//树头的移动速度
private MyDrawable mPropDrawable;//树头的图片
private List<PropData> mProps;//全部树头的数据
private List<Integer> mLeavedProps;//已放置的树头(索引)
private float mStartX, mStartY;//树头一开始的位置
private int mPropSize;//树头尺寸
private Future mUpdateTask;//更新位置的线程
private float mLeftOffset;//左边的偏移量
private volatile boolean isNeed;//是否需要更新位置
private long mLastStopTime;//上一次暂停的时间
下面我们来看最重要的方法：
/**
* 开始更新树桩的位置
*/
public void startComputeOffset() {
updatePropGenerateTime();
isNeed = true;
//更新树头位置线程
mUpdateTask = ThreadPool.getInstance().execute(() -> {
boolean isFinished;//树头是否已经到对应的位置
float distance,//需要偏移的路程
offset;//本次更新的偏移量
int hitOffsetCount;//排在该树头前面的,并且已经离队的(已放置),需要忽略距离
long intervalTime,//上次更新与现在的间隔时间
updateTime;//今次更新时间
while (isNeed) {
for (int i = 0; i < mProps.size(); i++) {
PropData prop = mProps.get(i);
//已离队的不需要更新位置
if (mLeavedProps.contains(i)) {
continue;
}
//计算出总距离
distance = i * mPropSize + mLeftOffset;
//离队树桩数量
hitOffsetCount = 0;
for (int j = 0; j < mLeavedProps.size(); j++) {
//检查是否有离队的树头
if (mLeavedProps.get(j) < i) {
hitOffsetCount++;
}
}
//减去已离队的树桩占用的位置，得出真实的位置
distance -= mPropSize * hitOffsetCount;
//树桩的x轴小于或等于实际的偏移距离，则认为已经偏移完成，不需要继续更新位置
isFinished = prop.getX() <= distance;
updateTime = SystemClock.uptimeMillis();
if (!isFinished) {
//计算间隔时间
intervalTime = updateTime - prop.lastUpdateTime;
//路程 = 时间 * 速度
offset = intervalTime * mPropOffsetSpeed;
//更新x轴位置
prop.setX(prop.getX() - offset);
}
//刷新上一次的更新时间
prop.lastUpdateTime = updateTime;
}
}
});
}
/**
* 更新线程停止后又重新开始,需要加上停止的这段时间
*/
private void updatePropGenerateTime() {
if (mLastStopTime > 0) {
//总停止时间 = 当前时间 - 上次更新时间
long totalStoppedTime = SystemClock.uptimeMillis() - mLastStopTime;
mLastStopTime = 0;
for (int i = 0; i < mProps.size(); i++) {
//加上这段时间
mProps.get(i).lastUpdateTime += totalStoppedTime;
}
}
}
这次我们树桩的位置是根据时间来更新的， 这样就算在cpu满载的时候，也不会出现偏移很慢的情况，只是屏幕刷新频率慢了（掉帧）最多只是偏移的动画不是那么流畅而已。
好了，现在我们的准备工作都已经差不多了，下面我们来将它们拼到一起。
我们先看这张图：
有没有发现，一个小格子只能容纳1样东西（小猪或者树桩），如果格子上面已经有东西了的话，再放东西上去，是会自动偏移到离他最近的一个空闲的格子上的。好吧，我们先搞定格子的位置吧：
声明两个二维数组（一个存放格子坐标，一个记录格子状态：小猪占用、树桩占用、空闲）：
private Rect[][] mItems;//矩形二维数组
private volatile int[][] mItemStatus;//用来保存对应的矩形状态(小猪占用,木头占用,空闲)
下面我们来看看怎么初始化格子的坐标：
private void initItems() {
mItems = new Rect[VERTICAL_COUNT][HORIZONTAL_COUNT];
mItemStatus = new int[VERTICAL_COUNT][HORIZONTAL_COUNT];
int currentX, currentY;
int childrenY = (getHeight() - mItemSize * VERTICAL_COUNT - mItemSize) / 2 + mItemSize / 2,
childrenX = (getWidth() - mItemSize * HORIZONTAL_COUNT - mItemSize) / 2 + mItemSize / 2;
//初始化矩形二维数组, 用单双行交错的方式排列
for (int vertical = 0; vertical < VERTICAL_COUNT; vertical++) {
currentY = mItemSize * vertical;
for (int horizontal = 0; horizontal < HORIZONTAL_COUNT; horizontal++) {
//如果行数是双数，则向右偏移半个格子
currentX = mItemSize * horizontal + (vertical % 2 == 0 ? mItemSize / 2 : 0);
Rect rect = new Rect(childrenX + currentX, childrenY + currentY,
childrenX + currentX + mItemSize, childrenY + currentY + mItemSize);
mItems[vertical][horizontal] = rect;
changeItemStatus(vertical, horizontal, Item.STATE_UNSELECTED);
}
}
}
我们现在看到的效果是这样的：
我们放置树桩的时候，肯定不是每次都刚好落到格子的中心点的，所以当手指松开的时候，还要我们去调整一下树桩的位置，好让它刚好落到中心点上，当然了，我们还要判断离它最近的格子上是不是空闲状态，如果不是，那就寻找下一个，直到找到空闲的格子为止。
我们先看看当手指松开后，怎么确定树桩的位置：
还记不记得我们的格子(Rect) 存放在一个二位数组里面？当拖动树桩的手指松开后，我们可以遍历这个二维数组，然后逐个判断event.getX和getY是否在该矩形里面，如果在，那就根据它的坐标来确定树桩的位置了，如果它是不可放置状态(小猪占用或已有树桩) 那就以它为起点寻找下一个空闲的格子，哈哈，这个还是用深度优先遍历来实现：
/**
* 以currentPos为中心点,向周围6个方向查找空闲的位置(广度优先遍历)
* @param items 格子状态
* @param ignorePos 需要忽略的格子
* @param currentPos 起始的格子（以这个格子为起点向四周查找）
* @return 空闲的格子
*/
public static WayData findNextUnSelected(int[][] items, List<WayData> ignorePos, WayData currentPos) {
int verticalCount = items.length;
int horizontalCount = items[0].length;
Queue<WayData> way = new ArrayDeque<>();
int[][] pattern = new int[verticalCount][horizontalCount];
for (int vertical = 0; vertical < verticalCount; vertical++) {
//复制数组(因为要对数组元素值进行修改，且不能影响原来的)
System.arraycopy(items[vertical], 0, pattern[vertical], 0, horizontalCount);
}
way.offer(currentPos);//当前pos先入队
pattern[currentPos.y][currentPos.x] = STATE_WALKED;//状态标记(已走过)
while (!way.isEmpty()) {//队列不为空
WayData header = way.poll();//队头出队
List<WayData> directions = getCanArrivePosUnchecked(pattern, header);//获取周围6个方向的位置(不包括越界的)
//遍历周边的位置
for (int i = 0; i < directions.size(); i++) {
WayData direction = directions.get(i);
//判断该位置是否空闲,如果是空闲则直接返回,如果不是空闲,则入队,下次以它为中心,寻找周边的元素
if (!currentPos.equals(direction) && items[direction.y][direction.x] == Item.STATE_UNSELECTED
&& !(ignorePos != null && ignorePos.contains(direction))) {
return direction;
} else {
way.offer(direction);
}
}
}
//队列直至为空还没返回,则找不到了
return null;
}
我们找到这个空闲的格子之后，更新格子状态，然后再检测当前小猪的路径动画中，是否经过这个格子，如果经过这个格子的话，需要重新找路径(不能在树桩上面走过)：
/**
* 通知有新的树头放下, 有逃跑路径在这个新占用位置上的小猪,都要重新计算新的逃跑路线(旧的已经无效了)
*/
private void positionOccupied(int vertical, int horizontal) {
for (int i = 0; i < PIGGY_COUNT; i++) {
Pig pig = mPiggies[i];
List<WayData> pathData = pig.getPathData();
if (pathData == null || pig.getState() != Pig.STATE_RUNNING) {
continue;
}
int currentIndex = -1;
if (pig.isRepeatAnimation()) {
currentIndex = 0;
} else {
for (int j = 0; j < pathData.size(); j++) {
WayData pos = pig.getPosition();
if (pathData.get(j).equals(pos)) {
currentIndex = j;
break;
}
}
}
if (currentIndex != -1) {
for (int k = currentIndex; k < pathData.size(); k++) {
if (pathData.get(k).x == horizontal && pathData.get(k).y == vertical) {
stopTask(pig);
pig.setState(Pig.STATE_STANDING);
initRunAnimation(pig, true);
break;
}
}
}
}
}
我们再来看一下这张图：
有没有发现，四个格子里面刚好放进了四只小猪，第五只怎么放也放不下，尽管有时候最下面的那个格子没有小猪。
如果小猪的位置不会变，是固定的话，那还好办，但是现在的小猪位置是不断的在变的，而且小猪之间还会重叠，这样一来，如果是直接根据小猪当前位置去判断的话，肯定是不行的，那应该要怎么做呢？
哈哈，看这个：
/**
* 判断当前位置是否能放置树桩或小猪(如果在一个封闭的圈子里面,则连小猪当前位置也要计算)例如:(0表示树头 .表示小猪)
* * * * * * *
* * 0 0 0 * *
* * 0 . . 0 *
* * 0 * 0 * *
* * * 0 0 * *
* * * * * * *
* 计算出来空闲的结果是1,也即是可以放置,如果再多一个小猪在里面,则不可放置
* @param items 格子状态
* @param occupiedPos 小猪们的所在位置
* @param currentPos 起点
* @param result 空闲的格子
* @return 圈子内能否放置
*/
public static boolean isCurrentPositionCanSet(int[][] items, WayData[] occupiedPos, WayData currentPos, List<WayData> result) {
int verticalCount = items.length;
int horizontalCount = items[0].length;
Queue<WayData> way = new ArrayDeque<>();
int[][] pattern = new int[verticalCount][horizontalCount];
for (int vertical = 0; vertical < verticalCount; vertical++) {
//复制数组(因为要对数组元素值进行修改，且不能影响原来的)
System.arraycopy(items[vertical], 0, pattern[vertical], 0, horizontalCount);
}
for (WayData tmp : occupiedPos) {
if (tmp != null) {
//先将小猪们占用的位置标记未未选中
pattern[tmp.y][tmp.x] = Item.STATE_UNSELECTED;
}
}
//以currentPos为起点
way.offer(currentPos);
//标记状态(已走过)
pattern[currentPos.y][currentPos.x] = STATE_WALKED;
if (items[currentPos.y][currentPos.x] != Item.STATE_SELECTED) {
//如果起点也是空闲状态，则算他一个
result.add(currentPos);
}
//开始广度优先遍历
while (!way.isEmpty()) {
//队头出队
WayData header = way.poll();
//寻找周围6个方向可以到达的位置(不包括越界的,标记过的,不是空闲的)也就是空闲的格子
List<WayData> directions = getCanArrivePos(pattern, header);
for (int i = 0; i < directions.size(); i++) {
WayData direction = directions.get(i);
//将这些位置添加进去
result.add(direction);
way.offer(direction);
}
}
int count = 0;
//重点来了
//现在result里面保存的位置，都是忽略了小猪的坐标的，所以现在要重新计算一下
//遍历小猪们当前所在位置，是否在result中，如果在，记录一下
for (WayData tmp : occupiedPos) {
if (tmp != null && result.contains(tmp)) {
count++;
}
}
//最后，如果空闲格子内的小猪数 < 总的空闲格子数，则认为这个圈内还能放得下，反之
return count < result.size();
}
有的小伙伴看完可能就会有疑惑，为什么用List的contains方法判断也可以呢？它们的内存地址可能都不相同的啊，
哈哈，这个，我们先来看一下ArrayList中contains方法是怎么实现的：
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
调用了indexOf方法，那我们再看看indexOf：
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
哈哈，有没有发现，如果我们传进去的对象不为空，那么它就会调用这个对象的equals方法，看到这个方法，我们大多数时候，都是只用来判断字符串是否一样是吧，这个方法在Object类中，是直接返回 this == obj的，那么我们可以在WayData中重写equals方法，然后再判断它们的x和y是否相等就行了，嘻嘻：
@Override
public boolean equals(Object obj) {
return obj instanceof WayData ? x == ((WayData) obj).x && y == ((WayData) obj).y : this == obj;
}
好了，本篇文章到此结束，有错误的地方请指出，谢谢大家！
完整代码地址: https://github.com/wuyr/CatchPiggy
游戏主页: https://wuyr.github.io/