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/player2.cpp

1575 lines
60 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. short map[2][48][48][48][48];

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

  14. extern const bool asynchronous = false;

  15. 

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

  17. 

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

  19. 	THUAI6::StudentType::StraightAStudent,

  20. 	THUAI6::StudentType::StraightAStudent,

  21. 	THUAI6::StudentType::Teacher,

  22. 	THUAI6::StudentType::Sunshine

  23. };

  24. 

  25. extern const THUAI6::TrickerType trickerType = THUAI6::TrickerType::ANoisyPerson;

  26. 

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

  28. //坐标的结构体

  29. struct posStruct {

  30. 	int x, y;

  31. 	bool operator!=(const posStruct b) {

  32. 		return x != b.x || y != b.y;

  33. 	}

  34. 	bool operator==(const posStruct b) {

  35. 		return x == b.x && y == b.y;

  36. 	}

  37. };

  38. //new

  39. struct gridPos {

  40. 	int x, y;

  41. };

  42. //end new

  43. class GameState {

  44. public:

  45. 	static int readCnt;

  46. 	static int clsFinishCnt;

  47. 	static const int sizeX = Constants::rows;    //地图X轴最大值

  48. 	static const int sizeY = Constants::cols;    //地图Y轴最大值

  49. 	static int timeCounter;

  50. 	THUAI6::PlaceType gameMap[sizeX][sizeY];	//存图信息

  51. 	std::vector <posStruct> ClassRoom;  //线性列出所有ClassRoom坐标（方便遍历）（下同）

  52. 	std::vector <posStruct> Gate;

  53. 	std::vector <posStruct> HiddenGate;

  54. 	std::vector <posStruct> Window;

  55. 	std::vector <posStruct> Door3;

  56. 	std::vector <posStruct> Door5;

  57. 	std::vector <posStruct> Door6;

  58. 	std::vector <posStruct> Chest;

  59. 	posStruct posStudent[4];    //四个学生的坐标

  60. 	posStruct posTricker;       //捣蛋鬼的坐标

  61. 	static posStruct helpStudent[4];//学生求救位置

  62. 	static int helpcount;//已接受到的学生求救的数量

  63. 	static int saveID;//要救的人的ID

  64. 	static bool isDead[4];//是不是要去救人

  65. 	static bool isHurt[4];//sunshine专用

  66. 	static bool ifQuit[4];

  67. 	static int iftosave[4];

  68. 	int isTrickerSwinging;

  69. 	int mapType;

  70. 	int determination;

  71. 	bool isStudentAttacked;

  72. 	bool isTrickerStill;

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

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

  75. 	bool isDoor(posStruct pos) const;

  76. 	//new

  77. 	bool isGrass(posStruct pos) const;

  78. 	bool isClassroomNear(posStruct pos) const;

  79. 	//

  80. 	bool isWindow(posStruct pos) const;

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

  82. 	bool isTrickerClose(posStruct studentPos, IStudentAPI& api, int maxDistance) const;   //判断student和tricker是否接近，是否要开始规避

  83. 	bool canReach(posStruct pos, GameState state, IStudentAPI& api);

  84. 	//new

  85. 	posStruct isGrassNear(posStruct studentPos, IStudentAPI& api) const;

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

  87. 	double getAngle(gridPos grid1, gridPos grid2) const;		//计算两点间方位角

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

  89. 	std::pair<int, double> getClosestStu(gridPos trickerPos, std::vector<std::shared_ptr<const THUAI6::Student>> Students);	//找到视野中最近的学生

  90. 	//endnew

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

  92. 	bool isAtCell(int characterX, int characterY, int desX, int desY) const; //判断人物是否完全在格点内

  93. 	bool atPosition(posStruct character, posStruct pos) const;    //判断character坐标与pos坐标是否在一个九宫格内

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

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

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

  97. 	int distance(posStruct A, posStruct B);

  98. 	void getMapType();

  99. 	bool isTrickerAttackGrass(IStudentAPI& api, posStruct studentPos);

  100. };

  101. 

  102. class Action {

  103. public:

  104. 	enum class Direction {

  105. 		up, down, left, right,

  106. 		up_left, up_right, down_left, down_right

  107. 	};    //移动方式

  108. 	static int isAtCellFalseCnt;

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

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

  111. 	static Direction posToDirection(posStruct nowPos, posStruct nextPos); //目标点的坐标转化为Direction

  112. 	static bool isValidMove(posStruct judgePos, Direction comedir, GameState state, IStudentAPI& api);//判断judgePos是不是一个合法的位置

  113. 	static void Move(posStruct des, IStudentAPI& api);

  114. 	static void Move(posStruct des, ITrickerAPI& api);

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

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

  117. };//所有成员均为静态

  118. 

  119. class Communicate {

  120. public:

  121. 	static void sendClassroonPos(IStudentAPI& api, int64_t myID, posStruct classroomPos);

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

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

  124. 	static void sendHelpSignal(IStudentAPI& api, int64_t myID);

  125. 	static void getMateinfo(IStudentAPI& api);

  126. 	static void sendHelpingSignal(IStudentAPI& api, int64_t myID, int64_t savingID);

  127. 	/*

  128. 		通信协议：AA BB CC DD

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

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

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

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

  133. 	*/

  134. };

  135. int minimax(posStruct studentPos, posStruct tricerPos, int alpha, int beta, bool isStudent, IStudentAPI& api, int depth, bool trickerSwinging, bool isTeacher);

  136. std::pair<int, posStruct > bfs(posStruct start, posStruct destination, IStudentAPI& api);

  137. int GameState::readCnt = 0;

  138. int GameState::clsFinishCnt = 0;

  139. int GameState::timeCounter = 0;

  140. int GameState::saveID = -1;

  141. int GameState::iftosave[4] = { -1,-1,-1,-1 };

  142. bool GameState::isDead[4] = { 0,0,0,0 };

  143. bool GameState::isHurt[4] = { 0,0,0,0 };

  144. int GameState::helpcount = 0;

  145. bool GameState::ifQuit[4] = { 0,0,0,0 };

  146. posStruct GameState::helpStudent[4] = { {-1,-1},{-1,-1},{-1,-1},{-1,-1} };

  147. GameState gameState;

  148. 

  149. Action::Direction lastMove;  //记录上一次移动方向，用于还没移动到格点时保持向格点移动

  150. //记录上一次的目标点，用于还没移动到格点时保持向格点移动（此处的用法与lastMove等价，最好可以用语义更明确的lastMove，但因为posToDirection还没完善就先用lastNextPos）

  151. int Action::isAtCellFalseCnt = 0;

  152. 

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

  154. 	Action::Direction::up,

  155. 	Action::Direction::down,

  156. 	Action::Direction::left,

  157. 	Action::Direction::right,

  158. 	Action::Direction::up_left,

  159. 	Action::Direction::up_right,

  160. 	Action::Direction::down_left,

  161. 	Action::Direction::down_right

  162. };   //所有的移动方式

  163. 

  164. posStruct lastNextPos;

  165. std::pair<posStruct, posStruct> bfs(posStruct start, THUAI6::PlaceType destination, IStudentAPI& api);

  166. //std::pair<posStruct, Action::Direction> minimax(posStruct start, THUAI6::PlaceType destination);   //规避算法（目前还是一个饼）

  167. 

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

  169. 	for (int i = 0; i < sizeX; i++) {

  170. 		for (int j = 0; j < sizeY; j++) {

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

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

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

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

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

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

  177. 		}

  178. 	}

  179. 	/*

  180. 		待完成：学生通过通讯向GameState传入他们的坐标和捣蛋鬼的坐标

  181. 	*/

  182. }

  183. 

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

  185. 	for (int i = 0; i < sizeX; i++) {

  186. 		for (int j = 0; j < sizeY; j++) {

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

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

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

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

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

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

  193. 		}

  194. 	}

  195. 	/*

  196. 		待完成：学生通过通讯向GameState传入他们的坐标和捣蛋鬼的坐标

  197. 	*/

  198. }

  199. 

  200. inline bool GameState::isDoor(posStruct pos) const {

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

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

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

  204. }     //判断是不是门

  205. 

  206. inline bool GameState::isWindow(posStruct pos) const {

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

  208. }

  209. 

  210. //new

  211. inline bool GameState::isGrass(posStruct pos) const {

  212. 	return gameMap[pos.x][pos.y] == THUAI6::PlaceType::Grass;

  213. }

  214. //

  215. 

  216. inline bool GameState::isAtCell(int characterX, int characterY, int desX, int desY) const {

  217. 	return abs(characterX - desX) < 100 && abs(characterY - desY) < 100;

  218. }

  219. 

  220. inline bool GameState::atPosition(posStruct character, posStruct pos) const {

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

  222. }

  223. 

  224. bool GameState::readyToGraduate() const {

  225. 	if (clsFinishCnt >= Constants::numOfRequiredClassroomForGate)

  226. 		return true;

  227. 	return false;

  228. }

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

  230. 	return !(posTricker.x == -1 && posTricker.y == -1);

  231. }

  232. 

  233. inline bool GameState::isClassroomNear(posStruct myPos) const {

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

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

  236. 			if (gameState.gameMap[myPos.x + i][myPos.y + j] == THUAI6::PlaceType::ClassRoom) {

  237. 				return 1;

  238. 			}

  239. 		}

  240. 	}

  241. 	return 0;

  242. }

  243. bool GameState::isTrickerClose(posStruct studentPos, IStudentAPI& api, int maxDistance) const {

  244. 	if (!isTrickerVisible()) {

  245. 		api.Print(fmt::format("Not visible!!"));

  246. 		return 0;

  247. 	}

  248. 	int distance = gameState.distance(studentPos, gameState.posTricker);

  249. 	api.Print(fmt::format("distance:{}", distance));

  250. 	return distance <= maxDistance;

  251. }

  252. 

  253. bool GameState::canReach(posStruct pos, GameState state, IStudentAPI& api) {

  254. 	auto students = api.GetStudents();

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

  256.         {

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

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

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

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

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

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

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

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

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

  266.         }

  267. 	auto trickers = api.GetTrickers();

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

  269. 	{

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

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

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

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

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

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

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

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

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

  279. 	}

  280. 	auto bullets = api.GetBullets();

  281. 	for (auto it = bullets.begin(); it != bullets.end(); it++)

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

  283. 	return

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

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

  286. 		state.gameMap[pos.x][pos.y] == THUAI6::PlaceType::Window ||

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

  288. }

  289. 

  290. 

  291. bool GameState::isClassroomFinished(posStruct classroomPos, IStudentAPI& api) const {

  292. 	int xcls = classroomPos.x, ycls = classroomPos.y;

  293. 	api.Print(fmt::format("Classroom Progress {}", api.GetClassroomProgress(xcls, ycls)));

  294. 	if (api.GetClassroomProgress(xcls, ycls) >= Constants::maxClassroomProgress)

  295. 		return true;

  296. 	return false;

  297. }

  298. 

  299. posStruct GameState::isGrassNear(posStruct studentPos, IStudentAPI& api) const {

  300. 	/*posStruct grassPos = bfs(studentPos, THUAI6::PlaceType::Grass, api).second;

  301. 	if (bfs(studentPos, grassPos, api) <= 2) {

  302. 		return 1;

  303. 	}*/

  304. 	auto students = api.GetStudents();

  305. 	auto state = gameState;

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

  307. 	{

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

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

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

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

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

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

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

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

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

  317. 	}

  318. 	for (int i = -5; i <= 5; i++) {

  319. 		if (studentPos.x + i >= 0 && studentPos.x + i < 50)

  320. 			for (int j = -5; j <= 5; j++) {

  321. 				if (studentPos.y + j >= 0 && studentPos.y + j < 50)

  322. 					if (state.isGrass({ studentPos.x + i, studentPos.y + j })) {

  323. 						return { studentPos.x + i, studentPos.y + j };

  324. 					}

  325. 			}

  326. 	}

  327. 	return { -1, -1 };

  328. }

  329. 

  330. bool GameState::isGateFinished(posStruct gatePos, IStudentAPI& api) const {

  331. 	int xg = gatePos.x, yg = gatePos.y;

  332. 	api.Print(fmt::format("Gate Progress {}", api.GetGateProgress(xg, yg)));

  333. 	if (api.GetGateProgress(xg, yg) >= Constants::maxGateProgress)

  334. 		return true;

  335. 	return false;

  336. }

  337. double GameState::gridDistance(gridPos grid1, gridPos grid2) const {

  338. 	double dist;

  339. 	dist = std::sqrt(pow((grid1.x - grid2.x), 2) + pow((grid1.y - grid2.y), 2));

  340. 	return dist;

  341. }

  342. bool GameState::isAttackable(gridPos trickerPos, gridPos studentPos) const {

  343. 	double dist;

  344. 	dist = std::sqrt(pow((studentPos.x - trickerPos.x), 2) + pow((studentPos.y - trickerPos.y), 2));

  345. 	if (dist < 1500) {

  346. 		return true;

  347. 	}

  348. 	else {

  349. 		return false;

  350. 	}

  351. }

  352. 

  353. std::pair<int, double> GameState::getClosestStu(gridPos trickerPos, std::vector<std::shared_ptr<const THUAI6::Student>> Students) {

  354. 	int num;

  355. 	int min = 0;

  356. 	double distance = 1000000;

  357. 	gridPos stu;

  358. 	for (num = 0; num < Students.size(); num++) {

  359. 		if (Students[num]->determination <= 0) {

  360. 			continue;

  361. 		}

  362. 		stu.x = Students[num]->x;

  363. 		stu.y = Students[num]->y;

  364. 		if (distance > gridDistance(trickerPos, stu)) {

  365. 			distance = gridDistance(trickerPos, stu);

  366. 			min = num;

  367. 		}

  368. 	}

  369. 	if (distance == 1000000) {

  370. 		min = -1;

  371. 	}

  372. 	return { min,distance };

  373. }

  374. double GameState::getAngle(gridPos grid1, gridPos grid2) const {

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

  376. }

  377. void GameState::deleteStudiedClassroom(posStruct classroomPos) {

  378. 	int xcls = classroomPos.x, ycls = classroomPos.y;

  379. 	if (gameState.gameMap[xcls][ycls] == THUAI6::PlaceType::ClassRoom)

  380. 	{

  381. 		gameState.gameMap[xcls][ycls] = THUAI6::PlaceType::Wall;    //在map里变成wall

  382. 		clsFinishCnt++;

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

  384. 			if ((*it).x == classroomPos.x && (*it).y == classroomPos.y)

  385. 			{

  386. 				ClassRoom.erase(it);

  387. 				break;

  388. 			}   //在classroom数组里删除

  389. 	}

  390. }

  391. 

  392. inline int GameState::distance(posStruct A, posStruct B){

  393. 	if (A.x >= 1 && A.y >= 1 && B.x >= 1 && B.y >= 1)

  394. 		return map[mapType][A.x - 1][A.y - 1][B.x - 1][B.y - 1];

  395. }

  396. 

  397. void GameState::getMapType(){

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

  399. 		mapType = 0;

  400. 	}

  401. 	else

  402. 		mapType = 1;

  403. }

  404. 

  405. bool GameState::isTrickerAttackGrass(IStudentAPI &api, posStruct studentPos){

  406. 	if (isGrass(studentPos) && isStudentAttacked){

  407. 		return true;

  408. 	}

  409. 	return false;

  410. }

  411. 

  412. posStruct Action::getNextPos(posStruct nowPos, Direction direction) {

  413. 	switch (direction)

  414. 	{

  415. 	case Action::Direction::up:

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

  417. 	case Action::Direction::down:

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

  419. 	case Action::Direction::left:

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

  421. 	case Action::Direction::right:

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

  423. 	case Action::Direction::up_left:

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

  425. 	case Action::Direction::up_right:

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

  427. 	case Action::Direction::down_left:

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

  429. 	case Action::Direction::down_right:

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

  431. 	}

  432. }

  433. 

  434. Action::Direction Action::posToDirection(posStruct myPos, posStruct nextPos)

  435. {

  436. 	if (nextPos.x == myPos.x + 1 && nextPos.y == myPos.y)

  437. 		return Action::Direction::down;

  438. 	if (nextPos.x == myPos.x - 1 && nextPos.y == myPos.y)

  439. 		return Action::Direction::up;

  440. 	if (nextPos.x == myPos.x && nextPos.y == myPos.y + 1)

  441. 		return Action::Direction::right;

  442. 	if (nextPos.x == myPos.x && nextPos.y == myPos.y - 1)

  443. 		return Action::Direction::left;

  444. 	if (nextPos.x == myPos.x + 1 && nextPos.y == myPos.y + 1)

  445. 		return Action::Direction::down_right;

  446. 	if (nextPos.x == myPos.x - 1 && nextPos.y == myPos.y + 1)

  447. 		return Action::Direction::up_right;

  448. 	if (nextPos.x == myPos.x + 1 && nextPos.y == myPos.y - 1)

  449. 		return Action::Direction::down_left;

  450. 	if (nextPos.x == myPos.x - 1 && nextPos.y == myPos.y - 1)

  451. 		return Action::Direction::up_left;

  452. }

  453. 

  454. inline bool Action::isValidMove(posStruct judgePos, Direction comeDir, GameState state, IStudentAPI& api)

  455. {

  456.     auto students = api.GetStudents();

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

  458.     {

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

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

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

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

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

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

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

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

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

  468.     }

  469. 	auto trickers = api.GetTrickers();

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

  471. 	{

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

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

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

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

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

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

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

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

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

  481. 	}

  482. 	auto bullets = api.GetBullets();

  483. 	for (auto it = bullets.begin(); it != bullets.end(); it++)

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

  485. 	switch (comeDir)

  486. 	{

  487. 	case Action::Direction::up_left: {

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

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

  490. 		break;

  491. 	}

  492. 	case Action::Direction::up_right: {

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

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

  495. 		break;

  496. 	}

  497. 	case Action::Direction::down_right: {

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

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

  500. 		break;

  501. 	}

  502. 	case Action::Direction::down_left: {

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

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

  505. 		break;

  506. 	}

  507. 	default:break;

  508. 	}//这里判断走斜线时会不会被目标周围点卡住，只有当目标周围点（两个）为Land

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

  510. }

  511. 

  512. void Action::Move(posStruct destination, IStudentAPI& api) {

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

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

  515. 	auto self = api.GetSelfInfo();

  516. 	auto directRad = atan2(1.0 * desY - (*self).y, 1.0 * desX - (*self).x);

  517. 	api.Move(50, directRad);

  518. }

  519. 

  520. void Action::Move(posStruct destination, ITrickerAPI& api) {

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

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

  523. 	auto self = api.GetSelfInfo();

  524. 	auto directRad = atan2(1.0 * desY - (*self).y, 1.0 * desX - (*self).x);

  525. 	api.Move(50, directRad);

  526. }

  527. 

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

  529. 	auto self = api.GetSelfInfo();

  530. 	int x = api.GridToCell((*self).x), y = api.GridToCell((*self).y);

  531. 	Move(Action::getNextPos({ x, y }, direction), api);

  532. }

  533. 

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

  535. 	auto self = api.GetSelfInfo();

  536. 	int x = api.GridToCell((*self).x), y = api.GridToCell((*self).y);

  537. 	Move(Action::getNextPos({ x, y }, direction), api);

  538. }

  539. 

  540. void Communicate::sendClassroonPos(IStudentAPI& api, int64_t myID, posStruct classroomPos) {

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

  542. 	//api.Print(message);

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

  544. 		if (id != myID) {

  545. 			api.SendTextMessage(id, message);

  546. 		}

  547. 	}

  548. }

  549. void Communicate::getMateinfo(IStudentAPI& api) {

  550. 	auto students = api.GetStudents();

  551. 	gameState.helpcount = 0;

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

  553. 		gameState.isDead[i] = 0;

  554. 		gameState.isHurt[i] = 0;

  555. 	}

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

  557. 		auto stu = (*(*it));

  558. 		auto state = stu.playerState;

  559. 		gameState.posStudent[stu.playerID].x = api.GridToCell(stu.x);

  560. 		gameState.posStudent[stu.playerID].y = api.GridToCell(stu.y);

  561. 		if (state == THUAI6::PlayerState::Quit)gameState.ifQuit[stu.playerID] = 1;

  562. 		if (stu.determination <= 0&&state!=THUAI6::PlayerState::Quit)gameState.isDead[stu.playerID] = 1;

  563. 		else {

  564. 			switch (stu.playerID) {

  565. 			case 0: {if (stu.determination < 3000000)gameState.isHurt[0] = 1; }break;

  566. 			case 1: {if (stu.determination < 3000000)gameState.isHurt[1] = 1; }break;

  567. 			case 2: {if (stu.determination < 29000000)gameState.isHurt[2] = 1; }break;

  568. 			case 3: {if (stu.determination < 3200000)gameState.isHurt[3] = 1; }break;

  569. 			default:break;

  570. 			}

  571. 		}

  572. 	}

  573. 	for (int i = 0; i < 4; i++)api.Print(fmt::format(" isDead {} is {}", i, gameState.isDead[i]));

  574. 	for (int i = 0; i < 4; i++)api.Print(fmt::format(" isHurt {} is {}", i, gameState.isHurt[i]));

  575. }

  576. void Communicate::sendHelpSignal(IStudentAPI& api, int64_t myID) {

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

  578. 		if (gameState.iftosave[i] == myID)return;//如果有人来救自己，就不发了

  579. 	}

  580. 	int trickergridx = api.CellToGrid(gameState.posTricker.x);

  581. 	int trickergridy = api.CellToGrid(gameState.posTricker.y);

  582. 	if (api.HaveView(trickergridx, trickergridy))return;//如果还能看到tricker，就不发了

  583. 	auto self = api.GetSelfInfo();

  584. 	std::pair<int, posStruct>bfsResult;

  585. 	int targetID = -1;

  586. 	int minstep = 9999;

  587. 	posStruct myPos, nextPos;

  588. 	myPos.x = api.GridToCell(self->x);

  589. 	myPos.y = api.GridToCell(self->y);

  590. 	auto message = fmt::format("h  {}", myID);

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

  592. 		if (!gameState.isDead[3] && (gameState.iftosave[3] == -1 || gameState.iftosave[3] == myID)&&!gameState.ifQuit[i]) {

  593. 			targetID = 3;

  594. 			break;

  595. 		}

  596. 		if (!gameState.isDead[i] && (gameState.iftosave[i] == -1 || gameState.iftosave[i] == myID)&&!gameState.ifQuit[i]) {

  597. 			posStruct nowstudent = { -1,-1 };

  598. 			nowstudent.x = gameState.posStudent[i].x;

  599. 			nowstudent.y = gameState.posStudent[i].y;

  600. 			bfsResult = bfs(myPos, nowstudent, api);

  601. 			if (bfsResult.first < minstep) {

  602. 				targetID = i;

  603. 				api.Print(fmt::format("targetID changed to {}", i));

  604. 				minstep = bfsResult.first;

  605. 				nextPos = bfsResult.second;

  606. 			}

  607. 		}

  608. 	}

  609. 	api.SendTextMessage(targetID, message);

  610. 	api.Print(fmt::format("sos sent to {}", targetID));

  611. }

  612. void Communicate::sendHelpingSignal(IStudentAPI& api, int64_t myID, int64_t savingID) {

  613. 	auto message = fmt::format("s {} {}", myID, savingID);

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

  615. 		if (i != myID)api.SendTextMessage(i, message);

  616. 	}

  617. }

  618. //new

  619. void Communicate::sendTrickerPos(IStudentAPI& api, int64_t myID) {

  620. 	auto trickerPtrVector = api.GetTrickers();

  621. 	if (trickerPtrVector.empty()) { return; }

  622. 	posStruct trickerPos = { api.GridToCell(trickerPtrVector[0]->x), api.GridToCell(trickerPtrVector[0]->y) };

  623. 	int trickerSwinging = trickerPtrVector[0]->playerState == THUAI6::PlayerState::Swinging;

  624. 	std::string message = fmt::format("p {} {} {} {} {}", -1, -1, trickerPos.x, trickerPos.y, trickerSwinging);

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

  626. 		if (i != myID) {

  627. 			api.SendTextMessage(i, message);

  628. 		}

  629. 	}

  630. }

  631. 

  632. void Communicate::receiveMessage(IStudentAPI& api, int64_t myID) {

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

  634. 	posStruct classroomPos, trickerPos, studentPos;

  635. 	int64_t helpID = 5, tobesaved, savingid, saverid;

  636. 	char type;

  637. 	int messageOfTrickerSwinging;

  638. 	std::stringstream ss;

  639. 	if (GameState::timeCounter >= 300)

  640. 	{

  641. 		gameState.posTricker = { -1, -1 };

  642. 		gameState.isTrickerSwinging = 0;

  643. 		GameState::timeCounter = 0;

  644. 		gameState.isStudentAttacked = false;

  645. 	}

  646. 	auto myViewOfTricker = api.GetTrickers();

  647. 	if (!myViewOfTricker.empty()) {

  648. 		gameState.posTricker = { api.GridToCell(myViewOfTricker[0]->x), api.GridToCell(myViewOfTricker[0]->y) };

  649. 		gameState.isTrickerSwinging = myViewOfTricker[0]->playerState == THUAI6::PlayerState::Swinging;

  650. 	}

  651. 	while (api.HaveMessage()) {

  652. 		ss.clear();

  653. 		message = api.GetMessage();

  654. 		ss.str(message.second);

  655. 		ss >> type;

  656. 		if (type == 'p') {

  657. 			ss >> classroomPos.x >> classroomPos.y >> trickerPos.x >> trickerPos.y >> messageOfTrickerSwinging;

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

  659. 				gameState.deleteStudiedClassroom(classroomPos);

  660. 			}

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

  662. 				gameState.posTricker = trickerPos;

  663. 			}

  664. 			if (messageOfTrickerSwinging)

  665. 				gameState.isTrickerSwinging = messageOfTrickerSwinging;

  666. 		}

  667. 		else if (type == 'h') {

  668. 			ss >> savingid;

  669. 			gameState.iftosave[myID] = savingid;

  670. 			gameState.saveID = savingid;

  671. 			api.Print(fmt::format("{} to save {} is true", myID, savingid));

  672. 		}

  673. 		else if (type == 's') {

  674. 			ss >> saverid >> savingid;

  675. 			gameState.iftosave[saverid] = savingid;

  676. 			api.Print(fmt::format("{} 's iftosave {} is true", myID, saverid));

  677. 		}

  678. 	}

  679. }

  680. 

  681. 

  682. bool vis[GameState::sizeX][GameState::sizeY];

  683. posStruct now, nxt, pre[GameState::sizeX][GameState::sizeY];

  684. std::pair<posStruct, posStruct> bfs(posStruct start, THUAI6::PlaceType destination, IStudentAPI& api)

  685. {//return pair<next_point,destination>

  686. 	std::queue<posStruct> posQ;

  687. 

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

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

  690. 	posQ.push(start);

  691. 	while (!posQ.empty())

  692. 	{

  693. 		now = posQ.front();

  694. 		posQ.pop();

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

  696. 		{

  697. 			nxt = Action::getNextPos(now, *move);

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

  699. 			{

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

  701. 				now = nxt;

  702. 				break;

  703. 			}

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

  705. 				continue;

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

  707. 			{

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

  709. 				now = nxt;

  710. 				break;

  711. 			}

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

  713. 			posQ.push(nxt);

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

  715. 		}

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

  717. 		{

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

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

  720. 			return { now,nxt };

  721. 		}

  722. 	}

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

  724. }

  725. std::pair<int, posStruct> bfs(posStruct start, posStruct destination, IStudentAPI& api)

  726. {//return pair<next_point,destination>

  727. 	std::queue<std::pair <posStruct, int> > posQ;

  728. 	int length = 0;

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

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

  731. 	posQ.push({ start, 0 });

  732. 	while (!posQ.empty())

  733. 	{

  734. 		auto node = posQ.front();

  735. 		now = node.first;

  736. 		length = node.second;

  737. 		posQ.pop();

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

  739. 		{

  740. 			nxt = Action::getNextPos(now, *move);

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

  742. 			{

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

  744. 				now = nxt;

  745. 				break;

  746. 			}

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

  748. 				continue;

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

  750. 			{

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

  752. 				now = nxt;

  753. 				break;

  754. 			}

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

  756. 			posQ.push({ nxt, length + 1 });

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

  758. 		}

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

  760. 		{

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

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

  763. 			return { length + 1, now };

  764. 		}

  765. 	}

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

  767. }

  768. 

  769. int minimax(posStruct studentPos, posStruct trickerPos, int alpha, int beta, bool isStudent, IStudentAPI& api, int depth, bool trickerSwinging, bool isTeacher) {

  770. 	if (depth == 0) {

  771. 		if (gameState.isTrickerVisible()){

  772. 			// return (studentPos.x - trickerPos.x) * (studentPos.x - trickerPos.x) + (studentPos.y - trickerPos.y) * (studentPos.y - trickerPos.y);

  773.             if (!isTeacher)

  774.                 return gameState.distance(studentPos, trickerPos);

  775.             else{

  776.                 auto students = api.GetStudents();

  777. 				int targetDistance = 10000;

  778. 				posStruct targetStudent;

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

  780.                     posStruct studentsPos = {api.GridToCell((*(*it)).x), api.GridToCell((*(*it)).y)};

  781.                     if (gameState.distance(studentsPos, gameState.posTricker) < targetDistance){

  782.                         targetDistance = gameState.distance(studentsPos, gameState.posTricker);

  783.                         targetStudent = studentsPos;

  784.                     }

  785.                 }

  786.                 return 3 * (gameState.distance(studentPos, trickerPos) + gameState.distance(studentPos, targetStudent));

  787.             }

  788. 		}

  789. 		else 

  790. 			return 0;

  791. 

  792. 	}

  793. 	if (isStudent) {

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

  795. 			posStruct nextPos = Action::getNextPos(studentPos, *move);

  796. 			if (!Action::isValidMove(nextPos, *move, gameState, api)) continue;

  797. 			alpha = std::max(alpha, minimax(nextPos, trickerPos, alpha, beta, !isStudent, api, depth, trickerSwinging, isTeacher));

  798. 			if (beta <= alpha) {

  799. 				break;

  800. 			}

  801. 		}

  802. 		return alpha;

  803. 	}

  804. 	else {

  805. 		if (trickerSwinging) {

  806. 			beta = std::min(beta, minimax(studentPos, trickerPos, alpha, beta, !isStudent, api, depth - 1, trickerSwinging, isTeacher));

  807. 		}

  808. 		else {

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

  810. 				posStruct nextPos = Action::getNextPos(trickerPos, *move);

  811. 				if (!Action::isValidMove(nextPos, *move, gameState, api)) continue;

  812. 				beta = std::min(beta, minimax(studentPos, nextPos, alpha, beta, !isStudent, api, depth - 1, trickerSwinging, isTeacher));

  813. 				if (beta <= alpha)

  814. 					break;

  815. 			}

  816. 		}

  817. 		return beta;

  818. 	}

  819. }

  820. void AI::play(IStudentAPI& api)

  821. {

  822. 	if (this->playerID == 0 || this->playerID == 1)

  823. 	{

  824. 		// 玩家0执行操作

  825. 			// 公共操作

  826. 		GameState::timeCounter++;

  827. 

  828. 		if (gameState.readCnt < 1)

  829. 		{

  830. 			gameState.getMap(api);

  831. 			gameState.readCnt++;

  832. 			gameState.getMapType();

  833. 			api.PrintSelfInfo();

  834. 			gameState.determination = api.GetSelfInfo()->determination;

  835. 		}

  836. 		auto self = api.GetSelfInfo();

  837. 		if (self->playerState == THUAI6::PlayerState::Quit) return;

  838. 

  839. 		if (self->determination < gameState.determination) {

  840. 			gameState.isStudentAttacked = true;

  841. 		}

  842. 		gameState.determination = self->determination;

  843. 		posStruct myPos = { api.GridToCell((*self).x), api.GridToCell((*self).y) };

  844. 		api.Print(fmt::format("cls finish cnt {}", GameState::clsFinishCnt));

  845. 		if ((*self).determination <= 0)Communicate::sendHelpSignal(api, this->playerID);

  846. 		Communicate::sendTrickerPos(api, this->playerID);

  847. 		Communicate::receiveMessage(api, this->playerID);

  848. 		Communicate::getMateinfo(api);//获取友军位置和死亡情况

  849. 		if (gameState.saveID != -1) {//初始化救人信息

  850. 			if (!gameState.isDead[gameState.saveID]) {

  851. 				gameState.saveID = -1;

  852. 				api.Print(fmt::format("saveID reset"));

  853. 			}

  854. 			else api.StartRouseMate(gameState.saveID);//开局救一下人

  855. 		}

  856. 		// if (gameState.isClassroomNear(myPos)) {

  857. 		// 	api.UseSkill(0);

  858. 		// 	api.StartLearning();

  859. 		// }//直接学一下

  860. 		api.Print(fmt::format("{} save id is {}", this->playerID, gameState.saveID));

  861. 		if (gameState.isAtCell((*self).x, (*self).y, api.CellToGrid(myPos.x), api.CellToGrid(myPos.y)) || Action::isAtCellFalseCnt > 10)

  862. 		{

  863. 			Action::isAtCellFalseCnt = 0;

  864. 			if (gameState.isTrickerClose(myPos, api, 10))

  865. 			{

  866. 				//离Tricker过近

  867. 				//规避Tricker（待完成）

  868. 				api.Print(fmt::format("start escaping!!!"));

  869. 				posStruct grassOccupied = { -1, -1 };

  870. 				posStruct nearGrass = gameState.isGrassNear(myPos, api);

  871. 				if (!gameState.isGrass(myPos) && nearGrass != grassOccupied && !gameState.isGrass(gameState.posTricker)) {

  872. 					auto students = api.GetStudents();

  873. 					auto grass = bfs(myPos, nearGrass, api);

  874. 					posStruct nextPos = grass.second;

  875. 					if (gameState.isWindow(nextPos))

  876. 						api.SkipWindow();

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

  878. 					lastNextPos = nextPos;

  879. 				}

  880. 				else if (gameState.isGrass(myPos) && !gameState.isGrass(gameState.posTricker) && !gameState.isStudentAttacked) {

  881. 

  882. 				}

  883. 				else

  884. 				{

  885. 					if (gameState.isTrickerSwinging) {

  886. 						api.Print(fmt::format("Tricker is swinging, run!"));

  887. 					}

  888. 					int alpha = -1000000;

  889. 					int beta = 1000000;

  890. 					int ans = -100000;

  891. 					Action::Direction ans_action;

  892. 					bool flag = 0;

  893. 					posStruct nextPos;

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

  895. 						nextPos = Action::getNextPos(myPos, *move);

  896. 						if (!Action::isValidMove(nextPos, *move, gameState, api)) continue;

  897. 						int possibleValue;

  898. 						if (gameState.isTrickerAttackGrass(api, myPos)){

  899. 							possibleValue = minimax(nextPos, gameState.posTricker, alpha, beta, 0, api, 3, true, false);

  900. 						}

  901. 						else {

  902. 							possibleValue = minimax(nextPos, gameState.posTricker, alpha, beta, 0, api, 3, gameState.isTrickerSwinging, false);

  903. 						}

  904. 						api.Print(fmt::format("Possiblevalue:{}", possibleValue));

  905. 						if (possibleValue > ans) {

  906. 							ans = possibleValue;

  907. 							ans_action = *move;

  908. 							flag = 1;

  909. 							api.Print(fmt::format("ans_action updated!!"));

  910. 

  911. 						}

  912. 					}

  913. 					if (flag) {

  914. 						nextPos = Action::getNextPos(myPos, ans_action);

  915. 						if (gameState.isWindow(nextPos))

  916. 							api.SkipWindow();

  917. 						Action::Move(ans_action, api);

  918. 						lastNextPos = nextPos;

  919. 						api.Print(fmt::format("ans_action:{}", (int)ans_action));

  920. 					}

  921. 				}

  922. 			}//规避

  923. 			else if (api.GetSelfInfo()->dangerAlert && api.GetSelfInfo()->dangerAlert < 1000000) {

  924. 				if (gameState.isGrass(myPos)) {

  925. 					//如果在草里，就待着

  926. 				}

  927. 				else {

  928. 					//如果不在草里，就进草

  929. 					api.Print(fmt::format("dangerAlert: {}", api.GetSelfInfo()->dangerAlert));

  930. 					auto grass = bfs(myPos, THUAI6::PlaceType::Grass, api);

  931. 

  932. 					posStruct grassOccupied = { -1, -1 };

  933. 					// posStruct nearGrass = gameState.isGrassNear(myPos, api);

  934. 					posStruct nearGrass = grass.first;

  935. 					if (!gameState.isGrass(myPos) && nearGrass != grassOccupied && !gameState.isGrass(gameState.posTricker)) {

  936. 						auto students = api.GetStudents();

  937. 						auto grass = bfs(myPos, nearGrass, api);

  938. 						posStruct nextPos = grass.second;

  939. 						if (gameState.isWindow(nextPos))

  940. 							api.SkipWindow();

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

  942. 						lastNextPos = nextPos;

  943. 					}

  944. 				}

  945. 			}

  946. 			else if (gameState.saveID != -1)//离Tricker有一段距离且有人需要救,去救人

  947. 			{

  948. 				posStruct nextPos = { -1,-1 };

  949. 				std::pair<int, posStruct>bfsResult;

  950. 				bfsResult = bfs(myPos, gameState.posStudent[gameState.saveID], api);

  951. 				nextPos = bfsResult.second;

  952. 				Communicate::sendHelpingSignal(api, this->playerID, gameState.saveID);

  953. 				api.Print(fmt::format("go to save {}", gameState.saveID));

  954. 

  955. 				if (!gameState.atPosition(myPos, gameState.posStudent[gameState.saveID])) {//如果还没到救人位置

  956. 					if (gameState.isWindow(nextPos))

  957. 						api.SkipWindow();

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

  959. 					lastNextPos = nextPos;

  960. 					lastMove = Action::posToDirection(myPos, nextPos);

  961. 					api.Print(fmt::format("moving to save {}", gameState.saveID));

  962. 				}

  963. 			}

  964. 			else if (!gameState.readyToGraduate())

  965. 			{

  966. 				//还没达到毕业要求

  967. 				//bfs搜教室

  968. 				auto tmp = bfs(myPos, THUAI6::PlaceType::ClassRoom, api);

  969. 				auto nextPos = tmp.first;

  970. 				auto classroomPos = tmp.second;

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

  972. 				if (nextPos.x == -1)

  973. 					return;

  974. 				if (!gameState.atPosition(myPos, classroomPos))

  975. 				{

  976. 					//还没到达教室,前往教室

  977. 					//如果是窗，就翻窗

  978. 					if (gameState.isWindow(nextPos))

  979. 						api.SkipWindow();

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

  981. 					lastNextPos = nextPos;

  982. 					lastMove = Action::posToDirection(myPos, nextPos);

  983. 				}

  984. 				else

  985. 				{

  986. 					//到达教室，开始学习

  987. 					api.Print("reach classroom");

  988. 					if (gameState.isClassroomFinished(classroomPos, api))

  989. 					{

  990. 						//如果学完了,就把这个教室从教室列表中删掉

  991. 						api.Print("finish classroom");

  992. 						gameState.deleteStudiedClassroom(classroomPos);

  993. 						Communicate::sendClassroonPos(api, this->playerID, classroomPos);

  994. 					}

  995. 					else

  996. 					{

  997. 						//如果没学完，就在教室学

  998. 						api.UseSkill(0);

  999. 						api.StartLearning();

  1000. 					}

  1001. 				}

  1002. 			}

  1003. 			else

  1004. 			{

  1005. 				//达到毕业要求，前往校门处开门

  1006. 				api.Print("ready to graduate");

  1007. 				auto tmp = bfs(myPos, THUAI6::PlaceType::Gate, api);

  1008. 				auto nextPos = tmp.first;

  1009. 				auto gatePos = tmp.second;

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

  1011. 				if (nextPos.x == -1)

  1012. 					return;

  1013. 				if (!gameState.atPosition(myPos, gatePos))

  1014. 				{

  1015. 					//还没到达大门,前往大门

  1016. 					//如果是窗，就翻窗

  1017. 					if (gameState.isWindow(nextPos))

  1018. 						api.SkipWindow();

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

  1020. 					lastNextPos = nextPos;

  1021. 					lastMove = Action::posToDirection(myPos, nextPos);

  1022. 				}

  1023. 				else

  1024. 				{

  1025. 					//到达大门，开始开门

  1026. 					//api.Print("reach gate");

  1027. 					if (gameState.isGateFinished(gatePos, api))

  1028. 					{

  1029. 						//如果开门了,就毕业

  1030. 						//api.Print("gate opened");

  1031. 						api.Graduate();

  1032. 					}

  1033. 					else

  1034. 					{

  1035. 						//如果没开好，就开门

  1036. 						api.StartOpenGate();

  1037. 					}

  1038. 				}

  1039. 			}

  1040. 		}

  1041. 		else

  1042. 		{

  1043. 			//如果不在完整格点内，就先移动到格点

  1044. 			Action::isAtCellFalseCnt++;

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

  1046. 		}

  1047. 	}

  1048. 	else if (this->playerID == 2)

  1049. 	{

  1050. 		// 公共操作

  1051. 		GameState::timeCounter++;

  1052. 		if (gameState.readCnt < 1)

  1053. 		{

  1054. 			gameState.getMap(api);

  1055. 			gameState.readCnt++;

  1056. 			gameState.getMapType();

  1057. 			api.PrintSelfInfo();

  1058. 		}

  1059. 		auto self = api.GetSelfInfo();

  1060. 		if (self->playerState == THUAI6::PlayerState::Quit)return;

  1061. 		posStruct myPos = { api.GridToCell((*self).x), api.GridToCell((*self).y) };

  1062. 		api.Print(fmt::format("cls finish cnt {}", GameState::clsFinishCnt));

  1063. 		if ((*self).determination <= 0)Communicate::sendHelpSignal(api, this->playerID);

  1064. 		Communicate::sendTrickerPos(api, this->playerID);

  1065. 		Communicate::receiveMessage(api, this->playerID);

  1066. 		Communicate::getMateinfo(api);//获取友军位置和死亡情况

  1067. 		if (gameState.saveID != -1) {//初始化救人信息

  1068. 			if (!gameState.isDead[gameState.saveID]) {

  1069. 				gameState.saveID = -1;

  1070. 				api.Print(fmt::format("saveID reset"));

  1071. 			}

  1072. 			else api.StartRouseMate(gameState.saveID);//开局救一下人

  1073. 		}

  1074. 		// if (gameState.isClassroomNear(myPos)) {

  1075. 		// 	api.UseSkill(0);

  1076. 		// 	api.StartLearning();

  1077. 		// }

  1078. 		api.Print(fmt::format("{} save id is {}", this->playerID, gameState.saveID));

  1079. 		if (gameState.isAtCell((*self).x, (*self).y, api.CellToGrid(myPos.x), api.CellToGrid(myPos.y)) || Action::isAtCellFalseCnt > 10){

  1080. 			Action::isAtCellFalseCnt = 0;

  1081. 			if (gameState.saveID != -1)//离Tricker有一段距离且有人需要救,去救人

  1082. 			{

  1083. 				posStruct nextPos = { -1,-1 };

  1084. 				std::pair<int, posStruct>bfsResult;

  1085. 				bfsResult = bfs(myPos, gameState.posStudent[gameState.saveID], api);

  1086. 				nextPos = bfsResult.second;

  1087. 				Communicate::sendHelpingSignal(api, this->playerID, gameState.saveID);

  1088. 				api.Print(fmt::format("go to save {}", gameState.saveID));

  1089. 

  1090. 				if (!gameState.atPosition(myPos, gameState.posStudent[gameState.saveID])) {//如果还没到救人位置

  1091. 					if (gameState.isWindow(nextPos))

  1092. 						api.SkipWindow();

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

  1094. 					lastNextPos = nextPos;

  1095. 					lastMove = Action::posToDirection(myPos, nextPos);

  1096. 					api.Print(fmt::format("moving to save {}", gameState.saveID));

  1097. 				}

  1098. 			}

  1099. 			else if(!gameState.readyToGraduate()) {

  1100. 			//----------------------找教室------------------------

  1101. 			if (!gameState.isTrickerVisible()) {

  1102. 				auto tmp = bfs(myPos, THUAI6::PlaceType::ClassRoom, api);

  1103. 				auto nextPos = tmp.first;

  1104. 				auto classroomPos = tmp.second;

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

  1106. 				if (nextPos.x == -1)

  1107. 					return;

  1108. 				if (!gameState.atPosition(myPos, classroomPos))

  1109. 				{

  1110. 					//还没到达教室,前往教室

  1111. 					//如果是窗，就翻窗

  1112. 					if (gameState.isWindow(nextPos))

  1113. 						api.SkipWindow();

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

  1115. 					lastNextPos = nextPos;

  1116. 					lastMove = Action::posToDirection(myPos, nextPos);

  1117. 				}

  1118. 				else

  1119. 				{

  1120. 					//到达教室，开始学习

  1121. 					api.Print("reach classroom");

  1122. 					if (gameState.isClassroomFinished(classroomPos, api))

  1123. 					{

  1124. 						//如果学完了,就把这个教室从教室列表中删掉

  1125. 						api.Print("finish classroom");

  1126. 						gameState.deleteStudiedClassroom(classroomPos);

  1127. 						Communicate::sendClassroonPos(api, this->playerID, classroomPos);

  1128. 					}

  1129. 					else

  1130. 					{

  1131. 						//如果没学完，就在教室学

  1132. 						api.StartLearning();

  1133. 					}

  1134. 				}

  1135. 			

  1136. 			}

  1137. 			else if (gameState.distance(myPos, gameState.posTricker) >= 10) {

  1138. 				//---------------离tricker有一定距离，寻找tricker---------------

  1139. 				auto tricker = bfs(myPos, gameState.posTricker, api);

  1140. 				posStruct nextPos = tricker.second;

  1141. 				if (gameState.isWindow(nextPos))

  1142. 					api.SkipWindow();

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

  1144. 				lastNextPos = nextPos;

  1145. 			}

  1146. 			else {

  1147. 				//------------离tricker很近---------------------

  1148. 				auto self = api.GetSelfInfo();

  1149. 				double punishTime = self->timeUntilSkillAvailable[0];

  1150. 				double haveTeaTime = self->timeUntilSkillAvailable[1];

  1151. 				if (punishTime > 0) {

  1152. 					//-------------------------技能还没好，先逃跑---------

  1153. 					posStruct grassOccupied = { -1, -1 };

  1154. 					posStruct nearGrass = gameState.isGrassNear(myPos, api);

  1155. 					if (!gameState.isGrass(myPos) && nearGrass != grassOccupied && !gameState.isGrass(gameState.posTricker)) {

  1156. 						auto students = api.GetStudents();

  1157. 						auto grass = bfs(myPos, nearGrass, api);

  1158. 						posStruct nextPos = grass.second;

  1159. 						if (gameState.isWindow(nextPos))

  1160. 							api.SkipWindow();

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

  1162. 						lastNextPos = nextPos;

  1163. 					}

  1164. 					else if (gameState.isGrass(myPos) && !gameState.isGrass(gameState.posTricker) && !gameState.isStudentAttacked) {

  1165. 

  1166. 					}

  1167. 					else {

  1168. 						int alpha = -1000000;

  1169. 						int beta = 1000000;

  1170. 						int ans = -100000;

  1171. 						Action::Direction ans_action;

  1172. 						bool flag = 0;

  1173. 						posStruct nextPos;

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

  1175. 							nextPos = Action::getNextPos(myPos, *move);

  1176. 							if (!Action::isValidMove(nextPos, *move, gameState, api)) continue;

  1177. 							int possibleValue;

  1178. 							if (gameState.isTrickerAttackGrass(api, myPos)){

  1179. 								possibleValue = minimax(nextPos, gameState.posTricker, alpha, beta, 0, api, 3, true, false);

  1180. 							}

  1181. 							else {

  1182. 								possibleValue = minimax(nextPos, gameState.posTricker, alpha, beta, 0, api, 3, gameState.isTrickerSwinging, false);

  1183. 							}

  1184. 							api.Print(fmt::format("Possiblevalue:{}", possibleValue));

  1185. 							if (possibleValue > ans) {

  1186. 								ans = possibleValue;

  1187. 								ans_action = *move;

  1188. 								flag = 1;

  1189. 								api.Print(fmt::format("ans_action updated!!"));

  1190. 							}

  1191. 						}

  1192. 						if (flag) {

  1193. 							nextPos = Action::getNextPos(myPos, ans_action);

  1194. 							//如果闪现好了，就闪现

  1195. 							if (haveTeaTime == 0) {

  1196. 								gridPos myGrid, nextGrid;

  1197. 								myGrid = { api.CellToGrid(myPos.x), api.CellToGrid(myPos.y) };

  1198. 								nextGrid = { api.CellToGrid(nextPos.x), api.CellToGrid(nextPos.y) };

  1199. 								double angle = gameState.getAngle(myGrid, nextGrid);

  1200. 								api.UseSkill(1, angle * 1000);

  1201. 							}

  1202. 							else {

  1203. 								if (gameState.isWindow(nextPos))

  1204. 									api.SkipWindow();

  1205. 								Action::Move(ans_action, api);

  1206. 								lastNextPos = nextPos;

  1207. 								api.Print(fmt::format("ans_action:{}", (int)ans_action));

  1208. 							}

  1209. 						}

  1210. 					}

  1211. 				}

  1212. 				else {

  1213. 					//----------------------技能好了，给tricker迎头痛击！---------

  1214. 					auto tricker = bfs(myPos, gameState.posTricker, api);

  1215. 					posStruct nextPos = tricker.second;

  1216. 					if (gameState.isWindow(nextPos))

  1217. 						api.SkipWindow();

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

  1219. 					lastNextPos = nextPos;

  1220. 					gridPos myGrid, trickerGrid;

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

  1222. 					trickerGrid = { api.CellToGrid(gameState.posTricker.x), api.CellToGrid(gameState.posTricker.y) };

  1223. 					if (sqrt((myGrid.x - trickerGrid.x) * (myGrid.x - trickerGrid.x) + (myGrid.y - trickerGrid.y) * (myGrid.y - trickerGrid.y)) <= self->viewRange / 3) {

  1224. 						api.UseSkill(0);

  1225. 					}

  1226. 				}

  1227. 			}

  1228. 			}

  1229. 			else{

  1230. 				auto self = api.GetSelfInfo();

  1231. 				double punishTime = self->timeUntilSkillAvailable[0];

  1232. 				double haveTeaTime = self->timeUntilSkillAvailable[1];

  1233. 				posStruct grassOccupied = { -1, -1 };

  1234. 					posStruct nearGrass = gameState.isGrassNear(myPos, api);

  1235. 					if (!gameState.isGrass(myPos) && nearGrass != grassOccupied && !gameState.isGrass(gameState.posTricker)) {

  1236. 						auto students = api.GetStudents();

  1237. 						auto grass = bfs(myPos, nearGrass, api);

  1238. 						posStruct nextPos = grass.second;

  1239. 						if (gameState.isWindow(nextPos))

  1240. 							api.SkipWindow();

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

  1242. 						lastNextPos = nextPos;

  1243. 					}

  1244. 					else if (gameState.isGrass(myPos) && !gameState.isGrass(gameState.posTricker) && !gameState.isStudentAttacked) {

  1245. 

  1246. 					}

  1247. 					else {

  1248. 						int alpha = -1000000;

  1249. 						int beta = 1000000;

  1250. 						int ans = -100000;

  1251. 						Action::Direction ans_action;

  1252. 						bool flag = 0;

  1253. 						posStruct nextPos;

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

  1255. 							nextPos = Action::getNextPos(myPos, *move);

  1256. 							if (!Action::isValidMove(nextPos, *move, gameState, api)) continue;

  1257. 							int possibleValue;

  1258. 							if (gameState.isTrickerAttackGrass(api, myPos)){

  1259. 								possibleValue = minimax(nextPos, gameState.posTricker, alpha, beta, 0, api, 3, true, false);

  1260. 							}

  1261. 							else {

  1262. 								possibleValue = minimax(nextPos, gameState.posTricker, alpha, beta, 0, api, 3, gameState.isTrickerSwinging, false);

  1263. 							}

  1264. 							api.Print(fmt::format("Possiblevalue:{}", possibleValue));

  1265. 							if (possibleValue > ans) {

  1266. 								ans = possibleValue;

  1267. 								ans_action = *move;

  1268. 								flag = 1;

  1269. 								api.Print(fmt::format("ans_action updated!!"));

  1270. 							}

  1271. 						}

  1272. 						if (flag) {

  1273. 							nextPos = Action::getNextPos(myPos, ans_action);

  1274. 							//如果闪现好了，就闪现

  1275. 							if (haveTeaTime == 0) {

  1276. 								gridPos myGrid, nextGrid;

  1277. 								myGrid = { api.CellToGrid(myPos.x), api.CellToGrid(myPos.y) };

  1278. 								nextGrid = { api.CellToGrid(nextPos.x), api.CellToGrid(nextPos.y) };

  1279. 								double angle = gameState.getAngle(myGrid, nextGrid);

  1280. 								api.UseSkill(1, angle * 1000);

  1281. 							}

  1282. 							else {

  1283. 								if (gameState.isWindow(nextPos))

  1284. 									api.SkipWindow();

  1285. 								Action::Move(ans_action, api);

  1286. 								lastNextPos = nextPos;

  1287. 								api.Print(fmt::format("ans_action:{}", (int)ans_action));

  1288. 							}

  1289. 						}

  1290. 					}

  1291. 			}

  1292. 		}

  1293. 		else

  1294. 		{

  1295. 			//如果不在完整格点内，就先移动到格点

  1296. 			Action::isAtCellFalseCnt++;

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

  1298. 		}

  1299. 	}

  1300. 	//当然可以写成if (this->playerID == 2||this->playerID == 3)之类的操作

  1301. 	//公共操作

  1302. 	else if (this->playerID == 3){

  1303. 		GameState::timeCounter++;

  1304. 		

  1305. 		if (gameState.readCnt < 1)

  1306. 		{

  1307. 			gameState.getMap(api);

  1308. 			gameState.readCnt++;

  1309. 			gameState.getMapType();

  1310. 			api.PrintSelfInfo();

  1311. 		}

  1312. 		auto self = api.GetSelfInfo();

  1313. 		if (self->playerState == THUAI6::PlayerState::Quit)return;

  1314. 		bool iftocure = 0;//是否去给人回血

  1315. 		int curetarget = -1;

  1316. 		posStruct myPos = { api.GridToCell((*self).x), api.GridToCell((*self).y) };

  1317. 		api.Print(fmt::format("cls finish cnt {}", GameState::clsFinishCnt));

  1318. 		if ((*self).determination <= 0)Communicate::sendHelpSignal(api, this->playerID);

  1319. 		Communicate::sendTrickerPos(api, this->playerID);

  1320. 		Communicate::receiveMessage(api, this->playerID);

  1321. 		Communicate::getMateinfo(api);//获取友军位置和死亡情况

  1322. 		if (gameState.saveID != -1) {//初始化救人信息

  1323. 			if (!gameState.isDead[gameState.saveID]) {

  1324. 				gameState.saveID = -1;

  1325. 				api.Print(fmt::format("saveID reset"));

  1326. 			}

  1327. 			else {

  1328. 				int32_t gridx = api.CellToGrid(gameState.posStudent[gameState.saveID].x);

  1329. 				int32_t gridy = api.CellToGrid(gameState.posStudent[gameState.saveID].y);

  1330. 				if (api.HaveView(gridx, gridy)) {

  1331. 					api.UseSkill(0);

  1332. 					api.UseSkill(1);

  1333. 				}

  1334. 				api.StartRouseMate(gameState.saveID);

  1335. 			}

  1336. 		}

  1337. 		else {

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

  1339. 				if (gameState.isHurt[i]) {

  1340. 					int32_t gridx = api.CellToGrid(gameState.posStudent[i].x);

  1341. 					int32_t gridy = api.CellToGrid(gameState.posStudent[i].y);

  1342. 					if (api.HaveView(gridx, gridy)) {

  1343. 						api.UseSkill(1);

  1344. 						api.UseSkill(2);

  1345. 						api.Print(fmt::format("useskill 1 and 2"));

  1346. 					}

  1347. 					else {

  1348. 						if (self->timeUntilSkillAvailable[1] == 0)

  1349. 							curetarget = i;

  1350. 					}

  1351. 				}

  1352. 		}

  1353. 		//直接学一下

  1354. 		/*for (int i = 0; i < 4; i++) {

  1355. 			if (gameState.isDead[i])api.StartRouseMate(i);

  1356. 		}//直接救一下*/

  1357. 		api.Print(fmt::format("{} save id is {}", this->playerID, gameState.saveID));

  1358. 		api.Print(fmt::format("{} curetarget is {}", this->playerID, curetarget));

  1359. 		if (gameState.isAtCell((*self).x, (*self).y, api.CellToGrid(myPos.x), api.CellToGrid(myPos.y)) || Action::isAtCellFalseCnt > 10)

  1360. 		{

  1361. 			Action::isAtCellFalseCnt = 0;

  1362. 			if (gameState.isTrickerClose(myPos, api, 10))

  1363. 			{

  1364. 				//离Tricker过近

  1365. 				//规避Tricker（待完成）

  1366. 				api.Print(fmt::format("start escaping!!!"));

  1367. 				posStruct grassOccupied = { -1, -1 };

  1368. 				posStruct nearGrass = gameState.isGrassNear(myPos, api);

  1369. 				if (!gameState.isGrass(myPos) && nearGrass != grassOccupied && !gameState.isGrass(gameState.posTricker)) {

  1370. 					auto students = api.GetStudents();

  1371. 					auto grass = bfs(myPos, nearGrass, api);

  1372. 					posStruct nextPos = grass.second;

  1373. 					if (gameState.isWindow(nextPos))

  1374. 						api.SkipWindow();

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

  1376. 					lastNextPos = nextPos;

  1377. 				}

  1378. 				else if (gameState.isGrass(myPos) && !gameState.isGrass(gameState.posTricker) && !gameState.isStudentAttacked) {

  1379. 

  1380. 				}

  1381. 				else

  1382. 				{

  1383. 					if (gameState.isTrickerSwinging) {

  1384. 						api.Print(fmt::format("Tricker is swinging, run!"));

  1385. 					}

  1386. 					int alpha = -1000000;

  1387. 					int beta = 1000000;

  1388. 					int ans = -100000;

  1389. 					Action::Direction ans_action;

  1390. 					bool flag = 0;

  1391. 					posStruct nextPos;

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

  1393. 						nextPos = Action::getNextPos(myPos, *move);

  1394. 						if (!Action::isValidMove(nextPos, *move, gameState, api)) continue;

  1395. 						int possibleValue;

  1396. 						if (gameState.isTrickerAttackGrass(api, myPos)){

  1397. 							possibleValue = minimax(nextPos, gameState.posTricker, alpha, beta, 0, api, 3, true, false);

  1398. 						}

  1399. 						else {

  1400. 							possibleValue = minimax(nextPos, gameState.posTricker, alpha, beta, 0, api, 3, gameState.isTrickerSwinging, false);

  1401. 						}

  1402. 						api.Print(fmt::format("Possiblevalue:{}", possibleValue));

  1403. 						if (possibleValue > ans) {

  1404. 							ans = possibleValue;

  1405. 							ans_action = *move;

  1406. 							flag = 1;

  1407. 							api.Print(fmt::format("ans_action updated!!"));

  1408. 

  1409. 						}

  1410. 					}

  1411. 					if (flag) {

  1412. 						nextPos = Action::getNextPos(myPos, ans_action);

  1413. 						if (gameState.isWindow(nextPos))

  1414. 							api.SkipWindow();

  1415. 						Action::Move(ans_action, api);

  1416. 						lastNextPos = nextPos;

  1417. 						api.Print(fmt::format("ans_action:{}", (int)ans_action));

  1418. 					}

  1419. 				}

  1420. 			}//规避

  1421. 			else if (api.GetSelfInfo()->dangerAlert && api.GetSelfInfo()->dangerAlert < 1000000) {

  1422. 				if (gameState.isGrass(myPos)) {

  1423. 

  1424. 				}

  1425. 				else {

  1426. 					api.Print(fmt::format("dangerAlert: {}", api.GetSelfInfo()->dangerAlert));

  1427. 					auto grass = bfs(myPos, THUAI6::PlaceType::Grass, api);

  1428. 					api.UseSkill(2);

  1429. 					posStruct grassOccupied = { -1, -1 };

  1430. 					posStruct nearGrass = grass.first;

  1431. 					if (!gameState.isGrass(myPos) && nearGrass != grassOccupied && !gameState.isGrass(gameState.posTricker)) {

  1432. 						auto students = api.GetStudents();

  1433. 						auto grass = bfs(myPos, nearGrass, api);

  1434. 						posStruct nextPos = grass.second;

  1435. 						if (gameState.isWindow(nextPos))

  1436. 							api.SkipWindow();

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

  1438. 						lastNextPos = nextPos;

  1439. 					}

  1440. 

  1441. 					// posStruct nextPos = grass.first;

  1442. 					// posStruct grassPos = grass.second;

  1443. 					// api.Print(fmt::format("grass: ({}, {})", grassPos.x, grassPos.y));

  1444. 					// if (gameState.isWindow(nextPos))

  1445. 					// 	api.SkipWindow();

  1446. 					// Action::Move(nextPos, api);

  1447. 					// lastNextPos = nextPos;

  1448. 				}

  1449. 			}

  1450. 			else if (gameState.saveID != -1)//离Tricker有一段距离且有人需要救,去救人

  1451. 			{

  1452. 				posStruct nextPos = { -1,-1 };

  1453. 				std::pair<int, posStruct>bfsResult;

  1454. 				bfsResult = bfs(myPos, gameState.posStudent[gameState.saveID], api);

  1455. 				nextPos = bfsResult.second;

  1456. 				Communicate::sendHelpingSignal(api, this->playerID, gameState.saveID);

  1457. 				api.Print(fmt::format("go to save {}", gameState.saveID));

  1458. 

  1459. 				if (!gameState.atPosition(myPos, gameState.posStudent[gameState.saveID])) {//如果还没到救人位置

  1460. 					if (gameState.isWindow(nextPos))

  1461. 						api.SkipWindow();

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

  1463. 					lastNextPos = nextPos;

  1464. 					lastMove = Action::posToDirection(myPos, nextPos);

  1465. 					api.Print(fmt::format("moving to save {}", gameState.saveID));

  1466. 				}

  1467. 

  1468. 

  1469. 			}

  1470. 			else if (curetarget != -1) {//有人残血，去回血

  1471. 			posStruct nextPos = { -1,-1 };

  1472. 			std::pair<int, posStruct>bfsResult;

  1473. 			bfsResult = bfs(myPos, gameState.posStudent[curetarget], api);

  1474. 			nextPos = bfsResult.second;

  1475. 			api.Print(fmt::format("help nxtPos {} {}",nextPos.x,nextPos.y)); 

  1476. 			if (!gameState.atPosition(myPos, gameState.posStudent[curetarget])) {//如果还没到救人位置

  1477. 				if (gameState.isWindow(nextPos))

  1478. 					api.SkipWindow();

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

  1480. 				lastNextPos = nextPos;

  1481. 				lastMove = Action::posToDirection(myPos, nextPos);

  1482. 				api.Print(fmt::format("moving to cure {}", curetarget));

  1483. 			}

  1484. 

  1485. 			}

  1486. 			else if (!gameState.readyToGraduate())

  1487. 			{

  1488. 				//还没达到毕业要求

  1489. 				//bfs搜教室

  1490. 				auto tmp = bfs(myPos, THUAI6::PlaceType::ClassRoom, api);

  1491. 				auto nextPos = tmp.first;

  1492. 				auto classroomPos = tmp.second;

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

  1494.                 api.Print(fmt::format("cls pos {} {}",classroomPos.x,classroomPos.y));

  1495. 				if (nextPos.x == -1)

  1496. 					return;

  1497. 				if (!gameState.atPosition(myPos, classroomPos))

  1498. 				{

  1499. 					//还没到达教室,前往教室

  1500. 					//如果是窗，就翻窗

  1501. 					if (gameState.isWindow(nextPos))

  1502. 						api.SkipWindow();

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

  1504. 					lastNextPos = nextPos;

  1505. 					lastMove = Action::posToDirection(myPos, nextPos);

  1506. 				}

  1507. 				else

  1508. 				{

  1509. 					//到达教室，开始学习

  1510. 					api.Print("reach classroom");

  1511. 					if (gameState.isClassroomFinished(classroomPos, api))

  1512. 					{

  1513. 						//如果学完了,就把这个教室从教室列表中删掉

  1514. 						api.Print("finish classroom");

  1515. 						gameState.deleteStudiedClassroom(classroomPos);

  1516. 						Communicate::sendClassroonPos(api, this->playerID, classroomPos);

  1517. 					}

  1518. 					else

  1519. 					{

  1520. 					//	//如果没学完，就在教室学

  1521. 					//	api.UseSkill(0);

  1522. 						api.StartLearning();

  1523. 					}

  1524. 				}

  1525. 			}

  1526. 			else

  1527. 			{

  1528. 				//达到毕业要求，前往校门处开门

  1529. 				api.Print("ready to graduate");

  1530. 				auto tmp = bfs(myPos, THUAI6::PlaceType::Gate, api);

  1531. 				auto nextPos = tmp.first;

  1532. 				auto gatePos = tmp.second;

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

  1534. 				if (nextPos.x == -1)

  1535. 					return;

  1536. 				if (!gameState.atPosition(myPos, gatePos))

  1537. 				{

  1538. 					//还没到达大门,前往大门

  1539. 					//如果是窗，就翻窗

  1540. 					if (gameState.isWindow(nextPos))

  1541. 						api.SkipWindow();

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

  1543. 					lastNextPos = nextPos;

  1544. 					lastMove = Action::posToDirection(myPos, nextPos);

  1545. 				}

  1546. 				else

  1547. 				{

  1548. 					//到达大门，开始开门

  1549. 					//api.Print("reach gate");

  1550. 					if (gameState.isGateFinished(gatePos, api))

  1551. 					{

  1552. 						//如果开门了,就毕业

  1553. 						//api.Print("gate opened");

  1554. 						api.Graduate();

  1555. 					}

  1556. 					else

  1557. 					{

  1558. 						//如果没开好，就开门

  1559. 						api.StartOpenGate();

  1560. 					}

  1561. 				}

  1562. 			}

  1563. 		}

  1564. 		else

  1565. 		{

  1566. 			//如果不在完整格点内，就先移动到格点

  1567. 			Action::isAtCellFalseCnt++;

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

  1569. 			api.Print(fmt::format("moving to complete gedian"));

  1570. 		}

  1571. }

  1572. }

  1573. void AI::play(ITrickerAPI& api) {

  1574. 	api.UseSkill(0);

  1575. }