数据结构- 炸弹人游戏

已于 2022-11-24 09:20:29 修改
阅读量822 收藏 2
点赞数
分类专栏： 找工作-数据结构学习 文章标签： 数据结构 游戏 算法
于 2022-11-23 08:42:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43110298/article/details/127993282
版权

1. 基本任务介绍

算法目的：炸弹放在哪里可以最大杀伤？
编程难点：

  1. 数组作为形参是深（是）？如果深，有必要应用？
    答：形参是实参的一份拷贝，是局部变量。但是数组是个例外，因为数组的数据太多了，将其一一赋值既麻烦又浪费空间，所以数组作为参数传递给函数的只是数组首元素的地址，数据还是在内存里的，函数在需要用到后面元素时再按照这个地址和数组下标去内存查找。也就是说后面的元素根本没到函数里来。因为数组的复制将导致连续的内存读与内存写，其时间开销取决于数组长度，有可能会变得非常大。为了避免复制数组的开销，才用指针代替数组。因此C语言使得当数组作为实参传递给函数的时候，将退化为同类型的指针，再传递指针的值。
    因此，在函数中修改数组值时，修改的是真的值。
  • 由于是通过指针传递，因此无法得到数组的长度。（在通过指针传递时，需要另外传入参数来传递数组的大小）
  • 传递引用时，同时将数组长度也传递进去了，所以传入时必须为相应长度的数组。并且，在传递引用时，需要注意用（）将&aa括起来，否则编译器报错。
  1. 二维数组形参和一维不太一样
  • (Type (&str_)[size], char map_[][13]) 后面的13好像不能少
  1. 不能纯统计每行列的敌人，有墙的

代码


// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
# include <string>
#include<iostream>
using namespace std;
char map_[13][13] = {0
  };
std::string map2[] = {
    "#############",
"#GG.GGG#GGG.#",
"###.#G#G#G#G#",
"#.......#..G#",
"#G#.###.#G#G#",
"#GG.GGG.#.GG#",
"#G#.#G#.#.#.#",
"##G...G.....#",
"#G#.#G###.#G#",
"#...G#GGG.GG#",
"#G#.#G#G#.#G#",
"#GG.GGG#G.GG#",
"#############",
};
 int lines = sizeof(map_) / sizeof(map_[0][0]); //总共多长
    int col = sizeof(map_[0])/ sizeof(map_[0][0]); 
    int row = lines / col;
template <typename  Type, int size>
void string2char(Type (&str_)[size], char map_[][13]) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < str_[i].size(); j++) {
            map_[i][j] = str_[i][j];
        }
    }
}

int get_range1(int i, int j) {
    int num = 0;
    for (int i_ = 0; i_ < row; i_++) {
        if (map_[i_][j] == 'G') num += 1;
        //num += map_[i_][j];
    }
    for (int i_ = 0; i_ < col; i_++) {
        if (map_[i][i_] == 'G') num += 1;
        //num += map_[i][i_];
    }
    return num;
}
int get_direction(int  currenti, int  currentj, int direction[2]) {
    int num = 0;
    while ((currenti >= 0 && currenti <= row)&&((currentj >= 0 && currentj <= col) )) {
        currenti += direction[0];
        currentj += direction[1];

        if (map_[currenti][currentj] == 'G') 
            num += 1;
        if (map_[currenti][currentj] == '#')
            break;
        
    }
    return num;
}
int get_range(int i, int j) {
    int num = 0;
    int currenti=i, currentj=j;
    int direction[][2] = {
        {1,0},
        {0,1},
        {-1,0},
        {0,-1}
    };
    for (auto d : direction) {
        num += get_direction(i, j, d);
    }
    return num;
}




void main() {
    string2char(map2, map_);
    int i = 0;
    // 遍历所有 map_ 的点位
    int num_ = 0;
    int maxi = 0;
    int maxj = 0;
    int max_num = 0;
    for (int i = 0; i < row;i++) {
        for (int j = 0; j < col; j++) {
            if (map_[i][j] == '.') {
                num_ = get_range(i, j);
                if (num_ > max_num) {
                    maxi = i;
                    maxj = j;
                    max_num = num_;
                }
            }
                

        }
    }
    cout << maxi << "," << maxj << endl;
    return;
}

