python游戏初探：拍子打小球

最新推荐文章于 2022-10-15 11:24:49 发布
最新推荐文章于 2022-10-15 11:24:49 发布
阅读量1.4k 收藏 4
点赞数 1
分类专栏： Python 文章标签： python 游戏 tkinter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x6_9x/article/details/50814911
版权

根据前面慢屏幕乱跑的小球，改编一个弹球游戏，下面加一个球拍，当球碰到拍子的时候弹回去

版本一

目前这个实现的功能是：加入了一拍子，可以用键盘来左右控制移动


#########################
#之前做的画面没有互动，这次加入一个球拍，使之能把下落的球给挡回去，目前功能加入了一拍子，可以用键盘来左右控制移动
######################
from tkinter import *
import random
import time

#
#创建一个类，这个类含有两个参数，一个是画布，一个是球的颜色
#
class Ball:
    def __init__(self,canvas,color):
        self.canvas = canvas
        self.id = canvas.create_oval(10,10,25,25,fill=color)
        self.canvas.move(self.id,245,100)
        #来回反弹
        #--self.x = 0
        #--self.y = -1
        starts = [-3,-2,-1,1,2,3]
        random.shuffle(starts)
        self.x = starts[0]
        self.y = -3
        #winfo_height()函数来获取画布当前的高度，赋值给对象变量
        self.canvas_height = self.canvas.winfo_height()
        #获取X轴坐标
        self.canvas_width = self.canvas.winfo_width()
    def draw(self):
        self.canvas.move(self.id,self.x,self.y)
        #获取某个对象在画布的坐标，返回一个数组（两个坐标，左上角的坐标和右下角的两个坐标）
        pos = self.canvas.coords(self.id)
        #打印获取的坐标
        print(pos)
        #如果最上面的纵轴坐标在顶上，则往下移动一个像素
        if pos[1] <= 0:
            self.y = 1
        #如果最下面的纵轴坐标在底上，则向上移动
        if pos[3] > self.canvas_height:
            self.y = -1
        #宽度控制#
        #如果在左边框了，那么向右边移动3像素
        if pos[0] <= 0:
            self.x = 3
        #如果到右边框了，左移动3像素
        if pos[2] > self.canvas_width:
            self.x = -3
#
#创建一个球拍类，这个类含有两个参数，一个是画布，一个是球的颜色
#
class Paddle:
    def __init__(self,canvas,color):
        self.canvas = canvas
        self.id = self.canvas.create_rectangle(0,0,100,10,fill = color)
        self.canvas.move(self.id,200,300)
        self.x = 0
        self.canvas_width = self.canvas.winfo_width()
    #这个函数绑定一个事件，来实现小球用键盘来控制左右移动,当移动到边界的时候要停止移动    
    def draw(self,event):
        pos = self.canvas.coords(self.id)
        if event.keysym == 'Left':
            if pos[0] <= 0:
                self.canvas.move(self.id,0,0)
            else:
                self.canvas.move(self.id,-100,0)
        if event.keysym == 'Right':
            if pos[2] >= self.canvas_width:
                self.canvas.move(self.id,0,0)
            else:
                self.canvas.move(self.id,100,0)



#创建画布
tk = Tk()
tk.title("Game_ball")
tk.resizable(0,0)
tk.wm_attributes("-topmost",1)
#bd=0,highlightthickness=0 画布之外没有边框
canvas = Canvas(tk,width=500,height=400,bd=0,highlightthickness=0)
canvas.pack()
tk.update()

#创建对象 
ball = Ball(canvas,'red')
paddle = Paddle(canvas,'blue')
#一直保持循环
while 1:
    ball.draw()
    #给球拍绑定事件
    canvas.bind_all('<KeyPress-Left>',paddle.draw)
    canvas.bind_all('<KeyPress-Right>',paddle.draw)
    #快速刷新屏幕
    tk.update_idletasks()
    tk.update()
    time.sleep(0.01)

版本2

