@jutge.org/toolkit 4.2.23 → 4.2.24

package/assets/problems/games/the-walking-dead.pbm/ca/Doc-eng/rules.tex

@@ -0,0 +1,194 @@
+
+\section{Game Rules}
+
+Due to yet unknown reasons, the Earth is going through a zombie
+apocalypse. The few human survivors fight to stay alive and to gain
+control of the scarce existing resources.
+
+This is a game for four players, identified with numbers from 0 to
+3. Each player has control over a clan of alive units. But there are
+two additional types of units in the game: dead units and zombies.
+
+The game lasts 200 rounds, numbered from 1 to 200. Each unit
+can move at most once per round. Dead units, as expected, cannot move.
+During the rounds, the clans accumulate points and the winner
+of the game is the clan with the largest amount of points after
+round 200.
+
+The board game has dimensions $60 \times 60$. Units cannot move
+outside it.  A position in the board is given by a pair of integers
+$(r,c)$ where $0 \leq r < 60$ and $0\leq c < 60$. The top-left
+position is $(0,0)$, whereas the bottom-right position is
+$(59,59)$. Hence, $r$ (for row) refers to the vertical axis and $c$
+(for column) refers to the horizontal axis. Each cell in the board is
+either part of a street or is full of waste. Units cannot move on
+waste and must necessarily move through streets.
+
+Clans start the game with a certain amount of strength points.  The
+{\em strength of a clan} is defined as $\left\lfloor{{\texttt{strength
+      points}}\over{\texttt{alive units}}}\right\rfloor$ and is key
+for determining the winner of the fights that will occur during the
+game.  After each round, the strength points of a clan will be
+decremented in an amount equal to the number of alive units of that
+clan. However, strength points are never negative. In order to
+increment strength points, alive units can collect food. It is easy to
+see that a clan with a lot of alive units needs to collect a lot of
+food in order to have a good amount of strength.  Thus, some units
+decide to abandon their clan: at each round, with a probability of
+$20\%$, a unit from the clan with the most number of alive units
+becomes part of the clan with the least amount of alive units. If
+there are several clans with these properties, one of them is chosen
+randomly.
+
+\bigskip
+    {\bf Movements of alive units.} An alive unit moves in the board following these rules:
+    
+\begin{itemize}
+\item It can only move to adjacent cells horizontally and vertically, never in diagonal.
+  
+\item If it tries to move to a cell occupied by waste, by a unit of
+  the same clan, o by a dead unit, the movement will be ignored.
+
+\item If it moves to a cell with food, the strength points of its clan will be incremented,
+  the unit will occupy the cell, the food item will disappear and the clan will possess this cell.
+  At the end of the round, a food item will reappear in another position. Note that we will never
+  find a cell occupied by food and by a unit.
+
+\item It it tries to move to an empty cell (without food or unit),
+  the movement will be done and the clan will possess this cell.
+
+\item If it moves to a cell occupied by a zombie, the zombie will die but the unit will not move. As a result,
+  the clan will receive a certain number of points and, at the end of the round, an alive unit
+  of this clan will reappear in another position, and the zombie will disappear.
+
+\item If it moves to a cell occupied by an alive unit of another clan, a fight will start. The
+  unit losing the fight will become a dead unit, and the process of zombie conversion will start: after a certain
+  number of rounds, it will be a zombie. If this unit had already started a zombie conversion process for being
+  bitten by a zombie, the process will restart. The clan of the unit winning the fight will receive
+  a certain number of points, but the unit will not move. The winner of the fight is determined as follows:
+
+  With a probability of $30\%$, the unit starting the fight will
+  surprise the other unit and hence will win the fight
+  immediately. Otherwise, if the strengths of the clans involved in
+  the fight are $N$ and $M$, respectively, the first unit will win
+  with probability $N/(N+M)$ and the second unit with probability
+  $M/(N+M)$. If $N = M = 0$, the units will have the same probability
+  of winning.
+\end{itemize}
+
+{\bf Movements of zombies.} Zombies are not part of any clan and hence
+are not controlled by any player.  Zombies will always move to the
+closest alive unit, considering that they cannot move through
+waste. If there are multiple units at the same distance, one of them
+will be randomly chosen. A zombie will always move following these
+rules:
+
+\bigskip
+\begin{itemize}
+  
+\item It can move to adjacent cells horizontally, vertically and also in diagonal.
+    
+\item It will never move to a cell occupied by waste, a dead unit or a zombie.
+    
+\item If it moves to a cell occupied by food, the food will
+  disappear. At the end of the round, a food item will reappear in a
+  random position. If a clan was possessing this cell, it will stop
+  doing so.
+
+\item If it moves to an empty cell (with no food or unit)
+  owned by a clan, this clan will stop possessing this cell.
+
+\item If it tries to move to a cell with an alive unit on it, the movement will not be done.
+  However, it will bite the unit and it will start the process of becoming a zombie, that will finish
+  after a certain number of rounds. If that process had already started due to a previous bite,
+  the process will not restart, but rather continue. During the conversion, the unit will behave
+  as an alive one.
+\end{itemize}
+
+As a result of the previous rules, the total number of units is constant during the game.
+
+\bigskip
+    {\bf Object regeneration.}
+    Every time a food unit or an alive unit needs to be regenerated, it will always appear in an
+    empty cell $C$ with no unit or food in the surrounding cells (the ones with an x in the table):
+
+\medskip
+\begin{center}
+  \begin{tabular}{|c|c|c|c|c|}\hline
+    x & x & x & x & x \\\hline
+    x & x & x & x & x \\\hline
+    x & x & C & x & x \\\hline
+    x & x & x & x & x \\\hline
+    x & x & x & x & x \\\hline
+  \end{tabular}
+\end{center}
+\medskip
+
+If there is no safe cell in this sense, the object will reappear in an empty cell,
+with no unit or food in it.
+
+It is important to remark that units have an identifier that never changes, not even
+after they are regenerated. For example, if a unit with a certain initial identifier becomes
+a zombie, it will still have the same identifier. If, later on, the zombie is killed and reappears
+as an alive unit of another clan, the identifier will still be the same.
+
+\bigskip
+    {\bf Score computation.} The score of a clan in a given round is given by two components.
+    On the one hand, for each zombie that the clan has killed so far, 10 points will be awarded.
+    For each killed alive unit, 50 points will be given.
+
+    On the other hand, for each cell owned by the clan {\bf in this
+      round} 1 point is given. The score of a clan is the sum of these
+    two components. Note that the score can be decremented if a clan
+    loses the possession of a cell. The constants 10, 50 and 1, as
+    well as other constants that define the initial settings of the
+    game, are defined in the input file \texttt{default.cnf}.  All
+    games will be played with the values given in this file.
+    
+\bigskip
+{\bf Execution of orders.}
+In each round, more than one order can be given to the same unit,
+although only the first such order (if any) will be selected. Any player
+that tries to give more than 1000 orders during the same round will be aborted.
+
+Every round, the selected movements of the four players will be executed using a random order,
+but respecting the relative order of the units of the same clan.
+As a consequence of the previous rule, consider giving the orders to your units at every
+round from most urgent to least urgent.
+
+Take into account that the every movement is applied to the board resulting
+of the previous movements. For example, consider the board
+
+\medskip
+\begin{center}
+  \begin{tabular}{|c|c|c|c|c|}\hline
+    x & x & x & x \\\hline
+    x & F & U & x \\\hline
+    x & V & x & x \\\hline
+    x & x & x & x \\\hline
+  \end{tabular}
+\end{center}
+\medskip
+
+where F represents food and U, V two alive units of different clans.
+Let us assume that the player controlling U decides that it should go
+left, and the player controlling V decides to go up. If the V movement
+is executed first, then U has no food left, because V has already
+taken it. Moreover, the subsequent movement of U is an attack to V. If
+U dies in this fight, in the visualization of the game we will see a
+transition from the previous matrix to a situation where U has
+disappeared. Obviously, there could be no attack between U and V in
+the original configuration because units cannot move diagonally, but
+the execution order of the movements has made it possible. Take this
+into account when you do not understand certain situations in the
+visualization of games.
+
+After the execution of all movements from the players, the movements
+of zombies are executed.  After that, the following processes are
+executed in this order: units that have finished their conversion
+process become zombies, killed zombies will reappear as alive units, a
+unit from the clan with the largest number of alive units might move
+to the clan with the least number of alive units, food items will be
+regenerated and scores will be updated.
+
+

