java 推箱子 两个箱子 两个位置 ,练习java二维数组

最新推荐文章于 2024-02-02 15:43:29 发布
最新推荐文章于 2024-02-02 15:43:29 发布
阅读量1.4k 收藏 7
点赞数 4
文章标签： java 二维数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xc164725/article/details/77159991
版权
package com.lanou.homework;

import java.util.Scanner;

public class Homework_TuiXiangZi1 {

    @SuppressWarnings("resource")
    public static void main(String[] args) {

        /*
         * 首先, 我们创建出来小人可以移动的地图--->这个地图是一个二维数组
         **/
        int[][] map = new int[5][5];

        /*
         * 接下来,我希望从输入确定我的小人的初始位置
         */
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入小人初始位置的行坐标从 0 到 " + (map.length - 1));
        int m = scanner.nextInt(); // 小人的行坐标
        if (m > map.length - 1 || m < 0) {
            System.out.println("您输入的行数有误,小人坐标脱离了地图!!");
            return;
        }
        System.out.println("请输入小人初始位置的列坐标从 0 到 " + (map[m].length - 1));
        int n = scanner.nextInt(); // 小人的列坐标!!
        if (n > map[m].length - 1 || n < 0) {
            System.out.println("您输入的列数有误,小人坐标脱离了地图");
            return;
        }

        map[m][n] = 1; // 给小人赋值

        /*
         * 关于箱子1的逻辑判断
         */

        System.out.println("请输入箱子1的行坐标,从0 到" + (map.length - 1));
        int boxM = scanner.nextInt();
        if (boxM >= map.length || boxM < 0) {
            System.out.println("箱子1已经脱离地图");
            return;
        }
        System.out.println("请输入箱子1的列坐标,从0 到 " + (map[boxM].length - 1));
        int boxN = scanner.nextInt();
        if (boxN >= map[boxM].length || boxN < 0) {
            System.out.println("箱子1已经脱离地图了");
            return;
        }
        if (boxM == m && boxN == n) {
            System.out.println("此处小人已经占了,请另寻他处!");
            return;
        }
        map[boxM][boxN] = 2;// 给箱子所在的位置赋值

        /*
         * 关于箱子二的逻辑判断
         */

        System.out.println("请输入箱子2的行坐标,从0 到" + (map.length - 1));
        int boxM1 = scanner.nextInt();
        if (boxM1 >= map.length || boxM1 < 0) {
            System.out.println("箱子1已经脱离地图");
            return;
        }
        System.out.println("请输入箱子1的列坐标,从0 到 " + (map[boxM].length - 1));
        int boxN1 = scanner.nextInt();
        if (boxN1 >= map[boxM1].length || boxN1 < 0) {
            System.out.println("箱子1已经脱离地图了");
            return;
        }
        if (boxM1 == m && boxN1 == n) {
            System.out.println("此处小人已经占了,请另寻他处!");
            return;
        } else if (boxM1 == boxM && boxN1 == boxN) {
            System.out.println("此处箱子已经占了!");
        }

        map[boxM1][boxN1] = 2;// 给箱子所在的位置赋值

        /*
         * 关于箱子目的地1的逻辑判断
         *
         */

        System.out.println("请输入箱子空的行坐标,从0 到" + (map.length - 1));
        int boxK = scanner.nextInt();
        if (boxK >= map.length || boxK < 0) {
            System.out.println("箱子空 已经脱离地图了");
            return;
        }
        System.out.println("请输入箱子空的列坐标,从0 到" + (map[boxK].length - 1));
        int boxL = scanner.nextInt();
        if (boxL >= map[boxK].length || boxL < 0) {
            System.out.println("箱子空 已经脱离地图了");
        }
        map[boxK][boxL] = 3;// 给箱子空(相当于给箱子所要推送的位置)赋值

        if (boxK == m && boxL == n) {
            map[m][n] = 4;
        } else if ((boxK == boxM && boxL == boxM) || (boxK == boxM1 && boxL == boxN1)) {
            map[boxK][boxK] = 5;
        }

        /*
         * 关于箱子目的地2的逻辑判断
         *
         */

        System.out.println("请输入箱子空的行坐标,从0 到" + (map.length - 1));
        int boxK1 = scanner.nextInt();
        if (boxK1 >= map.length || boxK1 < 0) {
            System.out.println("箱子空 已经脱离地图了");
            return;
        }
        System.out.println("请输入箱子空的列坐标,从0 到" + (map[boxK1].length - 1));
        int boxL1 = scanner.nextInt();
        if (boxL1 >= map[boxK1].length || boxL1 < 0) {
            System.out.println("箱子空 已经脱离地图了");
        }
        map[boxK1][boxL1] = 3;// 给箱子空(相当于给箱子所要推送的位置)赋值

        if (boxK1 == m && boxL1 == n) {
            map[m][n] = 4;
        } else if ((boxK1 == boxM && boxL1 == boxM) || (boxK1 == boxM1 && boxL1 == boxN1)) {
            map[boxK1][boxL1] = 5;
        }

        /*-----------------创建地图并赋值结束--------------------*/

        /*
         * 检查地图是否有误
         */
        if (map[boxK][boxL] == 5 && map[boxK1][boxL1] == 5) {
            System.out.println("您设置的地图有误请重新设置!!!");

            return;
        }

        /*
         * 我们检查一下目前的地图和小人
         */
        System.out.println("小地图目前状态如下:");
        System.out.println("-------------------------------");
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + "\t");
            }
            System.out.println();
        }
        /*-------------------检查地图结束----------------------*/

        /*
         * 小人行走的逻辑
         */
        while (true) {
            System.out.println("请输入小人行走的方向: W 上 , A:左 , S: 下 , D:右");
            String commend = scanner.next();
            commend.toUpperCase();
            switch (commend) {

            case "W":
                // 这里让小人向上移动
                if (m == 0) {
                    System.out.println("小人已经到最上面了不能再走了!");
                } else {

                    if (map[m][n] == 4) {
                        if (map[m - 1][n] == 2) {

                            if (m - 1 == 0) {
                                System.out.println("箱子已经到顶了,请重新选择方向!");
                            } else {

                                if (map[m - 2][n] == 2) {
                                    System.out.println("上面还有一个箱子,请重新选择方向!");
                                } else if (map[m - 2][n] == 5) {
                                    System.out.println("上面还有一个箱子,请重新选择方向!");
                                } else if (map[m - 2][n] == 3) {
                                    map[m - 2][n] = 5;
                                    map[m][n] = 3;
                                    m = m - 1;
                                    map[m][n] = 1;
                                } else {
                                    map[m - 2][n] = 2;
                                    map[m][n] = 3;
                                    m = m - 1;
                                    map[m][n] = 1;
                                }

                            }

                        } else if (map[m - 1][n] == 5) {

                            if (m - 1 == 0) {
                                System.out.println("已经到最上面了!");
                            } else {
                                map[m - 1][n] = 3;
                                if (map[m - 2][n] == 2) {
                                    System.out.println("上面有一个箱子,请重新选择方向");
                                    break;
                                } else if (map[m - 2][n] == 3) {
                                    map[m - 2][n] = 5;
                                    map[m][n] = 3;
                                    m = m - 1;
                                    map[m][n] = 4;
                                } else {

                                    map[m - 2][n] = 2;
                                    map[m][n] = 3;
                                    m = m - 1;
                                    map[m][n] = 4;

                                }

                            }

                        } else if (map[m - 1][n] == 3) {
                            map[m][n] = 3;
                            m = m - 1;
                            map[m][n] = 4;

                        } else {

                            map[m][n] = 3;
                            m = m - 1;
                            map[m][n] = 1;

                        }
                    } else {

                        if (map[m - 1][n] == 2) {

                            if (m - 1 == 0) {
                                System.out.println("箱子已经到顶了,请重新选择方向!");
                            } else {

                                if (map[m - 2][n] == 2) {
                                    System.out.println("上面还有一个箱子,请重新选择方向!");
                                } else if (map[m - 2][n] == 5) {
                                    System.out.println("上面还有一个箱子,请重新选择方向!");
                                } else if (map[m - 2][n] == 3) {
                                    map[m - 2][n] = 5;
                                    map[m][n] = 0;
                                    m = m - 1;
                                    map[m][n] = 1;
                                } else {
                                    map[m - 2][n] = 2;
                                    map[m][n] = 0;
                                    m = m - 1;
                                    map[m][n] = 1;
                                }

                            }

                        } else if (map[m - 1][n] == 5) {

                            if (m - 1 == 0) {
                                System.out.println("已经到最上面了!");
                            } else {

                                if (map[m - 2][n] == 2) {
                                    System.out.println("上面有一个箱子,请重新选择方向");
                                    break;
                                } else if (map[m - 2][n] == 3) {
                                    map[m - 2][n] = 5;
                                    map[m][n] = 0;
                                    m = m - 1;
                                    map[m][n] = 4;
                                } else {

                                    map[m - 2][n] = 2;
                                    map[m][n] = 0;
                                    m = m - 1;
                                    map[m][n] = 4;

                                }

                            }

                        } else if (map[m - 1][n] == 3) {
                            map[m][n] = 0;
                            m = m - 1;
                            map[m][n] = 4;

                        } else {

                            map[m][n] = 0;
                            m = m - 1;
                            map[m][n] = 1;

                        }

                    }

                }

                break;

            case "A":

                if (n == 0) {
                    System.out.println("小人已经到最左面了不能再走了!");
                } else {

                    if (map[m][n] == 4) {
                        if (map[m][n - 1] == 2) {

                            if (n - 1 == 0) {
                                System.out.println("箱子已经到顶了,请重新选择方向!");
                            } else {

                                if (map[m][n - 2] == 2) {
                                    System.out.println("左面还有一个箱子,请重新选择方向!");
                                } else if (map[m][n - 2] == 5) {
                                    System.out.println("左面还有一个箱子,请重新选择方向!");
                                } else if (map[m][n - 2] == 3) {
                                    map[m][n - 2] = 5;
                                    map[m][n] = 3;
                                    n = n - 1;
                                    map[m][n] = 1;
                                } else {
                                    map[m][n - 2] = 2;
                                    map[m][n] = 3;
                                    n = n - 1;
                                    map[m][n] = 1;
                                }

                            }

                        } else if (map[m][n - 1] == 5) {

                            if (n - 1 == 0) {
                                System.out.println("已经到最上面了!");
                            } else {
                                map[m][n - 1] = 3;
                                if (map[m][n - 2] == 2) {
                                    System.out.println("上面有一个箱子,请重新选择方向");
                                    break;
                                } else if (map[m][n - 2] == 3) {
                                    map[m][n - 2] = 5;
                                    map[m][n] = 3;
                                    n = n - 1;
                                    map[m][n] = 4;
                                } else {

                                    map[m][n - 2] = 2;
                                    map[m][n] = 3;
                                    n = n - 1;
                                    map[m][n] = 4;

                                }

                            }

                        } else if (map[m][n - 1] == 3) {
                            map[m][n] = 3;
                            n = n - 1;
                            map[m][n] = 4;

                        } else {

                            map[m][n] = 3;
                            n = n - 1;
                            map[m][n] = 1;

                        }
                    } else {

                        if (map[m][n - 1] == 2) {

                            if (n - 1 == 0) {
                                System.out.println("箱子已经到左边了,请重新选择方向!");
                            } else {

                                if (map[m][n - 2] == 2) {
                                    System.out.println("左面还有一个箱子,请重新选择方向!");
                                } else if (map[m][n - 2] == 5) {
                                    System.out.println("左面还有一个箱子,请重新选择方向!");
                                } else if (map[m][n - 2] == 3) {
                                    map[m][n - 2] = 5;
                                    map[m][n] = 0;
                                    n = n - 1;
                                    map[m][n] = 1;
                                } else {
                                    map[m][n - 2] = 2;
                                    map[m][n] = 0;
                                    n = n - 1;
                                    map[m][n] = 1;
                                }

                            }

                        } else if (map[m][n - 1] == 5) {

                            if (n - 1 == 0) {
                                System.out.println("已经到最上面了!");
                            } else {

                                if (map[m][n - 2] == 2) {
                                    System.out.println("上面有一个箱子,请重新选择方向");
                                    break;
                                } else if (map[m][n - 2] == 3) {
                                    map[m][n - 2] = 5;
                                    map[m][n] = 0;
                                    n = n - 1;
                                    map[m][n] = 4;
                                } else {

                                    map[m][n - 2] = 2;
                                    map[m][n] = 0;
                                    n = n - 1;
                                    map[m][n] = 4;

                                }

                            }

                        } else if (map[m][n - 1] == 3) {
                            map[m][n] = 0;
                            n = n - 1;
                            map[m][n] = 4;

                        } else {

                            map[m][n] = 0;
                            n = n - 1;
                            map[m][n] = 1;

                        }

                    }

                }
                break;
            case "S":

                if (m == map.length) {
                    System.out.println("小人已经到最上面了不能再走了!");
                } else {

                    if (map[m][n] == 4) {
                        if (map[m + 1][n] == 2) {

                            if (m + 1 == 0) {
                                System.out.println("箱子已经到顶了,请重新选择方向!");
                            } else {

                                if (map[m + 2][n] == 2) {
                                    System.out.println("下面还有一个箱子,请重新选择方向!");
                                } else if (map[m + 2][n] == 5) {
                                    System.out.println("下面还有一个箱子,请重新选择方向!");
                                } else if (map[m + 2][n] == 3) {
                                    map[m + 2][n] = 5;
                                    map[m][n] = 3;
                                    m = m + 1;
                                    map[m][n] = 1;
                                } else {
                                    map[m + 2][n] = 2;
                                    map[m][n] = 3;
                                    m = m + 1;
                                    map[m][n] = 1;
                                }

                            }

                        } else if (map[m + 1][n] == 5) {

                            if (m + 1 == map.length) {
                                System.out.println("已经到最下面了!");
                            } else {
                                map[m + 1][n] = 3;
                                if (map[m + 2][n] == 2) {
                                    System.out.println("下面有一个箱子,请重新选择方向");
                                    break;
                                } else if (map[m + 2][n] == 3) {
                                    map[m + 2][n] = 5;
                                    map[m][n] = 3;
                                    m = m + 1;
                                    map[m][n] = 4;
                                } else {

                                    map[m + 2][n] = 2;
                                    map[m][n] = 3;
                                    m = m + 1;
                                    map[m][n] = 4;

                                }

                            }

                        } else if (map[m + 1][n] == 3) {
                            map[m][n] = 3;
                            m = m + 1;
                            map[m][n] = 4;

                        } else {

                            map[m][n] = 3;
                            m = m + 1;
                            map[m][n] = 1;

                        }
                    } else {

                        if (map[m + 1][n] == 2) {

                            if (m + 1 == 0) {
                                System.out.println("箱子已经到顶了,请重新选择方向!");
                            } else {

                                if (map[m + 2][n] == 2) {
                                    System.out.println("上面还有一个箱子,请重新选择方向!");
                                } else if (map[m + 2][n] == 5) {
                                    System.out.println("上面还有一个箱子,请重新选择方向!");
                                } else if (map[m + 2][n] == 3) {
                                    map[m + 2][n] = 5;
                                    map[m][n] = 0;
                                    m = m + 1;
                                    map[m][n] = 1;
                                } else {
                                    map[m + 2][n] = 2;
                                    map[m][n] = 0;
                                    m = m + 1;
                                    map[m][n] = 1;
                                }

                            }

                        } else if (map[m + 1][n] == 5) {

                            if (m + 1 == 0) {
                                System.out.println("已经到最上面了!");
                            } else {

                                if (map[m + 2][n] == 2) {
                                    System.out.println("上面有一个箱子,请重新选择方向");
                                    break;
                                } else if (map[m + 2][n] == 3) {
                                    map[m + 2][n] = 5;
                                    map[m][n] = 0;
                                    m = m + 1;
                                    map[m][n] = 4;
                                } else {

                                    map[m + 2][n] = 2;
                                    map[m][n] = 0;
                                    m = m + 1;
                                    map[m][n] = 4;

                                }

                            }

                        } else if (map[m + 1][n] == 3) {
                            map[m][n] = 0;
                            m = m + 1;
                            map[m][n] = 4;

                        } else {

                            map[m][n] = 0;
                            m = m + 1;
                            map[m][n] = 1;

                        }

                    }

                }
                break;
            case "D":

                if (n == map.length) {
                    System.out.println("小人已经到最右面了不能再走了!");
                } else {

                    if (map[m][n] == 4) {
                        if (map[m][n + 1] == 2) {

                            if (n + 1 == 0) {
                                System.out.println("箱子已经到顶了,请重新选择方向!");
                            } else {

                                if (map[m][n + 2] == 2) {
                                    System.out.println("右面还有一个箱子,请重新选择方向!");
                                } else if (map[m][n + 2] == 5) {
                                    System.out.println("右面还有一个箱子,请重新选择方向!");
                                } else if (map[m][n + 2] == 3) {
                                    map[m][n + 2] = 5;
                                    map[m][n] = 3;
                                    n = n + 1;
                                    map[m][n] = 1;
                                } else {
                                    map[m][n + 2] = 2;
                                    map[m][n] = 3;
                                    n = n + 1;
                                    map[m][n] = 1;
                                }

                            }

                        } else if (map[m][n + 1] == 5) {

                            if (n + 1 == 0) {
                                System.out.println("已经到最上面了!");
                            } else {
                                map[m][n + 1] = 3;
                                if (map[m][n + 2] == 2) {
                                    System.out.println("上面有一个箱子,请重新选择方向");
                                    break;
                                } else if (map[m][n + 2] == 3) {
                                    map[m][n + 2] = 5;
                                    map[m][n] = 3;
                                    n = n + 1;
                                    map[m][n] = 4;
                                } else {

                                    map[m][n + 2] = 2;
                                    map[m][n] = 3;
                                    n = n + 1;
                                    map[m][n] = 4;

                                }

                            }

                        } else if (map[m][n + 1] == 3) {
                            map[m][n] = 3;
                            n = n + 1;
                            map[m][n] = 4;

                        } else {

                            map[m][n] = 3;
                            n = n + 1;
                            map[m][n] = 1;

                        }
                    } else {

                        if (map[m][n + 1] == 2) {

                            if (n + 1 == map.length) {
                                System.out.println("箱子已经到右边了,请重新选择方向!");
                            } else {

                                if (map[m][n + 2] == 2) {
                                    System.out.println("右面还有一个箱子,请重新选择方向!");
                                } else if (map[m][n + 2] == 5) {
                                    System.out.println("右面还有一个箱子,请重新选择方向!");
                                } else if (map[m][n + 2] == 3) {
                                    map[m][n + 2] = 5;
                                    map[m][n] = 0;
                                    n = n + 1;
                                    map[m][n] = 1;
                                } else {
                                    map[m][n + 2] = 2;
                                    map[m][n] = 0;
                                    n = n + 1;
                                    map[m][n] = 1;
                                }

                            }

                        } else if (map[m][n + 1] == 5) {

                            if (n + 1 == 0) {
                                System.out.println("已经到最上面了!");
                            } else {

                                if (map[m][n + 2] == 2) {
                                    System.out.println("上面有一个箱子,请重新选择方向");
                                    break;
                                } else if (map[m][n + 2] == 3) {
                                    map[m][n + 2] = 5;
                                    map[m][n] = 0;
                                    n = n + 1;
                                    map[m][n] = 4;
                                } else {

                                    map[m][n + 2] = 2;
                                    map[m][n] = 0;
                                    n = n + 1;
                                    map[m][n] = 4;

                                }

                            }

                        } else if (map[m][n + 1] == 3) {
                            map[m][n] = 0;
                            n = n + 1;
                            map[m][n] = 4;

                        } else {

                            map[m][n] = 0;
                            n = n + 1;
                            map[m][n] = 1;

                        }

                    }

                }
                break;
            default:

                System.out.println("您主动关闭程序了!");
                return;

            }
            System.out.println("小地图目前状态如下:");
            System.out.println("-------------------------------");
            for (int i = 0; i < map.length; i++) {
                for (int j = 0; j < map[i].length; j++) {
                    System.out.print(map[i][j] + "\t");
                }
                System.out.println();
            }
            if (map[boxK][boxL] == 5 && map[boxK1][boxL1] == 5) {
                System.out.println("您已经成功了!");

                return;
            }

        }

    }

}

