SurfaceView开发[捉小猪]手机游戏 (二)

我们在上一回(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/

到此这篇关于SurfaceView开发[捉小猪]手机游戏 (二)的文章就介绍到这了,更多相关SurfaceView游戏内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！