[Δομές Δεδομένων] Τουρνουά Blokus - αλγόριθμοι

[Thmmy.gr portal]

  Thmmy.gr portal
   Forum
   Downloads
   Ενεργ. Λογαριασμού
   Επικοινωνία
  
  Χρήσιμα links
   Σελίδα τμήματος
   Βιβλιοθήκη Τμήματος
   Elearning
   Φοιτητικά fora
   Πρόγραμμα Λέσχης
   Πρακτική Άσκηση
   Ηλεκτρονική Εξυπηρέτηση Φοιτητών
   Διανομή Συγγραμμάτων
   Ψηφιακό Καταθετήριο Διπλωματικών
   Πληροφορίες Καθηγητών
   Instagram @thmmy.gr
   mTHMMY
  
  Φοιτητικές Ομάδες
   ACM
   Aristurtle
   ART
   ASAT
   BEAM
   BEST Thessaloniki
   EESTEC LC Thessaloniki
   EΜΒ Auth
   IAESTE Thessaloniki
   IEEE φοιτητικό παράρτημα ΑΠΘ
   SpaceDot
   VROOM
   Panther
  

THMMY.gr Web

Helios_MultiScribbles2SMF Default ThemeSMFone_Blue

[Ανεβάζετε τα θέματα των εξετάσεων στον τομέα Downloads]

Είσαι πρωτοετής;... Καλώς ήρθες! Μπορείς να βρεις πληροφορίες εδώ. Βοήθεια για τους καινούργιους μέσω χάρτη.

Κατεβάστε εδώ το Android Application για εύκολη πρόσβαση στο forum.

Ανεβάζετε τα θέματα των εξετάσεων στον τομέα Downloads με προσοχή στα ονόματα των αρχείων!

Για ανανέωση (ή προσθήκη νέου) avatar, πρέπει η μεγαλύτερη διάσταση της εικόνας να είναι 110 pixels.

[SolidSNK]

Απ' όσο βλέπω οι περισσότεροι αρκεστήκατε στη διαφορά γωνιών δλδ.

[BLV]

Ομάδα Β3 (Ομάδα 8)
Πλατή Παρασκευή
Χατζοπούλου Γεωργία

Έχουμε δημιουργήσει ένα πρόγραμμα στο οποίο ακολουθούμε την παρακάτω στρατηγική:
Αρχικά,από τα κομμάτια που έχουμε στη διάθεση μας και ξεκινώντας από αυτό με τον μεγαλύτερο αριθμό τετραγώνων βρίσκουμε τις πιθανές κινήσεις του παίκτη μας.Στην περίπτωση όμως, που για το συγκεκριμένο κομμάτι δεν υπάρχουν κινήσεις δοκιμάζουμε το αμέσως επόμενο.Στόχος μας είναι να "ξεφορτωθούμε" όσο το δυνατόν νωρίτερα τα μεγάλα κομμάτια.Εφόσον έχουμε βρει το κομμάτι που θέλουμε να τοποθετήσουμε καθώς και όλες τις διαθέσιμες κινήσεις του παίκτη καλούμε μία συνάρτηση minimax.
H συνάρτηση αυτή επιστρέφει τον αριθμό της καλύτερης δυνατής θέσης, ώστε  να εχουμε τη λιγότερη δυνατή ζημιά. Πιο συγκεκριμένα η minimax τοποθετεί το κομμάτι σ' ένα εικονικό ταμπλό και κατόπιν ακολουθεί την ίδια διαδικασία για τις πιθανες κινήσεις του αντιπάλου.Κρίνεται αναγκαίο να επισημανθεί ότι η minimax κοιτάει τρεις κινήσεις:μία για εμάς, μία για τον αντίπαλό μας και μία ακόμη για εμάς (βάθος 3). Για την υλοποίηση της  χρησιμοποιήσαμε άλλες τρεις συναρτήσεις:
την putpiece,την  possiblemoves και την nextcolor.
Η nextcolor δέχεται το χρώμα του παίκτη που παίζει και επιστρέφει το χρώμα του επόμενου παίκτη.
Η putpiece δέχεται ένα ταμπλό, το χρώμα του παίκτη που παίζει, το σχήμα του κομματιού και τη θέση. Με δύο for σαρώνουμε το κομμάτι και το τοποθετούμε χρωματίζοντας  το ταμπλό με το χρώμα του παίκτη που παίζει.
Η possiblemoves δέχεται ένα ταμπλό και το χρώμα του κομματιού και επιστρέφει έναν αντικείμενο places με τις πιθανές κινήσεις του παίκτη που παίζει. Δημιουργούμε ένα αντικείμενο κομμάτια το οποίο περιέχει τα κομμάτια που έχουν απομείνει για τον  παίκτη που παίζει. Αν είναι άδεια τότε επιστρέφει ένα άδειο αντικείμενο. Ενώ αν δεν είναι άδεια τότε δημιουργεί ένα αντικείμενο τύπου piece και βρίσκει την πιθανή κίνηση με τη βοήθεια των συναρτήσεων scanTheBoard και findWhereItFits , για το μεγαλύτερο κομμάτι. Αν δεν υπάρχει πιθανή θέση για το μεγαλύτερο κομμάτι, τότε παίρνει το αμέσως επόμενο.
Στο τέλος του βάθους της minimax αξιολογούνται οι κινήσεις με την evaluate.Η evaluate είναι αυτή που δινόταν απο την εκφώνηση της άσκησης. Η evaluate λαμβάνει ένα ταμπλό και επιστρέφει τον αριθμό των ελεύθερων γωνιών του παίκτη μας - τον αριθμό των ελεύθερων γωνιών του αντιπάλου μας.Όταν, λοιπόν, καλούμε την evaluate αυτη επιστρέφει έναν αριθμό ο οποίος αξιολογεί την κίνηση. Όσο μεγαλύτερος είναι αυτός ο αριθμός τόσο καλύτερη θεωρείται η κίνηση.

 τέλος

