Lập trình trò chơi W / Java 2048 của riêng bạn !: 8 bước

2024 Tác giả: John Day | [email protected]. Sửa đổi lần cuối: 2024-01-30 13:30

Bởi PranP1My (Chưa hoàn thành) SiteFollow More của tác giả:

Tôi yêu trò chơi 2048. Và vì vậy tôi quyết định lập trình phiên bản của riêng mình.

Nó rất giống với trò chơi thực tế, nhưng tự lập trình nó cho tôi quyền tự do thay đổi bất cứ điều gì tôi muốn bất cứ khi nào tôi muốn. Nếu tôi muốn một trò chơi 5x5 thay vì 4x4 điển hình, một thay đổi đơn giản bằng cách sử dụng trình tạo 'Bảng' sẽ cho phép tôi làm như vậy. Giả sử tôi muốn làm cho trò chơi trở nên khó khăn hơn, thêm các quân cờ ở các vị trí sẽ khiến nó phức tạp nhất đối với người chơi hơn là một cách ngẫu nhiên. Sử dụng một thuật toán đơn giản, tôi có thể làm được điều đó. Mặc dù tôi sẽ không đề cập đến tất cả các sửa đổi này trong Có thể hướng dẫn này, nhưng tôi có kế hoạch bổ sung thêm khi tôi tiếp tục.

Tuy nhiên, hiện tại, chúng tôi sẽ lập trình trò chơi điển hình năm 2048 của bạn.

Bắt đầu nào!

(Lưu ý phụ: Có thể giảng dạy này yêu cầu kiến thức vừa phải về lập trình - đặc biệt là với Java)

Bước 1: Vật liệu

Bạn sẽ không cần nhiều cho dự án này vì nó chỉ là một hướng dẫn lập trình.

Vật liệu:

• Máy tính xách tay
• Eclipse (hoặc bất kỳ IDE nào bạn chọn)

Chuẩn rồi. Đó là nó.

Bước 2: Tìm hiểu về Chương trình - Hội đồng quản trị

Tôi đã tải tất cả mã của mình lên GitHub - hãy xem tại đây:

Tôi chia trò chơi thành 3 lớp: Board, Tile và Game.

Bảng:

Mô tả: Lớp Board xử lý trò chơi, thiết lập một mảng các phần tử 'Xếp hạng', nhận điểm hiện tại và ô xếp cao nhất, và đặt mảng đó thành một chuỗi (sẽ được sử dụng sau này trong 'Trò chơi'). Hầu hết logic cũng nằm ở đây, lớp cung cấp các phương thức sinh sản 2 và 4 tại các vị trí ngẫu nhiên, di chuyển lên, xuống, trái và phải và cho người chơi biết khi trò chơi kết thúc.

Người xây dựng:

/ * Hàm tạo mặc định cho Bảng - thiết lập ma trận 4x4 * /

bảng công khai () {…}

/ * Khối tạo cho Bảng - thiết lập ma trận với kích thước lưới được chỉ định * /

bảng công khai (int lưới) {…}

Phương pháp:

/ * Phương thức Getter trả về bảng * /

public Tile getBoard () {…}

/ * Phương thức Getter trả về điểm * /

public int getScore () {…}

/ * Tìm ô cao nhất trên bảng và trả về * /

public int getHighTile () {…}

/ * In bảng lên bảng điều khiển - cho mục đích thử nghiệm * /

public void print () {…}

/ * Trả về bảng dưới dạng Chuỗi - được sử dụng trong GUI * /

public String toString () {…}

/ * Sinh ra 2 (hoặc 4) tại một khoảng không gian trống tại thời điểm một nước đi được thực hiện * /

public void spawn () {…}

/ * Kiểm tra xem bảng đã bị bôi đen hoàn toàn chưa và nếu có, nó sẽ thúc người chơi khởi động lại * /

public boolean blackOut () {…}

/ * Kiểm tra xem trò chơi đã kết thúc chưa - khi bàn cờ bị bôi đen và không có ô xếp nào có thể kết hợp * /

public boolean gameOver () {…}

/ * Được gọi khi nhấn 'w' hoặc mũi tên lên - gọi 'verticalMove' cho mọi ô trên bảng có tham số 'up' * /

public void up () {…}

/ * Được gọi khi nhấn 's' hoặc mũi tên xuống - gọi 'verticalMove' cho mọi ô trên bảng có tham số 'down' * / public void down () {…}

/ * Được gọi khi nhấn 'd' hoặc mũi tên phải - gọi 'verticalMove' cho mọi ô trên bảng có tham số 'right' * / public void right () {…}

/ * Được gọi khi nhấn 'a' hoặc mũi tên trái - gọi 'verticalMove' cho mọi ô trên bảng có tham số 'left' * /

khoảng trống công cộng còn lại () {…}

/ * So sánh các giá trị của hai ô với nhau và nếu chúng giống nhau hoặc nếu một bằng 0 (ô trơn) - giá trị của chúng sẽ được thêm vào (miễn là các ô mà chúng tôi đang so sánh là hai ô khác nhau và chúng đang di chuyển theo hướng thích hợp) - di chuyển đệ quy qua hàng * /

