tkinter当前屏幕大小

你可以使用Tkinter模块中的`winfo_screenwidth()`和`winfo_screenheight()`方法来获取当前屏幕的大小。下面是一个简单的示例代码：

import tkinter as tk

# 创建Tkinter窗口
root = tk.Tk()

# 获取屏幕的宽度和高度
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()

# 打印屏幕的大小
print("Screen width:", screen_width)
print("Screen height:", screen_height)

# 关闭窗口
root.destroy()

这个代码会输出当前屏幕的宽度和高度。

相关问题

一个由tkinter按钮指令控制的封装成函数的pygame俄罗斯方块小游戏

### 回答1：
这是一个基本的封装成函数的pygame俄罗斯方块小游戏，由tkinter按钮指令控制。

代码如下：

import pygame
import random
import tkinter as tk
from tkinter import messagebox

# 定义方块大小和颜色
block_size = 30
block_color = {
    0: (0, 0, 0),
    1: (255, 85, 85),
    2: (255, 153, 51),
    3: (255, 255, 85),
    4: (51, 255, 51),
    5: (17, 17, 255),
    6: (102, 153, 255),
    7: (255, 102, 255)
}

# 定义方块形状
tetris_shapes = [
    [[1, 1, 1],
     [0, 1, 0]],

    [[0, 2, 2],
     [2, 2, 0]],

    [[3, 3, 0],
     [0, 3, 3]],

    [[4, 0, 0],
     [4, 4, 4]],

    [[0, 0, 5],
     [5, 5, 5]],

    [[6, 6, 6, 6]],

    [[7, 7],
     [7, 7]]
]


class TetrisApp(object):
    def __init__(self, master):
        self.master = master
        self.width = 10
        self.height = 22
        self.score = 0
        self.gameover = False
        self.paused = False
        self.grid = [[0 for x in range(self.width)] for y in range(self.height)]
        self.next_stone = tetris_shapes[random.randint(0, len(tetris_shapes) - 1)]
        self.init_game()

    def init_game(self):
        self.score = 0
        self.gameover = False
        self.paused = False
        self.grid = [[0 for x in range(self.width)] for y in range(self.height)]
        self.next_stone = tetris_shapes[random.randint(0, len(tetris_shapes) - 1)]
        self.new_stone()

    def new_stone(self):
        self.stone = self.next_stone[:]
        self.next_stone = tetris_shapes[random.randint(0, len(tetris_shapes) - 1)]
        self.stone_x = int(self.width / 2 - len(self.stone[0]) / 2)
        self.stone_y = 0

        if self.check_collision():
            self.gameover = True

    def check_collision(self, adj_x=0, adj_y=0):
        for i in range(len(self.stone)):
            for j in range(len(self.stone[0])):
                try:
                    if i + self.stone_y + adj_y < 0:
                        continue
                    if self.stone[i][j] and self.grid[i + self.stone_y + adj_y][j + self.stone_x + adj_x]:
                        return True
                except IndexError:
                    return True
        return False

    def remove_row(self, row):
        del self.grid[row]
        self.grid = [[0 for x in range(self.width)]] + self.grid
        self.score += 10

    def check_row_complete(self):
        rows_removed = 0
        for i in range(len(self.grid)):
            if 0 not in self.grid[i]:
                self.remove_row(i)
                rows_removed += 1
        if rows_removed > 0:
            self.score += 10 * rows_removed

    def move(self, adj_x):
        if not self.gameover and not self.paused:
            self.stone_x += adj_x
            if self.check_collision(adj_x=adj_x):
                self.stone_x -= adj_x

    def quit(self):
        self.master.quit()

    def drop(self):
        if not self.gameover and not self.paused:
            self.stone_y += 1
            if self.check_collision(adj_y=1):
                self.freeze()

    def rotate(self):
        if not self.gameover and not self.paused:
            new_stone = [[self.stone[y][x] for y in range(len(self.stone))] for x in range(len(self.stone[0]) - 1, -1, -1)]
            if not self.check_collision(adj_x=0, adj_y=0, new_stone=new_stone):
                self.stone = new_stone

    def toggle_pause(self):
        self.paused = not self.paused

    def start_game(self):
        if self.gameover:
            self.init_game()
            self.gameover = False

    def freeze(self):
        for i in range(len(self.stone)):
            for j in range(len(self.stone[0])):
                if self.stone[i][j]:
                    self.grid[i + self.stone_y][j + self.stone_x] = self.stone[i][j]
        self.check_row_complete()
        self.new_stone()
        if self.check_collision():
            self.gameover = True

    def draw_matrix(self, matrix, offset):
        for i in range(len(matrix)):
            for j in range(len(matrix[0])):
                if matrix[i][j]:
                    pygame.draw.rect(self.screen, block_color[matrix[i][j]],
                                     pygame.Rect((j + offset[0]) * block_size,
                                                 (i + offset[1]) * block_size,
                                                 block_size, block_size), 0)

    def draw_game(self):
        self.screen.fill((0, 0, 0))
        if self.gameover:
            font = pygame.font.Font(None, 36)
            text = font.render("Game Over", 1, (255, 255, 255))
            self.screen.blit(text, (block_size * self.width / 2 - text.get_width() / 2,
                                    block_size * self.height / 2 - text.get_height() / 2))
        else:
            self.draw_matrix(self.grid, (0, 0))
            self.draw_matrix(self.stone, (self.stone_x, self.stone_y))
        pygame.display.update()

    def run(self):
        pygame.init()
        self.screen = pygame.display.set_mode((self.width * block_size, self.height * block_size))
        pygame.time.set_timer(pygame.USEREVENT + 1, 1000)
        clock = pygame.time.Clock()
        while 1:
            clock.tick(60)
            for event in pygame.event.get():
                if event.type == pygame.USEREVENT + 1:
                    self.drop()
                elif event.type == pygame.QUIT:
                    self.quit()
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_UP:
                        self.rotate()
                    elif event.key == pygame.K_DOWN:
                        self.drop()
                    elif event.key == pygame.K_LEFT:
                        self.move(-1)
                    elif event.key == pygame.K_RIGHT:
                        self.move(+1)
                    elif event.key == pygame.K_SPACE:
                        self.toggle_pause()
                    elif event.key == pygame.K_RETURN:
                        self.start_game()

            self.draw_game()

            if self.gameover:
                tk.messagebox.showinfo("Game Over", "Your score is: %d" % self.score)
                self.init_game()

    def start(self):
        self.run()