[Matzika]

αλλα πιστευω καταλαβαμε ολοι απο τον κοσμο στο τουρνουα γιατι πολλες ομαδες ειχαν ενα μονο εκπροσωπο- μαλον θα εκανε αυτος  την περισσοτερη δουλεια ; )

τώρα θίχτηκα
δεν ξέρω τι συμβαίνει γενικά αλλα εγώ που δεν ήμουν στο τουρνουα σε πληροφορώ ότι έριξα περισσότερη δουλειά απο την κοπέλα που ήμασταν μαζί στην ομάδα...ελπίζω όσοι λείπαμε να μη δώσαμε αυτή την εντύπωση στους διδάσκοντες...
Η απουσία μου οφειλόταν:
1)Στο γεγονός ότι η συμμετοχή μας στο τουρνουά αποφασίστηκε περίπου 1 ώρα πριν τη διεξαγωγή του καθώς δεν είχαμε φτιάξει έξτρα κώδικα αλλα ρισκάραμε αυτόν της τρίτης εργασίας
2)Εδινα 2 εργαστήρια +2 εργασίες εκεινη την βδομάδα και τη Δευτέρα έγραφα οπότε όπως καταλαβαίνεις δεν είχα και πολυτέλεια χρόνου...

[ThemisMP]

ΟΜΑΔΑ Α3 (6354_6466)
Διαμαντόπουλος Θεμιστοκλής
Τακούδης Χρήστος

Φτιάξαμε έναν παίκτη που αρχικά υπολόγιζε και αποθήκευε σε μια δομή τύπου MySet0 όλες τις δυνατές κινήσεις του παίκτη για το τελευταίο κομμάτι. Εν συνεχεία, καλούσε τη συνάρτηση Minimax η οποία επέλεγε ποιο κομμάτι θα τοποθετηθεί, όπως θα εξηγηθεί παρακάτω.

Η Συνάρτηση Minimax:
Έπαιζε κάθε δυνατή κίνηση του παίκτη μας σε ένα εικονικό ταμπλό. Κατόπιν ξανακαλούσε τον εαυτό της οπότε και έπαιζε τις κινήσεις του αντιπάλου. Έκανε την παραπάνω διαδικασία για 2 δικές μας κινήσεις και δύο του αντιπάλου, είχε δηλαδή βάθος 4. Χρησιμοποιούσε το κλάδεμα άλφα-βήτα, κάτι που περιόριζε σημαντικά το χρόνο εκτέλεσης. Μετά το τέλος της τελευταίας κίνησης, καλούσε την evaluate με την οποία αξιολογούσε το ταμπλό.

