精华内容
下载资源
问答
  • Python开发一个滑雪小游戏

    万次阅读 多人点赞 2021-06-09 14:27:01
    Python开发小游戏

    大家好,我是Lex 喜欢欺负超人那个Lex

    擅长领域:Python开发一个小游戏

    今日重点:一步步分析and越过亚马逊的反爬虫机制

     不一会,游戏写好了

    效果是这样的

    一、如何搭建开发环境环境

    一起来学pygame吧 游戏开发30例(开篇词)——环境搭建+游戏效果展示

    windows系统,python3.6+  pip21+

    安装游戏依赖模块
    
    pip install pygame

    二、完整开发流程

    1、代码结构

    首先,先整理一下项目的主结构,其实看一下主结构,基本就清晰了

    modules:自己定义的模块
    ——game.py:主程序
    
    res:存放引用到的图片和音频等等
    ——music: 音频 资源
    ——imgs: 图片 资源
    ——fonts: 字体
    
    cfg.py:为主配置文件
    
    skiing.py:主程序文件
    
    requirements.txt:需要引入的python依赖包

    2、详细配置

    cfg.py

    配置文件中,需要引入os模块,并且配置打开游戏的屏幕大小。将我们需要用到的图片、音频和字体文件全部引入到项目中。

    '''配置文件'''
    import os
    
    
    '''FPS'''
    FPS = 40
    '''游戏屏幕大小'''
    SCREENSIZE = (640, 640)
    '''图片路径'''
    SKIER_IMAGE_PATHS = [
        os.path.join(os.getcwd(), 'res/imgs/game_forward.png'),
        os.path.join(os.getcwd(), 'res/imgs/game_right1.png'),
        os.path.join(os.getcwd(), 'res/imgs/game_right2.png'),
        os.path.join(os.getcwd(), 'res/imgs/game_left2.png'),
        os.path.join(os.getcwd(), 'res/imgs/game_left1.png'),
        os.path.join(os.getcwd(), 'res/imgs/game_fall.png')
    ]
    OBSTACLE_PATHS = {
        'tree': os.path.join(os.getcwd(), 'res/imgs/tree.png'),
        'flag': os.path.join(os.getcwd(), 'res/imgs/flag.png')
    }
    '''背景音乐路径'''
    BGMPATH = os.path.join(os.getcwd(), 'res/music/bgm.mp3')
    '''字体路径'''
    FONTPATH = os.path.join(os.getcwd(), 'res/font/FZSTK.TTF')

    3、动画中引用到的图片

    4、资源文件

    包括游戏背景音频、图片和字体设计

    res

    music:游戏背景音乐

    fonts:记分牌呀、显示呀的 相关字体

    imgs:游戏动画里的静态图片,所谓动画都是图片

    5、主程序

    skiing.py

    在主程序中,通过读取配置文件,引入项目资源:包括图片、音频等,并从我们的modules里引入所有我们的模块。

    ''' 类'''
    class lexGame():
        def __init__(self, screen, sounds, font, lex_imgs, cfg, **kwargs):
            self.info = 'Gemlex —— hacklex'
            self.screen = screen
            self.sounds = sounds
            self.font = font
            self.lex_imgs = lex_imgs
            self.cfg = cfg
            self.reset()
        '''开始 '''
        def start(self):
            clock = gamepy.time.Clock()
            # 遍历整个 界面更新位置
            overall_moving = True
            # 指定某些对象个体更新位置
            individual_moving = False
            # 定义一些必要的变量
            lex_selected_xy = None
            lex_selected_xy2 = None
            swap_again = False
            add_score = 0
            add_score_showtimes = 10
            time_pre = int(time.time())
            #  主循环
            while True:
                for event in gamepy.event.get():
                    if event.type == gamepy.QUIT or (event.type == gamepy.KEYUP and event.key == gamepy.K_ESCAPE):
                        gamepy.quit()
                        sys.exit()
                    elif event.type == gamepy.MOUSEBUTTONUP:
                        if (not overall_moving) and (not individual_moving) and (not add_score):
                            position = gamepy.mouse.get_pos()
                            if lex_selected_xy is None:
                                lex_selected_xy = self.checkSelected(position)
                            else:
                                lex_selected_xy2 = self.checkSelected(position)
                                if lex_selected_xy2:
                                    if self.swapGem(lex_selected_xy, lex_selected_xy2):
                                        individual_moving = True
                                        swap_again = False
                                    else:
                                        lex_selected_xy = None
                if overall_moving:
                    overall_moving = not self.dropGems(0, 0)
                    # 移动一次可能可以拼出多个3连块
                    if not overall_moving:
                        res_match = self.isMatch()
                        add_score = self.removeMatched(res_match)
                        if add_score > 0:
                            overall_moving = True
                if individual_moving:
                    lex1 = self.getGemByPos(*lex_selected_xy)
                    lex2 = self.getGemByPos(*lex_selected_xy2)
                    lex1.move()
                    lex2.move()
                    if lex1.fixed and lex2.fixed:
                        res_match = self.isMatch()
                        if res_match[0] == 0 and not swap_again:
                            swap_again = True
                            self.swapGem(lex_selected_xy, lex_selected_xy2)
                            self.sounds['mismatch'].play()
                        else:
                            add_score = self.removeMatched(res_match)
                            overall_moving = True
                            individual_moving = False
                            lex_selected_xy = None
                            lex_selected_xy2 = None
                self.screen.fill((154, 206, 235))
                self.drawGrids()
                self.lexs_group.draw(self.screen)
                if lex_selected_xy:
                    self.drawBlock(self.getGemByPos(*lex_selected_xy).rect)
                if add_score:
                    if add_score_showtimes == 10:
                        random.choice(self.sounds['match']).play()
                    self.drawAddScore(add_score)
                    add_score_showtimes -= 1
                    if add_score_showtimes < 1:
                        add_score_showtimes = 10
                        add_score = 0
                self.remaining_time -= (int(time.time()) - time_pre)
                time_pre = int(time.time())
                self.showRemainingTime()
                self.drawScore()
                if self.remaining_time <= 0:
                    return self.score
                gamepy.display.update()
                clock.tick(self.cfg.FPS)
    			
        '''初始化'''
        def reset(self):
            # 随机生成各个块
            while True:
                self.all_lexs = []
                self.lexs_group = gamepy.sprite.Group()
                for x in range(self.cfg.NUMGRID):
                    self.all_lexs.append([])
                    for y in range(self.cfg.NUMGRID):
                        lex = lexSprite(img_path=random.choice(self.lex_imgs), size=(self.cfg.GRIDSIZE, self.cfg.GRIDSIZE), position=[self.cfg.XMARGIN+x*self.cfg.GRIDSIZE, self.cfg.YMARGIN+y*self.cfg.GRIDSIZE-self.cfg.NUMGRID*self.cfg.GRIDSIZE], downlen=self.cfg.NUMGRID*self.cfg.GRIDSIZE)
                        self.all_lexs[x].append(lex)
                        self.lexs_group.add(lex)
                if self.isMatch()[0] == 0:
                    break
            # 得分
            self.score = 0
            # 拼出一个的奖励
            self.reward = 10
            # 时间
            self.remaining_time = 300
        '''显示剩余时间'''
        def showRemainingTime(self):
            remaining_time_render = self.font.render('CountDown: %ss' % str(self.remaining_time), 1, (85, 65, 0))
            rect = remaining_time_render.get_rect()
            rect.left, rect.top = (self.cfg.SCREENSIZE[0]-201, 6)
            self.screen.blit(remaining_time_render, rect)
        '''显示得分'''
        def drawScore(self):
            score_render = self.font.render('SCORE:'+str(self.score), 1, (85, 65, 0))
            rect = score_render.get_rect()
            rect.left, rect.top = (10, 6)
            self.screen.blit(score_render, rect)
        '''显示加分'''
        def drawAddScore(self, add_score):
            score_render = self.font.render('+'+str(add_score), 1, (255, 99, 99))
            rect = score_render.get_rect()
            rect.left, rect.top = (250, 250)
            self.screen.blit(score_render, rect)
        '''生成新的 块'''
        def generateNewGems(self, res_match):
            if res_match[0] == 1:
                start = res_match[2]
                while start > -2:
                    for each in [res_match[1], res_match[1]+1, res_match[1]+2]:
                        lex = self.getGemByPos(*[each, start])
                        if start == res_match[2]:
                            self.lexs_group.remove(lex)
                            self.all_lexs[each][start] = None
                        elif start >= 0:
                            lex.target_y += self.cfg.GRIDSIZE
                            lex.fixed = False
                            lex.direction = 'down'
                            self.all_lexs[each][start+1] = lex
                        else:
                            lex = lexSprite(img_path=random.choice(self.lex_imgs), size=(self.cfg.GRIDSIZE, self.cfg.GRIDSIZE), position=[self.cfg.XMARGIN+each*self.cfg.GRIDSIZE, self.cfg.YMARGIN-self.cfg.GRIDSIZE], downlen=self.cfg.GRIDSIZE)
                            self.lexs_group.add(lex)
                            self.all_lexs[each][start+1] = lex
                    start -= 1
            elif res_match[0] == 2:
                start = res_match[2]
                while start > -4:
                    if start == res_match[2]:
                        for each in range(0, 3):
                            lex = self.getGemByPos(*[res_match[1], start+each])
                            self.lexs_group.remove(lex)
                            self.all_lexs[res_match[1]][start+each] = None
                    elif start >= 0:
                        lex = self.getGemByPos(*[res_match[1], start])
                        lex.target_y += self.cfg.GRIDSIZE * 3
                        lex.fixed = False
                        lex.direction = 'down'
                        self.all_lexs[res_match[1]][start+3] = lex
                    else:
                        lex = lexSprite(img_path=random.choice(self.lex_imgs), size=(self.cfg.GRIDSIZE, self.cfg.GRIDSIZE), position=[self.cfg.XMARGIN+res_match[1]*self.cfg.GRIDSIZE, self.cfg.YMARGIN+start*self.cfg.GRIDSIZE], downlen=self.cfg.GRIDSIZE*3)
                        self.lexs_group.add(lex)
                        self.all_lexs[res_match[1]][start+3] = lex
                    start -= 1
        '''移除匹配的lex'''
        def removeMatched(self, res_match):
            if res_match[0] > 0:
                self.generateNewGems(res_match)
                self.score += self.reward
                return self.reward
            return 0
        ''' 界面的网格绘制'''
        def drawGrids(self):
            for x in range(self.cfg.NUMGRID):
                for y in range(self.cfg.NUMGRID):
                    rect = gamepy.Rect((self.cfg.XMARGIN+x*self.cfg.GRIDSIZE, self.cfg.YMARGIN+y*self.cfg.GRIDSIZE, self.cfg.GRIDSIZE, self.cfg.GRIDSIZE))
                    self.drawBlock(rect, color=(0, 0, 255), size=1)
        '''画矩形block框'''
        def drawBlock(self, block, color=(255, 0, 255), size=4):
            gamepy.draw.rect(self.screen, color, block, size)
        '''下落特效'''
        def dropGems(self, x, y):
            if not self.getGemByPos(x, y).fixed:
                self.getGemByPos(x, y).move()
            if x < self.cfg.NUMGRID - 1:
                x += 1
                return self.dropGems(x, y)
            elif y < self.cfg.NUMGRID - 1:
                x = 0
                y += 1
                return self.dropGems(x, y)
            else:
                return self.isFull()
        '''是否每个位置都有 块了'''
        def isFull(self):
            for x in range(self.cfg.NUMGRID):
                for y in range(self.cfg.NUMGRID):
                    if not self.getGemByPos(x, y).fixed:
                        return False
            return True
        '''检查有无 块被选中'''
        def checkSelected(self, position):
            for x in range(self.cfg.NUMGRID):
                for y in range(self.cfg.NUMGRID):
                    if self.getGemByPos(x, y).rect.collidepoint(*position):
                        return [x, y]
            return None
        '''是否有连续一样的三个块(无--返回0/水平--返回1/竖直--返回2)'''
        def isMatch(self):
            for x in range(self.cfg.NUMGRID):
                for y in range(self.cfg.NUMGRID):
                    if x + 2 < self.cfg.NUMGRID:
                        if self.getGemByPos(x, y).type == self.getGemByPos(x+1, y).type == self.getGemByPos(x+2, y).type:
                            return [1, x, y]
                    if y + 2 < self.cfg.NUMGRID:
                        if self.getGemByPos(x, y).type == self.getGemByPos(x, y+1).type == self.getGemByPos(x, y+2).type:
                            return [2, x, y]
            return [0, x, y]
        '''根据坐标获取对应位置的 对象'''
        def getGemByPos(self, x, y):
            return self.all_lexs[x][y]
        '''交换 '''
        def swapGem(self, lex1_pos, lex2_pos):
            margin = lex1_pos[0] - lex2_pos[0] + lex1_pos[1] - lex2_pos[1]
            if abs(margin) != 1:
                return False
            lex1 = self.getGemByPos(*lex1_pos)
            lex2 = self.getGemByPos(*lex2_pos)
            if lex1_pos[0] - lex2_pos[0] == 1:
                lex1.direction = 'left'
                lex2.direction = 'right'
            elif lex1_pos[0] - lex2_pos[0] == -1:
                lex2.direction = 'left'
                lex1.direction = 'right'
            elif lex1_pos[1] - lex2_pos[1] == 1:
                lex1.direction = 'up'
                lex2.direction = 'down'
            elif lex1_pos[1] - lex2_pos[1] == -1:
                lex2.direction = 'up'
                lex1.direction = 'down'
            lex1.target_x = lex2.rect.left
            lex1.target_y = lex2.rect.top
            lex1.fixed = False
            lex2.target_x = lex1.rect.left
            lex2.target_y = lex1.rect.top
            lex2.fixed = False
            self.all_lexs[lex2_pos[0]][lex2_pos[1]] = lex1
            self.all_lexs[lex1_pos[0]][lex1_pos[1]] = lex2
            return True
        '''info'''
        def __repr__(self):
            return self.info

    四、如何启动游戏

    1、开发工具

    如果你有配置了工具的环境VScode、sublimeText、notepad+、pycharm什么的,可以直接在工具中,运行游戏。

    如果没配置,可以使用命令启动。

    2、命令行

    【两种方法获取完整源码】

    1、资源下载:【pygame开发实战开发30例 完整源码】

    https://download.csdn.net/download/weixin_42350212/15836285

    2、订阅专栏:【获取完整源码+教程】

    一起来学pygame吧 游戏开发30例(二)——塔防游戏

    一起来学pygame吧 游戏开发30例(四)——俄罗斯方块小游戏

    推荐阅读

    python实战

    【python实战】前女友婚礼,python破解婚礼现场的WIFI,把名称改成了

    【python实战】前女友发来加密的 “520快乐.pdf“,我用python破解开之后,却发现

    【python实战】昨晚,我用python帮隔壁小姐姐P证件照 自拍,然后发现...

    【python实战】女友半夜加班发自拍 python男友用30行代码发现惊天秘密

    【python实战】python你TM太皮了——区区30行代码就能记录键盘的一举一动

    python实战】女神相册密码忘记了,我只用Python写了20行代码~~~

    pygame系列文章【订阅专栏,获取完整源码】

    一起来学pygame吧 游戏开发30例(二)——塔防游戏

    一起来学pygame吧 游戏开发30例(四)——俄罗斯方块小游戏

    渗透测试实战专栏

    Windows AD/Exchange管理专栏

    Linux高性能服务器搭建 

    PowerShell自动化专栏

    CSDN官方学习推荐 ↓ ↓ ↓

    CSDN出的Python全栈知识图谱,太强了,推荐给大家!

     ​

    展开全文
  • Python开发接水果小游戏

    万次阅读 多人点赞 2016-03-13 19:32:22
    现在我们就来使用它完成一个极其简单的小游戏:接水果。游戏操作说明:点击屏幕左右两边或者使用键盘方向键控制人物移动,使人物与水果接触得分,碰到非水果的物品,如碎玻璃,就会game over。接下来是详尽的开发...

    我研发的Python游戏引擎Pylash已经更新到1.4了。现在我们就来使用它完成一个极其简单的小游戏:接水果。以下是游戏截图:

    接水果 游戏截图

    游戏操作说明:点击屏幕左右两边或者使用键盘方向键控制人物移动,使人物与水果接触得分,碰到非水果的物品,如碎玻璃,就会game over。

    接下来是详尽的开发过程,篇幅较长,请看官耐心阅读。

    Pylash项目地址

    由于本次开发用到了pylash,大家可以先去Github上对引擎进行了解。
    https://github.com/yuehaowang/pylash_engine

    创建项目

    首先在工作目录创建一个名为get_fruits的目录。然后到Github下载Pylash。引擎是基于Python3和PyQt4构建的,所以在使用前请确保你使用的是Python3并且安装了PyQt4。如果没有,可以在上述项目地址中找到他们的相关网页链接进行下载安装,安装和配置步骤都十分简单。这里不再赘述。

    下载完Pylash后,我们得到这样的目录结构:

    +- pylash_engine/
        |
        +- pylash/
        |
        +- demo/
        |
        +- examples/

    大家可以在demo/examples/两个目录下查看示例。本文的源代码可以在examples/get_fruits中找到。

    pylash目录就是引擎源代码。接下来把这个目录复制到我们创建的get_fruits目录下,再在get_fruits目录下创建一个images目录,用于储存图片。最后创建一个Main.py文件。这时,我们的get_fruits目录结构如下:

    +- get_fruits/
        |
        +- pylash/
        |
        +- images/
        |
        +- Main.py

    然后将引擎目录plash_engine/examples/get_fruits/images/下图片复制到项目目录get_fruits/images/下,用作游戏素材。

    images/目录 截图

    这样一来,我们的项目就创建好了,接下来只用往Main.py里填写代码,然后运行即可。

    编写Hello World小程序

    用代码编辑器(推荐Sublime Text)打开Main.py文件,写入以下代码:

    # !/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    from pylash.utils import init, addChild
    from pylash.text import TextField
    
    def main():
        # 创建文本显示对象
        txt = TextField()
        # 设置文本内容
        txt.text = "Hello World"
        # 设置文本颜色
        txt.textColor = "red"
        # 设置文本位置
        txt.x = 50
        txt.y = 100
        # 设置文本字体大小
        txt.size = 50
        # 将文本对象加入到最底层
        addChild(txt)
    
    # 初始化窗口,参数:界面刷新时间(单位:毫秒),窗口标题,窗口宽度,窗口高度,初始化完毕后回调函数
    init(1000 / 60, "Hello World", 800, 600, main)

    运行Main.py,如果得到了如下图所示的界面,说明程序正常运转起来了。

    Hello World 演示截图

    大家可以结合注释初步认识Pylash。熟悉flash的同学不难发现,TextField就是flash里显示文本的类,而且用法十分相近。
    我们从代码的第4行看起,这里我们引入了pylash中的一些函数和类。pylash提供了很多模块,大家可以到这里查看它们的简介。
    再往下看,我们会发现,pylash提供了一个用于显示文本的类,通过设置这个类的不同属性来设定文本样式。最后使用addChild将文本显示对象加入到界面中。我们可以把游戏看作分为很多层:地图层、人物层、UI层……,通过分层我们就能实现层次化显示效果。比如人物一直是在地图上方显示的,那么人物层就在地图层上方。addChild函数就是把一个显示对象加到最底层。
    最后,我们使用init函数初始化窗口。

    Pylash提供了许多基础显示对象,除了TextField文本显示类,还有Bitmap图片显示类,Sprite精灵类等。下文会提及。

    编写游戏

    有了上述对pylash的大致了解,我们就可以开始编写游戏了。首先,删除第四行以后所有代码。

    引入所需

    首先引入我们所需的所有类和函数,修改Main.py

    from pylash.utils import stage, init, addChild, KeyCode
    from pylash.system import LoadManage
    from pylash.display import Sprite, BitmapData, Bitmap, FPS
    from pylash.text import TextField, TextFormatWeight
    from pylash.events import MouseEvent, Event, KeyboardEvent
    from pylash.ui import LoadingSample1

    这些类和函数在下面的代码中都会被用到。由于我是提前写好了游戏,所以在这里把这部分代码一块儿贴出来了,大家使用的时候可以根据自己使用情况,每用一个引入一个。

    全局变量

    游戏中需要用到一些全局变量,大家可以先浏览一遍,不同知道它们是干什么的,后文会用到它们:

    dataList = {}
    
    stageLayer = None
    player = None
    itemLayer = None
    scoreTxt = None
    addItemSpeed = 40
    addItemSpeedIndex = 0
    score = 0
    keyboardEnabled = False

    加载资源

    我们的游戏中要用到图片,所以要提前加载图片(存储于images/目录下)。加载图片我们用到LoadManage静态类和LoadingSample1进度条类(还有LoadingSample2LoadingSample3这两款不同样式的进度条。或者大家深入学习后,可以自己写一个进度条类)。修改main函数:

    def main():
        # 资源列表,一个list对象,格式:{"name" : 资源名称, "path" : 资源路径}
        loadList = [
            {"name" : "player", "path" : "./images/player.png"},
            {"name" : "bg", "path" : "./images/bg.jpg"},
            {"name" : "item0", "path" : "./images/item0.png"},
            {"name" : "item1", "path" : "./images/item1.png"},
            {"name" : "item2", "path" : "./images/item2.png"},
            {"name" : "item3", "path" : "./images/item3.png"},
            {"name" : "item4", "path" : "./images/item4.png"},
            {"name" : "item5", "path" : "./images/item5.png"},
            {"name" : "item6", "path" : "./images/item6.png"},
            {"name" : "item7", "path" : "./images/item7.png"}
        ]
    
        # 创建进度条
        loadingPage = LoadingSample1()
        addChild(loadingPage)
    
        # 加载完成后调用的函数,接受一个参数,该参数是一个dict对象,通过result[资源名称]来获取加载完成的资源
        def loadComplete(result):
            # 调用remove方法从界面上移除自身
            loadingPage.remove()
    
            # 调用初始化游戏函数
            gameInit(result)
    
        # 加载文件,参数:资源列表,每加载完一个资源回调函数(多用于显示进度),加载完所有资源回调函数
        LoadManage.load(loadList, loadingPage.setProgress, loadComplete)

    上述代码含有详细注释,理解起来应该不算困难。可以看到,我们使用LoadManage.load实现加载。LoadingSample1.setProgress用于设置显示进度。

    创建开始界面

    我们在main函数中调用了gameInit函数,所以添加该函数:

    def gameInit(result):
        global dataList, stageLayer
    
        # 保存加载完成的资源,这样一来,就可以使用dataList[资源名称]来获取加载完成的资源
        dataList = result
    
        # 创建舞台层
        stageLayer = Sprite()
        addChild(stageLayer)
    
        # 加入FPS,方便查看游戏效率
        fps = FPS()
        addChild(fps)
    
        # 加入背景图片
        bg = Bitmap(BitmapData(dataList["bg"]))
        stageLayer.addChild(bg)
    
        # 加入文本
        titleTxt = TextField()
        titleTxt.text = "Get Furit"
        titleTxt.size = 70
        titleTxt.textColor = "red"
        titleTxt.x = (stage.width - titleTxt.width) / 2
        titleTxt.y = 100
        stageLayer.addChild(titleTxt)
    
        hintTxt = TextField()
        hintTxt.text = "Tap to Start the Game!~"
        hintTxt.textColor = "red"
        hintTxt.size = 40
        hintTxt.x = (stage.width - hintTxt.width) / 2
        hintTxt.y = 300
        stageLayer.addChild(hintTxt)
    
        engineTxt = TextField()
        engineTxt.text = "- Powered by Pylash -"
        engineTxt.textColor = "red"
        engineTxt.size = 20
        engineTxt.weight = TextFormatWeight.BOLD
        engineTxt.italic = True
        engineTxt.x = (stage.width - engineTxt.width) / 2
        engineTxt.y = 500
        stageLayer.addChild(engineTxt)
    
        # 加入鼠标点击事件:点击舞台层后,开始游戏
        stageLayer.addEventListener(MouseEvent.MOUSE_UP, startGame)
    
        # 加入键盘事件:用于控制游戏中的人物
        stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDown)
        stage.addEventListener(KeyboardEvent.KEY_UP, keyUp)
    
    def startGame(e):
        print("start game")
    
    def keyDown(e):
        print("key down")
    
    def keyUp(e):
        print("key up")

    上述代码中,我们需要突破以下几个难点:

    1. Sprite精灵类。Sprite是一个精灵类。可是什么是精灵?其实你可以把它理解为一个层。它拥有addChild方法,用于把显示对象加到自身这个层上(和全局的addChild函数类似)。当然Sprite不只是有层的功能,不过你姑且把它看作一个层吧。

    2. BitmapBitmapData类的使用。Bitmap在上文中提到是一个用于显示图片的类。和TextField一样,使用addChild将它加入界面。BitmapData类是用于储存图像数据的,它接收的参数就是加载完成的图片资源。将他作为参数传给Bitmap类的构造器,就能创建出图片。BitmapData还可以进行像素操作,不过这是较高级的功能,目前不用了解。

    3. 事件。在pylash中,使用addEventListener统一接口加入事件,该方法参数:事件类型,事件监听器(即事件回调函数)。什么是事件呢?类似于一个信号,这个信号在某种情况下被发送后,指定的信号监听器就会被触发。这里添加鼠标事件的addEventListener是在EventDispatcher中定义的,DisplayObject类继承自EventDispatcher,所以继承自DisplayObject的所有类,都能加入事件。不过只有Sprite才有触发鼠标事件的能力。所以我们给stageLayer(舞台层,一个Sprite对象)加入了鼠标点击事件(MouseEvent.MOUSE_UP)。对应addEventListener方法的有removeEventListener(移除事件,参数相同)。鼠标事件除了MouseEvent.MOUSE_UP(鼠标弹起),还有MouseEvent.MOUSE_DOWN(鼠标按下),MouseEvent.MOUSE_MOVE(鼠标移动),MouseEvent.MOUSE_OUT(鼠标移出)等事件。后文会用到一些。事件的监听器是一个函数,startGamekeyDownkeyUp它们都是事件监听器。监听器在事件触发时被调用,并接受一个事件数据参数(通常写为e),通过这个参数可以获取事件的一些信息,如鼠标事件的监听器可以通过该参数获取鼠标位置。

    4. stage全局类。这里的stage是一个全局类,用于管理整个窗口,比如设置窗口刷新速度、获取窗口尺寸(stage.width,stage.height),有点类似于JavaScript里的window。键盘事件总不能加到某个对象上吧,所以stage还能加入键盘事件。加入键盘事件同样使用addEventListener这个的统一接口。

    最后加入init函数初始化窗口:

    init(1000 / 60, "Get Fruits", 800, 600, main)

    init函数中,值得注意的是第一个参数,上文代码的注释中解释的是“界面刷新时间”,也就是说我们的界面是在不断刷新重绘的。这个参数就是用来决定刷新的时间。参数值越小,刷新得越快,游戏越流畅,不过也不用设置得太小,太小了话,刷新速度过快,设备会跟不上这个节奏的。玩过游戏的朋友可以这么理解这个参数,用1000除以这个参数,得到的就是FPS。

    运行Main.py,得到如下界面:

    接水果开始界面 截图

    可以看到,我们的界面上有图片也有文本。点击界面输出“start game”,按下键盘输出“key down”,释放键盘输出“key up”。这样一来,我们就成功地添加了显示对象和鼠标&键盘事件。

    开始游戏

    舞台层鼠标点击事件的监听器是startGame函数,也就是说,我们点击开始界面就开始游戏。修改startGame函数:

    def startGame(e):
        global player, itemLayer, scoreTxt, addItemSpeedIndex, score, keyboardEnabled
    
        # 初始一些全局变量
        addItemSpeedIndex = 0
        score = 0
    
        keyboardEnabled = True
    
        # 清空舞台层和舞台事件
        stageLayer.removeAllChildren()
        stageLayer.removeAllEventListeners()
    
        # 加入背景
        bg = Bitmap(BitmapData(dataList["bg"]))
        stageLayer.addChild(bg)
    
        # 创建角色
        player = Player(dataList["player"])
        player.x = (stage.width - player.width) / 2
        player.y = 450
        stageLayer.addChild(player)
    
        # 创建下落物品层
        itemLayer = Sprite()
        stageLayer.addChild(itemLayer)
        # 将人物对象保存到itemLayer中,用于检测碰撞
        itemLayer.hitTarget = player
    
        # 加入分数文本
        scoreTxt = TextField()
        scoreTxt.text = "Score: 0"
        scoreTxt.textColor = "red"
        scoreTxt.size = 30
        scoreTxt.x = scoreTxt.y = 30
        scoreTxt.weight = TextFormatWeight.BOLDER
        stageLayer.addChild(scoreTxt)
    
        # 加入事件
        stageLayer.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown)
        stageLayer.addEventListener(MouseEvent.MOUSE_UP, onMouseUp)
        stageLayer.addEventListener(Event.ENTER_FRAME, loop)
    
    def onMouseDown(e):
        print("mouse down")
    
    def onMouseUp(e):
        print("mouse up")
    
    def loop(e):
        print("loop")

    对应addChildSprite提供了removeChild方法用于移除显示对象。除此之外还有removeAllChildren移除所有对象方法。removeAllEventListeners顾名思义就是移除所有事件。上面的代码会让人一头雾水,同样的,我们需要突破以下难关:

    1. 全局变量。addItemSpeedIndex是用于控制添加下落物品的时间间隔,后文会提及。score是保存分数的变量。由于游戏开始后,这些变量要回到初始值,所以在startGame函数中添加了这些代码来完成这项任务。keyboardEnabled = True这行代码是用于打开键盘事件,键盘事件是加到stage对象上的(见上文),但是是用于操作游戏中主角的,所以只有在游戏开始后才有用,所以加入keyboardEnabled变量作为能否使用键盘的开关,后文修改键盘事件监听器时会用到它。

    2. Player类。这个类是我们要自己创建的人物类,后文会展示其代码。

    3. 时间轴事件ENTER_FRAME。我们了解了鼠标事件,认识MouseEvent.MOUSE_DOWNMouseEvent.MOUSE_UP,可是Event.ENTER_FRAME是什么东西-_-#?这个事件就是时间轴事件。时间轴事件类似于一个计时器。这个事件的监听器每隔段事件就会触发。事件触发的时间间隔取决于init函数的第一个参数。

    运行代码,点击开始界面开始游戏,你可以发现控制台在不停地输出“loop”,代表时间轴事件运转了。

    Player人物类

    上文提到了这个类,在写这个类之前,我们重新在get_fruits/目录下创建一个名为Player.py的python文件。创建完成后,打开这个文件,加入以下代码:

    from pylash.utils import stage
    from pylash.display import Sprite, Animation, BitmapData
    
    # 创建Player类,并使其继承自Sprite类
    class Player(Sprite):
        def __init__(self, playerImage):
            super(Player, self).__init__()
    
            # 移动方向,【right向右,left向左,None不移动】
            self.direction = None
            # 移动速度
            self.step = 5
    
            # 创建图片数据
            bmpd = BitmapData(playerImage)
            # 创建动画帧列表
            frames = Animation.divideUniformSizeFrames(bmpd.width, bmpd.height, 4, 4)
    
            # 创建动画
            self.animation = Animation(bmpd, frames)
            # 设置动画播放速度
            self.animation.speed = 5
            # 播放动画
            self.animation.play()
            # 将动画加入界面
            self.addChild(self.animation)
    
        def loop(self):
            # 向右移动
            if self.direction == "right":
                self.x += self.step
                # 播放向右移动时的动画
                self.animation.currentRow = 2
            # 向左移动
            elif self.direction == "left":
                self.x -= self.step
                # 播放向左移动时的动画
                self.animation.currentRow = 1
            # 不移动
            else:
                # 播放不移动时的动画
                self.animation.currentRow = 0
    
            # 限制人物位置
            if self.x < 0:
                self.x = 0
            elif self.x > stage.width - self.width:
                self.x = stage.width - self.width

    这个Player类需要继承自Sprite,使其成为一个显示对象。也就是说继承自Sprite后,就可以被addChild到界面上去了,并可以显示出来。除此之外,还可以使用Player对象的addChild方法来向人物类添加显示元件。Player类的构造器接收一个人物图片参数。
    代码中用到了Animation类。它由pylash提供,用于创建简单的基于图片的动画。Animation构造器接收两个参数:动画位图数据,动画帧列表。

    一般而言,我们的动画用的图片都是这样的:

    动画图片

    所以我们播放动画的时候,只需要控制位图显示区域的大小和位置就能实现播放动画。类似于放映机放映电影。如下两幅图所示,显示区域就是空白部分,不被显示的区域就是被半透明黑色幕布遮住的部分。动画中的每个小图叫帧,移动显示区域就实现切换帧,达到播放动画的目的。

    动画播放示例之一

    动画播放示例之二

    代码中的Animation.divideUniformSizeFrames(bmpd.width, bmpd.height, 4, 4)就是用于获取每帧的位置和大小。divideUniformSizeFrames静态方法接收四个参数:动画图片宽度,动画图片高度,动画列数,动画行数。该方法只适合得到每帧分布和大小都是均匀的帧列表。

    Animation有个speed属性,用于控制动画播放速度。如果不设置这个属性,动画中每帧的切换速度就和init中设置的刷新速度一样。设置后,切换速度变为speed * 刷新速度。

    Animation类默认只播放第一排第一行动画,要指定动画播放的位置,需要设置currentRowcurrentColumn属性来控制播放的行和列。

    下落物品类:Item

    这个类在前面没出现过,不过我们先写好放在这里,下文要用到。同样的,新建一个名为Item.py的文件,打开它,写入代码:

    from pylash.utils import stage
    from pylash.display import Sprite, Bitmap, BitmapData
    
    class Item(Sprite):
        # 定义自定义事件
        EVENT_ADD_SCORE = "event_add_score"
        EVENT_GAME_OVER = "event_game_over"
    
        def __init__(self, image):
            super(Item, self).__init__()
    
            bmp = Bitmap(BitmapData(image))
            self.addChild(bmp)
    
            self.index = 0
            self.y = -bmp.height / 2
    
        def loop(self):
            player = None
    
            # 获取人物对象
            if self.parent:
                player = self.parent.hitTarget
    
            if player is None:
                return
    
            # 向下移动
            self.y += 5
    
            # 碰撞检测
            if (abs(self.x + self.width / 2 - player.x - player.width / 2) <= (self.width + player.width) / 2) and (abs(self.y + self.height / 2 - player.y - player.height / 2) <= (self.height + player.height) / 2):
                # 如果index <= 3,代表物品是水果
                if self.index <= 3:
                    # 触发自定义事件:加分事件
                    self.dispatchEvent(Item.EVENT_ADD_SCORE)
    
                    self.remove()
                # 如果物品是非水果
                else:
                    # 触发自定义事件:游戏结束
                    self.dispatchEvent(Item.EVENT_GAME_OVER)
    
            # 移除自身,当自身移出了屏幕
            if self.y >= stage.height:
                self.remove()

    Item类的构造器和Player构造器一样,接受一个图片参数。
    我们这里用到了一个比较高级的功能:自定义事件。自定的事件可以是一个字符串,作为该事件的标识。使用dispatchEvent方法触发事件。dispatchEvent方法在EventDispatcher中定义,通过继承使Item也能使用这个方法。
    值得关注的还有检测碰撞部分。目前处理简单的矩形碰撞即可。首先来看张图:

    矩形碰撞检测演示图

    如果要横向判断碰撞的话,判断(x1-x2)的绝对值是否小于或者等于w1/2+w2/2,如果是则横向则有碰撞。纵向判断是一样的,判断(y1-y2)的绝对值是否小于或等于h1/2+h2/2即可。

    修改事件监听器

    上面的代码中我们虽然添加了事件,但是没有添加有效的事件监听器,所以修改这些函数:

    def keyDown(e):
        global player
    
        if not keyboardEnabled or not player:
            return
    
        if e.keyCode == KeyCode.KEY_RIGHT:
            player.direction = "right"
        elif e.keyCode == KeyCode.KEY_LEFT:
            player.direction = "left"
    
    def keyUp(e):
        global player
    
        if not keyboardEnabled or not player:
            return
    
        player.direction = None
    
    def onMouseDown(e):
        global player
    
        if e.offsetX > (stage.width / 2):
            player.direction = "right"
        else:
            player.direction = "left"
    
    def onMouseUp(e):
        global player
    
        player.direction = None
    
    def loop(e):
        global player, itemLayer, addItemSpeed, addItemSpeedIndex
    
        player.loop()
    
        for o in itemLayer.childList:
            o.loop()
    
        # 控制添加下落物品时间间隔
        if addItemSpeedIndex < addItemSpeed:
            addItemSpeedIndex += 1
    
            return
    
        addItemSpeedIndex = 0
    
        # 获得随机下落物品
        randomNum = random.randint(0, 7)
    
        # 加入下落物品
        item = Item(dataList["item" + str(randomNum)])
        item.index = randomNum
        item.x = int(random.randint(30, stage.width - 100))
        itemLayer.addChild(item)
        # 加入自定义的事件
        item.addEventListener(Item.EVENT_ADD_SCORE, addScore)
        item.addEventListener(Item.EVENT_GAME_OVER, gameOver)

    keyDownkeyUponMouseDownonMouseUp这四个监听器用于操作人物(player)。

    接下来看监听器loop。该函数中,首先调用了人物的loop方法(见Player类的loop)。我们在上文定义的itemLayer是一个Sprite对象,Sprite对象有一个childList属性,是一个list对象,保存了所有的子对象。所以我们通过遍历itemLayer的这个列表,获取每个下落物品,调用它们的loop方法。接下来使用addItemSpeedIndexaddItemSpeed两个全局变量控制加入下落物品的速度。接下来的代码就是来构造Item类创建下落物品。

    加分和Game Over

    我们给Item对象加入了自定义事件,分别触发addScoregameOver监听器,加入这两个监听器:

    def addScore(e):
        global score, scoreTxt
    
        score += 1
    
        scoreTxt.text = "Score: %s" % score
    
    def gameOver(e):
        global player, scoreTxt, stageLayer, keyboardEnabled
    
        keyboardEnabled = False
    
        stageLayer.removeAllEventListeners()
    
        scoreTxt.remove()
        player.animation.stop()
    
        resultTxt = TextField()
        resultTxt.text = "Final Score: %s" % score
        resultTxt.size = 40
        resultTxt.weight = TextFormatWeight.BOLD
        resultTxt.textColor = "orangered"
        resultTxt.x = (stage.width - resultTxt.width) / 2
        resultTxt.y = 250
        stageLayer.addChild(resultTxt)
    
        hintTxt = TextField()
        hintTxt.text = "Double Click to Restart"
        hintTxt.size = 35
        hintTxt.textColor = "red"
        hintTxt.x = (stage.width - hintTxt.width) / 2
        hintTxt.y = 320
        stageLayer.addChild(hintTxt)
    
        # 加入双击事件,点击后重新开始游戏
        stageLayer.addEventListener(MouseEvent.DOUBLE_CLICK, startGame)

    运行Main.py,开始游戏后,得到本文开篇图片所示效果。移动人物,接触下落的物品。如果碰到碎玻璃等非水果物品就会game over:

    接水果游戏Game Over 截图

    Ok,我们的接水果小游戏就完成了。可见使用python+pylash开发小游戏还是很方便的。

    源代码

    本文的源代码可以在引擎目录的examples/get_fruits中找到。或者到这里在线查看。

    文中有任何不妥之处或者读者有疑问的话,欢迎大家交流~


    欢迎大家继续关注我的博客

    转载请注明出处:Yorhom’s Game Box

    http://blog.csdn.net/yorhomwang

    展开全文
  • 最近发现很多人对python制作小游戏感兴趣,于是花了半天时间做了个塔防小游戏,在这里分享给大家,希望对大家有帮助。 让我们愉快地开始吧~ 效果图 ps: 封面和效果均为参考图,侵权删 开发工具 Python版本:3.6.4 ...

    往期回顾

    Python实现“小兔子和Bun”游戏

    Python实现八音符小游戏

    Python实现拼图小游戏

    Python实现滑雪小游戏

    Python实现经典90坦克大战

    Python实现FlappyBird的小游戏

    Python实恐龙跳一跳小游戏现

    导语

    最近发现很多人对python制作小游戏感兴趣,于是花了半天时间做了个塔防小游戏,在这里分享给大家,希望对大家有帮助。
    让我们愉快地开始吧~

    效果图

    图片仅供参考
    ps: 封面和效果均为参考图,侵权删

    开发工具

    Python版本:3.6.4

    相关模块:

    pygame模块;

    以及一些Python自带的模块。

    环境搭建

    安装Python并添加到环境变量,pip安装需要的相关模块即可。

    原理介绍

    游戏规则简介:

    玩家通过建造箭塔抵御敌人的进攻。

    每隔一段时间,将会有一波敌人从左上角的洞穴中诞生,并冲向右下角的城堡。玩家需要做的,则是通过建造箭塔射杀敌人,避免城堡受到敌人攻击,同时,每当你射杀一个敌人,将获得一定的金钱奖励。

    游戏失败:

    每有一个敌人冲进城堡,城堡的生命值下降一定的数值,当城堡的生命值为0时,则游戏失败。

    游戏胜利:

    随着时间的推移,敌人的实力会越来越强,数量也会越来越多,所以你是不可能胜利的,哈哈。

    游戏界面说明:

    图片

    T1-T3代表不同的箭塔类型,不同的箭塔类型具有不同的价格以及能力;

    XXX代表出售箭塔(半价);

    Pause代表暂停游戏;

    Quit代表退出游戏。

    玩家通过左键选中箭塔/出售箭塔标识,右键放弃当前选中的内容。鼠标中间箭用于控制箭塔射击的方向,否则箭塔将自由射击。

    选中箭塔后,将其移动到你认为合适的位置,点击鼠标左键即可在该位置建造一个箭塔(当然前提是你账户余额买得起箭塔,不然只能打怪攒钱了);选中出售箭塔后,将出售箭塔标识放在已建造的箭塔上,点击鼠标左键,即可出售选中的箭塔。

    逐步实现:

    Step1:明确游戏主逻辑

    游戏主逻辑应当是这样的:

    图片

    代码描述如下:

    图片

    Step2:实现游戏开始界面

    这里的要点在于当检测到鼠标移动到按钮上时,执行按钮变色操作,检测到鼠标点击按钮位置时,跳出游戏开始界面。主代码如下:

    图片

    Step3:实现游戏选择界面

    要点同步骤二,主代码如下:

    图片

    游戏难度定义在一个.json文件夹中,例如:

    图片

    Step4:实现游戏界面

    首先,将地图设计在.map文件中,不同的数字代表不同的地图元素,例如:

    图片

    这样就可以很方便地导入不同的地图:

    图片

    其次就是画工具栏:

    图片

    如此一来,游戏界面的雏形就出来了。接下来就是每隔一段时间产生一批敌人:

    图片

    通过按键检测和定义一些函数来实现用户与游戏的交互,例如造塔等操作。其中按键检测的代码如下:

    图片

    操作函数的定义如下:

    图片

    当然,当检测到暂停按钮被按下时,你需要将游戏切入暂停界面:

    图片

    其中按键闪烁的实现主要依靠每隔一小段时间显示一次按键实现,其它要点同步骤二。

    最后,就是让箭塔可以不停地射箭并且通过碰撞检测来判断箭是否射中了敌人(射中的话敌人生命值会下降,下降到0时敌人才会死掉),画出游戏界面中还存在着的所有元素:

    图片

    当然,如果城堡死掉了,那么游戏也就结束了:

    图片

    Step5:实现结束界面

    要点同步骤二,主代码如下:

    图片

    文章到这里就结束了,感谢你的观看,Python24个小游戏系列,下篇文章分享接水果和金币的小游戏

    为了感谢读者们,我想把我最近收藏的一些编程干货分享给大家,回馈每一个读者,希望能帮到你们。

    干货主要有:

    ① 2000多本Python电子书(主流和经典的书籍应该都有了)

    ② Python标准库资料(最全中文版)

    ③ 项目源码(四五十个有趣且经典的练手项目及源码)

    ④ Python基础入门、爬虫、web开发、大数据分析方面的视频(适合小白学习)

    ⑤ Python学习路线图(告别不入流的学习)

    ⑥ 两天的Python爬虫训练营直播权限

    资源

    All done~分享不易记得给波点赞+评论支持下~详见个人简介或者私信获取完整源代码。。

    展开全文
  • Python实现八音符小游戏 Python实现拼图小游戏 Python实现滑雪小游戏 Python实现经典90坦克大战 Python实现FlappyBird的小游戏 Python实恐龙跳一跳小游戏Python实现塔防小游戏 Python实现接水果和金币小游戏 ...

    往期回顾

    Python实现“小兔子和Bun”游戏

    Python实现八音符小游戏

    Python实现拼图小游戏

    Python实现滑雪小游戏

    Python实现经典90坦克大战

    Python实现FlappyBird的小游戏

    Python实恐龙跳一跳小游戏现

    Python实现塔防小游戏

    Python实现接水果和金币小游戏

    Python实现简易版飞机大战小游戏

    前言:

    上班无聊用pyqt5写的写了个俄罗斯方块的小游戏,让我们愉快地开始吧~

    效果

    image.png

    开发工具

    Python版本: 3.6.4

    相关模块:

    pyqt5模块;

    以及一些Python自带的模块。

    环境搭建

    安装Python并添加到环境变量,pip安装需要的相关模块即可。

    原理简介

    游戏规则:

    由小方块组成的不同形状的板块陆续从屏幕上方落下来,玩家通过调整板块的位置和方向,使它们在屏幕底部拼出完整的一条或几条。这些完整的横条会随即消失,给新落下来的板块腾出空间,与此同时,玩家得到分数奖励。没有被消除掉的方块不断堆积起来,一旦堆到屏幕顶端,玩家便告输,游戏结束。(ps百度百科)

    控制方式:

    ←→键控制位置,↑键控制方向,空格键使板块快速下落到底部,P键暂停游戏。

    逐步实现:

    Step1:定义一个俄罗斯方块

    首先,我们来定义一个俄罗斯方块类,其具体作用为利用小方块组成不同形状的板块:

    为了便于获取某个俄罗斯方块内各个小方块的位置信息,我们再来定义一些获取其位置信息的类内方法,如下图所示:

    image.gif

    Step2:制作游戏主界面

    我们将游戏进行中的数据记录与数据处理部分定义在内部板块类中,将游戏数据可视化定义在外部板块类中,具体实现如下。

    (1)定义一个内部板块类:

    图片

    我们可以在内部板块中操作当前可控制的俄罗斯方块向左/向右/向下(向下运动由系统自动操作)移动和快速坠落:

    图片

    当然移动的时候要实时地判断当前可控制的俄罗斯方块是否已经“着陆”:

    图片

    “着陆”后将当前可控制的俄罗斯方块并入到最下方那些不可再控制的俄罗斯方块中,并移除整行都有小方块的那些行(即完整的横条):

    图片

    然后创建新的俄罗斯方块:

    图片

    循环往复。

    (2)定义一个外部板块类

    图片

    其作用就是将内部板块类的实时数据信息用pyqt5模块实时地显示出来。

    Step3:画个游戏侧面板

    我们在游戏主界面右侧画个侧面板来实时地显示下一个俄罗斯方块的形状:

    图片

    Step4:实现游戏主循环

    定义俄罗斯方块游戏类并初始化:

    图片

    其中游戏开始和游戏暂停的定义如下:

    图片

    按键监听定义如下:

    图片

    然后调用执行它就OK啦:

    图片

    文章到这里就结束了,感谢你的观看,Python24个小游戏系列,下篇文章分享推箱子小游戏

    为了感谢读者们,我想把我最近收藏的一些编程干货分享给大家,回馈每一个读者,希望能帮到你们。

    干货主要有:

    ① 2000多本Python电子书(主流和经典的书籍应该都有了)

    ② Python标准库资料(最全中文版)

    ③ 项目源码(四五十个有趣且经典的练手项目及源码)

    ④ Python基础入门、爬虫、web开发、大数据分析方面的视频(适合小白学习)

    ⑤ Python学习路线图(告别不入流的学习)

    ⑥ 两天的Python爬虫训练营直播权限

    All done~点赞支持下~详见个人简介或者私信获取完整源代码。。

    展开全文
  • Python实现八音符小游戏 Python实现拼图小游戏 Python实现滑雪小游戏 Python实现经典90坦克大战 Python实现FlappyBird的小游戏 Python实恐龙跳一跳小游戏Python实现塔防小游戏 Python实现接水果和金币小游戏 ...
  • PythonPython小游戏-贪吃蛇大冒险

    万次阅读 多人点赞 2021-04-17 17:26:59
    一、前言 距上次更新博客,又过去很长时间了,感觉再不更新一下,自己写博客的习惯...二、贪吃蛇大冒险小游戏 一、游戏简介 1.1游戏操作及游戏规则 (1)游戏开始后,通过键盘上下左右键控制贪吃蛇移动寻找食物; (2
  • Python实现八音符小游戏 Python实现拼图小游戏 Python实现滑雪小游戏 Python实现经典90坦克大战 Python实现FlappyBird的小游戏 Python实恐龙跳一跳小游戏Python实现塔防小游戏 Python实现接水果和金币小游戏 ...
  • Python实现经典吃豆豆小游戏 Python实现“小兔子和Bun”游戏 Python实现八音符小游戏 Python实现拼图小游戏 Python实现滑雪小游戏 Python实现经典90坦克大战 Python实现FlappyBird的小游戏 Python实恐龙跳一跳小游戏...
  • Python实现八音符小游戏 Python实现拼图小游戏 Python实现滑雪小游戏 Python实现经典90坦克大战 Python实现FlappyBird的小游戏 Python实恐龙跳一跳小游戏Python实现塔防小游戏 Python实现接水果和金币小游戏 前言...
  • python小游戏开发——简单弹球游戏

    千次阅读 多人点赞 2019-04-25 11:09:28
    本案例采用 python 实现了一个简单的弹球游戏。该游戏在一个单独的图形窗口中运行。游戏初始化后,在游戏窗口点击鼠标左键开始游戏。玩家通过控制键盘的左、右方向键来控制弹板的移动,弹球和弹板撞击一次,得一分,...
  • python小游戏开发合集

    千次阅读 2020-04-27 11:26:13
    ") 5、提升彩票小游戏 注意: 1、对猜拳小游戏进行的提升 2、需要一定的基础、如有疑问可私信或百度 import random t1="开始游戏" t2="结束游戏" print(t1.center(50,"*")) data1=[] money=int(input("输入投入的...
  • Python实现八音符小游戏 Python实现拼图小游戏 Python实现滑雪小游戏 Python实现经典90坦克大战 Python实现FlappyBird的小游戏 前言: 本期我们将仿制一个Chrome浏览器里隐藏多年的彩蛋小游戏,即"恐龙跳一跳"(当然...
  • python小游戏开发——井字棋

    千次阅读 多人点赞 2019-04-25 11:00:51
    本案例采用 python 实现了一个简单的井字棋游戏。该游戏在控制台界面中进行,有游戏提示。游戏棋盘为 3 X 3 的九宫格样式,每个棋格与数字键盘上的 1 - 9 数字键一一对应,可通过输入数字来选择落棋位置和落子。游戏...
  • 游戏开发是程序开发的一种。程序就是指令,让计算机明白要做什么的指令。编写指令,让计算机能够显示游戏界面,角色,与我们参与者交互,就是我们要学习的内容。编写游戏有很多种语言工具,python是其中之一。 1.1...
  • python开发华容道小游戏

    千次阅读 2018-03-31 16:45:04
    """对每个方格,创建方块对象""" # 随机打乱列表 random.shuffle(all_coordinates) # 填充并且拼接图版 for i in range(ROWS): for j in range(COLS): idx = i * ROWS + j square_center = all_...
  • python3小游戏(1):吃苹果小游戏

    万次阅读 多人点赞 2018-05-18 17:41:01
    python小白群交流:861480019 注意,申请入群时必须备注“不...1.本文是基于pygame库开发小游戏,主要功能有: (1).可以通过键盘的上下左右四个键来控制主人公小刘的位置(同是移动方向不同,小刘的姿势也不同)...
  • 如何用Python开发拼图游戏

    千次阅读 2018-11-25 10:12:22
    编用了91步才完成这拼图...你会用多少步呢? 二、 游戏的玩法 思路:先设置一个棋盘,棋盘里面有我们的图像,在图像里面我们有一个个的小方块,通过这些错乱的小方块拼接图板。拼接的过程就是鼠标点击事件的一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,407
精华内容 25,762
关键字:

python开发小游戏

python 订阅