class board:
    def __init__(self):
        self.pointcalc = [0, 40, 100, 300, 1200]
        self.weights = (5.06450279, -0.40483617,  1.14291331,  1.83894321,  0.18530122, 0.35860931,  0.93125075,  0.23497438)
        ###self.survweights = (1.72746616e+00,  1.18972449e-02,  4.54023544e-01,  4.19517578e-01,1.46628694e-03, -2.19499807e-01,  5.36884577e-01, -4.83240272e-01)
        #board data
        self.heights = [0] * 10
        self.ones = [0] * 10
        self.grid = [0] * 24 #each row is an integer
        self.rowTrans = [0] * 24
        self.alive = 1
        #heuristic variables
        self.holes = 0
        self.avgHeight = 0
        self.maxHeight = 0
        self.bumpiness = 0
        self.newl = 0 #new lines in this move
        self.wellCells = 0
        self.deepWells = 0
        self.blocks = 0
        #scoring variables
        self.lines = 0
        self.pts = 0
    def col(self, x, y, piece): #checks collision
    def countrowTrans(self, row):
    def place (self, x, y, piece, type): #places piece
    def checkline(self): #checks for filled lines and updates board position
    def put(self, x, piece): #puts piece down according to rotation and position
    def printboard(self): #prints current board for debugging
    def getstats(self): #completely refreshes stats by checking entire board (only called when lines are cleared)
    def getval(self): #the evaluation function
 
class piece:
    def __init__(self, p, num):
        self.tile = [] #stores representation of different tile rotations
        self.types = num
    def getbounds(self):
           
tet = [piece([[0, 0], [0, 1], [0, 2], [0, 3]], 2),
       piece([[0, 0], [0, 1], [1, 1], [1, 0]], 1),
       piece([[0, 0], [1, 0], [0, 1], [0, 2]], 4),
       piece([[0, 0], [1, 0], [1, 1], [1, 2]], 4),
       piece([[0, 0], [1, 0], [1, 1], [2, 1]], 2),
       piece([[0, 0], [0, 1], [1, 1], [1, 2]], 2),
       piece([[0, 0], [0, 1], [0, 2], [1, 1]], 4), ] #I, O, L, J, S, Z, T
for i in tet:
    i.getbounds()

cur = tet[x[cnt]]
best = 1000
bestrot, bestpos = 0, 0
for i in range(cur.types):  # for each rotation
    for j in range(cur.minx[i], cur.maxx[i] + 1):  # possible placements
        result = board()
        result.copyboard(gameboard)
        result.put(j, cur.tile[i])
        resval = result.getval()
        if resval < best:
            best = resval
            bestrot, bestpos = i, j

self.weights = (5.06450279, -0.40483617,  1.14291331,  1.83894321,  0.18530122, 0.35860931,  0.93125075,  0.23497438)
def getval(self):
  return self.weights[0] * self.holes + self.weights[1] * self.bumpiness + self.weights[2] * (max(7, self.maxHeight) - 7) \
                         + self.weights[3] * (-self.newl) + self.weights[4] * self.wellCells + self.weights[5] * self.deepWells + \
                         self.weights[6] * totalrowtrans + self.weights[7] * -self.blocks + 0.1 * self.avgHeight

if random.random() < 0.07122: #mutation
    if random.randint(0, 1) == 0:
        child1[0][j] += random.uniform(-0.5/(gen + 1), 0.5/(gen + 1))
    else:
        child2[0][j] += random.uniform(-0.5/(gen + 1), 0.5/(gen + 1))

pop = []
size = 50
tabugen = 3
clancnt = 0
for i in range(size): #隨機產生族群
    pop.append([numpy.array(list(random.uniform(-1, 1) for i in range(8))), clancnt, [], numpy.array(list(random.uniform(-1, 1) for i in range(8))), 1])
    # individual: weights forming a chromosome, the clan number, tabu list, memetic vector for local optimization, memetic scalar
    clancnt += 1
 