Η Συνάρτηση Evaluate
Δεχόταν ως όρισμα ένα ταμπλό και επέστρεφε τη διαφορά των πιθανών γωνιών μας μείον τις γωνίες του αντιπάλου. Εκτός αυτού είχε κώδικα ο οποίος τσέκαρε ποιο κομμάτι του παίκτη μας παίζεται (με το this.getInventory()) και εάν ήταν από την 3η εώς την 6η κίνηση έστελνε μια πολύ θετική αξιολόγηση για τα τοποθετημένα στο κέντρο κομμάτια.

Χρησιμοποιήσαμε και δύο ακόμα συναρτήσεις, που είχαν καθαρά βοηθητικό ρόλο. Είχαμε μια συνάρτηση που δεχόταν ως ορίσματα ποιος παίζει και το ταμπλό και επέστρεφε τις πιθανές κινήσεις του. Ακόμα, μία συνάρτηση που δεχόταν ένα χρώμα και έδινε το επόμενο (προφανώς για το ποιός παίζει μετά). Τέλος, μια συνάρτηση που τοποθετούσε το κομμάτι στο εικονικό ταμπλό.

Ως γενικότερο σχόλιο, το τουρνουά ήταν καλή φάση, και θα άξιζε να υπήρχε μεγαλύτερη προσέλευση!!!

[manos88]

ΟΜΑΔΑ 22(δηλώσεων)

Πλατανάκης Εμμανουήλ(6442)
Ναί Νικόλαος(6417)


Βήμα 1:

Σκανάρεται το inventory του computer-player από το τέλος προς την αρχή μέχρις ότου βρεθεί
ένα κομμάτι για το οποίο ο παίκτης έχει διαθέσιμη κίνηση. Μόλις βρεθεί αυτό το κομμάτι
προσμετράται ο αριθμός των χρωματισμένων τετραγώνων του .Στη συνέχεια βρίσκουμε και
τα άλλα κομμάτια που έχουν τον ίδιο αριθμό χρωματισμένων τετραγώνων και που έχουν
βέβαια έγκυρη κίνηση.


Βήμα 2:

Για κάθε έγκυρο κομμάτι που βρίσκουμε με την παραπάνω μεθοδολογία δημιουργούμε ένα
virtual δέντρο. Το virtual αυτό δέντρο υλοποιείται με τη βοήθεια της αναδρομής. Δηλαδή
τοποθετείται το συγκεκριμένο κομμάτι σε ένα κλώνο του board και για τον κλώνο αυτό
βρίσκονται όλες οι έγκυρες κινήσεις του αντιπάλου. Τώρα κάθε κίνηση του αντιπάλου
τοποθετείται στον αρχικό κλώνο και η μελέτη συνεχίζει για καθένα από τα board που
προκύπτουν ανάλογα με την κίνηση του αντιπάλου. Και ούτω κάθε εξής μέχρις ότου φτάσω
στο επιθυμητό βάθος.


Βήμα 3:

Μόλις γίνει αυτό εφαρμόζουμε τον αλγόριθμο minmax από κάτω προς τα πάνω στο
προκύπτον δέντρο. Δηλαδή στα επίπεδα που παίζω εγώ βρίσκω ποια κίνηση μεγιστοποιεί τη
συνάρτηση κέρδους και στα επίπεδα που παίζει ο αντίπαλος ποια κίνηση την ελαχιστοποιεί.
Σε κάθε επίπεδο θα έχω ξεχωριστά σύνολα από αδέρφια. Το κάθε σύνολο θα έχει 
διαφορετικό πατέρα. Με αυτόν τον τρόπο θα επιλέγω ένα αδέρφο από κάθε σύνολο και θα το
οδηγώ στον πατέρα. Έτσι θα καταλήξω στο αρχικό επίπεδο και θα έχω βρει το κατά εμένα
επακολουθούμενο σύνολο κινήσεων. Έτσι θα έχω βρεί ποια θα είναι η κατάλληλη κίνηση που
πρέπει να κάνω και την κάνω.

[vasso]

ομάδα Β5
Ηλιακοπούλου 6364 - Καλαϊτζίδου 6369


ο κώδικάς μας ήταν αυτός που ζητήθηκε στην τρίτη εργασία χωρίς προσθήκες (με μία απώλεια για να είναι ταχύτερος)

παρουσιάζουμε αναλυτικά τον αλγόριθμο με τις προσθήκες του:

Εργασία 3η:


Στην τρίτη και τελευταία εργασία (την οποία θα περιγράψουμε αναλυτικά) αναλάβαμε να δημιουργήσουμε έναν ολοκληρωμένο παίκτη blokus (Computer) ο οποίος θα μπορεί να “βλέπει” τις πιθανές κινήσεις του αντιπάλου και να διαλέγει να κάνει την καλύτερη διαθέσιμη από τις κινήσεις του, σε συνάρτηση και με την κίνηση του αντίπαλου παίκτη. Ο παίκτης μας θα είναι σε θέση να νικάει άνετα την τρίτη μορφή παίκτη που εμφανίζεται στην εργασία, τον παίκτη Random ο οποίος διαλέγει και παίζει μια οποιαδήποτε τυχαία κίνηση ενός οποιουδήποτε τυχαίου κομματιού του χωρίς καμία στρατηγική. Χρησιμοποιούμε τον αλγόριθμο min-max ο οποίος είναι ιδιαίτερα διαδεδομένος για ανάλυση παιχνιδιών παρόμοιας φύσης με του blokus.  Ιδανικό θα ήταν να μπορούσε ο υπολογιστής μας να αναλύσει όλες τις επόμενες δυνατές κινήσεις, -του αντιπάλου και δικές του-  να δημιουργήσει ένα δέντρο παιχνιδιού για αυτές και να διαλέγει την κίνηση η οποία θα τον οδηγήσει είτε σε σίγουρη νίκη, είτε (παίζοντας ενδεχομένως με τον εαυτό του) σε ισοπαλία. Δυστυχώς, οι απαιτήσεις σε μνήμη και χρόνο της παραπάνω στρατηγικής συναγωνίζονται αυτές της ανάλυσης του σκακιού και οι υπολογιστές του σπιτιού μας είναι πολύ... ερασιτέχνες για να κάνουν μια τέτοια δουλειά.

Για τη δημιουργία του δέντρου παιχνιδιού, επιλέξαμε να κάνουμε δύο δικές μας κλάσεις, την Tree και την Node  οι οποίες έχουν την εξής δομή:
   η Tree περιέχει μόνο έναν vector από Nodes και τις κατάλληλες συναρτήσεις για προσθήκη στοιχείων, αναζήτηση, έλεγχο αν ο vector είναι άδειος και τέλος μια συνάρτηση που επιστρέφει το μέγεθος του vector.
   η Node περιγράφει έναν κόμβο του δέντρου παιχνιδιού και περιλαμβάνει τις εξής μεταβλητές:
   int Value η οποία θα κρατάει τις τιμές min-max
   boolean [][] Shape η οποία θα περιγράφει το σχήμα του κομματιού της συγκεκριμένης κίνησης
   int x, int y που περιέχουν τις συντεταγμένες του board
   Piece NodePiece που θα κρατάει όλο το κομμάτι και τέλος θα περιλαμβάνει και ένα Tree, το newNode, στο οποίο θα αποθηκεύονται τα παιδιά του   κόμβου αυτου.
 
Επίσης, στην Node περιλαμβάνονται οι κατάλληλες συναρτήσεις για  καταχώρηση και επιστροφή    των παραπάνω μεταβλητών, καθώς και οι συναρτήσεις addNode(Node e)  για προσθήκη παιδιού    στον κόμβο Node, η size( ) που επιστρέφει το μέγεθος του newNode και η elementAt(int i) που μας  δίνει το Node που βρίσκεται στη θέση i του tree newNode.

Ο αλγόριθμος που ζητήθηκε για να υπολογίζει την value κάθε κίνησης είναι ο υπολογισμός της παράστασης

(Τρέχουσες γωνίες μου – Τρέχουσες γωνίες αντιπάλου) – (Αρχικές γωνίες μου – Αρχικές γωνίες αντιπάλου)