package/assets/problems/games/the-walking-dead.pbm/ca/Doc-eng/tips.tex

@@ -0,0 +1,85 @@
+
+\section{Tips}
+
+  \begin{itemize}
+
+\item \textbf{DO NOT GIVE OR ASK YOUR CODE TO/FROM ANYBODY.} Not even
+  an old version. Not even to your best friend. Not even from students
+  of previous years. We will use plagiarism detectors to compare
+  pairwise all submissions and also with submissions from previous
+  editions.  However, you can share the compiled \texttt{.o} files.
+  
+  Any detected plagiarism will result in an {\bf overall grade of 0}
+  in the course (not only in the Game) of all involved students.
+  Additional disciplinary measures might also be taken. If student A
+  and B are involved, measures will be applied to both of them,
+  independently of who created the original code. No exceptions will
+  be made under any circumstances.
+
+\item Before competing with your classmates, focus on qualifying and
+defeating the ''Dummy'' player.
+
+\item Read only the headers of the classes in the provided source
+  code. Do not worry about the private parts nor the implementation.
+
+\item Start with simple strategies, easy to code and debug, since this
+is exactly what you will need at the beginning.
+
+\item Define basic auxiliary methods, and make sure they work
+  properly.
+
+\item Try to keep your code clean. Then it will be easier to change it
+and to add new strategies.
+
+\item As usual, compile and test your code often. It is \emph{much}
+easier to trace a bug when you only have changed few lines of code.
+
+\item Use \texttt{cerr}s to output debug information and add
+  \texttt{assert}s to make sure the code is doing what it should do.
+  Remember to remove (or comment out) the \texttt{cerr}s before
+  uploading your code to Jutge.org. Otherwise, your submission will be
+  killed.
+
+
+\item When debugging a player, remove the \texttt{cerr}s you may have in
+the other players' code, to make sure you only see the messages you
+want.
+
+\item By using commands like \texttt{grep} in Linux you can filter the
+  output that \texttt{Game} produces.
+  
+\item Switch on the \texttt{DEBUG} option in the Makefile, which will
+allow you to get useful backtraces when your program crashes. There is
+also a \texttt{PROFILE} option you can use for code optimization.
+
+\item If using \texttt{cerr} is not enough to debug your code, learn
+  how to use \texttt{valgrind}, \texttt{gdb}, \texttt{ddd} or any
+  other debugging tool. 
+
+\item You can analyze the files that the program \texttt{Game}
+produces as output, which describe how the board evolves after each
+round.
+
+\item Keep a copy of the old versions of your player. When a new
+version is ready, make it fight against the previous ones to measure
+the improvement.
+
+\item Make sure your program is fast enough: the CPU time you are
+allowed to use is rather short.
+
+\item Try to figure out the strategies of your competitors by
+watching matches. This way you can try to defend against them or
+even improve them in your own player.
+
+\item Do not wait till the last minute to submit your player. When
+there are lots of submissions at the same time, it will take longer for
+the server to run the matches, and it might be too late!
+
+\item You can submit new versions of your program at any time.
+
+\item And again: Keep your code simple, build often, test often. Or
+you will regret.
+
+\end{itemize}
+
+

