From bbe2182636a6467f07930c6823cd2bc6e4764a01 Mon Sep 17 00:00:00 2001
From: "john.wohl@uconn.edu" <jnw900@gmail.com>
Date: Thu, 12 Dec 2019 23:14:44 -0500
Subject: [PATCH] finished client

---
 Konane.py                         |  75 ++++++++++++++++++++++++++++--
 __pycache__/client.cpython-36.pyc | Bin 2049 -> 3393 bytes
 __pycache__/state.cpython-36.pyc  | Bin 6135 -> 6083 bytes
 client.py                         |  59 ++++++++++++++++++++---
 state.py                          |   7 +--
 5 files changed, 128 insertions(+), 13 deletions(-)

diff --git a/Konane.py b/Konane.py
index 95a9b8d..ffd9f4c 100644
--- a/Konane.py
+++ b/Konane.py
@@ -1,13 +1,17 @@
 import client
 import sys
 import state
+import math
 
 # Top level class that has the client and the state
+
 class Konane:
     def __init__(self):
         self.client = client.ArtemisClient("artemis.engr.uconn.edu", 4705)
         self.state = state.State()
         self.playerNumber = None
+        self.color = None
+        self.player = None
 
     def stringToCoords(self, string):
         coords = []
@@ -16,15 +20,78 @@ def stringToCoords(self, string):
 
         return coords
     
+    def coordsToString(self, coords):
+        return "[{0}:{1}]".format(coords[0], coords[1])
+
     def start(self):
-        firstMove = self.state.first_moves_set()[0]
-        firstMoveCommand = "[{0}:{1}]".format(firstMove[0], firstMove[1])
-        firstRemoved = self.client.initialize(firstMoveCommand)
+        firstMove = self.coordsToString(self.state.first_moves_set()[0])
+        firstRemoved = self.client.initialize(firstMove)
         removedCoords = self.stringToCoords(firstRemoved)
         self.state.removePiece(removedCoords[0], removedCoords[1])
 
+        self.color = self.client.color
+        self.player = int(self.client.playerNumber)
+
+        if(self.client.color == "WHITE"):
+            state.playerColor = self.color = state.WHITE
+        else:
+            state.playerColor = self.color = state.BLACK
+
+        if(self.player == 1):
+            try:
+                removedCoords = self.stringToCoords(self.client.waitREMOVE())
+            except:
+                return
+            self.state.removePiece(removedCoords[0], removedCoords[1])
+            myTurn = True
+        
+        else:
+            secondMove = self.coordsToString(self.state.second_moves_set()[0])
+            self.client.sendREMOVE(secondMove)
+            try:
+                removedCoords = self.stringToCoords(self.client.waitREMOVE())
+            except:
+                return
+
+            self.state.removePiece(removedCoords[0], removedCoords[1])
+            myTurn = False
+
+        finished = False
+        #print(self.state)
+        turns = 0
+        while(not finished):
+            if(myTurn):
+                moveCoords = self.state.makeMove(self.color)
+                if(moveCoords == 1):
+                    finished = True
+                else:
+                    startCoords = self.coordsToString(moveCoords[0])
+                    endCoords = self.coordsToString(moveCoords[1])
+                    self.client.sendMOVE(startCoords, endCoords)
+
+                    movedString = self.client.waitMOVE(myTurn)
+
+                    try:
+                        movedStart = self.stringToCoords(movedString[0])
+                        movedEnd = self.stringToCoords(movedString[1])
+                        self.state.movePiece(movedStart, movedEnd)
+                    except:
+                        break
+            else:       
+                movedString = self.client.waitMOVE(myTurn)
+
+                try:
+                    movedStart = self.stringToCoords(movedString[0])
+                    movedEnd = self.stringToCoords(movedString[1])
+                    self.state.movePiece(movedStart, movedEnd)
+                except:
+                    break
 
+            myTurn = not myTurn
+            print(self.state)
+        
+        self.client.close()
 
 k = Konane()
-print(k.stringToCoords("[0:14]"))
+k.start()
 
diff --git a/__pycache__/client.cpython-36.pyc b/__pycache__/client.cpython-36.pyc
index 8531e5bc70ac102ac4f6a4dd0102a0e8275ecd41..dec3fe6480f71de0adb02e0c7fdb5a8a3d4666de 100644
GIT binary patch
literal 3393
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

