@jutge.org/toolkit 4.2.23 → 4.2.24

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

@@ -0,0 +1,81 @@
+\section{Consells}
+
+\begin{itemize}
+
+\item {\bf NO DONEU O DEMANEU EL VOSTRE CODI A NINGÚ}. Ni tan sols una
+  versió antiga. Ni fins i tot al vostre millor amic. Ni tans sols
+  d'estudiants d'anys anteriors. Utilitzem detectors de plagi per
+  comparar els vostres programes, també contra enviaments de jocs
+  d’anys anteriors. No obstant, podeu compartir arxius objecte.
+
+  
+  Qualsevol plagi implicarà {\bf una nota de 0 en l'assignatura} (no
+  només del Joc) de tots els estudiants involucrats. Es podran també
+  prendre mesures disciplinàries addicionals. Si els estudiants A i B
+  es veuen implicats en un plagi, les mesures s'aplicaran als dos,
+  independentment de qui va crear el codi original. No es farà cap
+  excepció sota cap circumstància.
+
+
+\item Abans de competir amb els companys, concentreu-vos en derrotar al Dummy.
+  
+\item Llegiu les capçaleres de les classes que aneu a utilitzar. No cal que mireu 
+les parts privades o la implementació.
+
+\item Comenceu amb estratègies simples, fàcils d'implementar i depurar, ja que
+és exactament el que necessitareu al principi.
+
+\item Definiu mètodes auxiliars senzills (però útils) i \emph{assegureu-vos
+que funcionin correctament}.
+
+\item Intenteu mantenir el vostre codi net. Això farà més fàcil canviar-lo i afegir
+  noves estratègies.
+
+\item Com sempre, compileu i proveu el vostre codi sovint. És \emph{molt}
+  més fàcil rastrejar un error quan només heu canviat poques línies de codi.
+
+\item Utilitzeu @cerr@ per produir informació de depuració i afegiu
+  \texttt{assert}s per assegurar-vos que el vostre codi fa el que hauria de fer.
+
+\item Quan depureu un jugador, elimineu els @cerr@s que tingueu en el codi
+d’altres jugadors, per tal de veure només els missatges que desitgeu.
+
+\item Podeu utilitzar comandes com el \texttt{grep} de Linux per tal de filtrar
+  la sortida produïda per \texttt{Game}.
+
+\item Activeu l'opció \texttt{DEBUG} al Makefile, que us permetrà
+ obtenir traces útils quan el vostre programa avorta. També hi ha una opció
+\texttt{PROFILE} que podeu utilitzar per optimitzar codi.
+
+\item Si l'ús de @cerr@ no és suficient per depurar el vostre codi, apreneu
+com utilitzar \texttt{valgrind}, \texttt{gdb} o qualsevol altra eina de depuració.
+
+
+\item Podeu analitzar els arxius produïts per \texttt{Game}, que descriuen com
+  evoluciona el tauler a cada ronda.
+  
+\item Conserveu una còpia de les versions antigues del vostre jugador. Feu-lo lluitar
+contra les seves versions anteriors per quantificar les millores.
+
+
+\item Assegureu-vos que el vostre programa sigui prou ràpid. El temps de CPU que
+es permet utilitzar és bastant curt.
+
+\item Intenteu esbrinar les estratègies dels altres jugadors observant
+  diverses partides. D’aquesta manera, podeu intentar reaccionar als
+  seus moviments, o fins i tot imiteu-los o milloreu-los amb el vostre
+  propi codi.
+
+\item No espereu fins al darrer minut per enviar el jugador. Quan hi
+  ha molts enviaments al mateix temps, el servidor triga més en
+  executar les partides i podria ser ja massa tard!
+
+\item Podeu enviar noves versions del vostre programa en qualsevol moment.
+  
+\item Recordeu: mantingueu el codi senzill, compileu-lo sovint i proveu-lo sovint, o
+us en penedireu.
+
+\end{itemize}
+
+
+

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