if __name__ == '__main__':
    root = tk.Tk()
    app = TetrisApp(root)
    root.title("Tetris")
    root.geometry('%dx%d' % (app.width * block_size + 150, app.height * block_size))
    tk.Button(root, text="Start", command=app.start_game).pack(side="top")
    tk.Button(root, text="Quit", command=app.quit).pack(side="top")
    tk.Label(root, text="Score:").pack(side="left")
    tk.Label(root, textvariable=tk.StringVar(value=str(app.score))).pack(side="left")
    app.start()

在这个游戏中，可以通过上下左右键来控制方块的移动，空格键暂停游戏，回车键重新开始游戏。我们还可以在窗口中添加“开始”和“退出”按钮来控制游戏的开始和结束，并且在窗口中显示当前得分。

### 回答2：
俄罗斯方块是一款非常经典的益智小游戏，以下是一个封装成函数并由Tkinter按钮指令控制的Pygame俄罗斯方块小游戏的简单描述。

首先，我们需要导入所需的Pygame和Tkinter模块。创建一个Pygame窗口，并初始化游戏所需的变量，例如方块的大小、游戏区域的宽度和高度等。

接下来，我们可以定义一个函数来生成随机的俄罗斯方块，包括方块的形状和颜色。这里可以使用Pygame的Surface对象来表示方块，然后将它们绘制到游戏区域上。

然后，我们可以编写一个函数来处理游戏的逻辑。例如，当方块下落到底部或碰到其他方块时，需要将它们固定在游戏区域上，并生成新的方块。我们还可以编写函数来实现方块的移动和旋转操作。

在Tkinter中，我们可以创建几个按钮来控制游戏，例如开始游戏、暂停和重新开始。通过绑定按钮的事件回调函数，我们可以实现这些按钮的功能。

