@jutge.org/toolkit 4.2.22 → 4.2.24

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

@@ -0,0 +1,83 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#include "Game.hh"
+
+
+void help (int argc, char** argv) {
+  cout << "Usage: " << argv[0] << " [options] player1 player2 ... [< default.cnf] [> default.out] " << endl;
+  cout << "Available options:" << endl;
+  cout << "--seed=seed     -s seed     set random seed"                   << endl;
+  cout << "--input=file    -i input    set input file  (default: stdin)"  << endl;
+  cout << "--output=file   -o output   set output file (default: stdout)" << endl;
+  cout << "--list          -l          list registered players"           << endl;
+  cout << "--version       -v          print version"                     << endl;
+  cout << "--help          -h          print help"                        << endl;
+}
+
+
+int main (int argc, char** argv) {
+  if (argc == 1) {
+    help(argc, argv);
+    return EXIT_SUCCESS;
+  }
+
+  struct option long_options[] = {
+    { "seed",    required_argument, 0, 's' },
+    { "input",   required_argument, 0, 'i' },
+    { "output",  required_argument, 0, 'o' },
+    { "list",    no_argument,       0, 'l' },
+    { "version", no_argument,       0, 'v' },
+    { "help",    no_argument,       0, 'h' },
+    { 0, 0, 0, 0 }
+  };
+
+  char* ifile = 0;
+  char* ofile = 0;
+  int seed = -1;
+  vector<string> names;
+
+  while (true) {
+    int index = 0;
+    int c = getopt_long(argc, argv, "s:i:o:lvh", long_options, &index);
+    if (c == -1) break;
+
+    switch (c) {
+      case 's':
+        seed = string_to_int(optarg);
+        break;
+      case 'i':
+        ifile = optarg;
+        break;
+      case 'o':
+        ofile = optarg;
+        break;
+      case 'l':
+        Registry::print_players(cout);
+        return EXIT_SUCCESS;
+      case 'v':
+        cout << Board::version() << endl;
+        cout << "compiled " << __TIME__ << " " << __DATE__ << endl;
+        return EXIT_SUCCESS;
+      case 'h':
+        help(argc, argv);
+        return EXIT_SUCCESS;
+      default:
+        return EXIT_FAILURE;
+    }
+  }
+
+  while (optind < argc) {
+    names.push_back(argv[optind++]);
+    _my_assert(names.back().size() <= 12, "Player name too long.");
+  }
+
+  _my_assert(seed >= 0, "Missing seed?");
+
+  istream* is = ifile ? new ifstream(ifile) : &cin;
+  ostream* os = ofile ? new ofstream(ofile) : &cout;
+
+  Game::run(names, *is, *os, seed);
+
+  if (ifile) delete is;
+  if (ofile) delete os;
+}

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

@@ -0,0 +1,56 @@
+DUMMY_OBJ = AIDummy.o
+
+# Add here any extra .o player files you want to link to the executable
+EXTRA_OBJ =
+
+# Configuration
+OPTIMIZE = 3 # Optimization level    (0 to 3)
+DEBUG    = 0 # Compile for debugging (0 or 1)
+PROFILE  = 0 # Compile for profile   (0 or 1)
+
+# For debugging matches against Dummy
+# OPTIMIZE = 0, DEBUG = 1
+
+# For debugging matches among your players
+# OPTIMIZE = 0, DEBUG = 1 and add -D_GLIBCXX_DEBUG at the end of DEBUG_FLAGS
+
+# Flags
+ifeq ($(strip $(PROFILE)),1)
+	PROFILEFLAGS=-pg
+endif
+
+ifeq ($(strip $(DEBUG)),1)
+	DEBUGFLAGS=-g -O0 -fno-inline -D_GLIBCXX_DEBUG 
+endif
+
+CXXFLAGS = -std=c++17 -Wall -Wno-unused-variable -fPIC $(PROFILEFLAGS) $(DEBUGFLAGS) -O$(strip $(OPTIMIZE))
+LDFLAGS  = -std=c++11                            $(PROFILEFLAGS) $(DEBUGFLAGS) -O$(strip $(OPTIMIZE))
+
+
+# The following two lines will detect all your players (files matching "AI*.cc")
+
+PLAYERS_SRC = $(wildcard AI*.cc)
+PLAYERS_OBJ = $(patsubst %.cc, %.o, $(PLAYERS_SRC)) $(EXTRA_OBJ) $(DUMMY_OBJ)
+
+# Rules
+
+OBJ = Structs.o Settings.o State.o Info.o Random.o Board.o Action.o Player.o Registry.o Utils.o 
+
+all: Game
+
+clean:
+	rm -rf Game SecGame *.o *.exe Makefile.deps
+
+Game:  $(OBJ) Game.o Main.o $(PLAYERS_OBJ) 
+	$(CXX) $^ -o $@ $(LDFLAGS)
+
+SecGame: $(OBJ) SecGame.o SecMain.o
+	$(CXX) $^ -o $@ $(LDFLAGS) -lrt
+
+%.exe: %.o $(OBJ) SecGame.o SecMain.o 
+	$(CXX) $^ -o $@ $(LDFLAGS) -lrt
+
+Makefile.deps: *.cc
+	$(CXX) $(CXXFLAGS) -MM *.cc > Makefile.deps
+
+include Makefile.deps

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

