@jutge.org/toolkit 4.2.23 → 4.2.24

package/assets/problems/games/the-walking-dead.pbm/ca/Runner/Board.hh

@@ -0,0 +1,287 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#ifndef Board_hh
+#define Board_hh
+
+
+#include "Info.hh"
+#include "Action.hh"
+#include "Random.hh"
+
+
+/**
+ * Contains the Board class, with all the game information,
+ * plus the names of the players and a random generator.
+ */
+
+
+/**
+ * Manages a random generator and the information of the board.
+ */
+class Board : public Info, public Random_generator {
+
+  friend class Game;
+  friend class SecGame;
+
+  vector<string> names;
+  int            fresh_id;
+
+  /**
+   * Checks whether initial fixed board is ok
+   */
+  void check_is_good_initial_fixed_board() const;  
+  
+  /**
+   * Reads the generator method, and generates or reads the grid.
+   */
+  void read_generator_and_grid (istream& is) {
+    string generator;
+    is >> generator;
+    if (generator == "FIXED") {
+      read_grid(is);
+      check_is_good_initial_fixed_board();
+    }
+    else if (generator == "RANDOM") generate_random_board();
+    else                            _my_assert(false,"unknown generator  " + generator);
+  }
+
+  /**
+   * Prints some information of the unit.
+   */
+  inline static void print_unit (Unit& u, ostream& os) {
+    os << UnitType2char(u.type)  << '\t'
+       << u.id                      << '\t'
+       << u.player                  << '\t'
+       << u.pos.i                   << '\t'
+       << u.pos.j                   << '\t'        
+       << u.rounds_for_zombie       << '\t'
+       << endl;
+  }
+
+
+  /**
+   * Tries to apply a move. Returns true if it could.
+   */
+  bool execute(const Command&    m,
+	       vector<int>&          food_to_regenerate,
+	       vector<vector<int>>&  zombie_to_unit,
+	       vector<vector<int>>&  alive_to_dead
+	       );
+
+
+  /*
+   * Returns whether unit u1 wins u2 in an attack
+   */
+  bool first_unit_wins_attack(const Unit& u1, const Unit& u2);
+
+  /* 
+   * Perfom an attack from orig_u to dest_u and updates alive_to_dead accordingly
+   */
+  void perform_attack (Unit& orig_u, Unit& dest_u, vector<vector<int>>& alive_to_dead);  
+
+  /*
+   * Returns whether p is an appropriate position to regenerate an object.
+     Should be empty and have no unit/food in the two surrounding squares
+   */
+  bool is_good_pos_to_regen ( const Pos& p) const;
+
+  /*
+   * Tries to get a random position which is good_pos_to_regen. If not, return an empty position
+   * Note that there should always be empty positions in the board
+   */  
+  Pos get_random_pos_where_regenerate ( );
+  
+  /*
+   * All units with rounds_for_zombie == 0 are converted into zombies.
+   * player2alive, player2dead and zombies_ are updated accordingly
+   */  
+  void execute_conversion_to_zombie ( );
+
+  /*
+   * zombie_to_unit[p] contains all zombies that player p has killed in last round
+   * All these units are regenerated as alive units of player p
+   * player2alive and zombies_ are updated accordingly
+   */  
+  void execute_conversion_zombie_to_alive (vector<vector<int>>& zombie_to_unit);
+
+  /*
+   * alive_to_dead[p] contains all alive units of player p that have been killed in last round
+   * All these units are converted to dead
+   * player2alive and player2dead are updated accordingly
+   */  
+  void execute_conversion_alive_to_dead (vector<vector<int>>& alive_to_dead);
+
+  /*
+   * With probability 20% an alive unit from the clan with largest number of alive units becomes 
+   * an alive unit of the clan with smallest number of alive units.
+   * player2alive is updated accordingly
+   */    
+  void execute_random_conversion_live_unit ( );
+
+  /*
+   * Returns <p1,p2> where p1 is a player with minimum number of alive units and
+   * p2 is a player with maximum number of alive units
+   */      
+  pair<int,int> selectLargestSmallestClan ( );
+
+  /* 
+   * Decrement round_for_zombie for all units such that round_for_zombie > 0
+   */
+  void decrement_rounds_for_becoming_zombie ( );
+
+  /*
+    Generate a new food item on the board. Used for regenerating consumed food items
+   */
+  void generate_food_item ( );
+
+  /* 
+   * food_to_regenerate[p] is the number of food items consumed by player p in last round
+   * Food items consumed by zombis are in position 4
+   * We regenerate all food items and update the strength of clans accordingly
+   */
+  void regenerate_food_and_update_strength (vector<int>& food_to_regenerate);
+
+  /*
+   * Update nb_cells vector so that it contains the number of cell possessed by each player
+   */
+  void update_nb_cells ( );
+
+  /* 
+   * Update scr vector in order to contain the score of each player
+   */
+  void update_score ( );
+
+  /* 
+   * Returns whether cell(i,j) has a dead unit on it
+   */
+  bool cell_has_dead_unit (int i, int j);
+
+  /* 
+   * Returns whether cell(i,j) has a zombie on it
+   */
+  bool cell_has_zombie (int i, int j);
+
+  /*
+   * Move all zombies at the end of the round by moving them to the closest alive unit
+   * Parameters food_to_regenerate, zombie_to_unit, alive_to_dead and commands_done are needed for calling "execute"
+   */
+  void move_zombies (vector<int>& food_to_regenerate, vector<vector<int>>& zombie_to_unit, vector<vector<int>>& alive_to_dead, vector<Command>& commands_done);
+  
+  /////////////////////// BEGIN BOARD GENERATION ///////////////////////
+
+
+  /**
+   * Generates a board.
+   */
+  void generate_random_board ( );
+  
+  /**
+   * Randomnly returns an empty pos
+   */
+  Pos get_empty_pos ( );
+
+  /**
+   * s_id identifies the current street. Position should be not in border. Not already occupied by street. 
+   * Num of adjacent cells of the current street is <= 2.
+   * Num of adjacents cells of other streets is 0.
+   */
+  bool pos_ok_for_street(int s_id, const Pos& p);
+
+  /**
+   * s_id identifies the current street. Position should be not in border. Not already occupied by street. 
+   * Num of adjacent cells of some street is 0.
+   */
+  bool pos_ok_for_initial_street(const Pos& p);
+  
+  /**
+   * Randomnly returns a position that fulfills pos_ok_for_street(s_id)
+   */
+  Pos get_ok_pos_for_street (int s_id );
+
+  /**
+   * Randomnly returns a position that fulfills pos_ok_for_initial_street()
+   */
+  Pos get_ok_pos_for_initial_street ( );
+
+
+  /**
+   * Tries to randomly generates num_building_cells cells of type Building in num_street disconnected parts
+   * Sometime it does not succeed and generates less.
+   */
+  void generate_all_waste (int num_building_cells, int num_streets);
+
+  /**
+  * Tries to generate a stree of length with identifier s_id
+  */
+  int generate_waste (int s_id, int length);
+
+  /**
+   * Returns the number of connected component grid has (taking into account only streets and buildings)
+   */
+  int num_connected_components( );
+
+  /** 
+   * Auxiliary DFS to count connected components
+   */
+  void explore_from(vector<vector<int>>& G, int i, int j, int n);
+
+  /** 
+   * Creates a unit alive unit for player in position p
+   */  
+  void create_new_unit (Pos& p, int player);
+
+  /** 
+   * Creates a zombie at position p
+   */  
+  void create_new_zombie (Pos& p);
+  
+  // Grid that stores the already generated streets. 0 means no street. Otherwise, contains street_ids
+  vector<vector<int>> street_plan;
+
+  vector<Dir> dir_permutation ( );
+  /////////////////////// END BOARD GENERATION ///////////////////////  
+  
+public:
+
+  /**
+   * Construct a board by reading information from a stream.
+   */
+  Board (istream& is, int seed);
+
+  /**
+   * Returns the name of a player.
+   */
+  inline string name (int pl) const {
+    _my_assert(player_ok(pl), "Player is not ok.");
+    return names[pl];
+  }
+
+  /**
+   * Prints the board settings to a stream.
+   */
+  void print_settings (ostream& os) const;
+
+  /**
+   * Prints the name players to a stream.
+   */
+  void print_names (ostream& os) const;
+
+  /**
+   * Prints the state of the board to a stream.
+   */
+  void print_state (ostream& os);
+
+  /**
+   * Prints the results and the names of the winning players.
+   */
+  void print_results () const;
+
+  /**
+   * Computes the next board aplying the given actions to the current board.
+   * It also prints to os the actual actions performed.
+   */
+  void next (const vector<Action>& act, ostream& os);
+
+};
+
+#endif

