programming python

Làm thế nào để bạn tạo một trò chơi 2048 trong python?

⚠️LƯU Ý⚠️. Chúng tôi sẽ không chấp nhận bất kỳ đóng góp/thay đổi nào đối với dự án nữa. Nó bây giờ là chỉ đọc

Dựa trên trò chơi nổi tiếng 2048 của Gabriele Cirulli. Mục tiêu của trò chơi là trượt các ô được đánh số trên một lưới để kết hợp chúng để tạo ô có số 2048. Đây là phiên bản Python sử dụng TKinter

Để bắt đầu trò chơi, hãy chạy

$ python3 puzzle.py

người đóng góp

Yanghun Tay
Emmanuel Goh

Trong hướng dẫn này, chúng tôi sẽ xây dựng trò chơi 2048 bằng Python. Chúng tôi sẽ trải qua các bước di chuyển khác nhau trong quá trình xây dựng trò chơi

*Tôi sẽ sử dụng ma trận 4×4 để giải thích trò chơi này trong bối cảnh này*

Một số chi tiết về trò chơi 2048

Trong trò chơi này ban đầu, chúng tôi đã được cung cấp hai số 2 ở vị trí ngẫu nhiên trong ma trận

Khi di chuyển lên, xuống, trái hoặc phải, nó sẽ hợp nhất với các số tương tự duy nhất có trên đường đi của nó

Ví dụ, bên dưới là ảnh chụp màn hình của trò chơi

Sau đó, nếu chúng ta nhấn phím 'W' hoặc di chuyển lên, chúng ta sẽ thực hiện các thay đổi sau

4 tại [0,0] và [1,0] hợp nhất thành 8
2 tại [2,0] di chuyển đến [1,0]
16 tại [1,1] và [2,1] hợp nhất thành 32 như hình
không thay đổi trong 8
2 tại [2,3] di chuyển đến [2,1]

Điều này sẽ dẫn đến ma trận sau

Tôi khuyên bạn nên chơi trò chơi này của bạn 3-4 lần để hiểu kỹ về nó

Trước tiên chúng ta hãy đi qua các chức năng khác nhau sẽ được sử dụng, tôi sẽ giải thích chúng sau

Nén

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

hợp nhất

def merge[mat]:
    for i in range[4]:
        for j in range[3]:
            if mat[i][j]==mat[i][j+1] and mat[i][j]!=0:
                mat[i][j]+=mat[i][j].                     #This merge function is for left move.
                mat[i][j+1]=0
    return mat

Đảo ngược

def reverse[mat]:
    new_mat=[]
    for i in range[4]:
        new_mat.append[[]]
        for j in range[4]:
            new_mat[i].append[mat[i][3-j]]
    return new_mat

chuyển vị

def transp[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]
    for i in range[4]:
        for j in range[4]:
            new_mat[i][j]=mat[j][i]
    return new_mat

Bốn chức năng này chủ yếu được sử dụng trong toàn bộ trò chơi

Nói một cách đơn giản, chức năng nén hoàn thành khoảng cách giữa các số được yêu cầu hoặc tạo các số quan trọng mà chúng tôi muốn thực hiện các hành động tiếp theo, đóng

Chức năng hợp nhất, hợp nhất các số tương tự hiện tại so sánh ma trận tiếp theo

Các chức năng đảo ngược và chuyển đổi đồng thời đảo ngược và chuyển đổi ma trận

Ngoài ra, đọc. Cách chuyển đổi hình ảnh thành ma trận bằng Python

Ban đầu, các chức năng hợp nhất và nén được mã hóa cho bước di chuyển bên trái, chúng ta có thể sử dụng cùng một chức năng cho các bước di chuyển khác nhau bằng cách sử dụng các chức năng đảo ngược và chuyển vị. Các chức năng khác nhau cho các bước di chuyển khác nhau như sau

Di chuyển trái

Nén
hợp nhất
Nén

di chuyển phải

Đảo ngược
Nén
hợp nhất
Nén
Đảo ngược

Trong trường hợp này, bằng cách đảo ngược và đảo ngược lại, hãy tạo một ma trận để xử lý nó giống như Di chuyển trái

di chuyển lên

chuyển vị
Nén
hợp nhất
Nén
chuyển vị