xc164725
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java课程设计之推箱子
m0_49684834的博客
11-28 4018
推箱子游戏是一个比较古老的游戏，深受广大游戏爱好者的欢迎，它在带来乐趣的同时也能培养我们的反应力以及严谨的思维能力。 游戏规则是要求角色将地图中所有放置的箱子推到指定目标位置，只有合理安排移动次序和位置，才能顺利完成任务。 项目任务是用java语言设计并实现一个推箱子游戏，旨在培养学生面向对象编程思维方式，开发小型桌面应用程序的能力。 系统功能模块设计 其中系统可以分为初始化模块，绘制地图模块，移动箱子模块、移动小人模块，音乐播放模块，功能控制模块。 程序设计 主
Java小游戏-推箱子
m0_54570435的博客
04-23 2042
推箱子是来自于日本的一个古老游戏，目的是在于训练逻辑思维能力，在一个狭小的空间里，要把木箱推到指定的位置，稍不小心箱子就会无法移动或者被通道堵住的情况，所以需要巧妙的利用有限的空间和通道，合理安排移动的次序和位置，才能顺利的完成任务。在此游戏本着娱乐为目的，游戏者不仅可以在玩游戏的同时享受乐趣，游戏界面简单，操作容易，在玩游戏的同时还可以锻炼大家的反应速度和灵敏程度，在游戏中设置关卡，级别由低到高，一关比一关难，提高大家的兴趣，通过对小人的移动是否到达指定位置进行判断决定是否通关并进入下一关。
java课程设计之推箱子小游戏
Jsjsbaja的博客
06-14 1502
推箱子游戏是一个比较古老的游戏，深受广大游戏爱好者的欢迎，它在带来乐趣的同时也能培养我们的反应力以及严谨的思维能力。项目任务是用java语言设计并实现一个推箱子游戏，旨在培养学生面向对象编程思维方式，开发小型桌面应用程序的能力。游戏规则是要求角色将地图中所有放置的箱子推到指定目标位置，只有合理安排移动次序和位置 ，才能顺利完成任务。系统可以分为初始化模块，绘制地图模块，移动箱子模块，移动圆球模块，功能控制模块等。
Java实战推箱子——菜鸟之路
Puppet__的博客
10-23 6857
当时找了很久也没找到几个实战的教程视频，最后还是花了半天看了网络上的一些源码和思路然后来写了这个。总体感觉自己写的还是很烂，写这个的时候自己并没有写地图，而是引用了网络上的地图（用0~9来标记不同的图真的是给绘制地图较低了很大一部分难度）。 先来说一下要来做什么，我们想要实现的就是传统的推箱子小游戏。那传统的推箱子小游戏有什么，他的背景很大，并且你需要不同的地方来标志你的地图，以......
java版本实现推箱子小游戏
meisir666的博客
11-18 4624
java版本实现推方块小游戏
java实现二维数组推箱子小游戏
qq_47627490的博客
11-13 2488
推箱子小游戏 import java.util.Scanner; public class 推箱子 { public static void main(String[] args) { int x =3, y =3;// 定义玩家的坐标 boolean finish=false; //定义一个布尔型变量初始值为false Scanner in = new Scanner(System.in); int map[][]={ {0,0,1,1,1,0,0,0}, //0表示黑色区
推箱子（C语言）（二维数组）
03-17
2.基于二维数组的实现 3.元素：R表示人，X表示箱子，*表示墙 4.实现人推箱子走，碰到墙不走 5.代码共230行，有注释及代码介绍，易理解学习 6.对二维数组的拓展学习很有帮助 7.我还有其他资源，欢迎询问获取 8.若代码...
使用JAVA开发的一款推箱子游戏.zip
01-09
基于JAVA的推箱子游戏系统主要用于实现游戏推箱子功能，提供多种不同难度的关卡。本系统结构如下： （1）初始化模块: 该模块包括屏幕初始化和游戏第一关的初始化。屏幕初始化用于输出欢迎信息和操 （2）画图模块: 该...
java小游戏 推箱子 java小游戏 推箱子
06-23
java小游戏 推箱子java小游戏 推箱子java小游戏 推箱子java小游戏 推箱子java小游戏 推箱子java小游戏 推箱子java小游戏 推箱子java小游戏 推箱子java小游戏 推箱子java小游戏 推箱子java小游戏 推箱子java小游戏 推...
java实现简单的推箱子小游戏
08-19
"Java实现简单的推箱子小游戏...Java实现简单的推箱子小游戏是一个不错的选择，使用Java可以快速地实现游戏的逻辑和界面。游戏的设计和实现需要考虑多个方面，包括游戏的界面设计、游戏的逻辑实现和游戏的音效和音乐。
java版推箱子小游戏
10-29
java推箱子小游戏，游戏分为50个关卡，难度依次递增，游戏可以自己设置背景音乐
java版简易版推箱子游戏
04-08
运行swing制作 使用eclipse软件制作 推箱子各种关卡 压缩包里面图片 map 都存在
基于Java的推箱子游戏设计与源码实现.rar
02-27
此次毕业设计基于Java语言，将游戏地图做成通用的关卡设计，关卡用二维数组实现，在二维数组中设置值域来表示不同对象，运用二维数组的遍历算法来加载对应图片实现了游戏图片初始化状态。同时，通过初始化多个不同...
PP.rar_java推箱子_推箱子 java_推箱子JAVA
09-22
推箱子游戏，也称为 Sokoban，是一种经典的逻辑益智游戏，玩家需要在二维网格环境中移动一个角色（在这里可能是“炮炮兵”），将箱子推到指定的位置。此项目可能包含源代码、资源文件以及可能的执行程序，以展示如何...
java带音乐版推箱子源码及素材
09-02
4. **游戏逻辑实现**：推箱子游戏的核心在于玩家与箱子的移动规则，包括箱子只能被推动、不能被拉动、不能通过已放置的箱子等，这部分需要使用到数据结构（如二维数组）和算法来实现。 5. **音乐播放**：Java的...
【经典项目】Java小游戏 —— 推箱子
最新发布
m0_46013789的博客
02-02 1346
用Java实现推箱子的小游戏，推箱子是一种益智解谜类的小游戏，玩家需要通过推动箱子将它们放置到指定的位置，以完成关卡的任务。
【java毕业设计】基于java+swing+Eclipse的推箱子游戏设计与实现（毕业论文+程序源码）——推箱子游戏
m0_66238867的博客
06-23 6891
大家好，今天给大家介绍基于java+swing+Eclipse的推箱子游戏设计与实现，文章末尾附有本毕业设计的论文和源码下载地址哦。文章目录： 项目难度：中等难度 适用场景：相关题目的毕业设计 配套论文字数：31887个字 包含内容：整套源码+完整毕业论文+答辩PPT+任务书+辅导视频+运行截图提示：以下为毕业设计的简略介绍，项目源码及完整毕业论文下载地址见文末。引 言 策略性游戏可以锻炼人的思维能力还能缓解人的压力，使人们暂时忘却生活当中的烦恼，增强人们的逻辑思维能力，游戏的艺术美也吸引着越来越多的
基于java的推箱子游戏系统设计与实现
m0_62396648的博客
12-19 1248
推箱子游戏是经典的计算机游戏之一，由于其简单的规则和易于上手的操作，深受广大玩家的喜爱。本文将介绍基于Java的推箱子游戏系统设计与实现的系统性能评估的总结和分析。首先，该系统由三部分组成：玩家控制部分、机器人控制和游戏控制部分。玩家控制部分负责控制玩家的移动和操作，机器人控制部分负责控制机器人的移动和操作，游戏控制部分负责控制游戏的全局控制和游戏状态的管理。其次，该系统采用基于事件驱动的开发方式，将游戏中的事件分为四个主要类型：玩家移动、机器人移动、箱子移动和游戏状态。
推箱子游戏设计与实现（Java+swing+JAWT）
毕业作品网站
11-07 3448
建造这样一个系统的目的是为了考察某一方面的可行性，如算法的可行性,技术的可行性,或考察是否满足用户的需求等。就是从系统角度来理解软件,确定对所开发系统的综合要求,并提出这些需求的实现条件,以及需求应该达到的标准.这些需求包括：功能需求(做什么),性能需求(要达到什么指标),环境需求(如机型,操作系统等),可靠性需求(不发生故障的概率）,安全保密需求,用户界面需求,资源使用需求(软件运行是所需的内存,CPU等),软件成本消耗与开发进度需求,预先估计以后系统可能达到的目标。原型化方法是十分重要的。
Java实现的推箱子游戏设计与实现
通过遍历二维数组，程序可以方便地处理游戏状态，如检查当前位置是否可移动、是否存在箱子等。 3. **游戏地图与关卡设计** 关卡设计是游戏的核心部分。通过初始化不同的二维数组，开发者可以创建多个具有不同挑战...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值