亲宝软件园·资讯

展开

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

陈小缘 人气:0
想了解SurfaceView开发[捉小猪]手机游戏 (二)的相关内容吗,陈小缘在本文为您仔细讲解SurfaceView游戏的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:SurfaceView游戏,Android手机游戏,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/

加载全部内容

相关教程
猜你喜欢
用户评论