控制器 制作 单一的推箱子游戏(马推箱子)

马推箱子(有些复杂化了(当时没有想那么多,尽量不要出bug))

思路:

1.二维数组(三个左边(终点,箱子,马)),随机坐标,不相同。

2.只需要做出一个方向的全部操作,另外三个都一样。

3.确定情况四种(W)代码都是重复的只是改了下标:

  一)整个Y轴

 

   

  二)整个Y轴只有马和箱子

 

 

 

 

  三)整个Y轴只有马和终点

 

  四)整Y轴,有马,箱子,终点

    1)马在最上面,另外两个随便位置

 

 

    2)马在两个之间(两种情况)

 

 

    3)马在最下面(最复杂的

      3.1)箱子在最上面,终点在中间

 

             3.2)终点在最上面,箱子在中间(成功)

 

 

 

 

 

 

package com.xmx.lzy5_array;


import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

public class SokobanTwoDimensionalArrayDemo4 {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        Random rd=new Random();
        //1.确定地图样式
        String[][] map=new String[10][10];
        for (String[] strings : map) {
            Arrays.fill(strings, "口");
        }

        //2.确定马的坐标                  这里的10个数  0:第1个数  从0开始一共10个数所以是0~9
        int h_x= rd.nextInt(10),h_y=rd.nextInt(10);
        map[h_y][h_x]="♘";

        //3.确定箱子的坐标 判断是否跟马重叠 这里0~8 箱子不挨边 挨边会出现问题
        int b_x= rd.nextInt(8)+1,b_y=rd.nextInt(8)+1;
        //判断
        while (h_x==b_x&&h_y==b_y){
            b_x= rd.nextInt(8)+1;
            b_y=rd.nextInt(8)+1;
        }
        map[b_y][b_x]="〼";

