modifica el codigo para optimizar el algoritmo para encontrar la mejor solucion al tetris cuando la IA esta activa, solo modifica este apartado de la IA: ""import pygame
import random
import copy
import sys
import time # Sigue siendo útil para el drop_timer del jugador

--- Constantes ---

GRID_W, GRID_H = 10, 20
CELL_S = 30
WIDTH, HEIGHT = GRID_W * CELL_S, GRID_H * CELL_S
INFO_W = 150
TOTAL_W = WIDTH + INFO_W
FPS = 60
WHITE, BLACK, GRAY, RED, GREEN = (255,)*3, (0,)*3, (128,)*3, (255,0,0), (0,255,0)
DARK_GRAY = (50,) * 3

COLORS = [(0,255,255),(255,255,0),(128,0,128),(0,0,255),(255,165,0),(0,255,0),(255,0,0)]
PIECES = [[[1]*4],[[1,1],[1,1]],[[0,1,0],[1,1,1]],[[1,0,0],[1,1,1]],
[[0,0,1],[1,1,1]],[[0,1,1],[1,1,0]],[[1,1,0],[0,1,1]]]

--- Pesos Heurística IA ---

W_H, W_L, W_HOLE, W_BUMP = -0.51, 0.76, -0.35, -0.18

--- Clase Pieza Simplificada ---

class Piece:
def init(self, x, y, shape_idx):
self.x, self.y, self.shape_idx = x, y, shape_idx
self.shape = PIECES[shape_idx]
self.color = COLORS[shape_idx]
self.rot = 0

text
def get_shape(self):
    s = self.shape
    for _ in range(self.rot % 4): s = list(zip(*s[::-1]))
    return s

def rotate(self):
    p = copy.deepcopy(self); p.rot = (self.rot + 1) % 4; return p

def move(self, dx, dy):
    p = copy.deepcopy(self); p.x += dx; p.y += dy; return p

--- Funciones de Juego ---

def create_grid(): return [[0] * GRID_W for _ in range(GRID_H)]

def is_valid(grid, piece):
shape = piece.get_shape()
for y, row in enumerate(shape):
for x, cell in enumerate(row):
if cell:
px, py = piece.x + x, piece.y + y
if not (0 <= px < GRID_W and py < GRID_H): return False
if py >= 0 and grid[py][px] != 0: return False
return True

def add_to_grid(grid, piece):
shape, val = piece.get_shape(), piece.shape_idx + 1
for y, row in enumerate(shape):
for x, cell in enumerate(row):
if cell and 0 <= piece.y + y < GRID_H and 0 <= piece.x + x < GRID_W:
grid[piece.y + y][piece.x + x] = val

def clear_lines(grid):
new_grid = [row for row in grid if not all(row)]
cleared = GRID_H - len(new_grid)
for _ in range(cleared): new_grid.insert(0, [0] * GRID_W)
scores = {1: 40, 2: 100, 3: 300, 4: 1200}
return new_grid, scores.get(cleared, 0)

--- Lógica IA ---

def get_heights_holes_agg(grid):
heights = [0] * GRID_W; holes = 0; agg_h = 0
for x in range(GRID_W):
col_block = False
for y in range(GRID_H):
if grid[y][x] != 0:
if not col_block:
h = GRID_H - y
heights[x] = h; agg_h += h; col_block = True
elif col_block: holes += 1
return heights, holes, agg_h

def calculate_heuristic(grid, piece):
temp_grid = copy.deepcopy(grid)
add_to_grid(temp_grid, piece)
cleared_grid, score_gain = clear_lines(temp_grid) # Simula limpieza
lines_cleared = score_gain // 40 if score_gain <= 100 else (score_gain // 300 + 2 if score_gain <= 300 else 4) # Estima líneas

text
heights, holes, agg_h = get_heights_holes_agg(cleared_grid)
bumpiness = sum(abs(heights[i] - heights[i+1]) for i in range(GRID_W - 1))
return W_H * agg_h + W_L * lines_cleared + W_HOLE * holes + W_BUMP * bumpiness

def find_best_move(grid, piece):
possible_moves = []
for r_off in range(4):
p_rot = copy.deepcopy(piece); p_rot.rot = (piece.rot + r_off) % 4
shape_now = p_rot.get_shape()
min_x = -min((x for r in shape_now for x, c in enumerate(r) if c), default=0)
max_x = GRID_W - max((x + 1 for r in shape_now for x, c in enumerate(r) if c), default=len(shape_now[0]) if shape_now else 0)

text
    for tx in range(min_x, max_x + 1):
        p_test = Piece(tx, 0, p_rot.shape_idx); p_test.rot = p_rot.rot
        if not is_valid(grid, p_test):
             p_test.y = -1 # Intenta un poco más arriba
             if not is_valid(grid, p_test): continue

        while is_valid(grid, p_test.move(0, 1)): p_test = p_test.move(0, 1)

        if is_valid(grid, p_test): # Asegura que la pos final es válida
            is_dup = any(m.x == p_test.x and m.y == p_test.y and m.rot == p_test.rot for m in possible_moves)
            if not is_dup: possible_moves.append(p_test)

best_move, best_score = None, -sys.maxsize
if not possible_moves: # Fallback si no hay movimientos
    p_fall = copy.deepcopy(piece)
    while is_valid(grid, p_fall.move(0, 1)): p_fall = p_fall.move(0, 1)
    return p_fall

for move in possible_moves:
    score = calculate_heuristic(grid, move)
    if score > best_score: best_score, best_move = score, move
return best_move if best_move else possible_moves[0] # Devuelve el mejor o el primero

--- Inicialización y Bucle Principal ---

