report/config

@@ -1 +1 @@
-Subproject commit 5523c571a9dc02b432d539428307f756e63c4c0c
+Subproject commit 4b3765f4ab57fb91e770597e417d74b5849fa144

report/report.tex

@@ -18,9 +18,7 @@
 \newcommand{\CoAuthorMail}{cchoutou@ece.auth.gr}
 \newcommand{\CoAuthorAEM}{8997}
 
-\newcommand{\WorkGroup}{Ομάδα 182}
+\newcommand{\DocTitle}{Λαβύρινθος: Ο Θησέας και ο Μινώταυρος Β}
-
-\newcommand{\DocTitle}{Λαβύρινθος: Ο Θησέας και ο Μινώταυρος III}
 \newcommand{\Department}{Τμημα ΗΜΜΥ. Τομεάς Ηλεκτρονικής}
 \newcommand{\ClassName}{Δομές δεδομένων}
 
@@ -34,7 +32,7 @@
 %\setFancyHeadLERO{\ClassName}{\DocTitle}
 %\BottomTitleSpace{8em}
 
-\renewcommand{\bottomtitlespace}{0.12\textheight}
+\renewcommand{\bottomtitlespace}{0.1\textheight}
 
 % Document
 % =================
@@ -47,15 +45,20 @@
 %\listoftables
 
 \section{Εισαγωγή}
-Η παρούσα εργασία αφορά την δημιουργία ενός παιχνιδιού με τίτλο “Μία νύχτα στο μουσείο”.
+Η παρούσα εργασία αφορά την δημιουργία ενός παιχνιδιού λαβυρίνθου  “Μία νύχτα στο μουσείο”.
 Στο συγκεκριμένο παιχνίδι καλούμαστε να υλοποιήσουμε ένα λαβύρινθο μέσα στον οποίο κινούνται δύο παίκτες, ο Μινώταυρος και ο Θησέας.
 Στόχος του Μινώταυρου είναι να  “πιάσει” τον Θησέα και στόχος του Θησέα είναι να βρει όλα τα εφόδια πού βρίσκονται κατανεμημένα στον ταμπλό, πριν ξημερώσει και πριν τον “πιάσει” ο Μινώταυρος. 
 
-\par Υπενθυμίζουμε πως στις πρώτες εργασίες κληθήκαμε να υλοποιήσουμε το ταμπλό και τα στοιχεία που το απαρτίζουν καθώς και τις βασικές λειτουργίες του παιχνιδιού.
+\par Υπενθυμίζουμε ότι στην πρώτη εργασία κληθήκαμε να λύσουμε δύο βασικά προβλήματα.
-Στη δεύτερη εργασία κληθήκαμε επιπρόσθετα να υλοποιήσουμε ένα παίκτη ο οποίος χειρίζεται το ζάρι προς όφελός του.
+Το πρόβλημα της δημιουργίας του λαβυρίνθου και το πρόβλημα της λειτουργίας των παικτών.
-Στην παρούσα εργασία ασχοληθήκαμε με τη δημιουργία ενός παίκτη που κάνει χρήση του αλγόριθμου \eng{minimax}, με σκοπό να προβλέψει καλύτερα την κίνησή του, αναλύοντας τις πιθανές κινήσεις του αντιπάλου.
+Το ταμπλό αποτελείται από πλακίδια και τοίχους.
-Φυσικά όλα τα βασικά συστατικά του παιχνιδιού που αναπτύξαμε στις δύο πρώτες εργασίες είναι παρόντα.
+Τα πλακίδια είναι διατεταγμένα σε τετραγωνικό σχήμα και ανάμεσά τους τοποθετούνται οι τοίχοι.
-Οι τροποποιήσεις σε αυτά είναι ελάχιστες και αφορούν κυρίως την συμβατότητα με τις νέες λειτουργίες, όπως αυτές περιγράφονται στην εκφώνηση.
+Το πρόβλημα έγκειται στην επιλογή και τοποθέτηση τοίχων με τέτοιο τρόπο ώστε να πληρούνται οι προδιαγραφές του παιχνιδιού όπως πχ κάθε πλακίδιο να έχει το πολύ δύο τοίχους ή τα εξωτερικά πλακίδια να έχουν τοίχο από την έξω μεριά.
+Μετά από μια πιο λεπτομερή ανάλυση του προβλήματος, διαπιστώσαμε πως οι δοθείσες προδιαγραφές δεν αποτρέπουν τη δημιουργία κλειστών δωματίων, κάτι που θεωρήσαμε άδικο, με αποτέλεσμα, όπως περιγράφουμε και αναλυτικά παρακάτω, \textbf{να προσθέσουμε έναν ακόμη περιορισμό}.
+\textbf{Την αποτροπή κλειστών δωματίων στο ταμπλό}.
+
+\par Λαμβάνοντας υπόψιν τόσο τα δεδομένα που μας δόθηκαν, δηλαδή για την δομή του παιχνιδιού, όσο και τα δύο βασικά προβλήματα που χρειάστηκε να επεξεργαστούμε και να λύσουμε στο πρώτο μέρος, αποφασίσαμε να υλοποιήσουμε την δεύτερη εργασία με γνώμονα τις σχεδιαστικές επιλογές και τα \eng{concepts} που αναπτύξαμε και περιγράφονται αναλυτικά στην αναφορά του πρώτου μέρους.
+Όσον αφορά επίσης τον τρόπο κίνησης των παικτών επιλέξαμε μόνο ο Θησέας να έχει την δυνατότητα να επιλέγει την κατεύθυνση της επόμενης κίνησης του, ενώ ο Μινώταυρος να κινείται με τυχαίο τρόπο.
 
 \section{Παραδοτέα}
 Τα επισυναπτόμενα παραδοτέα αποτελούνται από:
@@ -66,28 +69,28 @@
     \item Ένας υποκατάλογος \eng{\textbf{doc/}} με την τεκμηρίωση του κώδικα όπως αυτή έχει παραχθεί από τα σχόλια, με το εργαλείο \eng{doxygen}.
     Το αρχείο ρυθμίσεων του \eng{doxygen} είναι στον \eng{root} με το όνομα \eng{Doxyfile}.
     Η πλοήγηση στην τεκμηρίωση μπορεί να γίνει ανοίγοντας το αρχείο \eng{doc/html/index.html}
