欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

拼图小游戏

程序员文章站 2022-07-13 08:27:26
...

自己动手,写出一个拼图类的小游戏。主要步骤如下:
1.将一张完整图片进行有序切割成若干小块;单个图片需要唯一标识itemId,以及拼图成功时的校验Id——bitmapId.
2.图片数组已经具备了,接下来就是打乱有序图片集合,这里进行两两置换,会用到2个bean进行数据交换
3.打乱图片集合后需要判断该集合是否有解,这个就根据唯一表示itemId来进行倒置和算法判断。
4.循环判断每个图片条目是否恢复到了原始状态,鉴别拼图成功与否。
以下是具体代码逻辑:

本项目中的图片来源通过拍照或者相册里面取,所以第一步是读取相册图片或者拍照获取到对应图片。注意在6.0以上的系统中,系统权限有了改变,所以到读取照片或者拍照的时候会用到读写内存卡的权限,所以第一件事是检验是否开放了权限:

    /**
     * 检查权限
     */
    @TargetApi(Build.VERSION_CODES.M)
    private boolean checkNeededPermission() {
        if (checkSelfPermission(
                READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED ||
                checkSelfPermission(
                        WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE}, PERMISSIONCODE);
            return false;
        } else return true;
    }

还需要权限开启结果的回调来判断是否真的开启了权限:

@Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == PERMISSIONCODE) {
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED
                    && grantResults[1] == PackageManager.PERMISSION_GRANTED) {
                selPic();
            } else {
                Toast.makeText(PictureGameAct.this, "Permission Denied", Toast.LENGTH_SHORT).show();
            }
            return;
        }
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

    }

selPic()方法就是调起相机或者拍照:

 public void selPic() {
        if (isTackPhoto) {//拍照
            Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            path = Environment.getExternalStorageDirectory().getAbsolutePath() + "/img.png";
            Uri uri = Uri.fromFile(new File(path));
            intent.putExtra(MediaStore.EXTRA_OUTPUT, uri);
            startActivityForResult(intent, IMAGE_TACK_PICK_CODE);
        } else {//相册
            Intent intent = new Intent(Intent.ACTION_PICK, null);//Intent.ACTION_PICK相册的action
            intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, IMAGE_TYPE);
            startActivityForResult(intent, IMAGE_PIC_CODE);
        }
    }

然后就是在onActivityResult中接收结果:

@Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == RESULT_OK) {
            if (requestCode == IMAGE_PIC_CODE) {//相册
                if (data != null && data.getData() != null) {
                    String filePath;
                    Cursor cursor = getContentResolver().query(data.getData(), null, null, null, null);
                    if (cursor != null) {
                        cursor.moveToFirst();
                        filePath = cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
                        cursor.close();
                    } else {
                        filePath = data.getData().getPath();
                    }
                    getBitmapList(filePath);
                    generateMapList();
                    setBitmapData();
                }
            } else if (requestCode == IMAGE_TACK_PICK_CODE) {//拍照
                getBitmapList(path);
                generateMapList();
                setBitmapData();
            }
        }
    }

getBitmapList方法是初始化图片资源,有序等分图片;generateMapList方法是打乱有序的图片资源;
setBitmapData是展示数据

/**
     * 初始化图片资源,有序等分图片
     *
     * @param filePath
     */
    private void getBitmapList(String filePath) {
        datas.clear();
        Bitmap bitmap = BitmapFactory.decodeFile(filePath);//获取源文件
        int itemWidth = bitmap.getWidth() / TYPE;
        int itemHeight = bitmap.getHeight() / TYPE;
        for (int i = 0; i < TYPE; i++) {
            for (int j = 0; j < TYPE; j++) {
                PicItemBean item = new PicItemBean();
                item.bitmap = Bitmap.createBitmap(bitmap, itemWidth * j, itemHeight * i, itemWidth, itemHeight);//逐步剪裁图片
                item.bitmapId = i*TYPE+j+1;
                item.itemId = i*TYPE+j+1;
                datas.add(item);
            }
        }
        datas.remove(TYPE * TYPE - 1);//移除最后一张图片,然后添加一张空白图片
        PicItemBean item = new PicItemBean();
        item.bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.back);
        item.itemId = TYPE * TYPE;
        item.bitmapId = 0;
        datas.add(item);
        mBlackItem = item;//先将最后一个item赋值给空白的item
    }

