def height(g_prec, g_next, action):
""" Heuristique qui retourne la hauteur du dernier coup joué.
Paramètres :
- grid_prec : instance State.State : Etat du jeu avant le coup 'action'.
- grid_next : instance State.State : Etat du jeu après le coup 'action'.
- action : dictionnaire de la forme {"choose" : kind, "rotate" : rotation, "hor_move" : move} :
action à jouer.
retour :
int : hauteur du dernier coup"""
kind = action["choose"]
rotation = action["rotate"]
hor_move = action["hor_move"]
p = Piece.Piece.factory(kind, copy.copy(Piece.Piece.centers_init[kind]))
etat = State.State(g_prec.grid)
hauteur = 0
for _ in range(rotation):
p.rotate()
if (State.is_piece_accepted_abscisse(
p, p.center[0] + p.block_control[0] + hor_move)):
p.center[0] += hor_move
r = etat.drop_piece(p, 0)
for b in p.blocks:
h_tmp = p.center[1] + b[1]
if h_tmp > hauteur:
hauteur = h_tmp
return hauteur
return gp.TAILLE_Y_LIMITE - 1
def basic_smart_ia(state) :
""" Stratégie IA aléatoire smart : Elle joue aléatoirement, sauf si elle peut prendre une ligne.
Dans ce cas, elle complète la ligne;
Paramètres :
- state : instance State.State : etat du jeu
Retour :
Un play de la forme {"hor_move":hor_move, "rotate":rotat, "choose":piece}"""
pieces = copy.copy(state["pieces"])
scores = []
compteur = 0
for kind in pieces :
for rotation in range(0,4,1) :
for move in range(-5,7,1) :
play = {"choose":kind, "rotate":rotation, "hor_move":move}
grid_tmp = State.State(copy_grid(state["grid"]))
p = Piece.Piece.factory(kind, copy.copy(Piece.Piece.centers_init[kind]))
for _ in range(rotation) :
p.rotate()
if(State.is_piece_accepted_abscisse(p, p.center[0] + p.block_control[0] + move)) :
p.center[0] += move
r = grid_tmp.drop_piece(p, 0)
scores += [[play, grid_tmp.score[0]]]
scores.sort(key=lambda x : x[1], reverse=True)
best = scores[0][1]
best_plays = []
for s in scores :
if s[1] >= best :
best_plays += [s]
play_send = random.choice(best_plays)[0]
return play_send
async def hor_move_piece(self, move):
"""Déplace la pièce courante horizontalement selon move.
Attributs :
- move : int / Réprésente le mouvement horizontale de la pièce
move > 0 : déplacement à droite
move < 0 : déplacement à gauche"""
if State.is_piece_accepted_abscisse(self.current_piece,
self.current_abscisse + move):
self.current_abscisse = self.current_abscisse + move
self.current_piece.center[0] += move
def erosion(g_prec, g_next, action):
""" Heuristique : (nombre de line réalisée par action)*(nombre de block de la piece détuits).
Paramètres :
- grid_prec : instance State.State : Etat du jeu avant le coup 'action'.
- grid_next : instance State.State : Etat du jeu après le coup 'action'.
- action : dictionnaire de la forme {"choose" : kind, "rotate" : rotation, "hor_move" : move} :
action à jouer.
retour :
- int : (nombre de line réalisée par action)*(nombre de block de la piece détuits) """
kind = action["choose"]
rotation = action["rotate"]
hor_move = action["hor_move"]
#on recréer la piece et l'état précédent
p = Piece.Piece.factory(kind, copy.copy(Piece.Piece.centers_init[kind]))
etat = State.State(g_prec.grid)
hauteur = 0
for _ in range(rotation):
p.rotate()
#si elle dépasse, return 0
if (not State.is_piece_accepted_abscisse(
p, p.center[0] + p.block_control[0] + hor_move)):
return 0
#on descend la piece
p.center[0] += hor_move
while not etat.is_piece_blocked(p):
p.center[1] -= 1
#on calcul tous les indices d'ordonne de la piece qui est tombé
indices_ordonnee_piece = []
for block in p.blocks:
indices_ordonnee_piece += [int(p.center[1] + block[1])]
etat.grid[int(p.center[0] + block[0])][int(p.center[1] +
block[1])] = p.color
set_ordonnee_piece = list(set(indices_ordonnee_piece))
#on compte le nombre de block détruit et le nombre de ligne réalisées.
nb_block_detruit = 0
nb_lines_complete = 0
for j in set_ordonnee_piece:
line_complete = True
for i in range(gp.TAILLE_X):
if etat.grid[i][j] == Block.Block.Empty:
line_complete = False
if line_complete:
nb_lines_complete += 1
nb_block_detruit += indices_ordonnee_piece.count(j)
return nb_lines_complete * nb_block_detruit
def best_move(heuristic, weights, state):
""" Teste toutes les coups et retourne le meilleurs selon les heuristiques et
l'état du jeu.
Paramètres :
- heuristic : liste de fonction : chaque fonction de la liste représente une heuristic
et est de la forme : fonction(grid_prec, grid_next, action) .
- weights : liste de poids (float) : cette liste doit être de la même taille que heuristic.
Chaque poids indicé i dans la liste sera associé à l'heuristique indicée i.
- state : instance State.State : représente l'état du jeu au moment de choisir le l'action
Retour :
dictionnaire de la forme {"choose" : kind, "rotate" : rotation, "hor_move" : move} :
Représente la meilleur action calculée en fonction des heuristiques."""
pieces = copy.copy(state["pieces"])
scores_valid = []
scores_non_valid = []
compteur = 0
for kind in pieces:
for rotation in range(0, 4, 1):
for move in range(-5, 5, 1):
play = {"choose": kind, "rotate": rotation, "hor_move": move}
grid_tmp = State.State(copy_grid(state["grid"]))
grid_prec = State.State(copy_grid(state["grid"]))
p = Piece.Piece.factory(
kind, copy.copy(Piece.Piece.centers_init[kind]))
for _ in range(rotation):
p.rotate()
if (State.is_piece_accepted_abscisse(
p, p.center[0] + p.block_control[0] + move)):
p.center[0] += move
r = grid_tmp.drop_piece(p, 0)
if r:
#ne prends pas en compte les coups perdants
scores_valid += [[
play,
evaluate_play(grid_prec, grid_tmp, play, weights,
heuristic)
]]
else:
#prends tous les coups perdants
scores_non_valid += [[
play,
evaluate_play(grid_prec, grid_tmp, play, weights,
heuristic)
]]
scores = []
if len(scores_valid) > 0:
#On ne veut choisir un play que parmis ceux qui ne font pas perdre
scores = scores_valid
else:
#s'il n'existe pas de play valid, alors on doit en choisir un parmis tous ceux qui font perdre
scores = scores_non_valid
scores.sort(key=lambda x: x[1], reverse=True)
best = scores[0][1]
best_plays = []
for s in scores:
if s[1] >= best:
best_plays += [s]
play_send = random.choice(best_plays)[0]
return play_send