Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· OpenAIAi2 WildChat-4.8M (AI2)

import pygame import sys import random pygame.init() WIDTH = 800 HEIGHT = 800 CELLSIZE =…

  1. User

    import pygame import sys import random

    pygame.init()

    WIDTH = 800 HEIGHT = 800 CELL_SIZE = 40 GRID_SIZE = WIDTH // CELL_SIZE

    WHITE = (255, 255, 255) BLACK = (0, 0, 0) player_colors = [(255, 0, 0), (0, 0, 255)]

    grid = []

    def initialize_grid(): global grid grid = [[None] * GRID_SIZE for _ in range(GRID_SIZE)]

    def draw_pion(screen, x, y, color): position = (x * CELL_SIZE + CELL_SIZE // 2, y * CELL_SIZE + CELL_SIZE // 2) pygame.draw.circle(screen, color, position, CELL_SIZE // 2 - 2)

    def draw_grid(screen): for y in range(GRID_SIZE): for x in range(GRID_SIZE): rect = pygame.Rect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE) pygame.draw.rect(screen, BLACK, rect, 1)

            if grid[y][x] is not None:
                color = pygame.Color(player_colors[grid[y][x]])
                draw_pion(screen, x, y, color)
    

    def place_pion(player, x, y): global grid if grid[y][x] is None: grid[y][x] = player return True return False

    def change_pion(player, x, y): global grid if grid[y][x]: grid[y][x] = player return True

    def expand_pions(player): global grid new_positions = []

    for y in range(GRID_SIZE):
        for x in range(GRID_SIZE):
            if grid[y][x] == player:
                for dy in (-1, 0, 1):
                    for dx in (-1, 0, 1):
                        ny, nx = y + dy, x + dx
                        if 0 <= nx < GRID_SIZE and 0 <= ny < GRID_SIZE and grid[ny][nx] is None:
                            new_positions.append((nx, ny))
    
    for position in new_positions:
        grid[position[1]][position[0]] = player
    

    def check_neighbors(x, y, player): global grid neighbors = [ (x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1), ]

    colors_found = set()
    for nx, ny in neighbors:
        if 0 <= nx < GRID_SIZE and 0 <= ny < GRID_SIZE and grid[ny][nx] is not None:
            colors_found.add(grid[ny][nx])
    
    return colors_found
    

    def pierre_feuille_ciseaux(player1, player2): choices = ["pierre", "feuille", "ciseaux"] choice1 = choices[random.randint(0, 2)] choice2 = choices[random.randint(0, 2)]

    print("Joueur", player1 + 1, ":", choice1)
    print("Joueur", player2 + 1, ":", choice2)
    
    if (choice1 == "pierre" and choice2 == "ciseaux") or (choice1 == "feuille" and choice2 == "pierre") or (choice1 == "ciseaux" and choice2 == "feuille"):
        return player1
    if choice1 == choice2:
        return None
    return player2
    

    def is_game_over(start_phase): if start_phase: return False for row in grid: if None in row: return False return True

    def count_pions(player): count = 0 for row in grid: for cell in row: if cell == player: count += 1 return count

    def play_game():

    screen = pygame.display.set_mode((WIDTH, HEIGHT))
    clock = pygame.time.Clock()
    pygame.display.set_caption("Jeu de connexion")
    
    initialize_grid()
    
    start_phase = True
    running = True
    game_over = False
    turn = 0
    grid_x, grid_y = -1, -1
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE:
                if grid_x != -1 and grid_y != -1:
                    colors_found = check_neighbors(grid_x, grid_y, turn)
                    if len(colors_found) == 2 and (grid[grid_y][grid_x] is None or len(check_neighbors(grid_x, grid_y, grid[grid_y][grid_x])) < 4):
                        winner = pierre_feuille_ciseaux(list(colors_found)[0], list(colors_found)[1])
    
                        if winner is not None:
                            print("Le gagnant est le joueur", winner + 1)
                            change_pion(winner, grid_x, grid_y)
                        expand_pions(turn)
                        turn = (turn + 1) % len(player_colors)
                elif event.key == pygame.K_RETURN:
                    turn = (turn + 1) % len(player_colors)
            elif event.type == pygame.MOUSEBUTTONUP:
                x, y = pygame.mouse.get_pos()
                grid_x, grid_y = x // CELL_SIZE, y // CELL_SIZE
                if start_phase:
                    if count_pions(turn) == 0:
                        place_pion(turn, grid_x, grid_y)
                        turn = (turn + 1) % len(player_colors)
                    if count_pions(turn) == 1:
                        start_phase = False
                        turn = 0
    
        screen.fill(WHITE)
        draw_grid(screen)
        pygame.display.flip()
        clock.tick(60)
    
        if not game_over and is_game_over(start_phase):
            winner = 0 if count_pions(0) > count_pions(1) else 1
            print("Le joueur", winner + 1, "a gagné!")
            game_over = True
    
    pygame.quit()
    sys.exit()
    

    if name == "main": play_game()

      File "/home/ludovic/Bureau/tricolor.py", line 130
    if event.key == pygame.K_SPACE:
    ^
    

    IndentationError: expected an indented block after 'elif' statement on line 129

  2. Assistant

    It seems there is an indentation issue in your code at line 130. Just indent the line containing "if event.key == pygame.K_SPACE:" and the ones below it that need to be inside the "elif" clause, like this:

            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    if grid_x != -1 and grid_y != -1:
                        colors_found = check_neighbors(grid_x, grid_y, turn)
                        if len(colors_found) == 2 and (grid[grid_y][grid_x] is None or len(check_neighbors(grid_x, grid_y, grid[grid_y][grid_x])) < 4):
                            winner = pierre_feuille_ciseaux(list(colors_found)[0], list(colors_found)[1])
    
                            if winner is not None:
                                print("Le gagnant est le joueur", winner + 1)
                                change_pion(winner, grid_x, grid_y)
                            expand_pions(turn)
                            turn = (turn + 1) % len(player_colors)
                elif event.key == pygame.K_RETURN:
                    turn = (turn + 1) % len(player_colors)
    

    Now your code should run without this indentation error.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.