然后就是混合图片变成无序,并判断混合后的结果是否有解:

 /**
     * 将图片进行混合成无序的
     */
    private void generateMapList() {
        for (int i = 0; i < datas.size(); i++) {
            int pos = (int) (Math.random() * TYPE * TYPE);
            swipeData(mBlackItem, datas.get(pos));
        }
        List<Integer> idDatas = new ArrayList<Integer>();
        for (int i = 0; i < datas.size(); i++) {
            idDatas.add(datas.get(i).bitmapId);
        }
        //判断生成是否有解
        if (canSolve(idDatas)) {
            return;
        } else {
            generateMapList();
        }
    }

    /**
     * 判断是否有解
     *
     * @param data 拼图id数组数据
     * @return
     */
    public boolean canSolve(List<Integer> data) {
        //获取空格id
        int blackId = mBlackItem.itemId;
        if (data.size() % 2 == 1) {
            return getInversions(data) % 2 == 0;
        } else {
            //从下往上数,空格位于奇数行,
            if (((blackId - 1) / TYPE) % 2 == 1) {
                return getInversions(data) % 2 == 0;
            } else {
                //从下往上数,空格位于偶数行,
                return getInversions(data) % 2 == 1;
            }
        }
    }

    /**
     * 倒置和算法
     *
     * @param data
     * @return 该序列的倒置和
     */
    public int getInversions(List<Integer> data) {
        int inversions = 0;
        int inversionCount = 0;
        for (int i = 0; i < data.size(); i++) {
            for (int j = i + 1; j < data.size(); j++) {
                int index = data.get(i);
                if (data.get(j) != 0 && data.get(j) < index) {
                    inversionCount++;
                }
            }
            inversions += inversionCount;
            inversionCount = 0;
        }
        return inversions;
    }
    /**
     * 交换空白格数据和点击条目的数据
     *
     * @param blackItem
     * @param item
     */
    private void swipeData(PicItemBean blackItem, PicItemBean item) {
        int bitmapId = item.bitmapId;
        Bitmap bitmap = item.bitmap;
        item.bitmapId = blackItem.bitmapId;
        item.bitmap = blackItem.bitmap;
        blackItem.bitmap = bitmap;
        blackItem.bitmapId = bitmapId;
        mBlackItem = item;//注意,这里需要将空白格的值重新赋值,值为新的需要交换数据的item,这样就保证了空白格条目和集合中的空白格数据同步
    }

这里补充一下图片bean:

public class PicItemBean {
    public Bitmap bitmap;
    public int bitmapId;
    public int itemId;

    @Override
    public String toString() {
        return "bitmap=" + bitmap.hashCode() + ",bitmapId==" + bitmapId + ",itemId=" + itemId;
    }
}

最后就是显示数据了:

/**
     * 显示数据
     */
    public void setBitmapData() {
        adapter = new BitmapAdapter(this);
        gv.setAdapter(adapter);
        gv.setOnItemClickListener(new AdapterView.OnItemClickListener()

        {
            @Override
            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
                PicItemBean bean = datas.get(position);
                //判断四周是否有空格
                if (couldChange(bean)) {
                    swipeData(mBlackItem, bean);
                    if (isSucceed()) {//拼图成功,将缺省的图片还原
                        datas.get(TYPE * TYPE - 1).bitmap = lastBimtap;
                    }
                    adapter.notifyDataSetChanged();
                }
            }
        });
    }
     /**
     * 点击条目是否可以和空白格交换位置数据
     * 依据是当处于同一行的时候,他们的itemId相差1就说明两者可以交换位置,如果是不同行,只有相差TYPE时
     * 才可以交换位置
     *
     * @param bean
     * @return
     */
    private boolean couldChange(PicItemBean bean) {
        if (Math.abs(bean.itemId - mBlackItem.itemId) == TYPE) {
            return true;//不同行的时候两个相差3就可以交换
        } else if (Math.abs(bean.itemId - mBlackItem.itemId) == 1) {//同行相差1
            return true;
        }
        return false;
    }

    /**
     * 拼图是否完成
     *
     * @return
     */
    private boolean isSucceed() {
        boolean result = true;
        for (int i = 0; i < datas.size(); i++) {
            PicItemBean item = datas.get(i);
            if (i < TYPE * TYPE - 1) {
                if (item.bitmapId != item.itemId) {
                    result = false;
                    break;
                }
            } else {
                if (item.bitmapId == 0 && item.itemId == TYPE * TYPE) {
                    result = true;
                } else {
                    result = false;
                }
            }
        }
        return result;
    }

在条目的点击事件中就需要判断是否可以交换数据,并且交换后拼图是否完成。
还有一个适配器就完成了

private class BitmapAdapter extends BaseAdapter {

        public BitmapAdapter(Context context) {
        }

        @Override
        public int getCount() {
            Log.d(TAG, "SIZE====" + datas.size());
            return datas == null ? 0 : datas.size();
        }

        @Override
        public Object getItem(int position) {
            return datas.get(position);
        }

        @Override
        public long getItemId(int position) {
            return position;
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder holder;
            if (convertView == null) {
                holder = new ViewHolder();
                convertView = LayoutInflater.from(PictureGameAct.this).inflate(R.layout.item_img, null);
                convertView.setTag(holder);
            } else {
                holder = (ViewHolder) convertView.getTag();
            }
            holder.iv = (ImageView) convertView.findViewById(R.id.iv);
            ViewGroup.LayoutParams layoutParams = holder.iv.getLayoutParams();
            layoutParams.height = getScreenWidth() / 3;
            holder.iv.setLayoutParams(layoutParams);
            holder.iv.setImageBitmap(datas.get(position).bitmap);
            return convertView;
        }
    }

    private static class ViewHolder {
        ImageView iv;
    }

    public int getScreenWidth() {
        DisplayMetrics metrics = new DisplayMetrics();
        WindowManager wm = (WindowManager) getSystemService(Context.WINDOW_SERVICE);
        wm.getDefaultDisplay().getMetrics(metrics);
        return metrics.widthPixels;
    }

整个拼图就已经完成了
拼图小游戏
源码下载地址

相关标签: 游戏 bitmap使用