这个可用用键盘来回移动球拍，并且如果球碰到球拍会给它弹回去


#########################
#之前做的画面没有互动，这次加入一个球拍，使之能把下落的球给挡回去
######################
from tkinter import *
import random
import time

#
#创建一个类，这个类含有两个参数，一个是画布，一个是球的颜色
#
class Ball:
    #这个地方要获取paddle的数据，所以要把paddle对象作为一个参数传递进来
    def __init__(self,canvas,paddle,color):
        self.canvas = canvas
        self.paddle = paddle
        self.id = canvas.create_oval(10,10,25,25,fill=color)
        self.canvas.move(self.id,245,100)
        #来回反弹
        #--self.x = 0
        #--self.y = -1
        starts = [-3,-2,-1,1,2,3]
        random.shuffle(starts)
        self.x = starts[0]
        self.y = -3
        #winfo_height()函数来获取画布当前的高度，赋值给对象变量
        self.canvas_height = self.canvas.winfo_height()
        #获取X轴坐标
        self.canvas_width = self.canvas.winfo_width()

    #fun:判断是否击中球拍的函数，击中返回True，不然返回false
    #函数的擦数要获取球拍的位置，然后和小球的位置来判断
    def hit_paddle(self,pos):
        paddle_pos = canvas.coords(self.paddle.id)
        #这个地方来讲一下判断规则，现在我们获取了两个球和拍子两个对象在画布中的坐标，通过对坐标来判断是否撞拍
        #先判断横坐标：如果小球的最左边pos[0]的值大于等于拍子最左边的值，且球最右边的坐标的值pos[2]小于拍子最右边的值，那么横向是命中的
        if pos[0] >= paddle_pos[0] and pos[2] <= paddle_pos[2]:
            #纵向判断：小球的最下边的值位于球拍的pos[3]上底和下底之间,则纵向命中
            if pos[3] >= paddle_pos[1] and pos[3] <= paddle_pos[3]:
                return True
            else:
                return False

    def draw(self):
        self.canvas.move(self.id,self.x,self.y)
        #获取某个对象在画布的坐标，返回一个数组（两个坐标，左上角的坐标和右下角的两个坐标）
        pos = self.canvas.coords(self.id)
        ##纵轴控制##
        #如果最上面的纵轴坐标在顶上，则往下移动一个像素
        if pos[1] <= 0:
            self.y = 1
        #如果最下面的纵轴坐标在底上，则向上移动
        if pos[3] > self.canvas_height:
            self.y = -1
        #这儿加入球拍的位置，如果到了球拍的底部也要弹回去,通过加入一个函数来判断，在draw之前
        if self.hit_paddle(pos) == True:
            self.y = -1
        ##宽度控制##
        #如果在左边框了，那么向右边移动3像素
        if pos[0] <= 0:
            self.x = 3
        #如果到右边框了，左移动3像素
        if pos[2] > self.canvas_width:
            self.x = -3

#
#创建一个球拍类，这个类含有两个参数，一个是画布，一个是球的颜色
#
class Paddle:
    def __init__(self,canvas,color):
        self.canvas = canvas
        self.id = self.canvas.create_rectangle(0,0,100,10,fill = color)
        self.canvas.move(self.id,200,300)
        self.x = 0
        self.canvas_width = self.canvas.winfo_width()

    #这个函数绑定一个事件，来实现小球用键盘来控制左右移动,当移动到边界的时候要停止移动    
    def draw(self,event):
        pos = self.canvas.coords(self.id)
        if event.keysym == 'Left':
            if pos[0] <= 0:
                self.canvas.move(self.id,0,0)
            else:
                self.canvas.move(self.id,-100,0)
        if event.keysym == 'Right':
            if pos[2] >= self.canvas_width:
                self.canvas.move(self.id,0,0)
            else:
                self.canvas.move(self.id,100,0)