最后，我们需要一个无限循环来更新游戏的画面，并处理游戏的逻辑。当游戏结束时，可以显示得分，并提供重新开始游戏的选项。

总之，通过将Pygame俄罗斯方块小游戏封装成函数，并使用Tkinter按钮指令控制游戏的开始、暂停和重新开始等功能，我们可以创建一个简单而有趣的游戏。这个游戏可以通过点击按钮来控制方块的移动和旋转，为玩家带来欢乐和挑战。

### 回答3：
俄罗斯方块是一种经典的游戏，现在我创建了一个封装成函数的pygame俄罗斯方块小游戏，并通过tkinter的按钮指令来进行控制。

这个小游戏包含了几个主要函数：initialize_game()、draw_board()、update_board()、game_over()和button_command()。

initialize_game()函数被调用以初始化游戏，并设置游戏所需的变量。它创建了一个2D列表作为游戏的棋盘，并将其显示在屏幕上。

draw_board()函数将当前的棋盘状态显示在屏幕上。它通过循环遍历棋盘列表，并为每个方块绘制一个矩形。

update_board()函数在每一帧被调用，它负责更新棋盘状态。它检查当前的方块是否可以继续向下移动，如果可以，则更新方块的位置。如果方块无法继续向下移动，它将固定在当前位置，并生成一个新的方块。

game_over()函数用于判断游戏是否结束。如果当前的方块无法在顶部找到位置放置，则游戏结束。它会在屏幕上显示一条消息，并停止游戏。

button_command()函数会在点击tkinter按钮时被调用。它根据按钮的指令来控制当前方块的移动。例如，当点击向左按钮时，它将当前方块向左移动一格。

通过这些函数和按钮指令，玩家可以控制方块的移动来完成俄罗斯方块的游戏目标。玩家可以通过按钮来移动方块的位置和旋转方块。如果方块无法继续移动或旋转，玩家需要注意避开堆积的方块，以免游戏结束。

这个小游戏结合了tkinter和pygame，提供了一个简单而有趣的俄罗斯方块游戏体验，玩家可以通过点击按钮来控制方块的移动和旋转。希望你喜欢这个小游戏！

tk 的simpledialog使用时如何在当前鼠标位置弹出？

在 Tkinter 中，可以使用 `tkinter.simpledialog` 模块中的 `SimpleDialog` 类来实现简单对话框的功能，但是该类并没有提供直接在当前鼠标位置弹出对话框的方法。

不过，我们可以通过以下步骤来实现在当前鼠标位置弹出 `SimpleDialog`：

1. 获取当前鼠标位置。可以使用 `tkinter` 的 `winfo_pointerxy` 方法获取当前鼠标位置的 X 和 Y 坐标。

2. 计算对话框的位置。可以根据当前鼠标位置、对话框的大小以及屏幕的大小来计算对话框的位置。

3. 创建 `SimpleDialog` 对象，并设置其位置。可以使用 `SimpleDialog` 的 `geometry` 方法设置对话框的位置，具体来说，可以将计算出的对话框位置作为参数传递给 `geometry` 方法。

下面是一个示例代码，可以在当前鼠标位置弹出一个大小为 300x200 的 `SimpleDialog`：

import tkinter as tk
import tkinter.simpledialog as sd

class MyDialog(sd.SimpleDialog):
    def __init__(self, parent):
        super().__init__(parent, title="My Dialog", width=300, height=200)

root = tk.Tk()

# 获取当前鼠标位置
x, y = root.winfo_pointerxy()

# 计算对话框位置
width, height = 300, 200
screen_width, screen_height = root.winfo_screenwidth(), root.winfo_screenheight()
x = max(0, min(x, screen_width - width))
y = max(0, min(y, screen_height - height))

# 创建 SimpleDialog 对象，并设置位置
MyDialog(root).geometry(f"+{x}+{y}")

root.mainloop()

以上示例代码中，`MyDialog` 是继承自 `SimpleDialog` 的自定义对话框类，通过计算鼠标位置和屏幕大小来确定对话框的位置，并将位置作为参数传递给 `geometry` 方法来设置对话框的位置。