2048小游戏

最新推荐文章于 2023-11-19 16:10:44 发布
最新推荐文章于 2023-11-19 16:10:44 发布
阅读量331 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mkgdjing/article/details/86632628
版权

绘制棋盘

import random
#画分隔符
def draw_sep():
    print('+-----'*4+'+')

#画格子
def draw_one_row(row):
    print(''.join(['|  %d  '%(item) if item != 0 else '|     'for item in row])+'|')


#创建棋盘数据，默认情况下4*4，数值全为0
field =[[0 for j in range(4)]for i in range(4)]
# print(field)

#开始游戏时，棋盘数据随机生成2或者4

def random_create():
    while True:
        firstIndex = random.choice(range(4))
        secondIndex = random.choice(range(4))
        if field[firstIndex][secondIndex] == 0:
            value = random.choice([2,2,2,2,4])
            field[firstIndex][secondIndex] = value
            break
# random_create()
# random_create()
# print(field)

def game():
    random_create()
    random_create()
    for row in field:
        draw_sep()
        draw_one_row(row)
    draw_sep()

if __name__=='__main__':
    game()

在这里插入图片描述

判断棋盘是否可以左右移动

1 .判断是否可以向左移动

  • 判断棋盘是否可以向左移动?
  • 1). 只要棋盘的任意一行可以向左移动， 就返回True；
    目标: 如何判断棋盘的一行是否可以向左移动?
    2). 只要这一行的任意两个元素可以向左移动， 则返回True;
    目标: 如何两个元素可以向左移动?
    # - 如果第一个数值为0， 第二个数值不为0， 则说明可以向左移动；
    # - 如果第一个数值不为0， 第二个数值与第一个元素相等， 则说明可以向左移动；
def is_row_left(row):
    def is_change(index):
        if row[index] ==0 and row[index+1]!=0:    # 如果第一个数值为0， 第二个数值不为0， 则说明可以向左移动；
            return True
        if row[index]!=0 and row[index+1] == row[index]:   # 如果第一个数值不为0， 第二个数值与第一个元素相等， 则说明可以向左移动；
            return True
        return False
    return any([is_change(row) for row in range(3)]) # 只要这一行的任意两个元素可以向左移动， 则返回True;

def is_move_left(field):
#只要有一行可以向左移动就返回Ture

    return any(is_row_left(row) for row in field)

if __name__=='__main__':
    try:
        assert is_move_left([[0,0,0,0],[0,2,0,0],[0,0,0,0],[0,0,0,4]]) == True,'棋盘向左移动失败'
        assert is_row_left([2,2,2,2])==True,'Error'
        assert is_row_left([2,4,2,4])==False,'Error'
    except AssertionError as e:
        print(e)
    else:
        print('测试用例完成')

在这里插入图片描述
2.判断是否可以向右移动

from chess import  is_move_left

def invert(field):
    """矩阵的反转"""
    return  [row[::-1] for row in field]

def is_move_right(field):
    # 对棋盘的每一行元素进行反转;
    invertField = invert(field)
    return  is_move_left(invertField)
if __name__ == '__main__':
    assert  is_move_right([[0, 0, 0, 0], [0, 2, 0, 0], [0, 0, 0, 0], [0, 0, 0, 4]]) == True, 'Error'
    print(is_move_right([[0, 0, 0, 0], [0, 2, 0, 0], [0, 0, 0, 0], [0, 0, 0, 4]]))

在这里插入图片描述

判断棋盘是否可以上下移动

def transpose(field):
    """实现矩阵的转置"""
    # zip: 实现
    # *field对列表进行解包;
    return  list(zip(*field))

def is_move_up(field):
    # 对棋盘的每一行元素进行转置;
    transposeField = transpose(field)
    return  is_move_left( transposeField)


def is_move_down(field):
    # 判断能否向下移动, 也就是对于元素进行转置, 判断转置后的棋盘能否向右移动;
    # 对棋盘的每一行元素进行反转;
    transposeField = transpose(field)
    return is_move_right(transposeField)