for gen in range(100):
    print("Generation ", gen + 1, sep='')
    print(pop)
    gettestdata(10)
    res = []
    c = 0
    for individual in pop: #取得適應度
        val = score(individual[0], 0)
        res.append((val, individual))
        print(val, end=" ")
        c += 1
    res = sorted(res, key= lambda x: x[0])
    res.reverse()
    print()
    print(res[0])
    s = sum(list(a[0] for a in res))
    pop = []
    valid = 0
    count = 0
    while valid < size - 1: #交配
        count += 1
        p1, p2 = [], [] #selects p1 and p2 as parents
        s1, s2 = 0, 0
        r = random.uniform(0, s - 0.01)
        n = 0
        for j in range(len(res)):
            n += res[j][0]
            if n > r:
                p1 = res[j][1]
                s1 = res[j][0]
                break
 
        r = random.uniform(0, s - 0.01)
        n = 0
        for j in range(len(res)):
            n += res[j][0]
            if n > r:
                p2 = res[j][1]
                s2 = res[j][0]
                break
        #print(p1, p2)
 
        child1, child2 = [numpy.array([0.0] * 8), p1[1], copy.deepcopy(p1[2])], [numpy.array([0.0] * 8), p2[1], copy.deepcopy(p2[2])]
 
        for j in range(8):
            if random.random() < 0.5:
                child1[0][j] = p1[0][j]
                child2[0][j] = p2[0][j]
            else:
                child1[0][j] = p2[0][j]
                child2[0][j] = p1[0][j]
            if random.random() < 0.07122: #mutation 突變
                if random.randint(0, 1) == 0:
                    child1[0][j] += random.uniform(-0.5/(gen + 1), 0.5/(gen + 1))
                else:
                    child2[0][j] += random.uniform(-0.5/(gen + 1), 0.5/(gen + 1))
 
        child1[2].append(child2[1]) #adds each other to tabu list
        child2[2].append(child1[1])
 
        pop.append(child1)
        if valid < size - 1:
            pop.append(child2)
    pop.append(res[0][1])

pop = []
size = 50
tabugen = 3 #禁忌名單存幾個世代
clancnt = 0
for i in range(size):
    pop.append([numpy.array(list(random.uniform(-1, 1) for i in range(8))), clancnt, [], numpy.array(list(random.uniform(-1, 1) for i in range(8))), 1])
    # individual: weights forming a chromosome, the clan number, tabu list, memetic vector for local optimization, memetic scalar
    clancnt += 1
    
for gen in range(100):
    #...和前面一樣
    while valid < size - 1:
        count += 1
        p1, p2 = [], [] #selects p1 and p2 as parents
        s1, s2 = 0, 0
        r = random.uniform(0, s - 0.01)
        n = 0
        for j in range(len(res)):
            n += res[j][0]
            if n > r:
                p1 = res[j][1]
                s1 = res[j][0]
                break
 
        r = random.uniform(0, s - 0.01)
        n = 0
        for j in range(len(res)):
            n += res[j][0]
            if n > r:
                p2 = res[j][1]
                s2 = res[j][0]
                break
        #print(p1, p2)
        
        #判斷禁忌
        tabu = False #checks if match is tabu/
        if p1[1] == p2[1]:
            tabu = True
        for clan in p1[2]:
            if p2[1] == clan:
                tabu = True
        for clan in p2[2]:
            if p1[1] == clan:
                tabu = True
        #print(tabu)
        if tabu:
            continue
        else:
            valid += 2
 
        child1, child2 = [numpy.array([0.0] * 8), p1[1], copy.deepcopy(p1[2])], [numpy.array([0.0] * 8), p2[1], copy.deepcopy(p2[2])]
 
        for j in range(8):
            if random.random() < 0.5:
                child1[0][j] = p1[0][j]
                child2[0][j] = p2[0][j]
            else:
                child1[0][j] = p2[0][j]
                child2[0][j] = p1[0][j]
            if random.random() < 0.07122: #mutation
                if random.randint(0, 1) == 0:
                    child1[0][j] += random.uniform(-0.5/(gen + 1), 0.5/(gen + 1))
                else:
                    child2[0][j] += random.uniform(-0.5/(gen + 1), 0.5/(gen + 1))
 
        child1[2].append(child2[1]) #adds each other to tabu list
        child2[2].append(child1[1])
        while len(child1[2]) > tabugen:
            child1[2].pop(0)
        while len(child2[2]) > tabugen:
            child2[2].pop(0)
            
        pop.append(child1)
        if valid < size - 1:
            pop.append(child2)
    pop.append(res[0][1])
    clancnt += 1

pop = []
size = 50
tabugen = 3
clancnt = 0
for i in range(size):
    pop.append([numpy.array(list(random.uniform(-1, 1) for i in range(8))), clancnt, [], numpy.array(list(random.uniform(-1, 1) for i in range(8))), 1])
    # individual: weights forming a chromosome, the clan number, tabu list, memetic vector for local optimization, memetic scalar
    clancnt += 1
 
for individual in pop:
    val = score(individual[0], 0)
    # print(individual[0], individual[3], individual[4])
    for step in range(5):
        newparam = numpy.add(individual[0],
                             numpy.multiply(numpy.divide(individual[3], numpy.linalg.norm(individual[3])),
                                            individual[4]))
        localval = score(newparam, 0)
        if localval > val:
            val = localval
            individual[0] = newparam
            individual[4] *= 0.9
        else:
            if step == 0:
                individual[3] = numpy.array(list(random.random() for i in range(8)))
            break
    # print(individual[0])
    res.append((val, individual))
    print(val, end=" ")
    c += 1