package/assets/problems/games/the-walking-dead.pbm/ca/Doc-eng/viewer.tex

@@ -0,0 +1,36 @@
+\section{The Viewer}
+
+We know describe the viewer:
+
+\begin{itemize}
+  
+\item
+  In the upper part there are buttons that allow us to reproduce or stop the game, go to
+  the beginning or to the end, enable or disable the animation mode or obtaining a help window
+  with more ways to control the visualization. You will also see the current round and a button
+  to close the game. A horizontal toggle bar shows in which point of the game the current round is.
+  
+\item
+  In the left column, each player appears with her name and color. Below, we can see the
+  current score, the number of alive units and the player strength. In the game played in
+  Jutge.org, we can also see the percentage of CPU time that has been used (if consumed, a message
+  'out' is displayed). In the upper-right part we can see the colors of the players, ordered by score.
+  
+\item Cells have the color of the player that owns them. Otherwise, they are white.
+
+\item Waste cells are dark grey.
+
+\item Alive units are represented as circles of the corresponding color. If they are becoming zombies, they are squares.
+
+\item Dead units are represented by a cross.
+
+\item Zombies are represented by a red square with a black outer frame.
+  
+\item Food units are represented by a red circle with a black outer frame.
+  
+\end{itemize}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: t
+%%% End:

package/assets/problems/games/the-walking-dead.pbm/ca/Runner/AIDemo.cc

@@ -0,0 +1,89 @@
+#include "Player.hh"
+
+
+/**
+ * Write the name of your player and save this file
+ * with the same name and .cc extension.
+ */
+#define PLAYER_NAME Demo
+
+// DISCLAIMER: The following Demo player is *not* meant to do anything
+// sensible. It is provided just to illustrate how to use the API.
+// Please use AINull.cc as a template for your player.
+
+struct PLAYER_NAME : public Player {
+
+  /**
+   * Factory: returns a new instance of this class.
+   * Do not modify this function.
+   */
+  static Player* factory () {
+    return new PLAYER_NAME;
+  }
+
+
+  /**
+   * Types and attributes for your player can be defined here.
+   */
+  const vector<Dir> dirs = {Up,Down,Left,Right};
+
+
+
+  /**
+   * Play method, invoked once per each round.
+   */
+  virtual void play () {
+    
+    // If nearly out of time, do nothing.
+    double st = status(me());
+    if (st >= 0.9) return;
+
+    // If more than halfway through, do nothing.
+    if (round() > num_rounds()/2) return;
+
+    // Getting the alive units
+    vector<int> alive = alive_units(me());
+
+    // Write debugging info about my units
+    cerr << "At round " << round() << " player " << me() << " has " << alive.size() << " alive units: ";
+    for (auto id : alive) {
+      cerr << id << " at pos " << unit(id).pos << "; ";
+    }
+    cerr << endl;
+
+    if (round()% 2 == 0) {
+      // Move all alive units randomly (avoiding out of bounds and waste)
+      for (int id : alive) {
+	Dir d = dirs[random(0,dirs.size()-1)];
+	Pos new_pos = unit(id).pos + d;
+	if (pos_ok(new_pos) and cell(new_pos.i,new_pos.j).type != Waste) move(id,d);
+      }
+    }
+    else {
+      if (random(0,3) <= 1) {// Do this with 25% probability [move all units to the left]
+	for (int id : alive) {
+	  Dir d = Left;
+	  Pos new_pos = unit(id).pos + d;
+	  if (pos_ok(new_pos) and cell(new_pos.i,new_pos.j).type != Waste) move(id,d);
+	}
+      }
+      else { // With probability 75%: kill adjacent zombies
+	for (int id : alive) {
+	  for (auto d : dirs) {
+	    Pos new_pos = unit(id).pos + d;
+	    if (pos_ok(new_pos)) {
+	      int id_in_cell = cell(new_pos.i,new_pos.j).id;
+	      if (id_in_cell != -1 and unit(id_in_cell).type == Zombie) {move(id,d); break;}
+	    }
+	  }
+	}
+      }
+    }
+  }
+};
+
+
+/**
+ * Do not modify the following line.
+ */
+RegisterPlayer(PLAYER_NAME);

package/assets/problems/games/the-walking-dead.pbm/ca/Runner/AIDummy.cc