2. 基于广度搜索的炸弹人算法

// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
# include <string>
#include<iostream>
using namespace std;
char map_[13][13] = {0
  };
std::string map2[] = {
    "#############",
"#GG.GGG#GGG.#",
"###.#G#G#G#G#",
"#.......#..G#",
"#G#.###.#G#G#",
"#GG.GGG.#.GG#",
"#G#.#G#.#.#.#",
"##G...G.....#",
"#G#.#G###.#G#",
"#...G#GGG.GG#",
"#G#.#G#G#.#G#",
"#GG.GGG#G.GG#",
"#############",
};
 int lines = sizeof(map_) / sizeof(map_[0][0]); //总共多长
    int col = sizeof(map_[0])/ sizeof(map_[0][0]); 
    int row = lines / col;
template <typename  Type, int size>
void string2char(Type (&str_)[size], char map_[][13]) {
    for (int i = 0; i < size; i++) {
        for (int j = 0; j < str_[i].size(); j++) {
            map_[i][j] = str_[i][j];
        }
    }
}

int get_direction(int  currenti, int  currentj, int direction[2]) {
    int num = 0;
    while ((currenti >= 0 && currenti <= row)&&((currentj >= 0 && currentj <= col) )) {
        currenti += direction[0];
        currentj += direction[1];

        if (map_[currenti][currentj] == 'G') 
            num += 1;
        if (map_[currenti][currentj] == '#')
            break;
        
    }
    return num;
}
int get_range(int i, int j) {
    int num = 0;
    int currenti=i, currentj=j;
    int direction[][2] = {
        {1,0},
        {0,1},
        {-1,0},
        {0,-1}
    };
    for (auto d : direction) {
        num += get_direction(i, j, d);
    }
    return num;
}


// ---------------

// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <queue>
#include<vector>
#include<string>
using namespace std;

struct Point {
	//行与列
	int row;
	int col;
	int step = 0;
	int range = -1;

	//默认构造函数
	Point() {
		row = col = -1;
	}

	Point(int x, int y, int step_ = 0) {
		this->row = x;
		this->col = y;
		step = step_;
	}

	bool operator==(const Point& rhs) const {
		if (this->row == rhs.row && this->col == rhs.col)
			return true;
		return false;
	}
};


class Pos_find {
public:
	int maze[13][13];
	int passed[13][13];
	int neighbour[4][2] = {
		{1,0},
		{0,1},
		{-1,0},
		{0,-1}
	};	
	int row = sizeof(maze) / sizeof(maze[0]);
	int col = sizeof(maze[0]) / sizeof(maze[0][0]);
	int range_map[13][13] = { 0 }; //[]TODO: int range_map[row][col] = { 0 }; 为什么报错
	int obstacles = -1, blank = 0, enemy=-2;
	queue<Point> vecPath;
	Point ** mark = 0;
	template <class  T1, class  T2>
	bool valid_point(Point point, T1 obstacles = -1, T2 blank = 0) {
		//判断点是否可以作为下一 1 障碍物 2 边界 3 未走过
		int row = sizeof(maze) / sizeof(maze[0]);
		int col = sizeof(maze[0]) / sizeof(maze[0][0]);

		// 判断障碍物
		if (maze[point.row][point.col] == obstacles) {
			return false;
		}
		if (enemy != -2 && (maze[point.row][point.col] == enemy)) {
			return false;
		}

		// 判断边界
		if ((point.row < 0 || point.row > row - 1) || (point.col < 0 || point.col > col - 1))
			return false;

		else
			// 未走过
			if (passed[point.row][point.col] == 0)
				return true;
			else {
				cout << "wrong in valid" << endl;
				return false;
			}
	}

 
	int get_range(int i, int j) {
		int num = 0;
		//int currenti = i, currentj = j;
		int direction[][2] = {
			{1,0},
			{0,1},
			{-1,0},
			{0,-1}
		};
		for (auto d : direction) {
			num += get_direction(i, j, d);
		}
		return num;
	}

