用turtle做重力四子棋

非常感谢您的问题！我可以为您提供一些关于使用turtle制作重力四子棋的基本思路。首先，您需要了解turtle库的基本用法，以及重力四子棋的规则。然后，您可以使用turtle库来绘制棋盘和棋子，并编写相应的逻辑来实现游戏规则。具体的代码实现可以根据您的需求进行调整和修改。希望这些信息能够对您有所帮助！

相关问题

python 下面八个块显示鼠标追踪位置turtle.canvas 重力四子棋 turtle 代码

1. 显示鼠标追踪位置：

import turtle

def track_mouse(x, y):
    turtle.goto(x, y)

turtle.onscreenclick(track_mouse)
turtle.mainloop()

2. turtle.canvas：

import turtle

turtle.getcanvas().postscript(file="canvas.eps")
turtle.mainloop()

3. 重力：

import turtle

GRAVITY = 0.1

class Ball(turtle.Turtle):

    def __init__(self, x, y, dx, dy, radius, color):
        super().__init__(shape="circle")
        self.penup()
        self.setposition(x, y)
        self.dx = dx
        self.dy = dy
        self.radius = radius
        self.color(color)

    def move(self):
        self.dy -= GRAVITY
        self.sety(self.ycor() + self.dy)
        self.setx(self.xcor() + self.dx)

class Game:

    def __init__(self):
        self.window = turtle.Screen()
        self.window.setup(800, 600)
        self.window.bgcolor("white")
        self.balls = []

    def add_ball(self, x, y, dx, dy, radius, color):
        ball = Ball(x, y, dx, dy, radius, color)
        self.balls.append(ball)

    def start(self):
        while True:
            for ball in self.balls:
                ball.move()
                if ball.ycor() - ball.radius < -300:
                    ball.dy = -ball.dy
                if ball.xcor() + ball.radius > 400 or ball.xcor() - ball.radius < -400:
                    ball.dx = -ball.dx

            self.window.update()

game = Game()
game.add_ball(0, 200, 0, 0, 30, "red")
game.add_ball(0, 0, 5, 0, 20, "blue")
game.add_ball(0, -200, -5, 0, 10, "green")
game.start()

4. 四子棋：

import turtle

class Board:

    def __init__(self):
        self.board = [[None for _ in range(7)] for _ in range(6)]

    def is_full(self):
        for row in self.board:
            for cell in row:
                if cell is None:
                    return False
        return True

    def is_winner(self, player):
        # Check rows
        for row in self.board:
            count = 0
            for cell in row:
                if cell == player:
                    count += 1
                    if count == 4:
                        return True
                else:
                    count = 0

        # Check columns
        for j in range(7):
            count = 0
            for i in range(6):
                if self.board[i][j] == player:
                    count += 1
                    if count == 4:
                        return True
                else:
                    count = 0

        # Check diagonals
        for i in range(3):
            for j in range(4):
                if (self.board[i][j] == player and self.board[i+1][j+1] == player and
                    self.board[i+2][j+2] == player and self.board[i+3][j+3] == player):
                    return True
        for i in range(3):
            for j in range(3, 7):
                if (self.board[i][j] == player and self.board[i+1][j-1] == player and
                    self.board[i+2][j-2] == player and self.board[i+3][j-3] == player):
                    return True

        return False

    def play(self, player, column):
        for i in range(5, -1, -1):
            if self.board[i][column] is None:
                self.board[i][column] = player
                return True
        return False