package/assets/problems/games/the-walking-dead.pbm/ca/Runner/Defs.hh

@@ -0,0 +1,2 @@
+#define GAME_NAME "TheWalkingDead"
+#define VERSION   "1.0"

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

@@ -0,0 +1,55 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#include "Game.hh"
+
+
+void Game::run (vector<string> names, istream& is, ostream& os, int seed) {
+  cerr << "info: seed " << seed << endl;
+
+  cerr << "info: loading game" << endl;
+  Board b(is, seed);
+  cerr << "info: loaded game" << endl;
+
+  int np = b.num_players();
+  int nr = b.num_rounds();
+
+  _my_assert(np == (int)names.size(), "Wrong number of players.");
+
+  vector<Player*> players;
+  for (int pl = 0; pl < np; ++pl) {
+    string name = names[pl];
+    b.names[pl] = name;
+    cerr << "info: loading player " << name << endl;
+    players.push_back(Registry::new_player(name));
+    players[pl]->me_ = pl;
+    players[pl]->set_random_seed(seed + pl + 1);
+    *static_cast<Settings*>(players[pl]) = (Settings)b;
+  }
+  cerr << "info: players loaded" << endl;
+
+  os << "Game" << endl << endl;
+  os << "Seed " << seed << endl << endl;
+  b.print_settings(os);
+  b.print_names(os);
+  b.print_state(os);
+
+  for (int round = 0; round < nr; ++round) {
+    cerr << "info: start round " << round << endl;
+    vector<Action> actions(np);
+    for (int pl = 0; pl < np; ++pl) {
+      cerr << "info:     start player " << pl << endl;
+      players[pl]->reset(b);
+      players[pl]->play();
+      actions[pl] = *players[pl];
+      cerr << "info:     end player " << pl << endl;
+    }
+
+    b.next(actions, os);
+    b.print_state(os);
+    cerr << "info: end round " << round << endl;
+  }
+
+  b.print_results();
+
+  cerr << "info: game played" << endl;
+}