@@ -0,0 +1,66 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////
+
+#include "Player.hh"
+
+void Player::reset (ifstream& is) {
+
+  // Should read what Board::print_state() prints.
+  // Should fill the same data structures as
+  // Board::Board (istream& is, int seed), except for settings and names.
+  // THESE DATA STRUCTURES MUST BE RESET: maps WITH clear(), etc.
+
+
+  *(Action*)this = Action();
+
+  units             .clear();
+  player2alive_units.clear();
+  player2dead_units .clear();
+  zombies_          .clear();
+  nb_cells          .clear();
+  
+  player2alive_units   = vector<set<int>>(num_players());
+  player2dead_units    = vector<set<int>>(num_players());
+  nb_cells             = vector<int>(num_players(),0);
+
+  read_grid(is);
+
+  string s;
+  is >> s >> rnd;
+  _my_assert(s == "round", "Expected 'round' while parsing.");
+  _my_assert(rnd >= 0 and rnd < num_rounds(), "Round is not ok.");
+
+  is >> s;
+  _my_assert(s == "score", "Expected 'score' while parsing.");
+  scr = vector<int>(num_players());
+  for (auto& s : scr) {
+    is >> s;
+    _my_assert(s >= 0, "Score cannot be negative.");
+  }
+
+  is >> s;
+  _my_assert(s == "scr_acc", "Expected 'scr_acc' while parsing.");
+  scr_accumulated = vector<int>(num_players());
+  for (auto& s : scr_accumulated) {
+    is >> s;
+    _my_assert(s >= 0, "Accumulates scores cannot be negative.");
+  }
+
+  is >> s;
+  _my_assert(s == "strength", "Expected 'strength' while parsing.");
+  overall_strength = vector<int>(num_players());
+  for (auto& s : overall_strength) {
+    is >> s;
+    _my_assert(s >= 0, "Strength cannot be negative.");
+  }
+
+  is >> s;
+  _my_assert(s == "status", "Expected 'status' while parsing.");
+  stats = vector<double>(num_players());
+  for (auto& st : stats) {
+    is >> st;
+    _my_assert(st == -1 or (st >= 0 and st <= 1), "Status is not ok.");
+  }
+
+  _my_assert(ok(), "Invariants are not satisfied.");
+  //  forget();
+}

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

@@ -0,0 +1,63 @@
+#ifndef Player_hh
+#define Player_hh
+
+
+#include "Info.hh"
+#include "Action.hh"
+#include "Random.hh"
+#include "Registry.hh"
+
+
+/***
+ * Abstract base class for players.
+ * *
+ * This class uses multiple inheritance from Info and Action,
+ * so that their public operations can been used from within Player.
+ *
+ * In order to create new players, inherit from this class and register them.
+ * See for example AINull.cc and AIDemo.cc.
+ */
+class Player : public Info, public Random_generator, public Action {
+
+public:
+
+  /**
+   * Identifier of my player.
+   */
+  int me () const;
+  
+  //////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+  /**
+   * Play intelligence. Will be overwritten, thus declared virtual.
+   */
+  virtual void play () {
+  };
+  
+  /**
+   * Empty constructor.
+   */
+  Player () { }
+  
+private: 
+
+  friend class Game;
+  friend class SecGame;
+
+  int me_;
+
+  inline void reset (const Info& info) {
+    *static_cast<Action*>(this) = Action();
+    *static_cast<State*>(this) = (State) info;
+    //    forget();
+  }
+
+  void reset (ifstream& is);
+};
+
+
+inline int Player::me () const {
+  return me_;
+};
+
+#endif

