微信H5游戏是商家做宣传推广优先选择的方式，一个优质的小游戏，既能娱乐大众，又能宣传企业品牌，为商家增加网站流量。为此，很多商家都会想做一个h5游戏进行宣传推广自己的品牌、产品，那么微信h5游戏怎么制作呢，请看下面详细的h5游戏教程。



　　微信h5游戏怎么制作

　　其实要从根本上解答这个问题的话，就涉及程序开发领域了。一般情况下，商家做的H5小游戏都是借助第三方平台链接过来的。

　　有很多H5小游戏的免费平台，里面有很多种类的游戏供用户选择。但一般都会限制参与人数，比如超过50人就要给平台付费。如果商家只想打造一次性的H5游戏营销，给点钱平台也是可以的，不过要想推广自身品牌，大部分平台的H5小游戏是不支持修改游戏元素的。这种可能会有很大的局限性，但是自身又不会制作怎么办？

　　如果商家渴望长期借用H5游戏进行品牌推广，移动营销服务的平台——汇桔宝可以轻松解决这方面的问题，它拥有丰富的h5游戏模板，可以为商家度身定做微信h5游戏。也有海量的场景营销模板，让您不会错失任何一个与客户接触的机会。



 

很多朋友在玩游戏的时候都会有自己的一点思路，也想着创作出一款游戏。甚至想之后从事游戏相关的工作，那么心动不如行动，现在就开始寻找一款简单的引擎制作一款小游戏吧。
这里给大家推荐一款月活超过1亿的游戏发布与游玩平台罗布乐思(Roblox)，上手几乎没有难度。不仅适合制作第一款小游戏入门，也可以从实践中了解到更多关于游戏制作的知识。下面我就通过制作一个小游戏的步骤来给大家看看上手有多简单。
1、添加出生点
首先在“Explorer(资源管理器)”窗口中，在 Workspace里添加SpawnLocation作为玩家的出生点。
2、添加部件
在Home(主页)**选项卡中，单击Part(部件)。添加你所需要的部件
通过开启或关闭Collisions(碰撞)来控制部件能否穿过其他部件。
选择你想要锚定的部件。进入 **Properties(属性)**窗口，向下滚动至 Behavior(行为)，勾选 Anchored(锚定)。可以让该部件固定在此位置而不是一开始就受重力影响下坠。
3、制造场景
通过主页选项卡移动、缩放与旋转功能将你所需要的部件搭好，再通过材质和颜色功能制造出自己想要的场景。比如星空或者森林等。通过复制功能可以减少时间和步骤，先点击部件，再右键，点击复制。通过Ctrl键可以同时选中多个部件。
4、设置存档点
单击Service(服务)(图标为两个齿轮)，选择 Teams，单击 Insert(插入)。
在 **Explorer(资源管理器)**中，右键单击 Teams。
单击 Insert Object(插入对象)> Team。你会发现 Teams 文件夹中已经创建了一支队伍。
单击你的初始 SpawnLocation。
在 **Properties(属性)**窗口中，取消勾选 Neutral 复选框。
在 SpawnLocation 的 Properties(属性)窗口中，找到 TeamColor；你需要记住此颜色
单击你刚才重命名的 Team 对象。
设置 TeamColor 以便匹配第一个 SpawnLocation。(这样就让你的初始游戏对应着第一个出生点)
创建一个新 SpawnLocation。
将 SpawnLocation 重命名为 SpawnLocation2。
勾选 AllowTeamChangeOnTouch。现在每当有人触碰该 SpawnLocation 时，他们就会获得相应的队伍颜色。
取消勾选 Neutral。
选择一个新的 TeamColor。
取消勾选 AutoAssignable。(只有第一个队伍应该设为AutoAssignable。这样玩家会在开始游戏时自动分配到第一个保存点。)
更改 TeamColor 以便匹配新的 SpawnLocation。(这样碰到保存点再死就会在保存点复活)
5、运行测试
点击play运行游戏，测试无误后就可以点击右上角进行发布了。(当然这个小游戏有点简单了)。是不是感觉十分简单呢，感兴趣的话不妨上手试试。

好久没有写文章了，暑假一直没有怎么学习计算机方面的相关知识，不过倒是坚持背了一个多月的单词红宝书，看了汤神的基础课。真的没想到自己居然也能有毅力背了150多页的单词，还写完了一本正反面的字帖这些事以前从来没坚持下来过，可能就是长大了懂事了吧，hhh。还练了科三。后天第三次考了，希望这次能考过。

吃完晚饭闲来无事，准备回归从前写写小文章。现在先来分享一下我的python课两个期末大作业之一——Pygame开发的2048

这个2048项目主干部分是我在基于Python的PyGame库实现的2048小游戏上找的，自己加了音乐，主菜单，界面，重开本关，回到上一步，记录最高得分

游戏完整代码在第三部分，不想看讲解的可以直接拉到Part3

一、游戏效果展示

1.运行程序，出现欢迎界面。点击鼠标左键后，出现主菜单界面。          

                                          

2.分别点击“玩法介绍”和“游戏技巧”，进入查看相应的界面。

                                          

3.点击“开始游戏”按钮，进入游戏。操纵上下左右不断合并方块来提高分数。

                                        

4.当走错了步骤时，按一下空格间。可以回到上一步。

                                        

5.当游戏失败后，点击“New Game”按钮进行一局新的游戏。

                                        

6.当游戏进行不下去或者认为没有操作好的时候，系统自动判定失败。此时还可以点击NewGame重新进行一局游戏。                  

                                                      

7.右上角存在记分牌，可以记录玩家本机最高得分。

二、功能模块开发详细介绍

下面我将从七个部分讲解各个部分的功能，设计思想。可能会有点多，看不懂很正常，多思考多运行多体会。毕竟想要一下弄懂别人花了两周心血写的大作业可不是一件容易的事情呀。当时我打算题目写2048的时候也没着急着先写，就先去网上玩了一周的2048^ ^。对我这种手残党还是有很大帮助的。

1.欢迎界面和主菜单