	int get_direction(int  currenti, int  currentj, int direction[2]) {
		int num = 0;
		while ((currenti >= 0 && currenti <= row) && ((currentj >= 0 && currentj <= col))) {
			currenti += direction[0];
			currentj += direction[1];

			if (maze[currenti][currentj] == 'G')
				num += 1;
			if (maze[currenti][currentj] == '#')
				break;

		}
		return num;
	}

	// 修改地图
	template <typename  Type, int size>
	void string2char(Type(&str_)[size]) {
		for (int i = 0; i < size; i++) {
			for (int j = 0; j < str_[i].size(); j++) {
				maze[i][j] = str_[i][j];
			}
		}
		obstacles = '#';
		blank = '.';
		enemy = 'G';

	}

	void mazePath( Point& start_pos, Point& target_pos) {
		vecPath = queue<Point>();// build a empty queue
		vecPath.push(start_pos);
		maze[start_pos.row][start_pos.col] = 1;
		int flag = 0;
		int row = sizeof(maze) / sizeof(maze[0]);
		int col = sizeof(maze[0]) / sizeof(maze[0][0]);
		Point temp_point, new_point;
		int i = 1;
		// 建立一个二维数组，每个数组里面是Point
		Point** mark = new Point * [row];//[TODO] 这里不需要释放吗？
		//for (auto ) // ?auto 吗？[TODO]
		for (int i = 0; i < row; i++) {
			mark[i] = new Point[col];
		}
		// 开始的格子指向自己
		mark[0][0] = start_pos;
		// 指向数组的指针
		while (vecPath.empty() == false) {
			// 取
			temp_point = vecPath.front();
			// 获取相邻值
			for (auto deta : neighbour) {
				new_point = Point(temp_point.row + deta[0], temp_point.col + deta[1], temp_point.step + 1);
				if (valid_point(new_point, obstacles, blank)) { // 如果点可以加入
					maze[new_point.row][new_point.col] = temp_point.step + 1;
					mark[new_point.row][new_point.col] = temp_point;// 放入父节点
					vecPath.push(new_point);
				}
				if (new_point == target_pos) {
					flag = 1;
					break;
				}
			}
			vecPath.pop();
			if (flag == 1) break;
			i++;
		}

		if (vecPath.empty() == false) {
			// 获取最后一个格子的数值
			temp_point = vecPath.back();
			// 依据最后一个获取前一个
			while ((temp_point.row == start_pos.row && temp_point.col == start_pos.col) == false) {
				cout << " <" << temp_point.row << "," << temp_point.col << "> ";
				temp_point = mark[temp_point.row][temp_point.col];
			}
		}
		return;
	}

	void mazePath(Point& start_pos) {
		int num_ = 0;
		int maxi = 0;
		int maxj = 0;
		int max_num = 0;
		vecPath = queue<Point>();// build a empty queue
		vecPath.push(start_pos);
		//maze[start_pos.row][start_pos.col] = 1; []TODO:记录步伐应该放在一起，这种容易漏掉。
		max_num = get_range(start_pos.row, start_pos.col);
		range_map[start_pos.row][start_pos.col] = max_num;
		passed[start_pos.row][start_pos.col] = 1;
		int flag = 0;

		Point temp_point, new_point;
		int i = 1;
		// 建立一个二维数组，每个数组里面是Point
		Point** mark = new Point * [row];//[TODO] 这里不需要释放吗？		
		//for (auto ) // ?auto 吗？[TODO]
		for (int i = 0; i < row; i++) {
			mark[i] = new Point[col];
		}
		// 开始的格子指向自己
		mark[0][0] = start_pos;



		// 指向数组的指针
		while (vecPath.empty() == false) {
			// 取
			temp_point = vecPath.front();
			// 获取相邻值
			for (auto deta : neighbour) {
				new_point = Point(temp_point.row + deta[0], temp_point.col + deta[1], temp_point.step + 1);
				if (valid_point(new_point, obstacles, blank)) { // 如果点可以加入
					//maze[new_point.row][new_point.col] = temp_point.step + 1; //[x]TODO: 随意修改成员变量不是好习惯 - > 新编量记录走过的地方
					num_ = get_range(new_point.row, new_point.col);
					range_map[new_point.row][new_point.col] = num_;
					mark[new_point.row][new_point.col] = temp_point;// 放入父节点
					passed[new_point.row][new_point.col] = temp_point.step + 1;
					vecPath.push(new_point);
					if (num_ > max_num) {
						maxi = new_point.row;
						maxj = new_point.col;
						max_num = num_;
					}
				}
			}
			vecPath.pop();
			//if (flag == 1) break;
			i++;
		}
		// 找到最大的点
		cout << max_num << endl;
		return;
	}
};  //[TODO] warning :警告	C26495	未初始化变量 Pos_find::mark。始终初始化成员变量(type.6)。	 	238  解决加 Point ** mark = 0;
 