#创建画布
tk = Tk()
tk.title("Game_ball")
tk.resizable(0,0)
tk.wm_attributes("-topmost",1)
#bd=0,highlightthickness=0 画布之外没有边框
canvas = Canvas(tk,width=500,height=400,bd=0,highlightthickness=0)
canvas.pack()
tk.update()

#创建对象
paddle = Paddle(canvas,'blue')
ball = Ball(canvas,paddle,'red')

#一直保持循环
while 1:
    ball.draw()
    #给球拍绑定事件
    canvas.bind_all('<KeyPress-Left>',paddle.draw)
    canvas.bind_all('<KeyPress-Right>',paddle.draw)
    #快速刷新屏幕
    tk.update_idletasks()
    tk.update()
    time.sleep(0.01)

继续进行优化

加入计分功能和如果错过三次则自动停止功能

#########################
#之前做的画面没有互动，这次加入一个球拍，使之能把下落的球给挡回去
######################
from tkinter import *
import random
import time

#创建画布
tk = Tk()
tk.title("Game_ball")
tk.resizable(0,0)
tk.wm_attributes("-topmost",1)
#bd=0,highlightthickness=0 画布之外没有边框
canvas = Canvas(tk,width=500,height=400,bd=0,highlightthickness=0)
canvas.pack()
tk.update()

#
#创建一个类，这个类含有两个参数，一个是画布，一个是球的颜色
#
class Ball:
    #这个地方要获取paddle的数据，所以要把paddle对象作为一个参数传递进来
    def __init__(self,canvas,paddle,color):
        self.canvas = canvas
        self.paddle = paddle
        self.id = canvas.create_oval(10,10,25,25,fill=color)
        self.canvas.move(self.id,245,100)
        #来回反弹
        #--self.x = 0
        #--self.y = -1
        starts = [-3,-2,-1,1,2,3]
        random.shuffle(starts)
        self.x = starts[0]
        self.y = -3
        #winfo_height()函数来获取画布当前的高度，赋值给对象变量
        self.canvas_height = self.canvas.winfo_height()
        #获取X轴坐标
        self.canvas_width = self.canvas.winfo_width()
        #刚开始没有接触到底部
        self.hit_bottom_count = 0

    #fun:判断是否击中球拍的函数，击中返回True，不然返回false
    #函数的擦数要获取球拍的位置，然后和小球的位置来判断
    def hit_paddle(self,pos):
        paddle_pos = canvas.coords(self.paddle.id)
        #这个地方来讲一下判断规则，现在我们获取了两个球和拍子两个对象在画布中的坐标，通过对坐标来判断是否撞拍
        #先判断横坐标：如果小球的最左边pos[0]的值大于等于拍子最左边的值，且球最右边的坐标的值pos[2]小于拍子最右边的值，那么横向是命中的
        if pos[0] >= paddle_pos[0] and pos[2] <= paddle_pos[2]:
            #纵向判断：小球的最下边的值位于球拍的pos[3]上底和下底之间,则纵向命中
            if pos[3] >= paddle_pos[1] and pos[3] <= paddle_pos[3]:
                return True
            else:
                return False

    def draw(self):
        self.canvas.move(self.id,self.x,self.y)
        #获取某个对象在画布的坐标，返回一个数组（两个坐标，左上角的坐标和右下角的两个坐标）
        pos = self.canvas.coords(self.id)
        ##纵轴控制##
        #如果最上面的纵轴坐标在顶上，则往下移动一个像素
        if pos[1] <= 0:
            self.y = 1
        #如果最下面的纵轴坐标在底上，则向上移动
        #if pos[3] > self.canvas_height:
            #self.y = -1
        if pos[3] >= self.canvas_height:
            self.hit_bottom_count = self.hit_bottom_count + 1
            self.y = -1
        #这儿加入球拍的位置，如果到了球拍的底部也要弹回去,通过加入一个函数来判断，在draw之前
        if self.hit_paddle(pos) == True:
            self.y = -1
        ##宽度控制##
        #如果在左边框了，那么向右边移动3像素
        if pos[0] <= 0:
            self.x = 3
        #如果到右边框了，左移动3像素
        if pos[2] > self.canvas_width:
            self.x = -3