pygame.init()
screen = pygame.display.set_mode((TOTAL_W, HEIGHT))
pygame.display.set_caption("Tetris AI Mini")
clock = pygame.time.Clock()
font = pygame.font.Font(None, 36); small_font = pygame.font.Font(None, 28)

grid = create_grid()
score = 0; game_over = False; ai_playing = True; drop_timer = 0; drop_time = 0.8
current_piece, next_piece = None, None

def new_piece_set():
global current_piece, next_piece
current_piece = next_piece if next_piece else Piece(GRID_W//2-1, 0, random.randrange(len(PIECES)))
next_idx = random.randrange(len(PIECES))
next_piece = Piece(GRID_W // 2 - len(PIECES[next_idx][0]) // 2, 0, next_idx)
return is_valid(grid, current_piece)

new_piece_set()

running = True
while running:
delta_time = clock.tick(FPS) / 1000.0

text
for event in pygame.event.get():
    if event.type == pygame.QUIT: running = False
    if event.type == pygame.KEYDOWN:
        if event.key == pygame.K_p: ai_playing = not ai_playing
        if event.key == pygame.K_r and game_over:
             grid, score, game_over = create_grid(), 0, False; new_piece_set()

        if not ai_playing and not game_over:
            p_temp = current_piece; moved = False; hard_drop = False
            if event.key == pygame.K_LEFT: p_temp = current_piece.move(-1, 0); moved = True
            elif event.key == pygame.K_RIGHT: p_temp = current_piece.move(1, 0); moved = True
            elif event.key == pygame.K_UP: p_temp = current_piece.rotate(); moved = True
            elif event.key == pygame.K_DOWN: p_temp = current_piece.move(0, 1); moved = True; drop_timer = 0
            elif event.key == pygame.K_SPACE:
                while is_valid(grid, p_temp.move(0, 1)): p_temp = p_temp.move(0, 1)
                moved, hard_drop = True, True

            if moved and is_valid(grid, p_temp): current_piece = p_temp
            if hard_drop: drop_timer = drop_time # Force lock

if not game_over:
    lock_piece = False
    if ai_playing:
        current_piece = find_best_move(grid, current_piece)
        lock_piece = True # IA decide y bloquea instantáneamente
    else: # Player control drop
        drop_timer += delta_time
        if drop_timer >= drop_time:
            drop_timer = 0
            p_down = current_piece.move(0, 1)
            if is_valid(grid, p_down): current_piece = p_down
            else: lock_piece = True

    if lock_piece:
        add_to_grid(grid, current_piece)
        grid, score_gain = clear_lines(grid); score += score_gain
        if not new_piece_set(): game_over = True

# --- Dibujo ---
screen.fill(BLACK)
# Cuadrícula y piezas fijas
for y in range(GRID_H):
    for x in range(GRID_W):
        if grid[y][x]:
            pygame.draw.rect(screen, COLORS[grid[y][x]-1], (x*CELL_S, y*CELL_S, CELL_S, CELL_S))
            pygame.draw.rect(screen, GRAY, (x*CELL_S, y*CELL_S, CELL_S, CELL_S), 1)
for x in range(0, WIDTH, CELL_S): pygame.draw.line(screen, DARK_GRAY, (x, 0), (x, HEIGHT))
for y in range(0, HEIGHT, CELL_S): pygame.draw.line(screen, DARK_GRAY, (0, y), (WIDTH, y))

# Pieza actual
if current_piece and not game_over:
    for y, r in enumerate(current_piece.get_shape()):
        for x, c in enumerate(r):
            if c:
                px, py = (current_piece.x + x) * CELL_S, (current_piece.y + y) * CELL_S
                pygame.draw.rect(screen, current_piece.color, (px, py, CELL_S, CELL_S))
                pygame.draw.rect(screen, WHITE, (px, py, CELL_S, CELL_S), 1)

# Panel Info
panel_x = WIDTH + 10; panel_y = 10
screen.blit(small_font.render("NEXT:", True, WHITE), (panel_x, panel_y))
if next_piece:
    nx_s = next_piece.get_shape()
    nx_dx = panel_x + (INFO_W - len(nx_s[0])*CELL_S)//3; nx_dy = panel_y + 30
    for y, r in enumerate(nx_s):
        for x, c in enumerate(r):
            if c:
                pygame.draw.rect(screen, next_piece.color, (nx_dx+x*CELL_S, nx_dy+y*CELL_S, CELL_S, CELL_S))
                pygame.draw.rect(screen, GRAY, (nx_dx+x*CELL_S, nx_dy+y*CELL_S, CELL_S, CELL_S), 1)
sy = panel_y + 130
screen.blit(small_font.render("SCORE:", True, WHITE), (panel_x, sy))
screen.blit(font.render(f"{score}", True, WHITE), (panel_x, sy + 30))
ai_sy = sy + 80
screen.blit(small_font.render("IA (P):", True, WHITE), (panel_x, ai_sy))
screen.blit(font.render(f"{'ON' if ai_playing else 'OFF'}", True, GREEN if ai_playing else RED), (panel_x, ai_sy + 30))

if game_over:
    overlay = pygame.Surface((WIDTH, HEIGHT)); overlay.set_alpha(180); overlay.fill(BLACK)
    screen.blit(overlay, (0, 0))
    go_txt = font.render("GAME OVER", True, RED); r_txt = small_font.render("Press R to Restart", True, WHITE)
    screen.blit(go_txt, go_txt.get_rect(center=(WIDTH // 2, HEIGHT // 2 - 20)))
    screen.blit(r_txt, r_txt.get_rect(center=(WIDTH // 2, HEIGHT // 2 + 20)))

pygame.display.flip()

pygame.quit()

sys.exit() # No es estrictamente necesario si pygame.quit() se llama""