The Game - PCTF - iPw - TeamTasteless

'''

    PCTF - The Game solution by iPw for Tasteless!

'''


import socket
import pickle

HOST = '23.22.16.34'    # The remote host
PORT = 6969              # The same port as used by the server

# Too lazy to be consistent, just gave some variables their default values here!
previous_answer = []
relations = {}
previous_answer.append('Nope')
previous_answer.append('Nope')

def opensocket():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((HOST, PORT))
    return s

def senddata(s, answer=1):
    s.sendall(str(answer) + "\n")

def recdata(s):
    data = []
    data.append(s.recv(256))
    data.append(s.recv(256))
    data = ''.join(data)
    #print data
    return data

def getnext(relations, curr, type, current_answer, level):
    if not relations[curr][type]:
        #print "No level " + str(level) + " neighbours!"
        return 0
    for x in relations[curr][type]:
        if(x == current_answer[1]):
            #print "FOUND CHAIN!"
            return 1
            break
        else:
            if(level < 6):  #Make the longest chains 5!
                if(getnext(relations, x, type, current_answer, (level+1)) == 1):
                    return 1
                    break
    return 0

def maprelations(relations, current_answer):

    continuebool = 1
    try:
        relations[current_answer[0]]
    except KeyError:
        #print "No firstlevel neighbours"
        continuebool = 0
        return 0
    if(continuebool == 1):
        for x in relations[current_answer[0]]['greater']:
            if(x == current_answer[1]):
                #print "FOUND CHAIN!"
                return 1
                break
            else:
                if(getnext(relations, x, 'greater', current_answer, 1) == 1):
                    relations[current_answer[0]]['greater'].insert(0,current_answer[1])
                    relations[current_answer[1]]['smaller'].insert(0,current_answer[0])
                    return 1
        for x in relations[current_answer[0]]['smaller']:
            if(x == current_answer[1]):
                #print "FOUND CHAIN!"
                return 2
                break
            else:
                if(getnext(relations, x, 'smaller', current_answer, 1) == 1):
                    relations[current_answer[0]]['smaller'].insert(0,current_answer[1])
                    relations[current_answer[1]]['greater'].insert(0,current_answer[0])
                    return 2
        #print "No n-level neighbours"
        return 0

def parseresponse(s, response, first=0):
    global previous_answer
    global relations
    current_answer = []
    current_answer.append(0)
    current_answer.append(0)

    #print response
    response = response.split("\n")

    if(previous_answer[0] == 'Nope'):

        current_answer[0] = response[1][11:]
        current_answer[1] = response[2][11:]

    elif(previous_answer[0] == 'Known'):

        current_answer[0] = response[4][11:]
        current_answer[1] = response[5][11:]
        print "\n+++++++++++++++++\nSanity check: We were - '" + str(response[0]) + ":" + response[1] + "'\n+++++++++++++++++\n"
        #Sanity check, we should not have to use this to get info!

    else:

        current_answer[0] = response[4][11:]
        current_answer[1] = response[5][11:]
        #Now we put the answer to memory!
        #print "Current record is: '" + response[3] + "'!"
        #print "Previous guess was - '" + response[1] + "'"
        print  "\n+++++++++++++++++\nHad to guess, and I guessed: " + response[1] + "\n+++++++++++++++++\n"
        if(response[1] == 'Wrong :('):
            bigger = 0
        else:
            bigger = 1

        try:
            relations[previous_answer[0]]
        except KeyError:
            relations[previous_answer[0]] = {}
            relations[previous_answer[0]]['greater'] = []
            relations[previous_answer[0]]['smaller'] = []

        try:
            relations[previous_answer[1]]
        except KeyError:
            relations[previous_answer[1]] = {}
            relations[previous_answer[1]]['greater'] = []
            relations[previous_answer[1]]['smaller'] = []

        #print "[DEBUG] Saving New Relations!"

        if (bigger == 1):
            #print "[DEBUG] 1 is bigger than 2!"
            relations[previous_answer[0]]['greater'].insert(0,previous_answer[1])
            relations[previous_answer[1]]['smaller'].insert(0,previous_answer[0])
        else:
            #print "[DEBUG] 1 is smaller than 2!"
            relations[previous_answer[0]]['smaller'].insert(0,previous_answer[1])
            relations[previous_answer[1]]['greater'].insert(0,previous_answer[0])

    guess = maprelations(relations, current_answer)

    if(guess>0):
        previous_answer[0] = 'Known'
        return guess
    else:
        previous_answer = current_answer
        return 1

socket = opensocket()
result = parseresponse(socket, recdata(socket),1)

x = 1 #Starting iteration!

#Load old relations!
pkl_file = open('relations.pkl', 'rb')
relations = pickle.load(pkl_file)
pkl_file.close()

#print relations

try:
    while 1:
        print "[DEBUG] Iteration:" + str(x)
        senddata(socket, result)
        result = parseresponse(socket, recdata(socket))
        x=x+1

except KeyboardInterrupt:
    #Save relations!
    output = open('relations.pkl', 'wb')
    pickle.dump(relations, output)
    output.close()
    socket.close()