if __name__ == '__main__':
    print(invert([[0, 0, 0, 0], [0, 2, 0, 0], [0, 0, 0, 0], [0, 0, 0, 4]]))
    print(transpose([[0, 2, 0, 2], [0, 2, 0, 0], [0, 0, 0, 0], [2, 0, 0, 4]]))

在这里插入图片描述

实现棋盘的移动

# 棋盘向左移动?
#  1). 只要棋盘的每一行可以向左移动， e；
#          目标: 如何让棋盘的每一行向左移动?
#           [2， 2， 2， 2] === [4, 4, 0 ,0 ]
#           讨论:
#               1). 先把这一行的非0 数字向前放， 0向后放；   ==== [2, 2, 2, 2]
#               2). 依次循环判断两个数是否相等， 如果相等， 第一个*2， 第二个数为0；  【4， 0， 4， 0】
#               3).先把这一行的非0数字向前放， 0向后放；[4, 4, 0 ,0 ]

score = 0
def invert(field):
    """矩阵的反转"""
    return  [row[::-1] for row in field]

def transpose(field):
    """实现矩阵的转置"""
    # zip: 实现
    # *field对列表进行解包;
    return  list(zip(*field))


# 1). 先把这一行的非0 数字向前放， 0向后放；   ==== [2, 2, 2, 2]
def tight(row):  # [2,0,2,0]
    return sorted(row, key=lambda x: 1 if x == 0 else 0)


# 2). 依次循环判断两个数是否相等， 如果相等， 第一个*2， 第二个数为0；  【4， 0， 4， 0】
def merge(row):
    for index in range(3):
        if row[index] == row[index + 1]:
            row[index] *= 2
            row[index + 1] = 0
            # 如果合并完成， 分数增加row[index]
            global score
            score += row[index]
    return row


def move_row_left(row):
    return tight(merge(tight(row)))

def move_left(field):
    return  [move_row_left(row) for row in field]

def move_right(field):
    field = invert(field)
    return  invert(move_left(field))

def move_up(field):
    field = transpose(field)
    return  transpose(move_left(field))


def move_down(field):
    field = transpose(field)
    return transpose(move_right(field))

if __name__ == '__main__':
    print(move_right([[0, 0, 0, 0], [0, 2, 0, 0], [0, 0, 0, 0], [0, 0, 0, 4]]))
    print(move_right([[0, 0, 2, 2], [0, 2, 4, 4], [0, 2, 0, 0], [2, 2, 0, 4]]))
    print(move_up([[0, 0, 0, 0], [0, 2, 0, 0], [0, 0, 0, 0], [0, 0, 0, 4]]))
    print(move_up([[0, 0, 2, 2], [0, 2, 4, 4], [0, 2, 0, 0], [2, 2, 0, 4]]))
    print(move_down([[0, 0, 2, 2], [0, 2, 4, 4], [0, 2, 0, 0], [2, 2, 0, 4]]))

在这里插入图片描述

游戏结束条件

# 1. 何时用户游戏胜利?(当棋盘中出现num=2048时， 则代表用户胜利)
from itertools import  chain
field = [[2048, 0, 0, 0], [0, 0, 0, 0], [0, 0, 4, 0], [0, 0, 0, 4]]

def is_win(field):
    """
    list(chain(*[[2048, 0, 0, 0], [0, 0, 0, 0], [0, 0, 4, 0], [0, 0, 0, 4]]))
    [2048, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 4]
    :param field:
    :return:
    """
    # 遍历所有的元素， 有一个元素大于等于2048， 即游戏胜利!
    # for row in field:
    #     for item in row:
    #         if item >= 2048:
    #             return  True
    # else:
    #     return  False
    return  max(chain(*field) >= 2048)
print(is_win(field))




# 2. 何时game over?(当用户在任何方向都不能移动时， 则代表游戏结束， 用户失败)
# 只要有任意一个方向可以移动， 那就没有结束
def is_over():
    return  not any([is_move_left(field),is_move_right(field),
                     is_move_up(field),is_move_down(field), ])

完整代码

import curses
import random
from itertools import chain