#
#创建一个球拍类，这个类含有两个参数，一个是画布，一个是球的颜色
#
class Paddle:
    def __init__(self,canvas,color):
        self.canvas = canvas
        self.id = self.canvas.create_rectangle(0,0,100,10,fill = color)
        self.canvas.move(self.id,200,300)
        self.x = 0
        self.canvas_width = self.canvas.winfo_width()

    #这个函数绑定一个事件，来实现小球用键盘来控制左右移动,当移动到边界的时候要停止移动
    def draw(self,event):
        pos = self.canvas.coords(self.id)
        if event.keysym == 'Left':
            if pos[0] <= 0:
                self.canvas.move(self.id,0,0)
            else:
                self.canvas.move(self.id,-100,0)
        if event.keysym == 'Right':
            if pos[2] >= self.canvas_width:
                self.canvas.move(self.id,0,0)
            else:
                self.canvas.move(self.id,100,0)
        print(event.keysym)



def main():
    #创建对象
    paddle = Paddle(canvas,'blue')
    ball = Ball(canvas,paddle,'red')
    #一直保持循环
    while 1:
        #用一个变量来判断是否曾接触过底部,默认没接触过
        if True == True:
            if ball.hit_bottom_count <= 1 :
                #点击球拍开始
                is_begin = True
                ball.draw()
                #给球拍绑定事件
                canvas.bind_all('<KeyPress-Left>',paddle.draw)
                canvas.bind_all('<KeyPress-Right>',paddle.draw)
            else:
                #游戏结束后，闪烁游戏结束提示
                for i in range(1,20):
                    time.sleep(0.5)
                    endmsg=canvas.create_text(250,200,text = 'Game Over!',font =('Times',50),fill = 'red')
                    tk.update()
                    time.sleep(0.5)
                    canvas.itemconfig(endmsg,state = 'hidden')
                    tk.update()
                    tk.update_idletasks()
                break
            #快速刷新屏幕
            tk.update_idletasks()
            tk.update()
            time.sleep(0.005)


if __name__ == "__main__":
    main()

继续进行功能扩展

加入如下功能：

  1. 点击球拍开始游戏
  2. 计分功能
  3. 加速功能
  4. 结束提醒功能
'''
#########################
#之前做的画面没有互动，这次加入一个球拍，使之能把下落的球给挡回去,同时较少main处的代码，尽量都放到类中来实现,以符合高内聚低耦合原则
######################
'''
from tkinter import *
import random
import time

#创建画布
tk = Tk()
tk.title("Game_ball")
tk.resizable(0,0)
tk.wm_attributes("-topmost",1)
#bd=0,highlightthickness=0 画布之外没有边框
canvas = Canvas(tk,width=500,height=400,bd=0,highlightthickness=0)
canvas.pack()
tk.update()