package/assets/problems/games/the-walking-dead.pbm/ca/Runner/Game.hh

@@ -0,0 +1,23 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#ifndef Game_hh
+#define Game_hh
+
+
+#include "Player.hh"
+#include "Board.hh"
+
+
+/**
+ * Game class.
+ */
+class Game {
+
+public:
+
+  static void run (vector<string> names, istream& is, ostream& os, int seed);
+
+};
+
+
+#endif

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

@@ -0,0 +1,174 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#include "Info.hh"
+
+bool Info::ok() const {
+
+  if (int(grid.size()) != board_rows()) {
+    cerr << "error: mismatch in number of rows" << endl;
+    return false;
+  }
+
+  if (int(grid[0].size()) != board_cols()) {
+    cerr << "error: mismatch in number of columns" << endl;
+    return false;
+  }
+
+  if (not (rnd >= 0 and rnd <= num_rounds())) {
+    cerr << "error: wrong number of rounds" << endl;
+    return false;
+  }
+  
+  for (int pl = 0; pl < num_players(); ++pl) {
+    double st = stats[pl];
+    if (st != -1 and not (0 <= st and st <= 1)) {
+      cerr << "error: status should be -1 or within [0, 1]" << endl;
+      return false;
+    }
+  }
+
+  if (int(player2alive_units.size()) != num_players()) {
+    cerr << "error: size of player2alive_units should be number of players" << endl;
+    return false;
+  }
+
+  if (int(player2dead_units.size()) != num_players()) {
+    cerr << "error: size of player2dead_units should be number of players" << endl;
+    return false;
+  }
+
+  uint expected_units = num_players() * num_ini_units_per_clan() + num_ini_zombies();
+  if (units.size() != expected_units) {
+    cerr << "error: units has a wrong number of units" << endl;
+    return false;
+  }
+  
+  vector<int> tmp_nb_cells(num_players(), 0);
+  uint total_ids_in_cells = 0;
+  
+  for (int i = 0; i < board_rows(); ++i) {
+    for (int j = 0; j < board_cols(); ++j) {
+      const Cell& c = grid[i][j];
+
+      if (c.type == Waste) {
+	if (c.owner != -1) {
+	  cerr << "error: waste cells cannot have owner" << endl;
+	  return false;
+	}
+	if (c.id != -1) {
+	  cerr << "error: waste cells cannot have a unit on them" << endl;
+	  return false;
+	}
+	if (c.food) {
+	  cerr << "error: waste cells cannot have food" << endl;
+	  return false;
+	}
+      }
+      else if (c.type == Street) {
+	if (c.food and c.id != -1) {
+	  cerr << "error: street cells cannot have food and a unit on them" << endl;
+	  return false;
+	}
+	if (c.id != -1) {
+	  auto it = units.find(c.id);
+          if (it == units.end()) {
+            cerr << "error: could not find unit identifier" << endl;
+            return false;
+          }
+	  
+	  const Unit& u = it->second;
+          if (u.pos != Pos(i, j)) {
+            cerr << "error: mismatch in the position of unit " << c.id << endl;
+            return false;
+          }
+	  if (u.id != c.id) {
+	    cerr << "error: mismatch in the identifier of unit at pos " << Pos(i,j) << endl;
+	    return false;
+	  }
+
+	  ++total_ids_in_cells;
+	  if (u.type == Zombie){
+	    if (c.owner != -1) {
+	      cerr << "error: a cell with a zombie on it cannot have owner" << endl;
+	      cerr << "This happens with cell " << i << " " << j << " which owns id " << c.id << endl;
+	      return false;
+	    }
+	  }
+	  else if (u.player != c.owner) { // It has alive/dead unit
+	    cerr << "error: cell contains a unit but is not owned by her player" << endl;
+	    return false;
+	  }
+
+	  if (u.type == Zombie and zombies_.count(c.id) == 0) {
+	    cerr << "error: zombie at position " << Pos(i,j) << " is not in zombies_" << endl;
+	    return false;
+	  }
+
+	  if (u.type == Alive and player2alive_units[u.player].count(u.id) == 0) {
+	    cerr << "error: alive unit at posision " << Pos(i,j) << " is not in player2alive_units" << endl;
+	    return false;
+	  }
+
+	  if (u.type == Dead and player2dead_units[u.player].count(u.id) == 0) {
+	    cerr << "error: dead unit at posision " << Pos(i,j) << " is not in player2dead_units" << endl;
+	    return false;
+	  }
+
+	}
+	
+	if (c.owner != -1) {
+	  if (c.owner < 0 or c.owner >= num_players()) {
+	    cerr << "error: owner of a cell should be a number between 0 and " << num_players() - 1 << endl;
+	    return false;
+	  }
+	  ++tmp_nb_cells[c.owner];	  
+	}
+      }
+      else {
+        cerr << "error: cells should be either waster or streets" << endl;
+        return false;	
+      }
+    }
+  }
+
+  if (total_ids_in_cells != expected_units) {
+    cerr << "error: wrong number of units in the grid" << endl;
+    return false;
+  }
+
+  if (nb_cells != tmp_nb_cells) {
+    cerr << "error: nb_cells structure does not match the contents of the grid" << endl;
+    return false;
+  }
+  
+  uint tmp_units = 0;
+  for (auto& x : player2alive_units) tmp_units += x.size();
+  for (auto& x : player2dead_units)  tmp_units += x.size();
+  tmp_units += zombies_.size();
+
+  if (tmp_units != expected_units) {
+    cerr << "error: wrong number of units in the player2alive/dead + zombies" << endl;
+    return false;
+  }
+
+  for (const auto& p : units) {
+    const Unit& u = p.second;
+    if (u.type != Zombie and not player_ok(u.player)) {
+      cerr << "error: wrong player identifier" << endl;
+      return false;
+    }
+
+    if (u.id < 0 or u.id >= int(expected_units)){
+      cerr << "error: wrong identifier for unit" << endl;
+      return false;
+    }
+    
+    if (u.rounds_for_zombie == 0 or
+	u.rounds_for_zombie < -1 or
+	(u.rounds_for_zombie > 0 and u.type == Zombie)) {
+      cerr << "error: wrong round_for_zombie in unit " << u.id << endl;
+      return false;
+    }
+  }
+  return true;
+}