delta 827
zcmZvaPm9w)6u{?An(Q=9*1FaetE}CXE@ZI_;vNK7K?)x0qKFU>S(@pR&?aS)?m}rP
z(oaz5Q+N}^lPB+jSINPfhhF^v;(O^HDwrW}=Kam@y~)@5yQ=-bb?s}ve!ux#Uf2N~
zFOtWlm(1H-{Aj|_;?I#_s6odQ`YHI^o{^VQ+3zWXF{Vl=J}~9zFYu~XMTLR2z6`z3
z59{~P9>A1OAYyYig$b?*0zL<=c-yO>JGatIh4EQ#CB0rMGk+tMX9F2$%0cf+xcVpG
zgWDR6#thI(55IidxTiZPCM;rD8|Dyk`oa`4V}cs631A;aCu9gcHb+^n_0TIR8*}`U
zlHK#%3S>74WNr?TB=fi`z=V?NFo{#SPO^tt`IU>)FngA$7ncEbVz5v!*aD$Hnyne(
z6=)4StlAIY2E$PxWW*;tGUkln0va;!jJazg)D}h;WHjqI$SoNYnP(J8s)laA+Dp{n
zG|Oc0b~U<nKFYtvn9J_qDWzLt;OOtx&Zmp=BdA|RJ!i`e+Ti|@n3vS-lIw5w>lQVV
zn_)a0Wy-`em12sblps+iv5mqrRYjjvYKJ#b@f{@x$+-+pLfQRiTIkH}Fb=cuv>%RT
zQ@^h)8coWFRYPlcj8;Xi=eq6eLRm|vIol*7eNPeDispb$6u8!QQN|@3&7H_oG6@il
s5W*CeI4C?g;ky*IkHRly;XoGV|5eJx@!)zAjQa8k{c^?iVm%Q2FLS@3TmS$7

diff --git a/__pycache__/state.cpython-36.pyc b/__pycache__/state.cpython-36.pyc
index 8e25d00b4b2a017c10d5d935052e03b680f8bd19..7bc1eab79d1ca9ee1ceaa92435319c10d9b9d5e9 100644
GIT binary patch
delta 873
zcmZuvJ!=$E6rJ~WcJ@Ojgw1AWcU4R_nq-X2MvZa(SY5%dAP6FejYeT2enxn%-9U<9
zVP$bE3rTMyGPO3rK9FvIfm_(v2qNe`cV=V?2j;wU&pr3P``*mY&UUAC!gb5PfBm?-
z^QrXKR>SC>P0BfJS(cfl<Bmz`2j`8Nr=`O6M2KD&DylvQ-!#L}dHKQ&)&k>0IZ7Xk
z-_<m|FSY2HQ>ER~*XlASd~L88m2lcAPtIv`3R*YTu!z83;i4<kioTV5x;c+@9)L!p
z@zia)bir+}oZ*-Y{~4G=5_7tF;t@R^1RfNzCmx2{W8MZRE7_4GdoJV5dSp~>&Z1kw
z<8HAZWvQO+DLm;Zo}}jyDgMs}Qh;4}xFVXiqE}-<?)((EoE_K1NgOY}Y+JsPsY7T0
zT5#+&2f(Gr0(q6C^yA*Fw3X`9#zbRw5ssO(B=#Ocv6C&1zD(Fkg|uD0*O}t%$Od4R
z(I0;Nyy-I^+Rq;h9u0Gk*B_ewh;z@@*6IEvH7{{AutMvJ;#Y@iQ*Ww3J+;j;xwZQ3
zPzSnU-Le85TB}Z=nQ`RXH{v78nJ;q-zhJKMBAdmdx(KfTt^)Qk__=uU1=^~0^17%U
zMZ2|b?;s3Kfc)0+pNvqh;3U{-Ko8Id>;V)2EA-j(Xw_RBm%T1R!!4N^+VbxF1>X6X
A82|tP

delta 928
zcmZ8g&ubGw7@cpk-DIO%O42qz)Y_!Abt5I9v8_L9Jg5}}sk8?P*dpwTTDu9;)zd-_
z!Gk9cbMhdbym%2=@F+t63CUeB2QOYciO!qd)vbYj^S(Flo4jw9J!t-Hn&&JlFTVb`
z_wj@IQm0P%N*83zGsgHSan|4oeP_I&MbXOMiiPlbwm{_t_+}*xjr}h7U5B5Baz?z*
zeWzLR+N{&O_-uaJI4@;e<5)PQc&sl&2S|_ND-p+%=!z?ycrE;vU(>3K*d7DmoY6$$
z<}0FYE%h(RS|0e<AUPyuPQt_<rKf|T>Ax^4*u_Z4awu3j{H4g#Q4R6Nzw{bc&1#av
z)1r^Zy7H%c<3p8aS-j29S#gvcx@zImaVK--B)FOvS0nRdr0BwR^`3YcLIqHR<0wA?
zuFhzPQlXW+-aCaQqPFN4D+^6H>PbuFokO#cZVo>cbs}FJOm4RkW26I+W%OJAq`58m
zP~W@nKOANrc@Ow;)R`x)*BS5jdambs{?1<anY%AGrbKmH?)ofXk4ZjSKm%<+4(;lE
zOZ=KD_kAOf0>O|CG)Jp2hbk;)vKnZ_Jj2lfwv%(%CbRY1(PgOHxh4;{O};J{6)PIb
zLU|o<17HKx@W&*xGtsmSs72A6Zj4cmW;F3;dUb6EVilmii0C6gsoGm$tANV@+yg%X
Y$O3MP$<q3S`rE6hakacIc1w5v01?-rL;wH)

diff --git a/client.py b/client.py
index 7ffeec1..98fa29f 100644
--- a/client.py
+++ b/client.py
@@ -11,28 +11,75 @@ def __init__(self, server_host, server_port):
         self.opponent = None
         self.playerNumber = None
         self.color = None
-        # self.username = sys.stdin.readline()
-        # self.password = sys.stdin.readline()
         self.server_sock = None
 
+        self.gameOver = False
+
     def extractREMOVED(self, string):
         # len("Removed:")
         offset = 8
 
-        string = string .rstrip()
-        segment = string[string.find("Removed:"):string.find("]")+1]
+        string = string.rstrip()
+        segment = string[string.find("Removed:")+offset:string.find("]")+1]
         return segment
 
+    def extractMOVED(self, string):
+        #len(Move)
+        offset = 4
+
+        firstSegment = string[string.find("Move")+offset:string.find("]")+1]
+        
+        string = string[string.find("]")+2:]
+        secondSegment = string[:string.find("]")+1]
+
+        return (firstSegment, secondSegment)
+
     def waitForResponse(self):
-        response = self.server_sock.recv(1024).decode("utf-8")
-        print(response)
+        if(self.gameOver):
+            return "GAME OVER"
+
+        response = self.server_sock.recv(4096).decode("utf-8")
+        if(response.find("Opponent wins!") != -1):
+            self.gameOver = True
+        elif(response.find("You win!") != -1):
+            self.gameOver = True
+        elif(response.find("Error") != -1):
+            self.gameOver = True
+        print("----------------------\n" + response + "----------------------")
         return response
 
     def send(self, string):
+        if(self.gameOver):
+            return "GAME OVER"
+
         formatted_string = string.rstrip() + "\r\n"
+        print("**********************\n" + formatted_string + "**********************")
         #formatted_string = string
         #print(formatted_string, end="")
         self.server_sock.send(formatted_string.encode())
+    
+    def sendREMOVE(self, piece):
+        self.send(piece)
+    
+    def sendMOVE(self, start, end):
+        string = "{0}:{1}".format(start, end)
+        #print("I AM SENDING THIS MOVE: " + string)
+        self.send(string)
+
+    def waitREMOVE(self):
+        response = self.waitForResponse()
+        return self.extractREMOVED(response)
+
+    def waitMOVE(self, myTurn):
+        response = dummyResponse = self.waitForResponse()
+        # wait til i receive '?Move', so I know can transmit once it's my turn
+        while(not myTurn and dummyResponse.find("?Move") == -1):
+            #print("hit")
+            dummyResponse = self.waitForResponse()
+            
+        
+        #print("I JUST GOT THIS MOVE:" + response)
+        return self.extractMOVED(response)
   
     def initialize(self, firstMove):
         # Create socket and connect to server
diff --git a/state.py b/state.py
index 01e29ec..84ef76f 100644
--- a/state.py
+++ b/state.py
@@ -265,7 +265,7 @@ def eval(self, board, playerColor, opponentColor):
         if self.playerMode == 2:
             return len(player_moves)/len(opponent_moves)
         if self.playerMode == 3:
-            return len(player_moves)/(len(oppenent_moves)*2)
+            return len(player_moves)/(len(opponent_moves)*2)
         if self.playerMode == 4:
             return len(player_moves)/(len(opponent_moves)*3)
         if self.playerMode == 5:
@@ -274,7 +274,8 @@ def eval(self, board, playerColor, opponentColor):
     def makeMove(self, color):
         if len(self.generate_moves(self.board, color)) > 0:
             move = Minimax(self, 0, color, math.inf * -1, math.inf)
-            print(move)
-            self.movePiece(move[1][0], move[1][1])
+            #self.movePiece(move[1][0], move[1][1])
+            return move[1]
         else:
             self.gameOver = 1
+            return 1