Η βασική υλοποίηση του συγκεκριμένου αλγορίθμου γίνεται με τη συνάρτηση evaluate η οποία παίρνοντας σαν όρισμα έναν board, υπολογίζει τη διαφορά: (Διαθέσιμες γωνίες μου – Διαθέσιμες γωνίες Αντιπάλου). Αυτό υλοποιείται σε ένα loop για κάθε παίκτη ξεχωριστά και αν αυτός είναι δικός μας παίκτης προσθέτει το αποτέλεσμα της scanTheBoard(Board,Color) στη μεταβλητή evaluation ενώ αν είναι ο αντίπαλος το αφαιρεί.
Το μεγαλύτερο και δυσκολότερο κομμάτι της τρίτης εργασίας ήταν η τροποποίηση της συνάρτησης getNextMove η οποία για δοσμένο πίνακα, παίζει την επόμενη κίνηση του παίκτη. Για να απλοποιήσουμε τον κώδικά της, γράψαμε μερικές επιπλέον βοηθητικές συναρτήσεις, τις CalculateBoxes( ), ClonePlaceEvaluate( ), findRoot( ), getNextColor( )  και την getFirstMove( ).
 Συγκεκριμένα:
Η CalculateBoxes, δίνοντάς της ένα piece υπολογίζει πόσα τετραγωνάκια του έχουν χρώμα (τη χρησιμοποιούμε στον έλεγχο όταν θέλουμε πχ να πάρουμε όλα τα κομμάτια με 5 τετραγωνάκια).
H ClonePlaceEvaluate( ) έχει διπλή λειτουργία. Αν την καλούμε για τον δικό μας παίκτη, κλωνοποιεί τον πίνακα που της δίνουμε, τοποθετεί το κομμάτι στην θέση που της δίνουμε και καλεί την evaluate( ) και επιστρέφει το αποτέλεσμά της.. Αν πάλι την καλούμε για το επόμενο επίπεδο του δέντρου, για την κίνηση δηλαδή του αντιπάλου, κλωνοποιεί πάλι τον πίνακα, τοποθετεί και το δικό μας κομμάτι και του αντιπάλου και καλεί πάλι την evaluate( )  και επιστρέφει το αποτέλεσμά της.
Η findRoot( ) είναι αυτή που υλοποιεί τον max αλγόριθμο και βρίσκει την ρίζα του δέντρου.H συνάρτηση δημιουργεί  κάθε φορά ένα καινούρια αντικείμενο Node max το οποίο σαν default τιμή παίρνει τα στοιχεία του πρώτου Node του Myside. Στη συνέχεια για κάθε ένα απο τα Nodes του Myside ελέγχει αν η Value του max είναι μικρότερη της Value του συγκεκριμένου Node και αν ναι,τοποθετεί τα στοιχεία του Νοde στο max.Αφου τελειώσει τον έλεγχο επιστρέφει το max που βρήκε.
H getNextColor( )επιστρέφει μια ακέραια τιμή η οποία αν χρησιμοποιηθεί ως δείκτης στην εντολή players.elementAt(index) μας δίνει τον αντίπαλο παίκτη, δίνοντας προσοχή στην περίπτωση που ο αμέσως επόμενος παίκτης είναι dead. Τότε, η getNextColor( ) επιστρέφει το άλλο χρώμα του αντίπαλου.
Τέλος, η getFirstMove( ), παίζει τις πρώτες 4 κινήσεις του παίκτη μας, καθώς έτσι αποφασίσαμε να λύσουμε το πρόβλημα που προέκυψε στην αρχή, οπότε και κάθε μια από τις πρώτες κινήσεις του παίκτη μας χρειαζόταν υπερβολικό χρόνο για να υπολογιστεί και να παιχτεί. Οι κινήσεις αυτές είναι προεπιλεγμένες από εμάς και τοποθετούνται συγκεκριμένα κομμάτια αυτόματα σε συγκεκριμένες θέσεις. Έτσι, όταν ο υπολογιστής κληθεί να αναλύσει τις διαθέσιμες κινήσεις των μεγαλύτερων κομματιών του, θα μειωθεί ο αριθμός κομματιών που θα επεξεργαστούν οι συναρτήσεις μας και προφανώς θα μειωθεί και ο χρόνος και η απαίτηση σε μνήμη του προγράμματος. Επίσης, με βάση την εμπειρία μας ως παίκτες του συγκεκριμένου παιχνιδιού πιστεύουμε ότι οι πρώτες κινήσεις που επιβάλλουμε στον παίκτη μας είναι στρατηγικά ορθές και τον οδηγούν σε ευκολότερη νίκη.



