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: 274065ed49
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '274065ed49'
${ noResults }
THUAI6/players/LQ说什么都队/player2.cpp

3758 lines
140 kB
Raw Blame History 

  1. #include <vector>

  2. #include <thread>

  3. #include <array>

  4. #include "AI.h"

  5. #include "constants.h"

  6. #include <queue>

  7. const double PI=3.1415926;

  8. 

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

  10. extern const bool asynchronous =false;

  11. 

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

  13. 

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

  15.     THUAI6::StudentType::StraightAStudent,

  16.     THUAI6::StudentType::StraightAStudent,

  17.     THUAI6::StudentType::StraightAStudent,

  18.     THUAI6::StudentType::StraightAStudent

  19. };

  20. 

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

  22. bool move = false;

  23. 

  24. /*----------------------本代码简要介绍-------------------------*/

  25. /*

  26.     本代码的主要思路是Student（职业为StraightAStudent）选择一个合适的位置躲起来，等到比赛将要结束时前往作业处进行学习；而Tricker（职业为ANoisyPerson）则是沿着固定的路线前进

  27.     本代码并无任何的高级寻路算法，寻路是通过在每个教室标记一些特殊点（如TB1node数组），定义了在每两个标记点间的最短路径，通过字符串数组来保存（如TB3oath），将整个地图化简；

  28. 代码中的许多函数并不为最终的策略服务，原因是在设计时我们游戏的策略仍然为较普通的找教室学习and看到Tricker就躲避。

  29.     我们注意到这个游戏的双方阵营较为不平衡，再强的学生面对拥有一定实力的Tricker都很容易惨败（输几千分，而且学生活的越久越便于Tricker刷分），但是决赛的规则是计算双方交换阵容

  30. 两次比赛的得分和。于是我们在作为学生阵营时让学生躲起来，以此应对一些不会搜草的队伍，就算不能取胜净胜分也不会很低，而在作为Tricker阵营时利用游戏的较不平衡性获取更高的净胜分，

  31. 从而在比赛中胜出

  32. 

  33. */

  34. 

  35. 

  36. enum class TrickerStatus

  37. {

  38.     Init,

  39.     Tracing,

  40.     Attaking, 

  41.     Searching,

  42.     GotoGate,

  43. };

  44. enum class StudentStatus

  45. {

  46.     WantToStudy,

  47.     Studying,

  48.     Init,

  49.     WantToGraduate,

  50.     Graduating,

  51.     Running,

  52.     GoToWaitingPoint,

  53.     GoToStudy,

  54.     Studying1,

  55. };

  56. struct MapNode

  57. {

  58.     int x, y;

  59.     bool operator != (const MapNode& n)

  60.     {

  61.         if ((this->x != n.x) || (this->y != n.y))

  62.             return 1;

  63.         else return 0;

  64.     }

  65.     bool operator == (const MapNode& n)

  66.     {

  67.         if ((this->x == n.x) && (this->y == n.y))

  68.             return 1;

  69.         else return 0;

  70.     }

  71. };

  72. struct WindowNode

  73. {

  74.     int x_in, y_in, x_out, y_out;

  75. };

  76. struct Classroom

  77. {

  78.     int id;

  79.     long int progress;

  80.     MapNode xy[4];

  81.     MapNode realxy;

  82. };

  83. struct Gate

  84. {

  85.     int progress;

  86.     MapNode xy;

  87.     int Status;//0代表未刷新，1代表已刷新（正常的2个gate都是1）

  88. };

  89. 

  90. static THUAI6::PlaceType map[50][50];//保存地图信息

  91. MapNode path[1000];//保存该玩家到达想去的地方的路径

  92. int pathnum = 0;//记录path的下标

  93. int pathlength = 0;//记录path的长度

  94. 

  95. //保存各个教室的关键节点坐标（待补充）

  96. MapNode TB3node[7] = { {15,6},{23,6},{21,15},{13,16} ,{20,5} ,{24,16},{17,19} };

  97. MapNode TB5node[10] = { { 9,28 }, { 8,36 }, { 8,41 }, { 11,43 }, { 15,37 }, { 16,33 }, { 19,33 },{7,33},{18,39},{17,42} };

  98. MapNode TB6node[11] = { { 39,19 },{ 34,25 },{ 30,25 },{ 28,34 },{ 33,35 },{ 40,27 },{ 46,32 },{43,31},{31,38},{35,42},{27,28} };

  99. MapNode TB1node[29] = { 

  100.     {8,3},{7,10},{11,16},{10,21},{9,24},{14,26},{22,25},{26,22},{29,19},{31,12},

  101.     {37,8},{42,3},{46,12},{46,21},{24,31},{24,38},{28,44},{35,47},{41,42},{45,41},

  102.     {21,43},{21,48},{5,48},{5,42},{2,37},{2,20},{2,10},{11,31},{15,48} };

  103. MapNode TB1node2[16] = {

  104.     {11,11},{1,1},{11,1},{1,11},

  105.     {11,38},{1,48},{1,38},{11,48},

  106.     {38,11},{48,1},{38,1},{48,11},

  107.     {38,38},{48,48},{38,48},{48,38}

  108. };

  109. //各个教室的关键节点个数（待补充）

  110. const int sizeof_TB3node = 7;

  111. const int sizeof_TB5node = 10;

  112. const int sizeof_TB6node = 11;

  113. const int sizeof_TB1node = 29;

  114. const int sizeof_TB1node2 = 16;

  115. 

  116. //各个教室的节点间最短路径（待补充）

  117. const char* TB3path[7][7] = {

  118.     {"0","01","012","03","014","0125","036"},

  119.     {"10","1","12","103","14","15","126"},

  120.     {"210","21","2","23","214","25","26"},

  121.     {"30","301","32","3","3214","325","36"},

  122.     {"410","41","412","4123","4","45","4126"},

  123.     {"510","51","52","523","54","526"},

  124.     {"630","621","60","63","6214","625"}

  125. };

  126. const char* TB5path[10][10] = {

  127.     {"0","01","012","0123","014","0145","01456","017","0148","0149"},

  128.     {"10","1","12","123","14","145","1456","17","148","149"},

  129.     {"210","21","2","23","234","2345","23456","27","238","2349"},

  130.     {"3210","321","32","3","34","345","3456","327","38","349"},

  131.     {"410","41","412","43","4","45","46","417","48","49"},

  132.     {"5410","541","5412","543","54","5","56","5417","568","549"},

  133.     {"65410","6541","65432","6543","654","65","6","65417","68","6549"},

  134.     {"710","71","72","723","714","7145","71456","7","7148","7149"},

  135.     {"8410","841","832","83","84","865","86","8417","8","89"},

  136.     {"9410","941","9432","943","94","945","9456","9417","98","9"}

  137. };

  138. const char* TB6path[11][11] = {

  139.     {"0","01","012","0123","054","05","056","057","0548","0549","0543:"},

  140.     {"10","1","12","123","154","15","156","157","1548","1549","1543:"},

  141.     {"210","21","2","23","234","215","2156","2157","21548","21549","23:"},

  142.     {"3210","321","32","3","34","345","3456","3457","38","349","3:"},

  143.     {"450","451","432","43","4","45","456","457","48","49","43:"},

  144.     {"50","51","512","543","54","5","56","57","548","549","543:"},

  145.     {"650","651","6512","6543","654","65","6","657","6548","6549","6543:"},

  146.     {"7510","751","7512","7543","754","75","756","7","7548","7549","7543:"},

  147.     {"83210","8321","832","83","84","845","8456","8457","8","849","83:"},

  148.     {"9450","9451","94512","943","94","945","9456","9457","948","943:"},

  149.     {":3250",":3451",":32",":3",":34",":345",":3456","3457",":38",":349",":"}

  150. };

  151. const char* TB1path[29][29] = {

  152.     {"0","01","012","0123","01234","01235","012356","0123567","01235678","012356789","012356789:","012356789:;","012356789:;<","012356789:;<=","012356>","012356>?","012356>?@","012356>?@A","012356>?@AB","012356>?@ABC","012356>?D","012356>?DE","01JIHGF","01JIHG","01JIH","01JI","01J","012K","01JIHGFL"},

  153.     {"10","1","12","123","1234","1235","12356","123567","1235678","12356789","12356789:","12356789:;","12356789:;<","12356789:;<=","12356>","12356>?","12356>?@","12356>?@A","12356>?@AB","12356>?@ABC","12356>?D","12356>?DE","1JIHGF","1JIHG","1JIH","1JI","1J","12K","1JIHGFL"},

  154.     {"210","21","2","23","234","235","2356","23567","235678","2356789","2356789:","2356789:;","2356789:;<","2356789:;<=","2356>","2356>?","2356>?@","2356>?@A","2356>?@AB","2356>?@ABC","2356>?D","2356>?DE","23IHGF","23IHG","23IH","23I","21J","2K","23IHGFL"},

  155.     {"3210","321","32","3","34","35","356","3567","35678","356789","356789:","356789:;","356789:;<","356789:;<=","356>","356>?","356>?@","356>?@A","356>?@AB","356>?@ABC","356>?D","356>?DE","3IHGF","3IHG","3IH","3I","3IJ","35K","23IHGFL"},

  156.     {"43210","4321","432","43","4","45","456","4567","45678","456789","456789:","456789:;","456789:;<","456789:;<=","456>","456>?","456>?@","456>?@A","456>?@AB","456>?@ABC","456>?D","456>?DE","43IHGF","43IHG","43IH","43I","43IJ","45K","43IHGFL"},

  157.     {"53210","5321","532","53","54","5","56","567","5678","56789","56789:","56789:;","56789:;<","56789:;<=","56>","56>?","56>?@","56>?@A","56>?@AB","56>?@ABC","56>?D","56>?DE","53IHGF","53IHG","53IH","53I","53IJ","5K","56>?DEL"},

  158.     {"653210","65321","6532","653","654","65","6","67","678","6789","6789:","6789:;","6789:;<","6789:;<=","6>","6>?","6>?@","6>?@A","6>?@AB","6>?@ABC","6>?D","6>?DE","6>?DEF","6>?DEFG","653IH","653I","653IJ","65K","6>?DEL"},

  159.     {"7653210","765321","76532","7653","7654","765","76","7","78","789","789:","789:;","789:;<","789:;<=","76>","76>?","76>?@","76>?@A","76>?@AB","76>?@ABC","76>?D","76>?DE","76>?DEF","76>?DEFG","7653IH","7653I","7653IJ","765K","76>?DEL"},

  160.     {"87653210","8765321","876532","87653","87654","8765","876","87","8","89","89:","89:;","89:;<","89:;<=","876>","876>?","876>?@","876>?@A","876>?@AB","876>?@ABC","876>?D","876>?DE","876>?DEF","876>?DEFG","87653IH","87653I","87653IJ","8765K","876>?DEL"},

  161.     {"987653210","98765321","9876532","987653","987654","98765","9876","987","98","9","9:","9:;","9:;<","9:;<=","9876>","9876>?","9876>?@","9876>?@A","9876>?@AB","9876>?@ABC","9876>?D","9876>?DE","9876>?DEF","9876>?DEFG","987653IH","987653I","987653IJ","98765K","9876>?DEL"},

  162.     {":987653210",":98765321",":9876532",":987653",":987654",":98765",":9876",":987",":98",":9",":",":;",":;<",":;<=",":9876>",":9876>?",":9876>?@",":9876>?@A",":9876>?@AB",":9876>?@ABC",":9876>?D",":9876>?DE",":9876>?DEF",":9876>?DEFG",":987653IH",":987653I",":987653IJ",":98765K",":9876>?DEL"},

  163.     {";:987653210",";:98765321",";:9876532",";:987653",";:987654",";:98765",";:9876",";:987",";:98",";:9",";:",";",";<",";<=",";:9876>",";:9876>?",";:9876>?@",";:9876>?@A",";:9876>?@AB",";:9876>?@ABC",";:9876>?D",";:9876>?DE",";:9876>?DEF",";:9876>?DEFG",";:987653IH",";:987653I",";:987653IJ",";:98765K",";:9876>?DEL"},

  164.     {"<;:987653210","<;:98765321","<;:9876532","<;:987653","<;:987654","<;:98765","<;:9876","<;:987","<;:98","<;:9","<;:","<;","<","<=","<;:9876>","<;:9876>?","<;:9876>?@","<;:9876>?@A","<;:9876>?@AB","<;:9876>?@ABC","<;:9876>?D","<;:9876>?DE","<;:9876>?DEF","<;:9876>?DEFG","<;:987653IH","<;:987653I","<;:987653IJ","<;:98765K","<;:9876>?DEL"},

  165.     {"=<;:987653210","=<;:98765321","=<;:9876532","=<;:987653","=<;:987654","=<;:98765","=<;:9876","=<;:987","=<;:98","=<;:9","=<;:","=<;","=<","=","=<;:9876>","=<;:9876>?","=<;:9876>?@","=<;:9876>?@A","=<;:9876>?@AB","=<;:9876>?@ABC","=<;:9876>?D","=<;:9876>?DE","=<;:9876>?DEF","=<;:9876>?DEFG","=<;:987653IH","=<;:987653I","=<;:987653IJ","=<;:98765K","=<;:9876>?DEL"},

  166.     {">653210",">65321",">6532",">653",">654",">65",">6",">67",">678",">6789",">6789:",">6789:;",">6789:;<",">6789:;<=",">",">?",">?@",">?@A",">?@AB",">?@ABC",">?D",">?DE",">?DEF",">?DEFG",">?DEFGH",">653I",">653IJ",">65K",">?DEL"},

  167.     {"?>653210","?>65321","?>6532","?>653","?>654","?>65","?>6","?>67","?>678","?>6789","?>6789:","?>6789:;","?>6789:;<","?>6789:;<=","?>","?","?@","?@A","?@AB","?@ABC","?D","?DE","?DEF","?DEFG","?DEFGH","?>653I","?>653IJ","?>65K","?DEL"},

  168.     {"@?>653210","@?>65321","@?>6532","@?>653","@?>654","@?>65","@?>6","@?>67","@?>678","@?>6789","@?>6789:","@?>6789:;","@?>6789:;<","@?>6789:;<=","@?>","@?","@","@A","@AB","@ABC","@ED","@E","@EF","@EFG","@EFGH","@?>653I","@?>653IJ","@?>65K","@EL"},

  169.     {"A@?>653210","A@?>65321","A@?>6532","A@?>653","A@?>654","A@?>65","A@?>6","A@?>67","A@?>678","A@?>6789","A@?>6789:","A@?>6789:;","A@?>6789:;<","A@?>6789:;<=","A@?>","A@?","A@","A","AB","ABC","AED","AE","AEF","AEFG","AEFGH","A@?>653I","A@?>653IJ","A@?>65K","AEL"},

  170.     {"BA@?>653210","BA@?>65321","BA@?>6532","BA@?>653","BA@?>654","BA@?>65","BA@?>6","BA@?>67","BA@?>678","BA@?>6789","BA@?>6789:","BA@?>6789:;","BA@?>6789:;<","BA@?>6789:;<=","BA@?>","BA@?","BA@","BA","B","BC","BAED","BAE","BAEF","BAEFG","BAEFGH","BA@?>653I","BA@?>653IJ","BA@?>65K","BAEL"},

  171.     {"CBA@?>653210","CBA@?>65321","CBA@?>6532","CBA@?>653","CBA@?>654","CBA@?>65","CBA@?>6","CBA@?>67","CBA@?>678","CBA@?>6789","CBA@?>6789:","CBA@?>6789:;","CBA@?>6789:;<","CBA@?>6789:;<=","CBA@?>","CBA@?","CBA@","CBA","CB","C","CBAED","CBAE","CBAEF","CBAEFG","CBAEFGH","CBA@?>653I","CBA@?>653IJ","CBA@?>65K","CBAEL"},

  172.     {"D?>653210","D?>65321","D?>6532","D?>653","D?>654","D?>65","D?>6","D?>67","D?>678","D?>6789","D?>6789:","D?>6789:;","D?>6789:;<","D?>6789:;<=","D?>","D?","DE@","DEA","DEAB","DEBC","D","DE","DEF","DEFG","DEFGH","D?>653I","D?>653IJ","D?>65K","DEL"},

  173.     {"ED?>653210","ED?>65321","ED?>6532","ED?>653","ED?>654","ED?>65","ED?>6","ED?>67","ED?>678","ED?>6789","ED?>6789:","ED?>6789:;","ED?>6789:;<","ED?>6789:;<=","ED?>","ED?","E@","EA","EAB","EBC","ED","E","EF","EFG","EFGH","EFGHI","EFGHIJ","ED?>65K","EL"},

  174.     {"FGHIJ10","FGHIJ1","FGHI32","FGHI3","FGHI34","FGHI345","FED?>6","FED?>67","FED?>678","FED?>6789","FED?>6789:","FED?>6789:;","FED?>6789:;<","FED?>6789:;<=","FED?>","FED?","FE@","FEA","FEAB","FEBC","FED","FE","F","FG","FGH","FGHI","FGHIJ","FGHI35K","FL"},

  175.     {"GHIJ10","GHIJ1","GHI32","GHI3","GHI34","GHI345","GFED?>6","GFED?>67","GFED?>678","GFED?>6789","GFED?>6789:","GFED?>6789:;","GFED?>6789:;<","GFED?>6789:;<=","GFED?>","GFED?","GFE@","GFEA","GFEAB","GFEBC","GFED","GFE","GF","G","GH","GHI","GHIJ","GHI35K","GFL"},

  176.     {"HIJ10","HIJ1","HI32","HI3","HI34","HI345","HI3456","HI34567","HI345678","HI3456789","HI3456789:","HI3456789:;","HI3456789:;<","HI3456789:;<=","HI3456>","HGFED?","HGFE@","HGFEA","HGFEAB","HGFEBC","HGFED","HGFE","HGF","HG","H","HI","HIJ","HI35K","HGFL"},

  177.     {"IJ10","IJ1","I32","I3","I34","I345","I3456","I34567","I345678","I3456789","I3456789:","I3456789:;","I3456789:;<","I3456789:;<=","I3456>","IHGFED?","IHGFE@","IHGFE@A","IHGFE@AB","IHGFE@ABC","IHGFED","IHGFE","IHGF","IHG","IH","I","IJ","I35K","IHGFL"},

  178.     {"J10","J1","JI32","JI3","JI34","JI345","JI3456","JI34567","JI345678","JI3456789","JI3456789:","JI3456789:;","JI3456789:;<","JI3456789:;<=","JI3456>","JIHGFED?","JIHGFE@","JIHGFE@A","JIHGFE@AB","JIHGFE@ABC","JIHGFED","JIHGFE","JIHGF","JIHG","JIH","JI","J","JI35K","JIHGFL"},

  179.     {"K210","K21","K53","K54","K5","K56","K567","K5678","K56789","K56789:","K56789:;","K56789:;<","K56789:;<=","K56>","K56>?","K56>?@","K56>?@A","K56>?@AB","K56>?@ABC","K56>?D","K56>?DE","K53IHGF","K53IHG","K53IH","K53I","K53IJ","K","K56>?DEL"},

  180.     {"LFGHIJ10","LFGHIJ1","LFGHI32","LFGHI3","LFGHI34","LED?>65","LED?>6","LED?>67","LED?>678","LED?>6789","LED?>6789:","LED?>6789:;","LED?>6789:;<","LED?>6789:;<=","LED?>","LED?","LE@","LEA","LEAB","LEABC","LED","LE","LF","LFG","LFGH","LFGHI","LFGHIJ","LED?>65K","L"}

  181. };

  182. const char* TB1path2[16][16] = {

  183.     {"0","01","012","013","04","045","0456","0457","08","089","089:","089;","04<","04<=","04<=>","04<=?"},

  184.     {"10","1","12","13","104","1365","10456","10457","108","1089","1089:","12:9;","104<","104<=","104<=>","104<=?"},

  185.     {"210","21","2","213","2104","21365","210456","210457","2:98","2:9","2:","2:9;","2104<","2104<=","2104<=>","2104<=?"},

  186.     {"310","31","32","3","3104","365","36","3657","3108","32:9","32:","32:9;","32104<","32104<=","32104<=>","32104<=?"},

  187.     {"40","401","4012","4013","4","45","456","457","408","4089","4089:","4089;","4<","4<=","4<=>","4<=?"},

  188.     {"540","5401","54012","54013","54","5","56","57","5408","54089","54089:","54089;","54<","57?=","57?=>","57?"},

  189.     {"6310","631","632","63","654","65","6","67","63108","6312:9","632:","632:;","654<","657?=","657?=>","657?"},

  190.     {"7540","75631","756312","7563","754","75","76","7","75408","754089","754089:","754089;","7?=<","7?=","7?=>","7?"},

  191.     {"80","801","8012","8013","804","8045","80456","80457","8","89","89:","89;","8<","8<=","8<=>","8<=?"},

  192.     {"980","9:21","9:2","9:23","9804","98045","980136","980457","98","9","9:","9;","98<","98<=","98<=>","98<=?"},

  193.     {":210",":21",":2",":23",":2104",":21045",":236",":2367",":98",":9",":",":;",":98<",":9;>=",":;>",":;>?"},

  194.     {";980",";:21",";:2",";:23",";9804",";98045",";980456",";980457",";98",";9",";:",";",";>=<",";>=",";>",";>?"},

  195.     {"<80","<801","<89:2","<8013","<4","<45","<456","<457","<8","<89","<89:","<89;","<","<=","<=>","<=?"},

  196.     {"=<80","=<801","=<89:2","=<8013","=<4","=?75","=?76","=?7","=<8","=>;9","=>;:","=>;","=<","=","=>","=?"},

  197.     {">;980",">;9:21",">;9:2",">;9:23",">=<4",">=?75",">=?76",">=?7",">;98",">;9",">;:",">;",">=<",">=",">",">?"},

  198.     {"?=<40","?=>401","?=<4012","?=<4013","?754","?75","?76","?7","?=<8","?>;9","?>;:","?>;","?=<","?=","?>","?"},

  199. 

  200. };

  201. 

  202. //保存各个教室的窗子坐标（待补充）

  203. WindowNode TB3window[4] = { {25,10,27,10},{17,22,19,22},{13,20,11,20}, {14,5,14,3} };

  204. WindowNode TB5window[3] = { {17,31,17,29},{15,42,15,44},{6,32,4,32} };

  205. WindowNode TB6window[5] = { {40,17,42,17},{32,18,32,16},{27,34,25,34},{36,42,38,42},{45,37,45,39} };

  206. WindowNode TB1window[12] = { 

  207.     {27,10,25,10},{19,22,17,22},{11,20,13,20}, {14,3,14,5} ,

  208.     {17,29,17,31},{15,44,15,42},{4,32,6,32} ,{42,17,40,17},

  209.     {32,16,32,18},{25,34,27,34},{38,42,36,42},{45,39,45,37} };

  210. const int TB3windowNum = 4;

  211. const int TB5windowNum = 3;

  212. const int TB6windowNum = 5;

  213. const int TB1windowNum = 12;

  214. 

  215. //各个教室的作业信息（待补充）

  216. Classroom TB3[3] = {

  217.     {0,0,{{31,6},{30,6},{29,7},{30,8}},{30,7}} ,

  218.     {1,0,{{18,4},{17,5},{18,6},{19,5}},{18,5}},

  219.     {2,0,{{22,17},{21,18},{22,19},{23,18}},{22,18}} };

  220. Classroom TB5[3] = { 

  221.     {3,0,{{8,30},{7,31},{8,32},{9,31}}, {8,31}},

  222.     {4,0,{{10,37},{9,38},{10,39},{9,39}}, {10,38}},

  223.     {5,0,{{19,40},{18,41},{19,42},{18,40}},{19,41} } };

  224. Classroom TB6[4] = { 

  225.     {6,0,{{39,12},{39,12},{40,13},{40,13}},{40,12}},

  226.     {7,0,{{28,25},{27,26},{28,27},{29,27}}, {28,26}},

  227.     {8,0,{{44,31},{43,32},{44,33},{45,32}}, {44,32}},

  228.     {9,0,{{33,39},{32,40},{33,41},{34,40}}, {33,40} } };

  229. Classroom* AllClassroom[10] = { &TB3[0], &TB3[1], &TB3[2],

  230.                                  &TB5[0], &TB5[1], &TB5[2],

  231.                                  &TB6[0], &TB6[1], &TB6[2], &TB6[3] };

  232. 

  233. //各个大门的信息（待补充）

  234. Gate gate[6] = { {0,{5,6},1},{0,{46,45},1}, {0,{34,5},0}, {0,{47,13},0}, {0,{2,23},0}, {0,{21,47},0} };

  235. 

  236. enum class BulletType : unsigned char

  237. {

  238.     NullBulletType = 0,

  239.     FlyingKnife = 1,

  240.     CommonAttackOfTricker = 2,

  241.     BombBomb = 3,

  242.     JumpyDumpty = 4,

  243.     AtomBomb = 5,

  244. };

  245. //捣蛋鬼攻击类型数组

  246. int AttackRange[6] = { 0,78000,2200,2200,1600,2000 };

  247. 

  248. static bool Arrived = false;

  249. static bool Arrived1 = false;

  250. int lastSkipCount = 0;

  251. 

  252. StudentStatus Stu1Status = StudentStatus::Init;//定义玩家的初始状态为Init

  253. TrickerStatus Tricker1Status = TrickerStatus::Tracing;

  254. int NowArea=0;

  255. MapNode FinalDestination={0,0};//目前只在SetPath()中会更改

  256. MapNode ClosedStudent = { 0,0 };//单位是grid，不是cell

  257. MapNode TempDestination;//暂时好像还没用到，在某些函数中用局部变量来替代它，好像不需要作为全局变量

  258. Classroom* TempClassroom;//在WantToStudy状态下会用到，其实也是一个不需要作为全局变量的变量

  259. Gate* TempGate = &gate[0];//在WantToGraduate状态和Graduating状态下会用到。

  260. int FinishedClassroom = 0;//已完成的作业数

  261. int TB3FinishedClassroom = 0;

  262. int TB5FinishedClassroom = 0;

  263. int TB6FinishedClassroom = 0;

  264. 

  265. int lastStayCount = 0;

  266. MapNode lastposition = { 0,0 };

  267. MapNode lastposition1 = { 0,0 };

  268. bool Stuck = false;

  269. MapNode KeyNode[3] = { {25,7},{8,35}, {40,25} };//存放的是Tricker选择TB时的目的地关键点，不和之前定义的TBNode重复

  270. 

  271. //Tricker用于Searching的ClosedPath

  272. MapNode ClosedTrickerPath[56] = {

  273.     {20,25},{19,22},{17,22},{17,16},{21,16},{22,7},{20,4},{20,2},{20,3},{20,5},

  274.     {29,4},{30,3},{29,4},{24,8},{25,10},{28,11},{32,16},{32,24},{40,19},{40,30},

  275.     {45,30},{45,37},{43,43},{43,42},{39,38},{39,39},{38,39},{39,39},{38,42},{33,36},

  276.     {27,34},{24,34},{23,41},{21,44},{21,46},{16,46},{16,45},{15,46},{15,42},{19,39},

  277.     {20,36},{17,33},{14,36},{9,36},{7,32},{6,32},{4,34},{5,34},{4,34},{4,21},

  278.     {9,21},{6,25},{14,25},{14,29},{14,28}, {17,25},

  279. };

  280. MapNode ClosedTrickerPath2[68] = {

  281.     {17,21},{18,19},{30,18},{31,30},{19,31},{21,36},{17,38},{12,33},{11,38},{6,43},

  282.     {4,41},{11,48},{20,48},{20,44},{15,45},{19,42},{30,42},{34,45},{31,43},{31,42},

  283.     {31,39},{37,33},{38,38},{43,43},{41,45},{48,38},{48,29},{44,29},{45,34},{42,30},

  284.     {42,29},{42,19},{45,15},{43,18},{42,18},{39,18},{33,12},{38,11},{43,6},{46,9},

  285.     {38,1},{29,1},{29,5},{34,4},{32,7},{30,7},{17,7},{15,4},{18,6},{18,5},

  286.     {18,10},{12,16},{11,11},{6,6},{8,4},{1,11},{1,20},{5,20},{4,15},{7,17},

  287.     {7,19},{7,32},{4,34},{6,31},{7,31},{11,31},{11,20},{9,21},

  288. };

  289. int Closedpathlength = 56;

  290. int Closedpathlength2 = 68;

  291. bool StatusIsSearching = false;

  292. 

  293. //用于学生的固定去往settedpoint的路径

  294. MapNode Pathfor0[5] = { {36,7},{36,11}, {36,18},{38,18},{40,13} };

  295. MapNode Pathfor1[3] = { {3,37},{8,37},{10,37} };

  296. MapNode Pathfor2[4] = { {3,10},{10,13},{13,13},{17,5} };

  297. MapNode Pathfor3[4] = { {39,38},{40,35},{44,35},{44,33} };

  298. MapNode* Ppath[4] = {Pathfor0,Pathfor1,Pathfor2,Pathfor3};

  299. 

  300. MapNode Pathfor02[7] = { {4,2},{4,4},{11,11},{11,18},{9,18},{6,18},{6,14} };

  301. MapNode Pathfor22[7] = { {45,2},{45,4},{38,11},{31,11},{31,9},{31,6},{35,6} };

  302. MapNode Pathfor12[7] = { {4,47},{4,45},{11,38},{11,31},{9,31},{6,31},{6,35} };

  303. MapNode Pathfor32[7] = { {45,47},{45,45},{38,38},{38,31},{40,31},{43,31},{43,35} };

  304. MapNode* Ppath2[4] = { Pathfor02,Pathfor12,Pathfor22,Pathfor32 };

  305. int PathforLength[4] = { 5,3,4,4 };

  306. int PathforLength2[4] = { 7,7,7,7 };

  307. 

  308. 

  309. /*-------------------------------自定义的函数声明-------------------------------*/

  310. 

  311. /*--------------------------------基础功能函数----------------------------------*/

  312. 

  313. static inline int CellToGrid(int cell) noexcept;//·返回格子的中心坐标

  314. static inline int GridToCell(int grid) noexcept;//·返回该坐标所处的格子

  315. int GetArea(int x, int y);//·返回所在区域的值

  316. double GetDistance(double x1, double y1, double x2, double y2);//·返回两点间的距离

  317. 

  318. /*----------------------------------用于移动------------------------------------*/

  319. 

  320. void Goto(ITrickerAPI& api, int destX, int destY);//·去到一个格点坐标（不考虑是否有墙）(For Tricker)

  321. void GotoGrid(ITrickerAPI& api, double destX, double destY);//·去到一个Grid（For Tricker)

  322. void Goto(IStudentAPI& api, int destX, int destY);//·去到一个格点坐标（不考虑是否有墙）(For Student)

  323. void GotoGrid(IStudentAPI& api, double destX, double destY);//·去到一个Grid(For Tricker)

  324. bool arriveAt(IStudentAPI &api, int x2, int y2);//·判断是否到达某点(For Student)

  325. bool arriveAt(ITrickerAPI& api, int x2, int y2);//·判断是否到达某点

  326. bool isWalled(int x1, int y1, int x2, int y2);//·判断两点之间是否有墙

  327. int MostCloseNode(int x, int y, int AreaNum);//·寻找在该区域内离这个点最近的结点

  328. const char* PathInAnArea(IAPI& api, int origX, int origY, int destX, int destY, int AreaNum);//·在一个区域内，返回路径(字符串)

  329. void SetPath(IAPI &api, int origX,int origY,int destX, int destY);//·把path数组进行修改,也更改全局变量FinalDestination

  330. bool MoveAlongPath(IStudentAPI &api);//·用于沿着path移动的函数，到达目的地时返回ture(For Student)

  331. bool MoveAlongPath(ITrickerAPI& api);//·用于沿着path移动的函数，到达目的地时返回ture(For Tricker)

  332.                                      //缺一个更新，终点是作业的情况

  333. 

  334. /*------------------------寻找教室、窗子、宝箱、大门-----------------------------*/

  335. 

  336. int MostCloseWindow(int x, int y, int AreaNum);//·寻找在该区域内离这个点最近的窗子

  337. Classroom* ChooseAClassroom(IStudentAPI& api, int x, int y,int ID);//·寻找未写完的最近的作业(现在同一个区域找，若没有，在所有区域找）

  338. 

  339. Gate* ChooseAGate(IStudentAPI& api, int x, int y);//寻找离得最近的校门（包括隐藏校门）

  340. 

  341. /*---------------------------用于初始化以及决策----------------------------------*/

  342. 

  343. void InitMap(IAPI &api);//·扫描地图，获取每个格子的placetype，初始化全局变量map与nodemap

  344. void SetStatus(ITrickerAPI& api);//用于设置状态(For Tricker)

  345. void SetStatus(IStudentAPI& api);//用于设置状态(For Student)

  346. void UpdateInfo(IStudentAPI& api);//用于刷新信息

  347. void UpdateInfo(ITrickerAPI& api, int ID);//用于刷新信息，使用了GetGameInfo来获取写完的作业数，但在Student的函数里还没改

  348. 

  349. int MostCloseStudent(ITrickerAPI& api);//返回-1说明视野内没有血的学生

  350. bool BeStuck(ITrickerAPI& api);

  351. bool BeStuck(IStudentAPI& api);

  352. bool BeLongStuck(ITrickerAPI& api);

  353. 

  354. //函数定义

  355. 

  356. static inline int CellToGrid(int cell) noexcept

  357. {

  358.     return cell * numOfGridPerCell + numOfGridPerCell / 2;

  359. }

  360. static inline int GridToCell(int grid) noexcept

  361. {

  362.     return grid / numOfGridPerCell;

  363. }

  364. int GetArea(int x, int y)

  365. {

  366.     if ((x >= 17 && x <= 20 && y >= 1 && y <= 3) || (x >= 10 && x <= 25 && y >= 4 && y <= 11) || (x >= 26 && x <= 31 && y >= 3 && y <= 9)

  367.         || (x >= 12 && x <= 25 && y >= 12 && y <= 20) || (x >= 26 && x <= 27 && y >= 14 && y <= 16) || (x >= 12 && x <= 17 && y >= 21 && y <= 22))

  368.         return 3;

  369.     else if ((x >= 6 && x <= 9 && y >= 27 && y <= 42) || (x >= 10 && x <= 12 && y >= 35 && y <= 46) || (x >= 13 && x <= 20 && y >= 35 && y <= 42)

  370.         || (x >= 17 && x <= 19 && y >= 43 && y <= 44) || (x >= 15 && x <= 21 && y >= 30 && y <= 36) || (x == 19 && y >= 28 && y <= 29))

  371.         return 5;

  372.     else if ((x >= 40 && x <= 41 && y >= 9 && y <= 11) || (x >= 38 && x <= 41 && y >= 12 && y <= 16) || (x == 42 && y == 19) || (x >= 32 && x <= 41 && y >= 17 && y <= 23)

  373.         || (x >= 29 && x <= 30 && y == 23) || (x >= 27 && x <= 46 && y >= 23 && y <= 32) || (x >= 27 && x <= 37 && y >= 33 && y <= 39) || (x >= 43 && x <= 48 && y >= 33 && y <= 37) || (x >= 30 && x <= 36 && y >= 40 && y <= 43))

  374.         return 6;

  375.     else return 1;

  376. }

  377. double GetDistance(double x1, double y1, double x2, double y2)

  378. {

  379.     return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));

  380. }

  381. 

  382. void Goto(ITrickerAPI& api, int destX, int destY)

  383. {

  384.     api.Print(fmt::format("Goto({},{})", destX, destY));

  385.     auto self = api.GetSelfInfo();

  386.     int selfx = self->x;

  387.     int selfy = self->y;

  388.     auto delta_x = (double)(CellToGrid(destX) - selfx);

  389.     auto delta_y = (double)(CellToGrid(destY) - selfy);

  390.     double ang = 0;

  391.     ang = atan2(delta_y, delta_x);

  392. 

  393. 

  394.     api.Move(200, ang);

  395. }

  396. void GotoGrid(ITrickerAPI& api, double destX, double destY)

  397. {

  398.     api.Print(fmt::format("GotoGrid({},{})", destX, destY));

  399.     auto self = api.GetSelfInfo();

  400.     int selfx = self->x;

  401.     int selfy = self->y;

  402.     auto delta_x = destX - selfx;

  403.     auto delta_y = destY - selfy;

  404.     double ang = 0;

  405.     ang = atan2(delta_y, delta_x);

  406. 

  407. 

  408.     api.Move(800, ang);

  409. }

  410. void Goto(IStudentAPI& api, int destX, int destY)

  411. 

  412. {

  413.     api.Print(fmt::format("Goto({},{})", destX, destY));

  414.     auto self = api.GetSelfInfo();

  415.     int selfx = self->x;

  416.     int selfy = self->y;

  417.     auto delta_x = (double)(CellToGrid(destX) - selfx);

  418.     auto delta_y = (double)(CellToGrid(destY) - selfy);

  419.     double ang = 0;

  420.     ang = atan2(delta_y, delta_x);

  421.     api.Print(fmt::format("My location:{},{}", GridToCell(self->x), GridToCell(self->y)));

  422.     api.Print(fmt::format("delta_x+delta_y:{}", delta_x + delta_y));

  423.     api.Print(fmt::format("angle:", ang));

  424.     api.Move(200, ang);

  425.     //api.EndAllAction();

  426. }

  427. void GotoGrid(IStudentAPI& api, double destX, double destY)

  428. {

  429.     api.Print(fmt::format("GotoGrid({},{})", destX, destY));

  430.     auto self = api.GetSelfInfo();

  431.     int selfx = self->x;

  432.     int selfy = self->y;

  433.     auto delta_x = destX - selfx;

  434.     auto delta_y = destY - selfy;

  435.     double ang = 0;

  436.     ang = atan2(delta_y, delta_x);

  437. 

  438. 

  439.     api.Move(400, ang );

  440. }

  441. bool arriveAt(IStudentAPI &api,int x2, int y2)

  442. {

  443.     auto self = api.GetSelfInfo();

  444.     int selfx = self->x;

  445.     int selfy = self->y;

  446.     if (std::abs(selfx - (1000 * x2+500)) + std::abs(selfy- (1000 * y2+500)) < 200)

  447.     {

  448.         return true;

  449.     }

  450.     return false;

  451. }

  452. bool arriveAt(ITrickerAPI& api, int x2, int y2)

  453. {

  454.     auto self = api.GetSelfInfo();

  455.     int selfx = self->x;

  456.     int selfy = self->y;

  457.     if (std::abs(selfx - (1000 * x2 + 500)) + std::abs(selfy - (1000 * y2 + 500)) < 200)

  458.     {

  459.         return true;

  460.     }

  461.     return false;

  462. }

  463. bool arriveAtMax(IStudentAPI& api, int x2, int y2)

  464. {

  465.     auto self = api.GetSelfInfo();

  466.     int selfx = self->x;

  467.     int selfy = self->y;

  468.     if (std::abs(selfx - (1000 * x2 + 500)) + std::abs(selfy - (1000 * y2 + 500)) < 1800)

  469.     {

  470.         return true;

  471.     }

  472.     return false;

  473. }

  474. bool arriveAtMax(ITrickerAPI& api, int x2, int y2)

  475. {

  476.     auto self = api.GetSelfInfo();

  477.     int selfx = self->x;

  478.     int selfy = self->y;

  479.     if (std::abs(selfx - (1000 * x2 + 500)) + std::abs(selfy - (1000 * y2 + 500)) < 1200)

  480.     {

  481.         api.Print("ArrivedMax");

  482.         return true;

  483.     }

  484.     api.Print("NotArrivedMax");

  485.     return false;

  486. }

  487. bool isWalled1(int x1, int y1, int x2, int y2)

  488. {

  489.     int ktype = 2;//0对于斜率不存在，1对于斜率为0, 2对于斜率非0

  490.     double k, b;

  491.     if (x1 == x2)

  492.         ktype = 0;

  493.     else if (y1 == y2)

  494.         ktype = 1;

  495.     switch (ktype)

  496.     {

  497.     case 0:

  498.     {if (y1 > y2)

  499.     {

  500.         for (int y = y2 + 1; y < y1; y++)

  501.         {

  502.             if (map[x1][y] == THUAI6::PlaceType::Wall || map[x1][y] == THUAI6::PlaceType::Chest || map[x1][y] == THUAI6::PlaceType::ClassRoom)

  503.                 return true;

  504.         }

  505.         return false;

  506.     }

  507.     else

  508.     {

  509.         for (int y = y1 + 1; y < y2; y++)

  510.         {

  511.             if (map[x1][y] == THUAI6::PlaceType::Wall || map[x1][y] == THUAI6::PlaceType::Chest || map[x1][y] == THUAI6::PlaceType::ClassRoom)

  512.                 return true;

  513.         }

  514.         return false;

  515.     }

  516.     break; }

  517.     case 1:

  518.     {if (x1 > x2)

  519.     {

  520.         for (int x = x2 + 1; x < x1; x++)

  521.         {

  522.             if (map[x][y1] == THUAI6::PlaceType::Wall || map[x][y1] == THUAI6::PlaceType::Chest || map[x][y1] == THUAI6::PlaceType::ClassRoom)

  523.                 return true;

  524.         }

  525.         return false;

  526.     }

  527.     else

  528.     {

  529.         for (int x = x1 + 1; x < x2; x++)

  530.         {

  531.             if (map[x][y1] == THUAI6::PlaceType::Wall || map[x][y1] == THUAI6::PlaceType::Chest || map[x][y1] == THUAI6::PlaceType::ClassRoom)

  532.                 return true;

  533.         }

  534.         return false;

  535.     }

  536.     break; }

  537.     case 2:

  538.     {k = (y1 - y2) / (double)(x1 - x2);

  539.     b = (y1 * x2 - y2 * x1) / (double)(x2 - x1);

  540.     double x, y;

  541.     if (x1 < x2)

  542.     {

  543.         for (x = x1 ; x < x2; x += 0.01)

  544.         {

  545.             y = k * x + b;

  546.             int xGrid = CellToGrid(x);

  547.             int yGrid = CellToGrid(y);

  548.             int xCell = GridToCell(xGrid);

  549.             int yCell = GridToCell(yGrid);

  550.             if (map[xCell][yCell] == THUAI6::PlaceType::Wall || map[xCell][yCell] == THUAI6::PlaceType::Chest || map[xCell][yCell] == THUAI6::PlaceType::ClassRoom)

  551.                 return true;

  552.         }

  553.         return false;

  554.     }

  555.     else

  556.     {

  557.         for (x = x2; x < x1 ; x += 0.01)

  558.         {

  559.             y = k * x + b;

  560.             int xGrid = CellToGrid(x);

  561.             int yGrid = CellToGrid(y);

  562.             int xCell = GridToCell(xGrid);

  563.             int yCell = GridToCell(yGrid);

  564.             if (map[xCell][yCell] == THUAI6::PlaceType::Wall || map[xCell][yCell] == THUAI6::PlaceType::Chest || map[xCell][yCell] == THUAI6::PlaceType::ClassRoom)

  565.                 return true;

  566.         }

  567.         return false;

  568.     }}

  569.     default:

  570.         return false;

  571.         break;

  572.     }

  573. }

  574. bool isWalled(int x1, int y1, int x2, int y2)

  575. {

  576.     int ktype = 2;//0对于斜率不存在，1对于斜率为0, 2对于斜率非0

  577.     double k, b;

  578.     if (x1 == x2)

  579.         ktype = 0;

  580.     else if (y1 == y2)

  581.         ktype = 1;

  582.     switch (ktype)

  583.     {

  584.     case 0:

  585.     {if (y1 > y2)

  586.     {

  587.         for (int y = y2 + 1; y < y1; y++)

  588.         {

  589.             if (map[x1][y] == THUAI6::PlaceType::Wall || map[x1][y] == THUAI6::PlaceType::Chest || map[x1][y] == THUAI6::PlaceType::ClassRoom)

  590.                 return true;

  591.         }

  592.         return false;

  593.     }

  594.     else

  595.     {

  596.         for (int y = y1 + 1; y < y2; y++)

  597.         {

  598.             if (map[x1][y] == THUAI6::PlaceType::Wall || map[x1][y] == THUAI6::PlaceType::Chest || map[x1][y] == THUAI6::PlaceType::ClassRoom)

  599.                 return true;

  600.         }

  601.         return false;

  602.     }

  603.     break; }

  604.     case 1:

  605.     {if (x1 > x2)

  606.     {

  607.         for (int x = x2 + 1; x < x1; x++)

  608.         {

  609.             if (map[x][y1] == THUAI6::PlaceType::Wall || map[x][y1] == THUAI6::PlaceType::Chest || map[x][y1] == THUAI6::PlaceType::ClassRoom)

  610.                 return true;

  611.         }

  612.         return false;

  613.     }

  614.     else

  615.     {

  616.         for (int x = x1 + 1; x < x2; x++)

  617.         {

  618.             if (map[x][y1] == THUAI6::PlaceType::Wall || map[x][y1] == THUAI6::PlaceType::Chest || map[x][y1] == THUAI6::PlaceType::ClassRoom)

  619.                 return true;

  620.         }

  621.         return false;

  622.     }

  623.     break; }

  624.     case 2:

  625.     {

  626.         int x1Grid = CellToGrid(x1);

  627.         int y1Grid = CellToGrid(y1);

  628.         int x2Grid = CellToGrid(x2);

  629.         int y2Grid = CellToGrid(y2);

  630.         k = (y1Grid - y2Grid) / (double)(x1Grid - x2Grid);

  631.         b = (y1Grid * x2Grid - y2Grid * x1Grid) / (double)(x2Grid - x1Grid);

  632.     double x, y;

  633.     if (x1 < x2)

  634.     {

  635.         for (x = x1Grid; x < x2Grid; x += 100)

  636.         {

  637.             y = k * x + b;

  638.             int xCell = GridToCell(x);

  639.             int yCell = GridToCell(y);

  640.             if (map[xCell][yCell] == THUAI6::PlaceType::Wall || map[xCell][yCell] == THUAI6::PlaceType::Chest || map[xCell][yCell] == THUAI6::PlaceType::ClassRoom)

  641.                 return true;

  642.         }

  643.         return false;

  644.     }

  645.     else

  646.     {

  647.         for (x = x2Grid; x < x1Grid; x += 0.01)

  648.         {

  649.             y = k * x + b;

  650.             

  651.             int xCell = GridToCell(x);

  652.             int yCell = GridToCell(y);

  653.             if (map[xCell][yCell] == THUAI6::PlaceType::Wall || map[xCell][yCell] == THUAI6::PlaceType::Chest || map[xCell][yCell] == THUAI6::PlaceType::ClassRoom)

  654.                 return true;

  655.         }

  656.         return false;

  657.     }}

  658.     default:

  659.         return false;

  660.         break;

  661.     }

  662. }

  663. int MostCloseNode(int x, int y, int AreaNum,MapNode dest)

  664. {

  665.     MapNode* areanode;

  666.     int nodenum, result = -1;

  667.     switch (AreaNum)//选择合适的教室节点图

  668.     {

  669.     case 3:

  670.     {areanode = TB3node;

  671.     nodenum = sizeof_TB3node;

  672.     break; }

  673.     case 5:

  674.     {areanode = TB5node;

  675.     nodenum = sizeof_TB5node;

  676.     break; }

  677.     case 6:

  678.     {areanode = TB6node;

  679.     nodenum = sizeof_TB6node;

  680.     break; }

  681.     case 1:

  682.     {areanode = TB1node;

  683.     nodenum = sizeof_TB1node;

  684.     break; }

  685.     default:

  686.     {areanode = { 0 };

  687.     nodenum = 0;

  688.     break; }

  689.     }

  690.     double dis, min_dis = 1000;

  691.     for (int i = 0; i < nodenum; i++)

  692.     {

  693.         double x_p = areanode[i].x;

  694.         double y_p = areanode[i].y;

  695.         dis = sqrt((x - x_p) * (x - x_p) + (y - y_p) * (y - y_p))+GetDistance(x_p,y_p,dest.x,dest.y);

  696.         if (dis < min_dis)

  697.         {

  698.             if (!isWalled(x, y, x_p, y_p))

  699.             {

  700.                 min_dis = dis;

  701.                 result = i;

  702.             }

  703.         }

  704.     }

  705.     return result;

  706. }//寻找在该区域内离这个点最近的结点

  707. int MostCloseNode2(int x, int y, int AreaNum, MapNode dest)

  708. {

  709.     MapNode* areanode;

  710.     int nodenum, result = -1;

  711.     switch (AreaNum)//选择合适的教室节点图

  712.     {

  713.     case 3:

  714.     {areanode = TB3node;

  715.     nodenum = sizeof_TB3node;

  716.     break; }

  717.     case 5:

  718.     {areanode = TB5node;

  719.     nodenum = sizeof_TB5node;

  720.     break; }

  721.     case 6:

  722.     {areanode = TB6node;

  723.     nodenum = sizeof_TB6node;

  724.     break; }

  725.     case 1:

  726.     {areanode = TB1node2;

  727.     nodenum = sizeof_TB1node2;

  728.     break; }

  729.     default:

  730.     {areanode = { 0 };

  731.     nodenum = 0;

  732.     break; }

  733.     }

  734.     double dis, min_dis = 1000;

  735.     for (int i = 0; i < nodenum; i++)

  736.     {

  737.         double x_p = areanode[i].x;

  738.         double y_p = areanode[i].y;

  739.         dis = sqrt((x - x_p) * (x - x_p) + (y - y_p) * (y - y_p)) + GetDistance(x_p, y_p, dest.x, dest.y);

  740.         if (dis < min_dis)

  741.         {

  742.             if (!isWalled(x, y, x_p, y_p))

  743.             {

  744.                 min_dis = dis;

  745.                 result = i;

  746.             }

  747.         }

  748.     }

  749.     return result;

  750. }//寻找在该区域内离这个点最近的结点

  751. const char* PathInAnArea(IAPI& api, int origX, int origY, int destX, int destY, int AreaNum)

  752. {

  753.     //先根据AreaNum的值，找离起点、终点最近的点的序号

  754.     MapNode* areanode;

  755.     int nodenum;

  756.     switch (AreaNum)//选择合适的教室节点图

  757.     {

  758.     case 3:

  759.     {areanode = TB3node;

  760.     nodenum = sizeof_TB3node;

  761.     break; }

  762.     case 5:

  763.     {areanode = TB5node;

  764.     nodenum = sizeof_TB5node;

  765.     break; }

  766.     case 6:

  767.     {areanode = TB6node;

  768.     nodenum = sizeof_TB6node;

  769.     break; }

  770.     case 1:

  771.     {areanode = TB1node;

  772.     nodenum = sizeof_TB1node;

  773.     break; }

  774.     default:

  775.     {areanode = { 0 };

  776.     nodenum = 0;

  777.     break; }

  778.     }

  779.     int from = MostCloseNode(origX, origY, AreaNum, MapNode{ destX,destY });

  780.     int to = MostCloseNode(destX, destY, AreaNum, MapNode{ origX,origY });

  781.     api.Print("PathInAnArea has been called");

  782.     api.Print(fmt::format("FromTB{}[{}]", AreaNum,from));

  783.     api.Print(fmt::format("ToTB{}[{}]", AreaNum, to));

  784.     //再根据AreaNum的值，在对应的“结点to结点路径数组”中找到该路径(字符串）

  785.     switch (AreaNum)

  786.     {

  787.     case 3:

  788.     {return TB3path[from][to]; }

  789.     case 5:

  790.     {return TB5path[from][to]; }

  791.     case 6:

  792.     {return TB6path[from][to]; }

  793.     case 1:

  794.     {return TB1path[from][to]; }

  795.     default:

  796.     {return TB3path[0][0];

  797.         break; }

  798.     }

  799.     //返回该路径（字符串）

  800. }

  801. const char* PathInAnArea2(IAPI& api, int origX, int origY, int destX, int destY, int AreaNum)

  802. {

  803.     //先根据AreaNum的值，找离起点、终点最近的点的序号

  804.     MapNode* areanode;

  805.     int nodenum;

  806.     switch (AreaNum)//选择合适的教室节点图

  807.     {

  808.     case 3:

  809.     {areanode = TB3node;

  810.     nodenum = sizeof_TB3node;

  811.     break; }

  812.     case 5:

  813.     {areanode = TB5node;

  814.     nodenum = sizeof_TB5node;

  815.     break; }

  816.     case 6:

  817.     {areanode = TB6node;

  818.     nodenum = sizeof_TB6node;

  819.     break; }

  820.     case 1:

  821.     {areanode = TB1node2;

  822.     nodenum = sizeof_TB1node2;

  823.     break; }

  824.     default:

  825.     {areanode = { 0 };

  826.     nodenum = 0;

  827.     break; }

  828.     }

  829.     int from = MostCloseNode2(origX, origY, AreaNum, MapNode{ destX,destY });

  830.     int to = MostCloseNode2(destX, destY, AreaNum, MapNode{ origX,origY });

  831.     api.Print("PathInAnArea has been called");

  832.     api.Print(fmt::format("FromTB{}[{}]", AreaNum, from));

  833.     api.Print(fmt::format("ToTB{}[{}]", AreaNum, to));

  834.     //再根据AreaNum的值，在对应的“结点to结点路径数组”中找到该路径(字符串）

  835.     switch (AreaNum)

  836.     {

  837.     case 3:

  838.     {return TB3path[from][to]; }

  839.     case 5:

  840.     {return TB5path[from][to]; }

  841.     case 6:

  842.     {return TB6path[from][to]; }

  843.     case 1:

  844.     {return TB1path2[from][to]; }

  845.     default:

  846.     {return TB3path[0][0];

  847.     break; }

  848.     }

  849.     //返回该路径（字符串）

  850. }

  851. void SetPath(IAPI& api, int origX, int origY, int destX, int destY)

  852. {

  853.     int origArea = GetArea(origX, origY);

  854.     int destArea = GetArea(destX, destY);

  855.     if (origArea == destArea)

  856.     {

  857.         const char* path1 = PathInAnArea(api, origX, origY, destX, destY, origArea);

  858.         MapNode* areanode;

  859.         switch (origArea)//选择合适的教室节点图

  860.         {

  861.         case 3:

  862.         {areanode = TB3node;

  863.         break; }

  864.         case 5:

  865.         {areanode = TB5node;

  866.         break; }

  867.         case 6:

  868.         {areanode = TB6node;

  869.         break; }

  870.         case 1:

  871.         {areanode = TB1node;

  872.         break; }

  873.         default:

  874.         {areanode = { 0 };

  875.         break; }

  876.         }

  877.         int i = 0;

  878.         for (i = 0; i < strlen(path1); i++)//把path1（字符串）中的路径转为path（结点数组）的元素

  879.         {

  880.             path[i] = areanode[(int)path1[i] - 48];

  881.             pathlength++;

  882.         }

  883.         path[i] = { destX,destY };//把真实要去的点作为最后一个节点

  884.         pathlength++;

  885. 

  886.     }

  887.     else//如果不在一间教室的情况

  888.     {

  889.         if (origArea == 3 && destArea == 5)//三教到五教

  890.         {

  891.             const char* path3to5_3 = PathInAnArea(api, origX, origY, 17, 22, 3);

  892.             const char* path3to5_5 = PathInAnArea(api, 17, 31, destX, destY, 5);

  893.             api.Print(path3to5_3);

  894.             api.Print(path3to5_5);

  895.             int i = 0, j = 0;

  896.             int length = strlen(path3to5_3) + strlen(path3to5_5);

  897.             for (i = 0; i < strlen(path3to5_3); i++)

  898.             {

  899.                 path[i] = TB3node[(int)path3to5_3[i] - 48];

  900.                 pathlength++;

  901.             }

  902.             path[i] = { 17,22 };

  903.             path[i + 1] = { 19,25 };

  904.             path[i + 2] = { 17,25 };

  905.             path[i + 3] = { 17,29 };

  906.             pathlength += 4;

  907.             int bug = pathlength;

  908.             for (i = bug; i < bug + strlen(path3to5_5); i++, j++, pathlength++)

  909.             {

  910.                 path[i] = TB5node[(int)path3to5_5[j] - 48];

  911.             }

  912.             pathlength = length + 5;

  913.             path[pathlength - 1] = { destX,destY };

  914. 

  915.         }

  916.         else if (origArea == 5 && destArea == 3)//五教到三教

  917.         {

  918.             const char* path5to3_5 = PathInAnArea(api, origX, origY, 17, 31, 5);

  919.             const char* path5to3_3 = PathInAnArea(api, 17, 22, destX, destY, 3);

  920.             int i = 0, j = 0;

  921.             int length = strlen(path5to3_3) + strlen(path5to3_5);

  922.             for (i = 0; i < strlen(path5to3_5); i++)

  923.             {

  924.                 path[i] = TB5node[(int)path5to3_5[i] - 48];

  925.                 pathlength++;

  926.             }

  927.             path[i] = { 17,31 };

  928.             path[i + 1] = { 17,29 };

  929.             path[i + 2] = { 17,25 };

  930.             path[i + 3] = { 19,25 };

  931.             path[i + 4] = { 19,22 };

  932.             path[i + 5] = { 17,22 };

  933.             pathlength += 6;

  934.             int bug = pathlength;

  935.             for (i = bug; i < bug + strlen(path5to3_3); i++, j++, pathlength++)

  936.             {

  937.                 path[i] = TB3node[(int)path5to3_3[j] - 48];

  938.             }

  939.             pathlength = length + 7;

  940.             path[pathlength - 1] = { destX,destY };

  941. 

  942.         }

  943.         else if (origArea == 3 && destArea == 6)//三教到六教

  944.         {

  945.             const char* path6to3_3 = PathInAnArea(api, origX, origY, 25, 10, 3);

  946.             const char* path6to3_6 = PathInAnArea(api, 32, 18, destX, destY, 6);

  947.             int i = 0, j = 0;

  948.             int length = strlen(path6to3_3) + strlen(path6to3_6);

  949.             for (i = 0; i < strlen(path6to3_3); i++)

  950.             {

  951.                 path[i] = TB3node[(int)path6to3_3[i] - 48];

  952.                 pathlength++;

  953.             }

  954.             path[i] = { 25,10 };

  955.             path[i + 1] = { 31,13 };

  956.             path[i + 2] = { 32,16 };

  957.             path[i + 3] = { 32,18 };

  958.             //path[i + 3] = { 27,10 };

  959.             pathlength += 4;

  960.             int bug = pathlength;

  961.             for (i = bug; i < bug + strlen(path6to3_6); i++, j++, pathlength++)

  962.             {

  963.                 path[i] = TB6node[(int)path6to3_6[j] - 48];

  964.             }

  965.             pathlength = length + 5;

  966.             api.Print(fmt::format("pathlength:{}", pathlength));

  967.             path[pathlength - 1] = { destX,destY };/**/

  968.         }

  969.         else if (origArea == 6 && destArea == 3)//六教到三教

  970.         {

  971.             const char* path6to3_6 = PathInAnArea(api, origX, origY, 32, 18, 6);

  972.             const char* path6to3_3 = PathInAnArea(api, 25, 10, destX, destY, 3);

  973.             int i = 0, j = 0;

  974.             int length = strlen(path6to3_3) + strlen(path6to3_6);

  975.             for (i = 0; i < strlen(path6to3_6); i++)

  976.             {

  977.                 path[i] = TB6node[(int)path6to3_6[i] - 48];

  978.                 pathlength++;

  979.             }

  980.             path[i] = { 32,18 };

  981.             //path[i+1] = { 32,16 };

  982.             path[i + 1] = { 31,13 };

  983.             path[i + 2] = { 27,10 };

  984.             path[i + 3] = { 25,10 };

  985.             pathlength += 4;

  986.             int bug = pathlength;

  987.             for (i = bug; i < bug + strlen(path6to3_3); i++, j++, pathlength++)

  988.             {

  989.                 path[i] = TB3node[(int)path6to3_3[j] - 48];

  990.             }

  991.             pathlength = length + 5;

  992.             api.Print(fmt::format("pathlength:{}", pathlength));

  993.             path[pathlength - 1] = { destX,destY };/**/

  994.         }

  995.         else if (origArea == 5 && destArea == 6)//五教到六教

  996.         {

  997.             const char* path5to6_5 = PathInAnArea(api, origX, origY, 17, 31, 5);

  998.             const char* path5to6_6 = PathInAnArea(api, 27, 34, destX, destY, 6);

  999.             int i = 0, j = 0;

  1000.             int length = strlen(path5to6_5) + strlen(path5to6_6);

  1001.             for (i = 0; i < strlen(path5to6_5); i++)

  1002.             {

  1003.                 path[i] = TB5node[(int)path5to6_5[i] - 48];

  1004.                 pathlength++;

  1005.             }

  1006. 

  1007.             path[i] = { 17,31 };

  1008.             path[i + 1] = { 17,29 };

  1009.             path[i + 2] = { 17,25 };

  1010.             path[i + 3] = { 22,25 };

  1011.             path[i + 4] = { 25,34 };

  1012.             pathlength += 5;

  1013.             int bug = pathlength;

  1014.             for (i = bug; i < bug + strlen(path5to6_6); i++, j++, pathlength++)

  1015.             {

  1016.                 path[i] = TB6node[(int)path5to6_6[j] - 48];

  1017.             }

  1018.             pathlength = length + 6;

  1019.             path[pathlength - 1] = { destX,destY };

  1020.         }

  1021.         else if (origArea == 6 && destArea == 5)//六教到五教

  1022.         {

  1023.             const char* path6to5_6 = PathInAnArea(api, origX, origY, 27, 34, 6);

  1024.             const char* path6to5_5 = PathInAnArea(api, 17, 31, destX, destY, 5);

  1025.             int i = 0, j = 0;

  1026.             int length = strlen(path6to5_5) + strlen(path6to5_6);

  1027.             for (i = 0; i < strlen(path6to5_6); i++)

  1028.             {

  1029.                 path[i] = TB6node[(int)path6to5_6[i] - 48];

  1030.                 pathlength++;

  1031.             }

  1032. 

  1033.             path[i] = { 25,34 };

  1034.             path[i + 1] = { 22,25 };

  1035.             path[i + 2] = { 17,25 };

  1036.             path[i + 3] = { 17,29 };

  1037.             path[i + 4] = { 17,31 };

  1038.             pathlength += 5;

  1039.             int bug = pathlength;

  1040.             for (i = bug; i < bug + strlen(path6to5_5); i++, j++, pathlength++)

  1041.             {

  1042.                 path[i] = TB5node[(int)path6to5_5[j] - 48];

  1043.             }

  1044.             pathlength = length + 6;

  1045.             path[pathlength - 1] = { destX,destY };

  1046.         }

  1047. 

  1048.         else if (origArea == 1)//如果起点是一教

  1049.         {

  1050.             MapNode* OrigArea = TB1node, * DestArea;

  1051.             WindowNode* DestWindow;

  1052.             switch (destArea)//选择合适的教室节点图

  1053.             {

  1054.             case 3:

  1055.             {DestWindow = TB3window;

  1056.             DestArea = TB3node;

  1057.             break; }

  1058.             case 5:

  1059.             {DestWindow = TB5window;

  1060.             DestArea = TB5node;

  1061.             break; }

  1062.             case 6:

  1063.             {DestWindow = TB6window;

  1064.             DestArea = TB6node;

  1065.             break; }

  1066.             case 1:

  1067.             {DestWindow = TB1window;

  1068.             DestArea = TB1node;

  1069.             break; }

  1070.             default:

  1071.             {DestWindow = { 0 };

  1072.             DestArea = { 0 };

  1073.             break; }

  1074.             }

  1075.             int windowNum = MostCloseWindow(origX, origY, destArea);

  1076.             const char* path2window = PathInAnArea(api, origX, origY, DestWindow[windowNum].x_out, DestWindow[windowNum].y_out, origArea);

  1077.             const char* pathwindow2dest = PathInAnArea(api, DestWindow[windowNum].x_in, DestWindow[windowNum].y_in, destX, destY, destArea);

  1078.             int i = 0, j = 0;

  1079.             int length = strlen(path2window) + strlen(pathwindow2dest);

  1080.             for (i = 0; i < strlen(path2window); i++)

  1081.             {

  1082.                 path[i] = OrigArea[(int)path2window[i] - 48];

  1083.                 pathlength++;

  1084.             }

  1085.             path[i] = { DestWindow[windowNum].x_out,DestWindow[windowNum].y_out };

  1086.             path[i + 1] = { DestWindow[windowNum].x_in,DestWindow[windowNum].y_in };

  1087.             pathlength += 2;

  1088.             int bug = pathlength;

  1089.             for (i = bug; i < bug + strlen(pathwindow2dest); i++, j++, pathlength++)

  1090.             {

  1091.                 path[i] = DestArea[(int)pathwindow2dest[j] - 48];

  1092.             }

  1093.             pathlength = length + 3;

  1094.             path[pathlength - 1] = { destX,destY };

  1095.         }

  1096.         else if (destArea == 1)//终点是一教

  1097.         {

  1098.             MapNode* OrigArea, * DestArea;

  1099.             WindowNode* OrigWindow;

  1100.             switch (origArea)//选择合适的教室节点图

  1101.             {

  1102.             case 3:

  1103.             {OrigWindow = TB3window;

  1104.             OrigArea = TB3node;

  1105.             break; }

  1106.             case 5:

  1107.             {OrigWindow = TB5window;

  1108.             OrigArea = TB5node;

  1109.             break; }

  1110.             case 6:

  1111.             {OrigWindow = TB6window;

  1112.             OrigArea = TB6node;

  1113.             break; }

  1114.             case 1:

  1115.             {OrigWindow = TB1window;

  1116.             OrigArea = TB1node;

  1117.             break; }

  1118.             default:

  1119.             {OrigWindow = { 0 };

  1120.             OrigArea = { 0 };

  1121.             break; }

  1122.             }

  1123.             switch (destArea)//选择合适的教室节点图

  1124.             {

  1125.             case 3:

  1126.             {DestArea = TB3node;

  1127.             break; }

  1128.             case 5:

  1129.             {DestArea = TB5node;

  1130.             break; }

  1131.             case 6:

  1132.             {DestArea = TB6node;

  1133.             break; }

  1134.             case 1:

  1135.             {DestArea = TB1node;

  1136.             break; }

  1137.             default:

  1138.             {DestArea = { 0 };

  1139.             break; }

  1140.             }

  1141.             int windowNum = MostCloseWindow(destX, destY, origArea);

  1142.             const char* path2window = PathInAnArea(api, origX, origY, OrigWindow[windowNum].x_in, OrigWindow[windowNum].y_in, origArea);

  1143.             const char* pathwindow2dest = PathInAnArea(api, OrigWindow[windowNum].x_out, OrigWindow[windowNum].y_out, destX, destY, destArea);

  1144.             int i = 0, j = 0;

  1145.             int length = strlen(path2window) + strlen(pathwindow2dest);

  1146.             for (i = 0; i < strlen(path2window); i++)

  1147.             {

  1148.                 path[i] = OrigArea[(int)path2window[i] - 48];

  1149.                 pathlength++;

  1150.             }

  1151.             path[i] = { OrigWindow[windowNum].x_in,OrigWindow[windowNum].y_in };

  1152.             path[i + 1] = { OrigWindow[windowNum].x_out,OrigWindow[windowNum].y_out };

  1153.             pathlength += 2;

  1154.             int bug = pathlength;

  1155.             for (i = bug; i < bug + strlen(pathwindow2dest); i++, j++, pathlength++)

  1156.             {

  1157.                 path[i] = DestArea[(int)pathwindow2dest[j] - 48];

  1158.             }

  1159.             pathlength = length + 3;

  1160.             path[pathlength - 1] = { destX,destY };

  1161.         }

  1162.         else

  1163.             api.Print("no path between orig and dest");

  1164.     }

  1165.     api.Print("Path has been updated!");

  1166.     for (int i = 0; i < pathlength; i++)//便于debug，在每次move的时候打印出路径

  1167.     {

  1168.         api.Print(fmt::format("path[{}]:{},{}",i, path[i].x, path[i].y));

  1169.     }

  1170.     FinalDestination = { destX,destY };

  1171.     api.Print(fmt::format("Destination:{},{}", destX, destY));

  1172.     Arrived = false;

  1173.     pathnum = 0;//可能会在之后带来问题

  1174. }

  1175. void SetPath2(IAPI& api, int origX, int origY, int destX, int destY)

  1176. {

  1177.     int origArea = 1;

  1178.     int destArea = 1;

  1179.     if (origArea == destArea)

  1180.     {

  1181.         const char* path1 = PathInAnArea2(api, origX, origY, destX, destY, origArea);

  1182.         MapNode* areanode;

  1183.         switch (origArea)//选择合适的教室节点图

  1184.         {

  1185.         case 3:

  1186.         {areanode = TB3node;

  1187.         break; }

  1188.         case 5:

  1189.         {areanode = TB5node;

  1190.         break; }

  1191.         case 6:

  1192.         {areanode = TB6node;

  1193.         break; }

  1194.         case 1:

  1195.         {areanode = TB1node2;

  1196.         break; }

  1197.         default:

  1198.         {areanode = { 0 };

  1199.         break; }

  1200.         }

  1201.         int i = 0;

  1202.         for (i = 0; i < strlen(path1); i++)//把path1（字符串）中的路径转为path（结点数组）的元素

  1203.         {

  1204.             path[i] = areanode[(int)path1[i] - 48];

  1205.             pathlength++;

  1206.         }

  1207.         path[i] = { destX,destY };//把真实要去的点作为最后一个节点

  1208.         pathlength++;

  1209. 

  1210.     }

  1211.     else//如果不在一间教室的情况

  1212.     {

  1213.         if (origArea == 3 && destArea == 5)//三教到五教

  1214.         {

  1215.             const char* path3to5_3 = PathInAnArea(api, origX, origY, 17, 22, 3);

  1216.             const char* path3to5_5 = PathInAnArea(api, 17, 31, destX, destY, 5);

  1217.             api.Print(path3to5_3);

  1218.             api.Print(path3to5_5);

  1219.             int i = 0, j = 0;

  1220.             int length = strlen(path3to5_3) + strlen(path3to5_5);

  1221.             for (i = 0; i < strlen(path3to5_3); i++)

  1222.             {

  1223.                 path[i] = TB3node[(int)path3to5_3[i] - 48];

  1224.                 pathlength++;

  1225.             }

  1226.             path[i] = { 17,22 };

  1227.             path[i + 1] = { 19,25 };

  1228.             path[i + 2] = { 17,25 };

  1229.             path[i + 3] = { 17,29 };

  1230.             pathlength += 4;

  1231.             int bug = pathlength;

  1232.             for (i = bug; i < bug + strlen(path3to5_5); i++, j++, pathlength++)

  1233.             {

  1234.                 path[i] = TB5node[(int)path3to5_5[j] - 48];

  1235.             }

  1236.             pathlength = length + 5;

  1237.             path[pathlength - 1] = { destX,destY };

  1238. 

  1239.         }

  1240.         else if (origArea == 5 && destArea == 3)//五教到三教

  1241.         {

  1242.             const char* path5to3_5 = PathInAnArea(api, origX, origY, 17, 31, 5);

  1243.             const char* path5to3_3 = PathInAnArea(api, 17, 22, destX, destY, 3);

  1244.             int i = 0, j = 0;

  1245.             int length = strlen(path5to3_3) + strlen(path5to3_5);

  1246.             for (i = 0; i < strlen(path5to3_5); i++)

  1247.             {

  1248.                 path[i] = TB5node[(int)path5to3_5[i] - 48];

  1249.                 pathlength++;

  1250.             }

  1251.             path[i] = { 17,31 };

  1252.             path[i + 1] = { 17,29 };

  1253.             path[i + 2] = { 17,25 };

  1254.             path[i + 3] = { 19,25 };

  1255.             path[i + 4] = { 19,22 };

  1256.             path[i + 5] = { 17,22 };

  1257.             pathlength += 6;

  1258.             int bug = pathlength;

  1259.             for (i = bug; i < bug + strlen(path5to3_3); i++, j++, pathlength++)

  1260.             {

  1261.                 path[i] = TB3node[(int)path5to3_3[j] - 48];

  1262.             }

  1263.             pathlength = length + 7;

  1264.             path[pathlength - 1] = { destX,destY };

  1265. 

  1266.         }

  1267.         else if (origArea == 3 && destArea == 6)//三教到六教

  1268.         {

  1269.             const char* path6to3_3 = PathInAnArea(api, origX, origY, 25, 10, 3);

  1270.             const char* path6to3_6 = PathInAnArea(api, 32, 18, destX, destY, 6);

  1271.             int i = 0, j = 0;

  1272.             int length = strlen(path6to3_3) + strlen(path6to3_6);

  1273.             for (i = 0; i < strlen(path6to3_3); i++)

  1274.             {

  1275.                 path[i] = TB3node[(int)path6to3_3[i] - 48];

  1276.                 pathlength++;

  1277.             }

  1278.             path[i] = { 25,10 };

  1279.             path[i + 1] = { 31,13 };

  1280.             path[i + 2] = { 32,16 };

  1281.             path[i + 3] = { 32,18 };

  1282.             //path[i + 3] = { 27,10 };

  1283.             pathlength += 4;

  1284.             int bug = pathlength;

  1285.             for (i = bug; i < bug + strlen(path6to3_6); i++, j++, pathlength++)

  1286.             {

  1287.                 path[i] = TB6node[(int)path6to3_6[j] - 48];

  1288.             }

  1289.             pathlength = length + 5;

  1290.             api.Print(fmt::format("pathlength:{}", pathlength));

  1291.             path[pathlength - 1] = { destX,destY };/**/

  1292.         }

  1293.         else if (origArea == 6 && destArea == 3)//六教到三教

  1294.         {

  1295.             const char* path6to3_6 = PathInAnArea(api, origX, origY, 32, 18, 6);

  1296.             const char* path6to3_3 = PathInAnArea(api, 25, 10, destX, destY, 3);

  1297.             int i = 0, j = 0;

  1298.             int length = strlen(path6to3_3) + strlen(path6to3_6);

  1299.             for (i = 0; i < strlen(path6to3_6); i++)

  1300.             {

  1301.                 path[i] = TB6node[(int)path6to3_6[i] - 48];

  1302.                 pathlength++;

  1303.             }

  1304.             path[i] = { 32,18 };

  1305.             //path[i+1] = { 32,16 };

  1306.             path[i + 1] = { 31,13 };

  1307.             path[i + 2] = { 27,10 };

  1308.             path[i + 3] = { 25,10 };

  1309.             pathlength += 4;

  1310.             int bug = pathlength;

  1311.             for (i = bug; i < bug + strlen(path6to3_3); i++, j++, pathlength++)

  1312.             {

  1313.                 path[i] = TB3node[(int)path6to3_3[j] - 48];

  1314.             }

  1315.             pathlength = length + 5;

  1316.             api.Print(fmt::format("pathlength:{}", pathlength));

  1317.             path[pathlength - 1] = { destX,destY };/**/

  1318.         }

  1319.         else if (origArea == 5 && destArea == 6)//五教到六教

  1320.         {

  1321.             const char* path5to6_5 = PathInAnArea(api, origX, origY, 17, 31, 5);

  1322.             const char* path5to6_6 = PathInAnArea(api, 27, 34, destX, destY, 6);

  1323.             int i = 0, j = 0;

  1324.             int length = strlen(path5to6_5) + strlen(path5to6_6);

  1325.             for (i = 0; i < strlen(path5to6_5); i++)

  1326.             {

  1327.                 path[i] = TB5node[(int)path5to6_5[i] - 48];

  1328.                 pathlength++;

  1329.             }

  1330. 

  1331.             path[i] = { 17,31 };

  1332.             path[i + 1] = { 17,29 };

  1333.             path[i + 2] = { 17,25 };

  1334.             path[i + 3] = { 22,25 };

  1335.             path[i + 4] = { 25,34 };

  1336.             pathlength += 5;

  1337.             int bug = pathlength;

  1338.             for (i = bug; i < bug + strlen(path5to6_6); i++, j++, pathlength++)

  1339.             {

  1340.                 path[i] = TB6node[(int)path5to6_6[j] - 48];

  1341.             }

  1342.             pathlength = length + 6;

  1343.             path[pathlength - 1] = { destX,destY };

  1344.         }

  1345.         else if (origArea == 6 && destArea == 5)//六教到五教

  1346.         {

  1347.             const char* path6to5_6 = PathInAnArea(api, origX, origY, 27, 34, 6);

  1348.             const char* path6to5_5 = PathInAnArea(api, 17, 31, destX, destY, 5);

  1349.             int i = 0, j = 0;

  1350.             int length = strlen(path6to5_5) + strlen(path6to5_6);

  1351.             for (i = 0; i < strlen(path6to5_6); i++)

  1352.             {

  1353.                 path[i] = TB6node[(int)path6to5_6[i] - 48];

  1354.                 pathlength++;

  1355.             }

  1356. 

  1357.             path[i] = { 25,34 };

  1358.             path[i + 1] = { 22,25 };

  1359.             path[i + 2] = { 17,25 };

  1360.             path[i + 3] = { 17,29 };

  1361.             path[i + 4] = { 17,31 };

  1362.             pathlength += 5;

  1363.             int bug = pathlength;

  1364.             for (i = bug; i < bug + strlen(path6to5_5); i++, j++, pathlength++)

  1365.             {

  1366.                 path[i] = TB5node[(int)path6to5_5[j] - 48];

  1367.             }

  1368.             pathlength = length + 6;

  1369.             path[pathlength - 1] = { destX,destY };

  1370.         }

  1371. 

  1372.         else if (origArea == 1)//如果起点是一教

  1373.         {

  1374.             MapNode* OrigArea = TB1node, * DestArea;

  1375.             WindowNode* DestWindow;

  1376.             switch (destArea)//选择合适的教室节点图

  1377.             {

  1378.             case 3:

  1379.             {DestWindow = TB3window;

  1380.             DestArea = TB3node;

  1381.             break; }

  1382.             case 5:

  1383.             {DestWindow = TB5window;

  1384.             DestArea = TB5node;

  1385.             break; }

  1386.             case 6:

  1387.             {DestWindow = TB6window;

  1388.             DestArea = TB6node;

  1389.             break; }

  1390.             case 1:

  1391.             {DestWindow = TB1window;

  1392.             DestArea = TB1node;

  1393.             break; }

  1394.             default:

  1395.             {DestWindow = { 0 };

  1396.             DestArea = { 0 };

  1397.             break; }

  1398.             }

  1399.             int windowNum = MostCloseWindow(origX, origY, destArea);

  1400.             const char* path2window = PathInAnArea(api, origX, origY, DestWindow[windowNum].x_out, DestWindow[windowNum].y_out, origArea);

  1401.             const char* pathwindow2dest = PathInAnArea(api, DestWindow[windowNum].x_in, DestWindow[windowNum].y_in, destX, destY, destArea);

  1402.             int i = 0, j = 0;

  1403.             int length = strlen(path2window) + strlen(pathwindow2dest);

  1404.             for (i = 0; i < strlen(path2window); i++)

  1405.             {

  1406.                 path[i] = OrigArea[(int)path2window[i] - 48];

  1407.                 pathlength++;

  1408.             }

  1409.             path[i] = { DestWindow[windowNum].x_out,DestWindow[windowNum].y_out };

  1410.             path[i + 1] = { DestWindow[windowNum].x_in,DestWindow[windowNum].y_in };

  1411.             pathlength += 2;

  1412.             int bug = pathlength;

  1413.             for (i = bug; i < bug + strlen(pathwindow2dest); i++, j++, pathlength++)

  1414.             {

  1415.                 path[i] = DestArea[(int)pathwindow2dest[j] - 48];

  1416.             }

  1417.             pathlength = length + 3;

  1418.             path[pathlength - 1] = { destX,destY };

  1419.         }

  1420.         else if (destArea == 1)//终点是一教

  1421.         {

  1422.             MapNode* OrigArea, * DestArea;

  1423.             WindowNode* OrigWindow;

  1424.             switch (origArea)//选择合适的教室节点图

  1425.             {

  1426.             case 3:

  1427.             {OrigWindow = TB3window;

  1428.             OrigArea = TB3node;

  1429.             break; }

  1430.             case 5:

  1431.             {OrigWindow = TB5window;

  1432.             OrigArea = TB5node;

  1433.             break; }

  1434.             case 6:

  1435.             {OrigWindow = TB6window;

  1436.             OrigArea = TB6node;

  1437.             break; }

  1438.             case 1:

  1439.             {OrigWindow = TB1window;

  1440.             OrigArea = TB1node;

  1441.             break; }

  1442.             default:

  1443.             {OrigWindow = { 0 };

  1444.             OrigArea = { 0 };

  1445.             break; }

  1446.             }

  1447.             switch (destArea)//选择合适的教室节点图

  1448.             {

  1449.             case 3:

  1450.             {DestArea = TB3node;

  1451.             break; }

  1452.             case 5:

  1453.             {DestArea = TB5node;

  1454.             break; }

  1455.             case 6:

  1456.             {DestArea = TB6node;

  1457.             break; }

  1458.             case 1:

  1459.             {DestArea = TB1node;

  1460.             break; }

  1461.             default:

  1462.             {DestArea = { 0 };

  1463.             break; }

  1464.             }

  1465.             int windowNum = MostCloseWindow(destX, destY, origArea);

  1466.             const char* path2window = PathInAnArea(api, origX, origY, OrigWindow[windowNum].x_in, OrigWindow[windowNum].y_in, origArea);

  1467.             const char* pathwindow2dest = PathInAnArea(api, OrigWindow[windowNum].x_out, OrigWindow[windowNum].y_out, destX, destY, destArea);

  1468.             int i = 0, j = 0;

  1469.             int length = strlen(path2window) + strlen(pathwindow2dest);

  1470.             for (i = 0; i < strlen(path2window); i++)

  1471.             {

  1472.                 path[i] = OrigArea[(int)path2window[i] - 48];

  1473.                 pathlength++;

  1474.             }

  1475.             path[i] = { OrigWindow[windowNum].x_in,OrigWindow[windowNum].y_in };

  1476.             path[i + 1] = { OrigWindow[windowNum].x_out,OrigWindow[windowNum].y_out };

  1477.             pathlength += 2;

  1478.             int bug = pathlength;

  1479.             for (i = bug; i < bug + strlen(pathwindow2dest); i++, j++, pathlength++)

  1480.             {

  1481.                 path[i] = DestArea[(int)pathwindow2dest[j] - 48];

  1482.             }

  1483.             pathlength = length + 3;

  1484.             path[pathlength - 1] = { destX,destY };

  1485.         }

  1486.         else

  1487.             api.Print("no path between orig and dest");

  1488.     }

  1489.     api.Print("Path has been updated!");

  1490.     for (int i = 0; i < pathlength; i++)//便于debug，在每次move的时候打印出路径

  1491.     {

  1492.         api.Print(fmt::format("path[{}]:{},{}", i, path[i].x, path[i].y));

  1493.     }

  1494.     FinalDestination = { destX,destY };

  1495.     api.Print(fmt::format("Destination:{},{}", destX, destY));

  1496.     Arrived = false;

  1497.     pathnum = 0;//可能会在之后带来问题

  1498. }

  1499. bool MoveAlongPath(IStudentAPI& api)//当到达目的地时返回true

  1500. {

  1501.     auto self = api.GetSelfInfo();

  1502.     if (!Arrived)//测试用片段，沿着path中的结点前进

  1503.     {

  1504.         int nowCount = api.GetFrameCount();//这一部分用来实现翻墙

  1505.         api.Print(fmt::format("{},{}", nowCount, lastSkipCount));

  1506.         if (BeStuck(api))

  1507.         {

  1508.             int selfx = self->x;

  1509.             int selfy = self->y;

  1510.             auto delta_x = path[pathnum].x - selfx;

  1511.             auto delta_y = path[pathnum].y - selfy;

  1512.             double ang = 0;

  1513.             ang = atan2(delta_y, delta_x);

  1514.             if (Stuck)

  1515.             {

  1516.                 ang += PI / 2.0;

  1517.                 Stuck = false;

  1518.             }

  1519.             else

  1520.             {

  1521.                 ang -= PI / 2.0;

  1522.                 Stuck = true;

  1523.             }

  1524.             api.Move(80, ang);

  1525.         }

  1526.         if (nowCount - lastSkipCount > 100)

  1527.         {

  1528.             if (api.SkipWindow().get())

  1529.             {

  1530.                 pathnum++;

  1531.                 Goto(api, path[pathnum].x, path[pathnum].y);

  1532.                 lastSkipCount = nowCount;

  1533.             }

  1534.         }

  1535.         if (map[path[pathnum].x][path[pathnum].y] == THUAI6::PlaceType::ClassRoom || map[path[pathnum].x][path[pathnum].y] == THUAI6::PlaceType::Gate)

  1536.         {

  1537.             if (!arriveAtMax(api, path[pathnum].x, path[pathnum].y))

  1538.             {

  1539.                 api.Print(fmt::format("TempDestination:{},{}", path[pathnum].x, path[pathnum].y));

  1540.                 Goto(api, path[pathnum].x, path[pathnum].y);

  1541.                 return false;

  1542.             }

  1543.             else

  1544.             {

  1545.                 if (pathnum < pathlength - 1)//如果到达了一个节点且路还没走完

  1546.                 {

  1547.                     pathnum++;

  1548.                     return false;

  1549.                 }

  1550.                 else//如果到达的是最后一个节点

  1551.                 {

  1552.                     api.Print("到达了最后一个节点");

  1553.                     Arrived = true;

  1554.                     return true;

  1555.                 }

  1556.             }

  1557.         }

  1558.         else

  1559.         {

  1560.             if (!arriveAt(api, path[pathnum].x, path[pathnum].y))

  1561.             {

  1562.                 api.Print(fmt::format("TempDestination:{},{}", path[pathnum].x, path[pathnum].y));

  1563.                 Goto(api, path[pathnum].x, path[pathnum].y);

  1564.                 return false;

  1565.             }

  1566.             else

  1567.             {

  1568.                 if (pathnum < pathlength - 1)//如果到达了一个节点且路还没走完

  1569.                 {

  1570.                     pathnum++;

  1571.                     return false;

  1572.                 }

  1573.                 else//如果到达的是最后一个节点

  1574.                 {

  1575.                     api.Print("到达了最后一个节点");

  1576.                     pathnum = 0;

  1577.                     pathlength = 0;

  1578.                     Arrived = true;

  1579.                     return true;

  1580.                     memset(path, 0, 100);

  1581.                 }

  1582.             }

  1583.         }

  1584.     }

  1585.     else

  1586.         return true;

  1587. }

  1588. bool MoveAlongPath(ITrickerAPI& api)//当到达目的地时返回true

  1589. {

  1590.     auto self = api.GetSelfInfo();

  1591.     if (!Arrived)//测试用片段，沿着path中的结点前进

  1592.     {

  1593.         int nowCount = api.GetFrameCount();//这一部分用来实现翻墙

  1594.         api.Print(fmt::format("{},{}", nowCount, lastSkipCount));

  1595.         if (BeStuck(api))

  1596.         {

  1597.             int selfx = self->x;

  1598.             int selfy = self->y;

  1599.             auto delta_x = path[pathnum].x - selfx;

  1600.             auto delta_y = path[pathnum].y - selfy;

  1601.             double ang = 0;

  1602.             ang = atan2(delta_y, delta_x);

  1603.             if (Stuck)

  1604.             {

  1605.                 ang += PI / 2.0;

  1606.                 Stuck = false;

  1607.             }

  1608.             else

  1609.             {

  1610.                 ang -= PI / 2.0;

  1611.                 Stuck = true;

  1612.             }

  1613.             api.Move(80, ang);

  1614.         }

  1615. 

  1616.         if (nowCount - lastSkipCount > 100)

  1617.         {

  1618.             if (api.SkipWindow().get())

  1619.             {

  1620.                 pathnum++;

  1621.                 Goto(api, path[pathnum].x, path[pathnum].y);

  1622.                 lastSkipCount = nowCount;

  1623.             }

  1624.         }

  1625.         if (!arriveAt(api, path[pathnum].x, path[pathnum].y))

  1626.         {

  1627.             api.Print(fmt::format("TempDestination:{},{}", path[pathnum].x, path[pathnum].y));

  1628.             Goto(api, path[pathnum].x, path[pathnum].y);

  1629.             return false;

  1630.         }

  1631.         else

  1632.         {

  1633.             if (pathnum < pathlength - 1)//如果到达了一个节点且路还没走完

  1634.             {

  1635.                 pathnum++;

  1636.                 Goto(api, path[pathnum].x, path[pathnum].y);

  1637.                 return false;

  1638.             }

  1639.             else//如果到达的是最后一个节点

  1640.             {

  1641.                 api.Print("到达了最后一个节点");

  1642.                 pathnum = 0;

  1643.                 pathlength = 0;

  1644.                 Arrived = true;

  1645.                 return true;

  1646.                 memset(path, 0, 100);

  1647.             }

  1648.         }

  1649.     }

  1650.     else

  1651.         return true;

  1652. }

  1653. bool MoveAlongClosedPath(ITrickerAPI& api)//当到达目的地时返回true

  1654. {

  1655.     auto self = api.GetSelfInfo();

  1656.     if (!Arrived)//测试用片段，沿着Closedpath中的结点前进

  1657.     {

  1658.         int nowCount = api.GetFrameCount();//这一部分用来实现翻墙

  1659.         api.Print(fmt::format("{},{}", nowCount, lastSkipCount));

  1660.         if (nowCount - lastSkipCount > 100)

  1661.         {

  1662.             if (api.SkipWindow().get())

  1663.             {

  1664.                 pathnum++;

  1665.                 Goto(api, path[pathnum].x, path[pathnum].y);

  1666.                 lastSkipCount = nowCount;

  1667.             }

  1668.         }

  1669.         if (BeStuck(api))

  1670.         {

  1671.             int selfx = self->x;

  1672.             int selfy = self->y;

  1673.             auto delta_x = ClosedTrickerPath[pathnum].x - selfx;

  1674.             auto delta_y = ClosedTrickerPath[pathnum].y - selfy;

  1675.             double ang = 0;

  1676.             ang = atan2(delta_y, delta_x);

  1677.             if (Stuck)

  1678.             {

  1679.                 ang += PI / 2.0;

  1680.                 Stuck = false;

  1681.             }

  1682.             else

  1683.             {

  1684.                 ang -= PI / 2.0;

  1685.                 Stuck = true;

  1686.             }

  1687.             api.Move(80, ang);

  1688.         }

  1689.         

  1690.         if (!arriveAt(api, ClosedTrickerPath[pathnum].x, ClosedTrickerPath[pathnum].y))

  1691.         {

  1692.             api.Print(fmt::format("TempDestination:{},{}", ClosedTrickerPath[pathnum].x, ClosedTrickerPath[pathnum].y));

  1693.             Goto(api, ClosedTrickerPath[pathnum].x, ClosedTrickerPath[pathnum].y);

  1694.             return false;

  1695.         }

  1696.         else

  1697.         {

  1698.             if (pathnum < Closedpathlength - 1)//如果到达了一个节点且路还没走完

  1699.             {

  1700.                 pathnum++;

  1701.                 Goto(api, ClosedTrickerPath[pathnum].x, ClosedTrickerPath[pathnum].y);

  1702.                 return false;

  1703.             }

  1704.             else//如果到达的是最后一个节点

  1705.             {

  1706.                 pathnum = 0;

  1707.                 Goto(api, ClosedTrickerPath[pathnum].x, ClosedTrickerPath[pathnum].y);

  1708.                 return false;

  1709.             }

  1710.         }

  1711.     }

  1712.     else

  1713.         return true;

  1714. }

  1715. bool MoveAlongClosedPath2(ITrickerAPI& api)//当到达目的地时返回true

  1716. {

  1717.     auto self = api.GetSelfInfo();

  1718.     if (!Arrived)//测试用片段，沿着Closedpath中的结点前进

  1719.     {

  1720.         int nowCount = api.GetFrameCount();//这一部分用来实现翻墙

  1721.         api.Print(fmt::format("{},{}", nowCount, lastSkipCount));

  1722.         if (nowCount - lastSkipCount > 100)

  1723.         {

  1724.             if (api.SkipWindow().get())

  1725.             {

  1726.                 pathnum++;

  1727.                 Goto(api, path[pathnum].x, path[pathnum].y);

  1728.                 lastSkipCount = nowCount;

  1729.             }

  1730.         }

  1731.         if (BeStuck(api))

  1732.         {

  1733.             int selfx = self->x;

  1734.             int selfy = self->y;

  1735.             auto delta_x = ClosedTrickerPath2[pathnum].x - selfx;

  1736.             auto delta_y = ClosedTrickerPath2[pathnum].y - selfy;

  1737.             double ang = 0;

  1738.             ang = atan2(delta_y, delta_x);

  1739.             if (Stuck)

  1740.             {

  1741.                 ang += PI / 2.0;

  1742.                 Stuck = false;

  1743.             }

  1744.             else

  1745.             {

  1746.                 ang -= PI / 2.0;

  1747.                 Stuck = true;

  1748.             }

  1749.             api.Move(80, ang);

  1750.         }

  1751. 

  1752.         if (!arriveAt(api, ClosedTrickerPath2[pathnum].x, ClosedTrickerPath2[pathnum].y))

  1753.         {

  1754.             api.Print(fmt::format("TempDestination:{},{}", ClosedTrickerPath2[pathnum].x, ClosedTrickerPath2[pathnum].y));

  1755.             Goto(api, ClosedTrickerPath2[pathnum].x, ClosedTrickerPath2[pathnum].y);

  1756.             return false;

  1757.         }

  1758.         else

  1759.         {

  1760.             if (pathnum < Closedpathlength2 - 1)//如果到达了一个节点且路还没走完

  1761.             {

  1762.                 pathnum++;

  1763.                 Goto(api, ClosedTrickerPath2[pathnum].x, ClosedTrickerPath2[pathnum].y);

  1764.                 return false;

  1765.             }

  1766.             else//如果到达的是最后一个节点

  1767.             {

  1768.                 pathnum = 0;

  1769.                 Goto(api, ClosedTrickerPath2[pathnum].x, ClosedTrickerPath2[pathnum].y);

  1770.                 return false;

  1771.             }

  1772.         }

  1773.     }

  1774.     else

  1775.         return true;

  1776. }

  1777. bool MoveAlongSettedPath(IStudentAPI& api)//当到达目的地时返回true

  1778. {

  1779.     auto self = api.GetSelfInfo();

  1780.     int id = self->playerID;

  1781.     if (!Arrived1)//测试用片段，沿着path中的结点前进

  1782.     {

  1783.         int nowCount = api.GetFrameCount();//这一部分用来实现翻墙

  1784.         api.Print(fmt::format("{},{}", nowCount, lastSkipCount));

  1785.         if (BeStuck(api))

  1786.         {

  1787.             int selfx = self->x;

  1788.             int selfy = self->y;

  1789.             auto delta_x = (Ppath[id] + pathnum)->x - GridToCell(selfx);

  1790.             auto delta_y = (Ppath[id] + pathnum)->y - GridToCell(selfy);

  1791.             double ang = 0;

  1792.             ang = atan2(delta_y, delta_x);

  1793.             if (Stuck)

  1794.             {

  1795.                 ang += PI / 2.0;

  1796.                 Stuck = false;

  1797.             }

  1798.             else

  1799.             {

  1800.                 ang -= PI / 2.0;

  1801.                 Stuck = true;

  1802.             }

  1803.             api.Move(80, ang);

  1804.         }

  1805.         if (nowCount - lastSkipCount > 100)

  1806.         {

  1807.             if (api.SkipWindow().get())

  1808.             {

  1809.                 pathnum++;

  1810.                 Goto(api, path[pathnum].x, path[pathnum].y);

  1811.                 lastSkipCount = nowCount;

  1812.             }

  1813.         }

  1814.         

  1815.         if (!arriveAt(api, (Ppath[id]+pathnum)->x, (Ppath[id] + pathnum)->y))

  1816.         {

  1817.             //api.Print(fmt::format("TempDestination:{},{}", path[pathnum].x, path[pathnum].y));

  1818.             Goto(api, (Ppath[id] + pathnum)->x, (Ppath[id] + pathnum)->y);

  1819.             return false;

  1820.         }

  1821.         else

  1822.         {

  1823.             if (pathnum < PathforLength[id]-1)//如果到达了一个节点且路还没走完

  1824.             {

  1825.                 pathnum++;

  1826.                 return false;

  1827.             }

  1828.             else//如果到达的是最后一个节点

  1829.             {

  1830.                 api.Print("到达了最后一个节点");

  1831.                 pathnum = 0;

  1832.                 pathlength = 0;

  1833.                 Arrived1 = true;

  1834.                 return true;

  1835.                 memset(path, 0, 100);

  1836.                 api.UseSkill(0);

  1837.             }

  1838.         }

  1839.     }

  1840.     else

  1841.         return true;

  1842. }

  1843. bool MoveAlongSettedPath2(IStudentAPI& api)//当到达目的地时返回true

  1844. {

  1845.     auto self = api.GetSelfInfo();

  1846.     int id = self->playerID;

  1847.     if (!Arrived1)//测试用片段，沿着path中的结点前进

  1848.     {

  1849.         int nowCount = api.GetFrameCount();//这一部分用来实现翻墙

  1850.         api.Print(fmt::format("{},{}", nowCount, lastSkipCount));

  1851.         if (BeStuck(api))

  1852.         {

  1853.             int selfx = self->x;

  1854.             int selfy = self->y;

  1855.             auto delta_x = (Ppath2[id] + pathnum)->x - selfx;

  1856.             auto delta_y = (Ppath2[id] + pathnum)->y - selfy;

  1857.             double ang = 0;

  1858.             ang = atan2(delta_y, delta_x);

  1859.             if (Stuck)

  1860.             {

  1861.                 ang += PI / 2.0;

  1862.                 Stuck = false;

  1863.             }

  1864.             else

  1865.             {

  1866.                 ang -= PI / 2.0;

  1867.                 Stuck = true;

  1868.             }

  1869.             api.Move(80, ang);

  1870.         }

  1871.         if (nowCount - lastSkipCount > 100)

  1872.         {

  1873.             if (api.SkipWindow().get())//没用

  1874.             {

  1875.                 pathnum++;

  1876.                 Goto(api, path[pathnum].x, path[pathnum].y);

  1877.                 lastSkipCount = nowCount;

  1878.             }

  1879.         }

  1880. 

  1881. 

  1882. 

  1883.         if (!arriveAt(api, (Ppath2[id] + pathnum)->x, (Ppath2[id] + pathnum)->y))

  1884.         {

  1885.             //api.Print(fmt::format("TempDestination:{},{}", path[pathnum].x, path[pathnum].y));

  1886.             Goto(api, (Ppath2[id] + pathnum)->x, (Ppath2[id] + pathnum)->y);

  1887.             return false;

  1888.         }

  1889.         else

  1890.         {

  1891.             if (pathnum < PathforLength2[id] - 1)//如果到达了一个节点且路还没走完

  1892.             {

  1893.                 pathnum++;

  1894.                 return false;

  1895.             }

  1896.             else//如果到达的是最后一个节点

  1897.             {

  1898.                 api.Print("到达了最后一个节点");

  1899.                 pathnum = 0;

  1900.                 pathlength = 0;

  1901.                 Arrived1 = true;

  1902.                 return true;

  1903.                 memset(path, 0, 100);

  1904.                 api.UseSkill(0);

  1905.             }

  1906.         }

  1907. 

  1908.     }

  1909.     else

  1910.         return true;

  1911. }

  1912. 

  1913. int MostCloseWindow(int x, int y, int AreaNum)//返回最近的窗子的数组下标索引,不考虑墙的遮挡

  1914. {

  1915.     WindowNode* areanode;

  1916.     int Windownum, result = -1;

  1917.     switch (AreaNum)//选择合适的教室节点图

  1918.     {

  1919.     case 3:

  1920.     {areanode = TB3window;

  1921.     Windownum = TB3windowNum;

  1922.     break; }

  1923.     case 5:

  1924.     {areanode = TB5window;

  1925.     Windownum = TB5windowNum;

  1926.     break; }

  1927.     case 6:

  1928.     {areanode = TB6window;

  1929.     Windownum = TB6windowNum;

  1930.     break; }

  1931.     case 1:

  1932.     {areanode = TB1window;

  1933.     Windownum = TB1windowNum;

  1934.     break; }

  1935.     default:

  1936.     {areanode = { 0 };

  1937.     Windownum = 0;

  1938.     break; }

  1939.     }

  1940.     double dis, min_dis = 100;

  1941.     for (int i = 0; i < Windownum; i++)

  1942.     {

  1943.         double x_p = areanode[i].x_out;

  1944.         double y_p = areanode[i].y_out;

  1945.         dis = sqrt((x - x_p) * (x - x_p) + (y - y_p) * (y - y_p));

  1946.         if (dis < min_dis)

  1947.         {

  1948.             min_dis = dis;

  1949.             result = i;

  1950.         }

  1951.     }

  1952.     return result;

  1953. }

  1954. Classroom *ChooseAClassroom(IStudentAPI& api, int x, int y,int ID)//寻找未写完的最近的作业(先在同一个区域找，若没有，在所有区域找）

  1955. {

  1956.     Classroom *dest=&TB3[1];

  1957.     int area = GetArea(x, y);   //获取现在所处位置所在的区域

  1958.     int flag = 1;

  1959.     double dis, min_dis = 100;

  1960.     switch (area)

  1961.     {

  1962.     case 3:

  1963.     

  1964.     {for (int i = 0; i < 3; ++i)       //看三教中所有的作业

  1965.     {

  1966.         //api.Print(fmt::format("progress{}", TB3[i].progress));

  1967.         if (TB3[i].progress != Constants::maxClassroomProgress)  //如果有作业没写完

  1968.         {

  1969.             //api.Print("into the if");

  1970.             dis = GetDistance(x, y, TB3[i].xy[ID].x, TB3[i].xy[ID].y);

  1971.             if (dis < min_dis)

  1972.             {

  1973.                 min_dis = dis;

  1974.                 dest = &TB3[i];

  1975.             }

  1976.             flag = 0;

  1977.         }

  1978.     }

  1979.     break;

  1980.     }

  1981.     case 5:

  1982.     

  1983.     {for (int i = 0; i < 3; ++i)       //看五教中所有的作业

  1984.         {

  1985.             if (TB5[i].progress != Constants::maxClassroomProgress)  //如果有作业没写完

  1986.             {

  1987.                 dis = GetDistance(x, y, TB5[i].xy[ID].x, TB5[i].xy[ID].y);

  1988.                 if (dis < min_dis)

  1989.                 {

  1990.                     min_dis = dis;

  1991.                     dest = &TB5[i];

  1992.                 }

  1993.                 flag = 0;

  1994.             }

  1995.         }

  1996.         break; }

  1997.     case 6:

  1998.         //api.Print("finding in TB6");

  1999.     {for (int i = 0; i < 4; ++i)       //看六教中所有的作业

  2000.     {

  2001.         if (TB6[i].progress != Constants::maxClassroomProgress)  //如果有作业没写完

  2002.         {

  2003.             dis = GetDistance(x, y, TB6[i].xy[ID].x, TB6[i].xy[ID].y);

  2004.             if (dis < min_dis)

  2005.             {

  2006.                 min_dis = dis;

  2007.                 dest = &TB6[i];

  2008.             }

  2009.             flag = 0;

  2010.         }

  2011.     }

  2012.     break; }

  2013.     case 1:

  2014.         //api.Print("finding in TB1");

  2015.     {for (int i = 0; i < 3; ++i)       //看三教中所有的作业

  2016.     {

  2017.         if (TB3[i].progress != Constants::maxClassroomProgress)  //如果有作业没写完

  2018.         {

  2019.             dis = GetDistance(x, y, TB3[i].xy[ID].x, TB3[i].xy[ID].y);

  2020.             if (dis < min_dis)

  2021.             {

  2022.                 min_dis = dis;

  2023.                 dest = &TB3[i];

  2024.             }

  2025.             flag = 0;

  2026.         }

  2027.     }

  2028.     for (int i = 0; i < 3; ++i)       //看五教中所有的作业

  2029.     {

  2030.         if (TB5[i].progress != Constants::maxClassroomProgress)  //如果有作业没写完

  2031.         {

  2032.             dis = GetDistance(x, y, TB5[i].xy[ID].x, TB5[i].xy[ID].y);

  2033.             if (dis < min_dis)

  2034.             {

  2035.                 min_dis = dis;

  2036.                 dest = &TB5[i];

  2037.             }

  2038.             flag = 0;

  2039.         }

  2040.     }

  2041.     for (int i = 0; i < 4; ++i)       //看六教中所有的作业

  2042.     {

  2043.         if (TB6[i].progress != Constants::maxClassroomProgress)  //如果有作业没写完

  2044.         {

  2045.             dis = GetDistance(x, y, TB6[i].xy[ID].x, TB6[i].xy[ID].y);

  2046.             if (dis < min_dis)

  2047.             {

  2048.                 min_dis = dis;

  2049.                 dest = &TB6[i];

  2050.             }

  2051.             flag = 0;

  2052.         }

  2053.     }

  2054.     break; }

  2055.     default:

  2056.         break;

  2057.     }           //switch结构完成

  2058.     if (flag)   //flag仍为1，即没找到所在区域未完成的作业，或作业已全部被完成

  2059.     {

  2060.         //api.Print("在自己的区域没找到");

  2061.         for (int i = 0; i < 3; ++i)       //看三教中所有的作业

  2062.         {

  2063.             if (TB3[i].progress != Constants::maxClassroomProgress)  //如果有作业没写完

  2064.             {

  2065.                 dis = GetDistance(x, y, TB3[i].xy[ID].x, TB3[i].xy[ID].y);

  2066.                 if (dis < min_dis)

  2067.                 {

  2068.                     min_dis = dis;

  2069.                     dest = &TB3[i];

  2070.                 }

  2071.                 flag = 0;

  2072.             }

  2073.         }

  2074.         for (int i = 0; i < 3; ++i)       //看五教中所有的作业

  2075.         {

  2076.             if (TB5[i].progress != Constants::maxClassroomProgress)  //如果有作业没写完

  2077.             {

  2078.                 dis = GetDistance(x, y, TB5[i].xy[ID].x, TB5[i].xy[ID].y);

  2079.                 if (dis < min_dis)

  2080.                 {

  2081.                     min_dis = dis;

  2082.                     dest = &TB5[i];

  2083.                 }

  2084.                 flag = 0;

  2085.             }

  2086.         }

  2087.         for (int i = 0; i < 4; ++i)       //看六教中所有的作业

  2088.         {

  2089.             if (TB6[i].progress != Constants::maxClassroomProgress)  //如果有作业没写完

  2090.             {

  2091.                 dis = GetDistance(x, y, TB6[i].xy[ID].x, TB6[i].xy[ID].y);

  2092.                 if (dis < min_dis)

  2093.                 {

  2094.                     min_dis = dis;

  2095.                     dest = &TB6[i];

  2096.                 }

  2097.                 flag = 0;

  2098.             }

  2099.         }//再全看一遍，确保若flag仍为1则全部作业已被完成

  2100.     }

  2101.     return dest;

  2102. }

  2103. Gate *ChooseAGate(IStudentAPI& api, int x, int y)

  2104. {

  2105.     for (int i = 2; i < 6; i++)//先刷新所有校门的状态

  2106.     {

  2107.         gate[i].Status = (int)api.GetHiddenGateState(gate[i].xy.x, gate[i].xy.y);

  2108.         api.Print(fmt::format("gate[{}]status:{}", i, gate[i].Status));

  2109.     }

  2110.     double dis, min_dis = 100;

  2111.     int result = 0;

  2112.     for (int i = 0; i < 6; i++)

  2113.     {

  2114.         double x_p = gate[i].xy.x;

  2115.         double y_p = gate[i].xy.y;

  2116.         dis = sqrt((x - x_p) * (x - x_p) + (y - y_p) * (y - y_p));

  2117.         if (dis < min_dis&&gate[i].Status==1)

  2118.         {

  2119.             min_dis = dis;

  2120.             result = i;

  2121.         }

  2122.     }

  2123.     api.Print(fmt::format("Gate[{}]", result));

  2124.     return &gate[result];

  2125. }

  2126. int ChooseAnArea(ITrickerAPI& api)

  2127. {

  2128.     //暂时根据离得最近的窗子去选择，后续要调整，优化算法

  2129.     auto self = api.GetSelfInfo();

  2130.     int result,windowNum;

  2131.     windowNum = MostCloseWindow(GridToCell(self->x), GridToCell(self->y),1);

  2132.     if (windowNum <= 3)

  2133.         result = 3;

  2134.     else if (windowNum >= 7)

  2135.         result = 6;

  2136.     else

  2137.         result = 3;//先不去五教

  2138.     return result;

  2139. }

  2140. 

  2141. void InitMap(IAPI& api)

  2142. {

  2143.     int i, j;

  2144.     auto mapinfo = api.GetFullMap();

  2145.     for (i = 0; i < 50; i++)

  2146.         for (j = 0; j < 50; j++)

  2147.         {

  2148.             map[i][j] = mapinfo[i][j];

  2149.         }

  2150.     api.Wait();

  2151. }

  2152. void SetStatus(ITrickerAPI& api)

  2153. {

  2154.     auto self = api.GetSelfInfo();

  2155.     auto students = api.GetStudents();

  2156.     auto GameInfo = api.GetGameInfo();

  2157.     auto bulletType = self->bulletType;

  2158.     api.Print(fmt::format("BulletType:{}", THUAI6::bulletTypeDict[bulletType]));

  2159.     api.Print(fmt::format("StudentNum:{}", students.size()));

  2160.     if (BeLongStuck(api)&&Tricker1Status==TrickerStatus::Searching)

  2161.     {

  2162.         StatusIsSearching = false;

  2163.     }

  2164.     

  2165.         if (MostCloseStudent(api) != -1)

  2166.         {

  2167.             Tricker1Status = TrickerStatus::Tracing;

  2168.             StatusIsSearching = false;//说明这次setstatus现在的状态不是searching

  2169.             int closednum = MostCloseStudent(api);

  2170.             ClosedStudent = { students[closednum]->x, students[closednum]->y };

  2171.             if (GetDistance(self->x, self->y, students[closednum]->x, students[closednum]->y) < AttackRange[(int)self->bulletType] - 1000)

  2172.             {

  2173.                 Tricker1Status = TrickerStatus::Attaking;

  2174.             }

  2175. 

  2176.         }

  2177.         else if (students.size()==0&&self->trickDesire>16)

  2178.         {

  2179.             api.Print("Special sign");

  2180.                 Tricker1Status = TrickerStatus::Attaking;

  2181.         }

  2182.         else

  2183.         {

  2184.             if (FinishedClassroom > 7)

  2185.             {

  2186.                 Tricker1Status = TrickerStatus::GotoGate;

  2187.                 StatusIsSearching = false;

  2188.             }

  2189.             Tricker1Status = TrickerStatus::Searching;

  2190.         }

  2191.     api.Print(fmt::format("Status:{}", (int)Tricker1Status));

  2192. }

  2193. void SetStatus(IStudentAPI& api)

  2194. {

  2195.     

  2196. }

  2197. void UpdateInfo(IStudentAPI& api)

  2198. {

  2199.     auto self = api.GetSelfInfo();

  2200.     auto tricker = api.GetTrickers();

  2201.     auto students = api.GetStudents();

  2202.     //更新作业状态

  2203.     FinishedClassroom = 0;

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

  2205.     {

  2206.         if (TB3[i].progress == 10000000)

  2207.             FinishedClassroom += 1;

  2208.             

  2209.     }

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

  2211.     {

  2212.         if (TB5[i].progress == 10000000)

  2213.             FinishedClassroom += 1;

  2214.     }

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

  2216.     {

  2217.         if (TB6[i].progress == 10000000)

  2218.             FinishedClassroom += 1;

  2219.     }

  2220.     //更新宝箱状态

  2221.     

  2222. }

  2223. void UpdateInfo(ITrickerAPI& api,int ID)

  2224. {

  2225.     auto self = api.GetSelfInfo();

  2226.     auto Students = api.GetTrickers();

  2227.     auto GameInfo = api.GetGameInfo();

  2228.     //更新作业状态

  2229.     FinishedClassroom = 0;

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

  2231.     {

  2232.         TB3[i].progress = api.GetClassroomProgress(TB3[i].xy[ID].x, TB3[i].xy[ID].y);

  2233.         if (TB3[i].progress == 10000000)

  2234.         {

  2235.             TB3FinishedClassroom += 1;

  2236.         }

  2237. 

  2238.     }

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

  2240.     {

  2241.         TB5[i].progress = api.GetClassroomProgress(TB5[i].xy[ID].x, TB5[i].xy[ID].y);

  2242.         if (TB5[i].progress == 10000000)

  2243.         {

  2244.             TB5FinishedClassroom += 1;

  2245.         }

  2246.     }

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

  2248.     {

  2249.         TB6[i].progress = api.GetClassroomProgress(TB6[i].xy[ID].x, TB6[i].xy[ID].y);

  2250.         if (TB6[i].progress == 10000000)

  2251.         {

  2252.             TB6FinishedClassroom += 1;

  2253.         }

  2254.     }

  2255.     FinishedClassroom = GameInfo->subjectFinished;

  2256.     //更新宝箱状态

  2257. 

  2258. }

  2259. 

  2260. void DealingWithMessages(IStudentAPI& api)

  2261. {

  2262.     if (api.HaveMessage())

  2263.     {

  2264.         auto mes = api.GetMessage();

  2265.         api.Print("GotMessage");

  2266.         char c1 = mes.second[0];      //mes类型的第二个参数是一个string类对象,其第一个元素是信息类型       

  2267.         if (c1 == '0')    //根据第一个字符来确定类型，'0'类型是关于作业的

  2268.         {

  2269.             char c2 = mes.second[1];         //string类对象的第二个元素是作业序号

  2270.             int num = (int)c2 - 48;          //字符转数字

  2271.             int len = mes.second.length();   //字符串的长度

  2272.             char* c3 = new char[len - 1];    //减去前两位，再给结束符留一个位置，所以是len-1

  2273.             strcpy(c3, mes.second.c_str() + 2);    //不能直接用c3=mes.second.c_str()，否则析构时会被破坏

  2274.             long newprogress = atol(c3);                    //转成长整型，不能是整型，否则位数不够

  2275.             (*AllClassroom[num]).progress = newprogress;    //只改进度就行，作业坐标不会变

  2276.         }

  2277.         else if (c1 == '1')

  2278.         {

  2279. 

  2280.         }

  2281.     }

  2282. }

  2283. int MostCloseStudent(ITrickerAPI &api)

  2284. {

  2285.     auto self = api.GetSelfInfo();

  2286.     auto students = api.GetStudents();

  2287.     int num = students.size();

  2288.     int result = -1;

  2289.     double dis,min_dis=100000;

  2290.     for (int i = 0; i < num; i++)

  2291.     {

  2292.         dis = sqrt((self->x - students[i]->x) * (self->x - students[i]->x) + (self->y - students[i]->y) * (self->y - students[i]->y));

  2293.         if (dis < min_dis)

  2294.         {

  2295.             api.Print(fmt::format("Student[{}]Determination:{}", i, students[i]->determination));

  2296.             if (students[i]->determination > 0)

  2297.             {

  2298.                 min_dis = dis;

  2299.                 result = i;

  2300.             }

  2301.         }

  2302.         api.Print(fmt::format("MostCloseStudent return {}", result));

  2303.     }

  2304.     return result;

  2305. }

  2306. bool BeStuck(ITrickerAPI& api)

  2307. {

  2308.     int nowStayCount = api.GetFrameCount();

  2309.     api.Print(fmt::format("{},{}", nowStayCount, lastStayCount));

  2310.     auto self = api.GetSelfInfo();

  2311.     bool flag = 0;

  2312.     MapNode newposition = { GridToCell(self->x),GridToCell(self->y) };

  2313.     if (nowStayCount - lastStayCount > 13)

  2314.     {

  2315.         if (lastposition == newposition && self->playerState == THUAI6::PlayerState::Idle)

  2316.         {

  2317.             flag = 1;

  2318.             api.Print("BeStuck!!!!");

  2319.         }

  2320.         lastStayCount = nowStayCount;

  2321.         lastposition = newposition;

  2322.     }

  2323.     return flag;

  2324. }

  2325. bool BeStuck(IStudentAPI & api)

  2326. {

  2327.     int nowStayCount = api.GetFrameCount();

  2328.     api.Print(fmt::format("{},{}", nowStayCount, lastStayCount));

  2329.     auto self = api.GetSelfInfo();

  2330.     bool flag = 0;

  2331.     MapNode newposition = { GridToCell(self->x),GridToCell(self->y) };

  2332.     if (nowStayCount - lastStayCount > 13)

  2333.     {

  2334.         if (lastposition == newposition && self->playerState == THUAI6::PlayerState::Idle)

  2335.         {

  2336.             flag = 1;

  2337.             api.Print("BeStuck!!!!");

  2338.         }

  2339.         lastStayCount = nowStayCount;

  2340.         lastposition = newposition;

  2341.     }

  2342.     return flag;

  2343. }

  2344. int lastStayCount1 = 0;

  2345. bool BeLongStuck(ITrickerAPI& api)

  2346. {

  2347.     int nowStayCount = api.GetFrameCount();

  2348.     api.Print(fmt::format("{},{}", nowStayCount, lastStayCount1));

  2349.     auto self = api.GetSelfInfo();

  2350.     bool flag = 0;

  2351.     MapNode newposition = { GridToCell(self->x),GridToCell(self->y) };

  2352.     if (nowStayCount - lastStayCount1 > 50)

  2353.     {

  2354.         if (lastposition1 == newposition && self->playerState == THUAI6::PlayerState::Idle)

  2355.         {

  2356.             flag = 1;

  2357.             api.Print("BeLongStuck!!!!");

  2358.         }

  2359.         lastStayCount1 = nowStayCount;

  2360.         lastposition1 = newposition;

  2361.     }

  2362.     return flag;

  2363. }

  2364. 

  2365. void UsingSkills(IStudentAPI &api)

  2366. {

  2367.     auto self = api.GetSelfInfo();

  2368.     switch (self->studentType)

  2369.     {

  2370.     case THUAI6::StudentType::StraightAStudent:

  2371.     {

  2372.         break;

  2373.     }

  2374. 

  2375.     };

  2376. }//暂时没用到

  2377. bool ifarrived = true;//调试用变量，不重要

  2378. 

  2379. /*供调试所用代码合集

  2380. （1）设置一个path并查看

  2381.     InitMap(api);

  2382.     SetPath(api, 35, 24, 28, 26);

  2383.     for (int i = 0; i < pathnum; i++)

  2384.     {

  2385.         api.Print(fmt::format("{},{}", path[i].x, path[i].y));

  2386.     }

  2387. （2）设置一个path并沿着这条路走

  2388.     if (ifarrived)

  2389.         {

  2390.             SetPath(api, GridToCell(self->x), GridToCell(self->y), 4, 14);

  2391.             ifarrived = false;

  2392.         }

  2393.     if(!Arrived)

  2394.         MoveAlongPath(api);

  2395. （3）

  2396. */

  2397. bool test = true;

  2398. bool test1 = true;

  2399. bool test2 = true;

  2400. 

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

  2402. {

  2403.     // 公共操作

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

  2405.     {

  2406.         InitMap(api);

  2407.         if (map[20][20] == THUAI6::PlaceType::Wall)

  2408.         {

  2409.             int ID = 0;

  2410.             auto self = api.GetSelfInfo();

  2411.             auto tricker = api.GetTrickers();

  2412.             auto GAME = api.GetGameInfo();

  2413.             api.Print(fmt::format("GameTime:{}", GAME->gameTime));

  2414. 

  2415.             NowArea = GetArea(GridToCell(self->x), GridToCell(self->y));

  2416.             UpdateInfo(api);

  2417.             api.Print(fmt::format("cell:{},{}", (Ppath[ID] + PathforLength[ID] - 1)->x, (Ppath[ID] + PathforLength[ID] - 1)->y));

  2418.             if (GAME->gameTime < 580000)

  2419.             {

  2420.                 if (test)

  2421.                 {

  2422.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), 46, 7);

  2423.                     test = false;

  2424.                 }

  2425.                 Stu1Status = StudentStatus::GoToWaitingPoint;

  2426.             }

  2427.             else

  2428.             {

  2429.                 Stu1Status = StudentStatus::GoToStudy;

  2430.             }

  2431.             SetStatus(api);//空的

  2432.             DealingWithMessages(api);

  2433.             UsingSkills(api);//空的

  2434.             api.Print(fmt::format("Status:{}", (int)Stu1Status));

  2435. 

  2436.             switch (Stu1Status)

  2437.             {

  2438.             case StudentStatus::Init:

  2439.             {InitMap(api);

  2440.             Stu1Status = StudentStatus::WantToStudy;

  2441.             break; }

  2442. 

  2443.             case StudentStatus::WantToStudy:

  2444.             {

  2445. 

  2446.                 TempClassroom = ChooseAClassroom(api, GridToCell(self->x), GridToCell(self->y), 0);

  2447.                 api.Print(fmt::format("Tempclassroom{}", TempClassroom->id));

  2448.                 MapNode NewDestination = TempClassroom->xy[this->playerID];

  2449.                 if (NewDestination != FinalDestination)

  2450.                 {

  2451.                     //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  2452.                     pathnum = 0;

  2453.                     pathlength = 0;

  2454.                     memset(path, 0, 100);

  2455. 

  2456.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination.x, NewDestination.y);

  2457.                 }

  2458.                 if (MoveAlongPath(api))

  2459.                 {

  2460.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  2461.                     {

  2462.                         api.UseSkill(0);

  2463.                     }

  2464.                     Stu1Status = StudentStatus::Studying;

  2465.                 };

  2466.                 if (FinishedClassroom >= 7)

  2467.                 {

  2468.                     Stu1Status = StudentStatus::WantToGraduate;

  2469.                 }

  2470.                 break; }

  2471. 

  2472.             case StudentStatus::Studying:

  2473.             {

  2474.                 api.Print(fmt::format("TempClassroom:{},{},progress{}", TempClassroom->realxy.x, TempClassroom->realxy.y, TempClassroom->progress));

  2475.                 TempClassroom->progress = api.GetClassroomProgress(TempClassroom->realxy.x, TempClassroom->realxy.y);

  2476.                 if (TempClassroom->progress < 10000000)

  2477.                 {

  2478.                     api.StartLearning();

  2479.                     //api.EndAllAction();

  2480.                 }

  2481.                 else

  2482.                 {

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

  2484.                     {

  2485.                         api.SendTextMessage(i, fmt::format("0{}{}", TempClassroom->id, TempClassroom->progress));

  2486.                         api.Print(fmt::format("SEND MESSAGE:0{}{}", TempClassroom->id, TempClassroom->progress));

  2487.                     }

  2488.                     Stu1Status = StudentStatus::WantToStudy;

  2489.                 };

  2490.                 if (FinishedClassroom >= 7)

  2491.                 {

  2492.                     Stu1Status = StudentStatus::WantToGraduate;

  2493.                 }

  2494.                 break; }

  2495.             case StudentStatus::WantToGraduate://需要仿照wanttostudy写

  2496.             { TempGate = ChooseAGate(api, GridToCell(self->x), GridToCell(self->y));

  2497.             MapNode NewDestination1 = (*TempGate).xy;

  2498.             if (NewDestination1 != FinalDestination)

  2499.             {

  2500.                 //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  2501.                 pathnum = 0;

  2502.                 pathlength = 0;

  2503.                 memset(path, 0, 100);

  2504. 

  2505.                 SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination1.x, NewDestination1.y);

  2506.             }

  2507.             if (MoveAlongPath(api))

  2508.             {

  2509.                 Stu1Status = StudentStatus::Graduating;

  2510.             };

  2511.             break; }

  2512.             case StudentStatus::Graduating:

  2513.                 //先更新大门的进度

  2514.             {(*TempGate).progress = api.GetGateProgress(ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.x, ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.y);

  2515.             if (TempGate->progress < 18000)

  2516.             {

  2517.                 api.StartOpenGate();

  2518.             }

  2519.             else

  2520.             {

  2521.                 api.Graduate();

  2522.             }

  2523.             break; }

  2524.             case StudentStatus::GoToWaitingPoint:

  2525.             {

  2526.                 MoveAlongPath(api);

  2527.                 break;

  2528.             }

  2529.             case StudentStatus::GoToStudy:

  2530.             {

  2531.                 if (MoveAlongSettedPath(api))

  2532.                 {

  2533.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  2534.                     {

  2535.                         api.UseSkill(0);

  2536.                     }

  2537.                 };

  2538.                 break;

  2539.             }

  2540. 

  2541.             };

  2542.         }

  2543.         else

  2544.         {

  2545.             int ID = 0;

  2546.             auto self = api.GetSelfInfo();

  2547.             auto tricker = api.GetTrickers();

  2548.             auto GAME = api.GetGameInfo();

  2549.             api.Print(fmt::format("GameTime:{}", GAME->gameTime));

  2550. 

  2551.             NowArea = GetArea(GridToCell(self->x), GridToCell(self->y));//Wrong

  2552.             UpdateInfo(api);//Wrong

  2553.             api.Print(fmt::format("cell:{},{}", (Ppath[ID] + PathforLength[ID] - 1)->x, (Ppath[ID] + PathforLength[ID] - 1)->y));

  2554.             if (GAME->gameTime < 578000)

  2555.             {

  2556.                 if (test)

  2557.                 {

  2558.                     SetPath2(api, GridToCell(self->x), GridToCell(self->y), 6.2, 2.2);

  2559.                     test = false;

  2560.                 }

  2561.                 Stu1Status = StudentStatus::GoToWaitingPoint;

  2562.             }

  2563.             else

  2564.             {

  2565.                 Stu1Status = StudentStatus::GoToStudy;

  2566.             }

  2567.             SetStatus(api);//空的

  2568.             DealingWithMessages(api);

  2569.             UsingSkills(api);//空的

  2570.             api.Print(fmt::format("Status:{}", (int)Stu1Status));

  2571. 

  2572.             switch (Stu1Status)

  2573.             {

  2574.             case StudentStatus::Init:

  2575.             {InitMap(api);

  2576.             Stu1Status = StudentStatus::WantToStudy;

  2577.             break; }

  2578. 

  2579.             case StudentStatus::WantToStudy:

  2580.             {

  2581. 

  2582.                 TempClassroom = ChooseAClassroom(api, GridToCell(self->x), GridToCell(self->y), 0);

  2583.                 api.Print(fmt::format("Tempclassroom{}", TempClassroom->id));

  2584.                 MapNode NewDestination = TempClassroom->xy[this->playerID];

  2585.                 if (NewDestination != FinalDestination)

  2586.                 {

  2587.                     //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  2588.                     pathnum = 0;

  2589.                     pathlength = 0;

  2590.                     memset(path, 0, 100);

  2591. 

  2592.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination.x, NewDestination.y);

  2593.                 }

  2594.                 if (MoveAlongPath(api))

  2595.                 {

  2596.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  2597.                     {

  2598.                         api.UseSkill(0);

  2599.                     }

  2600.                     Stu1Status = StudentStatus::Studying;

  2601.                 };

  2602.                 if (FinishedClassroom >= 7)

  2603.                 {

  2604.                     Stu1Status = StudentStatus::WantToGraduate;

  2605.                 }

  2606.                 break; }

  2607. 

  2608.             case StudentStatus::Studying:

  2609.             {

  2610.                 api.Print(fmt::format("TempClassroom:{},{},progress{}", TempClassroom->realxy.x, TempClassroom->realxy.y, TempClassroom->progress));

  2611.                 TempClassroom->progress = api.GetClassroomProgress(TempClassroom->realxy.x, TempClassroom->realxy.y);

  2612.                 if (TempClassroom->progress < 10000000)

  2613.                 {

  2614.                     api.StartLearning();

  2615.                     //api.EndAllAction();

  2616.                 }

  2617.                 else

  2618.                 {

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

  2620.                     {

  2621.                         api.SendTextMessage(i, fmt::format("0{}{}", TempClassroom->id, TempClassroom->progress));

  2622.                         api.Print(fmt::format("SEND MESSAGE:0{}{}", TempClassroom->id, TempClassroom->progress));

  2623.                     }

  2624.                     Stu1Status = StudentStatus::WantToStudy;

  2625.                 };

  2626.                 if (FinishedClassroom >= 7)

  2627.                 {

  2628.                     Stu1Status = StudentStatus::WantToGraduate;

  2629.                 }

  2630.                 break; }

  2631.             case StudentStatus::WantToGraduate://需要仿照wanttostudy写

  2632.             { TempGate = ChooseAGate(api, GridToCell(self->x), GridToCell(self->y));

  2633.             MapNode NewDestination1 = (*TempGate).xy;

  2634.             if (NewDestination1 != FinalDestination)

  2635.             {

  2636.                 //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  2637.                 pathnum = 0;

  2638.                 pathlength = 0;

  2639.                 memset(path, 0, 100);

  2640. 

  2641.                 SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination1.x, NewDestination1.y);

  2642.             }

  2643.             if (MoveAlongPath(api))

  2644.             {

  2645.                 Stu1Status = StudentStatus::Graduating;

  2646.             };

  2647.             break; }

  2648.             case StudentStatus::Graduating:

  2649.                 //先更新大门的进度

  2650.             {(*TempGate).progress = api.GetGateProgress(ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.x, ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.y);

  2651.             if (TempGate->progress < 18000)

  2652.             {

  2653.                 api.StartOpenGate();

  2654.             }

  2655.             else

  2656.             {

  2657.                 api.Graduate();

  2658.             }

  2659.             break; }

  2660.             case StudentStatus::GoToWaitingPoint:

  2661.             {

  2662.                 MoveAlongPath(api);

  2663.                 break;

  2664.             }

  2665.             case StudentStatus::GoToStudy:

  2666.             {

  2667.                 if (MoveAlongSettedPath2(api))

  2668.                 {

  2669.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  2670.                     {

  2671.                         api.UseSkill(0);

  2672.                     }

  2673.                 };

  2674.                 break;

  2675.             }

  2676. 

  2677.             };

  2678.         }

  2679.     }

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

  2681.     {

  2682.         InitMap(api);

  2683.         if (map[20][20] == THUAI6::PlaceType::Wall)

  2684.         {

  2685.             int ID = 1;

  2686.             auto self = api.GetSelfInfo();

  2687.             auto tricker = api.GetTrickers();

  2688.             auto GAME = api.GetGameInfo();

  2689.             api.Print(fmt::format("GameTime:{}", GAME->gameTime));

  2690. 

  2691.             NowArea = GetArea(GridToCell(self->x), GridToCell(self->y));

  2692.             UpdateInfo(api);

  2693.             api.Print(fmt::format("cell:{},{}", (Ppath[ID] + PathforLength[ID] - 1)->x, (Ppath[ID] + PathforLength[ID] - 1)->y));

  2694.             if (GAME->gameTime < 590000)

  2695.             {

  2696.                 if (test)

  2697.                 {

  2698.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), 5, 34);

  2699.                     test = false;

  2700.                 }

  2701.                 Stu1Status = StudentStatus::GoToWaitingPoint;

  2702.             }

  2703.             else

  2704.             {

  2705.                 Stu1Status = StudentStatus::GoToStudy;

  2706.             }

  2707.             SetStatus(api);//空的

  2708.             DealingWithMessages(api);

  2709.             UsingSkills(api);//空的

  2710.             api.Print(fmt::format("Status:{}", (int)Stu1Status));

  2711. 

  2712.             switch (Stu1Status)

  2713.             {

  2714.             case StudentStatus::Init:

  2715.             {InitMap(api);

  2716.             Stu1Status = StudentStatus::WantToStudy;

  2717.             break; }

  2718. 

  2719.             case StudentStatus::WantToStudy:

  2720.             {

  2721. 

  2722.                 TempClassroom = ChooseAClassroom(api, GridToCell(self->x), GridToCell(self->y), 0);

  2723.                 api.Print(fmt::format("Tempclassroom{}", TempClassroom->id));

  2724.                 MapNode NewDestination = TempClassroom->xy[this->playerID];

  2725.                 if (NewDestination != FinalDestination)

  2726.                 {

  2727.                     //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  2728.                     pathnum = 0;

  2729.                     pathlength = 0;

  2730.                     memset(path, 0, 100);

  2731. 

  2732.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination.x, NewDestination.y);

  2733.                 }

  2734.                 if (MoveAlongPath(api))

  2735.                 {

  2736.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  2737.                     {

  2738.                         api.UseSkill(0);

  2739.                     }

  2740.                     Stu1Status = StudentStatus::Studying;

  2741.                 };

  2742.                 if (FinishedClassroom >= 7)

  2743.                 {

  2744.                     Stu1Status = StudentStatus::WantToGraduate;

  2745.                 }

  2746.                 break; }

  2747. 

  2748.             case StudentStatus::Studying:

  2749.             {

  2750.                 api.Print(fmt::format("TempClassroom:{},{},progress{}", TempClassroom->realxy.x, TempClassroom->realxy.y, TempClassroom->progress));

  2751.                 TempClassroom->progress = api.GetClassroomProgress(TempClassroom->realxy.x, TempClassroom->realxy.y);

  2752.                 if (TempClassroom->progress < 10000000)

  2753.                 {

  2754.                     api.StartLearning();

  2755.                     //api.EndAllAction();

  2756.                 }

  2757.                 else

  2758.                 {

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

  2760.                     {

  2761.                         api.SendTextMessage(i, fmt::format("0{}{}", TempClassroom->id, TempClassroom->progress));

  2762.                         api.Print(fmt::format("SEND MESSAGE:0{}{}", TempClassroom->id, TempClassroom->progress));

  2763.                     }

  2764.                     Stu1Status = StudentStatus::WantToStudy;

  2765.                 };

  2766.                 if (FinishedClassroom >= 7)

  2767.                 {

  2768.                     Stu1Status = StudentStatus::WantToGraduate;

  2769.                 }

  2770.                 break; }

  2771.             case StudentStatus::WantToGraduate://需要仿照wanttostudy写

  2772.             { TempGate = ChooseAGate(api, GridToCell(self->x), GridToCell(self->y));

  2773.             MapNode NewDestination1 = (*TempGate).xy;

  2774.             if (NewDestination1 != FinalDestination)

  2775.             {

  2776.                 //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  2777.                 pathnum = 0;

  2778.                 pathlength = 0;

  2779.                 memset(path, 0, 100);

  2780. 

  2781.                 SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination1.x, NewDestination1.y);

  2782.             }

  2783.             if (MoveAlongPath(api))

  2784.             {

  2785.                 Stu1Status = StudentStatus::Graduating;

  2786.             };

  2787.             break; }

  2788.             case StudentStatus::Graduating:

  2789.                 //先更新大门的进度

  2790.             {(*TempGate).progress = api.GetGateProgress(ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.x, ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.y);

  2791.             if (TempGate->progress < 18000)

  2792.             {

  2793.                 api.StartOpenGate();

  2794.             }

  2795.             else

  2796.             {

  2797.                 api.Graduate();

  2798.             }

  2799.             break; }

  2800.             case StudentStatus::GoToWaitingPoint:

  2801.             {

  2802.                 MoveAlongPath(api);

  2803.                 break;

  2804.             }

  2805.             case StudentStatus::GoToStudy:

  2806.             {

  2807.                 if (MoveAlongSettedPath(api))

  2808.                 {

  2809.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  2810.                     {

  2811.                         api.UseSkill(0);

  2812.                     }

  2813.                 };

  2814.                 break;

  2815.             }

  2816. 

  2817.             };

  2818.         }

  2819.         else

  2820.         {

  2821.         int ID = 1;

  2822.         auto self = api.GetSelfInfo();

  2823.         auto tricker = api.GetTrickers();

  2824.         auto GAME = api.GetGameInfo();

  2825.         api.Print(fmt::format("GameTime:{}", GAME->gameTime));

  2826. 

  2827.         NowArea = GetArea(GridToCell(self->x), GridToCell(self->y));//Wrong

  2828.         UpdateInfo(api);//Wrong

  2829.         api.Print(fmt::format("cell:{},{}", (Ppath2[ID] + PathforLength[ID] - 1)->x, (Ppath2[ID] + PathforLength2[ID] - 1)->y));

  2830.         if (GAME->gameTime < 578000)

  2831.         {

  2832.             if (test)

  2833.             {

  2834.                 SetPath2(api, GridToCell(self->x), GridToCell(self->y), 6, 47);

  2835.                 test = false;

  2836.             }

  2837.             Stu1Status = StudentStatus::GoToWaitingPoint;

  2838.         }

  2839.         else

  2840.         {

  2841.             Stu1Status = StudentStatus::GoToStudy;

  2842.         }

  2843.         SetStatus(api);//空的

  2844.         DealingWithMessages(api);

  2845.         UsingSkills(api);//空的

  2846.         api.Print(fmt::format("Status:{}", (int)Stu1Status));

  2847. 

  2848.         switch (Stu1Status)

  2849.         {

  2850.         case StudentStatus::Init:

  2851.         {InitMap(api);

  2852.         Stu1Status = StudentStatus::WantToStudy;

  2853.         break; }

  2854. 

  2855.         case StudentStatus::WantToStudy:

  2856.         {

  2857. 

  2858.             TempClassroom = ChooseAClassroom(api, GridToCell(self->x), GridToCell(self->y), 0);

  2859.             api.Print(fmt::format("Tempclassroom{}", TempClassroom->id));

  2860.             MapNode NewDestination = TempClassroom->xy[this->playerID];

  2861.             if (NewDestination != FinalDestination)

  2862.             {

  2863.                 //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  2864.                 pathnum = 0;

  2865.                 pathlength = 0;

  2866.                 memset(path, 0, 100);

  2867. 

  2868.                 SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination.x, NewDestination.y);

  2869.             }

  2870.             if (MoveAlongPath(api))

  2871.             {

  2872.                 if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  2873.                 {

  2874.                     api.UseSkill(0);

  2875.                 }

  2876.                 Stu1Status = StudentStatus::Studying;

  2877.             };

  2878.             if (FinishedClassroom >= 7)

  2879.             {

  2880.                 Stu1Status = StudentStatus::WantToGraduate;

  2881.             }

  2882.             break; }

  2883. 

  2884.         case StudentStatus::Studying:

  2885.         {

  2886.             api.Print(fmt::format("TempClassroom:{},{},progress{}", TempClassroom->realxy.x, TempClassroom->realxy.y, TempClassroom->progress));

  2887.             TempClassroom->progress = api.GetClassroomProgress(TempClassroom->realxy.x, TempClassroom->realxy.y);

  2888.             if (TempClassroom->progress < 10000000)

  2889.             {

  2890.                 api.StartLearning();

  2891.                 //api.EndAllAction();

  2892.             }

  2893.             else

  2894.             {

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

  2896.                 {

  2897.                     api.SendTextMessage(i, fmt::format("0{}{}", TempClassroom->id, TempClassroom->progress));

  2898.                     api.Print(fmt::format("SEND MESSAGE:0{}{}", TempClassroom->id, TempClassroom->progress));

  2899.                 }

  2900.                 Stu1Status = StudentStatus::WantToStudy;

  2901.             };

  2902.             if (FinishedClassroom >= 7)

  2903.             {

  2904.                 Stu1Status = StudentStatus::WantToGraduate;

  2905.             }

  2906.             break; }

  2907.         case StudentStatus::WantToGraduate://需要仿照wanttostudy写

  2908.         { TempGate = ChooseAGate(api, GridToCell(self->x), GridToCell(self->y));

  2909.         MapNode NewDestination1 = (*TempGate).xy;

  2910.         if (NewDestination1 != FinalDestination)

  2911.         {

  2912.             //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  2913.             pathnum = 0;

  2914.             pathlength = 0;

  2915.             memset(path, 0, 100);

  2916. 

  2917.             SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination1.x, NewDestination1.y);

  2918.         }

  2919.         if (MoveAlongPath(api))

  2920.         {

  2921.             Stu1Status = StudentStatus::Graduating;

  2922.         };

  2923.         break; }

  2924.         case StudentStatus::Graduating:

  2925.             //先更新大门的进度

  2926.         {(*TempGate).progress = api.GetGateProgress(ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.x, ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.y);

  2927.         if (TempGate->progress < 18000)

  2928.         {

  2929.             api.StartOpenGate();

  2930.         }

  2931.         else

  2932.         {

  2933.             api.Graduate();

  2934.         }

  2935.         break; }

  2936.         case StudentStatus::GoToWaitingPoint:

  2937.         {

  2938.             MoveAlongPath(api);

  2939.             break;

  2940.         }

  2941.         case StudentStatus::GoToStudy:

  2942.         {

  2943.             if (MoveAlongSettedPath2(api))

  2944.             {

  2945.                 if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  2946.                 {

  2947.                     api.UseSkill(0);

  2948.                 }

  2949.             };

  2950.             break;

  2951.         }

  2952. 

  2953.         };

  2954.         }

  2955.     }

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

  2957.     {

  2958.         InitMap(api);

  2959.         if (map[20][20] == THUAI6::PlaceType::Wall)

  2960.         {

  2961.             int ID = 2;

  2962.             auto self = api.GetSelfInfo();

  2963.             auto tricker = api.GetTrickers();

  2964.             auto GAME = api.GetGameInfo();

  2965.             api.Print(fmt::format("GameTime:{}", GAME->gameTime));

  2966.             api.Wait();

  2967.             if (test2)

  2968.             {

  2969.                 test2 = false;

  2970.                 api.Move(3000, 3.92699);

  2971.             }

  2972.             NowArea = GetArea(GridToCell(self->x), GridToCell(self->y));

  2973.             UpdateInfo(api);

  2974.             api.Print(fmt::format("cell:{},{}", (Ppath[ID] + PathforLength[ID] - 1)->x, (Ppath[ID] + PathforLength[ID] - 1)->y));

  2975.             if (GAME->gameTime < 582000)

  2976.             {

  2977.                 if (test)

  2978.                 {

  2979.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), 3, 8);

  2980.                     test = false;

  2981.                 }

  2982.                 Stu1Status = StudentStatus::GoToWaitingPoint;

  2983.             }

  2984.             else

  2985.             {

  2986.                 Stu1Status = StudentStatus::GoToStudy;

  2987.             }

  2988.             SetStatus(api);//空的

  2989.             DealingWithMessages(api);

  2990.             UsingSkills(api);//空的

  2991.             api.Print(fmt::format("Status:{}", (int)Stu1Status));

  2992. 

  2993.             switch (Stu1Status)

  2994.             {

  2995.             case StudentStatus::Init:

  2996.             {InitMap(api);

  2997.             Stu1Status = StudentStatus::WantToStudy;

  2998.             break; }

  2999. 

  3000.             case StudentStatus::WantToStudy:

  3001.             {

  3002. 

  3003.                 TempClassroom = ChooseAClassroom(api, GridToCell(self->x), GridToCell(self->y), 0);

  3004.                 api.Print(fmt::format("Tempclassroom{}", TempClassroom->id));

  3005.                 MapNode NewDestination = TempClassroom->xy[this->playerID];

  3006.                 if (NewDestination != FinalDestination)

  3007.                 {

  3008.                     //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  3009.                     pathnum = 0;

  3010.                     pathlength = 0;

  3011.                     memset(path, 0, 100);

  3012. 

  3013.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination.x, NewDestination.y);

  3014.                 }

  3015.                 if (MoveAlongPath(api))

  3016.                 {

  3017.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  3018.                     {

  3019.                         api.UseSkill(0);

  3020.                     }

  3021.                     Stu1Status = StudentStatus::Studying;

  3022.                 };

  3023.                 if (FinishedClassroom >= 7)

  3024.                 {

  3025.                     Stu1Status = StudentStatus::WantToGraduate;

  3026.                 }

  3027.                 break; }

  3028. 

  3029.             case StudentStatus::Studying:

  3030.             {

  3031.                 api.Print(fmt::format("TempClassroom:{},{},progress{}", TempClassroom->realxy.x, TempClassroom->realxy.y, TempClassroom->progress));

  3032.                 TempClassroom->progress = api.GetClassroomProgress(TempClassroom->realxy.x, TempClassroom->realxy.y);

  3033.                 if (TempClassroom->progress < 10000000)

  3034.                 {

  3035.                     api.StartLearning();

  3036.                     //api.EndAllAction();

  3037.                 }

  3038.                 else

  3039.                 {

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

  3041.                     {

  3042.                         api.SendTextMessage(i, fmt::format("0{}{}", TempClassroom->id, TempClassroom->progress));

  3043.                         api.Print(fmt::format("SEND MESSAGE:0{}{}", TempClassroom->id, TempClassroom->progress));

  3044.                     }

  3045.                     Stu1Status = StudentStatus::WantToStudy;

  3046.                 };

  3047.                 if (FinishedClassroom >= 7)

  3048.                 {

  3049.                     Stu1Status = StudentStatus::WantToGraduate;

  3050.                 }

  3051.                 break; }

  3052.             case StudentStatus::WantToGraduate://需要仿照wanttostudy写

  3053.             { TempGate = ChooseAGate(api, GridToCell(self->x), GridToCell(self->y));

  3054.             MapNode NewDestination1 = (*TempGate).xy;

  3055.             if (NewDestination1 != FinalDestination)

  3056.             {

  3057.                 //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  3058.                 pathnum = 0;

  3059.                 pathlength = 0;

  3060.                 memset(path, 0, 100);

  3061. 

  3062.                 SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination1.x, NewDestination1.y);

  3063.             }

  3064.             if (MoveAlongPath(api))

  3065.             {

  3066.                 Stu1Status = StudentStatus::Graduating;

  3067.             };

  3068.             break; }

  3069.             case StudentStatus::Graduating:

  3070.                 //先更新大门的进度

  3071.             {(*TempGate).progress = api.GetGateProgress(ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.x, ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.y);

  3072.             if (TempGate->progress < 18000)

  3073.             {

  3074.                 api.StartOpenGate();

  3075.             }

  3076.             else

  3077.             {

  3078.                 api.Graduate();

  3079.             }

  3080.             break; }

  3081.             case StudentStatus::GoToWaitingPoint:

  3082.             {

  3083.                 MoveAlongPath(api);

  3084.                 break;

  3085.             }

  3086.             case StudentStatus::GoToStudy:

  3087.             {

  3088.                 if (MoveAlongSettedPath(api))

  3089.                 {

  3090.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  3091.                     {

  3092.                         api.UseSkill(0);

  3093.                     }

  3094.                 };

  3095.                 break;

  3096.             }

  3097. 

  3098.             };

  3099.         }

  3100.         else

  3101.         {

  3102.         int ID = 2;

  3103.         auto self = api.GetSelfInfo();

  3104.         auto tricker = api.GetTrickers();

  3105.         auto GAME = api.GetGameInfo();

  3106.         api.Print(fmt::format("GameTime:{}", GAME->gameTime));

  3107. 

  3108.         NowArea = GetArea(GridToCell(self->x), GridToCell(self->y));//Wrong

  3109.         UpdateInfo(api);//Wrong

  3110.         api.Print(fmt::format("cell:{},{}", (Ppath2[ID] + PathforLength[ID] - 1)->x, (Ppath2[ID] + PathforLength2[ID] - 1)->y));

  3111.         if (GAME->gameTime < 578000)

  3112.         {

  3113.             if (test)

  3114.             {

  3115.                 SetPath2(api, GridToCell(self->x), GridToCell(self->y), 43,2);

  3116.                 test = false;

  3117.             }

  3118.             Stu1Status = StudentStatus::GoToWaitingPoint;

  3119.         }

  3120.         else

  3121.         {

  3122.             Stu1Status = StudentStatus::GoToStudy;

  3123.         }

  3124.         SetStatus(api);//空的

  3125.         DealingWithMessages(api);

  3126.         UsingSkills(api);//空的

  3127.         api.Print(fmt::format("Status:{}", (int)Stu1Status));

  3128. 

  3129.         switch (Stu1Status)

  3130.         {

  3131.         case StudentStatus::Init:

  3132.         {InitMap(api);

  3133.         Stu1Status = StudentStatus::WantToStudy;

  3134.         break; }

  3135. 

  3136.         case StudentStatus::WantToStudy:

  3137.         {

  3138. 

  3139.             TempClassroom = ChooseAClassroom(api, GridToCell(self->x), GridToCell(self->y), 0);

  3140.             api.Print(fmt::format("Tempclassroom{}", TempClassroom->id));

  3141.             MapNode NewDestination = TempClassroom->xy[this->playerID];

  3142.             if (NewDestination != FinalDestination)

  3143.             {

  3144.                 //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  3145.                 pathnum = 0;

  3146.                 pathlength = 0;

  3147.                 memset(path, 0, 100);

  3148. 

  3149.                 SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination.x, NewDestination.y);

  3150.             }

  3151.             if (MoveAlongPath(api))

  3152.             {

  3153.                 if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  3154.                 {

  3155.                     api.UseSkill(0);

  3156.                 }

  3157.                 Stu1Status = StudentStatus::Studying;

  3158.             };

  3159.             if (FinishedClassroom >= 7)

  3160.             {

  3161.                 Stu1Status = StudentStatus::WantToGraduate;

  3162.             }

  3163.             break; }

  3164. 

  3165.         case StudentStatus::Studying:

  3166.         {

  3167.             api.Print(fmt::format("TempClassroom:{},{},progress{}", TempClassroom->realxy.x, TempClassroom->realxy.y, TempClassroom->progress));

  3168.             TempClassroom->progress = api.GetClassroomProgress(TempClassroom->realxy.x, TempClassroom->realxy.y);

  3169.             if (TempClassroom->progress < 10000000)

  3170.             {

  3171.                 api.StartLearning();

  3172.                 //api.EndAllAction();

  3173.             }

  3174.             else

  3175.             {

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

  3177.                 {

  3178.                     api.SendTextMessage(i, fmt::format("0{}{}", TempClassroom->id, TempClassroom->progress));

  3179.                     api.Print(fmt::format("SEND MESSAGE:0{}{}", TempClassroom->id, TempClassroom->progress));

  3180.                 }

  3181.                 Stu1Status = StudentStatus::WantToStudy;

  3182.             };

  3183.             if (FinishedClassroom >= 7)

  3184.             {

  3185.                 Stu1Status = StudentStatus::WantToGraduate;

  3186.             }

  3187.             break; }

  3188.         case StudentStatus::WantToGraduate://需要仿照wanttostudy写

  3189.         { TempGate = ChooseAGate(api, GridToCell(self->x), GridToCell(self->y));

  3190.         MapNode NewDestination1 = (*TempGate).xy;

  3191.         if (NewDestination1 != FinalDestination)

  3192.         {

  3193.             //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  3194.             pathnum = 0;

  3195.             pathlength = 0;

  3196.             memset(path, 0, 100);

  3197. 

  3198.             SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination1.x, NewDestination1.y);

  3199.         }

  3200.         if (MoveAlongPath(api))

  3201.         {

  3202.             Stu1Status = StudentStatus::Graduating;

  3203.         };

  3204.         break; }

  3205.         case StudentStatus::Graduating:

  3206.             //先更新大门的进度

  3207.         {(*TempGate).progress = api.GetGateProgress(ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.x, ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.y);

  3208.         if (TempGate->progress < 18000)

  3209.         {

  3210.             api.StartOpenGate();

  3211.         }

  3212.         else

  3213.         {

  3214.             api.Graduate();

  3215.         }

  3216.         break; }

  3217.         case StudentStatus::GoToWaitingPoint:

  3218.         {

  3219.             MoveAlongPath(api);

  3220.             break;

  3221.         }

  3222.         case StudentStatus::GoToStudy:

  3223.         {

  3224.             if (MoveAlongSettedPath2(api))

  3225.             {

  3226.                 if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  3227.                 {

  3228.                     api.UseSkill(0);

  3229.                 }

  3230.             };

  3231.             break;

  3232.         }

  3233. 

  3234.         };

  3235.         }

  3236.     }

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

  3238.     {

  3239.         InitMap(api);

  3240.         if (map[20][20] == THUAI6::PlaceType::Wall)

  3241.         {

  3242.             int ID = 3;

  3243.             auto self = api.GetSelfInfo();

  3244.             auto tricker = api.GetTrickers();

  3245.             auto GAME = api.GetGameInfo();

  3246.             api.Print(fmt::format("GameTime:{}", GAME->gameTime));

  3247. 

  3248.             NowArea = GetArea(GridToCell(self->x), GridToCell(self->y));

  3249.             UpdateInfo(api);

  3250.             api.Print(fmt::format("cell:{},{}", (Ppath[ID] + PathforLength[ID] - 1)->x, (Ppath[ID] + PathforLength[ID] - 1)->y));

  3251.             if (GAME->gameTime < 586000)

  3252.             {

  3253.                 if (test)

  3254.                 {

  3255.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), 43, 43);

  3256.                     test = false;

  3257.                 }

  3258.                 Stu1Status = StudentStatus::GoToWaitingPoint;

  3259.             }

  3260.             else

  3261.             {

  3262.                 Stu1Status = StudentStatus::GoToStudy;

  3263.             }

  3264.             SetStatus(api);//空的

  3265.             DealingWithMessages(api);

  3266.             UsingSkills(api);//空的

  3267.             api.Print(fmt::format("Status:{}", (int)Stu1Status));

  3268. 

  3269.             switch (Stu1Status)

  3270.             {

  3271.             case StudentStatus::Init:

  3272.             {InitMap(api);

  3273.             Stu1Status = StudentStatus::WantToStudy;

  3274.             break; }

  3275. 

  3276.             case StudentStatus::WantToStudy:

  3277.             {

  3278. 

  3279.                 TempClassroom = ChooseAClassroom(api, GridToCell(self->x), GridToCell(self->y), 0);

  3280.                 api.Print(fmt::format("Tempclassroom{}", TempClassroom->id));

  3281.                 MapNode NewDestination = TempClassroom->xy[this->playerID];

  3282.                 if (NewDestination != FinalDestination)

  3283.                 {

  3284.                     //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  3285.                     pathnum = 0;

  3286.                     pathlength = 0;

  3287.                     memset(path, 0, 100);

  3288. 

  3289.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination.x, NewDestination.y);

  3290.                 }

  3291.                 if (MoveAlongPath(api))

  3292.                 {

  3293.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  3294.                     {

  3295.                         api.UseSkill(0);

  3296.                     }

  3297.                     Stu1Status = StudentStatus::Studying;

  3298.                 };

  3299.                 if (FinishedClassroom >= 7)

  3300.                 {

  3301.                     Stu1Status = StudentStatus::WantToGraduate;

  3302.                 }

  3303.                 break; }

  3304. 

  3305.             case StudentStatus::Studying:

  3306.             {

  3307.                 api.Print(fmt::format("TempClassroom:{},{},progress{}", TempClassroom->realxy.x, TempClassroom->realxy.y, TempClassroom->progress));

  3308.                 TempClassroom->progress = api.GetClassroomProgress(TempClassroom->realxy.x, TempClassroom->realxy.y);

  3309.                 if (TempClassroom->progress < 10000000)

  3310.                 {

  3311.                     api.StartLearning();

  3312.                     //api.EndAllAction();

  3313.                 }

  3314.                 else

  3315.                 {

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

  3317.                     {

  3318.                         api.SendTextMessage(i, fmt::format("0{}{}", TempClassroom->id, TempClassroom->progress));

  3319.                         api.Print(fmt::format("SEND MESSAGE:0{}{}", TempClassroom->id, TempClassroom->progress));

  3320.                     }

  3321.                     Stu1Status = StudentStatus::WantToStudy;

  3322.                 };

  3323.                 if (FinishedClassroom >= 7)

  3324.                 {

  3325.                     Stu1Status = StudentStatus::WantToGraduate;

  3326.                 }

  3327.                 break; }

  3328.             case StudentStatus::WantToGraduate://需要仿照wanttostudy写

  3329.             { TempGate = ChooseAGate(api, GridToCell(self->x), GridToCell(self->y));

  3330.             MapNode NewDestination1 = (*TempGate).xy;

  3331.             if (NewDestination1 != FinalDestination)

  3332.             {

  3333.                 //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  3334.                 pathnum = 0;

  3335.                 pathlength = 0;

  3336.                 memset(path, 0, 100);

  3337. 

  3338.                 SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination1.x, NewDestination1.y);

  3339.             }

  3340.             if (MoveAlongPath(api))

  3341.             {

  3342.                 Stu1Status = StudentStatus::Graduating;

  3343.             };

  3344.             break; }

  3345.             case StudentStatus::Graduating:

  3346.                 //先更新大门的进度

  3347.             {(*TempGate).progress = api.GetGateProgress(ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.x, ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.y);

  3348.             if (TempGate->progress < 18000)

  3349.             {

  3350.                 api.StartOpenGate();

  3351.             }

  3352.             else

  3353.             {

  3354.                 api.Graduate();

  3355.             }

  3356.             break; }

  3357.             case StudentStatus::GoToWaitingPoint:

  3358.             {

  3359.                 MoveAlongPath(api);

  3360.                 break;

  3361.             }

  3362.             case StudentStatus::GoToStudy:

  3363.             {

  3364.                 if (MoveAlongSettedPath(api))

  3365.                 {

  3366.                     if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  3367.                     {

  3368.                         api.UseSkill(0);

  3369.                     }

  3370.                 };

  3371.                 break;

  3372.             }

  3373. 

  3374.             };

  3375.         }

  3376.         else

  3377.         {

  3378.         int ID = 3;

  3379.         auto self = api.GetSelfInfo();

  3380.         auto tricker = api.GetTrickers();

  3381.         auto GAME = api.GetGameInfo();

  3382.         api.Print(fmt::format("GameTime:{}", GAME->gameTime));

  3383. 

  3384.         NowArea = GetArea(GridToCell(self->x), GridToCell(self->y));//Wrong

  3385.         UpdateInfo(api);//Wrong

  3386.         api.Print(fmt::format("cell:{},{}", (Ppath2[ID] + PathforLength[ID] - 1)->x, (Ppath2[ID] + PathforLength2[ID] - 1)->y));

  3387.         if (GAME->gameTime < 578000)

  3388.         {

  3389.             if (test)

  3390.             {

  3391.                 SetPath2(api, GridToCell(self->x), GridToCell(self->y), 43,47);

  3392.                 test = false;

  3393.             }

  3394.             Stu1Status = StudentStatus::GoToWaitingPoint;

  3395.         }

  3396.         else

  3397.         {

  3398.             Stu1Status = StudentStatus::GoToStudy;

  3399.         }

  3400.         SetStatus(api);//空的

  3401.         DealingWithMessages(api);

  3402.         UsingSkills(api);//空的

  3403.         api.Print(fmt::format("Status:{}", (int)Stu1Status));

  3404. 

  3405.         switch (Stu1Status)

  3406.         {

  3407.         case StudentStatus::Init:

  3408.         {InitMap(api);

  3409.         Stu1Status = StudentStatus::WantToStudy;

  3410.         break; }

  3411. 

  3412.         case StudentStatus::WantToStudy:

  3413.         {

  3414. 

  3415.             TempClassroom = ChooseAClassroom(api, GridToCell(self->x), GridToCell(self->y), 0);

  3416.             api.Print(fmt::format("Tempclassroom{}", TempClassroom->id));

  3417.             MapNode NewDestination = TempClassroom->xy[this->playerID];

  3418.             if (NewDestination != FinalDestination)

  3419.             {

  3420.                 //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  3421.                 pathnum = 0;

  3422.                 pathlength = 0;

  3423.                 memset(path, 0, 100);

  3424. 

  3425.                 SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination.x, NewDestination.y);

  3426.             }

  3427.             if (MoveAlongPath(api))

  3428.             {

  3429.                 if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  3430.                 {

  3431.                     api.UseSkill(0);

  3432.                 }

  3433.                 Stu1Status = StudentStatus::Studying;

  3434.             };

  3435.             if (FinishedClassroom >= 7)

  3436.             {

  3437.                 Stu1Status = StudentStatus::WantToGraduate;

  3438.             }

  3439.             break; }

  3440. 

  3441.         case StudentStatus::Studying:

  3442.         {

  3443.             api.Print(fmt::format("TempClassroom:{},{},progress{}", TempClassroom->realxy.x, TempClassroom->realxy.y, TempClassroom->progress));

  3444.             TempClassroom->progress = api.GetClassroomProgress(TempClassroom->realxy.x, TempClassroom->realxy.y);

  3445.             if (TempClassroom->progress < 10000000)

  3446.             {

  3447.                 api.StartLearning();

  3448.                 //api.EndAllAction();

  3449.             }

  3450.             else

  3451.             {

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

  3453.                 {

  3454.                     api.SendTextMessage(i, fmt::format("0{}{}", TempClassroom->id, TempClassroom->progress));

  3455.                     api.Print(fmt::format("SEND MESSAGE:0{}{}", TempClassroom->id, TempClassroom->progress));

  3456.                 }

  3457.                 Stu1Status = StudentStatus::WantToStudy;

  3458.             };

  3459.             if (FinishedClassroom >= 7)

  3460.             {

  3461.                 Stu1Status = StudentStatus::WantToGraduate;

  3462.             }

  3463.             break; }

  3464.         case StudentStatus::WantToGraduate://需要仿照wanttostudy写

  3465.         { TempGate = ChooseAGate(api, GridToCell(self->x), GridToCell(self->y));

  3466.         MapNode NewDestination1 = (*TempGate).xy;

  3467.         if (NewDestination1 != FinalDestination)

  3468.         {

  3469.             //Goto(api, path[pathnum - 2].x, path[pathnum - 2].y);

  3470.             pathnum = 0;

  3471.             pathlength = 0;

  3472.             memset(path, 0, 100);

  3473. 

  3474.             SetPath(api, GridToCell(self->x), GridToCell(self->y), NewDestination1.x, NewDestination1.y);

  3475.         }

  3476.         if (MoveAlongPath(api))

  3477.         {

  3478.             Stu1Status = StudentStatus::Graduating;

  3479.         };

  3480.         break; }

  3481.         case StudentStatus::Graduating:

  3482.             //先更新大门的进度

  3483.         {(*TempGate).progress = api.GetGateProgress(ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.x, ChooseAGate(api, GridToCell(self->x), GridToCell(self->y))->xy.y);

  3484.         if (TempGate->progress < 18000)

  3485.         {

  3486.             api.StartOpenGate();

  3487.         }

  3488.         else

  3489.         {

  3490.             api.Graduate();

  3491.         }

  3492.         break; }

  3493.         case StudentStatus::GoToWaitingPoint:

  3494.         {

  3495.             MoveAlongPath(api);

  3496.             break;

  3497.         }

  3498.         case StudentStatus::GoToStudy:

  3499.         {

  3500.             if (MoveAlongSettedPath2(api))

  3501.             {

  3502.                 if (self->studentType == THUAI6::StudentType::StraightAStudent)//学霸使用技能

  3503.                 {

  3504.                     api.UseSkill(0);

  3505.                 }

  3506.             };

  3507.             break;

  3508.         }

  3509. 

  3510.         };

  3511.         }

  3512.     }

  3513. }

  3514. 

  3515. int WantArea = 0;//用于Tricker的Searching状态调试

  3516. bool IsinCircle = true;//用于判断tricker能不能沿着规定的Circle走。

  3517. 

  3518. 

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

  3520. {

  3521.     auto self = api.GetSelfInfo();

  3522.     auto students = api.GetStudents();

  3523.     api.Print(fmt::format("TrickerDesire{}",self->trickDesire) );

  3524.     SetStatus(api);

  3525.     api.Print(fmt::format("CloseStudent:{},{}", GridToCell(ClosedStudent.x), GridToCell(ClosedStudent.y)));

  3526.     NowArea = GetArea(GridToCell(self->x), GridToCell(self->y));

  3527.     InitMap(api);

  3528.     if (self->trickDesire > 1.176)

  3529.     {

  3530.         api.UseSkill(0);

  3531.     }

  3532.     if(map[20][20]==THUAI6::PlaceType::Wall)

  3533. 

  3534.     {

  3535.         switch (Tricker1Status)

  3536.         {

  3537.         case TrickerStatus::Init:

  3538.         {InitMap(api);

  3539.         Tricker1Status = TrickerStatus::Searching;

  3540.         break; }

  3541.         case TrickerStatus::Tracing:

  3542.         {

  3543.             int nowCount = api.GetFrameCount();//这一部分用来实现翻墙

  3544.             api.Print(fmt::format("{},{}", nowCount, lastSkipCount));

  3545.             if (nowCount - lastSkipCount > 100)

  3546.             {

  3547.                 if (api.SkipWindow().get())

  3548.                 {

  3549.                     pathnum++;

  3550.                     Goto(api, path[pathnum].x, path[pathnum].y);

  3551.                     lastSkipCount = nowCount;

  3552.                 }

  3553.             }

  3554.             if (!BeStuck(api))

  3555.                 GotoGrid(api, ClosedStudent.x, ClosedStudent.y);

  3556.             else//处理被卡住的情况

  3557.             {

  3558.                 int selfx = self->x;

  3559.                 int selfy = self->y;

  3560.                 auto delta_x = ClosedStudent.x - selfx;

  3561.                 auto delta_y = ClosedStudent.y - selfy;

  3562.                 double ang = 0;

  3563.                 ang = atan2(delta_y, delta_x);

  3564.                 if (Stuck)

  3565.                 {

  3566.                     ang += PI / 2.0;

  3567.                     Stuck = false;

  3568.                 }

  3569.                 else

  3570.                 {

  3571.                     ang -= PI / 2.0;

  3572.                     Stuck = true;

  3573.                 }

  3574.                 api.Move(80, ang);

  3575.             }

  3576. 

  3577.             break; }

  3578.         case TrickerStatus::Attaking:

  3579.         {

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

  3581.             {

  3582.                 api.UseSkill(0);

  3583.             }

  3584.             if (students.size() > 0)

  3585.                 api.Attack(atan2(ClosedStudent.y - self->y, ClosedStudent.x - self->x));

  3586.             else

  3587.                 api.Attack(atan2(ClosedTrickerPath[pathnum].y - GridToCell(self->y), ClosedTrickerPath[pathnum].x - GridToCell(self->x)));

  3588.             GotoGrid(api, ClosedStudent.x, ClosedStudent.y);

  3589.             api.Print("Attacking!and Moving!");

  3590.             break;

  3591.         }

  3592.         case TrickerStatus::Searching:

  3593.             //如果在TB1而且是不知道去哪，就选个TB前往，如果到达TB3,5,6中的指定点，就更改一个其他TB的目的地，每帧都会移动

  3594.         {

  3595.             if (!StatusIsSearching)

  3596.             {

  3597.                 int closednumber = -1;

  3598.                 int mindistance = 100, tempdistance;

  3599.                 for (int i = 0; i < 56; i++)

  3600.                 {

  3601.                     tempdistance = GetDistance(GridToCell(self->x), GridToCell(self->y), ClosedTrickerPath[i].x, ClosedTrickerPath[i].y);

  3602.                     if ((tempdistance < mindistance) && !isWalled(GridToCell(self->x), GridToCell(self->y), ClosedTrickerPath[i].x, ClosedTrickerPath[i].y))

  3603.                     {

  3604. 

  3605.                         mindistance = tempdistance;

  3606.                         closednumber = i;

  3607.                     }

  3608.                     IsinCircle = true;

  3609. 

  3610.                 }

  3611.                 pathnum = closednumber;

  3612.                 if (closednumber == -1)

  3613.                 {

  3614.                     IsinCircle = false;

  3615.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), 22, 25);

  3616.                 }

  3617.                 api.Print(fmt::format("ClosedNumberInClosePath:{}", closednumber));

  3618. 

  3619.             }

  3620.             if (IsinCircle)

  3621.             {

  3622.                 api.Print("isincircle");

  3623.                 MoveAlongClosedPath(api);

  3624.                 api.Print(fmt::format("ClosePathnum:{}", pathnum));

  3625.             }

  3626.             else

  3627.             {

  3628.                 api.Print("notincircle");

  3629.                 if (MoveAlongPath(api)||arriveAt(api,22,25))

  3630.                 {

  3631. 

  3632.                     pathnum = 0;

  3633.                     IsinCircle = true;

  3634.                     Arrived = false;

  3635.                 }

  3636. 

  3637.             }

  3638. 

  3639.             StatusIsSearching = true;

  3640. 

  3641.             break;

  3642.         }

  3643.         }

  3644. 

  3645.         

  3646.     }

  3647.     else

  3648.     {

  3649.         api.Print("MAP 2 !!!");

  3650.         switch (Tricker1Status)

  3651.         {

  3652.         case TrickerStatus::Init:

  3653.         {InitMap(api);

  3654.         Tricker1Status = TrickerStatus::Searching;

  3655.         break; }

  3656.         case TrickerStatus::Tracing:

  3657.         {

  3658.             int nowCount = api.GetFrameCount();//这一部分用来实现翻墙

  3659.             api.Print(fmt::format("{},{}", nowCount, lastSkipCount));

  3660.             if (nowCount - lastSkipCount > 100)

  3661.             {

  3662.                 if (api.SkipWindow().get())

  3663.                 {

  3664.                     pathnum++;

  3665.                     Goto(api, path[pathnum].x, path[pathnum].y);

  3666.                     lastSkipCount = nowCount;

  3667.                 }

  3668.             }

  3669.             if (!BeStuck(api))

  3670.                 GotoGrid(api, ClosedStudent.x, ClosedStudent.y);

  3671.             else//处理被卡住的情况

  3672.             {

  3673.                 int selfx = self->x;

  3674.                 int selfy = self->y;

  3675.                 auto delta_x = ClosedStudent.x - selfx;

  3676.                 auto delta_y = ClosedStudent.y - selfy;

  3677.                 double ang = 0;

  3678.                 ang = atan2(delta_y, delta_x);

  3679.                 if (Stuck)

  3680.                 {

  3681.                     ang += PI / 2.0;

  3682.                     Stuck = false;

  3683.                 }

  3684.                 else

  3685.                 {

  3686.                     ang -= PI / 2.0;

  3687.                     Stuck = true;

  3688.                 }

  3689.                 api.Move(80, ang);

  3690.             }

  3691. 

  3692.             break; }

  3693.         case TrickerStatus::Attaking:

  3694.         {

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

  3696.             {

  3697.                 api.UseSkill(0);

  3698.             }

  3699.             api.Attack(atan2(ClosedStudent.y - self->y, ClosedStudent.x - self->x));

  3700.             GotoGrid(api, ClosedStudent.x, ClosedStudent.y);

  3701.             api.Print("Attacking!and Moving!");

  3702.             break;

  3703.         }

  3704.         case TrickerStatus::Searching:

  3705.             

  3706.         {

  3707.             if (!StatusIsSearching)

  3708.             {

  3709.                 int closednumber = -1;

  3710.                 int mindistance = 100, tempdistance;

  3711.                 for (int i = 0; i < 68; i++)

  3712.                 {

  3713.                     tempdistance = GetDistance(GridToCell(self->x), GridToCell(self->y), ClosedTrickerPath2[i].x, ClosedTrickerPath2[i].y);

  3714.                     if ((tempdistance < mindistance) && !isWalled(GridToCell(self->x),GridToCell( self->y), ClosedTrickerPath2[i].x, ClosedTrickerPath2[i].y))

  3715.                     {

  3716. 

  3717.                         mindistance = tempdistance;

  3718.                         closednumber = i;

  3719.                     }

  3720.                     IsinCircle = true;

  3721. 

  3722.                 }

  3723.                 pathnum = closednumber;

  3724.                 if (closednumber == -1)

  3725.                 {

  3726.                     IsinCircle = false;

  3727.                     SetPath(api, GridToCell(self->x), GridToCell(self->y), 25, 25);//这句慎重

  3728.                 }

  3729.                 api.Print(fmt::format("ClosedNumberInClosePath:{}", closednumber));

  3730. 

  3731.             }

  3732.             if (IsinCircle)

  3733.             {

  3734.                 api.Print("isincircle");

  3735.                 MoveAlongClosedPath2(api);

  3736.             }

  3737.             else

  3738.             {

  3739.                 api.Print("notincircle");

  3740.                 if (MoveAlongPath(api))

  3741.                 {

  3742.                     pathnum = 0;

  3743.                     IsinCircle = true;

  3744.                     Arrived = false;

  3745.                 }

  3746. 

  3747.             }

  3748. 

  3749.             StatusIsSearching = true;

  3750. 

  3751.             break;

  3752.         }

  3753.         }

  3754. 

  3755. 

  3756.     }

  3757. }