这个部分是纯属为了凑代码行数加的，当时我第一遍写完了只有300行左右，谁知道老师晚上上课专门说了码量起码500+,当时直接我晕！咱就写个简单的2048么，又不像琪哥睿哥写什么高级的超级玛丽和连连看，剩下那200行怎么凑，而且这都写完了，莫不是天要亡我？后来苦思冥想，加了个主菜单，做了个游戏说明故意打了很多行汉字来凑数，加了个播放音乐的功能，哈哈哈，机智如我，不过就是被井大爷批的很惨，/(ㄒoㄒ)/~~

def game_view_page0():#游戏欢迎界面，这里实现了一个动画功能：两排大小颜色不同的“2048小游戏”绕屏幕中心进行旋转
    FPS = 5
    BLACK = (0, 0, 0)
    BROWN = (187, 173, 160)
    WHITE = (255, 255, 255)
    BGCOLOR = BROWN
    titleFont = pygame.font.Font(r'C:\Windows\Fonts\simkai.ttf', 100)
    titleSurf1 = titleFont.render('2048小游戏', True, BLACK)
    titleSurf2 = titleFont.render('2048小游戏', True, WHITE)
    degrees1 = 0
    degrees2 = 0
    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                exit()
            elif event.type == pygame.MOUSEBUTTONDOWN or event.type == KEYUP:
                return
        screen.fill(BGCOLOR)
        rotatedSurf1 = pygame.transform.rotate(titleSurf1, degrees1)
        rotatedRect1 = rotatedSurf1.get_rect()
        rotatedRect1.center = (screen_width / 2, screen_height / 2 - 50)
        screen.blit(rotatedSurf1, rotatedRect1)
        rotatedSurf2 = pygame.transform.rotate(titleSurf2, degrees2)
        rotatedRect2 = rotatedSurf2.get_rect()
        rotatedRect2.center = (screen_width / 2, screen_height / 2 - 50)
        screen.blit(rotatedSurf2, rotatedRect2)
        screen.blit(write("点击鼠标左键进入游戏", height=30, color=(255, 255, 255)),
                    (left_of_screen + 60, left_of_screen // 2 + 450))
        pygame.display.update()
        FPSCLOCK.tick(10)
        degrees1 += 3
        degrees2 += 5


都是一些Pygame的基本操作，game_view_page0()函数用于绘制一个开始的欢迎界面，界面中有两行以窗口中心为轴进行旋转的文字“2048”，点击鼠标左键进入主菜单。

2.玩法介绍和高分技巧介绍

同1部分，为了凑行数= =

def game_start_page():#游戏开始界面
    #加载背景图片
    screen.blit(background, (0, 0))
    #创建几个自定义的按钮
    button4 = Button((left_of_screen + 110, 150), b4, 200, 80)
    button5 = Button((left_of_screen + 110, 270), b5, 200, 80)
    button6 = Button((left_of_screen + 110, 390), b6, 200, 80)
    while True:
        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
                pygame.quit()
                exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                if button4.isOver() == True:#如果按下的是button4,即开始游戏
                    return
                elif button5.isOver() == True:#如果按下的是button5，即游戏玩法介绍
                    game_introduce()
                    screen.blit(background, (0, 0))
                    button4 = Button((left_of_screen + 110, 150), b4, 200, 80)
                    button5 = Button((left_of_screen + 110, 270), b5, 200, 80)
                    button6 = Button((left_of_screen + 110, 390), b6, 200, 80)
                elif button6.isOver() == True:#如果按下的是button6，即游戏技巧介绍
                    game_skill()
                    screen.blit(background, (0, 0))
                    button4 = Button((left_of_screen + 110, 150), b4, 200, 80)
                    button5 = Button((left_of_screen + 110, 270), b5, 200, 80)
                    button6 = Button((left_of_screen + 110, 390), b6, 200, 80)
            screen.blit(write("2048", height=100, color=(119, 110, 101)),
                        (left_of_screen + 110, left_of_screen // 2))
            pygame.display.update()

game_start_page()函数用于绘制一个游戏主菜单，玩家可在主菜单中选择自己下一步将要进行的步骤。

欢迎界面中首先需要设置游戏首页旋转文字的字体大小和文字内容，然后以文字的中心点，设置文字摆放位置，刷新频率FPS设置为10时流畅度比较符合要求。将其放在while True死循环中即可绘制出欢迎界面。

主菜单放置了三个能导向不同界面的自定义按钮组件Button，Button中的is_Over()函数可以判断用户是否将鼠标放在按钮上进行了点击；Button的样子用不同的的图片加载。

class Button(object):#此类是一个自定义好的按钮类，用在游戏中出现的各种按钮
    def __init__(self, position, fileName, sizex, sizey):#初始化该按钮，包括加载图片，初始位置，按钮大小
        self.imageUp = pygame.image.load(fileName).convert_alpha()
        self.position = position
        self.imageUp = pygame.transform.scale(self.imageUp, (sizex, sizey))
        screen.blit(self.imageUp, self.position)

    def isOver(self):#判断鼠标是否放在该按钮上
        point_x, point_y = pygame.mouse.get_pos()
        x, y = self.position
        w, h = self.imageUp.get_size()

        in_x = x < point_x < x + w
        in_y = y < point_y < y + h
        return in_x and in_y

    def render(self):#判断是否要重新开始一局游戏
        global score
        w, h = self.imageUp.get_size()
        x, y = self.position
        if self.isOver() == True:
            score = 0
            draw_box(0)
            init_board()

图片文件夹截图：

                                       

game_introduce()用于显示游戏玩法介绍界面。

game_skill()用于显示游戏技巧介绍界面。

设置好要加载的文字和位置，然后调用screen.blit函数将他们加载到屏幕上。

3.方块的移动与合并（重难点）

其实这部分我也是网上copy的，这一部分的逻辑比较强，是方块合并移动的原理部分。

combinate()函数用来执行相同方块的合并操作。

up()函数用来对应游戏中用户按下“上”键后，对应向上合并方块的操作。

down()函数用来对应用游戏中户按下“下”键后，对应向下合并方块的操作。

left()用来对应游戏中用户按下“左”键后，对应向左合并方块的操作。

right()用来对应游戏中用户按下“右”键后，对应向右合并方块的操作。

combinate()合并运算设计思想：

要执行一行中相同方块的合并，首先从左到右将这一行的数字们存入一个新的列表ans中：

（1）当ans中有两个数字时，直接将他们相加合并。把相加后的新的一行返回。score加上相应的得分。

（2）当ans中有三个数字时，我们首先判断ans[0]和ans[1]是否相等，相等合并二者；否则判断and[1]和ans[2]。共两种可能合并的情况。再把score加上相应的的得分。

（3）当ans中有四个数字时同理，需要判断ans[0]和ans[1]，ans[1]和ans[2],ans[2]和ans[3]，有三种可能合并的情况。

向左合并时从上到下一行一行的进行combinate()运算；向右合并时将每一行左右逆序即可；向上合并时从左到右一列一列进行combinate()运算；向下合并时与向上上下逆序即可。

感觉说了这么多啊，= =其实你只要拿张纸画画，分三种情况，好像也不是太难？

def combinate(L):#此函数的功能是进行方块的合并原理，是本程序的重难点所在
    global score
    ans = [0, 0, 0, 0]
    num = []
    for i in L:
        if i != 0:#把本行中所有的数字放到列表num中去
            num.append(i)
    length = len(num)
    if length == 4:#本行中有4个数字
        if num[0] == num[1]:#case1
            ans[0] = num[0] + num[1]
            score += ans[0]
            if num[2] == num[3]:
                ans[1] = num[2] + num[3]
                score += ans[1]
            else:
                ans[1] = num[2]
                ans[2] = num[3]
        elif num[1] == num[2]:#case2
            ans[0] = num[0]
            ans[1] = num[1] + num[2]
            ans[2] = num[3]
            score += ans[1]
        elif num[2] == num[3]:#case3
            ans[0] = num[0]
            ans[1] = num[1]
            ans[2] = num[2] + num[3]
            score += ans[2]
        else:#case4 没有能合并的数字
            for i in range(length):
                ans[i] = num[i]
    elif length == 3:#本行中有3个数字
        if num[0] == num[1]:#case 1
            ans[0] = num[0] + num[1]
            ans[1] = num[2]
            score += ans[0]
        elif num[1] == num[2]:#case 2
            ans[0] = num[0]
            ans[1] = num[1] + num[2]
            score += ans[1]
        else:#case 3 没有能合并的数字
            for i in range(length):
                ans[i] = num[i]
    elif length == 2:#本行中有2个数字
        if num[0] == num[1]:#case 1
            ans[0] = num[0] + num[1]
            score += ans[0]
        else:#case 2 没有能合并的数字
            for i in range(length):
                ans[i] = num[i]
    elif length == 1:
        ans[0] = num[0]
    else:
        pass
    return ans


def left():#用户按下左键进行的移动
    for i in range(4):
        temp = combinate(board[i])
        for j in range(4):
            board[i][j] = temp[j]


def right():#用户按下右键进行的移动
    for i in range(4):
        temp = combinate(board[i][::-1])
        for j in range(4):
            board[i][3 - j] = temp[j]


def up():#用户按下上键进行的移动
    for i in range(4):
        to_comb = []
        for j in range(4):
            to_comb.append(board[j][i])
        temp = combinate(to_comb)
        for k in range(4):
            board[k][i] = temp[k]


def down():#用户按下下键进行的移动
    for i in range(4):
        to_comb = []
        for j in range(4):
            to_comb.append(board[3 - j][i])
        temp = combinate(to_comb)
        for k in range(4):
            board[3 - k][i] = temp[k]

4.“重新开始”功能

当用户点击重新开始按钮时，重新加载一局游戏。

设置一个Button类接受用户的点击，通过self.is_Over()函数判断用户当前的鼠标位置和按钮位置是否重叠。当用户点击按钮时，调用self.render()函数，对score分数，board游戏面板进行初始化。

5.记录得分和最高分

记录本机的最高得分并显示在high score处。

用txt文件存储本机最高得分，每一局失败时判断当前得分是否高于最高得分，with open覆盖写入模式打开文件，将分数写入txt文件进行保存。每次运行时读取模式读出最高得分，调用screen.blit显示在high score部分处。

6.“回到上一步"功能

用户走错时可以点击空格键回到上一步。

设置一个tmpScore和列表b存储上一步的分数和游戏情况。按下空格键后将上一步的状态赋值给当前的状态，刷新界面就可以实现回退的功能。

7.判负和判胜

判断用户本局游戏失败或胜利。

循环遍历二位列表board中元素。当列表board中没有空格，即没有0元素时，本局游戏失败；当列表board中出现数字2048时，本局游戏成功。将信息打印到屏幕上对用户进行相应的提示。

def win():#判断当前是否胜利
    for i in range(4):
        for j in range(4):
            if board[i][j] == 2048:#有2048，肯定是胜利了
                return True
    return False


def is_over():#判断当前是否失败
    for i in range(4):
        for j in range(4):
            if board[i][j] == 0:#有0，还有空白处，肯定不算失败
                return False
    for i in range(4):
        for j in range(3):
            if board[i][j] == board[i][j + 1]:#左右有相同的字母，还能够合并，肯定不算失败
                return False
    for i in range(3):
        for j in range(4):
            if board[i][j] == board[i + 1][j]:#上下有相同的字母，还能够合并，肯定不算失败
                return False
    return True#失败了

三、完整程序代码

#本程序用到的一些库
import os
import random
import pygame
from sys import exit
from copy import deepcopy
from pygame.locals import *

pygame.init()
FPS = 5
b4 = "button4.jpg"
b5 = "button5.jpg"
b6 = "button6.jpg"
folder = r'C:\Users\longlong\Music'
musics = [folder + '\\' + music for music in os.listdir(folder)
          if music.endswith('.mp3')]
total = len(musics)
pygame.mixer.init()

board = [[0, 0, 0, 0],
         [0, 0, 0, 0],
         [0, 0, 0, 0],
         [0, 0, 0, 0]]

box_size = 100  # 每个小方格
box_gap = 5  # 每个小方格与每个小方格之间的间距
top_of_screen = 100  # 格子到窗口顶端的距离
bottom_of_screen = 20  # 格子到窗口底端的距离
left_of_screen = 50  # 格子到窗口左端的距离
screen_width = 520  # 游戏界面的宽
screen_height = 600  # 游戏界面的高度
screen = pygame.display.set_mode((screen_width, screen_height), 0, 32)  # 初始化一个准备显示的窗口或屏幕
pygame.display.set_caption("My2048")  # 设置游戏窗口标题
background = pygame.image.load('background3.jpg').convert()  # 设置游戏背景图
high_score_name = "high_score.txt"
score = 0  # 得分
tmpScore = 0
high_score = 0


def play_music():#此函数的功能是播放音乐
    if not pygame.mixer.music.get_busy():
        nextMusic = random.choice(musics)
        pygame.mixer.music.load(nextMusic)
        pygame.mixer.music.play(1)
    else:
        time.sleep(1)


class Button(object):#此类是一个自定义好的按钮类，用在游戏中出现的各种按钮
    def __init__(self, position, fileName, sizex, sizey):#初始化该按钮，包括加载图片，初始位置，按钮大小
        self.imageUp = pygame.image.load(fileName).convert_alpha()
        self.position = position
        self.imageUp = pygame.transform.scale(self.imageUp, (sizex, sizey))
        screen.blit(self.imageUp, self.position)

    def isOver(self):#判断鼠标是否放在该按钮上
        point_x, point_y = pygame.mouse.get_pos()
        x, y = self.position
        w, h = self.imageUp.get_size()

        in_x = x < point_x < x + w
        in_y = y < point_y < y + h
        return in_x and in_y

    def render(self):#判断是否要重新开始一局游戏
        global score
        w, h = self.imageUp.get_size()
        x, y = self.position
        if self.isOver() == True:
            score = 0
            draw_box(0)
            init_board()


class Box:
    def __init__(self, topleft, text, color):
        self.topleft = topleft
        self.text = text
        self.color = color

    def render(self, surface):
        x, y = self.topleft
        pygame.draw.rect(surface, self.color, (x, y, box_size, box_size), 0)
        text_height = 35
        font_obj = pygame.font.SysFont("arial", text_height)
        text_surface = font_obj.render(self.text, True, (0, 0, 0))
        text_rect = text_surface.get_rect()
        text_rect.center = (x + 50, y + 50)
        surface.blit(text_surface, text_rect)


def load_data():#读取本地txt文件中的本机最高得分
    with open(high_score_name, "r") as f:
        high = int(f.read())
        return high


def draw_box(type):#绘制游戏棋盘界面，用一个4x4的列表表示
    global board
    if type == 0:
        board = [[0, 0, 0, 0],
                 [0, 0, 0, 0],
                 [0, 0, 0, 0],
                 [0, 0, 0, 0]]
    colors = {#各种不同的RGB色彩混合，完全按照原版2048仿制
        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)
    }
    x, y = left_of_screen, top_of_screen
    size = 425
    pygame.draw.rect(screen, (187, 173, 160), (x, y, size, size))
    x, y = x + box_gap, y + box_gap
    for i in range(4):
        for j in range(4):
            idx = board[i][j]
            if idx == 0:
                text = ""
            else:
                text = str(idx)
            if idx > 2048:
                idx = 2048
            color = colors[idx]
            box = Box((x, y), text, color)
            box.render(screen)
            x += box_size + box_gap
        x = left_of_screen + box_gap
        y += top_of_screen + box_gap


def set_random_number():#此函数的功能是用户每移动一步后在数字0处随机产生一个2或4
    num = []
    for i in range(4):
        for j in range(4):
            if board[i][j] == 0:
                num.append((i, j))
    m = random.choice(num)
    num.remove(m)
    value = random.uniform(0, 1)
    if value < 0.1:#产生4的概率要小一点
        value = 4
    else:
        value = 2
    board[m[0]][m[1]] = value


def init_board():#游戏开始时初始化棋盘：随机产生两个2/4
    for i in range(2):
        set_random_number()


def combinate(L):#此函数的功能是进行方块的合并原理，是本程序的重难点所在
    global score
    ans = [0, 0, 0, 0]
    num = []
    for i in L:
        if i != 0:#把本行中所有的数字放到列表num中去
            num.append(i)
    length = len(num)
    if length == 4:#本行中有4个数字
        if num[0] == num[1]:#case1
            ans[0] = num[0] + num[1]
            score += ans[0]
            if num[2] == num[3]:
                ans[1] = num[2] + num[3]
                score += ans[1]
            else:
                ans[1] = num[2]
                ans[2] = num[3]
        elif num[1] == num[2]:#case2
            ans[0] = num[0]
            ans[1] = num[1] + num[2]
            ans[2] = num[3]
            score += ans[1]
        elif num[2] == num[3]:#case3
            ans[0] = num[0]
            ans[1] = num[1]
            ans[2] = num[2] + num[3]
            score += ans[2]
        else:#case4 没有能合并的数字
            for i in range(length):
                ans[i] = num[i]
    elif length == 3:#本行中有3个数字
        if num[0] == num[1]:#case 1
            ans[0] = num[0] + num[1]
            ans[1] = num[2]
            score += ans[0]
        elif num[1] == num[2]:#case 2
            ans[0] = num[0]
            ans[1] = num[1] + num[2]
            score += ans[1]
        else:#case 3 没有能合并的数字
            for i in range(length):
                ans[i] = num[i]
    elif length == 2:#本行中有2个数字
        if num[0] == num[1]:#case 1
            ans[0] = num[0] + num[1]
            score += ans[0]
        else:#case 2 没有能合并的数字
            for i in range(length):
                ans[i] = num[i]
    elif length == 1:
        ans[0] = num[0]
    else:
        pass
    return ans


def left():#用户按下左键进行的移动
    for i in range(4):
        temp = combinate(board[i])
        for j in range(4):
            board[i][j] = temp[j]


def right():#用户按下右键进行的移动
    for i in range(4):
        temp = combinate(board[i][::-1])
        for j in range(4):
            board[i][3 - j] = temp[j]


def up():#用户按下上键进行的移动
    for i in range(4):
        to_comb = []
        for j in range(4):
            to_comb.append(board[j][i])
        temp = combinate(to_comb)
        for k in range(4):
            board[k][i] = temp[k]


def down():#用户按下下键进行的移动
    for i in range(4):
        to_comb = []
        for j in range(4):
            to_comb.append(board[3 - j][i])
        temp = combinate(to_comb)
        for k in range(4):
            board[3 - k][i] = temp[k]


def write(msg="Winning!!!", color=(255, 255, 0), height=14):#在屏幕上打印字体
    path = 'C:/Windows/Fonts/simhei.ttf'
    myfont = pygame.font.SysFont("simsunnsimsun", height)
    mytext = myfont.render(msg, True, color)
    mytext = mytext.convert_alpha()
    return mytext


def win():#判断当前是否胜利
    for i in range(4):
        for j in range(4):
            if board[i][j] == 2048:#有2048，肯定是胜利了
                return True
    return False


def is_over():#判断当前是否失败
    for i in range(4):
        for j in range(4):
            if board[i][j] == 0:#有0，还有空白处，肯定不算失败
                return False
    for i in range(4):
        for j in range(3):
            if board[i][j] == board[i][j + 1]:#左右有相同的字母，还能够合并，肯定不算失败
                return False
    for i in range(3):
        for j in range(4):
            if board[i][j] == board[i + 1][j]:#上下有相同的字母，还能够合并，肯定不算失败
                return False
    return True#失败了


def game_skill():#游戏技巧介绍
    button_back = Button((left_of_screen + 140, 480), "button_back.jpg", 130, 50)
    screen.blit(background, (0, 0))
    while True:
        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
                pygame.quit()
                exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                if button_back.isOver() == True:
                    return
            pygame.display.update()
            rect = pygame.draw.rect(screen, (251, 248, 241), (10, 10, 500, 580))
            screen.blit(write("1、简单点来说就是尽量不要向上。", height=30, color=(119, 110, 101)), (30, 165))
            screen.blit(write("滑动就可以了,尽量用左下右三个", height=30, color=(119, 110, 101)), (30, 195))
            screen.blit(write("键游戏，让大的方块尽量沉在底部", height=30, color=(119, 110, 101)), (30, 225))
            screen.blit(write("2、数越来越大以后，较大的数要", height=30, color=(119, 110, 101)), (30, 255))
            screen.blit(write("依次靠着这个。让一行中数字顺序", height=30, color=(119, 110, 101)), (30, 285))
            screen.blit(write("紧邻排列。不要总是急于清理桌面。", height=30, color=(119, 110, 101)), (30, 315))
            screen.blit(write("3、因为尽量不向上滑动，所以大的", height=30, color=(119, 110, 101)), (30, 345))
            screen.blit(write("数必然在底下。然后就是不要图快。", height=30, color=(119, 110, 101)), (30, 375))
            screen.blit(write("4、当游戏进行不下去时，NewGame", height=30, color=(119, 110, 101)), (30, 405))
            screen.blit(write("键点击重新开始，祝你玩的愉快。", height=30, color=(119, 110, 101)), (30, 435))
            button_back = Button((left_of_screen + 140, 480), "button_back.jpg", 130, 50)
            screen.blit(write("2048", height=100, color=(119, 110, 101)),
                        (left_of_screen + 110, left_of_screen // 2))

def game_introduce():#游戏玩法介绍
    button_back = Button((left_of_screen + 140, 480), "button_back.jpg", 130, 50)
    screen.blit(background, (0, 0))
    while True:
        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
                pygame.quit()
                exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                if button_back.isOver() == True:
                    return
            pygame.display.update()
            rect = pygame.draw.rect(screen, (251, 248, 241), (10, 10, 500, 580))
            screen.blit(write("游戏的规则很简单", height=30, color=(119, 110, 101)), (135, 165))
            screen.blit(write("需要控制所有方块", height=30, color=(119, 110, 101)), (135, 195))
            screen.blit(write("向同一个方向运动", height=30, color=(119, 110, 101)), (135, 225))
            screen.blit(write("两个相同数字方块", height=30, color=(119, 110, 101)), (135, 255))
            screen.blit(write("撞在一起之后会合", height=30, color=(119, 110, 101)), (135, 285))
            screen.blit(write("并成为他们的加和", height=30, color=(119, 110, 101)), (135, 315))
            screen.blit(write("之后会新产生一个", height=30, color=(119, 110, 101)), (135, 345))
            screen.blit(write("2或4当拼凑得到了", height=30, color=(119, 110, 101)), (135, 375))
            screen.blit(write("2048游戏就算胜利", height=30, color=(119, 110, 101)), (135, 405))
            button_back = Button((left_of_screen + 140, 480), "button_back.jpg", 130, 50)
            screen.blit(write("2048", height=100, color=(119, 110, 101)),
                        (left_of_screen + 110, left_of_screen // 2))


def game_view_page0():#游戏欢迎界面，这里实现了一个动画功能：两排大小颜色不同的“2048小游戏”绕屏幕中心进行旋转
    FPS = 5
    BLACK = (0, 0, 0)
    BROWN = (187, 173, 160)
    WHITE = (255, 255, 255)
    BGCOLOR = BROWN
    titleFont = pygame.font.Font(r'C:\Windows\Fonts\simkai.ttf', 100)
    titleSurf1 = titleFont.render('2048小游戏', True, BLACK)
    titleSurf2 = titleFont.render('2048小游戏', True, WHITE)
    degrees1 = 0
    degrees2 = 0
    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
                exit()
            elif event.type == pygame.MOUSEBUTTONDOWN or event.type == KEYUP:
                return
        screen.fill(BGCOLOR)
        rotatedSurf1 = pygame.transform.rotate(titleSurf1, degrees1)
        rotatedRect1 = rotatedSurf1.get_rect()
        rotatedRect1.center = (screen_width / 2, screen_height / 2 - 50)
        screen.blit(rotatedSurf1, rotatedRect1)
        rotatedSurf2 = pygame.transform.rotate(titleSurf2, degrees2)
        rotatedRect2 = rotatedSurf2.get_rect()
        rotatedRect2.center = (screen_width / 2, screen_height / 2 - 50)
        screen.blit(rotatedSurf2, rotatedRect2)
        screen.blit(write("点击鼠标左键进入游戏", height=30, color=(255, 255, 255)),
                    (left_of_screen + 60, left_of_screen // 2 + 450))
        pygame.display.update()
        FPSCLOCK.tick(10)
        degrees1 += 3
        degrees2 += 5


def game_start_page():#游戏开始界面
    #加载背景图片
    screen.blit(background, (0, 0))
    #创建几个自定义的按钮
    button4 = Button((left_of_screen + 110, 150), b4, 200, 80)
    button5 = Button((left_of_screen + 110, 270), b5, 200, 80)
    button6 = Button((left_of_screen + 110, 390), b6, 200, 80)
    while True:
        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
                pygame.quit()
                exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                if button4.isOver() == True:#如果按下的是button4,即开始游戏
                    return
                elif button5.isOver() == True:#如果按下的是button5，即游戏玩法介绍
                    game_introduce()
                    screen.blit(background, (0, 0))
                    button4 = Button((left_of_screen + 110, 150), b4, 200, 80)
                    button5 = Button((left_of_screen + 110, 270), b5, 200, 80)
                    button6 = Button((left_of_screen + 110, 390), b6, 200, 80)
                elif button6.isOver() == True:#如果按下的是button6，即游戏技巧介绍
                    game_skill()
                    screen.blit(background, (0, 0))
                    button4 = Button((left_of_screen + 110, 150), b4, 200, 80)
                    button5 = Button((left_of_screen + 110, 270), b5, 200, 80)
                    button6 = Button((left_of_screen + 110, 390), b6, 200, 80)
            screen.blit(write("2048", height=100, color=(119, 110, 101)),
                        (left_of_screen + 110, left_of_screen // 2))
            pygame.display.update()


def main():
    # play_music()注释掉了，播放音乐会导致游戏很卡
    global FPSCLOCK, score, high_score, tmpScore, board
    flag = False
    flag2 = False
    FPSCLOCK = pygame.time.Clock()
    game_view_page0()#游戏欢迎界面
    game_start_page()#游戏主菜单界面
    b = [[0, 0, 0, 0],#b是用来记录每次用户移动前一步的棋盘状态的，可以用于实现“回到上一步”功能
         [0, 0, 0, 0],
         [0, 0, 0, 0],
         [0, 0, 0, 0]]
    screen.blit(background, (0, 0))
    init_board()
    newboard = deepcopy(board)
    gameover = is_over()
    draw_box(1)
    button = Button((left_of_screen + 210, left_of_screen // 2 + 5), "button3.jpg", 100, 60)
    screen.blit(write("2048", height=60, color=(119, 110, 101)),
                (left_of_screen, left_of_screen // 2))
    high_score = load_data()

    while True:
        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):#用户如果按了ESC，退出
                pygame.quit()
                exit()
            elif not gameover:#如果当前游戏还没有失败（棋盘上还有空格，即数字0）
                if win() == True:#如果当前赢了（拼出来了数字2048）
                    screen.blit(write("You win!", height=40, color=(119, 110, 101)),#屏幕上打印“You win!”
                                (left_of_screen + 160, screen_height // 2 - 30))
                elif event.type == KEYUP and event.key == K_UP:#用户按了 up 键
                    tmpScore = score
                    flag = False
                    up()
                elif event.type == KEYUP and event.key == K_DOWN:#用户按了 down 键
                    tmpScore = score
                    flag = False
                    down()
                elif event.type == KEYUP and event.key == K_LEFT:#用户按了 left 键
                    tmpScore = score
                    flag = False
                    left()
                elif event.type == KEYUP and event.key == K_RIGHT:#用户按了 right 键
                    tmpScore = score
                    flag = False
                    right()
                elif event.type == pygame.MOUSEBUTTONDOWN:#用户点击了鼠标，也就是用户按下了重新开始的按钮
                    button.render()#重新开始一局游戏
                    flag = False#初始化各个数值
                    flag2 = True
                elif event.type == KEYUP and event.key == K_SPACE:#用户按了 space 打算回到上一步
                    if flag == False:
                        board = deepcopy(b)
                        score = tmpScore
                        flag = True
                if newboard != board:
                    b = deepcopy(newboard)
                    if flag == False and flag2 == False:
                        set_random_number()
                    flag2 = False
                    newboard = deepcopy(board)
                    draw_box(1)
                gameover = is_over()
            else:#否则判定用户本局游戏失败
                screen.blit(write("Game over!", height=40, color=(119, 110, 101)),#打印失败信息
                            (left_of_screen + 140, screen_height // 2 - 40))
                if score > high_score:#如果用户的分数比本机最高得分高
                    screen.blit(write("New record!", height=40, color=(119, 110, 101)),#提示用户刷新了记录
                                (left_of_screen + 140, screen_height // 2 + 10))
                    high_score = score
                    with open(high_score_name, "w") as f:
                        f.write(str(high_score))#用新的得分覆盖原有的最高得分
                if event.type == pygame.MOUSEBUTTONDOWN:#用户点击了鼠标，也就是用户按下了重新开始的按钮
                    gameover = False
                    score = 0
                    tmpScore = 0#初始化各个数值
                    button.render()#重新开始一局游戏
                    flag2 = True

        pygame.display.update()
        rect1 = pygame.draw.rect(screen, (187, 173, 160),
                                 (left_of_screen + 120, left_of_screen // 2 + 5, 80, 60))
        rect2 = pygame.draw.rect(screen, (187, 173, 160),
                                 (left_of_screen + 320, left_of_screen // 2 + 5, 105, 60))
        screen.blit(write("score:", height=28, color=(255, 255, 255)),
                    (left_of_screen + 125, left_of_screen // 2 + 5))
        screen.blit(write("best:", height=30, color=(255, 255, 255)),
                    (left_of_screen + 340, left_of_screen // 2 + 5))
        text1 = write(str(score), height=30, color=(255, 255, 255))
        text2 = write(str(high_score), height=30, color=(255, 255, 255))
        text_rect = text1.get_rect()
        text_rect2 = text2.get_rect()
        text_rect.center = (left_of_screen + 160, left_of_screen // 2 + 50)
        text_rect2.center = (left_of_screen + 370, left_of_screen // 2 + 50)
        screen.blit(text1, text_rect)
        screen.blit(text2, text_rect2)


if __name__ == "__main__":
    main()


直接复制源代码是不可以运行的，缺少了图片素材等本地文件。我把这些东西都放在我的GitHub上，需要的同学可去下载。

Pygame-2048

记得顺便给个star~OvO

另外小小博主还有一篇C语言制作的推箱子，感兴趣的同学可以去看看。学完C语言能干啥？先来做个推箱子吧~（有图片呦）

That's all, thanks for watching~

	

前段时间搞定解数独的算法，接下来准备做一个数独游戏，那就必须要用到pygame库。pygame库设计用来写游戏的python模块集合，是对优秀的SDL库的封装，pygame基本上是用python开发2D游戏的不二之选。
接触pygame是从去年开始的，开始是照着书上做了一个飞机大战的游戏，有点类似儿时任天堂红白机上的小蜜蜂。后来自己摸索做了扫雷、贪吃蛇两个小游戏。这个扫雷其实最终是烂尾了，主要是里面的一个递归算法百撕不得其姐，后来干脆放弃了。为了重温pygame的用法，为数独游戏打好基础，决定把这个烂尾扫雷项目重新启动，一定要把这个问题搞定，咱毕竟不是始乱终弃的人。
于是重新翻出来去年写的扫雷源代码，发现一个严重问题，原来的代码看不懂了，以前一句注释都没写，现在看来简直是天书一样，做一个合格的码农还首先要勤快。硬着头皮终于弄懂了原来的代码，并通过摸索递归算法的原理，最终解决了这个头疼的问题。
一、概况
扫雷游戏是windows自带的经典游戏，相比每个人都玩过，基本套路就是翻开雷区矩阵中每一个按钮，根据每一个按钮下面提示的周围地雷数，逐步把整个雷区中的地雷都找出来，翻开的如果是地雷就game over。
二、主要功能
整个扫雷游戏大致可以主要归纳为如下几个功能：
绘制雷区
布雷
计算每一块周边的8个方块中的地雷数
左键单击一个地雷块就翻开，如果这个块周边地雷数为0，就把周边的地雷块都翻开，直到翻开其周边地雷数>0的地雷块，就是扫雷中一键点开一片的功能。(去年项目烂尾就烂在这个递归算法上)
右键单击一个地雷块时，给这个块标注为推断地雷。
左右键同时单击一个地雷块时，可以翻开周边8块中根据已翻开的地雷块可以明确推断的地雷块。
计分系统。
本次v1.0版扫雷主要实现扫雷的基本功能，即前述1-5功能，功能6和7接下来的版本会继续完善，而且这次的1.0版也主要是实现基本功能，动画效果一概没有，配色方案也很ugly，雷区采用9*9，地雷数只有9个。总之功能简单，界面很丑，主要是实现主要算法。
三、主要功能的实现概述
为了显得有点专业，也是为了以后扩展方便，首先定义了一个setting类。主要定义一些基本的参数，目前仅定义了游戏窗口的宽度和高度，其实还可以定义一些颜色常量等。
定义了一个MineObj类，就是每一个地雷块，主要定义了是否是地雷的标记、周边地雷计数、地雷块的翻开状态标记等。
定义一个Button类，这个类就是每一个地雷块的实体，主要定义了与地雷块操作有关的变量和动作，包括背面颜色、翻开颜色、显示字体等等。这个类和MineObj类有一定关系但也不同，Button类主要是地雷块的表象，MineObj类是内容。简单说就是Button是肉体，MineObj是灵魂。
接下来是主流程，首先定义一个MineObj的9*9的矩阵；然后随机部署9个地雷在这个矩阵中；接下来遍历每一个地雷块，如果是地雷就标注地雷，不是地雷计算出其周边8个地雷块中有几个地雷，把数字写入MineObj的属性中；然后就是游戏主循环，监控鼠标操作，根据鼠标左键单击或右键单击选择不同的操作，左键就是翻开，右键就是插旗子标注为推断地雷。(为了简单，就不像真的扫雷游戏那样用图片表示地雷和旗子了，这里地雷用字母”B“表示，旗子用字母”F"表示)
四、我认为的两个关键技术问题
整个程序中我觉得两个技术问题值得介绍一下，一个是遍历某一个地雷块周边的地雷块的函数；一个就是那个递归算法。
1、get_around()函数
开始我是用了一个两层循环，而且还要判断是否超出矩阵的边界，并且要避开其本身单元格，所以很麻烦，也容易出错。后来在百度了一下，有人用了一个很巧妙的办法把这个问题解决了，我觉得有必要记录一下，这个思路以后也用得上。
def get_around(x,y):	return [(i,j) for i in range(max(0,x-1),min(9-1,x+1)+1) for j in range(max(0,y-1),min(9-1,y+1)+1) if i !=x or j != y]
2、递归算法
通过这个递归算法，我也看出了我和一个码农的智商差距还是相当大的，估计这个问题在我非常尊敬的L大师、W大师看来都是小儿科一般的问题，我却用了一年多才闹明白。这里简单介绍下递归的算法原理，并通过两个经典的案例来实操一下递归算法，一个是阶乘问题，一个是汉诺塔问题。
递归算法简介
递归(recursion)作为一种算法在程序设计中应用非常广泛，一个函数直接或间接调用其自身就是递归。递归可以把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。
递归有两个关键要素：一是边界条件，确定递归何时结束，也城维递归出口(去年的扫雷烂尾就是因为这个边界条件不明确)；二是递归模式，大问题是如何分解为小问题的，也称为递归体。
接下来利用两个经典递归案例来说明递归算法。
递归算法案例
阶乘问题
求n的阶乘，其实用一个循环就可以解决，但是用递归解决可以很直观的体现阶乘的基本概念。
n!不会解，那就先解(n-1)!，还不会，那就继续先求解(n-1-1)!,……直到1!总归会解了吧，1!=1就是这个递归的边界条件。一张图可以很直观的反映这个过程：
代码如下：
def fac(n):	print(n)	if n==1:		return 1	return n*fac(n-1)ans=1	ans=fac(995)print(ans)
汉诺塔问题
汉诺塔问题是递归函数的经典应用，它来自一个古老传说：在世界刚被创建的时候有一座钻石宝塔A，其上有64个金蝶。所有碟子按从大到小的次序从塔底堆放至塔顶。紧挨着这座塔有另外两个钻石宝塔B和C。从世界创始之日起，波罗门的牧师就一直在试图把塔A上的碟子移动到C上去，其间借助于塔B的帮助。每次只能移动一个碟子，任何时候都不能把一个碟子放在比它小的碟子上面。当牧师们完成这个任务时，世界末日也就到了。对于汉诺塔问题的求解，可以通过以下3步实现：(1)将塔A上的n -1个碟子借助C塔先移动到B塔上；(2)把塔A上剩下的一个碟子移动到塔C上；(3)将n - 1个碟子从B塔借助塔A移动到塔C上。
i=1def move(n,mfrom,mto):	global i	print("step%d, move plate No. %d from %s to %s" %(i,n,mfrom,mto))	i+=1	def hanoi(n,A,B,C):	if n==1:		move(1,A,C)	else:		hanoi(n-1,A,C,B)		move(n,A,C)		hanoi(n-1,B,A,C)n=3hanoi(n,'A','B','C')
五、扫雷源代码
扫雷v1.0一共包括两个文件，其实每一个类都最好用一个单独的文件来定义，我这里就简化了，只是把稍微复杂点的Button类单独存了一个文件。
button.py
import pygame.fontclass Button():	def __init__(self,screen,mineobj,point_topleft):		self.screen=screen		self.mineobj=mineobj		self.ismine =mineobj.ismine		self.flag=False		self.minecount=mineobj.minecount		self.screen_rect=screen.get_rect()		self.width=self.height=29		self.back_color=(0,0,255)		self.front_color=(230,230,230)		self.text_color=(255,0,0)		self.font=pygame.font.SysFont(None,28)		self.rect=pygame.Rect(0,0,self.width,self.height)		self.rect.topleft=point_topleft		#self.prep_msg('')		def prep_msg(self,msg,buttonstatus=0):		if buttonstatus==-1:			self.text_front_color=(0,0,255)		else:			self.text_front_color=(230,230,230)		self.msg_image=self.font.render(msg,True,self.text_color,self.text_front_color)		self.msg_image_rect=self.msg_image.get_rect()		self.msg_image_rect.center=self.rect.center			def draw_button(self,buttonstatus):		if buttonstatus==-1:			self.prep_msg('',buttonstatus)			self.screen.fill(self.back_color,self.rect)		elif buttonstatus==0:			if self.mineobj.ismine==True:				self.prep_msg('B')			else:				if self.mineobj.minecount==0:					self.prep_msg('')				else:					self.prep_msg(str(self.mineobj.minecount))			self.screen.fill(self.front_color,self.rect)		elif buttonstatus==2:			self.prep_msg('F')			self.screen.fill(self.back_color,self.rect)							self.screen.blit(self.msg_image, self.msg_image_rect)
mine_sweeper.py
import pygame,sys,randomfrom button import Buttonclass MineObj():	def __init__(self):		self.ismine=False		self.minecount=0		self.open_status=0class Settings():	def __init__(self):		self.screen_width=370		self.screen_height=340		def get_around(x,y):	return [(i,j) for i in range(max(0,x-1),min(9-1,x+1)+1) for j in range(max(0,y-1),min(9-1,y+1)+1) if i !=x or j != y]def mine_open(my_minebuttons,my_minearray,my_pressedrow,my_pressedcolm):	if my_minearray[my_pressedrow][my_pressedcolm].minecount==0 and my_minearray[my_pressedrow][my_pressedcolm].open_status==0:		my_minearray[my_pressedrow][my_pressedcolm].open_status=1		for i,j in get_around(my_pressedrow,my_pressedcolm):						mine_open(my_minebuttons,my_minearray,i,j)	else:		my_minearray[my_pressedrow][my_pressedcolm].open_status=1	my_minebuttons[my_pressedrow][my_pressedcolm].draw_button(0)							def run_game():	minerow=[]	minecolm=[]	pygame.init()	ms_settings = Settings()	screen=pygame.display.set_mode((ms_settings.screen_width,ms_settings.screen_height))	pygame.display.set_caption("MineSweeper 1.0")	bg_color=(230,230,230)	line_color=(0,0,0)	screen.fill(bg_color)		pygame.draw.line(screen,line_color,(48,58),(320,58),2)	pygame.draw.line(screen,line_color,(319,59),(319,330),2)	pygame.draw.line(screen,line_color,(48,58),(48,330),2)	pygame.draw.line(screen,line_color,(49,329),(320,329),2)	for i in range(8):		pygame.draw.line(screen,line_color,(50+29*(i+1)+i,60),(50+29*(i+1)+i,330),1)		pygame.draw.line(screen,line_color,(50,60+29*(i+1)+i),(320,60+29*(i+1)+i),1)			mine_array=[[] for i in range(11)]		for i in range(9):		for j in range(9):			mine_array[i].append(MineObj())	for i in range(9):		minerow.append(random.randint(0,8))		minecolm.append(random.randint(0,8))		mine_array[minerow[i]][minecolm[i]].ismine=True			#print(minerow)	#print(minecolm)		for i in range(9):		for j in range(9):			if mine_array[i][j].ismine==False:				for m,n in get_around(i,j):					if mine_array[m][n].ismine == True:						mine_array[i][j].minecount +=1								mine_buttons=[[] for i in range(9)]		for i in range(9):		for j in range(9):			mine_buttons[i].append(Button(screen,mine_array[i][j],(50+j*30,60+i*30)))			mine_buttons[i][j].draw_button(-1)		while True:			for event in pygame.event.get():				if event.type == pygame.QUIT:					pygame.quit()					sys.exit()				elif event.type==pygame.MOUSEBUTTONDOWN:					pressed_array= pygame.mouse.get_pressed()					pos=pygame.mouse.get_pos()					mouse_x=pos[0]					mouse_y=pos[1]					if 50<=mouse_x<=320 and 60<=mouse_y<=330:						pressedrow=int((mouse_y-60)/30)						pressedcolm=int((mouse_x-50)/30)						for index in range(len(pressed_array)):							if pressed_array[index]:								if index==0:									mine_open(mine_buttons,mine_array,pressedrow,pressedcolm)																	if index==2:									mine_buttons[pressedrow][pressedcolm].draw_button(2)			pygame.display.flip()	run_game()
效果
直接上运行效果。