Chức năng chuyển đổi làm cho ma trận hoạt động như Di chuyển trái, sau đó chuyển đổi nó một lần nữa để hoạt động hoàn hảo

Di chuyển xuống

chuyển vị
Đảo ngược
Nén
hợp nhất
Nén
Đảo ngược
chuyển vị

Chuyển đổi và đảo ngược làm cho ma trận hoạt động giống như di chuyển trái

Đây là cách chúng tôi viết mã cho các nước đi khác nhau

Đây là cách phần logic hoạt động cho trò chơi 2048

Một số thay đổi khác

Sau khi hoàn thành mọi công việc trên trò chơi này hoặc bất cứ khi nào chức năng nén hoặc hợp nhất hoạt động, 2 mới ở vị trí ngẫu nhiên sẽ được thêm vào trò chơi của chúng tôi

Chào các bạn. Trong bài viết này, chúng ta sẽ xem xét mã Python và logic để thiết kế trò chơi 2048 mà bạn đã chơi rất thường xuyên. Nếu bạn chưa quen với trò chơi, bạn nên chơi trò chơi trước để có thể hiểu chức năng cơ bản của nó 😉

điều kiện tiên quyết

IDE hỗ trợ Python

Kiến thức cơ bản về

def merge[mat]:
    for i in range[4]:
        for j in range[3]:
            if mat[i][j]==mat[i][j+1] and mat[i][j]!=0:
                mat[i][j]+=mat[i][j].                     #This merge function is for left move.
                mat[i][j+1]=0
    return mat

Hãy viết mã

Tạo bảng

Trước khi làm bất cứ điều gì, chúng ta cần cài đặt các mô-đun cần thiết

from tkinter import *
from tkinter import messagebox
import random

Tất cả các thiết lập. Bây giờ, chúng ta phải tạo

def reverse[mat]:
    new_mat=[]
    for i in range[4]:
        new_mat.append[[]]
        for j in range[4]:
            new_mat[i].append[mat[i][3-j]]
    return new_mat

0 cho bảng như sau

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

Trước hết, hãy tìm hiểu các biến chúng ta đã sử dụng là gì

def reverse[mat]:
    new_mat=[]
    for i in range[4]:
        new_mat.append[[]]
        for j in range[4]:
            new_mat[i].append[mat[i][3-j]]
    return new_mat

1. Đó là một từ điển lưu trữ màu nền cho mọi ô

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

0. Đó là một từ điển lưu trữ màu nền trước cho mọi ô

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

1. Đây là cửa sổ chính của Tkinter

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

2. Nó là một tiện ích khung Tkinter

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

3. Nó là ma trận số nguyên 4×4 lưu trữ giá trị nguyên thực tế của tất cả các ô

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

4. Đó là lưới 4×4 của tiện ích nhãn Tkinter hiển thị giá trị của ô trên cửa sổ Tkinter. Nó cũng được sử dụng để định cấu hình nền và tiền cảnh của ô theo giá trị gridCell của nó

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

5. Nó lưu trữ số điểm hiện tại của người chơi

Tiếp theo. Hãy viết mã các chức năng trong Board

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

Không, không hiểu điều này không khó chút nào. Hãy phá vỡ các chức năng này

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

6. Đó là hàm tạo. Nó khởi tạo tất cả các biến với các giá trị mặc định phù hợp như '0' cho gridCell, Sai cho di chuyển, hợp nhất, v.v.

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

7. Nó đảo ngược ma trận gridCell

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

8. Nó sử dụng hàm zip và chuyển vị trí của ma trận gridCell

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

9. Nó di chuyển tất cả các ô không trống sang bên trái để việc hợp nhất có thể được thực hiện dễ dàng

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

30. Nó thêm giá trị gridCell của hai ô liền kề nếu chúng có cùng giá trị gridCell

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

31. Đầu tiên, nó lưu trữ tất cả các ô trống trong một danh sách, sau đó chọn một ô ngẫu nhiên từ danh sách đã tạo và đặt giá trị gridCell của nó là 2

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

32. Nó trả về một giá trị boolean biểu thị chúng ta có thể hợp nhất hai ô bất kỳ hay không. Chúng ta có thể hợp nhất hai ô khi và chỉ khi chúng có cùng giá trị gridCell

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