public void ngangMove (int row, int col, String direction) {…}

/ * So sánh các giá trị của hai ô với nhau và nếu chúng giống nhau hoặc nếu một bằng 0 (ô trơn) - giá trị của chúng sẽ được thêm vào (miễn là các ô mà chúng tôi đang so sánh là hai ô khác nhau và chúng đang di chuyển theo hướng thích hợp) - di chuyển đệ quy qua cột * /

public void verticalMove (int row, int col, String direction) {…}

Vâng, đó là rất nhiều phương pháp - nhưng đừng lo lắng, hầu hết đều cực kỳ dễ hiểu. Trên hết, lớp 'Board' là lớp phức tạp nhất, vì vậy mọi thứ sau này sẽ tương đối đơn giản.

Bước 3: Tìm hiểu về chương trình - Tile

Ngói:

Mô tả: Lớp Tile xử lý các ô riêng lẻ và là lớp nhỏ nhất trong tất cả các lớp. Mỗi ô có một giá trị số nguyên và một màu. Nó có hai hàm tạo để tạo các Ô có giá trị 0 (mặc định) hoặc giá trị #. Các phương pháp chủ yếu là tự giải thích, với các phương pháp 'getter' và 'setter' chiếm phần lớn trong tổng số.

Người xây dựng:

/ * Tạo một ô cơ bản với giá trị 0 * /

Ngói công cộng () {…}

/ * Tạo một ô có giá trị là số * /

Public Tile (số int) {…}

Phương pháp:

/ * Nhận giá trị của ô * /

public int getValue () {…}

/ * Đặt giá trị của ô - được sử dụng khi thêm hai ô với nhau * /

public void setValue (int value) {…}

/ * Đại diện cho ô dưới dạng một Chuỗi - được sử dụng trong GUI * /

public String toString () {…}

/ * Đặt màu của ô dựa trên giá trị của nó * /

public void setColor () {…}

/ * Nhận màu sắc của ô * /

public void getColor () {…}

Bước 4: Tìm hiểu Chương trình - Trò chơi

Trò chơi

Mô tả: Lớp trò chơi chứa phương thức chính, hầu hết các phương thức GUI và các tương tác chính. Nó có cả hai lớp Tile và Board và cho phép chúng hoạt động cùng nhau.

Người xây dựng:

Không có

Phương pháp:

/ * thiết lập GUI với các kích thước thích hợp và thêm Trình xử lý chính * /

public static void setUpGUI () {…}

/ * Kiểm tra xem liệu phím mũi tên hay mũi tên được nhấn và thực hiện các hành động thích hợp - cập nhật JFrame sau mỗi lần di chuyển * /

public void keyPressed (KeyEvent e) {…}

/ * Sơn GUI với một loạt các chuỗi, bảng, các ô và đảm bảo chúng được sơn lại khi trò chơi kết thúc * /

public void paint (Graphics g) {…}

/ * vẽ một ô riêng lẻ - được gọi từ phương pháp sơn * /

public void drawTiles (Graphics g, Tile tile, int x, int y) {…}

/ * Phương pháp chính - thiết lập GUI và bắt đầu trò chơi * /

public static void main (String args) {…}

Bước 5: Phương pháp quan trọng - Chuyển động

Các phương pháp chuyển động là quan trọng nhất để hiểu, nhưng tin tốt là một khi bạn hiểu các chuyển động dọc, bạn có thể áp dụng sự hiểu biết đó cho các chuyển động ngang. Trên thực tế, ba phương pháp di chuyển theo chiều dọc hoàn toàn giống với ba phương thức di chuyển theo phương ngang, ngoại trừ một phương thức di chuyển qua hàng và phương thức kia qua cột. Vì lý do đó, chúng ta hãy chỉ tập trung vào các phương pháp chuyển động thẳng đứng.

private void verticalMove (int row, int col, String direction)

{Ngói ban đầu = board [border] [col]; Ngói so sánh = board [row] [col]; if (initial.getValue () == 0 || initial.getValue () == so sánh.getValue ()) {if (row> border || (direction.equals ("down") && (row <border))) {int addScore = initial.getValue () + so sánh.getValue (); if (initial.getValue ()! = 0) {score + = addScore; } initial.setValue (addScore); so sánh.setValue (0); }} else {if (direction.equals ("xuống")) {border--; } else {border ++; } verticalMove (hàng, cột, hướng); }}

Phương thức trên, verticalMove, được gọi bằng phương thức 'up' và 'down'. Chúng ta hãy xem xét phương pháp 'up'.

public void up ()

{for (int i = 0; i <lưới; i ++) {border = 0; for (int j = 0; j <grids; j ++) {if (board [j] .getValue ()! = 0) {if (border <= j) {verticalMove (j, i, "up"); }}}}}

Phương thức này đi qua toàn bộ bảng và gọi verticalMove cho mọi ô có tham số "up". verticalMove sau đó so sánh ô ở vị trí 'j' và 'i' với ô ở vị trí 'border' và 'i'. Nếu cả hai bằng nhau, chúng được kết hợp. Nếu không, ô đường viền sẽ tăng lên 1 (vì tham số tại chỗ là 'lên') và verticalMove được gọi lại.