class GameField(object):
    def __init__(self, width=4, height=4, win_score=2048):
        self.width = width
        self.height = height
        self.score = 0  # 当前得分
        self.highscore = 0  # 最高分
        self.win_score = win_score
        # 存储判断各个方向是否可移动的函数?
        self.moves = {}
        self.moves['Left'] = self.is_move_left
        self.moves['Right'] = self.is_move_right
        self.moves['Up'] = self.is_move_up
        self.moves['Down'] = self.is_move_down
        #  # 存储执行各个方向移动的函数?
        self.movesDict = {}
        self.movesDict['Left'] = self.move_left
        self.movesDict['Right'] = self.move_right
        self.movesDict['Up'] = self.move_up
        self.movesDict['Down'] = self.move_down

    # 重置棋盘， 重新开始游戏时， 执行的操作;
    def reset(self):
        # 2). 是否要更新最高分, 当前分数为0；
        if self.score > self.highscore:
            self.highscore = self.score
        self.score = 0

        # 3). 创建棋盘的数据， 默认情况下时4*4， 数值全为0；
        self.field = [[0 for j in range(self.height)] for i in range(self.width)]

        self.random_create()
        self.random_create()

    # 开始游戏时， 棋盘数据会随机生成2或者4，
    def random_create(self):
        # field[0][2] = 2
        while True:
            firstIndex = random.choice(range(self.height))
            secondIndex = random.choice(range(self.width))
            if self.field[firstIndex][secondIndex] == 0:
                value = random.choice([2, 4, 2, 2, 2])
                self.field[firstIndex][secondIndex] = value
                break

    # 画棋盘
    def draw(self, stdstr):
        def draw_sep():
            # print("+-----" * 4 + '+')
            stdstr.addstr("+-----" * self.width + '+' + '\n')

        # 2. 画每一行的格子
        def draw_one_row(row):  # [0, 2, 0, 0]   |    |  2  |    |    |
            stdstr.addstr("".join(['|  %d  ' % (item) if item != 0 else '|     ' for item in row]) + '|\n')

        stdstr.clear()
        stdstr.addstr(''.center(42, "*")+'\n')
        stdstr.addstr('2048游戏'.center(40, '*')+'\n')
        stdstr.addstr(''.center(42, '*')+'\n')
        # 3. 绘制棋盘
        for row in self.field:
            draw_sep()
            draw_one_row(row)
        draw_sep()
        stdstr.addstr("\n当前分数: %s" % (self.score))
        stdstr.addstr("\n当前最高分数: %s" % (self.highscore))
        stdstr.addstr(" \n游戏帮助: 上下左右键  (R)estart E(xit) ")
        if self.is_win():
            stdstr.addstr("\n游戏胜利\n")
        if self.is_gameover():
            stdstr.addstr("游戏失败\n")

    def is_win(self):
        # return max(chain(*self.field)) >= 2048
        return max(chain(*self.field)) >= self.win_score

    def is_gameover(self):
        return not any([self.is_move_left(self.field),
                        self.is_move_right(self.field),
                        self.is_move_up(self.field),
                        self.is_move_down(self.field)])


    def is_row_left(self, row):  # [0, 2,2,0]
        # 任意两个元素可以向左移动？
        def is_change(index):  # index时索引值， [0,1,2,3]
            # - 如果第一个数值为0， 第二个数值不为0， 则说明可以向左移动；
            if row[index] == 0 and row[index + 1] != 0:
                return True
            # - 如果第一个数值不为0， 第二个数值与第一个元素相等， 则说明可以向左移动；
            if row[index] != 0 and row[index + 1] == row[index]:
                return True
            return False

        # 只要这一行的任意两个元素可以向左移动， 则返回True;
        return any([is_change(index) for index in range(self.width-1)])



    def invert(self, field):
        """矩阵的反转"""
        return [row[::-1] for row in field]


    def transpose(self, field):
        """实现矩阵的转置"""
        # zip: 实现
        # *field对列表进行解包;
        return [ list(row) for row in zip(*field)]



    def is_move_left(self, field):
        # 只要棋盘的任意一行可以向左移动， 就返回True；
        return any([self.is_row_left(row) for row in field])
    def is_move_right(self, field):
        # 对棋盘的每一行元素进行反转;
        invertField = self.invert(field)
        return  self.is_move_left(invertField)

    def is_move_up(self, field):
        # 对棋盘的每一行元素进行转置;
        transposeField = self.transpose(field)
        return  self.is_move_left( transposeField)

    def is_move_down(self, field):
        # 判断能否向下移动, 也就是对于元素进行转置, 判断转置后的棋盘能否向右移动;
        # 对棋盘的每一行元素进行反转;
        transposeField = self.transpose(field)
        return self.is_move_right(transposeField)

    # 1). 先把这一行的非0 数字向前放， 0向后放；   ==== [2, 2, 2, 2]
    def tight(self, row):  # [2,0,2,0]
        return sorted(row, key=lambda x: 1 if x == 0 else 0)

    # 2). 依次循环判断两个数是否相等， 如果相等， 第一个*2， 第二个数为0；  【4， 0， 4， 0】
    def merge(self, row):
        for index in range(self.width-1):
            if row[index] == row[index + 1]:
                row[index] *= 2
                row[index + 1] = 0
                # 如果合并完成， 分数增加row[index]
                self.score += row[index]
        return row

    def move_row_left(self, row):
        return self.tight(self.merge(self.tight(row)))

    def move_left(self, field):
         return [self.move_row_left(row) for row in field]

    def move_right(self, field):
        field = self.invert(field)
        return self.invert(self.move_left(field))

    def move_up(self, field):
        field = self.transpose(field)
        return self.transpose(self.move_left(field))

    def move_down(self, field):
        field = self.transpose(field)
        return self.transpose(self.move_right(field))


    def move(self, direction):
        # 1). 判断这个方向是否可以移动?
        # 2). 执行移动的操作
        # 3). 再随机生成一个2或者4

        # 确保是上下左右的按键
        if direction in self.moves:
            # 1).判断这个方向是否可以移动?
            if self.moves[direction](self.field):
                self.field = self.movesDict[direction](self.field)
                self.random_create()
        else:
            return False


