@jutge.org/toolkit 4.2.22 → 4.2.24

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

@@ -0,0 +1,175 @@
+#ifndef Settings_hh
+#define Settings_hh
+
+
+#include "Structs.hh"
+
+
+/** \file
+ * Contains a class to store all the game settings that do not change
+ * during a game, except the names of the players.
+ */
+
+
+/**
+ * Stores most of the game settings.
+ */
+class Settings {
+
+public:
+    /**
+   * Returns a string with the game name and version.
+   */
+  static string version ();
+
+  /**
+   * Returns the number of players in the game.
+   */
+  int num_players () const;
+
+  /**
+   * Returns the number of rounds a match lasts.
+   */
+  int num_rounds () const;
+
+  /**
+   * Returns the number of rows of the board.
+   */
+  int board_rows () const;
+
+  /**
+   * Returns the number of columns of the board.
+   */
+  int board_cols () const;
+
+  /**
+   * Returns the initial number of units per clan
+   */
+  int num_ini_units_per_clan () const;
+
+  /**
+   * Returns the initial number of zombies on the board
+   */
+  int num_ini_zombies () const;
+
+  /**
+   * Returns the initial number of food items on the board
+   */
+  int num_ini_food () const;
+
+  /**
+   * Returns the initial strength of each clan
+   */
+  int clan_ini_strength () const;
+
+  /**
+   * Returns the points obtained after killing a person
+   */
+  int points_for_killing_person () const;
+
+  /**
+   * Returns the points obtained after killing a zombie
+   */
+  int points_for_killing_zombie () const;
+
+  /**
+   * Returns the points obtained for each owned cell at the end of a round
+   */
+  int points_per_owned_cell () const;
+
+  /**
+   * Returns the units of strenght obtained by eating an item of food
+   */
+  int food_strength () const;
+
+  /**
+   * Returns the number of rounds before a bitten/dead person becomes a zombie
+   */
+  int rounds_before_becoming_zombie () const;
+
+  /**
+   * Returns whether pl is a valid player identifier.
+   */
+  bool player_ok (int pl) const;
+
+  /**
+   * Returns whether (i, j) is a position inside the board.
+   */
+  bool pos_ok (int i, int j) const;
+
+  /**
+   * Returns whether p is a position inside the board.
+   */
+  bool pos_ok (Pos p) const;
+
+private:
+  
+  friend class Info;
+  friend class Board;
+  friend class Game;
+  friend class SecGame;
+  friend class Player;
+
+  int NUM_PLAYERS;
+  int NUM_ROUNDS;
+  int BOARD_ROWS;
+  int BOARD_COLS;
+  int NUM_INI_UNITS_PER_CLAN;
+  int NUM_INI_ZOMBIES;
+  int NUM_INI_FOOD;
+  int CLAN_INI_STRENGTH;
+  int POINTS_FOR_KILLING_PERSON;
+  int POINTS_FOR_KILLING_ZOMBIE;
+  int POINTS_PER_OWNED_CELL;
+  int FOOD_STRENGTH;
+  int ROUNDS_BEFORE_BECOMING_ZOMBIE;
+  
+  /**
+   * Reads the settings from a stream.
+   */
+  static Settings read_settings (istream& is);
+
+  
+  bool ok () const;
+};
+
+
+inline string Settings::version () {
+  return "TheWalkingDead 1.0";
+}
+
+inline int Settings::num_players                   () const { return NUM_PLAYERS                    ;}
+inline int Settings::num_rounds                    () const { return NUM_ROUNDS                     ;}
+inline int Settings::board_rows                    () const { return BOARD_ROWS                     ;}
+inline int Settings::board_cols                    () const { return BOARD_COLS                     ;}
+inline int Settings::num_ini_units_per_clan        () const { return NUM_INI_UNITS_PER_CLAN         ;}
+inline int Settings::num_ini_zombies               () const { return NUM_INI_ZOMBIES                ;}
+inline int Settings::num_ini_food                  () const { return NUM_INI_FOOD                   ;}
+inline int Settings::clan_ini_strength             () const { return CLAN_INI_STRENGTH              ;}
+inline int Settings::points_for_killing_person     () const { return POINTS_FOR_KILLING_PERSON      ;}
+inline int Settings::points_for_killing_zombie     () const { return POINTS_FOR_KILLING_ZOMBIE      ;}
+inline int Settings::points_per_owned_cell         () const { return POINTS_PER_OWNED_CELL          ;}
+inline int Settings::food_strength                 () const { return FOOD_STRENGTH                  ;}
+inline int Settings::rounds_before_becoming_zombie () const { return ROUNDS_BEFORE_BECOMING_ZOMBIE  ;}
+
+
+inline bool Settings::player_ok (int pl) const {
+  return pl >= 0 and pl < num_players();
+}
+
+inline bool Settings::pos_ok (int i, int j) const {
+  return i >= 0 and i < board_rows() and j >= 0 and j < board_cols();
+}
+
+inline bool Settings::pos_ok (Pos p) const {
+  return pos_ok(p.i, p.j);
+}
+
+
+inline bool Settings::ok() const {
+  if (num_players() != 4) return false;
+  return true;
+}
+
+
+#endif

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