class Game:

    def __init__(self):
        self.window = turtle.Screen()
        self.window.setup(700, 600)
        self.window.bgcolor("white")
        self.board = Board()
        self.turn = "red"
        self.draw_board()
        self.window.onclick(self.play)

    def draw_board(self):
        pen = turtle.Turtle()
        pen.hideturtle()
        pen.speed(0)
        pen.penup()
        pen.setposition(-300, -250)
        pen.pendown()
        pen.pensize(3)
        for _ in range(2):
            pen.forward(600)
            pen.left(90)
            pen.forward(500)
            pen.left(90)
        pen.penup()
        pen.setposition(-280, -225)
        for column in range(7):
            pen.write(column, align="center", font=("Arial", 16, "normal"))
            pen.forward(80)
        pen.hideturtle()

    def play(self, x, y):
        column = int((x + 300) // 80)
        if self.board.play(self.turn, column):
            self.draw_piece(column)
            if self.board.is_winner(self.turn):
                self.window.onclick(None)
                turtle.color(self.turn)
                turtle.write(f"{self.turn.upper()} wins!", align="center", font=("Arial", 32, "bold"))
            elif self.board.is_full():
                self.window.onclick(None)
                turtle.write("Draw!", align="center", font=("Arial", 32, "bold"))
            else:
                self.turn = "yellow" if self.turn == "red" else "red"

    def draw_piece(self, column):
        pen = turtle.Turtle()
        pen.hideturtle()
        pen.penup()
        pen.color(self.turn)
        row = max([i for i, cell in enumerate(self.board.board) if cell[column] is None])
        pen.setposition(-240 + column * 80, -200 + row * 80)
        pen.pendown()
        pen.begin_fill()
        pen.circle(30)
        pen.end_fill()

game = Game()
turtle.mainloop()

5. turtle 代码：

import turtle

pen = turtle.Turtle()
pen.speed(0)
pen.hideturtle()

def draw_triangle(x, y, size, color):
    pen.penup()
    pen.setposition(x, y)
    pen.pendown()
    pen.color(color)
    pen.begin_fill()
    for _ in range(3):
        pen.forward(size)
        pen.left(120)
    pen.end_fill()

draw_triangle(-200, 0, 100, "red")
draw_triangle(0, 0, 100, "green")
draw_triangle(200, 0, 100, "blue")

turtle.mainloop()

python 用鼠标追踪位置 重力四子棋 turtle 代码

以下是使用turtle模块实现的重力四子棋游戏代码，包括用鼠标追踪位置：

import turtle

# 棋盘大小
BOARD_SIZE = 7
# 棋子大小
PIECE_SIZE = 40
# 棋盘左上角坐标
BOARD_LEFT = -200
BOARD_TOP = 200
# 棋子颜色
PLAYER1_COLOR = 'red'
PLAYER2_COLOR = 'yellow'

# 初始化棋盘
board = [[0] * BOARD_SIZE for i in range(BOARD_SIZE)]

# 初始化玩家
current_player = 1

# 初始化游戏结束标志
game_over = False

# 初始化画布和画笔
screen = turtle.Screen()
screen.title('Gravity Four')
screen.setup(width=600, height=600)
pen = turtle.Turtle()
pen.speed(0)
pen.hideturtle()

# 绘制棋盘
def draw_board():
    pen.penup()
    pen.goto(BOARD_LEFT, BOARD_TOP)
    pen.pendown()
    for i in range(BOARD_SIZE + 1):
        pen.goto(BOARD_LEFT + i * PIECE_SIZE, BOARD_TOP)
        pen.goto(BOARD_LEFT + i * PIECE_SIZE, BOARD_TOP - BOARD_SIZE * PIECE_SIZE)
    pen.goto(BOARD_LEFT, BOARD_TOP)
    for i in range(BOARD_SIZE + 1):
        pen.goto(BOARD_LEFT, BOARD_TOP - i * PIECE_SIZE)
        pen.goto(BOARD_LEFT + BOARD_SIZE * PIECE_SIZE, BOARD_TOP - i * PIECE_SIZE)

# 绘制棋子
def draw_piece(row, col, player):
    x = BOARD_LEFT + col * PIECE_SIZE + PIECE_SIZE / 2
    y = BOARD_TOP - row * PIECE_SIZE - PIECE_SIZE / 2
    pen.penup()
    pen.goto(x, y)
    if player == 1:
        pen.color(PLAYER1_COLOR)
    else:
        pen.color(PLAYER2_COLOR)
    pen.begin_fill()
    pen.circle(PIECE_SIZE / 2)
    pen.end_fill()

# 检查是否有四个相连的棋子
def check_win(row, col):
    directions = [(1, 0), (0, 1), (1, 1), (-1, 1)]
    for d in directions:
        count = 1
        r, c = row, col
        while True:
            r += d[0]
            c += d[1]
            if r < 0 or r >= BOARD_SIZE or c < 0 or c >= BOARD_SIZE or board[r][c] != current_player:
                break
            count += 1
        r, c = row, col
        while True:
            r -= d[0]
            c -= d[1]
            if r < 0 or r >= BOARD_SIZE or c < 0 or c >= BOARD_SIZE or board[r][c] != current_player:
                break
            count += 1
        if count >= 4:
            return True
    return False

# 点击事件处理函数
def click_handler(x, y):
    global current_player
    global game_over
    if game_over:
        return
    col = int((x - BOARD_LEFT) / PIECE_SIZE)
    if col < 0 or col >= BOARD_SIZE:
        return
    row = -1
    for i in range(BOARD_SIZE):
        if board[i][col] == 0:
            row = i
            break
    if row == -1:
        return
    draw_piece(row, col, current_player)
    board[row][col] = current_player
    if check_win(row, col):
        pen.penup()
        pen.goto(BOARD_LEFT + BOARD_SIZE * PIECE_SIZE / 2, BOARD_TOP + PIECE_SIZE)
        pen.write('Player {} wins!'.format(current_player), align='center', font=('Arial', 24, 'bold'))
        game_over = True
        return
    current_player = 3 - current_player

# 鼠标移动事件处理函数
def move_handler(x, y):
    if game_over:
        return
    col = int((x - BOARD_LEFT) / PIECE_SIZE)
    if col < 0 or col >= BOARD_SIZE:
        return
    pen.clear()
    draw_board()
    for i in range(BOARD_SIZE):
        if board[i][col] == 0:
            draw_piece(i, col, current_player)
            break

# 注册鼠标点击事件
screen.onclick(click_handler)

# 注册鼠标移动事件
screen.onmousemove(move_handler)

# 初始化游戏
draw_board()

# 运行游戏
turtle.mainloop()

使用方法：

将代码复制到Python编辑器中，运行代码并在弹出的窗口中玩游戏。鼠标移动到棋盘上方时，会显示当前玩家的棋子。点击棋盘时，会下一个棋子。当有一方获胜时，会显示获胜信息并结束游戏。