int main()
{
	// 

	Pos_find map_;
	Point start_pt = Point(1, 3), end_pt = Point(4,4);

	//map_.mazePath(start_pt, end_pt);

	//  任务二
	// 修改地图
	map_.string2char(map2);
	map_.mazePath(start_pt);
}
Luna_Lovegood_001
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java小游戏-炸弹人-课程设计-论文-AI
12-29
完成像小时候玩的炸弹人游戏，或模仿4399小游戏中的泡泡堂 主要模块如下 游戏相关：换关卡、操作玩家、AI电脑、背景音乐、数值提升 游戏管理：重开、暂停/开始、退出、切换模式、音乐开关 关卡管理：关卡显示、关卡...
数据结构（c++）--炸弹人游戏（BFS）
qq_63533863的博客
07-14 1788
找出炸弹放在哪里消灭的敌人最多 样例输入： 样例输出：
【算法与数据结构】55、45、LeetCode跳跃游戏 I 、II
晚安的博客
12-18 1005
所有的LeetCode题解索引，可以看这篇文章——。
数据结构和算法(十)递归-迷宫游戏
yuan_xw的专栏
08-25 666
1. 数据结构和算法(十)递归-迷宫游戏 1.1 迷宫游戏   今天做一个简单的迷宫游戏，用二维数实现地图，让程序自动寻路的小游戏。 1.2 简单的迷宫 简单的迷宫 用二维数实现地图，找路策略：【右->下->左->上】方式进行找路， 0：表示是路 1：表示迷宫墙 2：表示是通路 3:表示是不通。 package com.yuanxw.datastructure.chapter10; /** * 简单的迷宫 * 迷宫寻路的方法： * 找路策略：【右->下->左
C++炸弹人小游戏
m0_66765541的博客
04-30 1490
谁说C++没有炸弹人
数据结构课程设计：约瑟夫生者死者游戏（c++实现、单循环链表、输出死者姓名和编号、附可执行源代码）
m0_64336416的博客
06-23 5441
（c++、单循环链表）有N个旅客同乘一条船，因为严重超载，加上风高浪大，危险万分；因此船长告诉乘客，只有将全船一半的旅客投入海中，其余人才能幸免于难；无奈，大家只得同意这种办法，并议定N个人围成一圈，由第一个人开始，依次报数，数到第9人，便把他投入大海中，然后再从他的下一个人开始，数到第9人，再把他投入大海中，如此循环地进行，直到剩下N/2个乘客为止。问哪些乘客是将被投入大海的？输出这些乘客的姓名和位置。......
java炸弹人游戏.zip
07-19
java课程设计大作业，java、算法练手项目，适合初学java、数据结构的同学拿来学习研究，基于java、GUI开发的小游戏，程序都经过测试，可以直接运行，资源含程序运行所需的源码、资源文件等全部数据，有需要的可放心...
dungeons-and-data-structures:2020年AI运动挑战赛的地牢和数据结构游戏环境
05-16
此存储库包含2020版地下城与数据结构的游戏和文档。 您可以练习练习它，但是在挑战赛开始的4月22日下午5点（澳大利亚东部标准时间）将发布新的游戏和文档。 加入我们的并检查您的电子邮件（在注册后），以了解最新...
java源码包---java 源码 大量 实例
04-18
　Java 3DMenu 界面源码，有人说用到游戏中不错，其实平时我信编写Java应用程序时候也能用到吧，不一定非要局限于游戏吧，RES、SRC资源都有，都在压缩包内。 Java zip压缩包查看程序源码 1个目标文件 摘要:Java源码...
成百上千个Java 源码DEMO 4(1-4是独立压缩包)
03-29
Java 3DMenu 界面源码 5个目标文件 内容索引:Java源码,窗体界面,3DMenu Java 3DMenu 界面源码，有人说用到游戏中不错，其实平时我信编写Java应用程序时候也能用到吧，不一定非要局限于游戏吧，RES、SRC资源都有，都...
一些数据结构小游戏
05-18
一些使用Java编写的数据结构小游戏，学期末了，各种课程设计纷至沓来~望大家好运，祝考得好成绩！
数据结构小游戏
04-25
数据结构的小游戏，C语言程序设计 是打发似的发的萨芬
数据结构纸牌游戏
06-19
数据结构纸牌游戏好用！编号为1-52张牌，正面向上 2. 从第2张开始，以2为基数，是2的倍数的牌翻一次，直到最后一张牌；然后，从第3张开始，以3为基数，是3的倍数的牌翻一次，直到最后一张牌；然后从第4张开始，以4为基数，是4的倍数的牌翻一次， 直到最后一张牌；...再依次5的倍数的牌翻一次，6的，7的直到以52为基数的翻过 3. 输出：这时正面向上的牌
数据结构-走迷宫游戏
m0_54570435的博客
04-26 836
设a[p][q]为A的第一个元素，即二维数组的行下标从p到m+p，列下标从q到n+q，按"行优先顺序"存储时则元素a[i][j]的地址，按"列优先顺序"存储时的地址。如果创建随机迷宫输入1，接下来程序会自动创建随机迷宫，并对迷宫进行寻找出口操作，有出口则显示含有出口路径的迷宫图，没有出口则显示：没有找到出口！用户首先根据提示输入迷宫行数列数，再选择创建随机迷宫还是自定义迷宫（1为随机迷宫，2为自定义迷宫）。printf("请选择创建随机迷宫还是自定义迷宫（1为随机迷宫，2为自定义迷宫）:");
数据结构--格子游戏
是芜湖的，更是世界的！
06-20 1105
并查集--格子游戏
C++/数据结构——课程设计——回合制对战小游戏
eeeee
03-20 7354
数据结构的课程设计
射击游戏
LIUZHIOJ的博客
06-20 307
include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; int main() { int shoot = 0,step = 0;//是否射中。操作次数 int Wide = 5,Long = 10;//初始位置 int x; int y; char m;//移动指令 int Rand; int X...
数据结构在游戏中的简单应用
weixin_30540691的博客
04-10 870
　　在游戏的编写中，不可避免的出现很多应用数据结构的地方，有些简单的游戏，只是由几个数据结构的组合，所以说，数据结构在游戏编程中扮演着很重要的角色。　　本文主要讲述数据结构在游戏中的应用，其中包括对链表、顺序表、栈、队列、二叉树及图的介绍。读者在阅读本文以前，应对数据结构有所了解，并且熟悉C/C++语言的各种功用。好了，现在我们由链表开始吧！1、链表　　在这一节中，我们将通过一个类似雷电的飞机射击...
从0开始的数据结构的书写-------线性表（单链表）
最新发布
xp_xht123的博客
04-30 192
从0开始的数据结构的书写-------线性表（单链表）
pygame炸弹人游戏源码提取
04-30
同时，还可以学习到代码优化和模块化设计的思路，以及游戏开发中常用的数据结构和算法。 总之，Pygame炸弹人游戏源码提取是一项非常有价值的学习和探索任务，可以提高游戏开发和编程技能，也可以为日后的游戏开发...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值