def get_user_action(stdstr):
    # 获取用户键盘输入的内容
    action = stdstr.getch()
    if action == curses.KEY_UP:
        return 'Up'
    if action == curses.KEY_DOWN:
        return 'Down'
    if action == curses.KEY_LEFT:
        # stdstr.addstr("left")
        return 'Left'
    if action == curses.KEY_RIGHT:
        # stdstr.addstr("right")
        return 'Right'
    # 获取字母r的ASCII码
    if action == ord('r'):
        # stdstr.addstr("重新开始")
        return 'Restart'
    if action == ord('e'):
        # stdstr.addstr("退  出")
        return 'Exit'


def main(stdstr):
    game_field = GameField(width=4, height=4, win_score=2048)

    def init():
        game_field.reset()
        game_field.draw(stdstr)
        return 'Game'

    def game():
        # 重新绘制棋盘
        game_field.draw(stdstr)
        action = get_user_action(stdstr)
        if action == 'Restart':
            return 'Init'
        if action == 'Exit':
            return 'Exit'
        if game_field.move(action):
            # move函数
            if game_field.is_win():
                return 'Win'
            if game_field.is_gameover():
                return 'Gameover'
        return 'Game'

    def not_game():
        action = get_user_action(stdstr)
        if action == 'Restart':
            return 'Init'
        if action == 'Exit':
            return 'Exit'

    state = 'Init'

    state_dict = {
        'Init': init,
        'Game': game,
        'Win':not_game,
        'Gameover':not_game,
        'Exit': exit
    }

    while True:
        state = state_dict[state]()


        # if state == 'Init':
        #     # 通过初始化函数， 进入游戏状态;
        #     state = init()
        # if state == 'Game':
        #     # 执行game函数， 判断用户的操作；
        #     # 1). 继续游戏; (upo, down, left, right)
        #     # 2). 重新开始；(R)
        #     # 3). 退出;(Q)
        #
        #     state = game()
        #
        # if state == 'Win':
        #     # 没有进行游戏， 只有两种状态;
        #     # 1). 重新开始；(R)
        #     # 2). 退出;(Q)
        #     state = not_game()
        # if state == 'Gameover':
        #     state = not_game()
        # if state == 'Exit':
        #     exit()