@@ -0,0 +1,202 @@
+#include "Player.hh"
+#include <climits>
+#include <queue>
+
+/**
+ * Write the name of your player and save this file
+ * with the same name and .cc extension.
+ */
+#define PLAYER_NAME Dummy
+
+
+struct PLAYER_NAME : public Player {
+
+  /**
+   * Factory: returns a new instance of this class.
+   * Do not modify this function.
+   */
+  static Player* factory () {
+    return new PLAYER_NAME;
+  }
+
+  /**
+   * Types and attributes for your player can be defined here.
+   */
+
+  const vector<Dir> dirs = { Down, Right, Up, Left };
+
+  const int oo = INT_MAX;
+
+  bool dead_in_pos (const Pos& p)  {
+    return pos_ok(p) and cell(p.i,p.j).id != -1 and unit(cell(p.i,p.j).id).type == Dead;
+  }
+
+  bool zombie_in_pos (const Pos& p)  {
+    return pos_ok(p) and cell(p.i,p.j).id != -1 and unit(cell(p.i,p.j).id).type == Zombie;
+  }
+
+  bool alive_in_pos (const Pos& p)  {
+    return pos_ok(p) and cell(p.i,p.j).id != -1 and unit(cell(p.i,p.j).id).type == Alive;
+  }
+
+  bool alive_same_clan_in_pos (const Pos& p, int pl)  {
+    return pos_ok(p) and cell(p.i,p.j).id != -1 and unit(cell(p.i,p.j).id).type == Alive and
+      unit(cell(p.i,p.j).id).player == pl;
+  }
+
+  
+
+  vector<vector<int>> distances_to_food ( ) {
+    vector<vector<int>> distances(board_rows(),vector<int>(board_cols(),oo));
+    queue<Pos> Q;
+    for (int i = 0; i < board_rows(); ++i)
+      for (int j = 0; j < board_cols(); ++j){
+	if (cell(i,j).food) {
+	  distances[i][j] = 0;
+	  Q.push({i,j});
+	}
+      }
+    
+    while (not Q.empty()) {
+      Pos p = Q.front(); Q.pop();
+      for (auto d : dirs) {
+	Pos np = p + d;
+	if (pos_ok(np) and cell(np.i,np.j).type == Street and
+	    not dead_in_pos(np) and
+	    not zombie_in_pos(np) and
+	    not alive_in_pos(np) and
+	    distances[np.i][np.j] == oo) {
+	  assert(distances[p.i][p.j] >= 0);
+	  distances[np.i][np.j] = distances[p.i][p.j] + 1;
+	  Q.push(np);
+	}
+      }      
+    }
+    return distances;
+  }
+
+  vector<vector<int>> distances_to_attackable_enemy (int pl) {
+    vector<vector<int>> distances(board_rows(),vector<int>(board_cols(),oo));
+    queue<Pos> Q;
+    for (int i = 0; i < board_rows(); ++i)
+      for (int j = 0; j < board_cols(); ++j){
+	if (cell(i,j).id != -1 and unit(cell(i,j).id).player != pl and unit(cell(i,j).id).type == Alive) {
+	  distances[i][j] = 0;
+	  Q.push({i,j});
+	}
+      }
+    
+    while (not Q.empty()) {
+      Pos p = Q.front(); Q.pop();
+      for (auto d : dirs) {
+	Pos np = p + d;
+	if (pos_ok(np) and cell(np.i,np.j).type == Street and
+	    not dead_in_pos(np) and
+	    not zombie_in_pos(np) and
+	    not alive_in_pos(np) and
+	    distances[np.i][np.j] == oo) {
+	  assert(distances[p.i][p.j] >= 0);
+	  distances[np.i][np.j] = distances[p.i][p.j] + 1;
+	  Q.push(np);
+	}
+      }      
+    }
+    return distances;
+  }
+  
+  vector<vector<int>> distances_to_zombie ( ) {
+    vector<vector<int>> distances(board_rows(),vector<int>(board_cols(),oo));
+    queue<Pos> Q;
+    for (int i = 0; i < board_rows(); ++i)
+      for (int j = 0; j < board_cols(); ++j){
+	if (cell(i,j).id != -1 and unit(cell(i,j).id).type == Zombie) {
+	  distances[i][j] = 0;
+	  Q.push({i,j});
+	}
+      }
+    
+    while (not Q.empty()) {
+      Pos p = Q.front(); Q.pop();
+      for (auto d : dirs) {
+	Pos np = p + d;
+	if (pos_ok(np) and cell(np.i,np.j).type == Street and
+	    not dead_in_pos(np) and
+	    not zombie_in_pos(np) and
+	    not alive_in_pos(np) and
+	    distances[np.i][np.j] == oo) {
+	  assert(distances[p.i][p.j] >= 0);
+	  distances[np.i][np.j] = distances[p.i][p.j] + 1;
+	  Q.push(np);
+	}
+      }      
+    }
+    return distances;
+  }
+
+  pair<Dir,int> closest_dir (int id, const vector<vector<int>>& dist) {
+    Pos p = unit(id).pos;
+    int s_d = oo; // shortest distance
+    Dir best_dir = Up;
+    for (auto d : dirs) {
+      Pos np = p + d;
+      if (pos_ok(np) and cell(np.i,np.j).type != Waste and dist[np.i][np.j] < s_d) {
+	s_d = dist[np.i][np.j];
+	best_dir = d;
+      }
+    }
+    return {best_dir,s_d};
+  }
+  
+  virtual void play() {
+
+    vector<vector<int>> dist_food = distances_to_food();
+    vector<vector<int>> dist_attack = distances_to_attackable_enemy(me());
+    vector<vector<int>> dist_zombie = distances_to_zombie();
+    
+    // for (uint i = 0; i < distances.size(); ++i){
+    //   for (uint j = 0; j < distances[i].size(); ++j){
+    // 	if (distances[i][j] == oo) cout << " in";
+    // 	else {
+    // 	  cout << " ";
+    // 	  if (distances[i][j] < 10) cout << " ";
+    // 	  cout << distances[i][j];
+    // 	}
+    //   }
+    //   cout << endl;
+    // }
+
+    
+    for (auto id : alive_units(me())) {
+      pair<Dir,int> res_f = closest_dir(id,dist_food);
+      pair<Dir,int> res_a = closest_dir(id,dist_attack);
+      pair<Dir,int> res_z = closest_dir(id,dist_zombie);
+
+      int best_dist = oo;
+      Dir d = Up;
+      if (random(0,100) < 80) {
+	if (res_f.second < best_dist) {
+	  d = res_f.first;
+	  best_dist = res_f.second;
+	}
+      }
+            
+      if (res_a.second < best_dist) {
+	d = res_a.first;
+	best_dist = res_a.second;
+      }
+
+      if (res_z.second < best_dist) {
+	d = res_z.first;
+	best_dist = res_z.second;
+      }
+
+      if (best_dist < oo) move(id,d);
+    }
+  }
+    
+};
+
+/**
+ * Do not modify the following line.
+ */
+RegisterPlayer(PLAYER_NAME);

package/assets/problems/games/the-walking-dead.pbm/ca/Runner/AINull.cc

@@ -0,0 +1,37 @@
+#include "Player.hh"
+
+
+/**
+ * Write the name of your player and save this file
+ * with the same name and .cc extension.
+ */
+#define PLAYER_NAME Null
+
+
+struct PLAYER_NAME : public Player {
+
+  /**
+   * Factory: returns a new instance of this class.
+   * Do not modify this function.
+   */
+  static Player* factory () {
+    return new PLAYER_NAME;
+  }
+
+  /**
+   * Types and attributes for your player can be defined here.
+   */
+
+  /**
+   * Play method, invoked once per each round.
+   */
+  virtual void play () {
+  }
+
+};
+
+
+/**
+ * Do not modify the following line.
+ */
+RegisterPlayer(PLAYER_NAME);