自制2048小游戏（附源码）

概述

　　作者这几天去一趟湖南，这快车真“快”啊，跨越3个省需要接近一天时间。。。坐火车实在无聊就去玩2048，结果一遍一遍的手滑失误，导致心态爆炸。想了想干脆自己做个2048算了，顺便还可以写外挂上分！

Python Code

MainWindow:

#!/usr/bin/python
#  -*- coding:utf-8 -*-
'''
Created on Mar 24, 2017

@author: zhengli
'''

import copy
import numpy
from PyQt5.QtCore import Qt
from PyQt5.QtGui import (QIcon, QFont)
from PyQt5.QtWidgets import (QAction,  QDesktopWidget, QGridLayout, QMainWindow, QMessageBox, QToolTip, QWidget)
import GameCanvas


class App(QMainWindow):
    """
    Main Window.
    """

    # noinspection PyArgumentList
    def __init__(self):

        QMainWindow.__init__(self)

        # noinspection PyCallByClass,PyTypeChecker
        QToolTip.setFont(QFont('SansSerif', 10))
        self.setGeometry(100, 100, 600, 600)
        self.frameGeometry().moveCenter(QDesktopWidget().availableGeometry().center())
        self.move(self.frameGeometry().topLeft())
        self.setWindowTitle('2048')
        self.setWindowIcon(QIcon('python.png'))
        self.setWindowFlags(Qt.WindowStaysOnTopHint)

        self.action = dict()
        self.actionLoad()
        self.menuBarLoad()

        self.data = dict()
        self.canvas = 0
        self.gameImage(4, 4)

        self.statusBar().showMessage('Ready')

        self.show()

    def actionLoad(self):
        """
        set MainData.action
        """
        self.action["4X4"] = QAction('4X4', self)
        self.action["4X4"].setShortcut('Ctrl+4')
        self.action["4X4"].setStatusTip('4X4 game')
        self.action["4X4"].triggered.connect(lambda: self.gameImage(4, 4))

        self.action["5X5"] = QAction('5X5', self)
        self.action["5X5"].setShortcut('Ctrl+5')
        self.action["5X5"].setStatusTip('5X5 game')
        self.action["5X5"].triggered.connect(lambda: self.gameImage(5, 5))

        self.action["6X6"] = QAction('6X6', self)
        self.action["6X6"].setShortcut('Ctrl+6')
        self.action["6X6"].setStatusTip('6X6 game')
        self.action["6X6"].triggered.connect(lambda: self.gameImage(6, 6))

    def menuBarLoad(self):
        """
        set MainWindow.menuBar
        """
        self.statusBar()
        menubar = self.menuBar()

        gameMenu = menubar.addMenu('&Game')
        gameMenu.addAction(self.action["4X4"])
        gameMenu.addAction(self.action["5X5"])
        gameMenu.addAction(self.action["6X6"])

    def gameImage(self, m, n):
        """
        image draw.
        """
        # noinspection PyBroadException
        try:
            data = self.data["%d_%d" % (m, n)]
            count = self.data["score_%d_%d" % (m, n)]
        except:
            self.data["%d_%d" % (m, n)] = numpy.zeros((m, n), dtype=int)
            data = self.data["%d_%d" % (m, n)]
            self.data["score_%d_%d" % (m, n)] = 0
            count = self.data["score_%d_%d" % (m, n)]
        self.statusBar().showMessage('Score: %d' % count)

        layout = QGridLayout()
        layout.setSpacing(10)

        widget = QWidget()
        self.canvas = GameCanvas.GameCanvas(data=data, count=count, parent=widget)
        self.canvas.fig.canvas.mpl_connect('button_press_event', self.button_press)
        self.canvas.fig.canvas.mpl_connect('button_release_event', self.button_release)

        layout.addWidget(self.canvas)
        widget.setLayout(layout)
        self.setCentralWidget(widget)

    def button_press(self, event):
        """
        Get coordinates
        """
        self.canvas.event_x = event.x
        self.canvas.event_y = event.y

    # noinspection PyUnresolvedReferences
    def button_release(self, event):
        """
        :param event:
        :return:
        """
        data_backup = copy.deepcopy(self.canvas.data)
        if abs(self.canvas.event_x - event.x) > abs(self.canvas.event_y - event.y):
            if event.x > self.canvas.event_x:
                self.canvas.right_operation(data_backup=data_backup)
            else:
                self.canvas.left_operation(data_backup=data_backup)
        else:
            if event.y > self.canvas.event_y:
                self.canvas.up_operation(data_backup=data_backup)
            else:
                self.canvas.down_operation(data_backup=data_backup)

        self.canvas.fig.clf()
        self.canvas.axes = self.canvas.fig.add_axes([0, 0, 1, 1], frameon=False)
        self.canvas.complete_draw()
        self.canvas.fig.canvas.draw()

        self.data["score_%d_%d" % (self.canvas.m, self.canvas.n)] = self.canvas.count
        self.statusBar().showMessage('Score: %d' % self.canvas.count)

    # noinspection PyUnresolvedReferences
    def keyPressEvent(self, event):
        """
        :param event:
        :return:
        """
        data_backup = copy.deepcopy(self.canvas.data)
        if event.key() == Qt.Key_Right:
            self.canvas.right_operation(data_backup=data_backup)
        elif event.key() == Qt.Key_Left:
            self.canvas.left_operation(data_backup=data_backup)
        elif event.key() == Qt.Key_Up:
            self.canvas.up_operation(data_backup=data_backup)
        elif event.key() == Qt.Key_Down:
            self.canvas.down_operation(data_backup=data_backup)
        elif event.key() == Qt.Key_Escape:
            self.canvas.data *= 0
            self.canvas.count = 0
        elif event.key() == Qt.Key_Delete:
            print("yes ")

        self.canvas.fig.clf()
        self.canvas.axes = self.canvas.fig.add_axes([0, 0, 1, 1], frameon=False)
        self.canvas.complete_draw()
        self.canvas.fig.canvas.draw()

        self.data["score_%d_%d" % (self.canvas.m, self.canvas.n)] = self.canvas.count
        self.statusBar().showMessage('Score: %d' % self.canvas.count)

    def closeEvent(self, event):
        """
        exit game.
        """
        # noinspection PyCallByClass,PyTypeChecker
        reply = QMessageBox.question(self, 'Message', "Are you sure to quit?",
                                     QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
        if reply == QMessageBox.Yes:
            event.accept()
        else:
            event.ignore()

GameImage:

#!/usr/bin/python
#  -*- coding:utf-8 -*-
'''
Created on Mar 24, 2017

@author: zhengli
'''

import copy
import random
import numpy
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg
from matplotlib.figure import Figure
from matplotlib import collections


class GameCanvas(FigureCanvasQTAgg):
    """
     basic data
    """

    def __init__(self, data=None, count=0, parent=None, width=5, height=4, dpi=100):

        self.data = data
        self.count = count
        self.m = len(data)
        self.n = len(data[0])

        self.event_x = 0
        self.event_y = 0

        self.fig = Figure(figsize=(width, height), dpi=dpi)
        self.axes = self.fig.add_axes([0, 0, 1, 1], frameon=False)
        self.complete_draw()

        FigureCanvasQTAgg.__init__(self, self.fig)
        self.setParent(parent)

    def complete_draw(self):
        """
        :return:
        """
        shape = numpy.array([[0.05, 0.05], [0.05, 0.95], [0.95, 0.95], [0.95, 0.05]])
        for i in range(self.m):
            for j in range(self.n):
                rectangle = copy.deepcopy(shape)
                rectangle[:, 0] += j
                rectangle[:, 1] += self.m - i
                if 0.1 * numpy.log2(max(2, 2 * self.data[i][j])) < 1:
                    alpha = 0.1 * numpy.log2(max(2, 2 * self.data[i][j]))
                else:
                    alpha = 1
                patch = collections.PolyCollection([rectangle], alpha=alpha)
                self.axes.add_collection(patch)
                if self.data[i][j] != 0:
                    self.axes.text(j + 0.5, self.m - i + 0.5, s=str(self.data[i][j]), color='white', fontsize=45,
                                   horizontalalignment='center', verticalalignment='center')
        self.axes.autoscale()

    def right_operation(self, data_backup):
        """
        :param data_backup:
        :return:
        """
        for i in range(self.m):
            index, = numpy.where(self.data[i, :] != 0)
            if len(index) != 0:
                values = self.data[i, index]
                if len(index) > 1:
                    j = len(values) - 1
                    while j != 0:
                        if values[j] == values[j - 1]:
                            self.count += values[j - 1]
                            values[j - 1] *= 2
                            values = numpy.hstack((values[:j], values[(j + 1):]))
                            break
                        else:
                            j -= 1
                self.data[i, :] *= 0
                for j in range(len(values)):
                    self.data[i][-j - 1] = values[-j - 1]
        if self.data.min() * (self.data - data_backup).min() == 0:
            index, = numpy.where(self.data[:, 0] == 0)
            if len(index) != 0:
                i = index[random.randint(1, len(index)) - 1]
                self.data[i][0] = random.randint(1, 2)

    def left_operation(self, data_backup):
        """
        :param data_backup:
        :return:
        """
        for i in range(self.m):
            index, = numpy.where(self.data[i, :] != 0)
            if len(index) != 0:
                values = self.data[i, index]
                if len(index) > 1:
                    j = 0
                    while j != len(values) - 1:
                        if values[j] == values[j + 1]:
                            self.count += values[j + 1]
                            values[j + 1] *= 2
                            values = numpy.hstack((values[:j], values[(j + 1):]))
                            break
                        else:
                            j += 1
                self.data[i, :] *= 0
                for j in range(len(values)):
                    self.data[i][j] = values[j]
        if self.data.min() * (self.data - data_backup).min() == 0:
            index, = numpy.where(self.data[:, -1] == 0)
            if len(index) != 0:
                i = index[random.randint(1, len(index)) - 1]
                self.data[i][-1] = random.randint(1, 2)

    def up_operation(self, data_backup):
        """
        :param data_backup:
        :return:
        """
        for j in range(self.n):
            index, = numpy.where(self.data[:, j] != 0)
            if len(index) != 0:
                values = self.data[index, j]
                if len(index) > 1:
                    i = 0
                    while i != len(values) - 1:
                        if values[i] == values[i + 1]:
                            self.count += values[i + 1]
                            values[i + 1] *= 2
                            values = numpy.hstack((values[:i], values[(i + 1):]))
                            break
                        else:
                            i += 1
                self.data[:, j] *= 0
                for i in range(len(values)):
                    self.data[i][j] = values[i]
        if self.data.min() * (self.data - data_backup).min() == 0:
            index, = numpy.where(self.data[-1, :] == 0)
            if len(index) != 0:
                j = index[random.randint(1, len(index)) - 1]
                self.data[-1][j] = random.randint(1, 2)

    def down_operation(self, data_backup):
        """
        :param data_backup:
        :return:
        """
        for j in range(self.n):
            index, = numpy.where(self.data[:, j] != 0)
            if len(index) != 0:
                values = self.data[index, j]
                if len(index) > 1:
                    i = len(values) - 1
                    while i != 0:
                        if values[i] == values[i - 1]:
                            self.count += values[i - 1]
                            values[i - 1] *= 2
                            values = numpy.hstack((values[:i], values[(i + 1):]))
                            break
                        else:
                            i -= 1
                self.data[:, j] *= 0
                for i in range(len(values)):
                    self.data[-i - 1][j] = values[-i - 1]
        if self.data.min() * (self.data - data_backup).min() == 0:
            index, = numpy.where(self.data[0, :] == 0)
            if len(index) != 0:
                j = index[random.randint(1, len(index)) - 1]
                self.data[0][j] = random.randint(1, 2)

Start:

#!/usr/bin/python
#  -*- coding:utf-8 -*-
'''
Created on Mar 24, 2017

@author: zhengli
'''

import MainWindow
import sys
from PyQt5.QtWidgets import QApplication

if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = MainWindow.App()
    sys.exit(app.exec_())

Demo

鼠标操作：

键盘操作：

声明

本文由“Hamilton算符”原创，未经博主允许不得转载！