@@ -0,0 +1,41 @@
+\section{El Visor}
+
+A continuació descrivim el visor de partides:
+
+\begin{itemize}
+  
+\item A la part superior hi ha botons que permeten
+  reproduir o pausar la partida, anar al començament o al final de la
+  partida, activar o desactivar el mode d’animació o obtenir una
+  finestra d'ajuda amb més maneres de controlar com es reprodueix la
+  partida. També hi trobareu la ronda actual i un botó per tancar el
+  visor.
+  Una barra de desplaçament horitzontal mostra visualment en quin punt
+  de la partida es troba la ronda actual.
+  
+\item A la columna de l'esquerra, apareix cada jugador amb el nom i
+  color corresponents. A sota es mostra la puntuació actual, el
+  nombre d'unitats vives i la força del jugador corresponent. A les
+  partides jugades a Jutge.org, també es mostra el percentatge de
+  temps de CPU que s’ha consumit fins ara (si està esgotat, s’indica
+  amb un 'out'). A la part superior dreta apareixen els colors dels jugadors
+  ordenats per puntuació.
+  
+\item Les cel·les no posseïdes per ningú són de color blanc. En cas contrari, tenen el color del jugador que les posseeix.
+
+\item Les cel·les amb deixalles tenen color gris fosc.
+
+\item Les unitats vives es representen amb un cercle del color corresponent. En cas d'estar en procés de conversió, a zombi, tenen forma quadrada.
+
+\item Les unitats mortes es representen amb una creu.
+
+\item Els zombis es representen amb un quadrat vermell i contorn exterior negre.
+
+\item Les unitats de menjar es representen amb un cercle vermell i contorn exterior negre.
+
+\end{itemize}
+
+%%% Local Variables:
+%%% mode: latex
+%%% TeX-master: t
+%%% End:

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

@@ -0,0 +1,6 @@
+all:
+	pdflatex main
+	pdflatex main
+
+clean:
+	rm -rf *.pdf *.log *.aux *.dvi  *.synctex.gz auto

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