package/assets/problems/games/the-walking-dead.pbm/ca/Runner/README.txt

@@ -0,0 +1,9 @@
+
+title:      ThePurge
+
+author(s):  Albert Oliveras
+
+
+contact:    oliveras@cs.upc.edu
+
+(c) Universitat Politècnica de Catalunya, 2022

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

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

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

@@ -0,0 +1,88 @@
+#ifndef Random_hh
+#define Random_hh
+
+
+#include "Utils.hh"
+
+
+/**
+ * Defines a random generator.
+ */
+class Random_generator {
+
+public:
+
+  /**
+   * Returns a random integer in [l..u]. u - l + 1 must be between 1 and 10^6.
+   */
+  int random (int l, int u);
+
+  /**
+   * Returns a random permutation of [0..n-1]. n must be between 0 and 10^6.
+   */
+  vector<int> random_permutation (int n);
+
+
+  //////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////
+  
+
+private:
+
+  friend class Board;
+  friend class Game;
+  friend class SecGame;
+
+  static const long long RANDOM_MOD = ((long long)1)<<31;
+  static const long long RANDOM_MASK = RANDOM_MOD - 1;
+
+  long long rnd_seed;
+
+  /**
+   * Sets random seed.
+   */
+  void set_random_seed (int s) {
+    if (s < 0) s = -s;
+    rnd_seed = s & RANDOM_MASK;
+  }
+
+  /**
+   * Computes next seed from current seed.
+   */
+  void next_rnd () {
+    rnd_seed = (843314861*rnd_seed + 453816693) & RANDOM_MASK;
+  }
+
+  /**
+   * Returns a real random number in [0, 1).
+   */
+  double uniform() {
+    next_rnd();
+    return double(rnd_seed)/RANDOM_MOD;
+  }
+  
+};
+
+
+inline int Random_generator::random (int l, int u) {
+    if (l > u) return l; // wrong interval
+
+    long long m = (long long)u - (long long)l + 1;
+    if (m > 1e6) return l; // interval too long
+
+    next_rnd();
+    return l + int((u - l + 1)*uniform()); //...
+  }
+
+  /**
+   * Returns a random permutation of [0..n-1]. n must be between 0 and 10^6.
+   */
+inline vector<int> Random_generator::random_permutation (int n) {
+    if (n < 0 or n > 1e6) return vector<int>(0); // wrong n
+
+    vector<int> v(n);
+    for (int i = 0; i < n; ++i) v[i] = i;
+    for (int i = 0; i < n; ++i) swap(v[i], v[random(i, n  - 1)]);
+    return v;
+  }
+
+#endif

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

@@ -0,0 +1,28 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#include "Registry.hh"
+
+
+typedef map<string, Registry::Factory> dict_;
+
+
+dict_* reg_ = 0;
+
+
+int Registry::Register (const char* name, Factory factory) {
+  if (reg_ == 0) reg_ = new dict_();
+  (*reg_)[name] = factory;
+  return 999;
+}
+
+
+Player* Registry::new_player (string name) {
+  auto it = reg_->find(name);
+  _my_assert(it != reg_->end(), "Player " + name + " not registered.");
+  return (it->second)();
+}
+
+
+void Registry::print_players (ostream& os) {
+  for (const auto& it : *reg_) cout << it.first << endl;
+}

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

@@ -0,0 +1,42 @@
+//////// STUDENTS DO NOT NEED TO READ BELOW THIS LINE ////////  
+
+#ifndef Registry_hh
+#define Registry_hh
+
+
+#include "Utils.hh"
+
+
+/**
+ * Magic to register players.
+ */
+
+
+class Player;
+
+
+/**
+ * Since the main program does not know how many players will be inherited
+ * from the Player class, we use a registration and factory pattern.
+ */
+class Registry {
+
+public:
+
+  typedef Player* (*Factory)();
+
+  static int Register (const char* name, Factory fact);
+
+  static Player* new_player (string name);
+
+  static void print_players (ostream& os);
+
+};
+
+
+#define _stringification(s) #s
+#define RegisterPlayer(x) static int registration = \
+        Registry::Register(_stringification(x), x::factory)
+
+
+#endif