        //4.确定终点的坐标 判断是否跟马和箱子重叠
        int t_x=rd.nextInt(10),t_y=rd.nextInt(10);
        //判断
        while ((t_x==b_x&&t_y==b_y)||(h_x==t_x&&h_y==t_y)){
            t_x= rd.nextInt(8)+1;
            t_y=rd.nextInt(8)+1;
        }
        map[t_y][t_x]="◇";
        //测试
//        b_x=h_x;
//        t_x=h_x;
        //检测
        int sum=0;
        //显示地图
        drawMap(map);
        //5.移动马(先弄一个死循环)
        while (true){
            System.out.println("请输入(w-向_上;s-向下;a-向左;d-向右):");
            String trend=input.next();
            switch (trend){
                case "w":
                    //清空马
                    map[h_y][h_x]="口";
                    //改变Y(-)坐标
                    if (h_y!=0){
                        //1.马Y轴,只有箱子。
                        if(h_x==b_x&&b_x!=t_x){
                            // 1.1).马前面是箱子
                            if(h_y-1==b_y){
                                //判断在临界点
                                if (b_y!=0){
                                    //清空原来的位置
                                    map[b_y][b_x]="口";
                                    //更新位置
                                    h_y-=1;
                                    b_y-=1;
                                }
                            }
                            // 1.2).马前面为空
                            else {
                                h_y-=1;
                            }
                        }
                        //2.马Y轴,只有终点。
                        if(h_x==t_x&&b_x!=t_x){
                            // 2.1).马前面是终点
                            if(h_y-1==t_y){
                                //判断在临界点
                                if(t_y!=0){
                                    //更新位置
                                    h_y-=2;
                                }
                            }
                            // 2.2).马前面为空
                            else {
                                h_y-=1;
                            }
                        }
                        //3.马Y轴,有箱子-终点。
                        if(h_x==t_x&&h_x==b_x){
                            //3.1).马在下面
                            if(h_y>t_y&&h_y>b_y){
                                //终点在上面--箱子中间
                                if (b_y>t_y){
                                    //马临界箱子的时候
                                    if(h_y-1==b_y){
                                        //箱子临界终点的时候
                                        if (b_y-1==t_y){
                                            //清空
                                            map[b_y][b_x]="口";
                                            map[t_y][t_x]="口";
                                            //更新位置
                                            h_y-=1;
                                            b_y=t_y;//b_y-=1;  这个时候 b_y=t_y b_x=t_x
                                            //填充位置 在下面 做判断
                                            sum++;
                                        }else {
                                            //清空箱子
                                            map[b_y][b_x]="口";
                                            //更新位置
                                            h_y-=1;
                                            b_y-=1;
                                        }
                                    }else {
                                        h_y-=1;
                                    }
                                }
                                //箱子在上面--终点中间
                                else {
                                    //判断马临界终点的时候
                                    if(h_y-1==t_y){
                                        //当终点前面是箱子
                                        if(t_y-1==b_y){
                                            //判断箱子临界
                                            if(b_y!=0){
                                                //更新位置
                                                h_y-=2;
                                                b_y-=1;
                                            }
                                        }else {
                                            //更新位置
                                            h_y-=2;
                                        }
                                    }else {
                                        h_y-=1;
                                    }
                                }
                            }
                            //3.2).马在上面 不需要判断 前面为全是空
                            else if (h_y<t_y&&h_y<b_y){
                                //更新位置
                                h_y-=1;
                            }
                            //3.3).马在中间
                            else {
                                //箱子在上面--终点下面(这个不需要管)
                                if(b_y<t_y){
                                    //临界
                                    if(h_y-1==b_y){
                                        //临界
                                        if (b_y!=0){
                                            //更新位置
                                            h_y-=1;
                                            b_y-=1;
                                        }
                                    }else {
                                        //更新位置
                                        h_y-=1;
                                    }
                                }
                                //终点在上面--箱子下面(这个不需要管)
                                else {
                                    //临界
                                    if(h_y-1==t_y){
                                        //临界
                                        if (t_y!=0){
                                            //更新位置
                                            h_y-=2;
                                        }
                                    }else {
                                        //更新位置
                                        h_y-=1;
                                    }
                                }
                            }
                        }
                        //4.马Y轴前面什么都没有
                        if(h_x!=b_x&&h_x!=t_x) {
                            h_y-=1;
                        }
                    }
                    map[h_y][h_x]="♘";
                    //判断 输出OK的时候 sum=1,map[t_y][t_x]="ok";
                    if(sum==1){
                        map[t_y][t_x]="ok";
                    }else {
                        map[b_y][b_x]="〼";
                    }
                    break;
                case "s":
                    //清空马
                    map[h_y][h_x]="口";
                    //改变Y(+)坐标
                    if (h_y!=9){
                        //1.马Y轴,只有箱子。
                        if(h_x==b_x&&b_x!=t_x){
                            // 1.1).马后面是箱子
                            if(h_y+1==b_y){
                                //判断在临界点
                                if (b_y!=9){
                                    //清空原来的位置
                                    map[b_y][b_x]="口";
                                    //更新位置
                                    h_y+=1;
                                    b_y+=1;
                                }
                            }
                            // 1.2).马后面为空
                            else {
                                h_y+=1;
                            }
                        }
                        //2.马Y轴,只有终点。
                        if(h_x==t_x&&b_x!=t_x){
                            // 2.1).马后面是终点
                            if(h_y+1==t_y){
                                //判断在临界点
                                if(t_y!=9){
                                    //更新位置
                                    h_y+=2;
                                }
                            }
                            // 2.2).马前面为空
                            else {
                                h_y+=1;
                            }
                        }
                        //3.马Y轴,有箱子-终点。
                        if(h_x==t_x&&h_x==b_x){
                            //3.1).马在下面 不需要判断 后面为全是空
                            if(h_y>t_y&&h_y>b_y){
                                //更新位置
                                h_y+=1;
                            }
                            //3.2).马在上面
                            else if (h_y<t_y&&h_y<b_y){
                                //终点在下面--箱子中间
                                if (b_y<t_y){
                                    //马临界箱子的时候
                                    if(h_y+1==b_y){
                                        //箱子临界终点的时候
                                        if (b_y+1==t_y){
                                            //清空
                                            map[b_y][b_x]="口";
                                            map[t_y][t_x]="口";
                                            //更新位置
                                            h_y+=1;
                                            b_y=t_y;//b_y-=1;  这个时候 b_y=t_y b_x=t_x
                                            //填充位置 在下面 做判断
                                            sum++;
                                        }else {
                                            //清空箱子
                                            map[b_y][b_x]="口";
                                            //更新位置
                                            h_y+=1;
                                            b_y+=1;
                                        }
                                    }else {
                                        h_y+=1;
                                    }
                                }
                                //箱子在下面--终点中间
                                else {
                                    //判断马临界终点的时候
                                    if(h_y+1==t_y){
                                        //当终点前面是箱子
                                        if(t_y+1==b_y){
                                            //判断箱子临界
                                            if(b_y!=9){
                                                //更新位置
                                                h_y+=2;
                                                b_y+=1;
                                            }
                                        }else {
                                            //更新位置
                                            h_y+=2;
                                        }
                                    }else {
                                        h_y+=1;
                                    }
                                }
                            }
                            //3.3).马在中间
                            else {
                                //箱子在下面--终点上面(这个不需要管)
                                if(b_y>t_y){
                                    //临界
                                    if(h_y+1==b_y){
                                        //临界
                                        if (b_y!=9){
                                            //更新位置
                                            h_y+=1;
                                            b_y+=1;
                                        }
                                    }else {
                                        //更新位置
                                        h_y+=1;
                                    }
                                }
                                //终点在上面--箱子下面(这个不需要管)
                                else {
                                    //临界
                                    if(h_y+1==t_y){
                                        //临界
                                        if (t_y!=9){
                                            //更新位置
                                            h_y+=2;
                                        }
                                    }else {
                                        //更新位置
                                        h_y+=1;
                                    }
                                }
                            }
                        }
                        //4.马Y轴前面什么都没有
                        if(h_x!=b_x&&h_x!=t_x) {
                            h_y+=1;
                        }
                    }
                    map[h_y][h_x]="♘";
                    //判断 输出OK的时候 sum=1,map[t_y][t_x]="ok";
                    if(sum==1){
                        map[t_y][t_x]="ok";
                    }else {
                        map[b_y][b_x]="〼";
                    }
                    break;
                case "a":
                    //清空马
                    map[h_y][h_x]="口";
                    //改变X(-)坐标
                    if (h_x>0){
                        //1.马X轴,只有箱子。
                        if(h_y==b_y&&b_y!=t_y){
                            // 1.1).马前面是箱子
                            if(h_x-1==b_x){
                                //判断在临界点
                                if (b_x!=0){
                                    //清空原来的位置
                                    map[b_y][b_x]="口";
                                    //更新位置
                                    h_x-=1;
                                    b_x-=1;
                                }
                            }
                            // 1.2).马前面为空
                            else {
                                h_y-=1;
                            }
                            /*
                            // 1.3).填充新位置
                            map[h_y][h_x]="♘";
                            map[b_y][b_x]="〼";*/
                        }
                        //2.马X轴,只有终点。
                        if(h_y==t_y&&b_y!=t_y){
                            // 2.1).马前面是终点
                            if(h_x-1==t_x){
                                //判断在临界点
                                if(t_x!=0){
                                    //更新位置
                                    h_x-=2;
                                }
                            }
                            // 2.2).马前面为空
                            else {
                                h_x-=1;
                            }
                        }
                        //3.马X轴,有箱子-终点。
                        if(h_y==t_y&&h_y==b_y){
                            //3.1).马在右边
                            if(h_x>t_x&&h_x>b_x){
                                //终点在左边--箱子中间
                                if (b_x>t_x){
                                    //马临界箱子的时候
                                    if(h_x-1==b_x){
                                        //箱子临界终点的时候
                                        if (b_x-1==t_x){
                                            //清空
                                            map[b_y][b_x]="口";
                                            map[t_y][t_x]="口";
                                            //更新位置
                                            h_x-=1;
                                            b_x=t_x;//b_y-=1;  这个时候 b_y=t_y b_x=t_x
                                            //填充位置 在下面 做判断
                                            sum++;
                                        }else {
                                            //清空箱子
                                            map[b_y][b_x]="口";
                                            //更新位置
                                            h_x-=1;
                                            b_x-=1;
                                        }
                                    }else {
                                        h_x-=1;
                                    }
                                }
                                //箱子在左边--终点中间
                                else {
                                    //判断马临界终点的时候
                                    if(h_x-1==t_x){
                                        //当终点前面是箱子
                                        if(t_x-1==b_x){
                                            //判断箱子临界
                                            if(b_x!=0){
                                                //更新位置
                                                h_x-=2;
                                                b_x-=1;
                                            }
                                        }else {
                                            //更新位置
                                            h_x-=2;
                                        }
                                    }else {
                                        h_x-=1;
                                    }
                                }
                            }
                            //3.2).马在左边 不需要判断 左边为全是空
                            else if (h_x<t_x&&h_x<b_x){
                                //更新位置
                                h_x-=1;
                            }
                            //3.3).马在中间
                            else {
                                //箱子在左边--终点右边(这个不需要管)
                                if(b_x<t_x){
                                    //临界
                                    if(h_x-1==b_x){
                                        //临界
                                        if (b_x!=0){
                                            //更新位置
                                            h_x-=1;
                                            b_x-=1;
                                        }
                                    }else {
                                        //更新位置
                                        h_x-=1;
                                    }
                                }
                                //终点在左边--箱子右边(这个不需要管)
                                else {
                                    //临界
                                    if(h_x-1==t_x){
                                        //临界
                                        if (t_x!=0){
                                            //更新位置
                                            h_x-=2;
                                        }
                                    }else {
                                        //更新位置
                                        h_x-=1;
                                    }
                                }
                            }
                        }
                        //4.马X轴前面什么都没有
                        if(h_y!=b_y&&h_y!=t_y) {
                            h_x-=1;
                        }
                    }
                    map[h_y][h_x]="♘";
                    //判断 输出OK的时候 sum=1,map[t_y][t_x]="ok";
                    if(sum==1){
                        map[t_y][t_x]="ok";
                    }else {
                        map[b_y][b_x]="〼";
                    }
                    break;
                case "d":
                    //清空马
                    map[h_y][h_x]="口";
                    //改变X(+)坐标
                    if (h_x<9){
                        //1.马Y轴,只有箱子。
                        if(h_y==b_y&&b_y!=t_y){
                            // 1.1).马右边是箱子
                            if(h_x+1==b_x){
                                //判断在临界点
                                if (b_x!=9){
                                    //清空原来的位置
                                    map[b_y][b_x]="口";
                                    //更新位置
                                    h_x+=1;
                                    b_x+=1;
                                }
                            }
                            // 1.2).马右边为空
                            else {
                                h_x+=1;
                            }
                        }
                        //2.马Y轴,只有终点。
                        if(h_y==t_y&&b_y!=t_y){
                            // 2.1).马右边是终点
                            if(h_x+1==t_x){
                                //判断在临界点
                                if(t_x!=9){
                                    //更新位置
                                    h_x+=2;
                                }
                            }
                            // 2.2).马右边为空
                            else {
                                h_x+=1;
                            }
                        }
                        //3.马Y轴,有箱子-终点。
                        if(h_y==t_y&&h_y==b_y){
                            //3.1).马在右边 不需要判断 后面为全是空
                            if(h_x>t_x&&h_x>b_x){
                                //更新位置
                                h_x+=1;
                            }
                            //3.2).马在左边
                            else if (h_x<t_x&&h_x<b_x){
                                //终点在右边--箱子中间
                                if (b_x<t_x){
                                    //马临界箱子的时候
                                    if(h_x+1==b_x){
                                        //箱子临界终点的时候
                                        if (b_x+1==t_x){
                                            //清空
                                            map[b_y][b_x]="口";
                                            map[t_y][t_x]="口";
                                            //更新位置
                                            h_x+=1;
                                            b_x=t_x;//b_y-=1;  这个时候 b_y=t_y b_x=t_x
                                            //填充位置 在下面 做判断
                                            sum++;
                                        }else {
                                            //清空箱子
                                            map[b_y][b_x]="口";
                                            //更新位置
                                            h_x+=1;
                                            b_x+=1;
                                        }
                                    }else {
                                        h_x+=1;
                                    }
                                }
                                //箱子在右边--终点中间
                                else {
                                    //判断马临界终点的时候
                                    if(h_x+1==t_x){
                                        //当终点前面是箱子
                                        if(t_x+1==b_x){
                                            //判断箱子临界
                                            if(b_x!=9){
                                                //更新位置
                                                h_x+=2;
                                                b_x+=1;
                                            }
                                        }else {
                                            //更新位置
                                            h_x+=2;
                                        }
                                    }else {
                                        h_x+=1;
                                    }
                                }
                            }
                            //3.3).马在中间
                            else {
                                //箱子在右边--终点左边(这个不需要管)
                                if(b_x>t_x){
                                    //临界
                                    if(h_x+1==b_x){
                                        //临界
                                        if (b_x!=9){
                                            //更新位置
                                            h_x+=1;
                                            b_x+=1;
                                        }
                                    }else {
                                        //更新位置
                                        h_x+=1;
                                    }
                                }
                                //终点在右边--箱子左边(这个不需要管)
                                else {
                                    //临界
                                    if(h_x+1==t_x){
                                        //临界
                                        if (t_x!=9){
                                            //更新位置
                                            h_x+=2;
                                        }
                                    }else {
                                        //更新位置
                                        h_x+=1;
                                    }
                                }
                            }
                        }
                        //4.马Y轴什么都没有
                        if(h_y!=b_y&&h_y!=t_y) {
                            h_x+=1;
                        }
                    }
                    map[h_y][h_x]="♘";
                    //判断 输出OK的时候 sum=1,map[t_y][t_x]="ok";
                    if(sum==1){
                        map[t_y][t_x]="ok";
                    }else {
                        map[b_y][b_x]="〼";
                    }
                    break;
                default:
                    System.out.println("************傻逼************"+"\n*********遵守游戏规则********");
            }
            //覆盖
            drawMap(map);
            if(sum==1){
                break;
            }
        }
        System.out.println("*****************成功*****************");
    }
    //定义一个方法 打印地图
    public static void drawMap(String [][] map){
        //显示地图
        for (String[] strings : map) {
            for (String string : strings) {
                System.out.print(string + "\t");
            }
            System.out.println();
        }
    }
}


posted on 2021-07-21 14:20    阅读(66)  评论(0编辑  收藏  举报

导航