EESAST
/
THUAI6
Not watched
1
0
Fork 0
Code
Releases 3 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branch: dev
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dev'
${ noResults }
THUAI6/players/ChatGPA/player5.cpp

995 lines
39 kB
Raw Permalink Blame History 

  1. #include <array>

  2. #include <cmath>

  3. #include <queue>

  4. #include <sstream>

  5. #include <stack>

  6. #include <thread>

  7. #include <utility>

  8. #include <vector>

  9. #include "AI.h"

  10. #include "constants.h"

  11. #define PI 3.14159265358979323846

  12. 

  13. // 为假则play()期间确保游戏状态不更新，为真则只保证游戏状态在调用相关方法时不更新

  14. extern const bool asynchronous = false;

  15. 

  16. // 选手需要依次将player0到player4的职业在这里定义

  17. extern const std::array<THUAI6::StudentType, 4> studentType = {

  18. 	THUAI6::StudentType::StraightAStudent,

  19. 	THUAI6::StudentType::StraightAStudent,

  20. 	THUAI6::StudentType::StraightAStudent,

  21. 	THUAI6::StudentType::StraightAStudent

  22. };

  23. 

  24. extern const THUAI6::TrickerType trickerType = THUAI6::TrickerType::Assassin;

  25. 

  26. //可以在AI.cpp内部声明变量与函数

  27. struct CellPos {

  28. 	int x, y;

  29. };

  30. struct GridPos {

  31. 	int x, y;

  32. };

  33. 

  34. class Action;

  35. class BFS;

  36. class Communication;

  37. class Escape;

  38. class GameState;

  39. 

  40. class Action {

  41. public:

  42. 	enum class Direction {

  43. 		null, up, down, left, right,

  44. 		up_left, up_right, down_left, down_right

  45. 	};															//移动方式

  46. 	static const std::vector <Direction> allMove;				//所有的移动方式

  47. 	static int isAtCellFalseCnt;

  48. 	static int classNo;											//要去的教室位置

  49. 	static CellPos lastNextPos;

  50. 	static CellPos lastDesPos;

  51. 	static Direction lastMove;

  52. 	static CellPos PredictPos;

  53. 

  54. 	static bool isValidMove(CellPos judgePos, Direction comeDir, GameState state, IStudentAPI& api);

  55. 	static bool isValidMove(CellPos judgePos, Direction comeDir, GameState state, ITrickerAPI& api);

  56. 	static double getAngle(GridPos grid1, GridPos grid2);													//计算两点间方位角

  57. 	static void Move(CellPos des, IStudentAPI& api);

  58. 	static void Move(CellPos des, ITrickerAPI& api);

  59. 	static void Move(Direction directon, IStudentAPI& api);

  60. 	static void Move(Direction direction, ITrickerAPI& api);

  61. 	static CellPos directionToPos(CellPos nowPos, Direction direction);										//根据当前坐标和移动方式计算出下一个坐标

  62. 	static Direction posToDirection(CellPos nowPos, CellPos nextPos);										//目标点的坐标转化为移动方式

  63. };

  64. class BFS {

  65. public:

  66. 	static bool vis[Constants::rows][Constants::cols];

  67. 	static CellPos now;

  68. 	static CellPos nxt;

  69. 	static CellPos pre[Constants::rows][Constants::cols];

  70. 

  71. 	static std::pair<CellPos, int> bfs(CellPos start, CellPos destination, ITrickerAPI& api);

  72. 	static std::pair<std::pair<CellPos, CellPos>, int> bfs(CellPos start, THUAI6::PlaceType destination, ITrickerAPI& api);		//return pair<next_point,destination>

  73. };

  74. class Communication {

  75. public:

  76. 	static void receiveMessage(IStudentAPI& api, int64_t myID);

  77. 	static void sendClassroomPos(IStudentAPI& api, int64_t myID, CellPos classroomPos);

  78. 	static void sendTrickerPos(IStudentAPI& api, int64_t myID);

  79. 	/*

  80. 		通信协议：AA BB CC DD

  81. 		（AA, BB)为学完的教室的坐标

  82. 		（CC, DD)为看到的捣蛋鬼的坐标

  83. 		若AA, BB均为-1，则忽略教室坐标，只读捣蛋鬼坐标

  84. 		若CC, DD均为-1，则忽略捣蛋鬼坐标，只读教室坐标

  85. 	*/

  86. };

  87. class Escape {

  88. public:

  89. 	//static std::pair<CellPos, Action::Direction> minimax(CellPos start, THUAI6::PlaceType destination);   //规避算法

  90. };

  91. class GameState {

  92. public:

  93. 	static int readCnt;

  94. 	static int clsFinishCnt;

  95. 	THUAI6::PlaceType gameMap[Constants::rows][Constants::cols];				//存图信息

  96. 	std::vector <CellPos> ClassRoom;

  97. 	std::vector <CellPos> Gate;

  98. 	std::vector <CellPos> HiddenGate;

  99. 	std::vector <CellPos> Window;

  100. 	std::vector <CellPos> Door3;

  101. 	std::vector <CellPos> Door5;

  102. 	std::vector <CellPos> Door6;

  103. 	std::vector <CellPos> Chest;

  104. 	std::vector <std::pair<GridPos,int>> ValidMoveBuffer;

  105. 	CellPos studentPos[4];									//四个学生的坐标

  106. 	GridPos studentGrid[4];

  107. 	CellPos trickerPos;										//捣蛋鬼的坐标

  108. 

  109. 	bool isAtCell(GridPos myPos, GridPos cellPos) const;										//判断人物是否完全在格点内

  110. 	bool isAtPosition(CellPos myPos, CellPos pos) const;

  111. 	bool isAtPos(CellPos myPos, CellPos pos) const;		//判断character坐标与pos坐标是否在一个九宫格内

  112. 	bool isAttackable(GridPos trickerPos, GridPos studentPos) const;							//判断是否可以攻击

  113. 	bool isClassroomFinished(CellPos classroomPos, IStudentAPI& studentapi) const;				//判断教室是否学完了

  114. 	bool isDoor(CellPos pos) const;

  115. 	bool isGateFinished(CellPos gatePos, IStudentAPI& api) const;								//判断大门是否开了

  116. 	bool isTrickerVisible() const;																//判断tricker是否可见

  117. 	bool isType(CellPos pos, THUAI6::PlaceType type) const;

  118. 	bool canReach(CellPos pos, ITrickerAPI& api) const;

  119. 	bool readyToGraduate() const;																//判断当前局面是否可毕业

  120. 	double gridDistance(GridPos grid1, GridPos grid2) const;									//计算两点间以grid计的距离

  121. 	void deleteStudiedClassroom(CellPos classroomPos);											//把学完的教室删除，变成墙

  122. 	void getMap(IStudentAPI& api);																//获取地图格点信息

  123. 	void getMap(ITrickerAPI& api);																//获取地图格点信息

  124. 	std::pair<std::pair<bool, std::pair<CellPos, GridPos>>, std::pair<double, double>> getClosestStudent(GridPos trickerPos, ITrickerAPI& api);		//找到视野中最近的学生

  125. 	//CellPos isGrassAround(CellPos, IStudentAPI& api) const;

  126. };

  127. 

  128. const std::vector <Action::Direction> Action::allMove = {

  129. 	Direction::up,

  130. 	Direction::down,

  131. 	Direction::left,

  132. 	Direction::right,

  133. 	Direction::up_left,

  134. 	Direction::up_right,

  135. 	Direction::down_left,

  136. 	Direction::down_right

  137. };

  138. int Action::isAtCellFalseCnt = 0;

  139. int Action::classNo = 0;

  140. CellPos Action::lastNextPos = { -1,-1 };

  141. Action::Direction Action::lastMove = Direction::null;

  142. CellPos Action::lastDesPos = { -1,-1 };

  143. bool BFS::vis[Constants::rows][Constants::cols] = { false };

  144. CellPos BFS::now = { -1,-1 };

  145. CellPos BFS::nxt = { -1,-1 };

  146. CellPos BFS::pre[Constants::rows][Constants::cols] = { {-1,-1} };

  147. 

  148. int GameState::readCnt = 0;

  149. int GameState::clsFinishCnt = 0;

  150. GameState gameState;

  151. 

  152. bool Action::isValidMove(CellPos judgePos, Direction comeDir, GameState state, IStudentAPI& api)

  153. {

  154. 	auto students = api.GetStudents();

  155. 

  156. 	for (auto it = students.begin(); it != students.end(); it++)

  157. 	{

  158. 

  159. 		state.gameMap[api.GridToCell((*it)->x)][api.GridToCell((*it)->y)] = THUAI6::PlaceType::Wall;

  160. 		state.gameMap[api.GridToCell((*it)->x + 390)][api.GridToCell((*it)->y)] = THUAI6::PlaceType::Wall;

  161. 		state.gameMap[api.GridToCell((*it)->x - 390)][api.GridToCell((*it)->y)] = THUAI6::PlaceType::Wall;

  162. 		state.gameMap[api.GridToCell((*it)->x)][api.GridToCell((*it)->y + 390)] = THUAI6::PlaceType::Wall;

  163. 		state.gameMap[api.GridToCell((*it)->x)][api.GridToCell((*it)->y - 390)] = THUAI6::PlaceType::Wall;

  164. 		state.gameMap[api.GridToCell((*it)->x + 280)][api.GridToCell((*it)->y + 280)] = THUAI6::PlaceType::Wall;

  165. 		state.gameMap[api.GridToCell((*it)->x + 280)][api.GridToCell((*it)->y - 280)] = THUAI6::PlaceType::Wall;

  166. 		state.gameMap[api.GridToCell((*it)->x - 280)][api.GridToCell((*it)->y + 280)] = THUAI6::PlaceType::Wall;

  167. 		state.gameMap[api.GridToCell((*it)->x - 280)][api.GridToCell((*it)->y - 280)] = THUAI6::PlaceType::Wall;

  168. 	}

  169. 	auto trickers = api.GetTrickers();

  170. 	for (auto it = trickers.begin(); it != trickers.end(); it++)

  171. 	{

  172. 		state.gameMap[api.GridToCell((*it)->x)][api.GridToCell((*it)->y)] = THUAI6::PlaceType::Wall;

  173. 		state.gameMap[api.GridToCell((*it)->x + 390)][api.GridToCell((*it)->y)] = THUAI6::PlaceType::Wall;

  174. 		state.gameMap[api.GridToCell((*it)->x - 390)][api.GridToCell((*it)->y)] = THUAI6::PlaceType::Wall;

  175. 		state.gameMap[api.GridToCell((*it)->x)][api.GridToCell((*it)->y + 390)] = THUAI6::PlaceType::Wall;

  176. 		state.gameMap[api.GridToCell((*it)->x)][api.GridToCell((*it)->y - 390)] = THUAI6::PlaceType::Wall;

  177. 		state.gameMap[api.GridToCell((*it)->x + 280)][api.GridToCell((*it)->y + 280)] = THUAI6::PlaceType::Wall;

  178. 		state.gameMap[api.GridToCell((*it)->x + 280)][api.GridToCell((*it)->y - 280)] = THUAI6::PlaceType::Wall;

  179. 		state.gameMap[api.GridToCell((*it)->x - 280)][api.GridToCell((*it)->y + 280)] = THUAI6::PlaceType::Wall;

  180. 		state.gameMap[api.GridToCell((*it)->x - 280)][api.GridToCell((*it)->y - 280)] = THUAI6::PlaceType::Wall;

  181. 	}

  182. 	switch (comeDir)

  183. 	{

  184. 	case Action::Direction::up_left: {

  185. 		if (state.gameMap[judgePos.x + 1][judgePos.y] != THUAI6::PlaceType::Land && state.gameMap[judgePos.x + 1][judgePos.y] != THUAI6::PlaceType::Grass)return false;

  186. 		if (state.gameMap[judgePos.x][judgePos.y + 1] != THUAI6::PlaceType::Land && state.gameMap[judgePos.x][judgePos.y + 1] != THUAI6::PlaceType::Grass)return false;

  187. 		break;

  188. 	}

  189. 	case Action::Direction::up_right: {

  190. 		if (state.gameMap[judgePos.x + 1][judgePos.y] != THUAI6::PlaceType::Land && state.gameMap[judgePos.x + 1][judgePos.y] != THUAI6::PlaceType::Grass)return false;

  191. 		if (state.gameMap[judgePos.x][judgePos.y - 1] != THUAI6::PlaceType::Land && state.gameMap[judgePos.x][judgePos.y - 1] != THUAI6::PlaceType::Grass)return false;

  192. 		break;

  193. 	}

  194. 	case Action::Direction::down_right: {

  195. 		if (state.gameMap[judgePos.x - 1][judgePos.y] != THUAI6::PlaceType::Land && state.gameMap[judgePos.x - 1][judgePos.y] != THUAI6::PlaceType::Grass)return false;

  196. 		if (state.gameMap[judgePos.x][judgePos.y - 1] != THUAI6::PlaceType::Land && state.gameMap[judgePos.x][judgePos.y - 1] != THUAI6::PlaceType::Grass)return false;

  197. 		break;

  198. 	}

  199. 	case Action::Direction::down_left: {

  200. 		if (state.gameMap[judgePos.x - 1][judgePos.y] != THUAI6::PlaceType::Land && state.gameMap[judgePos.x - 1][judgePos.y] != THUAI6::PlaceType::Grass)return false;

  201. 		if (state.gameMap[judgePos.x][judgePos.y + 1] != THUAI6::PlaceType::Land && state.gameMap[judgePos.x][judgePos.y + 1] != THUAI6::PlaceType::Grass)return false;

  202. 		break;

  203. 	}

  204. 	default:break;

  205. 	}

  206. 	return state.gameMap[judgePos.x][judgePos.y] == THUAI6::PlaceType::Land

  207. 		|| state.gameMap[judgePos.x][judgePos.y] == THUAI6::PlaceType::Grass

  208. 		|| state.gameMap[judgePos.x][judgePos.y] == THUAI6::PlaceType::Window

  209. 		|| (state.isDoor(judgePos) && api.IsDoorOpen(judgePos.x, judgePos.y));

  210. }

  211. bool Action::isValidMove(CellPos judgePos, Direction comeDir, GameState state, ITrickerAPI& api)

  212. {

  213. 	for (int i=0; i<gameState.ValidMoveBuffer.size(); i++) {

  214. 		auto it = &gameState.ValidMoveBuffer[i].first;

  215. 		if (api.HaveView(it->x, it->y)|| (api.GetFrameCount()- gameState.ValidMoveBuffer[i].second)>=100) {

  216. 			gameState.ValidMoveBuffer.erase(gameState.ValidMoveBuffer.begin()+i);

  217. 			i--;

  218. 		}

  219. 		else {

  220. 			state.gameMap[api.GridToCell(it->x)][api.GridToCell(it->y)] = THUAI6::PlaceType::Wall;

  221. 			state.gameMap[api.GridToCell(it->x + 390)][api.GridToCell(it->y)] = THUAI6::PlaceType::Wall;

  222. 			state.gameMap[api.GridToCell(it->x - 390)][api.GridToCell(it->y)] = THUAI6::PlaceType::Wall;

  223. 			state.gameMap[api.GridToCell(it->x)][api.GridToCell(it->y + 390)] = THUAI6::PlaceType::Wall;

  224. 			state.gameMap[api.GridToCell(it->x)][api.GridToCell(it->y - 390)] = THUAI6::PlaceType::Wall;

  225. 			state.gameMap[api.GridToCell(it->x + 280)][api.GridToCell(it->y + 280)] = THUAI6::PlaceType::Wall;

  226. 			state.gameMap[api.GridToCell(it->x + 280)][api.GridToCell(it->y - 280)] = THUAI6::PlaceType::Wall;

  227. 			state.gameMap[api.GridToCell(it->x - 280)][api.GridToCell(it->y + 280)] = THUAI6::PlaceType::Wall;

  228. 			state.gameMap[api.GridToCell(it->x - 280)][api.GridToCell(it->y - 280)] = THUAI6::PlaceType::Wall;

  229. 		}

  230. 	}

  231. 	auto students = api.GetStudents();

  232. 	for (auto it = students.begin(); it != students.end(); it++)

  233. 	{

  234. 		if ((*it)->determination>0)

  235. 			continue;

  236. 		state.gameMap[api.GridToCell((*it)->x)][api.GridToCell((*it)->y)] = THUAI6::PlaceType::Wall;

  237. 		state.gameMap[api.GridToCell((*it)->x + 390)][api.GridToCell((*it)->y)] = THUAI6::PlaceType::Wall;

  238. 		state.gameMap[api.GridToCell((*it)->x - 390)][api.GridToCell((*it)->y)] = THUAI6::PlaceType::Wall;

  239. 		state.gameMap[api.GridToCell((*it)->x)][api.GridToCell((*it)->y + 390)] = THUAI6::PlaceType::Wall;

  240. 		state.gameMap[api.GridToCell((*it)->x)][api.GridToCell((*it)->y - 390)] = THUAI6::PlaceType::Wall;

  241. 		state.gameMap[api.GridToCell((*it)->x + 280)][api.GridToCell((*it)->y + 280)] = THUAI6::PlaceType::Wall;

  242. 		state.gameMap[api.GridToCell((*it)->x + 280)][api.GridToCell((*it)->y - 280)] = THUAI6::PlaceType::Wall;

  243. 		state.gameMap[api.GridToCell((*it)->x - 280)][api.GridToCell((*it)->y + 280)] = THUAI6::PlaceType::Wall;

  244. 		state.gameMap[api.GridToCell((*it)->x - 280)][api.GridToCell((*it)->y - 280)] = THUAI6::PlaceType::Wall;

  245. 		gameState.ValidMoveBuffer.push_back({ { (*it)->x ,(*it)->y },api.GetFrameCount()});

  246. 	}

  247. 	switch (comeDir)

  248. 	{

  249. 	case Action::Direction::up_left: {

  250. 

  251. 		if (state.gameMap[judgePos.x + 1][judgePos.y] != THUAI6::PlaceType::Land )return false;

  252. 		if (state.gameMap[judgePos.x][judgePos.y + 1] != THUAI6::PlaceType::Land )return false;

  253. 		break;

  254. 	}

  255. 	case Action::Direction::up_right: {

  256. 

  257. 		if (state.gameMap[judgePos.x + 1][judgePos.y] != THUAI6::PlaceType::Land )return false;

  258. 		if (state.gameMap[judgePos.x][judgePos.y - 1] != THUAI6::PlaceType::Land )return false;

  259. 		break;

  260. 	}

  261. 	case Action::Direction::down_right: {

  262. 

  263. 		if (state.gameMap[judgePos.x - 1][judgePos.y] != THUAI6::PlaceType::Land )return false;

  264. 		if (state.gameMap[judgePos.x][judgePos.y - 1] != THUAI6::PlaceType::Land )return false;

  265. 		break;

  266. 	}

  267. 	case Action::Direction::down_left: {

  268. 

  269. 		if (state.gameMap[judgePos.x - 1][judgePos.y] != THUAI6::PlaceType::Land )return false;

  270. 		if (state.gameMap[judgePos.x][judgePos.y + 1] != THUAI6::PlaceType::Land )return false;

  271. 		break;

  272. 	}

  273. 	default:break;

  274. 	}

  275. 	return state.canReach(judgePos, api);

  276. }

  277. double Action::getAngle(GridPos grid1, GridPos grid2)

  278. {

  279. 	return atan2(grid2.y - grid1.y, grid2.x - grid1.x);

  280. }

  281. void Action::Move(CellPos destination, IStudentAPI& api)

  282. {

  283. 	int desX = api.CellToGrid(destination.x);

  284. 	int desY = api.CellToGrid(destination.y);

  285. 	auto self = api.GetSelfInfo();

  286. 	api.Move(50, getAngle({ self->x,self->y }, { desX,desY }));

  287. }

  288. void Action::Move(CellPos destination, ITrickerAPI& api)

  289. {

  290. 	int desX = api.CellToGrid(destination.x);

  291. 	int desY = api.CellToGrid(destination.y);

  292. 	auto self = api.GetSelfInfo();

  293. 	api.Move(50, getAngle({ self->x,self->y }, { desX,desY }));

  294. }

  295. 

  296. void Action::Move(Direction direction, IStudentAPI& api)

  297. {

  298. 	auto self = api.GetSelfInfo();

  299. 	int x = api.GridToCell(self->x);

  300. 	int y = api.GridToCell(self->y);

  301. 	Move(Action::directionToPos({ x, y }, direction), api);

  302. }

  303. void Action::Move(Direction direction, ITrickerAPI& api)

  304. {

  305. 	auto self = api.GetSelfInfo();

  306. 	int x = api.GridToCell(self->x);

  307. 	int y = api.GridToCell(self->y);

  308. 	Move(Action::directionToPos({ x, y }, direction), api);

  309. }

  310. CellPos Action::directionToPos(CellPos nowPos, Direction direction)

  311. {

  312. 	switch (direction)

  313. 	{

  314. 	case Action::Direction::up:

  315. 		return { nowPos.x - 1, nowPos.y };

  316. 	case Action::Direction::down:

  317. 		return { nowPos.x + 1, nowPos.y };

  318. 	case Action::Direction::left:

  319. 		return { nowPos.x, nowPos.y - 1 };

  320. 	case Action::Direction::right:

  321. 		return { nowPos.x, nowPos.y + 1 };

  322. 	case Action::Direction::up_left:

  323. 		return { nowPos.x - 1, nowPos.y - 1 };

  324. 	case Action::Direction::up_right:

  325. 		return { nowPos.x - 1, nowPos.y + 1 };

  326. 	case Action::Direction::down_left:

  327. 		return { nowPos.x + 1, nowPos.y - 1 };

  328. 	case Action::Direction::down_right:

  329. 		return { nowPos.x + 1, nowPos.y + 1 };

  330. 	}

  331. 	return { -1,-1 };

  332. }

  333. Action::Direction Action::posToDirection(CellPos nowPos, CellPos nextPos)

  334. {

  335. 	if (nextPos.x == nowPos.x + 1 && nextPos.y == nowPos.y)

  336. 		return Action::Direction::down;

  337. 	if (nextPos.x == nowPos.x - 1 && nextPos.y == nowPos.y)

  338. 		return Action::Direction::up;

  339. 	if (nextPos.x == nowPos.x && nextPos.y == nowPos.y + 1)

  340. 		return Action::Direction::right;

  341. 	if (nextPos.x == nowPos.x && nextPos.y == nowPos.y - 1)

  342. 		return Action::Direction::left;

  343. 	if (nextPos.x == nowPos.x + 1 && nextPos.y == nowPos.y + 1)

  344. 		return Action::Direction::down_right;

  345. 	if (nextPos.x == nowPos.x - 1 && nextPos.y == nowPos.y + 1)

  346. 		return Action::Direction::up_right;

  347. 	if (nextPos.x == nowPos.x + 1 && nextPos.y == nowPos.y - 1)

  348. 		return Action::Direction::down_left;

  349. 	if (nextPos.x == nowPos.x - 1 && nextPos.y == nowPos.y - 1)

  350. 		return Action::Direction::up_left;

  351. 	return Action::Direction::null;

  352. }

  353. 

  354. std::pair<CellPos, int> BFS::bfs(CellPos start, CellPos destination, ITrickerAPI& api)

  355. {

  356. 	int length = 0;

  357. 	std::queue<CellPos> posQ;

  358. 

  359. 	memset(vis, false, sizeof(vis));

  360. 	vis[start.x][start.y] = true;

  361. 	posQ.push(start);

  362. 	while (!posQ.empty())

  363. 	{

  364. 		now = posQ.front();

  365. 		posQ.pop();

  366. 		for (auto move = Action::allMove.begin(); move != Action::allMove.end(); move++)

  367. 		{

  368. 			nxt = Action::directionToPos(now, *move);

  369. 			if (nxt.x == destination.x && nxt.y == destination.y && !gameState.canReach(nxt, api))

  370. 			{

  371. 				pre[nxt.x][nxt.y] = now;

  372. 				now = nxt;

  373. 				break;

  374. 			}

  375. 			if (!Action::isValidMove(nxt, *move, gameState, api) || vis[nxt.x][nxt.y])

  376. 				continue;

  377. 			if (nxt.x == destination.x && nxt.y == destination.y)

  378. 			{

  379. 				pre[nxt.x][nxt.y] = now;

  380. 				now = nxt;

  381. 				break;

  382. 			}

  383. 			vis[nxt.x][nxt.y] = true;

  384. 			posQ.push(nxt);

  385. 			pre[nxt.x][nxt.y] = now;

  386. 		}

  387. 		if (now.x == nxt.x && now.y == nxt.y)

  388. 		{

  389. 			while (pre[now.x][now.y].x != start.x || pre[now.x][now.y].y != start.y)

  390. 			{

  391. 				now = pre[now.x][now.y];

  392. 				length++;

  393. 			}

  394. 			return { now, length + 1 };

  395. 		}

  396. 	}

  397. 	return { {-1,-1},-1 };

  398. }

  399. std::pair<std::pair<CellPos, CellPos>,int> BFS::bfs(CellPos start, THUAI6::PlaceType destination, ITrickerAPI& api)

  400. {

  401. 	int length = 0;

  402. 	std::queue<CellPos> posQ;

  403. 	if (gameState.gameMap[start.x][start.y] == destination) {

  404. 		return { {start,start},0 };

  405. 	}

  406. 	memset(vis, false, sizeof(vis));

  407. 	vis[start.x][start.y] = true;

  408. 	posQ.push(start);

  409. 	while (!posQ.empty())

  410. 	{

  411. 		now = posQ.front();

  412. 		posQ.pop();

  413. 		for (auto move = Action::allMove.begin(); move != Action::allMove.end(); move++)

  414. 		{

  415. 			nxt = Action::directionToPos(now, *move);

  416. 			if (gameState.gameMap[nxt.x][nxt.y] == destination && !gameState.canReach(nxt, api))

  417. 			{

  418. 				pre[nxt.x][nxt.y] = now;

  419. 				now = nxt;

  420. 				break;

  421. 			}

  422. 			if (!Action::isValidMove(nxt, *move, gameState, api) || vis[nxt.x][nxt.y])

  423. 				continue;

  424. 			if (gameState.gameMap[nxt.x][nxt.y] == destination)

  425. 			{

  426. 				pre[nxt.x][nxt.y] = now;

  427. 				now = nxt;

  428. 				break;

  429. 			}

  430. 			vis[nxt.x][nxt.y] = true;

  431. 			posQ.push(nxt);

  432. 			pre[nxt.x][nxt.y] = now;

  433. 		}

  434. 		if (now.x == nxt.x && now.y == nxt.y)

  435. 		{

  436. 			while (pre[now.x][now.y].x != start.x || pre[now.x][now.y].y != start.y) {

  437. 				length++;

  438. 				now = pre[now.x][now.y];

  439. 			}				

  440. 			return { { now,nxt },length };

  441. 		}

  442. 	}

  443. 	return { { {-1,-1},{-1,-1} },1000 };

  444. }

  445. 

  446. void Communication::sendClassroomPos(IStudentAPI& api, int64_t myID, CellPos classroomPos) {

  447. 	auto message = fmt::format("{} {} {} {}", classroomPos.x, classroomPos.y, -1, -1);

  448. 	for (int id = 0; id <= 3; id++)

  449. 		if (id != myID)

  450. 			api.SendTextMessage(id, message);

  451. }

  452. void Communication::sendTrickerPos(IStudentAPI& api, int64_t myID) {

  453. 	auto trickers = api.GetTrickers();

  454. 	if (trickers.empty())

  455. 		return;

  456. 	CellPos trickerPos = { api.GridToCell(trickers[0]->x), api.GridToCell(trickers[0]->y) };

  457. 	auto message = fmt::format("{} {} {} {}", -1, -1, trickerPos.x, trickerPos.y);

  458. 	for (int i = 0; i <= 3; i++)

  459. 		if (i != myID)

  460. 			api.SendTextMessage(i, message);

  461. }

  462. void Communication::receiveMessage(IStudentAPI& api, int64_t myID) {

  463. 	CellPos classroomPos, trickerPos;

  464. 	std::pair<int64_t, std::string> message;

  465. 	std::stringstream ss;

  466. 	gameState.trickerPos = { -1, -1 };

  467. 	auto trickers = api.GetTrickers();

  468. 	if (!trickers.empty())

  469. 		gameState.trickerPos = { api.GridToCell(trickers[0]->x), api.GridToCell(trickers[0]->y) };

  470. 	while (api.HaveMessage()) {

  471. 		ss.clear();

  472. 		message = api.GetMessage();

  473. 		ss.str(message.second);

  474. 		ss >> classroomPos.x >> classroomPos.y >> trickerPos.x >> trickerPos.y;

  475. 		if (classroomPos.x != -1 && classroomPos.y != -1)

  476. 			gameState.deleteStudiedClassroom(classroomPos);

  477. 		if (trickerPos.x != -1 && trickerPos.y != -1)

  478. 			gameState.trickerPos = trickerPos;

  479. 	}

  480. }

  481. 

  482. inline bool GameState::isAtCell(GridPos myPos, GridPos cellPos) const {

  483. 	return abs(myPos.x - cellPos.x) < 100 && abs(myPos.y - cellPos.y) < 100;

  484. }

  485. inline bool GameState::isAtPosition(CellPos character, CellPos pos) const {

  486. 	return (abs(character.x - pos.x) <= 1 && abs(character.y - pos.y) <= 1);

  487. }

  488. inline bool GameState::isAtPos(CellPos character, CellPos pos) const {

  489. 	return (abs(character.x - pos.x) <= 1 && abs(character.y - pos.y) == 0) || (abs(character.y - pos.y) <= 1 && abs(character.x - pos.x) == 0);

  490. }

  491. inline bool GameState::isAttackable(GridPos trickerPos, GridPos studentPos) const {

  492. 	return gridDistance(trickerPos, studentPos) <= 1500;

  493. }

  494. inline bool GameState::isClassroomFinished(CellPos classroomPos, IStudentAPI& api) const {

  495. 	return api.GetClassroomProgress(classroomPos.x, classroomPos.y) >= Constants::maxClassroomProgress;

  496. }

  497. inline bool GameState::isDoor(CellPos pos) const {

  498. 	return gameMap[pos.x][pos.y] == THUAI6::PlaceType::Door3

  499. 		|| gameMap[pos.x][pos.y] == THUAI6::PlaceType::Door5

  500. 		|| gameMap[pos.x][pos.y] == THUAI6::PlaceType::Door6;

  501. }

  502. inline bool GameState::isGateFinished(CellPos gatePos, IStudentAPI& api) const {

  503. 	return api.GetGateProgress(gatePos.x, gatePos.y) >= Constants::maxGateProgress;

  504. }

  505. inline bool GameState::isTrickerVisible() const {

  506. 	return trickerPos.x == -1 && trickerPos.y == -1;

  507. }

  508. inline bool GameState::isType(CellPos pos, THUAI6::PlaceType type) const {

  509. 	return gameMap[pos.x][pos.y] == type;

  510. }

  511. inline bool GameState::canReach(CellPos pos, ITrickerAPI& api) const {

  512. 	return gameMap[pos.x][pos.y] == THUAI6::PlaceType::Window

  513. 		|| gameMap[pos.x][pos.y] == THUAI6::PlaceType::Grass

  514. 		|| gameMap[pos.x][pos.y] == THUAI6::PlaceType::Land

  515. 		|| (isDoor(pos) && api.IsDoorOpen(pos.x, pos.y));

  516. }

  517. inline bool GameState::readyToGraduate() const {

  518. 	return clsFinishCnt >= Constants::numOfRequiredClassroomForGate;

  519. }

  520. double GameState::gridDistance(GridPos grid1, GridPos grid2) const {

  521. 	return sqrt(pow((grid1.x - grid2.x), 2) + pow((grid1.y - grid2.y), 2));

  522. }

  523. void GameState::deleteStudiedClassroom(CellPos classroomPos) {

  524. 	for (auto it = gameState.ClassRoom.begin(); it != gameState.ClassRoom.end(); it++)

  525. 		if (it->x == classroomPos.x && it->y == classroomPos.y)

  526. 		{

  527. 			ClassRoom.erase(it);

  528. 			gameState.gameMap[classroomPos.x][classroomPos.y] = THUAI6::PlaceType::Wall;

  529. 			clsFinishCnt++;

  530. 			break;

  531. 		}

  532. }

  533. void GameState::getMap(IStudentAPI& api) {

  534. 	for (int i = 0; i < Constants::rows; i++) {

  535. 		for (int j = 0; j < Constants::cols; j++) {

  536. 			gameMap[i][j] = (api.GetFullMap()[i][j]);

  537. 			if (gameMap[i][j] == THUAI6::PlaceType::ClassRoom) ClassRoom.push_back({ i, j });

  538. 			if (gameMap[i][j] == THUAI6::PlaceType::Gate) Gate.push_back({ i, j });

  539. 			if (gameMap[i][j] == THUAI6::PlaceType::HiddenGate) HiddenGate.push_back({ i, j });

  540. 			if (gameMap[i][j] == THUAI6::PlaceType::Window) Window.push_back({ i, j });

  541. 			if (gameMap[i][j] == THUAI6::PlaceType::Chest) Chest.push_back({ i, j });

  542. 		}

  543. 	}

  544. }

  545. void GameState::getMap(ITrickerAPI& api) {

  546. 	for (int i = 0; i < Constants::rows; i++) {

  547. 		for (int j = 0; j < Constants::cols; j++) {

  548. 			gameMap[i][j] = (api.GetFullMap()[i][j]);

  549. 			if (gameMap[i][j] == THUAI6::PlaceType::ClassRoom) ClassRoom.push_back({ i, j });

  550. 			if (gameMap[i][j] == THUAI6::PlaceType::Gate) Gate.push_back({ i, j });

  551. 			if (gameMap[i][j] == THUAI6::PlaceType::HiddenGate) HiddenGate.push_back({ i, j });

  552. 			if (gameMap[i][j] == THUAI6::PlaceType::Window) Window.push_back({ i, j });

  553. 			if (gameMap[i][j] == THUAI6::PlaceType::Chest) Chest.push_back({ i, j });

  554. 		}

  555. 	}

  556. }

  557. std::pair<std::pair<bool, std::pair<CellPos,GridPos>>, std::pair<double, double>> GameState::getClosestStudent(GridPos trickerPos, ITrickerAPI& api)

  558. {

  559. 	auto students = api.GetStudents();

  560. 	double minDistance = 1e5;

  561. 	CellPos studentPos = { -1,-1 };

  562. 	GridPos studentGrid = { -1,-1 };

  563. 	bool updated[4] = { false };

  564. 	bool inSight = false;

  565. 	double angle[5] = { -1,-1,-1,-1,-1 };

  566. 	int picked = 4;

  567. 	for (auto it = students.begin(); it != students.end(); it++)

  568. 	{

  569. 		if ((*it)->determination<=0) {

  570. 			gameState.studentPos[(*it)->playerID].x = -1;

  571. 			gameState.studentPos[(*it)->playerID].y = -1;

  572. 			gameState.studentGrid[(*it)->playerID].x = -1;

  573. 			gameState.studentGrid[(*it)->playerID].y = -1;

  574. 			continue;

  575. 		}

  576. 		angle[(*it)->playerID] = (*it)->facingDirection;

  577. 		gameState.studentPos[(*it)->playerID].x = api.GridToCell((*it)->x);

  578. 		gameState.studentPos[(*it)->playerID].y = api.GridToCell((*it)->y);

  579. 		gameState.studentGrid[(*it)->playerID].x = (*it)->x;

  580. 		gameState.studentGrid[(*it)->playerID].y = (*it)->y;

  581. 		updated[(*it)->playerID] = true;

  582. 	}

  583. 	for (int i = 0; i < 4; i++) {

  584. 		if (minDistance > gridDistance(trickerPos, { api.CellToGrid(gameState.studentPos[i].x),api.CellToGrid(gameState.studentPos[i].y) }) && gameState.studentPos[i].x >= 0)

  585. 		{

  586. 			minDistance = gridDistance(trickerPos, { api.CellToGrid(gameState.studentPos[i].x),api.CellToGrid(gameState.studentPos[i].y) });

  587. 			studentPos = gameState.studentPos[i];

  588. 			studentGrid = gameState.studentGrid[i];

  589. 			inSight = updated[i];

  590. 			picked = i;

  591. 		}

  592. 	}

  593. 	

  594. 	return { {inSight,{studentPos,studentGrid}},{minDistance,angle[picked]} };

  595. }

  596. 

  597. void AI::play(IStudentAPI& api) {}

  598. int AttackCount = 0;

  599. int needNew = 0;

  600. bool del=false;

  601. GridPos lastGrid = { -1,-1 };

  602. int stuck = 0;

  603. int classcount = 0;

  604. int pointing = -1;

  605. //bool attackToGrass = false;

  606. std::vector <CellPos> traversal;

  607. std::vector <CellPos> gates;

  608. void AI::play(ITrickerAPI& api)

  609. {

  610. 	if (gameState.readCnt < 1)

  611. 	{

  612. 		gameState.getMap(api);

  613. 		gameState.readCnt++;

  614. 		for (int i = 0; i < 4; i++) {

  615. 			//studentPos赋初值，代表视野没有，也没记住

  616. 			gameState.studentPos[i] = { -1,-1 };

  617. 			gameState.studentGrid[i] = { -1,-1 };

  618. 		}

  619. 		if (gameState.gameMap[5][9] == THUAI6::PlaceType::Grass) {

  620. 			traversal.push_back({ 6,24 });

  621. 			traversal.push_back({ 8,31 });//class

  622. 			traversal.push_back({ 10,38 });//class

  623. 			traversal.push_back({ 12,46 });

  624. 			traversal.push_back({ 19,41 });//class

  625. 			//traversal.push_back({ 18,46 });

  626. 			//traversal.push_back({ 23,40 });

  627. 			traversal.push_back({ 21,27 });

  628. 			traversal.push_back({ 28,26 });//class

  629. 			traversal.push_back({ 33,40 });//class

  630. 			//traversal.push_back({ 39,38 });

  631. 			traversal.push_back({ 44,32 });//class

  632. 			traversal.push_back({ 40,12 });//class

  633. 			//traversal.push_back({ 46,9 });

  634. 			//traversal.push_back({ 36,7 });

  635. 			traversal.push_back({ 30,7 });//class

  636. 			traversal.push_back({ 22,18 });//class

  637. 			traversal.push_back({ 18,5 });//class

  638. 			traversal.push_back({ 8,16 });

  639. 			traversal.push_back({ 7,21 });

  640. 			gates.push_back({ 46,45 });

  641. 			gates.push_back({ 5,6 });

  642. 		}

  643. 		else if (gameState.gameMap[5][9] == THUAI6::PlaceType::Wall) {

  644. 			traversal.push_back({ 16,20 });

  645. 			traversal.push_back({ 16,16 });//class

  646. 			traversal.push_back({ 20,16 });

  647. 			traversal.push_back({ 29,16 });

  648. 			traversal.push_back({ 33,16 });//class

  649. 			traversal.push_back({ 33,20 });

  650. 			traversal.push_back({ 33,29 });

  651. 			traversal.push_back({ 33,33 });//class

  652. 			traversal.push_back({ 29,33 });

  653. 			traversal.push_back({ 20,33 });

  654. 			traversal.push_back({ 16,33 });//class

  655. 			traversal.push_back({ 16,29 });

  656. 			traversal.push_back({ 6,13 });//class

  657. 			traversal.push_back({ 6,36 });//class

  658. 			traversal.push_back({ 13,43 });//class

  659. 			traversal.push_back({ 34,45 });

  660. 			traversal.push_back({ 43,36 });//class

  661. 			traversal.push_back({ 43,13 });//class

  662. 			traversal.push_back({ 36,6 });//class

  663. 			traversal.push_back({ 15,4 });

  664. 			gates.push_back({ 47,6 });

  665. 			gates.push_back({ 2,43 });

  666. 		}

  667. 		else {

  668. 			traversal = gameState.ClassRoom;

  669. 		}

  670. 		api.Print("Map read");

  671. 

  672. 	}

  673. 

  674. 	if (traversal.size())

  675. 		Action::classNo = Action::classNo % traversal.size();

  676. 	else

  677. 		Action::classNo = -1;

  678. 

  679. 	auto self = api.GetSelfInfo();

  680. 	

  681. 	GridPos myGrid = { self->x,self->y };

  682. 

  683. 	CellPos myCell = { api.GridToCell(self->x), api.GridToCell(self->y) };

  684. 	api.Print(fmt::format("mypos {} {}", myCell.x, myCell.y));

  685. 	if (self->playerState == THUAI6::PlayerState::Swinging || self->playerState == THUAI6::PlayerState::Attacking || self->playerState == THUAI6::PlayerState::Stunned) {

  686. 		gameState.getClosestStudent(myGrid, api);

  687. 		api.Print("not idle");

  688. 		return;

  689. 	}

  690. 	if (gameState.isAtCell(myGrid, { api.CellToGrid(myCell.x),api.CellToGrid(myCell.y) }) || Action::isAtCellFalseCnt > 15)

  691. 		//if (gameState.isAtCell(myGrid, { api.CellToGrid(myCell.x),api.CellToGrid(myCell.y) }))

  692. 	{

  693. 		//在格点上或者连续10次进不到格点

  694. 		bool notAtCell = Action::isAtCellFalseCnt > 15;

  695. 		Action::isAtCellFalseCnt = 0;

  696. 		api.Print(fmt::format("notAtCell {}", notAtCell));

  697. 		if (!notAtCell) {

  698. 			if (abs(myGrid.x - lastGrid.x) <= 5 && abs(myGrid.y - lastGrid.y) <= 5) {

  699. 				stuck++;

  700. 				api.Print(fmt::format("stuck {}", stuck));

  701. 			}

  702. 			else {

  703. 				stuck = 0;

  704. 				api.Print("stuck zero");

  705. 			}

  706. 			if (stuck >= 5) {

  707. 				if (pointing <= 1) {

  708. 

  709. 					auto angle = Action::getAngle({ api.CellToGrid(Action::directionToPos(myCell, Action::lastMove).x), api.CellToGrid(Action::directionToPos(myCell, Action::lastMove).y) }, { api.CellToGrid(myCell.x), api.CellToGrid(myCell.y) });

  710. 					angle = angle + pointing * PI / 4;

  711. 					api.Attack(angle);

  712. 					pointing++;

  713. 				}

  714. 				else {

  715. 					pointing = -1;

  716. 					stuck = 0;

  717. 				}

  718. 				api.Print(fmt::format("{} {} set to wall", Action::lastNextPos.x, Action::lastNextPos.y));

  719. 				stuck = 0;

  720. 				gameState.gameMap[Action::lastNextPos.x][Action::lastNextPos.y] = THUAI6::PlaceType::Wall;

  721. 				for (int i = 0; i < 4; i++) {

  722. 					if (gameState.studentPos[i].x == Action::lastNextPos.x && gameState.studentPos[i].y == Action::lastNextPos.y) {

  723. 						gameState.studentPos[i].x = -1;

  724. 						gameState.studentPos[i].y = -1;

  725. 						gameState.studentGrid[i].x = -1;

  726. 						gameState.studentGrid[i].y = -1;

  727. 					}

  728. 				}

  729. 			}

  730. 			lastGrid = myGrid;

  731. 		}

  732. 		else{

  733. 			if (gameState.gameMap[Action::lastNextPos.x][Action::lastNextPos.y] == THUAI6::PlaceType::Grass && AttackCount < 5) {

  734. 

  735. 				GridPos target = { api.CellToGrid(Action::lastNextPos.x),api.CellToGrid(Action::lastNextPos.y) };

  736. 				api.Attack(Action::getAngle(myGrid, target));

  737. 				api.Print(fmt::format("attacknum {}", AttackCount));

  738. 				api.Print(fmt::format("attackto {} {}", Action::lastNextPos.x, Action::lastNextPos.y));

  739. 				AttackCount++;

  740. 			}

  741. 			else {

  742. 				AttackCount = 0;

  743. 				del = true;

  744. 				//Action::lastNextPos = Action::directionToPos(Action::lastNextPos, Action::lastMove);

  745. 				api.Print(fmt::format("delete {} {}", Action::lastNextPos.x, Action::lastNextPos.y));

  746. 				gameState.gameMap[Action::lastNextPos.x][Action::lastNextPos.y] = THUAI6::PlaceType::Wall;

  747. 				for (int i = 0; i < 4; i++) {

  748. 					if (gameState.studentPos[i].x == Action::lastNextPos.x && gameState.studentPos[i].y == Action::lastNextPos.y) {

  749. 						gameState.studentPos[i].x = -1;

  750. 						gameState.studentPos[i].y = -1;

  751. 						gameState.studentGrid[i].x = -1;

  752. 						gameState.studentGrid[i].y = -1;

  753. 					}

  754. 				}

  755. 			}

  756. 

  757. 			Action::lastNextPos = Action::directionToPos(Action::lastNextPos, Action::lastMove);

  758. 			return;

  759. 		}

  760. 

  761. 		auto closestStudent = gameState.getClosestStudent(myGrid, api);

  762. 		bool inSight = closestStudent.first.first;

  763. 		auto stuCellPos = closestStudent.first.second.first;

  764. 		GridPos stuGridPos = closestStudent.first.second.second;

  765. 		auto distance = closestStudent.second.first;

  766. 		api.Print(fmt::format("insight {} stupos {} {} distance {}", inSight, stuCellPos.x, stuCellPos.y, distance));

  767. 		if (distance < Constants::basicTrickerViewRange)//如果视野里有学生，且未沉迷，则判断攻击条件，不满足则追击学生

  768. 		{

  769. 			Action::lastDesPos = { stuCellPos.x,stuCellPos.y };

  770. 			bool isClose;

  771. 			if (inSight) {

  772. 				isClose = gameState.isAtPos(myCell, stuCellPos);

  773. 				api.UseSkill(0);

  774. 				//if ((!api.GetSelfInfo()->buff.empty())&&api.GetSelfInfo()->buff[0]==THUAI6::TrickerBuffType::Invisible) 

  775. 					//api.Print("invisible");

  776. 				api.UseSkill(1);

  777. 				if (api.GetSelfInfo()->bulletType == THUAI6::BulletType::FlyingKnife) {

  778. 					//api.Print("knife");

  779. 					api.Attack(Action::getAngle(myGrid, stuGridPos));

  780. 				}

  781. 

  782. 			}

  783. 			else {

  784. 

  785. 				isClose = gameState.isAtCell(myGrid, {api.CellToGrid(stuCellPos.x),api.CellToGrid(stuCellPos.y)}) || (gameState.isAtPosition(myCell, stuCellPos) && notAtCell);

  786. 			}

  787. 			api.Print(fmt::format("isclose {}", isClose));

  788. 			if (isClose) {

  789. 

  790. 				if (inSight) {

  791. 					api.Attack(Action::getAngle(myGrid, stuGridPos));

  792. 

  793. 				}

  794. 				/*

  795. 				else if (notAtCell && AttackCount < 3) {

  796. 					api.Attack(Action::getAngle(myGrid, stuGridPos));

  797. 					AttackCount++;

  798. 				}

  799. 

  800. 				else if (del) {

  801. 					//AttackCount = 0;

  802. 					for (int i = 0; i < 4; i++) {

  803. 						if (gameState.studentPos[i].x == stuCellPos.x && gameState.studentPos[i].y == stuCellPos.y) {

  804. 							gameState.studentPos[i].x = -1;

  805. 							gameState.studentPos[i].y = -1;

  806. 						}

  807. 					}

  808. 					del = false;

  809. 				}*/

  810. 				else {

  811. 

  812. 					

  813. 					if (gameState.gameMap[myCell.x][myCell.y] != THUAI6::PlaceType::Grass) {

  814. 						int newx, newy;

  815. 						/*

  816. 						if (gameState.gameMap[stuCellPos.x][stuCellPos.y] == THUAI6::PlaceType::Grass) {

  817. 							newx = stuCellPos.x;

  818. 							newy = stuCellPos.y;

  819. 						}

  820. 						

  821. 						for (int i = -1; i <= 1; i = i + 2) {

  822. 							if (gameState.gameMap[stuCellPos.x + i][stuCellPos.y] == THUAI6::PlaceType::Grass) {

  823. 								newx = stuCellPos.x + i;

  824. 								newy = stuCellPos.y;

  825. 							}

  826. 						}

  827. 						for (int j = -1; j <= 1; j = j + 2) {

  828. 							if (gameState.gameMap[stuCellPos.x][stuCellPos.y + j] == THUAI6::PlaceType::Grass) {

  829. 								newx = stuCellPos.x;

  830. 								newy = stuCellPos.y + j;

  831. 							}

  832. 						}

  833. 						*/

  834. 						api.Print("bfsing");

  835. 						auto result = BFS::bfs(myCell, THUAI6::PlaceType::Grass, api);

  836. 						api.Print(fmt::format("newdist {}", result.second));

  837. 						if (result.second < 5&&result.second>=0) {

  838. 							newx = result.first.second.x;

  839. 							newy = result.first.second.y;

  840. 							for (int i = 0; i < 4; i++) {

  841. 								if (gameState.studentPos[i].x == stuCellPos.x && gameState.studentPos[i].y == stuCellPos.y) {

  842. 									gameState.studentPos[i].x = newx;

  843. 									gameState.studentPos[i].y = newy;

  844. 									gameState.studentGrid[i].x = api.CellToGrid(newx);

  845. 									gameState.studentGrid[i].y = api.CellToGrid(newy);

  846. 								}

  847. 							}

  848. 							api.Print(fmt::format("newxy {} {}", newx, newy));

  849. 						}

  850. 

  851. 

  852. 						//needNew=3;

  853. 						//return;

  854. 					}

  855. 					else {

  856. 						api.Print("not bfsing");

  857. 						for (int i = 0; i < 4; i++) {

  858. 							if (gameState.studentPos[i].x == stuCellPos.x && gameState.studentPos[i].y == stuCellPos.y) {

  859. 								gameState.studentPos[i].x = -1;

  860. 								gameState.studentPos[i].y = -1;

  861. 								gameState.studentGrid[i].x = -1;

  862. 								gameState.studentGrid[i].y = -1;

  863. 							}

  864. 						}

  865. 					}

  866. 

  867. 

  868. 

  869. 

  870. 				}

  871. 			}

  872. 			else

  873. 			{

  874. 				api.Print(fmt::format("my pos {} {}", myCell.x, myCell.y));

  875. 				api.Print(fmt::format("stu pos {} {}", stuCellPos.x, stuCellPos.y));

  876. 				auto result = BFS::bfs(myCell, stuCellPos, api);

  877. 				auto nextPos = result.first;

  878. 				api.Print(fmt::format("next {} {}", nextPos.x, nextPos.y));

  879. 				if (nextPos.x == -1) {

  880. 					for (int i = 0; i < 4; i++) {

  881. 						if (gameState.studentPos[i].x == stuCellPos.x && gameState.studentPos[i].y == stuCellPos.y) {

  882. 							gameState.studentPos[i].x = -1;

  883. 							gameState.studentPos[i].y = -1;

  884. 						}

  885. 					}

  886. 					return;

  887. 				}

  888. 				if (gameState.isType(nextPos, THUAI6::PlaceType::Window))

  889. 					api.SkipWindow();

  890. 				Action::Move(nextPos, api);

  891. 				Action::lastNextPos = nextPos;

  892. 				Action::lastMove = Action::posToDirection(nextPos, myCell);

  893. 			}

  894. 		}

  895. 		else//视野里没有学生，就遍历教室并前往

  896. 		{

  897. 			if (classcount >= 7) {

  898. 				auto classroomCellPos = gates[0];

  899. 				GridPos classroomGridPos = { api.CellToGrid(classroomCellPos.x),api.CellToGrid(classroomCellPos.y) };

  900. 				api.Print(fmt::format("class pos {} {}", classroomCellPos.x, classroomCellPos.y));

  901. 				auto result = BFS::bfs(myCell, classroomCellPos, api);

  902. 				auto nextPos = result.first;

  903. 				api.Print(fmt::format("next pos {} {}", nextPos.x, nextPos.y));

  904. 				if (nextPos.x == -1) {

  905. 					return;

  906. 				}

  907. 

  908. 				if (!gameState.isAtPosition(myCell, classroomCellPos))

  909. 				{

  910. 					if (gameState.isType(nextPos, THUAI6::PlaceType::Window))

  911. 						api.SkipWindow();

  912. 					Action::Move(nextPos, api);

  913. 					Action::lastNextPos = nextPos;

  914. 					Action::lastMove = Action::posToDirection(nextPos, myCell);

  915. 				}

  916. 				return;

  917. 			}

  918. 			auto classroomCellPos = traversal[Action::classNo];

  919. 			GridPos classroomGridPos = { api.CellToGrid(classroomCellPos.x),api.CellToGrid(classroomCellPos.y) };

  920. 			if (gameState.gameMap[classroomCellPos.x][classroomCellPos.y] == THUAI6::PlaceType::ClassRoom) {

  921. 				if (api.GetClassroomProgress(classroomCellPos.x, classroomCellPos.y) >= Constants::maxClassroomProgress) {

  922. 					traversal.erase(traversal.begin() + Action::classNo);

  923. 					classcount++;

  924. 				}

  925. 				//else if (api.GetClassroomProgress(classroomCellPos.x, classroomCellPos.y) == 0 && api.HaveView(classroomCellPos.x, classroomCellPos.y))

  926. 				else if (api.GetClassroomProgress(classroomCellPos.x, classroomCellPos.y) == 0 && api.HaveView(classroomGridPos.x, classroomGridPos.y))

  927. 					Action::classNo++;

  928. 				else

  929. 				{

  930. 					api.Print(fmt::format("class pos {} {}", classroomCellPos.x, classroomCellPos.y));

  931. 					auto result = BFS::bfs(myCell, classroomCellPos, api);

  932. 					auto nextPos = result.first;

  933. 					api.Print(fmt::format("next pos {} {}", nextPos.x, nextPos.y));

  934. 					if (nextPos.x == -1) {

  935. 						Action::classNo++;

  936. 						return;

  937. 					}

  938. 					if (!gameState.isAtPosition(myCell, classroomCellPos))

  939. 					{

  940. 						if (gameState.isType(nextPos, THUAI6::PlaceType::Window))

  941. 							api.SkipWindow();

  942. 						Action::Move(nextPos, api);

  943. 						Action::lastNextPos = nextPos;

  944. 						Action::lastMove = Action::posToDirection(nextPos, myCell);

  945. 					}

  946. 					else

  947. 					{

  948. 						//if (api.GetClassroomProgress(classroomCellPos.x, classroomCellPos.y) > 0)

  949. 							//api.Attack(Action::getAngle(myGrid, classroomGridPos));

  950. 						//else

  951. 						Action::classNo++;

  952. 					}

  953. 				}

  954. 			}

  955. 			else if (gameState.gameMap[classroomCellPos.x][classroomCellPos.y] == THUAI6::PlaceType::Grass) {

  956. 				api.Print(fmt::format("grass pos {} {}", classroomCellPos.x, classroomCellPos.y));

  957. 				auto result = BFS::bfs(myCell, classroomCellPos, api);

  958. 				auto nextPos = result.first;

  959. 				api.Print(fmt::format("next pos {} {}", nextPos.x, nextPos.y));

  960. 				if (nextPos.x == -1) {

  961. 					Action::classNo++;

  962. 					return;

  963. 				}

  964. 				if (!gameState.isAtCell(myGrid, classroomGridPos))

  965. 				{

  966. 					if (gameState.isType(nextPos, THUAI6::PlaceType::Window))

  967. 						api.SkipWindow();

  968. 					Action::Move(nextPos, api);

  969. 					Action::lastNextPos = nextPos;

  970. 					Action::lastMove = Action::posToDirection(nextPos, myCell);

  971. 				}

  972. 				else

  973. 				{

  974. 					Action::classNo++;

  975. 				}

  976. 			}

  977. 			else {

  978. 				Action::classNo++;

  979. 			}

  980. 

  981. 		}

  982. 		//if (needNew > 0) {

  983. 			//needNew--;

  984. 		//}

  985. 	}

  986. 	else

  987. 	{

  988. 		auto self = api.GetSelfInfo();

  989. 		GridPos myGrid = { self->x,self->y };

  990. 		CellPos myCell = { api.GridToCell(self->x), api.GridToCell(self->y) };

  991. 		gameState.getClosestStudent(myGrid, api);

  992. 		Action::Move(Action::lastNextPos, api);

  993. 		Action::isAtCellFalseCnt++;

  994. 	}

  995. }