package/assets/problems/games/the-walking-dead.pbm/ca/Runner/Info.hh

@@ -0,0 +1,129 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#ifndef Info_hh
+#define Info_hh
+
+
+#include "Settings.hh"
+#include "State.hh"
+
+
+/**
+ * Contains a class to store most of the information of the game.
+ */
+
+
+/**
+ * Stores all the information of the game,
+ * except the vector of names and the random generator of the board.
+ */
+class Info : public Settings, public State {
+
+  friend class Game;
+  friend class SecGame;
+
+public:
+
+  /**
+   * Returns the cell defined by the char c.
+   */
+  inline static Cell char2Cell (char c) {
+    //                     owner  id    food
+    Cell cell; // (Street, -1,    -1,   false) by default
+    switch (c) {
+    case '.':
+      cell.type = Street;
+      break; // empty cell
+    case 'W':
+      cell.type = Waste;
+      break;
+    case '0':
+      cell.type = Street;
+      cell.owner = 0;
+      break;
+    case '1':
+      cell.type = Street;
+      cell.owner = 1;
+      break;
+    case '2':
+      cell.type = Street;
+      cell.owner = 2;
+      break;
+    case '3':
+      cell.type = Street;
+      cell.owner = 3;
+      break;
+    default:
+      _my_assert(false, string(1, c) + " in grid definition.");
+    }
+    return cell;
+  }
+  
+  /**
+   * Reads the grid of the board.
+   * Should fill the same data structures as a board generator.
+   */
+  void read_grid (istream& is) {
+    for (auto x : nb_cells) _my_assert(x == 0, "nb_cells should be empty when starting to read_grid");
+    
+    // Read grid with streets and wastes
+    string l;
+    is >> l >> l; // Read 1st and 2nd line of column labels.
+    
+    grid = vector< vector<Cell> >(board_rows(), vector<Cell>(board_cols()));
+
+    for (int i = 0; i < board_rows(); ++i) {
+      string s;
+      is >> l >> s;      // Read row label in l and row in s.
+      _my_assert((int)s.size() == board_cols(),
+                 "The read map has a line with incorrect lenght.");
+      for (int j = 0; j < board_cols(); ++j) {
+	grid[i][j] = char2Cell(s[j]);
+	if (grid[i][j].owner != -1) ++nb_cells[grid[i][j].owner];	
+      }
+    }
+    
+    // Read units
+    is >> l; _my_assert(l == "units", "Expected *units* in grid format");
+    int num; is >> num; // Read number of citizens
+    is >> l >> l >> l >> l >> l >> l; // Read type id player row colum rounds
+    for (int i = 0; i < num; ++i) {
+      char type;
+      int id, pl, row, col, rounds;
+      is >> type >> id >> pl >> row >> col >> rounds;
+      _my_assert(pos_ok(row,col), "Citizen placed out of board");
+      _my_assert(grid[row][col].is_empty(), "Citizen placed in non-empty cell");
+      units[id] = Unit(UnitType(char2UnitType(type)),id,pl,Pos(row,col),rounds);
+      grid[row][col].id = id;
+
+      _my_assert(units[id].type == Zombie or grid[row][col].owner == pl, "Cell where unit stands is not owned by it");
+      _my_assert(units[id].type != Zombie or pl == -1, "Zombies in units should belong to player -1");
+      
+      if      (type == 'a') player2alive_units[pl].insert(id);
+      else if (type == 'd') player2dead_units[pl].insert(id);
+      else if (type == 'z') zombies_.insert(id);
+      else _my_assert(false, "Wrong type of unit in grid format");
+    }
+    
+    // Read food
+    is >> l; _my_assert(l == "food", "Expected barricades in grid format");
+    is >> num; _my_assert(num == num_ini_food(), "Number food in grid should be equal to num_ini_food()");
+    is >> l >> l; // Read "row column"
+    for (int i = 0; i < num; ++i) {
+      int row, col;
+      is >> row >> col;
+      _my_assert(pos_ok(row,col), "Food placed out of board");
+      _my_assert(grid[row][col].is_empty(),
+		 "Food placed in non-empty cell");
+      grid[row][col].food = true;
+    }
+  }
+  
+  /**
+   * Checks invariants are preserved.
+   */
+  bool ok() const;
+};
+
+
+#endif