'''
#
#创建一个类，这个类含有如下参数：画布，被击中的球拍paddle，球的颜色，击中次数score
#
'''
class Ball:
    #这个地方要获取paddle的数据，所以要把paddle对象作为一个参数传递进来
    def __init__(self,canvas,paddle,color,score):
        self.canvas = canvas
        self.paddle = paddle
        self.score = score
        self.id = canvas.create_oval(10,10,25,25,fill=color)
        self.canvas.move(self.id,245,100)
        #来回反弹
        #--self.x = 0
        #--self.y = -1
        starts = [-3,-2,-1,1,2,3]
        random.shuffle(starts)
        self.x = starts[0]
        self.y = -3
        #winfo_height()函数来获取画布当前的高度，赋值给对象变量
        self.canvas_height = self.canvas.winfo_height()
        #获取X轴坐标
        self.canvas_width = self.canvas.winfo_width()
        #刚开始没有接触到底部
        self.hit_bottom_count = 0

    #fun:判断是否击中球拍的函数，击中返回True，不然返回false
    #函数的擦数要获取球拍的位置，然后和小球的位置来判断
    def hit_paddle(self,pos):
        paddle_pos = canvas.coords(self.paddle.id)
        #这个地方来讲一下判断规则，现在我们获取了两个球和拍子两个对象在画布中的坐标，通过对坐标来判断是否撞拍
        #先判断横坐标：如果小球的最左边pos[0]的值大于等于拍子最左边的值，且球最右边的坐标的值pos[2]小于拍子最右边的值，那么横向是命中的
        if pos[0] >= paddle_pos[0] and pos[2] <= paddle_pos[2]:
            #纵向判断：小球的最下边的值位于球拍的pos[3]上底和下底之间,则纵向命中
            if pos[3] >= paddle_pos[1] and pos[3] <= paddle_pos[3]:
                #此处调用的score类的getScore函数得分，把计算得分的功能让得分类来实现，通过对象引用获取某个对象的得分，就相当于球这个对象有了分的属性
                self.score.getScore()
                return True
            else:
                return False


    def draw(self):
        self.canvas.move(self.id,self.x,self.y)
        #获取某个对象在画布的坐标，返回一个数组（两个坐标，左上角的坐标和右下角的两个坐标）
        pos = self.canvas.coords(self.id)
        ##纵轴控制##
        #如果最上面的纵轴坐标在顶上，则往下移动一个像素
        if pos[1] <= 0:
            self.y = 1
        #如果最下面的纵轴坐标在底上，则向上移动
        #if pos[3] > self.canvas_height:
            #self.y = -1
        if pos[3] >= self.canvas_height:
            self.hit_bottom_count = self.hit_bottom_count + 1
            self.y = -1
        #这儿加入球拍的位置，如果到了球拍的底部也要弹回去,通过加入一个函数来判断，在draw之前
        if self.hit_paddle(pos) == True:
            self.y = -1
        ##宽度控制##
        #如果在左边框了，那么向右边移动3像素
        if pos[0] <= 0:
            self.x = 3
        #如果到右边框了，左移动3像素
        if pos[2] > self.canvas_width:
            self.x = -3
'''
#
#创建一个球拍类，这个类含有两个参数，一个是画布，一个是球的颜色
#
'''
class Paddle:
    def __init__(self,canvas,color):
        self.canvas = canvas
        self.id = self.canvas.create_rectangle(0,0,100,10,fill = color)
        self.canvas.move(self.id,200,300)
        self.x = 0
        self.is_start = False
        self.canvas_width = self.canvas.winfo_width()
        self.canvas.bind_all('<KeyPress-Left>',self.turn_left)
        self.canvas.bind_all('<KeyPress-Right>',self.turn_right)
        self.canvas.bind_all('<Button-1>',self.start_game)

    #这个函数绑定一个事件，来实现小球用键盘来控制左右移动,当移动到边界的时候要停止移动
    #应该把检测是否过线的判断放在这个地方，因为只有按键的时候才触发判断，
    def draw(self):        
        self.canvas.move(self.id,self.x,0)
        pos = self.canvas.coords(self.id)
        if pos[0] <= 0 :
            self.x = 0            
        elif pos[2] >= self.canvas_width:
            self.x = 0

    def turn_left(self,evt):
        self.x = -3
        return self.x

    def turn_right(self,evt):
        self.x = 3
        return self.x
    def start_game(self,evt):
        self.is_start = True
        return self.is_start


'''
#
##得分类，有2个属性，画布和颜色；一个方法，得分方法
#
'''

class Score:
    def __init__(self,canvas,color):
        self.score = 0
        self.canvas = canvas
        self.id = canvas.create_text(450,10,fill = color,text= self.score,)
    def getScore(self):
        self.score += 1
        #改变得分
        self.canvas.itemconfig(self.id,text = self.score)