33. Nó gán màu nền trước và màu nền cho từng ô của lưới 4×4 tương ứng với giá trị gridCell của nó

Đó là về lớp học

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

Tạo trò chơi

Lớp này không có nhiều biến, nó chỉ có một số biến Boolean biểu thị trạng thái trò chơi. Vì vậy, hãy viết một số chức năng khác

def merge[mat]:
    for i in range[4]:
        for j in range[3]:
            if mat[i][j]==mat[i][j+1] and mat[i][j]!=0:
                mat[i][j]+=mat[i][j].                     #This merge function is for left move.
                mat[i][j+1]=0
    return mat

Giản dị

class Board:
    bg_color={
        '2': '#eee4da',
        '4': '#ede0c8',
        '8': '#edc850',
        '16': '#edc53f',
        '32': '#f67c5f',
        '64': '#f65e3b',
        '128': '#edcf72',
        '256': '#edcc61',
        '512': '#f2b179',
        '1024': '#f59563',
        '2048': '#edc22e',
    }
    color={
         '2': '#776e65',
        '4': '#f9f6f2',
        '8': '#f9f6f2',
        '16': '#f9f6f2',
        '32': '#f9f6f2',
        '64': '#f9f6f2',
        '128': '#f9f6f2',
        '256': '#f9f6f2',
        '512': '#776e65',
        '1024': '#f9f6f2',
        '2048': '#f9f6f2',
    }

6. Đó là hàm tạo. Nó khởi tạo tất cả các biến với các giá trị mặc định phù hợp

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

36. Nó gọi random_cell hai lần để gán '2' cho giá trị gridCell của hai ô ngẫu nhiên, sau đó nó vẽ lưới và sau đó, nó gọi link_keys để liên kết các phím lên, xuống, trái và phải

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

37. Trước hết, nó kiểm tra xem trò chơi đã thắng hay thua, và nếu đúng như vậy, nó sẽ thực hiện câu lệnh return mà không cần làm gì cả. Mặt khác, nó tiếp tục thực hiện

def merge[mat]:
    for i in range[4]:
        for j in range[3]:
            if mat[i][j]==mat[i][j+1] and mat[i][j]!=0:
                mat[i][j]+=mat[i][j].                     #This merge function is for left move.
                mat[i][j+1]=0
    return mat

Đây là những điều khiển chính của trò chơi. Trò chơi này được chơi bằng các phím mũi tên. Vì vậy, chúng ta phải kiểm soát vì nó

Tiếp theo, chúng ta cần thực hiện phần Game over và hoàn thành. Nếu các ô tạo thành số

def compress[mat]:
    new_mat=[[0 for i in range[4]] for i in range[4]]     
    for i in range[4]:
        pos=0
        for j in range[4]:
            if mat[i][j]!=0:
                new_mat[i][pos]=mat[i][j]             #This compress function is for lest move.
                pos+=1
    return new_mat

38 thì số đó sẽ thắng [rất hiếm khi]. Nếu không, nó là trò chơi kết thúc

Bạn có thể nhận được 4096 2048?

Có thể kết hợp các giá trị này từ phải sang trái để có được 4096. Đó là tổng cộng 12 gạch. Vì đó là ít hơn 16 [số ô tối đa có thể vừa], nên 4096 là có thể .

Logic của trò chơi 2048 là gì?

Mục tiêu của trò chơi là trượt các ô được đánh số trên một lưới để kết hợp chúng lại với nhau để tạo ô có số 2048 ; .

Có một thuật toán cho năm 2048?

Giải trò chơi này là một bài toán thú vị vì nó có yếu tố ngẫu nhiên. Không thể dự đoán chính xác không chỉ vị trí đặt mỗi ô mới mà còn dự đoán đó sẽ là “2” hay “4”. Như vậy, không thể có thuật toán giải câu đố chính xác mọi lúc .

Bạn có thể tạo trò chơi pixel bằng Python không?

Pyxel là công cụ trò chơi cổ điển dành cho Python . Nhờ các thông số kỹ thuật đơn giản lấy cảm hứng từ máy chơi game cổ điển, chẳng hạn như chỉ có thể hiển thị 16 màu và chỉ có thể phát lại 4 âm thanh cùng lúc, bạn có thể thoải mái tận hưởng việc tạo các trò chơi theo phong cách nghệ thuật pixel.