精华内容
下载资源
问答
  • 主要为大家详细介绍了python pygame实现2048游戏,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • PyGame2048小游戏

    2020-12-11 15:43:26
    这是一个使用python语言编写的小游戏,主要用的是pygame库,欢迎有兴趣的下载,一起学习。不知道有没有人能玩到2048.
  • Pygame2048算法总结

    2018-11-07 15:09:29
    游戏2048的中心思想: 根据键盘事件获得数组中的每一列或每一行 对获得的列或行进行精简操作 所谓精简操作就是将列表中每个元素想左侧合并 合并规则: 若紧邻的2个元素相等则叠加 列表中为0的元素被剔除 ...
    '''
        游戏2048的中心思想:
        根据键盘事件获得数组中的每一列或每一行
        对获得的列或行进行精简操作
        所谓精简操作就是将列表中每个元素想左侧合并
        合并规则:
            若紧邻的2个元素相等则叠加
            列表中为0的元素被剔除
        最终效果:
        若传入的数组为L,长度为len(L)
        则将精简后的列表末尾补0直至长度变回len(L)
    '''
    
    #   精简逻辑,出入列表和指定位置索引
    def jd1(l_, j):
        #   使用while使得循环中的list在不断发生变化(for循环达不到这个效果)
        while j < len(l_) - 1:
            #   索引位置数值和索引位置下一个数值都不为0
            if l_[j] * l_[j + 1] > 0:
                #   索引位置数值 == 索引位置下一个数值
                if l_[j] == l_[j + 1]:
                    if j == 0:
                        #   累加至索引位置,并剔除索引位置下一个数值
                        l_[j] += l_[j + 1]
                        del l_[j + 1]
                    else:
                        #   累加至索引位置,并剔除索引位置下一个数值
                        l_[j] += l_[j + 1]
                        del l_[j + 1]
                        #   累加后,索引位置数值需要同索引位置上一个数值比较是否相等,这里递归
                        jd1(l_, j - 1)
                #   索引位置数值 != 索引位置下一个数值
                else:
                    #   退出循环,只需要检查当前索引就可以,不相等就不需要再判断了
                    break
            #   索引位置数值和索引位置下一个数值有一个为0(默认为不会出现小于0的情况)
            else:
                #   索引位置数值 == 0,替换、剔除
                if l_[j] == 0:
                    l_[j] = l_[j + 1]
                    del l_[j + 1]
                #   索引位置下一个数值 == 0,无需替换,直接剔除
                elif l_[j + 1] == 0:
                    del l_[j + 1]
        return l_
    
    def reduce(l_):
        l_length = len(l_)
        i = 0
        #   对传入的列表的每个索引都进行精简,而且每次返回的都是一个新的列表,所以使用while
        while i < len(l_):
            l_ = jd1(l_, i)
            i += 1
        for j in range(l_length - len(l_)):
            l_.append(0)
        return l_
    
    l = [32, 16, 16, 4, 4, 4, 2]
    l = reduce(l)
    print(l)

     

    展开全文
  • pygame2048小游戏

    千次阅读 2019-01-09 17:07:12
    第一次写的pygame小游戏,欢迎评论。 直接贴图: 代码如下,注释详细(有... 2048小游戏 ''' import pygame,sys,random,numpy class MyGame(object): ''' 1.初始化函数 ''' def __init__(self): # 窗体 ...

    第一次写的pygame小游戏,欢迎评论。

    直接贴图:

    代码如下,注释详细(有个背景图片就不上传啦):

    '''
        2048小游戏
    '''
    import pygame,sys,random,numpy
    
    class MyGame(object):
    
        '''
           1.初始化函数
        '''
        def __init__(self):
            # 窗体
            self.screen = pygame.display.set_mode((460, 620),0,0)
            # 背景图
            self.back = pygame.image.load("2048.png")
            # 4行4列
            self.Size = 4
            # 每个块的长宽
            self.Block_WH = 100
            # 两个块之间的间隙
            self.Block_Space = 10
            # 初始化矩阵4*4的0矩阵
            self.matrix = numpy.zeros([self.Size,self.Size])
            # 设置计分器
            self.Score = 0
            # 数块颜色字典
            self.Block_Color = {
                0:(205,193,180),
                2:(255,255,220),
                4:(255,255,130),
                8:(255,255,0),
                16:(255,220,128),
                32:(255,220,0),
                64:(255,190,0),
                128:(255,160,0),
                256:(255,130,0),
                512:(255,100,0),
                1024:(255,70,0),
                2048:(255,40,0),
                4096:(255,10,0),
            }
            # 二维列表zerolist
            self.zerolist = []
            # 游戏结束标志
            self.flag = False
    
        '''
            5.初始化矩阵
        '''
        def initData(self,matrix = None,zerolist = None):
            # 若矩阵为空,则拷贝初始化矩阵
            if matrix is None:
                matrix = self.matrix.copy()
            # 若zerolist为空,则随机返回(x,y)位置,否则返回任意一个0元素位置
            a,b = self.getRandomLocal(zerolist)
            n = self.getNewNum()
            matrix[a][b] = n
            # 返回初始化任意位置为2或者4的矩阵
            return matrix
    
        # 5.1 获取要生成数字方块的位置
        def getRandomLocal(self,zerolist = None):
            # 5.1.1 若为空,随机生成某行某列
            if zerolist == None:
                a = random.randint(0,self.Size-1)
                b = random.randint(0,self.Size-1)
            # 5.1.2 若不为空,则从zerolist中随机抽取一个数字为0的列表坐标
            else:
                a,b = random.sample(zerolist,1)[0]
            return a,b
    
        # 5.2 随机返回新数字2或4
        def getNewNum(self):
            # 5.2.1 生成0和1之间的随机浮点数
            n = random.random()
            if n > 0.8:
                n = 4
            else:
                n = 2
            return n
    
    
        '''
           2.业务执行模块
        '''
        def action(self):
            # 2.1 循环所有监听时间
            for event in pygame.event.get():
                # 2.2 判断退出
                if event.type == pygame.QUIT:
                    sys.exit()
                # 2.3 判断键盘监听
                elif event.type == pygame.KEYDOWN:
                    # 2.4 判断按键,当游戏结束时,不可再按
                    if event.key == pygame.K_UP and self.flag == False:
                        self.matrix = self.upAction()
                    elif event.key == pygame.K_DOWN and self.flag == False:
                        self.matrix = self.downAction()
                    elif event.key == pygame.K_LEFT and self.flag == False:
                        self.matrix = self.leftAction()
                    elif event.key == pygame.K_RIGHT and self.flag == False:
                        self.matrix = self.rightAction()
                # 2.8 判断鼠标监听
                elif event.type == pygame.MOUSEBUTTONDOWN:
                    # 2.8.1 获取鼠标按下的位置
                    mouseX,mouseY = pygame.mouse.get_pos()
                    # 2.8.3 重新开始游戏
                    if 335 < mouseX < 430 and 95 < mouseY < 125:
                        # 2.8.4 重新初始化矩阵、分数、结束标志
                        self.matrix = numpy.zeros([self.Size,self.Size])
                        self.matrix = myGame.initData()
                        self.Score = 0
                        self.flag = False
                # 2.9 判断游戏是否结束
                # 2.9.1 当方块中的数字最大为2048时,游戏成功
                if self.matrix.max() == 256:
                    self.flag = True
                # 2.9.2 当方块中的数字都填满时,且移动方块后界面不会修改,则游戏失败
                elif self.matrix.min() != 0:
                    self.flag = self.gameOver()
    
        # 2.4.1 向上操作
        def upAction(self):
            print(self.matrix)
            matrix = self.matrix.T
            print(matrix)
            newmatrix = self.toSequence(matrix)
            print(newmatrix)
            return newmatrix.T
    
        # 2.4.2 向下操作
        def downAction(self):
            # print(self.matrix)
            matrix = self.matrix[::-1].T
            # print(matrix)
            newmatrix = self.toSequence(matrix)
            # print(newmatrix)
            return newmatrix.T[::-1]
    
        # 2.4.3 向左操作
        def leftAction(self):
            # print(self.matrix)
            newmatrix = self.toSequence(self.matrix)
            # print(newmatrix)
            return newmatrix
    
        # 2.4.4 向右操作
        def rightAction(self):
            # print(self.matrix)
            matrix = self.matrix[:,::-1]
            # print(matrix)
            newmatrix = self.toSequence(matrix)
            # print(newmatrix)
            return newmatrix[:,::-1]
    
        # 2.5 矩阵处理
        def toSequence(self,matrix):
            # 2.5.1 获得矩阵的行,列
            row,col = matrix.shape
            # 2.5.2 遍历矩阵
            for i in range(row):
                # 2.5.3 分别将每行矩阵中的0元素删除,从而实现了数字的移动
                newList = self.removeZero(list(matrix[i]))
                matrix[i] = newList
                # 2.5.4 在zerolist中添加0元素的位置,计算0的个数
                for k in range(self.Size-1,self.Size-newList.count(0)-1,-1):
                    self.zerolist.append((i,k))
            # 2.5.5 矩阵中有最小值0,才可以在0位置处添加随机数
            if matrix.min() == 0:
                self.initData(matrix,self.zerolist)
                # 列表清空
                self.zerolist = []
            return matrix
    
        # 2.6 删除0
        def removeZero(self,rowlist):
            while True:
                # 2.6.1 拷贝一份list
                mid = rowlist[:]
                try:
                    # 2.6.2 移除一个0,在最后加上一个0
                    rowlist.remove(0)
                    rowlist.append(0)
                except:
                    pass
                # 2.6.3 若列表中没有0,退出循环
                if rowlist == mid:
                    break
            # 2.6.4 返回新列表,数据要进行修改,调用combineList()函数
            return self.combineList(rowlist)
    
        # 2.7 列表数字调整,相同相加
        def combineList(self,rowlist):
            start_num = 0
            end_num = self.Size-rowlist.count(0)-1
            # 2.7.1 循环依次比较列表中非0位置的数字
            while start_num < end_num:
                if rowlist[start_num] == rowlist[start_num+1]:
                    # 2.7.2 分数相同相加
                    rowlist[start_num] *= 2
                    # 2.7.3 每次返回累加的分数
                    self.Score += int(rowlist[start_num])
                    # 2.7.4 数字前移,末尾加0
                    rowlist[start_num+1:] = rowlist[start_num+2:]
                    rowlist.append(0)
                start_num += 1
            return rowlist
    
        # 2.9 游戏结束判断
        def gameOver(self):
            testmatrix = self.matrix.copy()
            a,b = testmatrix.shape
            for i in range(a):
                for j in range(b-1):
                    # 2.9.1 如果每行存在相邻两个数相同,则游戏没有结束
                    if testmatrix[i][j] == testmatrix[i][j+1]:
                        print('游戏没有结束')
                        return False
            for i in range(b):
                for j in range(a-1):
                    # 2.9.1 如果每列存在相邻两个数相同,则游戏没有结束
                    if testmatrix[j][i] == testmatrix[j+1][i]:
                        print('游戏没有结束')
                        return False
            print('游戏结束')
            return True
    
        '''
            3.图形图像绘制模块
        '''
        def paint(self):
            # 3.1 绘制背景图上部分
            self.screen.blit(self.back,(0,0))
            # 3.1.1 初始化字体样式
            pygame.font.init()
            # 3.1.2 设置系统字体样式 华文行楷
            font = pygame.font.SysFont("stxingkai",40)
            # 3.1.3 添加分数居中显示
            fontW,fontH = font.size(str(self.Score))
            self.screen.blit(font.render("%d"%self.Score,True,(238,253,60)),((460-fontW)/2+152,45))
            # 3.2 绘制背景图下部分
            # 3.2.1 获取矩阵行数和列数
            a,b = self.matrix.shape
            # 3.2.2 循环遍历,依次绘图
            for i in range(a):
                for j in range(b):
                    # 3.2.3 确定方块的初始位置
                    w = j * self.Block_WH + (j + 1) * self.Block_Space
                    h = i * self.Block_WH + (i + 1) * self.Block_Space
                    # 3.2.4 画出方块   参数:位置,颜色,绘图的起始位置,矩形长宽
                    pygame.draw.rect(self.screen,self.Block_Color[int(self.matrix[i][j])],(w+5,h+155,100,100))
                    # 3.2.5 若初始化方块内有数字,修改方块背景颜色,并添加数字
                    if self.matrix[i][j] != 0:
                        # 3.2.6 设置使用系统字体 华文行楷
                        font = pygame.font.SysFont("stxingkai",80)
                        # 3.2.7 矩阵元素为浮点型===>int()===>str()
                        #        获取数字的字体大小来确定绘图位置
                        fw,fh = font.size(str(int(self.matrix[i][j])))
                        self.screen.blit(font.render(str(int(self.matrix[i][j])),True,(4,145,249)), \
                                         (w+(100-fw)/2+5,h+(110-fh)/2+155))
            # 3.3 游戏结束判断
            if self.flag:
                # 3.3.1 初始化字体样式
                pygame.font.init()
                # 3.3.2 设置系统字体样式 宋体
                font = pygame.font.SysFont("simsunnsimsun",40)
                # 3.3.3 绘图
                Str = "游戏结束"
                self.screen.blit(font.render("%s" % Str,True,(251,15,2)),(170,360))
    
    
        '''
            4.主函数
        '''
        def menu(self):
            # 4.1 设置窗口标题
            pygame.display.set_caption("2048小游戏")
            # 4.7 初始化矩阵
            self.matrix = myGame.initData()
            # 4.2 死循环
            while True:
                # 4.6 背景颜色填充
                self.screen.fill((250,248,240))
                # 4.3 业务执行模块
                self.action()
                # 4.4 图形图像绘制模块
                self.paint()
                # 4.5 刷新屏幕
                pygame.display.update()
    
    
    if __name__ == '__main__':
        myGame = MyGame()
        myGame.menu()
    
    

     

    展开全文
  • 2048小游戏-源码-需安装python- 主程序为2048.py
  • python pygame2048小游戏源码pygame2048小游戏源码 pygame2048小游戏源码 # coding:utf-8 import pygame, os, platform from pygame.locals import * pygame.init() screen = pygame.display.set_mode((500, 330)...

    python pygame2048小游戏源码


    在这里插入图片描述

    pygame2048小游戏源码

    # coding:utf-8
    import pygame, random
    from pygame.locals import *
    
    pygame.init()
    screen = pygame.display.set_mode((1050, 500))
    fontText = pygame.font.SysFont("dengxian", 50)
    pygame.display.set_caption("2048")
    row = 6
    col = 6
    print("游戏说明\n通过键盘上下左右控制数字移动,\n如果一行或者一列内有相同的两个数字则合成.\n每次按下会随机生成数字\n点击ok按钮开始游戏.")
    
    
    def showText(text, pos, color=(0, 0, 0)):
        screen.blit(fontText.render(text, True, color), pos)
    
    
    def handleEvent():
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                exit()
            if event.type == KEYDOWN:
                key = event.key
                if key == K_UP:
                    moveUp(map)
                if key == K_DOWN:
                    moveDown(map)
                if key == K_LEFT:
                    moveLeft(map)
                if key == K_RIGHT:
                    moveRight(map)
                generateNumber(map)
    
    
    def removeZero(arr):
        newArr = [0 for i in range(arr.__len__())]
        index = 0
        for i in range(arr.__len__()):
            if arr[i] != 0:
                newArr[index] = arr[i]
                index += 1
        return newArr
    
    
    def merge(arr):
        arr = removeZero(arr)
        for i in range(arr.__len__() - 1):
            if arr[i] != 0 and arr[i] == arr[i + 1]:
                arr[i] *= 2
                arr[i + 1] = 0
        arr = removeZero(arr)
        return arr
    
    
    def moveUp(map):
        mergeArray = [0 for i in range(map[0].__len__())]
        row = map[0].__len__()
        col = map[1].__len__()
        for j in range(col):
            for i in range(row):
                mergeArray[i] = map[i][j]
            mergeArray = merge(mergeArray)
            for i in range(row):
                map[i][j] = mergeArray[i]
        return map
    
    
    def moveDown(map):
        mergeArray = [0 for i in range(map[0].__len__())]
        row = map[0].__len__()
        col = map[1].__len__()
        for j in range(col):
            for i in range(row):
                mergeArray[i] = map[row - i - 1][j]
            mergeArray = merge(mergeArray)
            for i in range(row):
                map[row - i - 1][j] = mergeArray[i]
        return map
    
    
    def moveLeft(map):
        mergeArray = [0 for i in range(map[0].__len__())]
        row = map[0].__len__()
        col = map[1].__len__()
        for j in range(col):
            for i in range(row):
                mergeArray[i] = map[j][i]
            mergeArray = merge(mergeArray)
            for i in range(row):
                map[j][i] = mergeArray[i]
        return map
    
    
    def moveRight(map):
        mergeArray = [0 for i in range(map[0].__len__())]
        row = map[0].__len__()
        col = map[1].__len__()
        for j in range(col):
            for i in range(row):
                mergeArray[i] = map[j][col - i - 1]
            mergeArray = merge(mergeArray)
            for i in range(row):
                map[j][col - i - 1] = mergeArray[i]
        return map
    
    
    # 在0的位置产生2
    def generateNumber(map):
        x = random.randint(0, row - 1)
        y = random.randint(0, col - 1)
        if map[x][y] == 0:
            map[x][y] = 2
        else:
            generateNumber(map)
        return [x, y]
    
    
    map = [[0 for j in range(col)] for i in range(row)]
    lastPos = [-1, -1]
    
    
    def init(map):
        global lastPos
        # 生成而为列表
        for i in range(2):
            pos = generateNumber(map)
            if lastPos[0] == pos[0] and lastPos[1] == pos[1]:
                init(map)
            else:
                lastPos = pos
    
    
    def paint(map):
        y = 40
        for i in map:
            x = 120
            for j in i:
                showText(str(j), (x, y))
                x += 150
            y += 80
    
    
    init(map)
    while True:
        screen.fill((255, 255, 255))
        paint(map)
        handleEvent()
        pygame.display.update()
        pygame.time.delay(100)
    
    
    展开全文
  • pygame2048小游戏 初学python,发现看网上的python理论太过枯燥。 哎嘿~~干脆直接弄个小游戏叭,一边学习,一边写代码。 备注: 1.很多地方我尽量注解,方便大家观看。 2.完整代码在最末的代码片,复制就能用。 一...

    pygame之2048小游戏

    初学python,发现看网上的python理论太过枯燥。
    哎嘿~~干脆直接弄个小游戏叭,一边学习,一边写代码。

    备注:
    1.很多地方我尽量注解,方便大家观看。
    2.完整代码在最末的代码片,复制就能用。

    一、导入的库

    import sys
    import random
    import pygame
    

    二、全局变量

    1.每个语句边上都有注解。
    2.方块的颜色使用了经典2048游戏颜色。

    pygame.init()  # 初始化pygame()
    size = 100  # 每个游戏方格的大小
    queue = 4  # 初始设置为4X4阵列
    game_lis = []  # 存放
    background_color = (255, 239, 213)  # 背景颜色
    Dividingline_color = (255, 222, 173)  # 分割线颜色
    Dividingline_width = 15  # 分割线宽度
    
    score_height = 120  # 得分区的高度
    score_width = 140  # 得分区的宽度
    score_color = (205, 193, 180)  # 得分字体颜色
    font1 = pygame.font.SysFont('SimHei', 50)  # 得分区域字体显示黑体24
    font_pos_x = Dividingline_width  # 得分区域字体位置的X坐标
    font_pos_y = int(font1.size('得分')[1])  # 得分区域字体位置的Y坐标
    score = 0  # 得分初始值为0
    
    font3 = pygame.font.Font(None, 50)  # 数字字体
    black = (0, 0, 0)  # 数字颜色
    
    screen_height = (((size + Dividingline_width) * queue) + score_height + Dividingline_width * 2)  # 屏幕高度
    screen_width = (((size + Dividingline_width) * queue) + Dividingline_width)  # 屏幕宽度
    
    colors = {0: (205, 193, 180),  # 各种方块对应的颜色
              2: (238, 228, 218),
              4: (237, 224, 200),
              8: (242, 177, 121),
              16: (245, 149, 99),
              32: (246, 124, 95),
              64: (246, 94, 59),
              128: (237, 207, 114),
              256: (237, 204, 98),
              512: (237, 200, 80),
              1024: (237, 197, 63),
              2048: (225, 187, 0)}
    

    三、绘制游戏背景

    这部分代码片包括游戏背景颜色以及网格线。

    # 绘制背景
    def _draw_background(screen):
        screen.fill(background_color)
        Dividingline_width_half = int(Dividingline_width / 2)
        Difference = score_height + Dividingline_width + int(Dividingline_width / 2)
    
        for i in range(queue + 1):  # 绘制横线
            pygame.draw.line(screen, Dividingline_color,
                             (0, i * (size + Dividingline_width) + Difference),
                             (screen_height, i * (size + Dividingline_width) + Difference),
                             Dividingline_width)
    
        for j in range(queue + 1):  # 绘制横线
            pygame.draw.line(screen, Dividingline_color,
                             (Dividingline_width_half + j * (size + Dividingline_width), Difference),
                             (Dividingline_width_half + j * (size + Dividingline_width), screen_height),
                             Dividingline_width)
    

    四、绘制得分区域

    1.得分区是个可变化的区域,最省力的情况是只变化分数。
    2.然鹅,我在主程序中设计的是循环调用,不停的覆盖之前的结果(整块得分区域)。
    有没有大佬知道,如何在不覆盖的情况下显示动态的数字。

    # 绘制得分区域
    def _draw_score(screen, font, pos_x, pos_y):
        global score
        print_text(screen, font, pos_x, 10, f'得分')
        print_text(screen, font, pos_x, pos_y + 6, f'{score}')
    
    
    # 得分区域
    def print_text(screen, font, x, y, text):
        imgText = font.render(text, True, score_color)
        screen.blit(imgText, (x, y))
    

    五、初始化游戏列表

    这里是用二维阵列来存放游戏数字,初始全设置为0。

    # 初始化游戏列表,存放2048数字
    def _game_list():
        for i in range(queue):  # 初始设置全为0
            lis = []
            for j in range(queue):
                lis.append(0)
            game_lis.append(lis)
    

    六、显示游戏方块和数字

    1.显示游戏方块,方块颜色根据游戏列表里的值改变。
    2.显示游戏数字。

    # 显示游戏区域:游戏方块和数字
    def _show_game(screen):
        for i in range(queue):
            for j in range(queue):
                rect_color = colors[game_lis[i][j]]  # 取出字典colors对应的值
                rect_position = [(j + 1) * Dividingline_width + j * size,  # 色块的位置
                                 Dividingline_width * (i + 2) + size * i + score_height]
                pygame.draw.rect(screen, rect_color, (rect_position, (size, size)), 0)  # 绘制色块
    
                if game_lis[i][j] != 0:  # 只有数列里不为0的时候才会输出
                    textSurfaceObj = font3.render(str(game_lis[i][j]), True, black)  # get_rect()方法返回rect对象
                    textRectObj = textSurfaceObj.get_rect()
                    rect_position = [(j + 1) * Dividingline_width + (j + 0.5) * size,  # 数字的位置
                                     Dividingline_width * (i + 2) + size * (i + 0.5) + score_height]
                    textRectObj.center = tuple(rect_position)
                    screen.blit(textSurfaceObj, textRectObj)
    

    七、产生随机数

    在随机位置产生随机数

    # 在随机位置产生随机数
    def _random():
        random_num = random.randint(1, 2)  # 随机数
        num = pow(2, random_num)
        random_pos_x = random.randint(0, queue - 1)  # 随机X坐标
        random_pos_y = random.randint(0, queue - 1)  # 随机Y坐标
        if game_lis[random_pos_x][random_pos_y] == 0:
            game_lis[random_pos_x][random_pos_y] = num
        else:
            _random()
    

    八、按键控制-LEFT()

    左方向键控制。

    # 捕获键盘LEFT操作
    def _LEFT():
        global score
        for i in range(queue):
            while 0 in game_lis[i]:
                game_lis[i].remove(0)
            for j in range(len(game_lis[i]) - 1):
                if game_lis[i][j] == game_lis[i][j + 1]:
                    game_lis[i][j] = game_lis[i][j] + game_lis[i][j + 1]
                    score = score + game_lis[i][j]
                    game_lis[i][j + 1] = 0
            while 0 in game_lis[i]:
                game_lis[i].remove(0)
            lis = []
            for j in range(queue - len(game_lis[i])):
                lis.append(0)
            game_lis[i] = game_lis[i] + lis
    

    九、按键控制-RIGHT()

    右方向键控制。

    # 捕获键盘RIGHT操作
    def _RIGHT():
        global score
        for i in range(queue):
            while 0 in game_lis[i]:
                game_lis[i].remove(0)
            for j in range(len(game_lis[i]) - 1, 0, -1):
                if game_lis[i][j] == game_lis[i][j - 1]:
                    game_lis[i][j] = game_lis[i][j] + game_lis[i][j - 1]
                    score = score + game_lis[i][j]
                    game_lis[i][j - 1] = 0
            while 0 in game_lis[i]:
                game_lis[i].remove(0)
            lis = []
            for j in range(queue - len(game_lis[i])):
                lis.append(0)
            game_lis[i] = lis + game_lis[i]
    

    十、按键控制-UP()

    上方向键控制,使用了列表转置。

    def _UP():
        global score
        lis = [[0, 0, 0, 0],
               [0, 0, 0, 0],
               [0, 0, 0, 0],
               [0, 0, 0, 0]]
        for i in range(queue):  # 整个列表顺时针旋转90度
            for j in range(queue):
                lis[i][j] = game_lis[queue - 1 - j][i]
    
        for i in range(queue):
            while 0 in lis[i]:
                lis[i].remove(0)
            for j in range(len(lis[i]) - 1, 0, -1):
                if lis[i][j] == lis[i][j - 1]:
                    lis[i][j] = lis[i][j] + lis[i][j - 1]
                    score = score + lis[i][j]
                    lis[i][j - 1] = 0
            while 0 in lis[i]:
                lis[i].remove(0)
            list1 = []
            for j in range(queue - len(lis[i])):
                list1.append(0)
            lis[i] = list1 + lis[i]
    
        for i in range(queue):  # 整个列表逆时针旋转90度
            for j in range(queue):
                game_lis[i][j] = lis[j][queue - 1 - i]
    

    十一、按键控制-DOWN()

    下方向键控制,使用了列表转置。

    def _DOWN():
        global score
        lis = [[0, 0, 0, 0],
               [0, 0, 0, 0],
               [0, 0, 0, 0],
               [0, 0, 0, 0]]
    
        for i in range(queue):  # 整个列表顺时针旋转90度
            for j in range(queue):
                lis[i][j] = game_lis[queue - 1 - j][i]
    
        for i in range(queue):
            while 0 in lis[i]:
                lis[i].remove(0)
            for j in range(len(lis[i]) - 1):
                if lis[i][j] == lis[i][j + 1]:
                    lis[i][j] = lis[i][j] + lis[i][j + 1]
                    score = score + lis[i][j]
                    lis[i][j + 1] = 0
            while 0 in lis[i]:
                lis[i].remove(0)
            list1 = []
            for j in range(queue - len(lis[i])):
                list1.append(0)
            lis[i] = lis[i] + list1
    
        for i in range(queue):  # 整个列表逆时针旋转90度
            for j in range(queue):
                game_lis[i][j] = lis[j][queue - 1 - i]
    
    

    十二、主函数

    def main():
        screen = pygame.display.set_mode((screen_width, screen_height))  # 建立游戏窗口
        pygame.display.set_caption('2048')  # 设置窗口标题
    
        _draw_background(screen)  # 绘制背景
        _game_list()  # 初始化游戏列表
        _show_game(screen)  # 显示游戏方块和数字
        _draw_score(screen, font1, font_pos_x, font_pos_y)  # 绘制得分区
    
        # 开始游戏
        _random()  # 产生随机数
        pygame.display.flip()  # 更新游戏
        _show_game(screen)  # 显示游戏方块和数字
        _draw_score(screen, font1, font_pos_x, font_pos_y)  # 绘制得分区
    
    
        while True:
            for event in pygame.event.get():  # get()获取事件的返回值
                if event.type == pygame.QUIT:  # 判断事件是否是退出事件,是则退出
                    pygame.quit()  # 先退出pygame窗口
                    sys.exit()  # 再退出pygame程序
    
                elif event.type == pygame.KEYDOWN:  # 捕获按键操作
                    if event.key == pygame.K_LEFT:  # 按下左按键
                        _LEFT()
                        print("left")
                    elif event.key == pygame.K_RIGHT:  # 按下右按键
                        _RIGHT()
                        print("right")
                    elif event.key == pygame.K_UP:  # 按下上按键
                        _UP()
                        print("up")
                    elif event.key == pygame.K_DOWN:  # 按下下按键
                        _DOWN()
                        print("down")
                    else:
                        print("False")
                    pygame.display.flip()  # 更新游戏
                    _draw_background(screen)  # 绘制背景
                    _random()  # 产生随机数
                    _show_game(screen)  # 显示游戏方块和数字
                    _draw_score(screen, font1, font_pos_x, font_pos_y)  # 绘制得分区
    

    结果图

    1.开始界面
    在这里插入图片描述
    2.游戏界面
    在这里插入图片描述

    完整代码

    直接复制就能使用。

    import sys
    import random
    import pygame
    
    pygame.init()  # 初始化pygame()
    size = 100  # 每个游戏方格的大小
    queue = 4  # 初始设置为4X4阵列
    game_lis = []  # 存放
    background_color = (255, 239, 213)  # 背景颜色
    Dividingline_color = (255, 222, 173)  # 分割线颜色
    Dividingline_width = 15  # 分割线宽度
    
    score_height = 120  # 得分区的高度
    score_width = 140  # 得分区的宽度
    score_color = (205, 193, 180)  # 得分字体颜色
    font1 = pygame.font.SysFont('SimHei', 50)  # 得分区域字体显示黑体24
    font_pos_x = Dividingline_width  # 得分区域字体位置的X坐标
    font_pos_y = int(font1.size('得分')[1])  # 得分区域字体位置的Y坐标
    score = 0  # 得分初始值为0
    
    font3 = pygame.font.Font(None, 50)  # 数字字体
    black = (0, 0, 0)  # 数字颜色
    
    screen_height = (((size + Dividingline_width) * queue) + score_height + Dividingline_width * 2)  # 屏幕高度
    screen_width = (((size + Dividingline_width) * queue) + Dividingline_width)  # 屏幕宽度
    
    colors = {0: (205, 193, 180),  # 各种方块对应的颜色
              2: (238, 228, 218),
              4: (237, 224, 200),
              8: (242, 177, 121),
              16: (245, 149, 99),
              32: (246, 124, 95),
              64: (246, 94, 59),
              128: (237, 207, 114),
              256: (237, 204, 98),
              512: (237, 200, 80),
              1024: (237, 197, 63),
              2048: (225, 187, 0)}
    
    
    # 绘制背景
    def _draw_background(screen):
        screen.fill(background_color)
        Dividingline_width_half = int(Dividingline_width / 2)
        Difference = score_height + Dividingline_width + int(Dividingline_width / 2)
    
        for i in range(queue + 1):  # 绘制横线
            pygame.draw.line(screen, Dividingline_color,
                             (0, i * (size + Dividingline_width) + Difference),
                             (screen_height, i * (size + Dividingline_width) + Difference),
                             Dividingline_width)
    
        for j in range(queue + 1):  # 绘制横线
            pygame.draw.line(screen, Dividingline_color,
                             (Dividingline_width_half + j * (size + Dividingline_width), Difference),
                             (Dividingline_width_half + j * (size + Dividingline_width), screen_height),
                             Dividingline_width)
    
    
    # 绘制得分区域
    def _draw_score(screen, font, pos_x, pos_y):
        global score
        print_text(screen, font, pos_x, 10, f'得分')
        print_text(screen, font, pos_x, pos_y + 6, f'{score}')
    
    
    # 得分区域
    def print_text(screen, font, x, y, text):
        imgText = font.render(text, True, score_color)
        screen.blit(imgText, (x, y))
    
    
    # 初始化游戏列表,存放2048数字
    def _game_list():
        for i in range(queue):  # 初始设置全为0
            lis = []
            for j in range(queue):
                lis.append(0)
            game_lis.append(lis)
    
    
    # 显示游戏区域:游戏方块和数字
    def _show_game(screen):
        for i in range(queue):
            for j in range(queue):
                rect_color = colors[game_lis[i][j]]  # 取出字典colors对应的值
                rect_position = [(j + 1) * Dividingline_width + j * size,  # 色块的位置
                                 Dividingline_width * (i + 2) + size * i + score_height]
                pygame.draw.rect(screen, rect_color, (rect_position, (size, size)), 0)  # 绘制色块
    
                if game_lis[i][j] != 0:  # 只有数列里不为0的时候才会输出
                    textSurfaceObj = font3.render(str(game_lis[i][j]), True, black)  # get_rect()方法返回rect对象
                    textRectObj = textSurfaceObj.get_rect()
                    rect_position = [(j + 1) * Dividingline_width + (j + 0.5) * size,  # 数字的位置
                                     Dividingline_width * (i + 2) + size * (i + 0.5) + score_height]
                    textRectObj.center = tuple(rect_position)
                    screen.blit(textSurfaceObj, textRectObj)
    
    
    # 在随机位置产生随机数
    def _random():
        random_num = random.randint(1, 2)  # 随机数
        num = pow(2, random_num)
        random_pos_x = random.randint(0, queue - 1)  # 随机X坐标
        random_pos_y = random.randint(0, queue - 1)  # 随机Y坐标
        if game_lis[random_pos_x][random_pos_y] == 0:
            game_lis[random_pos_x][random_pos_y] = num
        else:
            _random()
    
    
    # 捕获键盘LEFT操作
    def _LEFT():
        global score
        for i in range(queue):
            while 0 in game_lis[i]:
                game_lis[i].remove(0)
            for j in range(len(game_lis[i]) - 1):
                if game_lis[i][j] == game_lis[i][j + 1]:
                    game_lis[i][j] = game_lis[i][j] + game_lis[i][j + 1]
                    score = score + game_lis[i][j]
                    game_lis[i][j + 1] = 0
            while 0 in game_lis[i]:
                game_lis[i].remove(0)
            lis = []
            for j in range(queue - len(game_lis[i])):
                lis.append(0)
            game_lis[i] = game_lis[i] + lis
    
    
    # 捕获键盘RIGHT操作
    def _RIGHT():
        global score
        for i in range(queue):
            while 0 in game_lis[i]:
                game_lis[i].remove(0)
            for j in range(len(game_lis[i]) - 1, 0, -1):
                if game_lis[i][j] == game_lis[i][j - 1]:
                    game_lis[i][j] = game_lis[i][j] + game_lis[i][j - 1]
                    score = score + game_lis[i][j]
                    game_lis[i][j - 1] = 0
            while 0 in game_lis[i]:
                game_lis[i].remove(0)
            lis = []
            for j in range(queue - len(game_lis[i])):
                lis.append(0)
            game_lis[i] = lis + game_lis[i]
    
    
    # 获取键盘UP操作
    def _UP():
        global score
        lis = [[0, 0, 0, 0],
               [0, 0, 0, 0],
               [0, 0, 0, 0],
               [0, 0, 0, 0]]
        for i in range(queue):  # 整个列表顺时针旋转90度
            for j in range(queue):
                lis[i][j] = game_lis[queue - 1 - j][i]
    
        for i in range(queue):
            while 0 in lis[i]:
                lis[i].remove(0)
            for j in range(len(lis[i]) - 1, 0, -1):
                if lis[i][j] == lis[i][j - 1]:
                    lis[i][j] = lis[i][j] + lis[i][j - 1]
                    score = score + lis[i][j]
                    lis[i][j - 1] = 0
            while 0 in lis[i]:
                lis[i].remove(0)
            list1 = []
            for j in range(queue - len(lis[i])):
                list1.append(0)
            lis[i] = list1 + lis[i]
    
        for i in range(queue):  # 整个列表逆时针旋转90度
            for j in range(queue):
                game_lis[i][j] = lis[j][queue - 1 - i]
    
    
    # 获取键盘DOWN操作
    def _DOWN():
        global score
        lis = [[0, 0, 0, 0],
               [0, 0, 0, 0],
               [0, 0, 0, 0],
               [0, 0, 0, 0]]
    
        for i in range(queue):  # 整个列表顺时针旋转90度
            for j in range(queue):
                lis[i][j] = game_lis[queue - 1 - j][i]
    
        for i in range(queue):
            while 0 in lis[i]:
                lis[i].remove(0)
            for j in range(len(lis[i]) - 1):
                if lis[i][j] == lis[i][j + 1]:
                    lis[i][j] = lis[i][j] + lis[i][j + 1]
                    score = score + lis[i][j]
                    lis[i][j + 1] = 0
            while 0 in lis[i]:
                lis[i].remove(0)
            list1 = []
            for j in range(queue - len(lis[i])):
                list1.append(0)
            lis[i] = lis[i] + list1
    
        for i in range(queue):  # 整个列表逆时针旋转90度
            for j in range(queue):
                game_lis[i][j] = lis[j][queue - 1 - i]
    
    
    # 主函数
    def main():
        screen = pygame.display.set_mode((screen_width, screen_height))  # 建立游戏窗口
        pygame.display.set_caption('2048')  # 设置窗口标题
    
        _draw_background(screen)  # 绘制背景
        _game_list()  # 初始化游戏列表
        _show_game(screen)  # 显示游戏方块和数字
        _draw_score(screen, font1, font_pos_x, font_pos_y)  # 绘制得分区
    
        # 开始游戏
        _random()  # 产生随机数
        pygame.display.flip()  # 更新游戏
        _show_game(screen)  # 显示游戏方块和数字
        _draw_score(screen, font1, font_pos_x, font_pos_y)  # 绘制得分区
    
    
        while True:
            for event in pygame.event.get():  # get()获取事件的返回值
                if event.type == pygame.QUIT:  # 判断事件是否是退出事件,是则退出
                    pygame.quit()  # 先退出pygame窗口
                    sys.exit()  # 再退出pygame程序
    
                elif event.type == pygame.KEYDOWN:  # 捕获按键操作
                    if event.key == pygame.K_LEFT:  # 按下左按键
                        _LEFT()
                        print("left")
                    elif event.key == pygame.K_RIGHT:  # 按下右按键
                        _RIGHT()
                        print("right")
                    elif event.key == pygame.K_UP:  # 按下上按键
                        _UP()
                        print("up")
                    elif event.key == pygame.K_DOWN:  # 按下下按键
                        _DOWN()
                        print("down")
                    else:
                        print("False")
                    pygame.display.flip()  # 更新游戏
                    _draw_background(screen)  # 绘制背景
                    _random()  # 产生随机数
                    _show_game(screen)  # 显示游戏方块和数字
                    _draw_score(screen, font1, font_pos_x, font_pos_y)  # 绘制得分区
    
    
    if __name__ == '__main__':
        main()
    

    存在的问题

    1.方向键控制不够灵活,偶尔需要按两边才会有反应 2.游戏结束了怎么办,没有弹出选项
    展开全文
  • 2048小游戏-pygame来实现.(借鉴网友代码,仅供学习) 文件结构如下: main.py代码 # main.py """ 功能:2048小游戏 作者:指尖魔法师 QQ:14555110 """ import pygame from sys import exit from modules....
  • #Python 2048游戏源码 Pygame 仿真 带移动动画 1. 使用方向键控制游戏; 2. 经典配色和数字块; 3. 记录分数和历史最高分; 4. 带移动动画效果。
  • 使用Pygame制作2048小游戏

    千次阅读 多人点赞 2020-07-28 21:23:51
    好久没有写文章了,暑假一直没有怎么学习计算机方面的相关...现在先来分享一下我的python课两个期末大作业之一——Pygame开发的2048 一、游戏效果展示 1.运行程序,出现欢迎界面。点击鼠标左键后,出现主菜单界面。.
  • 这里写自定义目录标题python-pygame模块实现2048小游戏代码展示主程序,程序入口为每一个小的显示单元模块,进行绘制设置操作音算法-实际操作-向上操作示例页面展示总结 python-pygame模块实现2048小游戏 本来是想做...
  • pygame开发2048游戏(附源代码)

    千次阅读 多人点赞 2017-06-21 20:32:38
    背景最近入手新游戏:《Threes》,2048的前身,难度比2048大,这个游戏的命运比较悲哀,App上架没几天,便被人仿制出与之类似、入手更快的《2048》,2048获得了巨大的成功,无论App store 还是Android 市场,下载量...
  • 前些天发现没有博主用Pygame实现比较漂亮的2048游戏,于是就自己做了一版。功能及特色包括:全套经典配色和数字块图片、记分牌(分数和历史最高分)以及移动动画效果。效果图如下:
  • 一、简介2048的游戏规则很简单,每次可以选择上下左右其中一个方向去滑动,每滑动一次,所有的数字方块都会往滑动的方向靠拢外,系统也会在空白的地方乱数出现一个数字方块,相同数字的方块在靠拢、相撞时会相加。...
  • 导语 “嗨嗨嗨!别睡了,醒醒醒醒!该干活儿了~” ...上期给大家分享的超详细——简易版本的2048都吃透了没?咳咳咳......没吃透也没关系! 慢慢来,木木子一直在等你们崛起~哈哈哈哈 ,呐~ 现在这篇文章...
  • 这次给大家来做个2048小游戏吧。废话不多说,让我们愉快地开始吧~ 开发工具 Python版本: 3.6.4 相关模块: pygame模块; 以及一些Python自带的模块。 环境搭建 安装Python并添加到环境变量,pip安装需要的...
  • Pygame游戏2048

    2018-11-07 16:09:54
    # _*_ coding:utf-8 _*_ import random from random import randint import numpy as np import pygame from pygame.locals import * from sys import exit __author__ = 'admin' ... 游戏2048: 游戏的开始、进行...
  • 2048游戏pygame

    2021-03-12 08:27:43
    改进前面博文tkinter制作的2048,使用pygame制作,绑定了键盘事件,使得操作更加便利。
  • pygame2048(功能不完全版)
  • python3实战--pygame写的2048游戏

    千次阅读 2018-06-24 11:41:03
    pygame.display.set_caption("2048")#设置界面标题 clock = pygame.time.Clock() #控制帧速率 display(map,screen)#显示界面 while not map.failed(): #如果没有失败 for event in pygame.event.get(): #获取...
  • 一、简介2048的游戏规则很简单,每次可以选择上下左右其中一个方向去滑动,每滑动一次,所有的数字方块都会往滑动的方向靠拢外,系统也会在空白的地方乱数出现一个数字方块,相同数字的方块在靠拢、相撞时会相加。...
  • 实现2048相对来说比较简单,用到
  • 2048游戏的算法参考:2048 Game in Python - GeeksforGeeks ...import pygame import numpy as np WINDOW_WIDTH, WINDOW_HEIGHT = 600, 601 CELL_SIZE = 60 #ref:https://www.geeksforgeeks.org/2048-game-in-pyt
  • pygame-1.9.4.rar

    2019-07-04 11:05:43
    pygame-1.9.4-cp37-cp37m-win_amd64.whl Python 游戏开发包 安装命令: python -m pip install --user pygame-1.9.4-cp37-cp37m-win_amd64.whl

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 566
精华内容 226
关键字:

pygame2048