def main():
    #创建对象
    score = Score(canvas,'green')
    paddle = Paddle(canvas,'blue')
    ball = Ball(canvas,paddle,'red',score)
    endmsg=canvas.create_text(250,200,text = 'Game Over!',font =('Times',50),fill = 'red',state = 'hidden')
    #ball2 = Ball(canvas,paddle,'green')
    #一直保持循环
    while 1:
        #用一个变量来判断是否曾接触过底部,默认没接触过
        if ball.hit_bottom_count <= 4 and paddle.is_start == True:
            #点击球拍开始
            #is_begin = True
            ball.draw()
            #ball2.draw()
            paddle.draw()
            if ball.hit_bottom_count > 4:
                canvas.itemconfig(endmsg,state='normal')
            #快速刷新屏幕
        tk.update_idletasks()
        tk.update()
        time.sleep(0.005)


if __name__ == "__main__":
    main()
贤时间
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python制作跳跃的小球
weixin_64311421的博客
12-01 1592
制作跳跃的小球
python小球游戏
03-18
以前的手机小游戏，挡板移动挡住小球，反弹，往返，落地则游戏结束
【pygame】之小球基础
m0_67388084的博客
10-15 2184
主要讲的的是制作python小游戏的基础-（小球），在玩中学习python，激发学习python的学习兴趣
CCF201803-2 碰撞的小球 （python语言）
SoftwareZhen的博客
01-23 1721
试题编号： 201803-2 试题名称： 碰撞的小球 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 问题描述 　　数轴上有一条长度为L（L为偶数)的线段，左端点在原点，右端点在坐标L处。有n个不计体积的小球在线段上，开始时所有的小球都处在偶数坐标上，速度方向向右，速度大小为1单位长度每秒。 　　当小球到达线段的端点...
击打小球（python）
Stone
12-31 684
击打小球 from tkinter import * import random import time class Ball: def __init__(self, canvas, paddle, color): self.canvas = canvas self.paddle = paddle self.id = canvas.crea...
【进阶篇】python使用tkinter实现透明窗体上绘制运动小球（第三篇）
dhjabc_1的专栏
05-16 1131
我一直在思索实现一个透明的窗体，然后可以基于这个窗体可以开发出各种好玩的应用（如桌面运动的小人、运动的小球、截图、录制GIF等等），今天无意间居然让我把其中一个最核心的技术难关突破了，我非常高兴，也借这个机会跟大家分享一下。 这一期，在前面两期的基础上，进一步介绍python使用tkinter实现透明窗体上绘制运动小球。进阶了！ 废话不多说，直接开始。 文章目录一、先上效果吧二、需求分析（一）先搞清楚角色（二）再搞清楚技术核心点（三）继续搞清楚需要的类库三、设计原则（一）类化（二）模块化（三）迭代优化四
PYTHON 游戏：弹跳小球游戏（pygame实现）
01-11
**Python 游戏开发：基于Pygame的弹跳小球游戏** 在计算机编程的世界里，游戏开发是一项引人入胜的实践，它结合了逻辑、艺术和交互性。本项目介绍了一个使用Python语言和Pygame库开发的弹跳小球游戏。Pygame是...
PYTHON 游戏：旋转小球躲避障碍物游戏（pygame实现）
01-12
"PYTHON 游戏：旋转小球躲避障碍物游戏（pygame实现）" 是一款基于Python编程语言和pygame库开发的趣味游戏。pygame是Python中的一个开源模块，专为创建2D游戏设计，它提供了丰富的功能，如图形绘制、事件处理、音频...
Python小游戏：扫雷
03-06
Python经典小游戏：扫雷
PYTHON 游戏：旋转小球（pygame实现的躲避障碍物的旋转小球游戏）
01-10
【标题】"PYTHON 游戏：旋转小球（pygame实现的躲避障碍物的旋转小球游戏）"涉及的知识点主要集中在Python编程语言、Pygame库的使用以及游戏开发的基本概念。下面将对这些方面进行详细阐述。 首先，Python是一种...
python 实战案例：商品竞猜价格游戏源码
最新发布
04-30
该游戏使用Python编写，可以作为娱乐项目或编程练习。 适用人群 Python初学者：希望通过一个有趣的项目学习Python基础。 游戏开发者：对创建简单的交互式游戏感兴趣。 编程爱好者：想要练习使用Python进行条件判断...
201803-2 碰撞的小球 Python
小小根堆的博客
02-18 418
问题描述： 数轴上有一条长度为L（L为偶数)的线段，左端点在原点，右端点在坐标L处。有n个不计体积的小球在线段上，开始时所有的小球都处在偶数坐标上，速度方向向右，速度大小为1单位长度每秒。 当小球到达线段的端点（左端点或右端点）的时候，会立即向相反的方向移动，速度大小仍然为原来大小。 当两个小球撞到一起的时候，两个小球会分别向与自己原来移动的方向相反的方向，以原来的速度大小继续移动。 现在，告诉你...
关于三堆小球的 python 实现
Mengrui_1991的博客
05-19 1207
关于三堆小球的 python 实现今天看到一个比较有意思的思维题:        游戏规则: 有三堆小球, 数量分别为3个, 5个, 7个, 如下:        。。。        。。。。。        。。。。。。                两人轮流从三堆小球里面的其中一堆拿走小球, 拿走的数量不限, 但至少拿走一个。        胜负条件: 拿走所有球里面最后一个的玩家为输家  ...
增加小球python,Python——pygame入门实例
weixin_42099936的博客
03-27 313
本文章是一篇学习笔记。加入了自己的理解。最终实现的是小球的一个移动pygame：就是一个制作游戏的模块，在Python中进行调用即可。impor pygame　　#导入pygame模块impor sys　　 #导入sys模块pygame.init()　　#初始化pygamescreen = pygame.display.set_mode((600,400))　　#设置窗口while True:...
【转载】tkinter中update和updateidletasks的区别
DarkFlameXMK的博客
05-02 7185
What are pending events? Events scheduled with after, mostly. And, as you also mentioned in your question, events that trigger a redraw. The circumstances when you should use update over update_idleta...
反弹的小球（python）
weiwei1994的专栏
01-10 5175
一个适合Python初学者体验的简单小游戏程序
Python解决小球反弹问题
weixin_43599240的博客
05-07 8399
一球从100米高度自由落体 每次反弹原来的一半；第10次落地一共经过多少米，第十次反弹多少米？ num = 100 b = list() for i in range(10): num = num / 2 b.append(num) print("小球一共移动了%s米" % (100+sum(b))) print("第十次小球弹了%s米" % b[9]) 结果： 小球一共移动了19...
Python 基础编程（001-1）Pygame制作跳跃小球小游戏，击中一次得一分并显示分数
SmartGridequation的博客
05-31 2362
Pygame制作跳跃小球小游戏，击中一次得一分并显示分数。仅添加击中判断模块和分数显示模块。一共包含三个步骤，代码如下： （1）首先创建一个游戏窗口，然后再窗口内创建一个小球。以一定的速度移动小球，当小球碰到游戏窗口的边缘时，小球弹回，继续移动。可以按照如下步骤实现该功能。 （2）其次增加鼠标点击的值域判断。 （3）最后通过右上角的分数显示模块显示分数。 ### -*- coding:utf-8 -*- import sys # 导入sys模块 import pygame # 导入pygame
Python实现小球游戏
东方电视台的博客
01-13 3051
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;用python实现小球的游戏，小球不断运动，用挡板接住小球使小球一直运动即可得分，参照着输上的介绍写的，很简易的游戏，只需要导入sys 和 pygame模块。 效果图如下所示： # -*- coding: utf-8 -*-： import pygame import sys # pygame初始化 pygam...
Python游戏编程入门：打造趣味游戏
"《Python游戏编程快速上手》是一本以编写游戏为教学方式的Python编程书籍，适合初学者。作者Al Sweigart通过实际的游戏示例，详细讲解了Python的基础知识、数据类型、函数、流程控制、调试、流程图设计、字符串操作...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

贤时间

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值