Πέραν των βοηθητικών συναρτήσεων, ένα μεγάλο τμήμα κώδικα βρίσκεται μέσα στην ίδια την getNextMove( ). Αγνοήσαμε το κομμάτι που δεν αναφερόταν σε παίκτη τύπου Computer και στη συνέχεια, ακολουθώντας τον ψευδοκώδικα που δόθηκε στην εκφώνηση της εργασίας ακολουθήσαμε τα εξής βήματα:
-Δημιουργούμε το δέντρο του παιχνιδιού με το όνομα MySide και τη ρίζα του (ως Node) με όνομα root.
-Yπολογίσαμε τις αρχικές γωνίες μας και του αντιπάλου χρησιμοποιώντας ως όρισμα το χρώμα του activePlayer. Συκεκριμένα, αν το χρώμα του είναι blue ή red, προσθέτει το μέγεθος των scanTheBoard() αν κληθούν για τα δύο αυτά χρώματα και το αποθηκεύει στη μεταβλητή arxikesMoy και αντίστοιχα τις καλεί για τα άλλα δύο, τις προσθέτει και αποθηκεύει το αποτέλεσμα στη μεταβλητή arxikesToy. Αντίστοιχα, αν τα δίκά μου χρώματα είναι το yellow και το green, τα καλεί και τα αποθηκεύει ανάποδα. Τέλος, αποθηκεύουμε τη διαφορά τους σε μία μεταβλητή  arxikes.
-Επιλέγουμε από το inventory ένα από τα μεγαλύτερα κομμάτια. Όπως προείπαμε, για τις 4 πρώτες κινήσεις, δεν θα τρέξει ο κανονικός κώδικας επιλογής κίνησης αλλά ένας ειδικός κώδικας που περιγράφεται στην getFirstMove( ). Αν βρισκόμαστε σε μια από τις επόμενες κινήσεις, μπαίνουμε σε μία επανάληψη τύπου do... while για να καλύψουμε την περίπτωση που τα μεγαλύτερα κομμάτια μας δεν έχουν κινήσεις και θελήσουμε να διαλέξουμε κάποιο κομμάτι με λιγότερα κουτάκια. Τότε, δημιουργούμε ένα κομμάτι temp, στο οποίο περνάμε το τελευταίο κομμάτι του inventory. Με την CalculateBoxes( ) υπολογίζουμε τον αριθμό τετραγώνων του και μέσα σε ένα while βρίσκουμε το πρώτο σε σειρά κομμάτι του inventory που έχει ίδιο ή μεγαλύτερο αριθμό τετραγώνων με το κομμάτι temp. Τη θέση του κομματιού αυτού στο inventory την κρατάω στην μεταβλητή LastSameSize.
-Βρίσκουμε όλες τις δυνατές κινήσεις για καθένα από τα κομμάτια του inventory που βρίσκονται από τη θέση LastSameSize ως το τέλος. Δημιουργούμε ένα MySet6364_6369  Moves και του δίνουμε το αποτέλεσμα της scanTheBoard. Στη συνέχεια, αν το LastSameSize δείχνει στο τέλος του inventory, δηλαδή έχουμε μόνο 1 μεγάλο κομμάτι για τοποθέτηση, φτιάχνουμε ακόμη ένα MySet6364_6369 Places αυτή τη φορά, του δίνουμε το αποτέλεσμα της findwhereItFits. Υπολογίζουμε για κάθε στοιχείο της places μέσω της ClonePlaceEvaluate τις τρέχουσες γωνίες, και τη διαφορά τους με τις αρχικές. Το αποτέλεσμα, μαζί με τα στοιχεία της κάθε κίνησης (Shape, Piece, Χ, Υ) τα αποθηκεύουμε σε ένα καινούριο Node που δημιουργούμε, το οποίο προσθέτουμε στο MySide.
Αν όμως, τα μεγάλα κομμάτια είναι περισσότερα από ένα, φτίαχνουμε έναν Vector, τον SelectedPiece στον οποίο περνάμε όλα τα κομμάτια που βρίσκονται στο inventory από τη θέση LastSameSize μέχρι και το τέλος του και έχουν δυνατές κινήσεις
(findWhereItFits(b,inventory.elementAt(LastSameSize+i).clone( ),Moves)!=null) 