curses.wrapper(main)

在这里插入图片描述

软件测试（2048小游戏测试用例）
weixin_30838921的博客
05-17 1496
2048小游戏测试用例 转载于:https://www.cnblogs.com/zzz-0613/p/6866478.html
案例：小游戏2048
qq_44147941的博客
10-12 270
实现效果 1.开始时棋盘内随机出现两个数字，出现的数字仅可能为2或4 2.玩家可以选择上下左右四个方向，若棋盘内的数字出现位移或合并，视为有效移动 3.玩家选择的方向上若有相同的数字则合并，每次有效移动可以同时合并，但不可以连续合并 合并所得的所有新生成数字想加即为该步的有效得分 玩家选择的方向行或列前方有空格则出现位移 每有效移动一步，棋盘的空位(无数字处)随机出现一个数字(依然可能为2或4)...
小程序版2048小游戏-项目源码-基于微信小程序开发框架的小游戏
最新发布
03-27
此款小游戏采用了模块化的设计思路，将游戏逻辑与界面渲染分离，保证了代码的可读性和可维护性。前端使用了简洁明了的HTML和CSS技术，结合微信小程序框架，实现了流畅的动画效果和响应式布局。后端则采用了高效的...
(基于微信小程序的毕业设计)2048小游戏小程序(源码).rar
05-16
(基于微信小程序的毕业设计)2048小游戏小程序(源码)(基于微信小程序的毕业设计)2048小游戏小程序(源码)(基于微信小程序的毕业设计)2048小游戏小程序(源码)(基于微信小程序的毕业设计)2048小游戏小程序(源码)(基于...
鸿蒙2048小游戏.zip
02-07
【鸿蒙2048小游戏.zip】这个压缩包文件，主要涉及的是华为的鸿蒙操作系统（HarmonyOS）上的一款游戏开发项目。鸿蒙系统，是华为推出的一款面向全场景的分布式操作系统，旨在打破不同设备之间的壁垒，实现硬件间的...
微信小程序经典2048小游戏实现版
03-16
标题中的“微信小程序经典2048小游戏实现版”指的是基于微信小程序平台开发的一个游戏应用，它是对流行数字拼图游戏2048的改编。2048游戏的规则简单，玩家通过上下左右滑动屏幕，使得数字方块合并，每次合并相同数字...
基于6818开发板实现2048小游戏和电子相册
06-21
（1）基于6818开发板使用C语言实现2048小游戏和电子相册 （2）2048小游戏实现步骤 1.进行初始化，触摸屏，LCD还有图片的初始化 2.游戏初始化，随机生成两个数字方块，开始进入游戏 3.封装显示图片函数功能 4.点击...
青少年CTF-WEB-2048
m0_73734159的博客
11-19 2427
String.fromCharCode将Unicode 编码转换成字符串形式。一、有参数改参数的数值达到题目规定的分数即可拿到flag。这道题并没有说题目通关即可获得flag，也并没有发现参数。二、没有参数那么flag就是被编码了，找编码即可。所以这里猜测flag被编码了，就在源代码里面。alert是JavaScript的弹窗方法。针对这种游戏通关类题目，常见的有两种情况。使用script标签将其作为JS代码执行。查看2048.js文件内容。
c++实现2048小游戏
qq_61859982的博客
03-13 4638
#include<bits/stdc++.h>//万能头文件 using namespace std; class RandomNumber { public: RandomNumber() { srand(time(0)); } int get(int begin = 0, int end = 1) { return rand() % (end - begin + 1) + begin; }//这是随机生成数字 }; int ma...
iOS端2048小游戏开发教程
综合以上知识点，可以看出“iOS 2048小游戏课件资源”这个文件包含了关于iOS开发环境的搭建、2048游戏逻辑的实现、手势控制的编程技术、Objective-C/Swift的编程实践、项目文件的管理以及应用打包发布的整个过程。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值