Guest User

The Accountant, Aveuh

a guest
Oct 16th, 2016
812
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #pragma GCC optimize "O3,omit-frame-pointer,inline"
  2. #include <chrono>
  3. #include <iostream>
  4. #include <cmath>
  5. #include <string>
  6. #include <cstring>
  7.  
  8. // Constants
  9. #define WIDTH         16000
  10. #define HEIGHT         9000
  11. #define MAX_DP          100
  12. #define MAX_EN          100
  13. #define EN_VEL          500
  14. #define MY_VEL         1000
  15. #define MIN_DIST       2000 // Death distance
  16. #define MIN_DIST2   4000000 // Same, squared
  17. #define THRESHOLD   4000000
  18. #define INF       337000000 // W*W*H*H
  19.  
  20. // State of a playout
  21. #define STATE_GAME_OVER 0
  22. #define STATE_ONGOING   1
  23. #define STATE_FINISHED  2
  24.  
  25. // AI Mode (useless, was put there in case I wished to use another AI algorithm)
  26. #define AI_MODE_MC 0
  27.  
  28. // Random moves around (0, 0)
  29. #define N_RANDOM 225
  30. const int rand_x[N_RANDOM] = {-10, -80, -151, -222, -292, -363, -434, -504, -575, -646, -717, -787, -858, -929, -1000, -9, -72, -136, -200, -263, -327, -391, -454, -518, -582, -646, -709, -773, -837, -900, -6, -50, -94, -138, -182, -226, -270, -314, -358, -403, -447, -491, -535, -579, -623, -2, -17, -33, -49, -65, -80, -96, -112, -128, -143, -159, -175, -191, -206, -222, 2, 17, 33, 49, 65, 80, 96, 112, 128, 143, 159, 175, 191, 206, 222, 6, 50, 94, 138, 182, 226, 270, 314, 358, 403, 447, 491, 535, 579, 623, 9, 72, 136, 200, 263, 327, 391, 454, 518, 582, 646, 709, 773, 837, 900, 10, 80, 151, 222, 292, 363, 434, 504, 575, 646, 717, 787, 858, 929, 1000, 9, 72, 136, 200, 263, 327, 391, 454, 518, 582, 646, 709, 773, 837, 900, 6, 50, 94, 138, 182, 226, 270, 314, 358, 403, 447, 491, 535, 579, 623, 2, 17, 33, 49, 65, 80, 96, 112, 128, 143, 159, 175, 191, 206, 222, -2, -17, -33, -49, -65, -80, -96, -112, -128, -143, -159, -175, -191, -206, -222, -6, -50, -94, -138, -182, -226, -270, -314, -358, -403, -447, -491, -535, -579, -623, -9, -72, -136, -200, -263, -327, -391, -454, -518, -582, -646, -709, -773, -837, -900, -10, -80, -151, -222, -292, -363, -434, -504, -575, -646, -717, -787, -858, -929, -1000};
  31. const int rand_y[N_RANDOM] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -4, -35, -65, -96, -127, -157, -188, -219, -249, -280, -311, -341, -372, -403, -433, -7, -63, -118, -173, -228, -284, -339, -394, -450, -505, -560, -615, -671, -726, -781, -9, -78, -147, -216, -285, -354, -423, -492, -561, -630, -699, -768, -837, -905, -974, -9, -78, -147, -216, -285, -354, -423, -492, -561, -630, -699, -768, -837, -905, -974, -7, -63, -118, -173, -228, -284, -339, -394, -450, -505, -560, -615, -671, -726, -781, -4, -35, -65, -96, -127, -157, -188, -219, -249, -280, -311, -341, -372, -403, -433, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 35, 65, 96, 127, 157, 188, 219, 249, 280, 311, 341, 372, 403, 433, 7, 63, 118, 173, 228, 284, 339, 394, 450, 505, 560, 615, 671, 726, 781, 9, 78, 147, 216, 285, 354, 423, 492, 561, 630, 699, 768, 837, 905, 974, 9, 78, 147, 216, 285, 354, 423, 492, 561, 630, 699, 768, 837, 905, 974, 7, 63, 118, 173, 228, 284, 339, 394, 450, 505, 560, 615, 671, 726, 781, 4, 35, 65, 96, 127, 157, 188, 219, 249, 280, 311, 341, 372, 403, 433, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  32.  
  33. #define DMG_THRESHOLD 12
  34. // Probabiity to one-shot an enemy
  35. #define PROB_OS        90
  36.  
  37. // Cumulated probabilities for every strategy (sums to 150 ... sorry)
  38. #define PROB_GO_DP     25
  39. #define PROB_GO_EN     50
  40. #define PROB_GO_RD     75
  41. #define PROB_SHOOT    150
  42.  
  43. // Macros
  44. //#define DEBUG
  45. #define min(a, b) (a < b ? a : b)
  46. #define max(a, b) (a > b ? a : b)
  47. #define RAND(x)   ((int)(rand() / (float)RAND_MAX * x))
  48.  
  49. // Timing
  50. using time_point = std::chrono::time_point<std::chrono::system_clock>;
  51. using duration = std::chrono::duration<float>;
  52. #define now std::chrono::system_clock::now
  53. #define TIME_LIMIT 0.096f
  54. #define LARGE_TIME_LIMIT 0.996f
  55.  
  56. // Player actions
  57. #define ACTION_MOVE  0
  58. #define ACTION_SHOOT 1
  59. #define ACTION_NONE  2
  60.  
  61. struct Action {
  62.   int type;   // if type == MOVE, p1 = x, p2 = y; if SHOOT; p1 = id, p2 = unused
  63.   int p1, p2;
  64. };
  65.  
  66. #define SOL_SIZE 200 // Maybe too much ?
  67. struct Solution {
  68.   int nactions;
  69.   int final_state;
  70.   int dist_from_killer;
  71.   Action actions[SOL_SIZE];
  72.   int score;
  73. };
  74.  
  75. // Distances
  76. inline int dist2(int x1, int y1, int x2, int y2) {
  77.   int dx = x1-x2;
  78.   int dy = y1-y2;
  79.   return dx*dx+dy*dy;
  80. }
  81.  
  82. // Moving an entity, /\ x and y are modified
  83. inline void move(int &x, int &y, int tx, int ty, int velocity) {
  84.   int dx = tx - x;
  85.   int dy = ty - y;
  86.  
  87.   if (dx != 0 || dy != 0) {
  88.     float L = sqrt(dx*dx+dy*dy);
  89.  
  90.     if (L < velocity) {
  91.       x = tx;
  92.       y = ty;
  93.     }
  94.     else {
  95.       float d = velocity / L;
  96.       x += dx*d;
  97.       if (x < 0)
  98.     x = 0;
  99.       else if (x >= WIDTH)
  100.     x = WIDTH-1;
  101.  
  102.       y += dy * d;
  103.       if (y < 0)
  104.     y = 0;
  105.       else if (y >= HEIGHT)
  106.     y = HEIGHT-1;
  107.     }
  108.   }
  109. }
  110.  
  111. // On squared distances
  112. inline int damage_dealt(int d2) {
  113.   if (d2 <= 4082821)
  114.     return 14;
  115.   if (d2 <= 4641588)
  116.     return 13;
  117.   if (d2 <= 5333598)
  118.     return 12;
  119.   if (d2 <= 6206801)
  120.     return 11;
  121.   if (d2 <= 7333489)
  122.     return 10;
  123.   if (d2 <= 8827108)
  124.     return 9;
  125.   if (d2 <= 10874632)
  126.     return 8;
  127.   if (d2 <= 13803665)
  128.     return 7;
  129.   if (d2 <= 18235270)
  130.     return 6;
  131.   if (d2 <= 25477833)
  132.     return 5;
  133.   if (d2 <= 38732002)
  134.     return 4;
  135.   if (d2 <= 67860440)
  136.     return 3;
  137.   if (d2 <= 158988089)
  138.     return 2;
  139.   else
  140.     return 1;
  141. }
  142.  
  143. // Game constants
  144. int n_dp;
  145. int n_enemies;
  146. int total_life;
  147. int dp_x[MAX_DP];
  148. int dp_y[MAX_DP];
  149. int ai_mode;
  150. int turn;
  151. Solution current_solution;
  152. int turn_in_sol;
  153. time_point start;
  154. duration elapsed;
  155.  
  156. // Game state
  157. struct State {
  158.   int en_alive;
  159.   int dp_alive;
  160.   int shots;
  161.   int x, y;
  162.   int en_x[MAX_EN];
  163.   int en_y[MAX_EN];
  164.   int en_l[MAX_EN]; // Life
  165.   int en_t[MAX_EN]; // Target DP
  166.   int dp_a[MAX_DP];
  167.   int dist2[MAX_EN];
  168.  
  169.   // Additional info in casae of death
  170.   int killer;           // Which enemy killed us
  171.   int dist_from_killer; // At what distance were we
  172.  
  173.   State() {
  174.     en_alive = 0;
  175.     dp_alive = 0;
  176.     shots = 0;
  177.     x = 0;
  178.     y = 0;
  179.     killer = -1;
  180.   }
  181. };
  182.  
  183. // Gives us a random alive enemy on the map
  184. inline int random_enemy(State &s) {
  185.   int eids[MAX_EN];
  186.   int n_en = 0;
  187.   for (int eid=0; eid < n_enemies; ++eid) {
  188.     if (s.en_l[eid] > 0)
  189.       eids[n_en++] = eid;
  190.   }
  191.   if (n_en == 0)
  192.     return -1;
  193.   return eids[RAND(n_en)];
  194. }
  195.  
  196. // Reading the turn state on stdin
  197. void read_state_from_stdin(State &s, bool first) {
  198.   std::cin >> s.x >> s.y;
  199.  
  200.   // Reset
  201.   memset(s.en_x, 0, MAX_EN*sizeof(int));
  202.   memset(s.en_y, 0, MAX_EN*sizeof(int));
  203.   memset(s.en_l, 0, MAX_EN*sizeof(int));
  204.   memset(s.dp_a, 0, MAX_EN*sizeof(int));
  205.  
  206.   // Data points
  207.   int tmp;
  208.   std::cin >> tmp;
  209.   s.dp_alive = (int8_t)tmp;
  210.   for (int i=0; i < s.dp_alive; ++i) {
  211.     int id, x, y;
  212.     std::cin >> id >> x >> y;
  213.  
  214. #ifdef DEBUG
  215.     std::cerr <<  "Data point #" << id << " at position : " << x << " " << y << std::endl;
  216. #endif
  217.  
  218.     s.dp_a[id] = 1;
  219.     dp_x[id] = x;
  220.     dp_y[id] = y;
  221.   }
  222.  
  223.   if (first)
  224.     n_dp = s.dp_alive;
  225.  
  226.   // Enemies
  227.   int t = 0;
  228.   std::cin >> tmp;
  229.   s.en_alive = (int)tmp;
  230.   for(int i=0; i < s.en_alive; ++i) {
  231.     int id, x, y, life;
  232.     std::cin >> id >> x >> y >> life;
  233.  
  234.     s.en_x[id] = x;
  235.     s.en_y[id] = y;
  236.     s.en_l[id] = life;
  237.  
  238.     // Distance to Wolff
  239.     int d = dist2(s.en_x[id], s.en_y[id], s.x, s.y);
  240.     s.dist2[id] = d;
  241.  
  242.     // Current target
  243.     int best_dist = INF;
  244.     for (int pid=0; pid < n_dp; ++pid) {
  245.       if (s.dp_a[pid]) {
  246.     int d = dist2(dp_x[pid], dp_y[pid], s.en_x[id], s.en_y[id]);
  247.  
  248.     if (d < best_dist) {
  249.       best_dist = d;
  250.       s.en_t[id] = pid;
  251.     }
  252.       }
  253.     }
  254.  
  255. #ifdef DEBUG
  256.     std::cerr <<  "Enemy #" << id << " at position : " << x << " " << y << "; Life left : "
  257.           << life << "; Target = " << s.en_t[id] << std::endl;
  258. #endif
  259.    
  260.     t += life;
  261.   }
  262.  
  263.   // First turn info to store as globals
  264.   if (first) {
  265.     n_enemies = s.en_alive;
  266.     total_life = t;
  267.  
  268. #ifdef DEBUG
  269.     std::cerr << "First turn init :" << std::endl;
  270.     std::cerr << " - " << n_enemies << " enemies" << std::endl;
  271.     std::cerr << " - Cumulating " << total_life << " life" << std::endl;
  272.     std::cerr << " - Trying to capture " << n_dp << " data points " << std::endl;
  273. #endif
  274.  
  275.   }
  276. }
  277.  
  278. // One step evolution of the game state
  279. // Here things have been reorganized to speed up the whole process :
  280. // In particular, Wolff's position is computed BEFORE the enemies.
  281. // This allows us to compute the distance to the enemy in the same loop as their new
  282. // position, and thus detecting Wolff's death much faster in only one loop.
  283. int evolve(State &s, const Action &a, bool check_for_death) {
  284.   // 1- Moving Wolff
  285.   if (a.type == ACTION_MOVE)
  286.     move(s.x, s.y, a.p1, a.p2, MY_VEL);
  287.  
  288.   // 2- Moving enemies + checking for death
  289.   for (int eid=0; eid < n_enemies; ++eid) {
  290.  
  291.     // Alive ?
  292.     if (s.en_l[eid] > 0) {
  293.  
  294.       // No target or target collected ? We find a new one
  295.       int tid;
  296.       if (s.en_t[eid] == -1 || !s.dp_a[s.en_t[eid]]) {
  297.     int best_dist = INF;
  298.     tid = -1;
  299.  
  300.     // Looking for the closest DP
  301.     for (int pid=0; pid < n_dp; ++pid) {
  302.       if (s.dp_a[pid]) {
  303.         int d = dist2(dp_x[pid], dp_y[pid], s.en_x[eid], s.en_y[eid]);
  304.         if (d < best_dist) {
  305.           best_dist = d;
  306.           tid = pid;
  307.         }
  308.       }
  309.     }
  310.     s.en_t[eid] = tid;
  311.       }
  312.       else
  313.     tid = s.en_t[eid];
  314.  
  315.       // Moving the enemy
  316.       move(s.en_x[eid], s.en_y[eid], dp_x[tid], dp_y[tid], EN_VEL);
  317.  
  318.       // Storing the distance, and checking for death
  319.       s.dist2[eid] = dist2(s.en_x[eid], s.en_y[eid], s.x, s.y);
  320.    
  321.       if (check_for_death && s.dist2[eid] <= MIN_DIST2) {
  322.     s.killer = eid;
  323.     s.dist_from_killer = s.dist2[eid];
  324.     return STATE_GAME_OVER;
  325.       }
  326.     }
  327.   }
  328.  
  329.   // 3- Shooting
  330.   if (a.type == ACTION_SHOOT) {
  331.     s.en_l[a.p1] -= damage_dealt(s.dist2[a.p1]);
  332.     s.shots++;
  333.     if (s.en_l[a.p1] <= 0 && --s.en_alive == 0)
  334.       return STATE_FINISHED;
  335.   }            
  336.  
  337.   // 4- DP collection
  338.   for (int eid=0; eid < n_enemies; ++eid) {
  339.     if (s.en_l[eid] > 0) {
  340.       int tid = s.en_t[eid];
  341.       if (s.dp_a[tid] && s.en_x[eid] == dp_x[tid] && s.en_y[eid] == dp_y[tid]) {
  342.     s.dp_a[tid] = false;
  343.     if (--s.dp_alive == 0) {
  344.       return (s.en_alive < n_enemies ? STATE_FINISHED : STATE_GAME_OVER);
  345.     }
  346.       }
  347.     }
  348.   }
  349.  
  350.   return STATE_ONGOING;
  351. }
  352.  
  353. // Score at the end of the game
  354. int game_score(State &s) {
  355.   return s.dp_alive * (100 + max(0, total_life - 3*s.shots) * 3) + 10*(n_enemies - s.en_alive);
  356. }
  357.  
  358. // Util function to output the initial conditions of a case in a C++ fashion
  359. // Used to debug locally
  360. #define IC_OUT(k, v) (std::cerr << k << " = " << v << ";" << std::endl)
  361. void output_ICs(State &s) {
  362.   IC_OUT("n_enemies", n_enemies);
  363.   IC_OUT("n_dp", n_dp);
  364.   IC_OUT("s.dp_alive", s.dp_alive);
  365.   IC_OUT("s.en_alive", s.en_alive);
  366.   IC_OUT("s.x", s.x);
  367.   IC_OUT("s.y", s.y);
  368.   for (int i=0; i < n_enemies; ++i) {
  369.     IC_OUT("s.en_x["+std::to_string(i)+"]", s.en_x[i]);
  370.     IC_OUT("s.en_y["+std::to_string(i)+"]", s.en_y[i]);
  371.     IC_OUT("s.en_l["+std::to_string(i)+"]", s.en_l[i]);
  372.     IC_OUT("s.en_t["+std::to_string(i)+"]", -1);
  373.   }
  374.   for (int i=0; i < n_dp; ++i) {
  375.     IC_OUT("dp_x["+std::to_string(i)+"]", dp_x[i]);
  376.     IC_OUT("dp_y["+std::to_string(i)+"]", dp_y[i]);
  377.     IC_OUT("s.dp_a["+std::to_string(i)+"]", s.dp_a[i]);
  378.   }
  379. }
  380.  
  381. // Comparing two solutions
  382. bool operator>(Solution &s1, Solution &s2) {
  383.   // If same final state
  384.   if (s1.final_state == s2.final_state) {
  385.     // If both finished
  386.     if (s1.final_state == STATE_FINISHED) {
  387.       // If same score, we keep the one that finished early
  388.       if (s1.score == s2.score)
  389.     return s1.nactions < s2.nactions;
  390.       // Otherwise, best score
  391.       else
  392.     return s1.score > s2.score;
  393.     }
  394.     // If both losing solutions
  395.     else {
  396.       // If same number of turns played
  397.       if (s1.nactions == s2.nactions) {
  398.     // We keep the death that is the farthest from the killer
  399.     return s1.dist_from_killer > s2.dist_from_killer;
  400.       }
  401.       // Otherwise we keep the solution that survives the longest
  402.       else
  403.     return s1.nactions > s2.nactions;
  404.     }
  405.   }
  406.   // Different states, we keep the one that is not game over
  407.   else
  408.     return s1.final_state == STATE_FINISHED;
  409. }
  410.  
  411. // Playing the turn, high level function
  412. void play_turn(State &s) {
  413.   // First turn = 1s, rest of the time 100ms
  414.   float time_limit = (turn == 1 ? LARGE_TIME_LIMIT : TIME_LIMIT);
  415.   switch(ai_mode) {
  416.   case AI_MODE_MC: play_mc(s, time_limit); break;
  417.   }
  418. }
  419.  
  420. // Playing a monte carlo move
  421. int play_mc(State &s, float time_limit) {
  422.   start = now();
  423.   bool done = false;
  424.   int ite = 0;
  425.   int nbok = 0;
  426.   Solution sol;
  427.  
  428.   // Looping while we have time
  429.   while (!done) {
  430.     ite++;
  431.  
  432.     // Generating a new solution
  433.     State ns(s);
  434.     generate_random_solution(ns, sol, time_limit);
  435.  
  436.     // Comparing the solution with the best one up until now
  437.     if (sol > current_solution) {
  438.       current_solution = sol;
  439.       turn_in_sol = 0;
  440.     }
  441.  
  442.     // Counting how many solutions survive
  443.     if (sol.final_state == STATE_FINISHED)
  444.       nbok++;
  445.    
  446.     elapsed = now() - start;
  447.     done = elapsed.count() > time_limit;
  448.   }
  449.  
  450.   // Stats/Debug
  451.   std::cerr << "Enemies alive : " << s.en_alive << std::endl;
  452.   std::cerr << "DP alive : " << s.dp_alive << std::endl;
  453.   std::cerr << "MC, score expected : " << current_solution.score << std::endl;
  454.   std::cerr << "MC, state expected : ";
  455.   switch(current_solution.final_state) {
  456.   case STATE_ONGOING: std::cerr << "On going ...... ?!!" << std::endl; break;
  457.   case STATE_GAME_OVER: std::cerr << "Lost !" << std::endl; break;
  458.   case STATE_FINISHED: std::cerr << "Finished !" << std::endl; break;
  459.   }
  460.  
  461.   std::cerr << ite << " solutions ; " << nbok << " solutions that survive" << std::endl;
  462.  
  463.   // Output
  464.   Action best_action = current_solution.actions[turn_in_sol];
  465.   if (best_action.type == ACTION_MOVE)
  466.     std::cout << "MOVE " << best_action.p1 << " " << best_action.p2 << " " << ite << std::endl;
  467.   else {
  468.     std::cout << "SHOOT " << best_action.p1 << " " << ite << std::endl;
  469.     s.shots++;
  470.   }
  471.   turn_in_sol++;
  472.  
  473.   // State after playing
  474.   int res = (turn_in_sol < current_solution.nactions ? STATE_ONGOING : current_solution.final_state);
  475.   return res;
  476. }
  477.  
  478. // The main piece of code : Generating a random solution
  479. void generate_random_solution(State &s, Solution &sol, float time_limit) {
  480.   int state = STATE_ONGOING;
  481.   int t = 0;
  482.   Action a;
  483.  
  484.   // Iterating until the end of the playout
  485.   while (state == STATE_ONGOING) {
  486.  
  487.     // Looking for a viable enemy to one shot
  488.     int best_id      = -1;
  489.     int best_dist    =  INF;
  490.     int best_life    =  0;
  491.     int closest_id   = -1;
  492.     int closest_dist = INF;
  493.     bool can_os   = false;
  494.  
  495.     // We get the position of every enemy next turn
  496.     State ns(s);
  497.     a.type=ACTION_NONE;
  498.     evolve(ns, a, false);
  499.    
  500.     // For every enemy
  501.     for (int eid=0; eid < n_enemies; ++eid) {
  502.       if (s.en_l[eid] > 0) {
  503.     int d = ns.dist2[eid];
  504.     int dmg = damage_dealt(d);
  505.  
  506.     // Can we one shot /
  507.     if (dmg >= s.en_l[eid]) {
  508.       can_os = true;
  509.      
  510.       // Closest enemy is preferrable to avoid death
  511.       if (d < best_dist) {
  512.         best_id = eid;
  513.         best_dist = d;
  514.         best_life = s.en_l[eid];
  515.       }
  516.       else if (d == best_dist && s.en_l[eid] > best_life) {
  517.         best_id = eid;
  518.         best_dist = d;
  519.         best_life = s.en_l[eid];  
  520.       }
  521.     }
  522.  
  523.     // We also use this loop to store the closest enemy
  524.     if (d < closest_dist) {
  525.       closest_dist = d;
  526.       closest_id   = eid;
  527.     }
  528.       }
  529.     }
  530.  
  531.     // If we can one-shot we have a 90% probability to shoot
  532.     if (can_os && RAND(100) < PROB_OS) {
  533.       a = Action{ACTION_SHOOT, best_id, 0};
  534.       sol.actions[t++] = a;
  535.       state = evolve(s, a, true);
  536.       continue;
  537.     }
  538.  
  539.     // Si no one-shot, we find a random strategy between the following :
  540.     //  1- Go towards a random DP (full speed)
  541.     //  2- Go towards an enemy (full speed)
  542.     //  3- Random move
  543.     //  4- Kill an enemy (shoot until it's dead)
  544.    
  545.     int prob = 150; // Rescaling ... ugly but work
  546.     int action = RAND(prob);
  547.     int nreps = RAND(4) + 1;  // How many repetitions ? (up to 5)
  548.     int ite = 0;
  549.  
  550.     // 1- DP
  551.     if (action <= PROB_GO_DP) {
  552.       int pids[MAX_DP];
  553.       int ndp=0;
  554.       for (int i=0; i < n_dp; ++i)
  555.     if (s.dp_a[i])
  556.       pids[ndp++] = i;
  557.        
  558.       int tid = pids[RAND(ndp)];
  559.       while (state == STATE_ONGOING && ite < nreps) {          
  560.     a = Action{ACTION_MOVE, dp_x[tid], dp_y[tid]};
  561.     sol.actions[t++] = a;
  562.     state = evolve(s, a, true);
  563.     ite++;
  564.       }
  565.     }
  566.    
  567.     // 2- Enemy
  568.     else if (action <= PROB_GO_EN) {      
  569.       int eid = random_enemy(s);
  570.      
  571.       while (state == STATE_ONGOING && ite < nreps) {    
  572.     int x = s.x;
  573.     int y = s.y;
  574.     move(x, y, s.en_x[eid], s.en_y[eid], MY_VEL);
  575.    
  576.     a = Action{ACTION_MOVE, x, y};
  577.     sol.actions[t++] = a;
  578.     state = evolve(s, a, true);
  579.     ite++;
  580.       }
  581.     }
  582.    
  583.     // 3- Random move
  584.     else if (action <= PROB_GO_RD) {
  585.       int move = RAND(N_RANDOM);
  586.       int rx = rand_x[move];
  587.       int ry = rand_y[move];
  588.    
  589.       while (state == STATE_ONGOING && ite < nreps) {
  590.     a = Action{ACTION_MOVE, s.x + rx, s.y + ry};
  591.     sol.actions[t++] = a;
  592.     state = evolve(s, a, true);
  593.     ite++;
  594.       }
  595.     }
  596.    
  597.     // 4- Shooting the closest enemy
  598.     else {
  599.       a = Action{ACTION_SHOOT, closest_id, 0};
  600.       while (state == STATE_ONGOING && s.en_l[closest_id] > 0) {
  601.     sol.actions[t++] = a;
  602.     state = evolve(s, a, true);
  603.       }
  604.     }
  605.   }
  606.  
  607.   // Copying final state, and filling in the info
  608.   sol.final_state = state;
  609.   sol.score = game_score(s);
  610.   if (state == STATE_GAME_OVER)
  611.     sol.dist_from_killer = s.dist_from_killer;
  612.   sol.nactions = t;
  613. }
  614.  
  615. // Main, obvious
  616. int main() {
  617.   srand(26111996);
  618.   turn = 0;
  619.   ai_mode = AI_MODE_MC;
  620.  
  621.   State s;
  622.   turn_in_sol = 0;
  623.   current_solution.score = -INF;
  624.  
  625.   while (true) {
  626.     read_state_from_stdin(s, turn==0);
  627.     turn++;
  628.     play_turn(s);
  629.   }
  630. }
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×