@@ -0,0 +1,3 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#include "State.hh"

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

@@ -0,0 +1,188 @@
+#ifndef State_hh
+#define State_hh
+
+
+#include "Structs.hh"
+#include "Settings.hh"
+
+/**
+ * Contains a class to store the current state of a game.
+ */
+
+
+/**
+ * Stores the game state.
+ */
+class State {
+
+public:
+
+  /**
+   * Returns the current round.
+   */
+  int round () const;
+
+  /**
+   * Returns a copy of the cell at (i, j).
+   */
+  Cell cell (int i, int j) const;
+
+  /**
+   * Returns a copy of the cell at p.
+   */
+  Cell cell (Pos p) const;
+
+  /**
+   * Returns the a copy of the unit with identifier id.
+   */
+  Unit unit (int id) const;
+
+  /**
+   * Returns the ids of the alive units of a player
+   */
+  vector<int> alive_units (int pl) const;
+
+  /**
+   * Returns the ids of the dead units of a player
+   */
+  vector<int> dead_units (int pl) const;
+
+  /**
+   * Returns the ids of the zombies
+   */
+  vector<int> zombies () const;
+  
+  /**
+   * Returns the current strength of a player ( strength_points/alive_units )
+   */
+  int strength (int pl) const;
+  
+  /**
+   * Returns the current score of a player.
+   */
+  int score (int pl) const;
+
+  /**
+   * Returns the percentage of cpu time used so far, in the
+   * range [0.0 - 1.0] or a value lesser than 0 if the player is dead.
+   */
+   // NOTE: only returns a sensible value in server executions.
+   // In local executions the returned value is meaningless.
+  double status (int pl) const;
+
+
+  //////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+private:
+
+  friend class Info;
+  friend class Board;
+  friend class Game;
+  friend class SecGame;
+  friend class Player;
+
+  vector< vector<Cell> >   grid;
+  
+  vector<int>              scr; // score of each player
+  vector<int>              scr_accumulated; // score referring to units and zombies killed
+  vector<int>              nb_cells; // current number of cells conquered by player
+  vector<int>              overall_strength; // strength of player (to be distributed among units)
+
+  vector<double>           stats; // -1 -> dead, 0..1 -> % of cpu time limit
+  int                      rnd;
+  
+  map<int, Unit>           units;
+  vector< set<int> >       player2alive_units;
+  vector< set<int> >       player2dead_units;
+  set<int>                 zombies_;
+
+  /**
+   * Returns whether id is a valid citizen identifier.
+   */
+  inline bool unit_ok (int id) const {
+    return units.count(id);
+  }
+};
+
+inline int State::round () const {
+  return rnd;
+}
+
+inline Cell State::cell (int i, int j) const {
+  if (i >= 0 and i < (int)grid.size() and j >= 0 and j < (int)grid[i].size())
+    return grid[i][j];
+  else {
+    cerr << "warning: cell requested for position " << Pos(i, j) << endl;
+    return Cell();
+  }
+}
+
+inline Cell State::cell (Pos p) const {
+  return cell(p.i, p.j);
+}
+
+inline Unit State::unit (int id) const {
+  auto it = units.find(id);
+  if (it != units.end()) {
+    return it->second;
+  }
+  else {
+    cerr << "warning: unit requested for identifier " << id << endl;
+    return Unit();
+  }
+}
+
+inline vector<int> State::alive_units (int pl) const {
+  if (pl >= 0 and pl < (int) player2alive_units.size())
+    return vector<int>(player2alive_units[pl].begin(), player2alive_units[pl].end());
+  else {
+    cerr << "warning: alive units requested for player " << pl << endl;
+    return vector<int>();
+  }
+}
+
+inline vector<int> State::dead_units (int pl) const {
+  if (pl >= 0 and pl < (int) player2dead_units.size())
+    return vector<int>(player2dead_units[pl].begin(), player2dead_units[pl].end());
+  else {
+    cerr << "warning: dead units requested for player " << pl << endl;
+    return vector<int>();
+  }
+}
+
+inline vector<int> State::zombies () const {
+  return vector<int>(zombies_.begin(), zombies_.end());
+}
+
+inline int State::strength (int pl) const {
+  if (pl >= 0 and pl < (int) scr.size()) {
+    if (player2alive_units[pl].size() == 0) return 0;
+    else return overall_strength[pl]/player2alive_units[pl].size();
+  }
+  else {
+    cerr << "warning: strength requested for player " << pl << endl;
+    return -1;
+  }
+}
+
+
+inline int State::score (int pl) const {
+  if (pl >= 0 and pl < (int) scr.size())
+    return scr[pl];
+  else {
+    cerr << "warning: score requested for player " << pl << endl;
+    return -1;
+  }
+}
+
+
+inline double State::status (int pl) const {
+  if (pl >= 0 and pl < (int)stats.size())
+    return stats[pl];
+  else {
+    cerr << "warning: status requested for player " << pl << endl;
+    return -2;
+  }
+}
+
+#endif

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

@@ -0,0 +1,3 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#include "Structs.hh"