@@ -0,0 +1,246 @@
+\documentclass[catalan]{article}
+\pagestyle{plain}
+
+\usepackage{float}
+\usepackage[utf8]{inputenc}
+\usepackage{graphicx}
+\usepackage{mdwlist}
+\usepackage{textcomp}
+\usepackage{mathpazo}
+\usepackage{listings}
+\usepackage{parskip}
+\usepackage{color}
+\usepackage{xspace}
+\usepackage{url}
+
+\makeatletter
+\usepackage[catalan]{babel}
+\makeatother
+
+\newcommand{\warning}[1]{{\color{red} #1}}
+
+\input{defs}
+
+%%% LISTINGS
+
+\lstset{language=C++}
+\lstset{columns=flexible}
+%\lstset{basewidth={1em,1em}}
+\lstset{keepspaces=true}
+\lstset{morekeywords={include,cin,cout,cerr,endl,null,string}}
+\lstset{deletekeywords={for}}
+\lstset{belowskip=0mm}
+\lstset{stringstyle={}}
+\lstset{commentstyle={}}
+\lstset{numberstyle=\tiny\sffamily}
+\lstset{numbersep=-5pt}
+\lstset{keywordstyle=\bfseries}
+\lstset{identifierstyle=\itshape}
+\lstset{showstringspaces=false}
+\lstset{upquote=true}
+\lstset{texcl=true}
+\lstset{mathescape=true}
+\lstset{literate={->}{$\rightarrow$}1 {<=}{$\le$}1 {>=}{$\ge$}1 {!=}{$\neq$}1 {<<}{$<\!\!\!<$}2 {>>}{$>\!\!\!>$}2}
+\lstset{xleftmargin=0.3cm}
+\lstMakeShortInline@
+
+\begin{document}
+
+\begin{center}
+{\bf \Large{Summarized API for playing The Walking Dead}}
+\end{center}
+
+\bigskip
+This short document briefly presents the main types, classes and methods that you
+may need to program your player.
+
+{\bf Positions and directions.}
+\begin{lstlisting}
+  // Enum to encode directions. Alive units cannot move diagonally
+  enum Dir {
+    Down, DR, Right, RU, Up, UL, Left, LD
+  };
+
+  // Simple struct to handle positions.
+  struct Pos {
+    int i, j;
+  };
+
+  Pos (int i, int j);
+  // Example: Pos p(3, 6);
+
+  ostream& operator<< (ostream& os, const Pos& p);
+  // Example: cerr $<\!\!<$ p $<\!\!<$ endl;
+
+  bool operator== (const Pos& a, const Pos& b);
+  // Example: if (p == Pos(3, 2)) ...
+
+  bool operator $!\!=$ (const Pos& a, const Pos& b);
+  // Example: if (p != Pos(3, 2)) ...
+
+  / Compares using lexicographical order (first by i, then by j).
+  // If needed, you can sort vectors of positions or build sets of positions.
+  bool operator< (const Pos& a, const Pos& b);
+  // Example: if (p $<$ Pos(3, 2)) ...
+
+  Pos& operator+= (Dir d);
+  // Example: p += Right;
+
+  Pos operator+ (Dir d );
+  // Example: Pos p2 = p + Left;
+  
+  Pos& operator+= (Pos p);
+  // Example: p += Pos(3, 2);
+
+  Pos operator+ (Pos p );
+  // Example: p2 = p + Pos(3, 2);
+
+  // Returns whether (i, j) is a position inside the board.
+  bool pos$\_$ok (int i , int j );
+  // Example: if (pos ok(i + 1, j - 1)) ...
+
+  // Returns whether p is a position inside the board.
+  bool pos$\_$ok (Pos p );
+  // Example: if (pos ok(p1 + Down)) ...
+\end{lstlisting}
+
+\medskip
+{\bf State of the game.}
+\begin{lstlisting}
+  // Returns whether pl is a valid player identifier.
+  bool player$\_$ok (int pl) const;
+
+  // Identifier of your player, between 0 and 3.
+  int me ();
+
+  // Defines kinds of cells.
+  enum CellType {
+    Street,
+    Waste
+  };
+
+  // Describes a cell on the board, and its contents.
+  struct Cell {    
+    CellType         type; // The kind of cell (street or waste).
+    int             owner; // The player that owns it, otherwise -1.
+    int                id; // The id of a unit if present, or -1 otherwise.
+    bool             food; // Whether it contains food
+  };
+  
+  // Defines the type of the unit.
+  enum UnitType {
+    Alive,
+    Dead,
+    Zombie
+  };
+
+  // Describes an unit on the board and its properties.
+  struct Unit {    
+    UnitType type;         // The type of unit.
+    int id;                // The unique id of this unit during the game.
+    int player;            // The player that owns this unit
+                           // (-1 if is a zombie)
+    Pos pos;               // The position on the board.    
+    int rounds$\_$for$\_$zombie; // Rounds before it becomes a zombie
+                          // (-1 if is not being converted to zombie)
+  };
+
+  // Returns the current round.
+  int round () const;
+
+  // Returns a copy of the cell at (i, j).
+  Cell cell (int i, int j) const;
+  // Example: Cell c3 = cell(3, 6);
+  
+  // Returns a copy of the cell at p.
+  Cell cell (Pos p) const;
+  // Example: Cell c2 = cell(p);
+  
+  // Returns a copy of the unit with identifier id.
+  Unit unit (int id) const;
+  // Example: Unit u2 = unit(23);
+  
+  // Returns the ids of the alive units of a player
+  vector$<$int$>$ alive$\_$units (int pl) const;
+  // Example: vector$<$int$>$ au = alive$\_$units(3);
+  
+  // Returns the ids of the dead units of a player
+  vector$<$int$>$ dead$\_$units (int pl) const;
+  // Example: vector$<$int$>$ du = dead$\_$units(0)
+
+  // Returns the ids of the zombies
+  vector$<$int$>$ zombies () const;
+  // Example: vector$<$int$>$ z = zombies();
+  
+  // 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;
+\end{lstlisting}
+
+\bigskip
+{\bf Command actions.}
+\begin{lstlisting}
+  // Commands unit with identifier id to move following direction dir.
+  void move (int id, Dir dir);
+  // Example: move(23,Down);
+\end{lstlisting}
+
+\bigskip
+{\bf Initial settings.}
+\begin{lstlisting}
+  // 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;
+\end{lstlisting}
+
+\bigskip
+{\bf Random.}
+\begin{lstlisting}
+  // Returns a random integer in [l..u]. u - l + 1 must be between 1 and $10^6$ .
+  int random (int l , int u );
+  // Example: if (random(0, 4) $<$ 2) whatever();
+  // This code executes whatever() with probability 2/5.
+
+  // Returns a random permutation of [0..n-1]. n must be between 0 and $10^6$.
+  vector$<$int$>$ random permutation (int n);
+\end{lstlisting}
+
+\end{document}

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

@@ -0,0 +1,2 @@
+\newcommand{\gameName}{The Walking Dead\xspace}
+\newcommand{\gameAuthor}{Albert Oliveras\xspace}

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

@@ -0,0 +1,63 @@
+\documentclass[english]{article}
+\pagestyle{plain}
+
+\usepackage{float}
+\usepackage[utf8]{inputenc}
+\usepackage{graphicx}
+\usepackage{mdwlist}
+\usepackage{textcomp}
+\usepackage{mathpazo}
+\usepackage{listings}
+\usepackage{parskip}
+\usepackage{color}
+\usepackage{xspace}
+\usepackage{url}
+
+\makeatletter
+\usepackage[english]{babel}
+\makeatother
+
+\newcommand{\warning}[1]{{\color{red} #1}}
+
+\input{defs}
+
+%%% LISTINGS
+
+\lstset{language=C++}
+\lstset{columns=flexible}
+%\lstset{basewidth={1em,1em}}
+\lstset{keepspaces=true}
+\lstset{morekeywords={include,cin,cout,cerr,endl,null,string}}
+\lstset{belowskip=0mm}
+\lstset{stringstyle={}}
+\lstset{commentstyle={}}
+\lstset{numberstyle=\tiny\sffamily}
+\lstset{numbersep=-5pt}
+\lstset{keywordstyle=\bfseries}
+\lstset{identifierstyle=\itshape}
+\lstset{showstringspaces=false}
+\lstset{upquote=true}
+\lstset{texcl=true}
+\lstset{mathescape=true}
+\lstset{literate={->}{$\rightarrow$}1 {<=}{$\le$}1 {>=}{$\ge$}1 {!=}{$\neq$}1 {<<}{$<\!\!\!<$}2 {>>}{$>\!\!\!>$}2}
+\lstset{xleftmargin=0.8cm}
+\lstMakeShortInline@
+
+\begin{document}
+
+\title{\textbf{\large \gameName}}
+\author{\gameAuthor}
+\maketitle
+
+\bigskip
+\begin{center}
+\includegraphics[width=13cm]{twd.png}
+\end{center}
+
+\newpage
+\input{rules}
+\input{viewer}
+\input{programming}
+\input{tips}
+
+\end{document}

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

@@ -0,0 +1,176 @@
+
+\section{Programming the game}
+
+The first thing you should do is downloading the source code. It
+includes a C++ program that runs the games and an HTML viewer to watch
+them in a reasonable animated format. Also, a ``Null'' player and a
+``Demo'' player are provided to make it easier to start coding your own
+player.
+
+\subsection{Running your first game}
+
+Here, we will explain how to run the game under Linux, but it should
+work \mbox{under} Windows, Mac, FreeBSD, OpenSolaris, \dots You only need a
+recent \texttt{g++} version, \texttt{make} installed in your system, plus a
+modern browser like Firefox or Chrome.
+
+
+\begin{enumerate}
+
+\item Open a console and \texttt{cd} to the directory where you
+extracted the source code.
+
+\item If, for example, you are using a 64-bit Linux version, run:
+
+  \texttt{cp AIDummy.o.Linux64 AIDummy.o}
+  
+  \texttt{cp Board.o.Linux64 Board.o}
+
+  If you use any other architecture, choose the right objects you will
+  find in the directory.
+
+\item Run
+
+\texttt{make all}
+
+to build the game and all the players. Note that \texttt{Makefile}
+identifies as a player any file matching \texttt{AI*.cc}.
+
+\item This creates an executable file called
+\texttt{Game}. This executable allows you to run a game using a command
+like:
+
+\texttt{./Game Demo Demo Demo Demo -s 30 -i default.cnf -o default.res}
+
+This starts a match, with random seed 30, of four instances of the
+player Demo, in the board defined in \texttt{default.cnf}. The output of
+this match is redirected to \texttt{default.res}.
+
+\item To watch a game, open the viewer file \texttt{viewer.html} with
+  your browser, for example by running \texttt{firefox viewer.html},
+  and load the file \texttt{default.res}.
+
+\end{enumerate}
+
+
+Use
+
+\texttt{./Game --help}
+
+to see the list of parameters that you can use. Particularly useful is
+
+\texttt{./Game --list}
+
+to show all the recognized player names.
+
+\medskip
+
+If needed, remember that you can run
+
+\texttt{make clean}
+
+to delete the executable and object files and start over the build.
+
+
+\begin{center}
+\includegraphics[width=12cm]{screenshot.png}
+\end{center}
+
+
+\subsection{Adding your player}
+
+To create a new player with, say, name \texttt{Rick},
+copy \texttt{AINull.cc} (an empty player that is provided as a template)
+to a new file \texttt{AIRick.cc}.
+Then, edit the new file and change the
+
+\begin{center}
+@#define PLAYER_NAME Null@
+\end{center}
+
+line to
+
+\begin{center}
+@#define PLAYER_NAME Rick@
+\end{center}
+
+The name that you choose for your player must be unique, non-offensive
+and at most 12 characters long. This name will be shown in the website
+and during the matches.
+
+\medskip
+
+Afterwards, you can start implementing the virtual method @play()@,
+inherited from the base class @Player@. This method, which will be
+called every round, must decide the orders to give to your units.
+
+\medskip
+
+You can define auxiliary type definitions, variables and methods inside
+your player class, but the entry point of your code will always be the
+@play()@ method.
+
+\medskip
+
+From your player class you can also call functions that you will find in the following files:
+
+\begin{itemize}
+\item \texttt{State.hh}: consulting the state of the game.
+\item \texttt{Action.hh}: giving orders to your units.
+\item \texttt{Structs.hh}: useful data structures.
+\item \texttt{Settings.hh}: consulting the initial parameters of the game.
+\item \texttt{Player.hh}: method @me()@.
+  \item \texttt{Random.hh}: random number generation.
+\end{itemize}
+
+You will find a summary of this information in the file \texttt{api.pdf}.
+You can also examine the code of the ``Demo'' player in \texttt{AIDemo.cc}
+as an example of how to use these functions.
+
+\medskip
+
+Note that you must not edit the @factory()@ method of your player
+class, nor the last line that adds your player to the list of available
+players.
+
+
+
+\subsection{Restrictions when submitting your player}
+
+When you think that your player is strong enough to enter the
+competition, you can submit it to the Jutge. Since it will run in a
+secure environment to prevent cheating, some restrictions apply to your
+code:
+
+\begin{itemize}
+
+\item All your source code must be in a single file (like AIRick.cc).
+
+\item You cannot use global variables (instead, use attributes in your
+class).
+
+\item You are only allowed to use standard libraries like
+\texttt{iostream}, \texttt {vector}, \texttt {map}, \texttt {set},
+\texttt {queue}, \texttt {algorithm}, \texttt {cmath}, \dots In many
+cases, you don't even need to include the corresponding library.
+
+\item You cannot open files nor do any other system calls (threads,
+forks, \dots).
+
+\item Your CPU time and memory usage will be limited, while they are
+not in your local environment when executing with \texttt{./Game}.
+
+\item Your program should not write to @cout@ nor read from @cin@. You
+can write debug information to @cerr@, but remember that doing so in
+the code that you upload can waste part of your limited CPU time.
+
+\item Any submission to the Jutge must be an honest attempt to play the
+game. Any try to cheat in any way will be severely penalized.
+
+\item Once you have submitted a player to Jutge that has defeated the Dummy
+  player, you can send more submissions but you will have to change the
+  player name. That is, once a player has defeated Dummy, his name is
+  blocked and cannot be reused.
+
+\end{itemize}
+