Για την places του κάθε κομματιού ξεχωριστά, φτιάξαμε ένα loop που κάνει ακριβώς το ίδιο με την προηγούμενη περίπτωση που είχαμε ένα μόνο κομμάτι, δηλαδή υπολογίζουμε για κάθε στοιχείο της places μέσω της ClonePlaceEvaluate τις τρέχουσες γωνίες, και τη διαφορά τους με τις αρχικές. Το αποτέλεσμα, μαζί με τα στοιχεία της κάθε κίνησης (Shape, Piece, Χ, Υ) τα αποθηκεύουμε σε ένα καινούριο Node που δημιουργούμε, το οποίο προσθέτουμε στο MySide.
Στο σημείο αυτό αυξάνουμε τη βοηθητική μεταβλητή abc και κλείνουμε το do βάζοντας στο while τον έλεγχο while(Myside.size( )==0). Αν δηλαδή, δεν έχω κινήσεις με τα μεγαλύτερα κομμάτια, θα ξαναγυρίσω στην αρχή και θα πάρω την ομάδα κομματιών με ένα λιγότερο box (αυτό  το επιτυγχάνω αφαιρώντας από τα κουτάκια του μεγαλύτερου κομματιού την abc).


Αν η MySide έχει κινήσεις, προχωράμε σε αναζήτηση των κινήσεων του αντιπάλου. Καλώντας την getNextColor() παίρνουμε τον αντίπαλο παίκτη-αν η συνάρτηση επιστρέψει 4 (default  τιμή της  int color ) σημαίνει πως και οι δύο αντίπαλοι είναι dead.
 -Αν κάτι τέτοιο δεν συμβαίνει ,όπως και για τον δικό μας παίκτη ,βρίσκουμε την ομάδα των μεγαλύτερων κομματιών (πεντάρια,τεσσαρια....κτλ )χρησιμοποιώντας το δείκτη LastSameSize και τη συνάρτηση CalculateBoxes( ) με αντίστοιχο τρόπο που εφαρμόσαμε για τον δικό μας παίκτη. Στη συνέχεια για κάθε  ένα απο τα κομμάτια του δικού μου παίκτη που έχω καταχωρήσει στο δέντρο  Myside  κάνω την επανάληψη do..while  ώστε σε περίπτωση που η ομάδα των κομματιών του inventory του αντιπάλου μου δεν έχει κινήσεις να προβλέψω τις πιθανές κινήσεις των κομματιών της αμέσως μικρότερης ομάδας.(Γιαυτό και στο while η συνθήκη έιναι Myside.elementAt(index).size( )==0 αυξάνοντας το abc_2 καθε φορά).
-Όμοια με πάνω (δικός μας παίκτης) είτε έχει μείνει μονο ένα μεγαλο κομμάτι είτε πολλά μπαίνουμε στο αντίστοιχο loop και αν η findWhereItFits δεν επιστρέφει null δημιουργούμε ένα αντικείμενο Myset6364_6369 places όπου αποθηκεύουμε τις δυνατες κινήσεις του κάθε κομματιού του αντιπάλου.Θετουμε στην Value του δικού μας κομματιού μία default τιμή 1000.Για κάθε μία απο τις κινήσεις της places καλούμε την ClonePlaceEvaluate και αν βρει result με μικρότερη τιμή απο την Value τοποθετει την Value, το Piece,το Shape και τα X, Y του κομματιού στο Myside.elementAt(index).Με τον τρόπο αυτό βρίσκουμε την κίνηση min από τις κινήσεις του αντιπάλου.
-Εχοντας συμπληρώσει πλέον το δέντρο  καλούμε τη συνάρτηση findroot(Tree) με την οποία βρίσκουμε τη ρίζα του.Για το Piece που αντιστοιχεί στη ρίζα και για την συγκεκριμένη κίνηση του παίρνω τα x,y και το shape του και με τη συνάρτηση place(Piece,Shape,int) του Board τοποθετώ το κομμάτι στο ταμπλώ.
-Σε περίπτωση που και οι δύο αντίπαλοι  είναι dead παρακάμπτει όλο το παραπάνω κομμάτι που αντιστοιχεί στον αντίπαλο και μπαίνουμε σε ένα else το οποίο καλεί τη findroot(Tree) με κόμβους μόνο για τον δικό μου παίκτη και επειτα με το αποτέλεσμα που επιστρέφει τοποθετεί το κομμάτι στο ταμπλώ .Τέλος και στις δύο περιπτώσεις μετα την τοποθέτηση με την place(Piece,Shape,int)  θέτουμε movePlayed=true ώστε να δηλώσουμε πως έχουμε κάνει την κινησή μας.