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

    private float mPropOffsetSpeed;//樹頭的移動(dòng)速度
    private MyDrawable mPropDrawable;//樹頭的圖片
    private List<PropData> mProps;//全部樹頭的數(shù)據(jù)
    private List<Integer> mLeavedProps;//已放置的樹頭(索引)
    private float mStartX, mStartY;//樹頭一開始的位置
    private int mPropSize;//樹頭尺寸
    private Future mUpdateTask;//更新位置的線程
    private float mLeftOffset;//左邊的偏移量
    private volatile boolean isNeed;//是否需要更新位置
    private long mLastStopTime;//上一次暫停的時(shí)間

    /**
     * 開始更新樹樁的位置
     */
    public void startComputeOffset() {
        updatePropGenerateTime();
        isNeed = true;
        //更新樹頭位置線程
        mUpdateTask = ThreadPool.getInstance().execute(() -> {
            boolean isFinished;//樹頭是否已經(jīng)到對(duì)應(yīng)的位置
            float distance,//需要偏移的路程
                    offset;//本次更新的偏移量
            int hitOffsetCount;//排在該樹頭前面的,并且已經(jīng)離隊(duì)的(已放置),需要忽略距離
            long intervalTime,//上次更新與現(xiàn)在的間隔時(shí)間
                    updateTime;//今次更新時(shí)間
            while (isNeed) {
                for (int i = 0; i < mProps.size(); i++) {
                    PropData prop = mProps.get(i);
                    //已離隊(duì)的不需要更新位置
                    if (mLeavedProps.contains(i)) {
                        continue;
                    }
                    //計(jì)算出總距離
                    distance = i * mPropSize + mLeftOffset;
                    //離隊(duì)樹樁數(shù)量
                    hitOffsetCount = 0;
                    for (int j = 0; j < mLeavedProps.size(); j++) {
                        //檢查是否有離隊(duì)的樹頭
                        if (mLeavedProps.get(j) < i) {
                            hitOffsetCount++;
                        }
                    }
                    //減去已離隊(duì)的樹樁占用的位置，得出真實(shí)的位置
                    distance -= mPropSize * hitOffsetCount;
                    //樹樁的x軸小于或等于實(shí)際的偏移距離，則認(rèn)為已經(jīng)偏移完成，不需要繼續(xù)更新位置
                    isFinished = prop.getX() <= distance;
                    updateTime = SystemClock.uptimeMillis();
                    if (!isFinished) {
                        //計(jì)算間隔時(shí)間
                        intervalTime = updateTime - prop.lastUpdateTime;
                        //路程 = 時(shí)間 * 速度
                        offset = intervalTime * mPropOffsetSpeed;
                        //更新x軸位置
                        prop.setX(prop.getX() - offset);
                    }
                    //刷新上一次的更新時(shí)間
                    prop.lastUpdateTime = updateTime;
                }
            }
        });
    }

    /**
     * 更新線程停止后又重新開始,需要加上停止的這段時(shí)間
     */
    private void updatePropGenerateTime() {
        if (mLastStopTime > 0) {
            //總停止時(shí)間 = 當(dāng)前時(shí)間 - 上次更新時(shí)間
            long totalStoppedTime = SystemClock.uptimeMillis() - mLastStopTime;
            mLastStopTime = 0;
            for (int i = 0; i < mProps.size(); i++) {
                //加上這段時(shí)間
                mProps.get(i).lastUpdateTime += totalStoppedTime;
            }
        }
    }

    private Rect[][] mItems;//矩形二維數(shù)組
    private volatile int[][] mItemStatus;//用來保存對(duì)應(yīng)的矩形狀態(tài)(小豬占用,木頭占用,空閑)

    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;
        //初始化矩形二維數(shù)組, 用單雙行交錯(cuò)的方式排列
        for (int vertical = 0; vertical < VERTICAL_COUNT; vertical++) {
            currentY = mItemSize * vertical;
            for (int horizontal = 0; horizontal < HORIZONTAL_COUNT; horizontal++) {
                //如果行數(shù)是雙數(shù)，則向右偏移半個(gè)格子
                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);
            }
        }
    }

    /**
     * 以currentPos為中心點(diǎn),向周圍6個(gè)方向查找空閑的位置(廣度優(yōu)先遍歷)
     * @param items 格子狀態(tài)
     * @param ignorePos 需要忽略的格子
     * @param currentPos 起始的格子（以這個(gè)格子為起點(diǎn)向四周查找）
     * @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++) {
            //復(fù)制數(shù)組(因?yàn)橐獙?duì)數(shù)組元素值進(jìn)行修改，且不能影響原來的)
            System.arraycopy(items[vertical], 0, pattern[vertical], 0, horizontalCount);
        }
        way.offer(currentPos);//當(dāng)前pos先入隊(duì)
        pattern[currentPos.y][currentPos.x] = STATE_WALKED;//狀態(tài)標(biāo)記(已走過)
        while (!way.isEmpty()) {//隊(duì)列不為空
            WayData header = way.poll();//隊(duì)頭出隊(duì)
            List<WayData> directions = getCanArrivePosUnchecked(pattern, header);//獲取周圍6個(gè)方向的位置(不包括越界的)
            //遍歷周邊的位置
            for (int i = 0; i < directions.size(); i++) {
                WayData direction = directions.get(i);
                //判斷該位置是否空閑,如果是空閑則直接返回,如果不是空閑,則入隊(duì),下次以它為中心,尋找周邊的元素
                if (!currentPos.equals(direction) && items[direction.y][direction.x] == Item.STATE_UNSELECTED
                        && !(ignorePos != null && ignorePos.contains(direction))) {
                    return direction;
                } else {
                    way.offer(direction);
                }
            }
        }
        //隊(duì)列直至為空還沒返回,則找不到了
        return null;
    }

    /**
     * 通知有新的樹頭放下, 有逃跑路徑在這個(gè)新占用位置上的小豬,都要重新計(jì)算新的逃跑路線(舊的已經(jīng)無效了)
     */
    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;
                    }
                }
            }
        }
    }

    /**
     * 判斷當(dāng)前位置是否能放置樹樁或小豬(如果在一個(gè)封閉的圈子里面,則連小豬當(dāng)前位置也要計(jì)算)例如:(0表示樹頭 .表示小豬)
     * * * * * * *
     *  * 0 0 0 * *
     * * 0 . . 0 *
     *  * 0 * 0 * *
     * * * 0 0 * *
     *  * * * * * *
     * 計(jì)算出來空閑的結(jié)果是1,也即是可以放置,如果再多一個(gè)小豬在里面,則不可放置
     * @param items 格子狀態(tài)
     * @param occupiedPos 小豬們的所在位置
     * @param currentPos 起點(diǎn)
     * @param result 空閑的格子
     * @return 圈子內(nèi)能否放置
     */
    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++) {
            //復(fù)制數(shù)組(因?yàn)橐獙?duì)數(shù)組元素值進(jìn)行修改，且不能影響原來的)
            System.arraycopy(items[vertical], 0, pattern[vertical], 0, horizontalCount);
        }
        for (WayData tmp : occupiedPos) {
            if (tmp != null) {
                //先將小豬們占用的位置標(biāo)記未未選中
                pattern[tmp.y][tmp.x] = Item.STATE_UNSELECTED;
            }
        }
        //以currentPos為起點(diǎn)
        way.offer(currentPos);
        //標(biāo)記狀態(tài)(已走過)
        pattern[currentPos.y][currentPos.x] = STATE_WALKED;
        if (items[currentPos.y][currentPos.x] != Item.STATE_SELECTED) {
            //如果起點(diǎn)也是空閑狀態(tài)，則算他一個(gè)
            result.add(currentPos);
        }
        //開始廣度優(yōu)先遍歷
        while (!way.isEmpty()) {
            //隊(duì)頭出隊(duì)
            WayData header = way.poll();
            //尋找周圍6個(gè)方向可以到達(dá)的位置(不包括越界的,標(biāo)記過的,不是空閑的)也就是空閑的格子
            List<WayData> directions = getCanArrivePos(pattern, header);
            for (int i = 0; i < directions.size(); i++) {
                WayData direction = directions.get(i);
                //將這些位置添加進(jìn)去
                result.add(direction);
                way.offer(direction);
            }
        }
        int count = 0;
        //重點(diǎn)來了
        //現(xiàn)在result里面保存的位置，都是忽略了小豬的坐標(biāo)的，所以現(xiàn)在要重新計(jì)算一下
        //遍歷小豬們當(dāng)前所在位置，是否在result中，如果在，記錄一下
        for (WayData tmp : occupiedPos) {
            if (tmp != null && result.contains(tmp)) {
                count++;
            }
        }
        //最后，如果空閑格子內(nèi)的小豬數(shù) < 總的空閑格子數(shù)，則認(rèn)為這個(gè)圈內(nèi)還能放得下，反之
        return count < result.size();
    }

    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }

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

    @Override
    public boolean equals(Object obj) {
        return obj instanceof WayData ? x == ((WayData) obj).x && y == ((WayData) obj).y : this == obj;
    }