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.
Tree: 5d411b646a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5d411b646a'
${ noResults }
THUAI6/players/你说什么都队/player5.cpp

1227 lines
47 kB
Raw Blame History 

  1. #include <vector>

  2. #include <thread>

  3. #include <array>

  4. #include <chrono>

  5. #include <queue>

  6. #include <cmath>

  7. #include <map>

  8. #include <algorithm>

  9. #include <string>

  10. #include "AI.h"

  11. #include "constants.h"

  12. using namespace std;

  13. #define PI 3.14159

  14. 

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

  16. extern const bool asynchronous = true;

  17. 

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

  19. 

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

  21.     THUAI6::StudentType::StraightAStudent,

  22.     THUAI6::StudentType::Athlete,

  23.     THUAI6::StudentType::StraightAStudent,

  24.     THUAI6::StudentType::Sunshine };

  25. 

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

  27. 

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

  29. 

  30. // 全局变量区

  31. bool ifchecked = false;

  32. std::vector<std::vector<THUAI6::PlaceType>> Map;//全局地图

  33. std::vector<std::pair<int32_t, int32_t>> Door3Position;// 3门的位置（x, y）

  34. std::vector<std::pair<int32_t, int32_t>> Door5Position; // 5门的位置

  35. std::vector<std::pair<int32_t, int32_t>> Door6Position; // 6门的位置

  36. std::vector<std::pair<int32_t, int32_t>> ClassroomPosition;//教室的位置

  37. std::vector<std::pair<int32_t, int32_t>> Chest;//箱子的位置

  38. std::vector<std::pair<int32_t, int32_t>> Gate;//校门

  39. static int num = 0;

  40. struct Node

  41. {

  42.     int x, y;

  43.     int Gcost, Hcost, Fcost;//0 1 2 空地，openlist，closelist

  44.     int flag;

  45.     struct Node* Parent;

  46. };

  47. Node NodeMap[50][50] = { 0 };

  48. static int current = 0;

  49. class MyFunction

  50. {

  51. public:

  52. 

  53.     //移动函数

  54.     bool isLeftoutofcell(IStudentAPI& api, int32_t cellx, int32_t celly) {

  55.         if (api.GetSelfInfo()->y - 400 < celly * 1000) return true;

  56.         else return false;

  57.     }//判断是否在目标格左边一定范围

  58. 

  59.     bool isRightoutofcell(IStudentAPI& api, int32_t cellx, int32_t celly) {

  60.         if (api.GetSelfInfo()->y + 400 > (celly + 1) * 1000) return true;

  61.         else return false;

  62.     }//判断是否在目标格右边一定范围

  63. 

  64.     bool isUpoutofcell(IStudentAPI& api, int32_t cellx, int32_t celly) {

  65.         if (api.GetSelfInfo()->x - 400 < cellx * 1000) return true;

  66.         else return false;

  67.     }//判断是否在目标格上边一定范围

  68. 

  69.     bool isDownoutofcell(IStudentAPI& api, int32_t cellx, int32_t celly) {

  70.         if (api.GetSelfInfo()->x + 400 > (cellx + 1) * 1000) return true;

  71.         else return false;

  72.     }//判断是否在目标格下边一定范围

  73. 

  74.     bool isInsideofcellx(IStudentAPI& api, int32_t cellx) {

  75.         if (!isUpoutofcell(api, cellx, -1) && !isDownoutofcell(api, cellx, -1)) return true;

  76.         else return false;

  77.     }

  78.     //判断人是否整个在某行内

  79. 

  80.     bool isInsideofcelly(IStudentAPI& api, int32_t celly) {

  81.         if (!isLeftoutofcell(api, -1, celly) && !isRightoutofcell(api, -1, celly)) return true;

  82.         else return false;

  83.     }

  84.     //判断人是否整个在某列内

  85.     bool isInsideofcell(IStudentAPI& api, int32_t cellx, int32_t celly) {

  86.         if (isInsideofcellx(api, cellx) && isInsideofcelly(api, celly)) return true;

  87.         else return false;

  88.     }

  89.     //判断人是否整个在某格子内

  90.     void moveinto(IStudentAPI& api, int32_t cellx, int32_t celly) {

  91.         if (!isInsideofcell(api, cellx, celly)) {

  92.             if (isLeftoutofcell(api, cellx, celly)) api.MoveRight(30);

  93.             else if (isRightoutofcell(api, cellx, celly)) api.MoveLeft(30);

  94.             if (isUpoutofcell(api, cellx, celly)) api.MoveDown(30);

  95.             else if (isDownoutofcell(api, cellx, celly)) api.MoveUp(30);

  96.         }

  97.     }

  98.     //使人的碰撞箱进入一整格内，避免卡死等问题:只用于人在该格子附近的微调!

  99. 

  100.     bool ArriveAt(IStudentAPI& api, int32_t desX, int32_t desY)

  101.     {

  102.         auto self = api.GetSelfInfo();

  103.         int32_t sx = self->x;

  104.         int32_t sy = self->y;

  105.         if (std::abs(sx - 1000 * desX - 500) + std::abs(sy - 1000 * desY - 500) < 800) return true;

  106.         return false;

  107.     }

  108.     //Astar算法

  109.     class Compare

  110.     {

  111.     public:

  112.         Compare() {};

  113.         bool operator()(const Node& node1, const Node& node2) const

  114.         {

  115.             return node1.Fcost > node2.Fcost;

  116.         }

  117.     }compare_by_cost;

  118. 

  119.     std::vector<std::pair<int32_t, int32_t>>Astar(IStudentAPI& api, int destX, int destY, Node Nodemap[50][50])

  120.     {

  121.         Node nodemap[50][50];

  122.         for (int i = 0; i < 50; i++)

  123.         {

  124.             for (int j = 0; j < 50; j++)

  125.             {

  126.                 nodemap[i][j] = Nodemap[i][j];

  127.             }

  128.         }

  129.         api.Print("Astar被调用");

  130.         std::priority_queue<Node, std::vector<Node>, Compare> openList;

  131.         auto self = api.GetSelfInfo();

  132.         if (self->x / 1000 == destX && self->y / 1000 == destY)

  133.         {

  134.             std::vector<std::pair<int, int>> path{ std::pair<int, int>(destX,destY) };

  135.             return path;//返回自身坐标是已经到了

  136.         }

  137.         auto& startNode = nodemap[self->x / 1000][self->y / 1000];

  138.         startNode.Gcost = 0;

  139.         startNode.Hcost = GetManhattanDistance(self->x / 1000, self->y / 1000, destX, destY);

  140.         startNode.Fcost = GetManhattanDistance(self->x / 1000, self->y / 1000, destX, destY);

  141.         startNode.flag = 1;

  142.         startNode.Parent = nullptr;

  143.         auto& endNode = nodemap[destX][destY];

  144.         endNode.Gcost = 0; endNode.Hcost = 0, endNode.Fcost = 0; endNode.flag = 0; endNode.Parent = nullptr;

  145.         openList.push(startNode);

  146.         Node* currentNode = &startNode;

  147.         while (!openList.empty() && !(currentNode->x == destX && currentNode->y == destY))

  148.         {

  149.             currentNode->flag = 2;

  150.             openList.pop();

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

  152.             {

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

  154.                 {

  155.                     if (!(i * j) && !(i == 0 && j == 0))

  156.                     {

  157.                         if (isInMap(currentNode->x + i, currentNode->y + j))

  158.                         {

  159.                             Node* logicNode = &nodemap[currentNode->x + i][currentNode->y + j];

  160.                             if (logicNode->x == destX && logicNode->y == destY)

  161.                             {

  162.                                 logicNode->flag = 2;

  163.                                 logicNode->Parent = currentNode;

  164.                                 currentNode = logicNode;

  165.                                 goto here;

  166.                             }

  167.                             else if (!isWall((*logicNode).x, (*logicNode).y) && logicNode->flag == 0)

  168.                             {

  169.                                 logicNode->Gcost = currentNode->Gcost + 1;

  170.                                 logicNode->flag = 1;

  171.                                 logicNode->Parent = currentNode;

  172.                                 logicNode->Hcost = GetManhattanDistance(logicNode->x, logicNode->y, destX, destY);

  173.                                 logicNode->Fcost = logicNode->Gcost + logicNode->Hcost;

  174.                                 openList.push(*logicNode);

  175.                             }

  176.                         }

  177.                         else

  178.                         {

  179.                             continue;

  180.                         }

  181.                     }

  182.                 }

  183.             }

  184.             if (!openList.empty())

  185.             {

  186.                 currentNode = &nodemap[openList.top().x][openList.top().y];

  187.             }

  188.         }

  189.     here:

  190.         if (currentNode->x == self->x / 1000 && currentNode->y == self->y / 1000)

  191.         {

  192.             std::vector<std::pair<int, int>> path;

  193.             api.Print("到不了，返回空路径");

  194.             return path;//返回空路径

  195.         }

  196.         auto path = GetPath(currentNode);

  197.         api.Print(fmt::format("Astar返回值：path.size()={}", path.size()));

  198.         return path;

  199.     }

  200. 

  201.     int32_t GetManhattanDistance(int32_t x1, int32_t y1, int32_t x2, int32_t y2)

  202.     {

  203.         return abs(x1 - x2) + abs(y1 - y2);

  204.     }

  205.     std::vector<std::pair<int, int>> GetPath(Node* endNode)

  206.     {

  207.         std::unique_ptr<std::vector<std::pair<int, int>>> path(new std::vector<std::pair<int, int>>);

  208.         Node* node = endNode;

  209.         while (node->Parent)

  210.         {

  211.             path->emplace_back(node->x, node->y);

  212.             node = node->Parent;

  213.         }

  214.         path->emplace_back(node->x, node->y); // 添加起点

  215.         std::reverse(path->begin(), path->end()); // 路径反转

  216.         return *path;

  217.     }

  218.     bool isWall(int x, int y)

  219.     {

  220.         return Map.at(x).at(y) == THUAI6::PlaceType::Wall||Map.at(x).at(y)==THUAI6::PlaceType::ClassRoom;

  221.     }

  222.     bool isInMap(int x, int y)

  223.     {

  224.         return 0 <= x && x < 50 && 0 <= y && y < 50;

  225.     }

  226.     /*bool MoveToCertainPlace();*/

  227.     bool ToNear(IStudentAPI& api, std::vector<std::pair<int32_t, int32_t>>set)

  228.     {

  229.         if (set.empty())return false;//空集或者去不了

  230.         int size = set.size();

  231.         int flag = -1;

  232.         int path_len = 50 * 50;

  233.         for (int i = 0; i < size; i++)

  234.         {

  235.             auto cur_path = Astar(api, set[i].first, set[i].second, NodeMap);

  236.             if (cur_path.empty())continue;

  237.             if (cur_path.size() < path_len)

  238.             {

  239.                 flag = i;

  240.             }

  241.         }

  242.         if (flag == -1)

  243.         {

  244.             return false;

  245.         }

  246.         else

  247.         {

  248.             auto path = Astar(api, set[flag].first, set[flag].second, NodeMap);

  249.             if (path.size() > 1)

  250.             {

  251.                 moveinto(api, path[1].first, path[1].second);

  252.                 api.Print("path>1");

  253.                 return true;

  254.             }

  255.             else

  256.             {

  257.                 moveinto(api, path[0].first, path[0].second);

  258.                 api.Print("path=1");

  259.                 return true;

  260.             }

  261.         }

  262.     }

  263. }myf;

  264. void delete_classroomposition(int i)

  265. {

  266.     ClassroomPosition.erase(ClassroomPosition.begin() + i);

  267. }

  268. //Gao:一个搜索的代码（可扩充）:04-24

  269. std::array<int, 2> find(IStudentAPI& api, THUAI6::PlaceType type)

  270. {

  271.     //Gao:获取位置与视野:04-24

  272.     int cellx, celly;

  273.     cellx = (api.GetSelfInfo()->x) / 1000; celly = (api.GetSelfInfo()->y) / 1000;

  274.     //Gao:从人物所在的格子向外搜索:04-24

  275.     array<int, 2> start = { cellx,celly };

  276.     queue<array<int, 2>> q;

  277.     bool** visited = new bool* [50];

  278.     for (int i = 0; i < 50; i++)

  279.     {

  280.         visited[i] = new bool[50];

  281.     }

  282.     for (int i = 0; i < 50; i++)

  283.     {

  284.         for (int j = 0; j < 50; j++)

  285.         {

  286.             visited[i][j] = { false };

  287.         }

  288.     }

  289.     int direction[4][2] = { {0,1},{0,-1},{1,0},{-1,0} };

  290.     q.push(start);

  291.     visited[cellx][celly] = true;

  292.     while (!q.empty())

  293.     {

  294.         array<int, 2> p = q.front();

  295.         q.pop();

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

  297.             int nx = p[0] + direction[i][0];

  298.             int ny = p[1] + direction[i][1];

  299.             array<int, 2> current = { nx, ny };

  300.             if (nx >= 0 && nx < 50 && ny >= 0 && ny < 50 && visited[nx][ny] == false)

  301.             {

  302.                 if (api.GetPlaceType(nx, ny) == type)

  303.                 {

  304.                     switch (type)

  305.                     {

  306.                     case THUAI6::PlaceType::NullPlaceType:

  307.                         break;

  308.                     case THUAI6::PlaceType::Land:

  309.                         break;

  310.                     case THUAI6::PlaceType::Wall:

  311.                         break;

  312.                     case THUAI6::PlaceType::Grass:

  313.                         break;

  314.                     case THUAI6::PlaceType::ClassRoom:

  315.                     {

  316.                         int j = 0;

  317.                         for (j = 0; j < (int)ClassroomPosition.size(); j++)

  318.                         {

  319.                             if (ClassroomPosition[j].first == nx && ClassroomPosition[j].second == ny)

  320.                             {

  321.                                 break;

  322.                             }

  323.                         }

  324.                         if ((api.GetClassroomProgress(nx, ny) < 10000000|| api.GetClassroomProgress(nx, ny)==-1) && j != (int)ClassroomPosition.size()) { return current; }

  325.                     }

  326.                     break;

  327.                     case THUAI6::PlaceType::Gate:

  328.                         break;

  329.                     case THUAI6::PlaceType::HiddenGate:

  330.                         break;

  331.                     case THUAI6::PlaceType::Window:

  332.                     {

  333.                         return current;

  334.                     }

  335.                         break;

  336.                     case THUAI6::PlaceType::Door3:

  337.                         break;

  338.                     case THUAI6::PlaceType::Door5:

  339.                         break;

  340.                     case THUAI6::PlaceType::Door6:

  341.                         break;

  342.                     case THUAI6::PlaceType::Chest:

  343.                         break;

  344.                     default:

  345.                         break;

  346.                     }

  347.                 }

  348.                 q.push(current);

  349.                 visited[nx][ny] = true;

  350.             }

  351.         }

  352.     }

  353.     for (int i = 0; i < 50; i++) {

  354.         delete[] visited[i];

  355.     }

  356.     delete[] visited;

  357.     return array<int, 2>{-1, -1};

  358. }

  359. 

  360. std::vector<std::vector<int>> getMessages(IStudentAPI & api)

  361. {

  362.     vector<vector<int>>messages;

  363.     while (api.HaveMessage())

  364.     {

  365.         auto a = api.GetMessage();

  366.         int x = ((int)a.second[1]-48) * 10 + (int)a.second[2]-48;

  367.         int y = ((int)a.second[3]-48) * 10 + (int)a.second[4]-48;

  368.         messages.push_back({ (int)a.first,(int)a.second[0] - 48,x,y });

  369.         //1 代表一台机子修好；2 代表7台机子修好；3 代表门开好；4代表可以毕业

  370.     }

  371.     return messages;

  372. }

  373. void sendMessage(IStudentAPI& api,int a, int b, int x, int y)

  374. {

  375.     string str1 = fmt::format("{:d}{:02}{:02}", b, x, y);

  376.     api.SendMessage(a,str1);

  377. }

  378. 

  379. std::array<int, 2> hw0 = { 0,0 };

  380. std::array<int, 2> hw1 = { 0,0 };

  381. std::array<int, 2> hw2 = { 0,0 };

  382. std::array<int, 2> hw3 = { 0,0 };

  383. std::array<int, 2> lo0 = { 0,0 };

  384. std::array<int, 2> lo1 = { 0,0 };

  385. std::array<int, 2> lo2 = { 0,0 };

  386. std::array<int, 2> lo3 = { 0,0 };

  387. 

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

  389. {

  390.     if (!ifchecked)

  391.     {

  392.         api.Print("check map!");

  393.         Map.resize(50 * 50);

  394.         Map = api.GetFullMap();

  395.         for (int i = 0; i < 50; i++)

  396.         {

  397.             for (int j = 0; j < 50; j++)

  398.             {

  399.                 switch (api.GetPlaceType(i,j))

  400.                 {

  401.                 case(THUAI6::PlaceType::NullPlaceType):;

  402.                 case(THUAI6::PlaceType::Land):;

  403.                 case(THUAI6::PlaceType::Grass):NodeMap[i][j] = { i,j,0,0,0,0,nullptr };; break;

  404.                 case(THUAI6::PlaceType::Chest):Chest.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  405.                 case(THUAI6::PlaceType::Door3):Door3Position.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  406.                 case(THUAI6::PlaceType::Door5):Door5Position.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  407.                 case(THUAI6::PlaceType::Door6):Door6Position.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  408.                 case(THUAI6::PlaceType::Gate):Gate.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  409.                 case(THUAI6::PlaceType::ClassRoom):ClassroomPosition.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  410.                 }

  411.             }

  412.         }//弄个大地图

  413.         ifchecked = true;

  414.     }

  415.     if (this->playerID == 0)

  416.     {

  417.         // 玩家0执行操作

  418.         bool gra = false;

  419.         if (api.GetSelfInfo()->x == lo0[0] && api.GetSelfInfo()->y == lo0[1])

  420.         {

  421.             myf.moveinto(api, (api.GetSelfInfo()->x) / 1000, (api.GetSelfInfo()->y) / 1000);

  422.         }

  423.         lo0 = { api.GetSelfInfo()->x ,api.GetSelfInfo()->y };

  424.         if (api.HaveMessage())

  425.         {

  426.             vector<vector<int>> mes;

  427.             mes = getMessages(api);

  428.             for (int i = 0; i<(int)mes.size(); ++i)

  429.             {

  430.                 switch (mes[i][1])

  431.                 {

  432.                 case 1: 

  433.                 {

  434.                     for (int j = 0; j < (int)ClassroomPosition.size();++j)

  435.                     {

  436.                         if (ClassroomPosition[j].first == mes[i][2] && ClassroomPosition[j].second == mes[i][3])ClassroomPosition.erase(ClassroomPosition.begin() + j);

  437.                     }

  438.                 }

  439.                 break;

  440.                 case 2: break;

  441.                 case 3: break;

  442.                 case 4: gra = true; break;

  443.                 default:break;

  444.                 }

  445.             }

  446.         }

  447.         if (!gra)

  448.         {

  449.             if (hw0 == find(api, THUAI6::PlaceType::ClassRoom )|| api.GetClassroomProgress(hw0[0], hw0[1]) == 10000000 || (hw0[0] == 0 && hw0[1] == 0))

  450.             {

  451.                 hw0 = find(api, THUAI6::PlaceType::ClassRoom);

  452.             }

  453.             if ((int)myf.Astar(api, hw0[0], hw0[1], NodeMap).size() != 0) {

  454.                 auto hw20 = myf.Astar(api, hw0[0], hw0[1], NodeMap);

  455.                 myf.moveinto(api, hw20[1].first, hw20[1].second);

  456.                 if (abs((api.GetSelfInfo()->x) / 1000 - hw0[0]) <= 1 && abs((api.GetSelfInfo()->y) / 1000 - hw0[1]) <= 1)

  457.                 {

  458.                     api.UseSkill(0);

  459.                     api.StartLearning();

  460.                     sendMessage(api, 1, 1, hw0[0], hw0[1]);

  461.                 }

  462.             }

  463.         }

  464.         else

  465.         {

  466.             if ((int)myf.Astar(api, Gate[1].first, Gate[1].second, NodeMap).size() != 0) {

  467.                 auto gate = myf.Astar(api, Gate[1].first, Gate[1].second, NodeMap);

  468.                 myf.moveinto(api, gate[1].first, gate[1].second);

  469.                 if (abs((api.GetSelfInfo()->x) / 1000 - Gate[1].first) <= 1 && abs((api.GetSelfInfo()->y) / 1000 - Gate[1].second) <= 1) api.Graduate();

  470.             }

  471.         }

  472.     }

  473.     else if (this->playerID == 1)

  474.     {

  475.         // 玩家1执行操作

  476.         auto trickers = api.GetTrickers();

  477.         if (api.GetGameInfo()->studentGraduated==3)

  478.         {

  479.             if ((int)myf.Astar(api, Gate[1].first, Gate[1].second, NodeMap).size() != 0) {

  480.                 auto gate = myf.Astar(api, Gate[1].first, Gate[1].second, NodeMap);

  481.                 myf.moveinto(api, gate[1].first, gate[1].second);

  482.                 if (abs((api.GetSelfInfo()->x) / 1000 - Gate[1].first) <= 1 && abs((api.GetSelfInfo()->y) / 1000 - Gate[1].second) <= 1) api.Graduate();

  483.             }

  484.         }

  485.         if (trickers.size() != 0)

  486.         {

  487.             api.EndAllAction();

  488.             if ((int)myf.Astar(api, trickers[0]->x / 1000, trickers[0]->y / 1000, NodeMap).size() != 0) {

  489.                 auto follow_Trickers = myf.Astar(api, trickers[0]->x / 1000, trickers[0]->y / 1000, NodeMap);

  490.                 myf.ToNear(api, follow_Trickers);

  491.                 api.UseSkill(0);

  492.             }

  493.         }

  494.         else

  495.         {

  496.             if ((hw1 == find(api, THUAI6::PlaceType::ClassRoom) || api.GetClassroomProgress(hw1[0], hw1[1]) == 10000000) || (hw1[0] == 0 && hw1[1] == 0))

  497.             {

  498.                 hw1 = find(api, THUAI6::PlaceType::ClassRoom);

  499.             }

  500.             if ((int)api.GetStudents().size() != 0 && abs(api.GetStudents()[0]->x - api.GetSelfInfo()->x) <= 1 && abs(api.GetStudents()[0]->y - api.GetSelfInfo()->y) <= 1)

  501.             {

  502.                 api.MoveLeft(100);

  503.                 api.MoveUp(100);

  504.                 api.MoveDown(100);

  505.                 api.MoveRight(100);

  506.             }

  507.             if ((int)myf.Astar(api, hw1[0], hw1[1], NodeMap).size() != 0) {

  508.                 auto hw21 = myf.Astar(api, hw1[0], hw1[1], NodeMap);

  509.                 myf.moveinto(api, hw21[1].first, hw21[1].second);

  510.             }

  511.         }

  512.         if (api.HaveMessage())

  513.         {

  514.             vector<vector<int>> mes;

  515.             mes = getMessages(api);

  516.             for (int i = 0;i< (int)mes.size(); ++i)

  517.             {

  518.                 switch (mes[i][1])

  519.                 {

  520.                 case 1:

  521.                 {

  522.                     for (int j = 0; j < (int)ClassroomPosition.size(); ++j)

  523.                     {

  524.                         if (ClassroomPosition[j].first == mes[i][2] && ClassroomPosition[j].second == mes[i][3])ClassroomPosition.erase(ClassroomPosition.begin() + j);

  525.                     }

  526.                     sendMessage(api, 0, 1, mes[i][2], mes[i][3]);

  527.                     sendMessage(api, 2, 1, mes[i][2], mes[i][3]);

  528.                     sendMessage(api, 3, 1, mes[i][2], mes[i][3]);

  529.                 }

  530.                 break;

  531.                 case 2:break;

  532.                 case 3:sendMessage(api,0,4,0,0); break;

  533.                 case 4:break;

  534.                 default:break;

  535.                 }

  536.             }

  537.         }

  538.         if ((int)ClassroomPosition.size()<=3)

  539.         {

  540.             sendMessage(api, 2, 2, 0, 0);

  541.             sendMessage(api, 3, 2, 0, 0);

  542.         }

  543.     }

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

  545.     {

  546.         // 玩家2执行操作

  547.         bool opendoorRequest2 = false;

  548.         if (api.GetSelfInfo()->x == lo2[0] && api.GetSelfInfo()->y == lo2[1])

  549.         {

  550.             myf.moveinto(api, (api.GetSelfInfo()->x) / 1000, (api.GetSelfInfo()->y) / 1000);

  551.         }

  552.         lo2 = { api.GetSelfInfo()->x ,api.GetSelfInfo()->y };

  553.         if (api.HaveMessage())

  554.         {

  555.             vector<vector<int>> mes;

  556.             mes = getMessages(api);

  557.             for (int i = 0; i<(int)mes.size(); ++i)

  558.             {

  559.                 switch (mes[i][1])

  560.                 {

  561.                 case 1: 

  562.                 {

  563.                     for (int j = 0; j < (int)ClassroomPosition.size(); ++j)

  564.                     {

  565.                         if (ClassroomPosition[j].first == mes[i][2] && ClassroomPosition[j].second == mes[i][3])ClassroomPosition.erase(ClassroomPosition.begin() + j);

  566.                     }

  567.                 }

  568.                 break;

  569.                 case 2: opendoorRequest2 = true; break;

  570.                 case 3: break;

  571.                 case 4: break;

  572.                 default:break;

  573.                 }

  574.             }

  575.         }

  576.         if (opendoorRequest2&&(api.GetClassroomProgress(hw2[0], hw2[1]) == 10000000 || api.GetClassroomProgress(hw2[0], hw2[1]) == -1))

  577.         {

  578.             if ((int)myf.Astar(api, Gate[0].first, Gate[0].second, NodeMap).size() != 0) {

  579.                 auto gate22 = myf.Astar(api, Gate[0].first, Gate[0].second, NodeMap);

  580.                 myf.moveinto(api, gate22[1].first, gate22[1].second);

  581.                 if (abs((api.GetSelfInfo()->x) / 1000 - Gate[0].first) <= 1 && abs((api.GetSelfInfo()->y) / 1000 - Gate[0].second) <= 1)

  582.                 {

  583.                     api.StartOpenGate();

  584.                 }

  585.                 if (api.GetGateProgress(Gate[0].first, Gate[0].second) == 18000)

  586.                 {

  587.                     sendMessage(api, 1, 3, Gate[0].first, Gate[0].second);

  588.                     api.Graduate();

  589.                 }

  590.             }

  591.         }

  592.         else

  593.         {

  594.             if ((hw2 == find(api, THUAI6::PlaceType::ClassRoom) || api.GetClassroomProgress(hw2[0], hw2[1]) == 10000000) || (hw2[0] == 0 && hw2[1] == 0))

  595.             {

  596.                 hw2 = find(api, THUAI6::PlaceType::ClassRoom);

  597.             }

  598.             if (api.GetStudents().size() != 0 && abs(api.GetStudents()[0]->x - api.GetSelfInfo()->x) <= 1 && abs(api.GetStudents()[0]->y - api.GetSelfInfo()->y) <= 1)

  599.             {

  600.                 api.MoveLeft(100);

  601.                 api.MoveDown(100);

  602.                 api.MoveUp(100);

  603.                 api.MoveRight(100);

  604. 

  605.             }

  606.             if ((int)myf.Astar(api, hw2[0], hw2[1], NodeMap).size() != 0) {

  607.                 auto hw22 = myf.Astar(api, hw2[0], hw2[1], NodeMap);

  608.                 myf.moveinto(api, hw22[1].first, hw22[1].second);

  609.                 if (abs((api.GetSelfInfo()->x) / 1000 - hw2[0]) <= 1 && abs((api.GetSelfInfo()->y) / 1000 - hw2[1]) <= 1)

  610.                 {

  611.                     api.UseSkill(0);

  612.                     api.StartLearning();

  613.                     sendMessage(api, 1, 1, hw2[0], hw2[1]);

  614.                 }

  615.             }

  616.         }

  617.     }

  618.     else if (this->playerID == 3)

  619.     {

  620.         // 玩家3执行操作

  621.         bool opendoorRequest3 = false;

  622.         if (api.GetSelfInfo()->x == lo3[0] && api.GetSelfInfo()->y == lo3[1])

  623.         {

  624.             myf.moveinto(api, (api.GetSelfInfo()->x) / 1000, (api.GetSelfInfo()->y) / 1000);

  625.             lo3 = { api.GetSelfInfo()->x ,api.GetSelfInfo()->y };

  626.         }

  627.         lo3 = { api.GetSelfInfo()->x ,api.GetSelfInfo()->y };

  628.         api.UseSkill(2);

  629.         if (api.HaveMessage())

  630.         {

  631.             vector<vector<int>> mes;

  632.             mes = getMessages(api);

  633.             for (int i = 0; i<(int)mes.size(); ++i)

  634.             {

  635.                 switch (mes[i][1])

  636.                 {

  637.                 case 1:

  638.                 {

  639.                     for (int j = 0; j < (int)ClassroomPosition.size(); ++j)

  640.                     {

  641.                         if (ClassroomPosition[j].first == mes[i][2] && ClassroomPosition[j].second == mes[i][3])ClassroomPosition.erase(ClassroomPosition.begin() + j);

  642.                     }

  643.                 }

  644.                 break;

  645.                 case 2: opendoorRequest3 = true; break;

  646.                 case 3: break;

  647.                 case 4: break;

  648.                 default:break;

  649.                 }

  650.             }

  651.         }

  652.         if (opendoorRequest3&& (api.GetClassroomProgress(hw3[0], hw3[1]) == 10000000|| api.GetClassroomProgress(hw3[0], hw3[1]) == -1))

  653.         {

  654.             if ((int)myf.Astar(api, Gate[1].first, Gate[1].second, NodeMap).size() != 0) {

  655.                 auto gate23 = myf.Astar(api, Gate[1].first, Gate[1].second, NodeMap);

  656.                 myf.moveinto(api, gate23[1].first, gate23[1].second);

  657. 

  658.                 if (abs((api.GetSelfInfo()->x) / 1000 - Gate[1].first) <= 1 && abs((api.GetSelfInfo()->y) / 1000 - Gate[1].second) <= 1)

  659.                 {

  660.                     api.StartOpenGate();

  661.                 }

  662.                 if (api.GetGateProgress(Gate[1].first, Gate[1].second) == 18000)

  663.                 {

  664.                     sendMessage(api, 1, 3, Gate[1].first, Gate[1].second);

  665.                     api.Graduate();

  666.                 }

  667.             }

  668.         }

  669.         else

  670.         {

  671.             if ((hw3 == find(api, THUAI6::PlaceType::ClassRoom) || api.GetClassroomProgress(hw3[0], hw3[1]) == 10000000) || (hw3[0] == 0 && hw3[1] == 0))

  672.             {

  673.                 hw3 = find(api, THUAI6::PlaceType::ClassRoom);

  674.             }

  675.             if (abs(api.GetStudents()[0]->x - api.GetSelfInfo()->x) <= 1 && abs(api.GetStudents()[0]->y - api.GetSelfInfo()->y)<=1)

  676.             {

  677.                 api.MoveLeft(200);

  678.                 api.MoveUp(200);

  679.                 api.MoveRight(200);

  680.                 api.MoveDown(200);

  681.             }

  682.             if ((int)myf.Astar(api, hw3[0], hw3[1], NodeMap).size() != 0) {

  683.                 auto hw23 = myf.Astar(api, hw3[0], hw3[1], NodeMap);

  684.                 myf.moveinto(api, hw23[1].first, hw23[1].second);

  685.                 if (abs((api.GetSelfInfo()->x) / 1000 - hw3[0]) <= 1 && abs((api.GetSelfInfo()->y) / 1000 - hw3[1]) <= 1)

  686.                 {

  687.                     api.StartLearning();

  688.                     sendMessage(api, 1, 1, hw3[0], hw3[1]);

  689.                 }

  690.             }

  691.         }

  692.     }

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

  694.     //  公共操作

  695.     for (int i = 0; i < (int)ClassroomPosition.size(); ++i)

  696.     {

  697.         if (ClassroomPosition.size()!=0 && api.GetClassroomProgress(ClassroomPosition[i].first, ClassroomPosition[i].second) == 10000000)

  698.         {

  699.             delete_classroomposition(i);

  700.         }

  701.     }

  702. }

  703. 

  704. class MyTrickerFunction

  705. {

  706. public:

  707. 

  708.     //移动函数

  709.     bool t_isLeftoutofcell(ITrickerAPI& api, int32_t cellx, int32_t celly) {

  710.         if (api.GetSelfInfo()->y - 400 < celly * 1000) return true;

  711.         else return false;

  712.     }//判断是否在目标格左边一定范围

  713. 

  714.     bool t_isRightoutofcell(ITrickerAPI& api, int32_t cellx, int32_t celly) {

  715.         if (api.GetSelfInfo()->y + 400 > (celly + 1) * 1000) return true;

  716.         else return false;

  717.     }//判断是否在目标格右边一定范围

  718. 

  719.     bool t_isUpoutofcell(ITrickerAPI& api, int32_t cellx, int32_t celly) {

  720.         if (api.GetSelfInfo()->x - 400 < cellx * 1000) return true;

  721.         else return false;

  722.     }//判断是否在目标格上边一定范围

  723. 

  724.     bool t_isDownoutofcell(ITrickerAPI& api, int32_t cellx, int32_t celly) {

  725.         if (api.GetSelfInfo()->x + 400 > (cellx + 1) * 1000) return true;

  726.         else return false;

  727.     }//判断是否在目标格下边一定范围

  728. 

  729.     bool t_isInsideofcellx(ITrickerAPI& api, int32_t cellx) {

  730.         if (!t_isUpoutofcell(api, cellx, -1) && !t_isDownoutofcell(api, cellx, -1)) return true;

  731.         else return false;

  732.     }

  733.     //判断人是否整个在某行内

  734. 

  735.     bool t_isInsideofcelly(ITrickerAPI& api, int32_t celly) {

  736.         if (!t_isLeftoutofcell(api, -1, celly) && !t_isRightoutofcell(api, -1, celly)) return true;

  737.         else return false;

  738.     }

  739.     //判断人是否整个在某列内

  740.     bool t_isInsideofcell(ITrickerAPI& api, int32_t cellx, int32_t celly) {

  741.         if (t_isInsideofcellx(api, cellx) && t_isInsideofcelly(api, celly)) return true;

  742.         else return false;

  743.     }

  744.     //判断人是否整个在某格子内

  745.     void t_moveinto(ITrickerAPI& api, int32_t cellx, int32_t celly) {

  746.         if (!t_isInsideofcell(api, cellx, celly)) {

  747.             if (t_isLeftoutofcell(api, cellx, celly)) api.MoveRight(30);

  748.             else if (t_isRightoutofcell(api, cellx, celly)) api.MoveLeft(30);

  749.             if (t_isUpoutofcell(api, cellx, celly)) api.MoveDown(30);

  750.             else if (t_isDownoutofcell(api, cellx, celly)) api.MoveUp(30);

  751.         }

  752.     }

  753.     //使人的碰撞箱进入一整格内，避免卡死等问题:只用于人在该格子附近的微调!

  754. 

  755.     bool t_ArriveAt(ITrickerAPI& api, int32_t desX, int32_t desY)

  756.     {

  757.         auto self = api.GetSelfInfo();

  758.         int32_t sx = self->x;

  759.         int32_t sy = self->y;

  760.         if (std::abs(sx - 1000 * desX - 500) + std::abs(sy - 1000 * desY - 500) < 800) return true;

  761.         return false;

  762.     }

  763.     //Astar算法

  764.     class t_Compare

  765.     {

  766.     public:

  767.         t_Compare() {};

  768.         bool operator()(const Node& node1, const Node& node2) const

  769.         {

  770.             return node1.Fcost > node2.Fcost;

  771.         }

  772.     }compare_by_cost;

  773. 

  774.     std::vector<std::pair<int32_t, int32_t>>t_Astar(ITrickerAPI& api, int destX, int destY, Node Nodemap[50][50])

  775.     {

  776.         Node nodemap[50][50];

  777.         for (int i = 0; i < 50; i++)

  778.         {

  779.             for (int j = 0; j < 50; j++)

  780.             {

  781.                 nodemap[i][j] = Nodemap[i][j];

  782.             }

  783.         }

  784.         api.Print("t_Astar被调用");

  785.         std::priority_queue<Node, std::vector<Node>, t_Compare> openList;

  786.         auto self = api.GetSelfInfo();

  787.         if (self->x / 1000 == destX && self->y / 1000 == destY)

  788.         {

  789.             std::vector<std::pair<int, int>> path{ std::pair<int, int>(destX,destY) };

  790.             return path;//返回自身坐标是已经到了

  791.         }

  792.         auto& startNode = nodemap[self->x / 1000][self->y / 1000];

  793.         startNode.Gcost = 0;

  794.         startNode.Hcost = GetManhattanDistance(self->x / 1000, self->y / 1000, destX, destY);

  795.         startNode.Fcost = GetManhattanDistance(self->x / 1000, self->y / 1000, destX, destY);

  796.         startNode.flag = 1;

  797.         startNode.Parent = nullptr;

  798.         auto& endNode = nodemap[destX][destY];

  799.         endNode.Gcost = 0; endNode.Hcost = 0, endNode.Fcost = 0; endNode.flag = 0; endNode.Parent = nullptr;

  800.         openList.push(startNode);

  801.         Node* currentNode = &startNode;

  802.         while (!openList.empty() && !(currentNode->x == destX && currentNode->y == destY))

  803.         {

  804.             currentNode->flag = 2;

  805.             openList.pop();

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

  807.             {

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

  809.                 {

  810.                     if (!(i * j) && !(i == 0 && j == 0))

  811.                     {

  812.                         if (isInMap(currentNode->x + i, currentNode->y + j))

  813.                         {

  814.                             Node* logicNode = &nodemap[currentNode->x + i][currentNode->y + j];

  815.                             if (logicNode->x == destX && logicNode->y == destY)

  816.                             {

  817.                                 logicNode->flag = 2;

  818.                                 logicNode->Parent = currentNode;

  819.                                 currentNode = logicNode;

  820.                                 goto here;

  821.                             }

  822.                             else if (!isWall((*logicNode).x, (*logicNode).y) && logicNode->flag == 0)

  823.                             {

  824.                                 logicNode->Gcost = currentNode->Gcost + 1;

  825.                                 logicNode->flag = 1;

  826.                                 logicNode->Parent = currentNode;

  827.                                 logicNode->Hcost = GetManhattanDistance(logicNode->x, logicNode->y, destX, destY);

  828.                                 logicNode->Fcost = logicNode->Gcost + logicNode->Hcost;

  829.                                 openList.push(*logicNode);

  830.                             }

  831.                         }

  832.                         else

  833.                         {

  834.                             continue;

  835.                         }

  836.                     }

  837.                 }

  838.             }

  839.             if (!openList.empty())

  840.             {

  841.                 currentNode = &nodemap[openList.top().x][openList.top().y];

  842.             }

  843.         }

  844.     here:

  845.         if (currentNode->x == self->x / 1000 && currentNode->y == self->y / 1000)

  846.         {

  847.             std::vector<std::pair<int, int>> path;

  848.             api.Print("到不了，返回空路径");

  849.             return path;//返回空路径

  850.         }

  851.         auto path = GetPath(currentNode);

  852.         api.Print(fmt::format("Astar返回值：path.size()={}", path.size()));

  853.         return path;

  854.     }

  855. 

  856.     int32_t GetManhattanDistance(int32_t x1, int32_t y1, int32_t x2, int32_t y2)

  857.     {

  858.         return abs(x1 - x2) + abs(y1 - y2);

  859.     }

  860.     std::vector<std::pair<int, int>> GetPath(Node* endNode)

  861.     {

  862.         std::unique_ptr<std::vector<std::pair<int, int>>> path(new std::vector<std::pair<int, int>>);

  863.         Node* node = endNode;

  864.         while (node->Parent)

  865.         {

  866.             path->emplace_back(node->x, node->y);

  867.             node = node->Parent;

  868.         }

  869.         path->emplace_back(node->x, node->y); // 添加起点

  870.         std::reverse(path->begin(), path->end()); // 路径反转

  871.         return *path;

  872.     }

  873.     bool isWall(int x, int y)

  874.     {

  875.         return Map.at(x).at(y) == THUAI6::PlaceType::Wall || Map.at(x).at(y) == THUAI6::PlaceType::ClassRoom;

  876.     }

  877.     bool isInMap(int x, int y)

  878.     {

  879.         return 0 <= x && x < 50 && 0 <= y && y < 50;

  880.     }

  881.     /*bool MoveToCertainPlace();*/

  882.     bool t_ToNear(ITrickerAPI& api, std::vector<std::pair<int32_t, int32_t>>set)

  883.     {

  884.         if (set.empty())return false;//空集或者去不了

  885.         int size = set.size();

  886.         int flag = -1;

  887.         int path_len = 50 * 50;

  888.         for (int i = 0; i < size; i++)

  889.         {

  890.             auto cur_path = t_Astar(api, set[i].first, set[i].second, NodeMap);

  891.             if (cur_path.empty())continue;

  892.             if (cur_path.size() < path_len)

  893.             {

  894.                 flag = i;

  895.             }

  896.         }

  897.         if (flag == -1)

  898.         {

  899.             return false;

  900.         }

  901.         else

  902.         {

  903.             auto path = t_Astar(api, set[flag].first, set[flag].second, NodeMap);

  904.             if (path.size() > 1)

  905.             {

  906.                 t_moveinto(api, path[1].first, path[1].second);

  907.                 api.Print("path>1");

  908.                 return true;

  909.             }

  910.             else

  911.             {

  912.                 t_moveinto(api, path[0].first, path[0].second);

  913.                 api.Print("path=1");

  914.                 return true;

  915.             }

  916.         }

  917.     }

  918. }mtf;

  919. 

  920. std::array<int, 2> t_find(ITrickerAPI& api, THUAI6::PlaceType type)

  921. {

  922.     int cellx, celly;

  923.     cellx = (api.GetSelfInfo()->x) / 1000; celly = (api.GetSelfInfo()->y) / 1000;

  924.     array<int, 2> start = { cellx,celly };

  925.     queue<array<int, 2>> q;

  926.     bool** visited = new bool* [50];

  927.     for (int i = 0; i < 50; i++)

  928.     {

  929.         visited[i] = new bool[50];

  930.     }

  931.     for (int i = 0; i < 50; i++)

  932.     {

  933.         for (int j = 0; j < 50; j++)

  934.         {

  935.             visited[i][j] = { false };

  936.         }

  937.     }

  938.     int direction[4][2] = { {0,1},{0,-1},{1,0},{-1,0} };

  939.     q.push(start);

  940.     visited[cellx][celly] = true;

  941.     while (!q.empty())

  942.     {

  943.         array<int, 2> p = q.front();

  944.         q.pop();

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

  946.             int nx = p[0] + direction[i][0];

  947.             int ny = p[1] + direction[i][1];

  948.             array<int, 2> current = { nx, ny };

  949.             if (nx >= 0 && nx < 50 && ny >= 0 && ny < 50 && visited[nx][ny] == false)

  950.             {

  951.                 if (api.GetPlaceType(nx, ny) == type)

  952.                 {

  953.                     switch (type)

  954.                     {

  955.                     case THUAI6::PlaceType::NullPlaceType:

  956.                         break;

  957.                     case THUAI6::PlaceType::Land:

  958.                         break;

  959.                     case THUAI6::PlaceType::Wall:

  960.                         break;

  961.                     case THUAI6::PlaceType::Grass:

  962.                         break;

  963.                     case THUAI6::PlaceType::ClassRoom:

  964.                     {

  965.                         int j = 0;

  966.                         for (j = 0; j < (int)ClassroomPosition.size(); j++)

  967.                         {

  968.                             if (ClassroomPosition[j].first == nx && ClassroomPosition[j].second == ny)

  969.                             {

  970.                                 break;

  971.                             }

  972.                         }

  973.                         if ((api.GetClassroomProgress(nx, ny) < 10000000 || api.GetClassroomProgress(nx, ny) == -1) && j != (int)ClassroomPosition.size()) { return current; }

  974.                     }

  975.                     break;

  976.                     case THUAI6::PlaceType::Gate:

  977.                         break;

  978.                     case THUAI6::PlaceType::HiddenGate:

  979.                         break;

  980.                     case THUAI6::PlaceType::Window:

  981.                         break;

  982.                     case THUAI6::PlaceType::Door3:

  983.                         break;

  984.                     case THUAI6::PlaceType::Door5:

  985.                         break;

  986.                     case THUAI6::PlaceType::Door6:

  987.                         break;

  988.                     case THUAI6::PlaceType::Chest:

  989.                         break;

  990.                     default:

  991.                         break;

  992.                     }

  993.                 }

  994.                 q.push(current);

  995.                 visited[nx][ny] = true;

  996.             }

  997.         }

  998.     }

  999.     for (int i = 0; i < 50; i++) {

  1000.         delete[] visited[i];

  1001.     }

  1002.     delete[] visited;

  1003.     return array<int, 2>{-1, -1};

  1004. }

  1005. std::array<int, 2> t_hw = { 0,0 };

  1006. std::array<int, 2> t_lo = { 0,0 };

  1007. 

  1008. 

  1009. void t_delete_classroomposition(int i)

  1010. {

  1011.     ClassroomPosition.erase(ClassroomPosition.begin() + i);

  1012. }

  1013. void FindWork(ITrickerAPI& api)

  1014. {

  1015.     t_lo = { api.GetSelfInfo()->x ,api.GetSelfInfo()->y };

  1016.     int i = 0;

  1017.     if ((int)ClassroomPosition.size() != 0)

  1018.     {

  1019.         for (i = 0; i < (int)ClassroomPosition.size(); i++)

  1020.         {

  1021.             if (t_hw[0] == ClassroomPosition[i].first && t_hw[1] == ClassroomPosition[i].second)

  1022.             {

  1023.                 break;

  1024.             }

  1025.         }

  1026.         if (t_hw == t_find(api, THUAI6::PlaceType::ClassRoom) || (t_hw[0] == 0 && t_hw[1] == 0) || i == (int)ClassroomPosition.size())

  1027.         {

  1028.             t_hw = t_find(api, THUAI6::PlaceType::ClassRoom);

  1029.         }

  1030.         auto work_road = mtf.t_Astar(api, t_hw[0], t_hw[1], NodeMap);

  1031.         mtf.t_moveinto(api, work_road[1].first, work_road[1].second);

  1032.     }

  1033. }

  1034. void AttackWork(ITrickerAPI& api, int t_x1, int t_y1, int h_x2, int h_y2, double ts, double dist)

  1035. {

  1036.     ts = atan2((h_y2 - t_y1), (h_x2 - t_x1));

  1037.     dist = sqrt(pow(t_x1 - h_x2, 2) + pow(t_y1 - h_y2, 2));

  1038.     if (((t_x1 < h_x2) && (t_y1 < h_y2)) || ((t_x1 < h_x2) && (t_y1 > h_y2)) || ((t_x1 > h_x2) && (t_y1 < h_y2)) || ((t_x1 > h_x2) && (t_y1 > h_y2)))

  1039.     {

  1040.         api.Attack(ts);

  1041.     }

  1042.     else if ((t_x1 == h_x2) && (t_y1 < h_y2))

  1043.     {

  1044.         api.Attack(3 * PI / 2);

  1045.     }

  1046.     else if ((t_x1 < h_x2) && (t_y1 == h_y2))

  1047.     {

  1048.         api.Attack(PI);

  1049.     }

  1050.     else if ((t_x1 > h_x2) && (t_y1 == h_y2))

  1051.     {

  1052.         api.Attack(0);

  1053.     }

  1054.     else if ((t_x1 == h_x2) && (t_y1 > h_y2))

  1055.     {

  1056.         api.Attack(PI / 2);

  1057.     }

  1058. }

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

  1060. {

  1061.     if (!ifchecked)

  1062.     {

  1063.         api.Print("check map!");

  1064.         Map.resize(50 * 50);

  1065.         Map = api.GetFullMap();

  1066.         for (int i = 0; i < 50; i++)

  1067.         {

  1068.             for (int j = 0; j < 50; j++)

  1069.             {

  1070.                 switch (api.GetPlaceType(i, j))

  1071.                 {

  1072.                 case(THUAI6::PlaceType::NullPlaceType):;

  1073.                 case(THUAI6::PlaceType::Land):;

  1074.                 case(THUAI6::PlaceType::Grass):NodeMap[i][j] = { i,j,0,0,0,0,nullptr };; break;

  1075.                 case(THUAI6::PlaceType::Chest):Chest.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  1076.                 case(THUAI6::PlaceType::Door3):Door3Position.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  1077.                 case(THUAI6::PlaceType::Door5):Door5Position.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  1078.                 case(THUAI6::PlaceType::Door6):Door6Position.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  1079.                 case(THUAI6::PlaceType::Gate):Gate.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  1080.                 case(THUAI6::PlaceType::ClassRoom):ClassroomPosition.push_back({ i,j }); NodeMap[i][j] = { i,j,0,0,0,0,nullptr }; break;

  1081.                 }

  1082.             }

  1083.         }//地图

  1084.         ifchecked = true;

  1085.     }

  1086.     if ((int)ClassroomPosition.size() == 0)

  1087.     {

  1088.         ifchecked = false;

  1089.     }

  1090.     else

  1091.     {

  1092.         for (int i = 0; i < (int)ClassroomPosition.size(); ++i)

  1093.         {

  1094.             if (abs(api.GetSelfInfo()->x / 1000 - ClassroomPosition[i].first) <= 2 && abs(api.GetSelfInfo()->y / 1000 - ClassroomPosition[i].second) <= 2)

  1095.             {

  1096.                 t_delete_classroomposition(i);

  1097.             }

  1098.         }

  1099.     }

  1100.     bool if_attack = false;//是否追击

  1101.     FindWork(api);

  1102.     auto students = api.GetStudents();

  1103.     int i;

  1104.     int StraightAStudent_Number = 0;

  1105.     int Sunshine_Number = 0;

  1106.     int Athlete_Number = 0;

  1107.     int addicted_students_number = 0;

  1108.     int k = 0;

  1109.     if ((int)students.size() == 0)

  1110.     {

  1111.         FindWork(api);

  1112.         int t_x = api.GetSelfInfo()->x;

  1113.         int t_y = api.GetSelfInfo()->y;

  1114.         int h_x = t_hw[0];

  1115.         int h_y = t_hw[1];

  1116.         double twangle = atan2((h_y - t_y), (h_x - t_x));

  1117.         double twdistance = sqrt(pow(t_x - h_x, 2) + pow(t_y - h_y, 2));

  1118.         if (twdistance <= 2200 && api.GetClassroomProgress(h_x, h_y) > 0 && api.GetClassroomProgress(h_x, h_y) < 10000000)

  1119.             AttackWork(api, t_x, t_y, h_x, h_y, twangle, twdistance);

  1120.     }

  1121.     else if ((int)students.size() != 0)

  1122.     {

  1123.         for (i = 0; i < (int)students.size(); i++)

  1124.         {

  1125.             switch (students[i]->studentType)

  1126.             {

  1127.             case THUAI6::StudentType::StraightAStudent:

  1128.             {

  1129.                 StraightAStudent_Number++;

  1130.                 break;

  1131.             }

  1132.             case THUAI6::StudentType::Sunshine:

  1133.             {

  1134.                 Sunshine_Number++;

  1135.                 break;

  1136.             }

  1137.             case THUAI6::StudentType::Athlete:

  1138.             {

  1139.                 Athlete_Number++;

  1140.                 break;

  1141.             }

  1142.             }

  1143.         }//优先级：学霸>开心果>体育生>老师

  1144.         if (StraightAStudent_Number != 0)

  1145.         {

  1146.             for (i = 0; i < (int)students.size(); i++)

  1147.             {

  1148.                 if (students[i]->studentType == THUAI6::StudentType::StraightAStudent && students[i]->playerState != THUAI6::PlayerState::Addicted)

  1149.                     break;

  1150.             }

  1151.             if (i != (int)students.size())

  1152.             {

  1153.                 if_attack = true;

  1154.                 auto students_i_road = mtf.t_Astar(api, students[i]->x / 1000, students[i]->y / 1000, NodeMap);

  1155.                 mtf.t_moveinto(api, students_i_road[1].first, students_i_road[1].second);

  1156.             }

  1157.         }

  1158.         else if (StraightAStudent_Number == 0 && Sunshine_Number != 0)

  1159.         {

  1160.             for (i = 0; i < (int)students.size(); i++)

  1161.             {

  1162.                 if (students[i]->studentType == THUAI6::StudentType::Sunshine && students[i]->playerState != THUAI6::PlayerState::Addicted)

  1163.                     break;

  1164.             }

  1165.             if (i != (int)students.size())

  1166.             {

  1167.                 if_attack = true;

  1168.                 auto students_i_road = mtf.t_Astar(api, students[i]->x / 1000, students[i]->y / 1000, NodeMap);

  1169.                 mtf.t_moveinto(api, students_i_road[1].first, students_i_road[1].second);

  1170.             }

  1171.         }

  1172.         else if (StraightAStudent_Number == 0 && Sunshine_Number == 0 && Athlete_Number != 0)

  1173.         {

  1174.             for (i = 0; i < (int)students.size(); i++)

  1175.             {

  1176.                 if (students[i]->studentType == THUAI6::StudentType::Athlete && students[i]->playerState != THUAI6::PlayerState::Addicted)

  1177.                     break;

  1178.             }

  1179.             if (i != (int)students.size())

  1180.             {

  1181.                 if_attack = true;

  1182.                 auto students_i_road = mtf.t_Astar(api, students[i]->x / 1000, students[i]->y / 1000, NodeMap);

  1183.                 mtf.t_moveinto(api, students_i_road[1].first, students_i_road[1].second);

  1184.             }

  1185.         }

  1186.         else if (StraightAStudent_Number == 0 && Sunshine_Number == 0 && Athlete_Number == 0)

  1187.         {

  1188.             if_attack = false;

  1189.         }

  1190.         if (if_attack)

  1191.         {

  1192.             int x1 = api.GetSelfInfo()->x; int y1 = api.GetSelfInfo()->y;

  1193.             auto x2 = students[i]->x;

  1194.             auto y2 = students[i]->y;

  1195.             double s = atan2((y2 - y1), (x2 - x1));

  1196.             double dist = sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));

  1197.             if (dist <= 8000)

  1198.             {

  1199.                 api.UseSkill(0);

  1200. 

  1201.                 if (dist <= 1700)

  1202.                 {

  1203.                     if (((x1 < x2) && (y1 < y2)) || ((x1 < x2) && (y1 > y2)) || ((x1 > x2) && (y1 < y2)) || ((x1 > x2) && (y1 > y2)))

  1204.                         api.Attack(s);

  1205. 

  1206.                     else if ((x1 == x2) && (y1 < y2))

  1207.                     {

  1208.                         api.Attack(3 * PI / 2);

  1209.                     }

  1210.                     else if ((x1 < x2) && (y1 == y2))

  1211.                     {

  1212.                         api.Attack(PI);

  1213.                     }

  1214.                     else if ((x1 > x2) && (y1 == y2))

  1215.                     {

  1216.                         api.Attack(0);

  1217.                     }

  1218.                     else if ((x1 == x2) && (y1 > y2))

  1219.                     {

  1220.                         api.Attack(PI / 2);

  1221.                     }

  1222.                 }

  1223.             }

  1224.         }

  1225.     }

  1226. }