-    \item Το αρχείο \eng{\textbf{report.pdf}} που αποτελεί την \textbf{παρούσα αναφορά}. 
+    \item Ένας υποκατάλογος \eng{\textbf{report/}} που περιέχει την \textbf{παρούσα αναφορά}. 
 \end{itemize}
 Εκτός από τα επισυναπτόμενα αρχεία διαθέσιμο υπάρχει και το \textbf{\eng{git} αποθετήριο} ολόκληρης της εργασίας \href{https://git.hoo2.net/hoo2/Labyrinth}{εδώ}.
 Αυτό περιέχει τόσο τον κώδικα της εφαρμογής όσο και τον κώδικα της αναφοράς.
 
 \section{Σχεδιαστικές επιλογές}
 Πριν ασχοληθούμε όμως με τα ζητηθέντα αντικείμενα του προγράμματος, θα πρέπει να αναφερθούμε σε ορισμένες δομές που προστέθηκαν, αλλά και κάποιες σχεδιαστικές επιλογές που έγιναν για να απλοποιήσουν τον κώδικα.
-Αρκετές από αυτές προέρχονται από τις προηγούμενες εργασίες.
+Αρκετές από αυτές προέρχονται από την προηγούμενη εργασία.
 Τις παραθέτουμε όμως και εδώ καθώς παίζουν σημαντικό ρόλο, τόσο στην λειτουργία του προγράμματος όσο και στην καλύτερη κατανόηση της τρέχουσας εργασίας.
 
 \subsection{\eng{Accessor - mutator idiom}}
 Στις προδιαγραφές της εργασίας αφήνεται να εννοηθεί πως ζητείται η χρήση του \eng{\textit{accessor - mutator idiom}}.
 Θα πρέπει να παραδεχτούμε όμως, πως \textbf{θεωρούμε το συγκεκριμένο ιδίωμα ιδιαίτερα προβληματικό}.
 Ο κύριος λόγος είναι πως παραβιάζει θεμελιακά τις αφαιρέσεις προδίδοντας τον εσωτερικό σχεδιασμό του αντικειμένου.
-Ακόμα δίνει πρόσβαση στην εσωτερική δομή του, “πίσω από την πλάτη” του αντικειμένου.
+Ακόμα δίνει πρόσβαση στην εσωτερική δομή του “πίσω από την πλάτη” του αντικειμένου.
 Εν αντιθέτως με το ιδίωμα αυτό, \textbf{τα αντικείμενα που υλοποιούνται ως αφαιρέσεις θα μπορούσαν να προσφέρουν μεθόδους που εκτελούν κάποια λειτουργία, κρύβοντας τελείως τις εσωτερικές λεπτομέρειες της υλοποίησης}.
 Αυτός είναι και ο δρόμος που διαλέξαμε για το σχεδιασμό του προγράμματος.
 Η κάθε τάξη του προγράμματός μας προσφέρει δημόσια ένα αριθμό από μεθόδους που είναι απαραίτητες για την εκάστοτε απαιτούμενη λειτουργικότητα και κρύβει όσο καλύτερα γίνεται την εσωτερική υλοποίηση.
-Ενώ λοιπόν υλοποιήσαμε το ζητηθέν \eng{get-set} ζευγάρι για την κάθε μεταβλητή των τάξεων, δεν το χρησιμοποιήσαμε σχεδόν καθόλου μέσα στο πρόγραμμα.
+Ενώ λοιπόν υλοποιήσαμε το ζητηθέν \eng{get-set} ζευγάρι για την κάθε μεταβλητή των τάξεων, δεν το χρησιμοποιήσαμε πουθενά μέσα στο πρόγραμμα.
 
 \subsection{Ενοποιημένο σύστημα συντεταγμένων}
-Στις προδιαγραφές της 1ης εργασίας περιγράφεται επίσης ένα διπλό σύστημα συντεταγμένων, τόσο για τα πλακίδια όσο και για τα εφόδια.
+Στις προδιαγραφές της εργασίας περιγράφεται επίσης ένα διπλό σύστημα συντεταγμένων, τόσο για τα πλακίδια όσο και για τα εφόδια.
 Ένα καρτεσιανό που διευθυνσιοδοτεί ως προς δύο άξονες και περιέχει ένα ζευγάρι γραμμής και στήλης και ένα μονοδιάστατο που αποτελείται από τον γραμμικό συνδυασμό των προηγουμένων.
 Το μονοδιάστατο αντικατοπτρίζει και την απεικόνιση στη μνήμη ενός πίνακα 2 διαστάσεων σε \eng{row major order}.
 
@@ -103,7 +106,7 @@
 Ακόμα σημαίνει πως δημιουργούν επιπλέον πλεονασμό σε δεδομένα, καθώς απαιτείται οι συντεταγμένες του πλακιδίου που βρίσκεται το εφόδιο να επαναληφθούν μέσα στην \eng{Supply}.
 Κάτι τέτοιο γίνεται αντιληπτό και από τις προδιαγραφές της \eng{Board} η οποία είναι αυτή που περιέχει τους πίνακες αναφορών τόσο των πλακιδίων όσο και των εφοδίων.
 \textbf{Μια πιο διαισθητική προσέγγιση βέβαια θα ήθελε τα εφόδια να ανήκουν στα πλακίδια} και όχι στο ταμπλό.
-Με αυτό τον τρόπο η τάξη \eng{Supply} δεν θα είχε τις επαναλαμβανόμενες πληροφορίες θέσης, αλλά αντίθετα η τάξη \eng{Tile} θα είχε απλώς μια επιπρόσθετη πληροφορία για το αν φιλοξενεί κάποιο εφόδιο ή όχι.
+Με αυτό τον τρόπο η τάξη \eng{Supply} δεν θα είχε τις επαναλαμβανόμενες πληροφορίες θέσης, αλλά αντίθετα η τάξη \eng{Tile} θα είχε απλώς μια επιπρόσθετη πληροφορία για το αν υπάρχει εφόδιο ή όχι.
 
 \par Όπως είναι φυσικό θελήσαμε να υλοποιήσουμε αυτή την προσέγγιση.
 Αν όμως μετακινούσαμε τις αναφορές των εφοδίων στην \eng{Tile} θα αλλοιώναμε τις προδιαγραφές της εκφώνησης.
@@ -121,40 +124,31 @@
 Αυτό είναι το τίμημα που πρέπει να πληρώσουμε προωθώντας τις μεθόδους αυτές στην \eng{Tile}.
 
 \subsection{Αναβάθμιση της τάξης \eng{Board}}
-Στην διάρκεια του σχεδιασμού θεωρήσαμε ωφέλιμη την εισαγωγή του πίνακα \eng{\textit{int[][] moves}} στην τάξη \eng{Board}.
+Στην διάρκεια του σχεδιασμού θεωρήσαμε ωφέλιμη την εισαγωγή της μεταβλητής \eng{\textit{ArrayList<Integer[]> moves}} στην τάξη \eng{Board}.
-Σε αυτόν καταχωρούμε τις πληροφορίες της τελευταίας κίνησης του κάθε παίκτη, όπως το \eng{id} του πλακιδίου που βρίσκεται ο παίκτης, οι συντεταγμένες του και η “ζαριά” της κίνησης.
+Σε αυτή καταχωρούμε τις πληροφορίες της τελευταίας κίνησης του κάθε παίκτη, όπως το \eng{id} του πλακιδίου που βρίσκεται ο παίκτης, οι συντεταγμένες του και η συλλογή εφοδίου.
 Στην προσθήκη αυτή οδηγηθήκαμε αφού παρατηρήσαμε πως για την τάξη \eng{HeuristicPlayer} είναι απαραίτητη η πρόσβαση στην θέση και στο \eng{id} του αντιπάλου.
-Φυσικά την ίδια απαίτηση έχουμε και με την τάξη \eng{MinMaxPlayer}.
+Αυτή πραγματοποιείται μέσω της μεταβλητής \eng{moves} και της συνάρτησης \eng{\textit{getOpponentMoves()}}.
-Η πρόσβαση στις κινήσεις πραγματοποιείται μέσω της μεταβλητής \eng{moves} και της συνάρτησης \eng{\textit{getOpponentMove()}}.
+Έτσι ο κάθε \eng{HeuristicPlayer} μπορεί να διαπιστώσει αν στο οπτικό του πεδίο βρίσκεται κάποιος αντίπαλος και να κινηθεί κατάλληλα.
-Έτσι ο κάθε \eng{HeuristicPlayer} ή \eng{MinMaxPlayer} μπορεί να διαπιστώσει αν στο οπτικό του πεδίο βρίσκεται κάποιος αντίπαλος και να κινηθεί κατάλληλα.
-
-\par Ακόμα μέσω του ίδιου μηχανισμού δίνουμε την δυνατότητα στους παίκτες να μαθαίνουν το \eng{ID} του αντιπάλου.
-Αυτό είναι χρήσιμο για τον \eng{MinMaxPlayer} όταν προσπαθεί να σκηνοθετήσει τις κινήσεις του αντιπάλου.
-Θα αναλύσουμε περισσότερα όμως γύρω από αυτό στην παράγραφο \ref{minimax}.
 
 \subsection{Αναβάθμιση της τάξης \eng{Player}}
 Για την επέμβαση σε αυτή την τάξη κινηθήκαμε με γνώμονα την αντιμετώπιση δύο προβλημάτων που μας παρουσιάστηκαν.
 Αρχικά για την σωστή λειτουργία τη κλάσης \eng{HeuristicPlayer}, όπως αναφέραμε και παραπάνω, είναι αναγκαία η πρόσβαση στο \eng{id} του αντιπάλου.
-Για τον λόγο αυτό επιλέξαμε να δημιουργείται ένα \eng{id} για κάθε παίκτη μέσω συνάρτησης της τάξης \eng{Board}, στο οποίο θα έχουμε πρόσβαση μέσω του πίνακα \eng{\textit{int[][] moves}}.
+Για τον λόγο αυτό επιλέξαμε να δημιουργείται ένα \eng{id} για κάθε παίκτη μέσω συνάρτησης της τάξης \eng{Board}, στο οποίο θα έχουμε πρόσβαση μέσω της μεταβλητής \eng{\textit{ArrayList<Integer[]> moves}}.
 Τη λειτουργία αυτή αναλαμβάνει η συνάρτηση \eng{\textit{int generatePlayerId()}}.
 
 \par
-Επιπρόσθετα, θελήσαμε να ενοποιήσουμε τις υλοποιήσεις των τάξεων \eng{Player}, \eng{HeuristicPlayer} και \eng{MinMaxPlayer}, ώστε να τις κάνουμε συμβατές με την αρχή του \eng{Liskov} \footnote{\eng{\url{https://en.wikipedia.org/wiki/Liskov_substitution_principle}}}.
+Επιπρόσθετα, θέλαμε να ενοποιήσουμε τις υλοποιήσεις των τάξεων \eng{Player} και \eng{HeuristicPlayer} και να τις κάνουμε συμβατές με την αρχή του \eng{Liskov} \footnote{\eng{\url{https://en.wikipedia.org/wiki/Liskov_substitution_principle}}}.
-Για το λόγο αυτό οι συναρτήσεις \eng{\textit{move(), statistics()}} και \eng{\textit{final\_statistice()}} είναι πλέον υλοποιημένες και σε όλα τα αντικείμενα.
+Για το λόγο αυτό οι συναρτήσεις \eng{\textit{move(), statistics()}} και \eng{\textit{final\_statistice()}} είναι πλέον υλοποιημένες και στα δύο αντικείμενα.
 Αυτό μας ανάγκασε να μετακινήσουμε την μεταβλητή \eng{path} στο \eng{base object} δηλαδή στην \eng{Player}.
 
 \section{\eng{Concepts}}
-Αν και τα \eng{concepts} υλοποιήθηκαν για την εκπόνηση του πρώτου μέρους, τα παραθέτουμε συνοπτικά και σε αυτή την αναφορά, καθώς τα θεωρούμε ουσιαστικό κομμάτι για όλα τα μέρη της εργασίας.
+Αν και τα \eng{concepts} υλοποιήθηκαν για την εκπόνηση του πρώτου μέρους, τα παραθέτουμε συνοπτικά και σε αυτή την αναφορά, καθώς τα θεωρούμε ουσιαστικό κομμάτι τόσο για το πρώτο, όσο και για το δεύτερο μέρος της εργασίας.
-Τα \eng{”concepts”} μας έχουν τη μορφή συναρτήσεων και αφορούν έννοιες σχετικές με την εφαρμογή.
+Για την εργασία υλοποιήσαμε κάποια \eng{concepts} σε μορφή συναρτήσεων κατά την εκτέλεση του προγράμματος.
+Τα \eng{concepts} αυτά αφορούν έννοιες σχετικές με την εφαρμογή και έχουν την μορφή \eng{predicate}.
 Μας δίνεται έτσι η δυνατότητα να ελέγχουμε αν κάποια είσοδός ενός \eng{predicate-concept} πληροί τις προδιαγραφές του ή όχι.
 Στο σχήμα \ref{fig:concepts} φαίνεται μια οπτικοποιημένη έκδοση τους.
 
 \subsection{Πλακίδιο φρουρός - \textit{\eng{isSentinel()}}}
-\WrapFigure{0.45}{r}{fig:concepts}{images/concepts.png}{
-    Οπτική αναπαράσταση των \eng{concepts} που χρησιμοποιούμε σε ένα ταμπλό $7x7$.
-    Με πράσινο αναπαρίστανται όσα πληρούν κάποιο \eng{concept} και με κόκκινο όσα όχι.
-    Τα πλακίδια με το γκρι χρώμα, είναι τα πλακίδια φρουροί.
-}
 Πρόκειται για \eng{concept} που μας επιτρέπει να ελέγξουμε αν το πλακίδιο είναι \textit{”πλακίδιο φρουρός”}.
 Αν δηλαδή βρίσκεται στα εξωτερικά άκρα του ταμπλό.
 Η υλοποίηση αυτού του \eng{concept} γίνεται μέσω τεσσάρων συναρτήσεων που ελέγχουν χωριστά τις τέσσερεις διευθύνσεις του ταμπλό.
@@ -173,6 +167,11 @@
 \end{itemize}
 
 \subsection{Χτίσιμη διεύθυνση - \textit{\eng{isWallableDir()}}}
+\WrapFigure{0.45}{r}{fig:concepts}{images/concepts.png}{
+    Οπτική αναπαράσταση των \eng{concepts} που χρησιμοποιούμε σε ένα ταμπλό $7x7$.
+    Με πράσινο αναπαρίστανται όσα πληρούν κάποιο \eng{concept} και με κόκκινο όσα όχι.
+    Τα πλακίδια με το γκρι χρώμα, είναι τα πλακίδια φρουροί.
+}
 Πρόκειται για \eng{predicate} που μας επιτρέπει να ελέγξουμε αν μια διεύθυνση κάποιου πλακιδίου είναι \textit{”χτίσιμη διεύθυνση”}.
 Αν δηλαδή μπορούμε να τοποθετήσουμε τοίχο στη διεύθυνση αυτή.
 Για να είναι μια διεύθυνση χτίσιμη θα πρέπει:
@@ -197,7 +196,7 @@
 \end{itemize}
 
 \subsection{Δημιουργός κλειστού δωματίου - \textit{\eng{isRoomCreator()}}} \label{sec:isRoomCreator}
-Οι προδιαγραφές της εργασίας που αφορούν τη δημιουργία του ταμπλό, δεν αποτρέπουν την εμφάνιση κλειστών δωματίων.
+Όπως αναφέραμε και παραπάνω οι προδιαγραφές της εργασίας δεν αποτρέπουν τη δημιουργία κλειστών δωματίων.
 Για το λόγο αυτό υλοποιήσαμε ένα αλγόριθμο που ανιχνεύει την πιθανότητα δημιουργίας κλειστών δωματίων του οποίου η ενεργοποίηση γίνεται κατόπιν επιλογής του χρήστη από τη γραμμή εντολών.
 
 \par Ένας αλγόριθμος για να είναι λειτουργικός χρειάζεται δεδομένα.
@@ -240,9 +239,10 @@
 Φυσικά θα μπορούσαμε να χρησιμοποιήσουμε υπομνηματισμό και να αποθηκεύουμε τους γράφους
 Όμως λόγο του ότι η επιβάρυνση λαμβάνει χώρα μόνο μία φορά κατά την εκκίνηση, σε συνδυασμό με το μικρό μέγεθος του ταμπλό, αποφασίσαμε να μην προχωρήσουμε σε περαιτέρω βελτιστοποίηση.
 
+
 \section{Υλοποίηση}
 Για την μεταγλώττιση της εφαρμογής, απαιτείται \eng{java} έκδοση 8 ή και μεταγενέστερη καθώς έχουμε κάνει χρήση \eng{lambdas}.
-Για υπενθύμιση, αναφέρουμε συνοπτικά τη λειτουργία ορισμένων αντικειμένων που προσθέσαμε κατά την πρώτη και δεύτερη εργασία.
+Για υπενθύμιση, αναφέρουμε συνοπτικά τη λειτουργία ορισμένων αντικειμένων που προσθέσαμε κατά την πρώτη εργασία.
 \begin{itemize}
     \item \eng{\textbf{Const}}\\
     Το αντικείμενο αυτό περιέχει σταθερές για όλη την εφαρμογή.
@@ -272,63 +272,16 @@
     Η τάξη αυτή κληρονομεί την \eng{Range} και προσθέτει τη λειτουργία του τυχαίου ανακατέματος των τιμών.
 \end{itemize}
 
-\subsection{Αλγόριθμος \eng{minimax}} \label{minimax}
+\subsection{Τάξη \eng{HeuristicPlayer}}
-\WrapFigure{0.45}{r}{fig:maxValue}{images/maxValue.png}{
+Η υλοποίηση της τάξης \eng{HeuristicPlayer} πραγματοποιήθηκε έτσι ώστε να ικανοποιούνται τα ζητήματα της εκφώνησης.
-    Διάγραμμα ροής της \eng{\textit{maxValue()}}, όπου γίνεται αναδρομική κλήση της \eng{\textit{minValue()}}.
+Η βασική λειτουργία της τάξης είναι η συνάρτηση \eng{\textit{double evaluate(int currentPos, int dice)}} η οποία ζητήθηκε και από την εκφώνηση.
-}
+Για τη δημιουργία της βασιστήκαμε στην ανάπτυξη κριτηρίων που θα βοηθήσουν τον παίκτη να “καταλήξει” στην βέλτιστη απόφαση με βάση το προκαθορισμένο οπτικό του πεδίο.
-Ο σκοπός της παρούσας εργασίας θεωρούμε πως ήταν η υλοποίηση του αλγόριθμου \eng{minimax}.
+Τα κριτήρια αυτά είναι η απόσταση από κάποιο εφόδιο και η απόσταση από τον αντίπαλο.
-Για τον αλγόριθμο αυτό αρχικά απαιτείται η δημιουργία ενός δέντρου.
+Στην τελική αξιολόγηση της κίνησης τα κριτήρια συνδυάζονται με συντελεστές βάρους οι οποίοι αποτελούν σταθερές και θέτονται κατά τη μεταγλώττιση του προγράμματος.
-Το κάθε επίπεδο του δέντρου έχει για κόμβους όλες τις δυνατές κινήσεις των παικτών εναλλάξ.
+\par
-Έτσι ο κάθε κόμβος αναπαριστά μια κίνηση και τα παιδιά του κάθε κόμβου αναπαριστούν όλες τις δυνατές κινήσεις-απαντήσεις του αντίπαλου παίκτη στην κίνηση αυτή.
+Ένα ακόμη χαρακτηριστικό της τάξης είναι η εκτενής χρήση της μεταβλητής \eng{path}.
-Καθώς εκτελείται ο αλγόριθμος η αξιολόγηση της κάθε κίνησης από τους κατώτερους κόμβους ανεβαίνει προς τα πάνω.
+Όπως αναφέραμε και παραπάνω η μεταβλητή αυτή είναι προσβάσιμη τόσο από την \eng{HeuristicPlayer}, όπως ζητήθηκε, όσο και από την \eng{Player}.
-Η επιλογή γίνεται εναλλάξ από τον κάθε παίκτη.
+Και οι δύο τάξεις καταχωρούν πληροφορίες για την κίνησή του κάθε παίκτη, με την διαφορά πως η \eng{HeuristicPlayer} καταχωρεί περισσότερες.
-Έτσι ο αντίπαλος επιλέγει για τιμή του κάθε κόμβου την τιμή από τα παιδιά με την μικρότερη αξιολόγηση, ενώ ο παίκτης μας την τιμή με την μεγαλύτερη.
-Στο τέλος ο βασικός κόμβος περιέχει την μέγιστη δυνατή τιμή λαμβάνοντας υπόψιν την καλύτερη δυνατή κίνηση-απάντηση του αντιπάλου.
-
-\par Για τον κάθε κόμβο υλοποιήσαμε την τάξη \eng{Node} ακολουθώντας τις οδηγίες της εκφώνησης.
-Πέρα από αυτές όμως χρειαστήκαμε και μια επιπλέον πληροφορία, που αφορά το μονοπάτι της επιλογής των κόμβων από τον αλγόριθμο.
-Δηλαδή, σε κάθε κόμβο αποθηκεύουμε επιπλέον ένα δείκτη προς τον κόμβο από τον οποίο έγινε η επιλογή της τιμής του.
-Με αυτό τον τρόπο ήμαστε σε θέση, μετά την εκτέλεση του αλγόριθμου, να γνωρίζουμε τόσο την τιμής της αξιολόγησης, όσο και την κίνηση από την οποία προήλθε.
-
-\par Η υλοποίηση του \eng{minimax} αλγόριθμου έγινε στην τάξη \eng{MinMaxPlayer}.
-Η τάξη αυτή κληρονομεί την \eng{Player} και μαζί και τις βασικές λειτουργίες όπως τους \eng{Constructors} και το \eng{accessor - mutator idiom}.
-Ακολουθώντας τον σχεδιασμό της \eng{HeuristicPlayer}, υλοποιήσαμε την \eng{MinMaxPlayer}, δίχως κανένα \eng{data member}.
-Αυτά ανήκουν όλα στην \eng{Player}.
-Έτσι όλη η επιπρόσθετη λειτουργικότητα της τάξης αφορά τον αλγόριθμο \eng{nimimax}.
-Οι κύριες μέθοδοι που υλοποιήθηκαν για την δημιουργία του δέντρου είναι:\\
-\begin{itemize}
-    \item \eng{\textbf{\textit{int[] dryMove()}}}\\
-    Η συνάρτηση αυτή προσομοιώνει την κίνηση κάποιου παίκτη χρησιμοποιώντας για ταμπλό αυτό από τα ορίσματά της.
-    Έτσι μπορούμε να πραγματοποιήσουμε διαφορετικές κινήσεις σε διαφορετικούς κλώνους του ταμπλό χωρίς να αλλοιώσουμε το βασικό ταμπλό του παιχνιδιού.
-    
-    \item \eng{\textbf{\textit{void createMySubtree()}}}\\
-    Η συνάρτηση αυτή είναι η μία από τις δύο μεθόδους που υλοποιούν το δέντρο με τις δυνατές κινήσεις των παικτών.
-    Ξεκινώντας από τη τρέχουσα θέση του παίκτη και για κάθε “διασχίσιμη διεύθυνση” δημιουργούμε και ένα αντίγραφο του ταμπλό και σε αυτό εκτελούμε την κίνηση του παίκτη εικονικά μέσω της συνάρτησης \eng{\textit{dryMove()}}.
-    Έπειτα αποθηκεύουμε στο δέντρο την κίνηση αυτή ώς κόμβο και καλούμε την συνάρτηση \eng{\textit{createOppSubtree()}} με αυτόν σαν όρισμα.
-
-    \item \eng{\textbf{\textit{void createOppSubtree()}}}\\
-    Η συνάρτηση εκτελεί την ίδια διαδικασία με την \eng{\textit{createMySubtree()}} αλλά για τον αντίπαλο αυτή τη φορά.
-    
-    \item \eng{\textbf{\textit{double evaluation()}}}\\
-    Η συνάρτηση αυτή είναι υπεύθυνη για την αξιολόγηση της κάθε κίνησης.
-    Τόσο στην περίπτωση της του παίκτη, όσο και στην περίπτωση του αντιπάλου.
-    Για να είναι συμβατή με τα ζητούμενα, αξιολογεί την κίνηση “κοιτώντας” το ταμπλό στην κατεύθυνση της κίνησης και μόνο.
-    Αυτή η συμπεριφορά είναι αρκετά περιοριστική και οδηγεί σε πολύ φτωχά αποτελέσματα.
-    Για παράδειγμα ενώ μια κίνηση προς τον αντίπαλο αξιολογείται αρνητικά καθώς ο παίκτης μπορεί να τον “δει”, η κατεύθυνση μακριά από τον αντίπαλο δεν αξιολογείται θετικά.
-    Ακόμα στην περίπτωση που η αξιολόγηση αφορά κίνηση του αντιπάλου, δεν έχουμε την δυνατότητα να αξιολογήσουμε την κατάσταση της πίστας συνολικά.
-    Για να αντιμετωπίσουμε αυτόν τον τελευταίο περιορισμό, μετά την προσομοίωση της κίνησης του αντιπάλου, αξιολογούμε ξανά την τελευταία κίνηση του παίκτη.
-    Μόνο που πλέον ο αντίπαλος είναι σε νέα θέση.
-\end{itemize}
-
-\par Τόσο η \eng{\textit{createMySubtree()}}, όσο και η \eng{\textit{createOppSubtree()}} εσωτερικά αξιολογούν την κάθε κίνηση.
-Αυτό είναι περιττό καθώς οι μόνοι κόμβοι που απαιτείται να αξιολογηθούν είναι τα φύλλα.
-Παρόλα αυτά αποφασίσαμε να εκτελέσουμε την \eng{\textit{evaluate()}} που αξιολογεί την κίνηση σε κάθε κόμβο ώστε να συμβαδίζουμε με τις οδηγίες της εκφώνησης.
-
-\par Ο αλγόριθμος ολοκληρώνεται με την υλοποίηση των συναρτήσεων που ανάγουν τις αξιολογήσεις των κόμβων προς τα πάνω.
-Αυτές είναι οι \eng{\textit{maxValue()}} και \eng{\textit{minValue()}} και εκτελούνται αναδρομικά εναλλάξ από τον παίκτη και τον αντίπαλο.
-Στο σχήμα \ref{fig:maxValue} φαίνεται το διάγραμμα ροής της \eng{\textit{maxValue()}}.
-Η \eng{\textit{minValue()}} είναι αντίστοιχη.
-Ο παίκτης προσπαθεί μέσω της \eng{\textit{maxValue()}} να επιλέξει τη μεγαλύτερη αξιολόγηση ενώ ο αντίπαλος, μέσω της \eng{\textit{minValue()}}, επιλέγει την μικρότερη.
 
 \section{Εκτελέσιμο} \label{sec:excecutable}
 Όπως αναφέραμε και στην παράγραφο με τα παραδοτέα, σε αυτά υπάρχει και το παραγόμενο εκτελέσιμο για την γραμμή εντολών.
@@ -375,18 +328,22 @@
     \eng{\texttt{java -jar labyrinth -r 200 -s 7}}\\[1.2ex]
     Αν ο χρήστης δεν χρησιμοποιήσει την επιλογή τότε ο προεπιλεγμένος αριθμός είναι 100.
 \end{itemize}
-\InsertFigure{0.6}{fig:executable}{images/screenshot.png}{
+\InsertFigure{0.5}{fig:executable}{images/screenshot.png}{
     Στιγμιότυπο από την εκτέλεση του προγράμματος σε \eng{interactive mode} και με αποφυγή κλειστών δωματίων.
     Η εντολή που χρησιμοποιήθηκε είναι \eng{\texttt{java -jar labyrinth -i -{}-norooms}}
 }
 
 \section{Παρατηρήσεις}
-Κλείνοντας θα θέλαμε να πούμε πως η παρούσα εργασία ήταν μια προσπάθεια να υλοποιήσουμε τα ζητούμενα χρησιμοποιώντας όμως πρακτικές που θεωρούμε αναγκαίες για την συγγραφή κώδικα.
+Θα θέλαμε εδώ να σταθούμε και σε κάποιες διορθώσεις που χρειάστηκε να πραγματοποιήσουμε στον κώδικα που καταθέσαμε για την πρώτη εργασία.
-Πρακτικές που στόχο έχουν να αποτρέψουν την πιθανότητα λανθασμένης χρήσης σε βάθος χρόνου.
+Για την ακρίβεια παρατηρήσαμε πως ο \eng{copy constructor} της \eng{Board} αποτύγχανε να αντιγράψει το διάνυσμα αναφορών των τοίχων.
-Για το λόγο αυτό προσπαθήσαμε να περιορίσουμε, όπου αυτό δεν ήταν αντίθετο με τα ζητούμενα, την δυνατότητα της λανθασμένης χρήσης εισάγοντας αρκετά επιπλέον εργαλεία για την εφαρμογή.
+Ακόμα ο αλγόριθμος που αναλάμβανε να τοποθετήσει τους εσωτερικούς τοίχους στο ταμπλό αποτύγχανε να εξαντλήσει όλες τις δυνατές θέσεις με τους πιθανούς τοίχους.
+Λεπτομέρειες για τις διορθώσεις μπορεί κάποιος να δει και \href{https://git.hoo2.net/hoo2/Labyrinth/commit/c14d1d812f312eda499c445e2827a8fbafa34100}{εδώ}.
+
+\par Κλείνοντας θα θέλαμε να παρατηρήσουμε πως η παρούσα υλοποίηση ήταν μια προσπάθεια να ισορροπήσουμε μεταξύ των ζητηθέντων και μεταξύ πρακτικών που διευκολύνουν στη συγγραφή ευκολότερου και καθαρότερου κώδικα.
+Γενικά, όπως είναι ίσως ήδη γνωστό, πιστεύουμε πως \textbf{αν ο χρήστης μιας βάσης κώδικα έχει τη δυνατότητα να χρησιμοποιήσει λανθασμένα τον κώδικα, κάποια στιγμή θα το κάνει.}
+Ακόμα και αν ο χρήστης είναι ο ίδιος ο αρχικός συντάκτης του κώδικα.
+Για το λόγο αυτό προσπαθήσαμε να περιορίσουμε, όπου αυτό δεν ήταν αντίθετο με τα ζητούμενα, την δυνατότητα της λανθασμένης χρήσης εισάγοντας αρκετά επιπλέον αντικείμενα και δομές ως εργαλεία για την εφαρμογή.
 Τέτοια για παράδειγμα είναι η τάξη \eng{Position} ή η αποφυγή των \eng{setters} κτλ.
-Ακόμα προσπαθήσαμε να οργανώσουμε τις δομές δεδομένων με τέτοιο τρόπο ώστε να περιορίσουμε τον απαιτούμενο κώδικά όσο το δυνατό περισσότερο.
-Αυτό έχει ως αποτέλεσμα ένα κάπως πιο μακροσκελές κώδικα, με πολλά αντικείμενα και συναρτήσεις, που ίσως είναι δυσανάλογος των μικρών απαιτήσεων της εργασίας.
 Ελπίζουμε να μην θεωρηθούν υπερβολικά.
 
 % References

src/host/labyrinth/Board.java

@@ -13,6 +13,7 @@
 package host.labyrinth;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.function.IntFunction;
 
 /**
@@ -36,8 +37,7 @@ class Board {
       tiles    = null;
       supplies =null;
       walls    = new ArrayList<Edge>();
-      moves    = new int[Const.numOfPlayers][Player.MOVE_DATA_SIZE];
+      moves    = new ArrayList<Integer[]>();
-      playerCount =0;
    }
 
    /**
@@ -54,8 +54,7 @@ class Board {
       tiles    = new Tile[N*N];
       supplies = new Supply[S];
       walls    = new ArrayList<Edge>();
-      moves    = new int[Const.numOfPlayers][Player.MOVE_DATA_SIZE];
+      moves    = new ArrayList<Integer[]>();
-      playerCount =0;
    }
 
    /**
@@ -76,25 +75,14 @@ class Board {
       this.N   = b.N;
       this.S   = b.S;
       this.W   = b.W;
-      tiles       = new Tile[b.tiles.length];
+      // Clone arrays
-      supplies    = new Supply[b.supplies.length];
+      this.tiles     = b.tiles.clone();
-      walls       = new ArrayList<Edge>();
+      this.supplies  = b.supplies.clone();
-      moves       = new int[Const.numOfPlayers][Player.MOVE_DATA_SIZE];
-      playerCount =b.playerCount;
-
-      // clone moves array of array of primitives
-      for (int i=0 ; i<b.moves.length ; ++i)
-         this.moves[i] = b.moves[i].clone();
-
-      // Clone arrays of objects
-      for (int i=0 ; i<b.tiles.length ; ++i)
-         this.tiles[i] = new Tile(b.tiles[i]);
-      for (int i=0 ; i<b.supplies.length ; ++i)
-         this.supplies[i] = new Supply(b.supplies[i]);
-
-      // clone vectors
       for (Edge it: b.walls)
     	  this.walls.add(new Edge(it));
+      for (Integer[] m : b.moves) {
+         this.moves.add(m);
+      }
    }
    /** @} */
 
@@ -231,35 +219,30 @@ class Board {
    /** @return the size of each site of the board.  */
    int size ()    { return N; }
 
-   /**
-    * Utility function to create player IDs
-    * @return  The generated player id.
-    */
-   int generatePlayerId () throws Exception {
-      if (playerCount < Const.numOfPlayers)
-         return playerCount++;
-      else
-         throw new Exception("Maximum number of players exceeded");
-   }
-
-   /**
-    * Boards utility to give access to other player Id.
-    *
-    * @param playerId   The id of player who asks
-    * @return           The other player's Id.
-    */
-   int getOpponentId(int playerId) {
-      return Const.numOfPlayers - (playerId +1);
-   }
-
    /**
     * Boards utility to give access to other player moves.
     *
     * @param playerId   The id of player who asks
-    * @return           The moves data of other player
+    * @return           The moves data of all other players
     */
-   int[] getOpponentMove (int playerId) {
+   int[][] getOpponentMoves (int playerId) {
-      return moves[getOpponentId(playerId)];
+      int[][] ret = new int[moves.size()-1][Const.moveItems];
+      int ii= 0, ri =0;
+      for (Integer[] m : moves) {
+         if (ii != playerId)
+            ret[ri++] = Arrays.stream(m).mapToInt(i->i).toArray();
+         ++ii;
+      }
+      return ret;
+   }
+
+   /**
+    * Utility function to create player IDs
+    * @return  The generated player id.
+    */
+   int generatePlayerId () {
+      moves.add(null);
+      return moves.size() -1;
    }
 
    /**
@@ -273,8 +256,7 @@ class Board {
     * @param playerId   The id of the player who update his/her data.
     */
    void updateMove(int[] m, int playerId) {
-      //moves.set(playerId, Arrays.stream(m).boxed().toArray(Integer[]::new));
+      moves.set(playerId, Arrays.stream(m).boxed().toArray(Integer[]::new));
-      moves[playerId] = m;
    }
 
    /** @} */
@@ -313,7 +295,7 @@ class Board {
     * <a href="https://github.com/sean-parent/sean-parent.github.io/blob/master/better-code/03-data-structures.md"> see also here</a>
     * @return  Reference to inner walls array.
     */
-   int[][] getMoves() { return moves; }
+   ArrayList<Integer[]> getMoves() { return moves; }
 
    void setN(int N)  { this.N = N; }
    void setS(int S)  { this.S = S; }
@@ -344,7 +326,7 @@ class Board {
     * @note    Use with care.
     * Any call to this function will probably add memory for the garbage collector.
     */
-   void setMoves(int[][] moves) { this.moves =moves; }
+   void setMoves(ArrayList<Integer[]> moves) { this.moves =moves; }
 
    /** @} */
 
@@ -651,7 +633,6 @@ class Board {
                                      *  Array to hold all the walls using the edge representation 
                                      *  required by the closed room preventing algorithm. 
                                      */
-   private int[][] moves;
+   private ArrayList<Integer[]>  moves;
-   private int playerCount;
    /** @} */
 }

src/host/labyrinth/Common.java

@@ -19,23 +19,16 @@ import java.util.Collections;
  * Class to hold constant values for entire application
  */
 class Const {
-   static final int numOfPlayers = 2;
    static final int maxTileWalls = 2;  /**< Number of maximum walls for each tile on the board */
    static final int noSupply =-1;      /**< Number to indicate the absent of supply */
    static final int noOpponent =-1;    /**< Number to indicate the absent of supply */
    static final int noTileId =-1;      /**< Number to indicate wrong tileId */
    static final int EOR =-1;           /**< Number to indicate the End Of Range */
+   static final int moveItems =4;      /**< The number of items return by move() */
    static final int viewDistance =3;   /**< The max distance of the Heuristic player's ability to see */
-   static final int noView = viewDistance+1;
 
-   /** Parameters to control move evaluation */
+   static final double opponentFactor  =1.0;
-   /** @{ */
+   static final double supplyFactor    =0.65;
-   static final double opponentFactor  = 1.0;   /**< opponent distance factor */
-   static final double supplyFactor    = 0.65;  /**< supply distance factor */
-   static final double preMoveFactor   = 0.65;  /**< pre move distances factor */
-   static final double postMoveFactor  = 0.35;  /**< post move distances factor */
-   static final int minimaxTreeDepth   = 4;     /**< The maximum depth of the minimax tree */
-   /** @} */
 }
 /**
  * Application wide object to hold settings like values for the session.
@@ -75,16 +68,13 @@ class Direction {
    static final int  RIGHT =3;   /**< East direction */
    static final int  DOWN  =5;   /**< South direction */
    static final int  LEFT  =7;   /**< West direction */
-   static final int  NONE  =8;   /**< No direction */
 
    /**
     * Utility to get the opposite direction.
     * @param direction  Input direction
     * @return           The opposite direction
     */
-   static int opposite (int direction) {
+   static int opposite (int direction) { return (direction+4)%DirRange.End; }
-      return (direction != NONE) ? (direction+4)%DirRange.End : NONE;
-   }
 
    static int get (int fromId, int toId) {
       if      (Position.toID(Position.toRow(fromId),   Position.toCol(fromId)-1) == toId)
@@ -143,7 +133,6 @@ class Position {
          case Direction.DOWN: this.id = toID(row-1, col);   break;
          case Direction.LEFT: this.id = toID(row, col-1);   break;
          case Direction.RIGHT:this.id = toID(row, col+1);   break;
-         case Direction.NONE: this.id = toID(row, col);     break;
       }
    }
 

src/host/labyrinth/Game.java

@@ -18,14 +18,13 @@
  * all the supplies of the board before Minotaur catches him and before the
  * game ends.
  * 
- * In this 3rd assignment we deal with the creation of a new minimax player
+ * In this 2nd assignment we deal with the creation of a new heuristic player
  * who can cheat and manipulate the dice. Documented classes:
  *  - Tile
  *  - Supply
  *  - Board
  *  - Player
  *  - HeuristicPlayer
- *  - MinMaxPlayer
  *  - Game
  *
  * Which are the requested classes. We also provide some extra functionalities in:
@@ -157,9 +156,9 @@ public class Game {
          // Create a game, a board and 2 players.
          Game game         = new Game();
          Board board       = new Board(Session.boardSize, Session.supplySize);
-         Player T          = new MinMaxPlayer("Theseus", true, board, 0);
+         Player T          = new HeuristicPlayer("Theseus", true, board, 0);
          Player M          = new Player("Minotaur", false, board, Position.toID(Session.boardSize/2, Session.boardSize/2));
-         Player players [] = {M, T};
+         Player players [] = {T, M};
 
          // Populate data to the board
          board.createBoard(T.playerTileId(), M.playerTileId());

src/host/labyrinth/HeuristicPlayer.java

@@ -1,5 +1,5 @@
 /**
- * @file HeuristicPlayer.java
+ * @file Player.java
  *
  * @author
  *    Anastasia Foti AEM:8959
@@ -29,7 +29,7 @@ class HeuristicPlayer extends Player {
     * @param row        The row coordinate of initial player position
     * @param column     The column coordinate of initial player's position
     */
-   public HeuristicPlayer(String name, boolean champion, Board board, int row, int column) throws Exception {
+   public HeuristicPlayer(String name, boolean champion, Board board, int row, int column) {
       super(name, champion, board, row, column);
    }
 
@@ -40,7 +40,7 @@ class HeuristicPlayer extends Player {
     * @param board      Reference to the board of the game
     * @param tileId     The tileId coordinate of player's initial position
     */
-   public HeuristicPlayer(String name, boolean champion, Board board, int tileId) throws Exception {
+   public HeuristicPlayer(String name, boolean champion, Board board, int tileId) {
       super(name, champion, board, tileId);
    }
    /** @} */
@@ -58,7 +58,7 @@ class HeuristicPlayer extends Player {
       Position pos = new Position(Position.toRow(currentPos), Position.toCol(currentPos));
 
       for (int i=0 ; board.isWalkable(pos.getId(), direction) && i<Const.viewDistance ; ++i) {
-         pos = new Position(pos.getRow(), pos.getCol(), direction);
+         pos = new Position(Position.toRow(pos.getId()), Position.toCol(pos.getId()), direction);
          if (board.hasSupply(pos.getId()))
             return i+1;
       }
@@ -73,13 +73,15 @@ class HeuristicPlayer extends Player {
     */
    int opponetInDirection(int currentPos, int direction) {
       Position pos  = new Position(Position.toRow(currentPos), Position.toCol(currentPos));
-      int [] opp = board.getOpponentMove(playerId);
+      int [][] opps = board.getOpponentMoves(playerId);
 
       for (int i=0 ; board.isWalkable(pos.getId(), direction) && i<Const.viewDistance ; ++i) {
-         pos = new Position(pos.getRow(), pos.getCol(), direction);
+         pos = new Position(Position.toRow(pos.getId()), Position.toCol(pos.getId()), direction);
-         if (opp[MOVE_TILE_ID] == pos.getId())
+         for (int o =0 ; o<opps.length; ++o) {
+            if (opps[o][0] == pos.getId())
                return i+1;
          }
+      }
       return Const.noOpponent;
    }
 
@@ -100,15 +102,8 @@ class HeuristicPlayer extends Player {
            - ((opDist != 0) ? (1.0/opDist  * Const.opponentFactor) : 0); 
    }
 
-   /**
+   // Must return a new move always
-    * Selects the best possible move to return
+   int getNextMove(int currentPos) {
-    * @param   currentPos  Player's current position to the board
-    * @return  The move array
-    *
-    * @note
-    *    This function always return a new move.
-    */
-   int[] getNextMove(int currentPos) {
       Range dirs        = new Range(DirRange.Begin, DirRange.End, DirRange.Step);
       int N             = dirs.size();
       double[] eval     = new double[N];
@@ -132,8 +127,7 @@ class HeuristicPlayer extends Player {
          dir = directionOfMax (eval, eval_dir, N);
       }
       Position new_pos = new Position( Position.toRow(currentPos), Position.toCol(currentPos), dir );
-      int [] ret = {new_pos.getId(), new_pos.getRow(), new_pos.getCol(), dir};
+      return new_pos.getId();
-      return ret;
    }
 
    /**
@@ -150,36 +144,37 @@ class HeuristicPlayer extends Player {
     * <li> int[0]: The tileId of the final player's position.
     * <li> int[1]: The row of the final player's position.
     * <li> int[2]: The column of the final player's position.
-    * <li> int[3]: The dice/direction of the move.
+    * <li> int[3]: The supplyId in case player picked one (Const.noSupply otherwise).   
     * </ul>
     */
    @Override
    int[] move(int id) {
       // Initialize return array with the current data
-      int[] ret = getNextMove(id);
+      int[] ret = new int[Const.moveItems];
-      y = Position.toRow(ret[MOVE_TILE_ID]);
+      ret[0] = getNextMove(id);
-      x = Position.toCol(ret[MOVE_TILE_ID]);
+      ret[1] = y = Position.toRow(ret[0]);
-
+      ret[2] = x = Position.toCol(ret[0]);
       int supplyFlag =0, moveFlag =1;
       // In case of a champion player, try also to pick a supply
-      if (champion && (board.tryPickSupply(ret[MOVE_TILE_ID]) != Const.noSupply)) {
+      if (champion && (ret[3] = board.tryPickSupply(ret[0])) != Const.noSupply) {
          ++score;                               // keep score
          ++supplyFlag;
       }
-      ++dirCounter[ret[MOVE_DICE]];             // update direction counters
+      int dir = Direction.get(id, ret[0]);      // update direction counters
+      ++dirCounter[dir];
       board.updateMove(ret, playerId);
 
       // Update supply and opponent distance
       int smin =DirRange.End, omin =DirRange.End;
       for (int d = DirRange.Begin ; d<DirRange.End ; d += DirRange.Step) {
-         int s = supplyInDirection (ret[MOVE_TILE_ID], d);
+         int s = supplyInDirection (ret[0], d);
-         int o = opponetInDirection(ret[MOVE_TILE_ID], d);
+         int o = opponetInDirection(ret[0], d);
          if (s >= 0 && s < smin)  smin = s;
          if (o >= 0 && o < omin)  omin = o;
       }
       // update path
       Integer[] p = {
-            ret[MOVE_TILE_ID], ret[MOVE_DICE], moveFlag, supplyFlag,
+            ret[0], dir, moveFlag, supplyFlag,
             dirCounter[Direction.UP], dirCounter[Direction.RIGHT], dirCounter[Direction.DOWN], dirCounter[Direction.LEFT],
             (smin != DirRange.End)? smin:Const.noSupply, (omin != DirRange.End)? omin:Const.noOpponent
       };
@@ -202,10 +197,10 @@ class HeuristicPlayer extends Player {
          else
             System.out.println("");
          // extra prints for heuristic
-         if (last[8] != Const.noSupply)   System.out.println("              supply   =" + last[8]);
+         if (last[8] != Const.noSupply)   System.out.println("            supply distance   =" + last[8]);
-         else                             System.out.println("              supply   = blind");
+         else                             System.out.println("            supply distance   = blind");
-         if (last[9] != Const.noOpponent) System.out.println("              opponent =" + last[9]);
+         if (last[9] != Const.noOpponent) System.out.println("            opponent distance =" + last[9]);
-         else                             System.out.println("              opponent = blind");
+         else                             System.out.println("            opponent distance = blind");
       }
    }
    

src/host/labyrinth/MinMaxPlayer.java

@@ -1,388 +0,0 @@
-/**
- * @file MinMaxPlayer.java
- *
- * @author
- *    Anastasia Foti AEM:8959
- *    <anastaskf@ece.auth.gr>
- *
- * @author
- *    Christos Choutouridis AEM:8997
- *    <cchoutou@ece.auth.gr>
- */
-
-package host.labyrinth;
-
-/**
- * @brief
- *    This class represents the game's minimax player.
- */
-class MinMaxPlayer extends Player {
-
-   /** @name Constructors */
-   /** @{ */
-
-   /**
-    * Create a new player and put him at the row-column coordinates 
-    * @param name       The name of the player
-    * @param champion   Flag to indicate if a player is a `champion`
-    * @param board      Reference to the board of the game
-    * @param row        The row coordinate of initial player position
-    * @param column     The column coordinate of initial player's position
-    */
-   public MinMaxPlayer(String name, boolean champion, Board board, int row, int column) throws Exception {
-      super(name, champion, board, row, column);
-   }
-
-   /**
-    * Create a new player and put him at the row-column coordinates 
-    * @param name       The name of the player
-    * @param champion   Flag to indicate if a player is a `champion`
-    * @param board      Reference to the board of the game
-    * @param tileId     The tileId coordinate of player's initial position
-    */
-   public MinMaxPlayer(String name, boolean champion, Board board, int tileId) throws Exception {
-      super(name, champion, board, tileId);
-   }
-   /** @} */
-   /** @name Board's main application interface */
-   /** @{ */
-   
-   /**
-    * Utility to get the distance of a possible supply in some direction
-    * @param currentPos    The current position of the player
-    * @param direction     The direction to check
-    * @param board         Reference to the Board object to use
-    *
-    * @return           The distance or Const.noView
-    */
-   int supplyInDirection(int currentPos, int direction, Board board) {
-      Position pos = new Position(Position.toRow(currentPos), Position.toCol(currentPos));
-
-      for (int i=0 ; i<=Const.viewDistance ; ++i) {
-         if (board.hasSupply(pos.getId()))
-            return i;
-         if (board.isWalkable(pos.getId(), direction))
-            pos = new Position(pos.getRow(), pos.getCol(), direction);
-         else
-            break;
-      } 
-      return Const.noView;
-   }
-
-   /**
-    * Utility to get the distance of a possible opponent in some direction
-    * @param currentPos    The current position of the player
-    * @param direction     The direction to check
-    * @param board         Reference to the Board object to use
-    *
-    * @return           The distance or Const.noView
-    */
-   int opponetInDirection(int currentPos, int direction, Board board) {
-      Position pos = new Position(Position.toRow(currentPos), Position.toCol(currentPos));
-      int[] opp = board.getOpponentMove(playerId);
-
-      for (int i=0 ; i<=Const.viewDistance ; ++i) {
-         if (opp[MOVE_TILE_ID] == pos.getId())
-            return i;
-         if (board.isWalkable(pos.getId(), direction))
-            pos = new Position(pos.getRow(), pos.getCol(), direction);
-         else
-            break;
-      }
-      return Const.noView;
-   }
-
-   /**
-    * This is the main move evaluation function.
-    *
-    * @param currentPos    The current position of the player (before the move to evaluate)
-    * @param direction     The direction (a.k.a. the move) to evaluate
-    * @param board         Reference to the Board object to use
-    * @return              A signed real number. The higher the output, the higher the evaluation.
-    */
-   double evaluate (int currentPos, int direction, Board board) {
-      Position next   = new Position (Position.toRow(currentPos), Position.toCol(currentPos), direction);
-
-      int preOpDist   = opponetInDirection (currentPos, direction, board);
-      int preSupDist  = supplyInDirection(currentPos, direction, board);
-      int postOpDist  = opponetInDirection (next.getId(), direction, board);
-      int postSupDist = supplyInDirection(next.getId(), direction, board);
-
-      return ((preSupDist != Const.noView) ? Const.preMoveFactor *(1.0/(preSupDist+1) * Const.supplyFactor) : 0)
-           - ((preOpDist != Const.noView)  ? Const.preMoveFactor *(1.0/(preOpDist+1)  * Const.opponentFactor) : 0) 
-           + ((postSupDist != Const.noView)? Const.postMoveFactor*(1.0/(preSupDist+1) * Const.supplyFactor) : 0)
-           - ((postOpDist != Const.noView) ? Const.postMoveFactor*(1.0/(preOpDist+1)  * Const.opponentFactor) : 0);
-   }
-
-   /**
-    * Executes the minimax algorithm and return a reference to selected move
-    * @param node    The root node to start
-    * @return        Reference to the selected move
-    */
-   Node chooseMinMaxMove(Node node) {
-      node.setNodeEvaluation(maxValue(node));
-      return node.getPath();
-   }
-
-   /**
-    * Selects the best possible move to return
-    * @param   currentPos  Player's current position to the board
-    * @return  The move array
-    *
-    * @note
-    *    This function always return a new move.
-    */
-   int[] getNextMove(int currentPos) {
-      Node root  = new Node (board);
-      int [] opp = board.getOpponentMove(playerId);
-
-      createMySubtree(currentPos, opp[MOVE_TILE_ID], root, root.getNodeDepth()+1);
-
-      return chooseMinMaxMove(root).getNodeMove();
-   }
-
-   /**
-    * MinMaxPlayer's move.
-    *
-    * A player of this kind cheats. He does not throw a dice to get a direction. In contrary he
-    * calculates his next move very carefully.
-    * If the player is a champion then he also picks up a possible supply from the tile.
-    *
-    * @param id   The id of the starting tile.
-    * @return     An array containing player's final position and possible supply of that position.
-    *             The array format is:
-    * <ul>
-    * <li> int[0]: The tileId of the final player's position.
-    * <li> int[1]: The row of the final player's position.
-    * <li> int[2]: The column of the final player's position.
-    * <li> int[3]: The dice/direction of the move.
-    * </ul>
-    */
-   @Override
-   int[] move(int id) {
-      // Initialize return array with the current data
-      int[] ret = getNextMove(id);
-      y = Position.toRow(ret[MOVE_TILE_ID]);
-      x = Position.toCol(ret[MOVE_TILE_ID]);
-
-      int supplyFlag =0, moveFlag =1;
-      // In case of a champion player, try also to pick a supply
-      if (champion && (board.tryPickSupply(ret[MOVE_TILE_ID]) != Const.noSupply)) {
-         ++score;                               // keep score
-         ++supplyFlag;
-      }
-      ++dirCounter[ret[MOVE_DICE]];             // update direction counters
-      board.updateMove(ret, playerId);
-
-      // Update supply and opponent distance
-      int smin =Const.noView, omin =Const.noView;
-      for (int d = DirRange.Begin ; d<DirRange.End ; d += DirRange.Step) {
-         int s = supplyInDirection (ret[MOVE_TILE_ID], d, board);
-         int o = opponetInDirection(ret[MOVE_TILE_ID], d, board);
-         if (s < smin)  smin = s;
-         if (o < omin)  omin = o;
-      }
-      // update path
-      Integer[] p = {
-            ret[MOVE_TILE_ID], ret[MOVE_DICE], moveFlag, supplyFlag,
-            dirCounter[Direction.UP], dirCounter[Direction.RIGHT], dirCounter[Direction.DOWN], dirCounter[Direction.LEFT],
-            smin, omin
-      };
-      path.add(p);
-      return ret;
-   }
-
-   /**
-    * Prints round information for the player
-    */
-   void statistics() {
-      if (!path.isEmpty()) {
-         Integer[] last = path.get(path.size()-1);
-         String who = String.format("%12s", name);
-         System.out.print(who + ": score[" + score + "]" + ", dice =" + last[1] + ", tileId =" + last[0] + " (" + Position.toRow(last[0]) + ", " + Position.toCol(last[0]) + ")");
-         if (last[2] == 0)
-            System.out.println(" *Can not move.");
-         else if (last[3] != 0)
-            System.out.println(" *Found a supply.");
-         else
-            System.out.println("");
-         // extra prints for minimax player
-         if (last[8] != Const.noView) System.out.println("              supply   =" + last[8]);
-         else                         System.out.println("              supply   = blind");
-         if (last[9] != Const.noView) System.out.println("              opponent =" + last[9]);
-         else                         System.out.println("              opponent = blind");
-      }
-   }
-   
-   /**
-    * Prints final statistics for the player
-    */
-   void final_statistics () {
-      String who = String.format("%12s", name);
-      System.out.println();
-      System.out.println(who + ": score[" + score + "]");
-      System.out.println("    Moves up: " + dirCounter[Direction.UP]);
-      System.out.println(" Moves right: " + dirCounter[Direction.RIGHT]);
-      System.out.println("  Moves down: " + dirCounter[Direction.DOWN]);
-      System.out.println("  Moves left: " + dirCounter[Direction.LEFT]);
-   }
-
-   /** @} */
-
-   /** @name Minimax algorithm related part */
-   /** @{ */
-
-   /**
-    * Get the previous direction of the player
-    * @param   parent   Reference to previous nNode
-    * @return  The previous direction if exist, else return Direction.NONE
-    */
-   private int prevDirection(Node parent) {
-      if (parent != null && parent.getParent() != null)
-         return parent.getParent().getNodeMove()[MOVE_DICE];
-      return Direction.NONE;
-   }
-
-   /**
-    * A simulated move in a copy of the bard.
-    *
-    * @param board         The board on witch we simulate the move
-    * @param currentPos    The current position of the player to the @c board
-    * @param dir           The direction of the move
-    * @param champion      Flag to indicate if the player is champion or not
-    * @return              The move array
-    */
-   private int[] dryMove (Board board, int currentPos, int dir, boolean champion) {
-      int[] ret = new int[MOVE_DATA_SIZE];
-      Position p = new Position(Position.toRow(currentPos), Position.toCol(currentPos), dir);
-      ret[MOVE_TILE_ID] = p.getId();
-      ret[MOVE_ROW]     = p.getRow();
-      ret[MOVE_COLUMN]  = p.getCol();
-      ret[MOVE_DICE]    = dir; 
-
-      board.updateMove(ret, (champion) ? playerId : board.getOpponentId(playerId));
-      return ret;
-   }
-
-   /**
-    * One of the 2 recursive functions for creating the minimax tree. This one 
-    * creates children for the MinMax player.
-    *
-    * @param parent        The parent Node
-    * @param depth         The current depth for the children
-    * @param currentPos    The tile of MinMax player
-    * @param oppCurrentPos The tile of the opponent
-    *
-    * @note
-    *    Even though unnecessary we calculate the evaluation for every node and not only for the leafs.
-    *    This follows the exercise instructions. We could also rely on lazy evaluation of "evaluation()"
-    *    and use AB pruning but the depth of the tree is not worth the try.
-    */
-   private void createMySubtree (int currentPos, int oppCurrentPos, Node parent, int depth) {
-      ShuffledRange dirs = new ShuffledRange(DirRange.Begin, DirRange.End, DirRange.Step);
-      int [] nodeMove;
-      
-      for (int dir = dirs.get() ; dir != Const.EOR ; dir = dirs.get()) {
-         if ((dir != Direction.opposite(prevDirection(parent)))
-          && parent.getNodeBoard().isWalkable(currentPos, dir)) {
-            Board nodeBoard = new Board (parent.getNodeBoard());     // clone board
-            double eval = evaluate (currentPos, dir, nodeBoard);     // evaluate the move
-            nodeMove = dryMove (nodeBoard, currentPos, dir, true);   // simulate the move
-            // make child Node
-            Node child = new Node (parent, depth, nodeMove, nodeBoard, eval);
-            parent.addChild(child);                                  // add child to tree
-            createOppSubtree (nodeMove[MOVE_TILE_ID], oppCurrentPos, child, depth+1);
-         }
-      }
-   }
-
-   /**
-    * One of the 2 recursive functions for creating the minimax tree. This one 
-    * creates children for the opponent player.
-    *
-    * @param parent        The parent Node
-    * @param depth         The current depth for the children
-    * @param currentPos    The tile of MinMax player
-    * @param oppCurrentPos The tile of the opponent
-    *
-    * @note
-    *    Even though unnecessary we calculate the evaluation for every node and not only for the leafs.
-    *    This follows the exercise instructions. We could also rely on lazy evaluation of "evaluation()"
-    *    and use AB pruning but the depth of the tree is not worth the try.
-    */
-   private void createOppSubtree (int currentPos, int oppCurrentPos, Node parent, int depth) {
-      ShuffledRange dirs = new ShuffledRange(DirRange.Begin, DirRange.End, DirRange.Step);
-      int [] nodeMove;
-      
-      for (int dir = dirs.get() ; dir != Const.EOR ; dir = dirs.get()) {
-         if ((dir != Direction.opposite(prevDirection(parent)))
-               && parent.getNodeBoard().isWalkable(oppCurrentPos, dir)) {
-            Board nodeBoard = new Board(parent.getNodeBoard());         // clone board
-            nodeMove = dryMove (nodeBoard, oppCurrentPos, dir, false);  // simulate move
-            Position init = new Position(                               // evaluate from "My" perspective the move
-                  parent.getNodeMove()[MOVE_ROW],
-                  parent.getNodeMove()[MOVE_COLUMN],
-                  Direction.opposite(parent.getNodeMove()[MOVE_DICE])
-            );
-            double eval = evaluate(init.getId(), parent.getNodeMove()[MOVE_DICE], nodeBoard);
-            // make child Node
-            Node child = new Node (parent, depth, nodeMove, nodeBoard, eval);
-            parent.addChild(child);                                     // add child to tree
-            if (depth < Const.minimaxTreeDepth) {
-               createMySubtree (currentPos, nodeMove[MOVE_TILE_ID], child, depth+1);
-            }
-         }
-      }
-   }
-   
-   /**
-    * The Minimax recursive function for the maximizing part.
-    *
-    * @param node The current Node
-    * @return     The selected Node
-    */
-   private double maxValue (Node node) {
-      if (node.getChildren() == null) {
-         //node.setPath(node);
-         return node.getNodeEvaluation();
-      }
-      else {
-         double M = Double.NEGATIVE_INFINITY;
-         for (Node n : node.getChildren()) {
-            n.setNodeEvaluation(minValue(n));   // evaluation propagation
-            if (M < n.getNodeEvaluation()) {
-               M = n.getNodeEvaluation();
-               node.setPath(n);                 // path propagation
-            }
-         }
-         return M;
-      }
-   }
-   
-   /**
-    * The Minimax recursive function for the minimizing part.
-    *
-    * @param node The current Node
-    * @return     The selected Node
-    */
-   private double minValue (Node node) {
-      if (node.getChildren() == null) {
-         //node.setPath(node);
-         return node.getNodeEvaluation();
-      }
-      else {
-         double m = Double.POSITIVE_INFINITY;
-         for (Node n : node.getChildren()) {
-            n.setNodeEvaluation(maxValue(n));   // evaluation propagation
-            if (m > n.getNodeEvaluation()) {
-               m = n.getNodeEvaluation();
-               node.setPath(n);                 // path propagation
-            }
-         }
-         return m;
-      }
-   }
-
-   /** @} */
-   
-}

src/host/labyrinth/Node.java

@@ -1,119 +0,0 @@
-/**
- * @file Node.java
- *
- * @author
- *    Anastasia Foti AEM:8959
- *    <anastaskf@ece.auth.gr>
- *
- * @author
- *    Christos Choutouridis AEM:8997
- *    <cchoutou@ece.auth.gr>
- */
-
-package host.labyrinth;
-
-import java.util.ArrayList;
-
-/**
- * Node object for minimax tree.
- */
-class Node {
-
-   /** @name Constructors */
-   /** @{ */
-   /** Null initialize constructor */
-   Node () { }
-   /** The main constructor for the Node */
-   Node (Node parent, int nodeDepth, int [] nodeMove, Board nodeBoard, double nodeEvaluation) {
-      this.parent          = parent;
-      this.children        = null;
-      this.nodeDepth       = nodeDepth;
-      this.nodeMove        = nodeMove;
-      this.nodeBoard       = nodeBoard;
-      this.nodeEvaluation  = nodeEvaluation;
-      this.path            = null;
-   }
-   /** A special constructor for creating a root Node */
-   Node (Board nodeBoard) {
-      this.parent          = null;
-      this.children        = null;
-      this.nodeDepth       = 0;
-      this.nodeMove        = new int [4];
-      this.nodeBoard       = nodeBoard;
-      this.nodeEvaluation  = 0;
-      this.path            = null;
-   }
-   /**@} */
-   
-   /** @name Get/Set interface */
-   /** @{ */
-   /** Get parent */
-   Node getParent()           { return parent; }
-   /** get children */
-   ArrayList<Node>
-      getChildren()           { return children; }
-   /** get nodeDepth */
-   int getNodeDepth()         { return nodeDepth; }
-   /** get nodeMove */
-   int[] getNodeMove()        { return nodeMove; }
-   /** get nodeBoard */
-   Board getNodeBoard()       { return nodeBoard; }
-   /** get nodeEvluation */
-   double getNodeEvaluation (){ return nodeEvaluation; }
-   /** get path */
-   Node getPath()             { return path; }
-
-   /** set parent */
-   void setParent(Node parent) { this.parent = parent; }
-   /** set children */
-   void setChildren(ArrayList<Node> children) {
-      this.children = children;
-   }
-   /** set nodeDepth */
-   void setNodeDepth(int nodeDepth) {
-      this.nodeDepth = nodeDepth;
-   }
-   /** set nodeMove */
-   void setNodeMove(int[] nodeMove) {
-      this.nodeMove = nodeMove;
-   }
-   /** set nodeBoard */
-   void setNodeBoard(Board nodeBoard) {
-      this.nodeBoard = nodeBoard;
-   }
-   /** set nodeEvaluation */
-   void setNodeEvaluation(double nodeEvaluation) {
-      this.nodeEvaluation = nodeEvaluation;
-   }
-   /** set path */
-   void setPath (Node path) {
-      this.path = path;
-   }
-
-   /**@}*/
-
-   /** @name Public API */
-   /** @{ */
-   /**
-    * Add a child to the tree
-    * @param   child   The child to add
-    * @return  the status of the operation
-    */
-   boolean addChild (Node child) {
-      if (children == null)
-         children = new ArrayList<>();
-      return children.add(child);
-   }
-   /**@}*/
-
-   /** @name Data members */
-   /** @{ */
-   private Node            parent;     /**< Back reference to parent Node */
-   private ArrayList<Node> children;   /**< Fwd reference to leaf Nodes */
-   private int             nodeDepth;  /**< The Node's depth */
-   private int[]           nodeMove;   /**< The Node's move data [tile, initTile, points, roll]*/
-   private Board           nodeBoard;  /**< Reference to Board's copy of the current node*/
-   private double          nodeEvaluation; /**< The Node's evaluation result */
-   private Node            path;       /**< The minimax evaluation path */
-   /**@}*/
-}

src/host/labyrinth/Player.java

@@ -19,13 +19,6 @@ import java.util.ArrayList;
  *    This class represents the game's player
  */
 class Player {
-   /** Helper variables to keep track of the move() return values @see move() */
-   static final int MOVE_DATA_SIZE        = 4;  /**< The move return data array size */
-   static final int MOVE_TILE_ID          = 0;  /**< Index of the tileId information of the move */
-   static final int MOVE_ROW              = 1;  /**< The index of row information */
-   static final int MOVE_COLUMN           = 2;  /**< The index of column information */
-   static final int MOVE_DICE             = 3;  /**< The index of dice information */
-
    /** @name Constructors */
    /** @{ */
 
@@ -37,7 +30,7 @@ class Player {
     * @param row        The row coordinate of initial player position
     * @param column     The column coordinate of initial player's position
     */
-   Player(String name, boolean champion, Board board, int row, int column) throws Exception {
+   Player(String name, boolean champion, Board board, int row, int column) {
       this.playerId  = board.generatePlayerId();
       this.name      = name;
       this.board     = board;
@@ -45,7 +38,7 @@ class Player {
       this.x         = column;
       this.y         = row;
       this.champion  = champion;
-      this.dirCounter= new int[DirRange.End];      // yes we spoil some memory. Java is the worst.
+      this.dirCounter= new int[DirRange.End];      // yes we spoil some memory. Java is worst.
       this.path      = new ArrayList<Integer[]>();
       int[] m        = {
             Position.toID(row, column), row, column, Const.noSupply
@@ -60,7 +53,7 @@ class Player {
     * @param board      Reference to the board of the game
     * @param tileId     The tileId coordinate of player's initial position
     */
-   Player(String name, boolean champion, Board board, int tileId) throws Exception {
+   Player(String name, boolean champion, Board board, int tileId) {
       this.playerId  = board.generatePlayerId();
       this.name      = name;
       this.board     = board;
@@ -68,7 +61,7 @@ class Player {
       this.x         = Position.toCol(tileId);
       this.y         = Position.toRow(tileId);
       this.champion  = champion;
-      this.dirCounter= new int[DirRange.End];      // yes we spoil some memory. Java is the worst.
+      this.dirCounter= new int[DirRange.End];      // yes we spoil some memory. Java is worst.
       this.path      = new ArrayList<Integer[]>();
       int[] m        = {
             tileId, Position.toRow(tileId), Position.toCol(tileId), Const.noSupply
@@ -94,39 +87,37 @@ class Player {
     * <li> int[0]: The tileId of the final player's position.
     * <li> int[1]: The row of the final player's position.
     * <li> int[2]: The column of the final player's position.
-    * <li> int[3]: The dice/direction of the move.
+    * <li> int[1]: The supplyId in case player picked one (Const.noSupply otherwise).   
     * </ul>
     */
    int[] move(int id) {
       // Initialize return array with the current data
-      int[] ret = new int[MOVE_DATA_SIZE];
+      int[] ret = new int[Const.moveItems];
-      ret[MOVE_TILE_ID]    = id;
+      ret[0] = id;
-      ret[MOVE_ROW]        = Position.toRow(id);
+      ret[1] = Position.toRow(id);
-      ret[MOVE_COLUMN]     = Position.toCol(id);
+      ret[2] = Position.toCol(id);
-      ret[MOVE_DICE]       = Direction.NONE;
+      ret[3] = Const.noSupply;
       int supplyFlag =0, moveFlag =0;
 
-      int diceDirection;
+      int diceDirection = board.dice();            // throw the dice
-      do
+      if (board.isWalkable(id, diceDirection)) {   // The result is walkable
-         diceDirection = board.dice();          // throw the dice
-      while (!board.isWalkable(id, diceDirection));
          moveFlag =1;                              // mark the successful move
          // Get next tile
          Position next = new Position(Position.toRow(id), Position.toCol(id), diceDirection);
-      ret[MOVE_TILE_ID] = next.getId();         // Update move's return data
+         ret[0] = next.getId();                    // Update player's and return data
-      ret[MOVE_ROW]     = y = next.getRow();
+         ret[1] = y = next.getRow();
-      ret[MOVE_COLUMN]  = x = next.getCol();
+         ret[2] = x = next.getCol();
-      ret[MOVE_DICE]    = diceDirection;
          // In case of a champion player, try also to pick a supply
-      if (champion && (board.tryPickSupply(next.getId()) != Const.noSupply)) {
+         if (champion && (ret[3] = board.tryPickSupply(next.getId())) != Const.noSupply) {
             supplyFlag =1;                         // mark the successful supply pickup
             ++score;                               // keep score
          }
          ++dirCounter[diceDirection];              // update direction counters
          board.updateMove(ret, playerId);
+      }
       // update path
       Integer[] p = {
-            ret[MOVE_TILE_ID], diceDirection, moveFlag, supplyFlag,
+            ret[0], diceDirection, moveFlag, supplyFlag,
             dirCounter[Direction.UP], dirCounter[Direction.RIGHT], dirCounter[Direction.DOWN], dirCounter[Direction.LEFT],
             Const.noSupply, Const.noOpponent
       };
@@ -204,11 +195,11 @@ class Player {
    void setChampion (boolean champion) {
       this.champion = champion;
    }
-   void setDirCounter(int[] dirCounter) {
+   public void setDirCounter(int[] dirCounter) {
       this.dirCounter = dirCounter;
    }
 
-   void setPath(ArrayList<Integer[]> path) {
+   public void setPath(ArrayList<Integer[]> path) {
       this.path = path;
    }
    /** @} */