Как написать 2048 на java

The code of 2048 was not written by me, it was a project found from the project platform of Niuke.com

Project code link (code is placed at the end of the article)

Recorded renderings:

Game logic analysis

Everyone has played 2048, so I won’t introduce it. If you haven’t played, you can go play it and talk about the logic of the game.

1. By moving up, down, left, and right, the adjacent same elements are merged, and then the numbers are added to get the result of 2048.

2. The number block obtained every time is 2 or 4, and the generated position appears randomly in the blank position.

3. Two number blocks appear randomly at the beginning of the game

4. Each time a moving direction (up, down, left, and right) is passed in, all digital blocks move in this direction until the boundary, and the same two digital blocks will be merged into the sum of two numbers and become one digital block.

5. If no digital block is displaced after the movement, the movement is invalid and no new digital block will be generated.

6. When the scene has no space and cannot be moved, the game will fail.

7. The game score is the largest number in the scene. The game ends when the number is 2048.

Code analysis

I feel that the code is already very concise. This game can be written in 200 lines.

Simple mind map

Text version

Game2048

main method

SwingUtilities.invokeLater(() -> {

JFrame f = new JFrame();

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE can close the window);

f.setTitle(«2048»); Set the window title

f.setResizable(true); The panel can be adjusted

f.add(new Game2048(), BorderLayout.CENTER); put the game into the panel

f.pack();

f.setLocationRelativeTo(null);

f.setVisible(true); visible

});

class Tile

Digital block

private boolean merged; whether to merge

private int value; value

Construction method

• Tile(int val) {

  • value = val;

get and set methods

• getValue()

• setMerged(boolean m)

canMergeWith(Tile other) determines whether two blocks can be merged

• return !merged && other != null && !other.merged && value == other.getValue();

• The value is equal, the other block is not empty, and the move is not merged with the other block, all can be merged

int mergeWith(Tile other) {Merge method

• if (canMergeWith(other)) {

  • value *= 2; the combined value is doubled

  • merged = true;

  • return value;

• return -1;

movesAvailable determines whether it can be moved

clearMerged clear panel

Traverse all grids, set false

variable

State static member

• start, won, running, over game state

colorTable color library

• new Color(0x701710), new Color(0xFFE4C3), new Color(0xfff4d3),

• new Color(0xffdac3), new Color(0xe7b08e), new Color(0xe7bf8e),

• new Color(0xffc4c3), new Color(0xE7948e), new Color(0xbe7e56),

• new Color(0xbe5e56), new Color(0x9c3931), new Color(0x701710)};

final static int target = 2048; target score

static int highest; game height

static int score; game score

private Color gridColor = new Color(0xBBADA0); grid color

private Color emptyColor = new Color(0xCDC1B4); empty color

private Color startColor = new Color(0xFFEBCD); start color

private Random rand = new Random(); random number

Private Tile tiles; digital block array stores all digital blocks

private int side = 4; grid size 4*4

private State gamestate = State.start; game state

private boolean checkingAvailableMoves; can move state

Game2048 construction method

setPreferredSize(new Dimension(900, 700));

setBackground(new Color(0xFAF8EF));

setFont(new Font(«SansSerif», Font.BOLD, 48));

setFocusable(true);

Monitor mouse

Monitor keyboard

paintComponent paint component

Initialize drawing

setRenderingHint anti-aliasing

startGame start the game

if (gamestate != State.running) {

score = 0;

highest = 0;

gamestate = State.running;

tiles = new Tileside;

addRandomTile();

addRandomTile();

}

drawGrid draw panel

g.setColor(gridColor); set the color

g.fillRoundRect(200, 100, 499, 499, 15, 15); fill the background

Determine the state of the game

drawTile draws digital blocks

fillRoundRect draws value in the r row and c column of the two-dimensional panel

addRandomTile randomly generates digital blocks

Randomly find empty positions to add 4 or 2

move to move the digital block

Move according to direction

Post-movement processing

• if (moved) {

• if (highest < target) {

• clearMerged();

• addRandomTile();

• if (!movesAvailable()) {

• gamestate = State.over;

• }

• } else if (highest == target)

• gamestate = State.won;

• }

A series of mobile methods

boolean moveUp() {

• return move(0, -1, 0);

boolean moveDown() {

• return move(side * side — 1, 1, 0);

boolean moveLeft() {

• return move(0, 0, -1);

boolean moveRight() {

• return move(side * side — 1, 0, 1);

package com.hanxu51.game2048;
import java.awt.*;
import java.awt.event.*;
import java.util.Random;
import javax.swing.*;
public class Game2048 extends JPanel {
    enum State {
        start, won, running, over
    }
    final Color[] colorTable = {
            new Color(0x701710), new Color(0xFFE4C3), new Color(0xfff4d3),
            new Color(0xffdac3), new Color(0xe7b08e), new Color(0xe7bf8e),
            new Color(0xffc4c3), new Color(0xE7948e), new Color(0xbe7e56),
            new Color(0xbe5e56), new Color(0x9c3931), new Color(0x701710)};
    final static int target = 2048;
    static int highest;
    static int score;
    private Color gridColor = new Color(0xBBADA0);
    private Color emptyColor = new Color(0xCDC1B4);
    private Color startColor = new Color(0xFFEBCD);
    private Random rand = new Random();
    private Tile[][] tiles;
    private int side = 4;
    private State gamestate = State.start;
    private boolean checkingAvailableMoves;
    public Game2048() {
        setPreferredSize(new Dimension(900, 700));
        setBackground(new Color(0xFAF8EF));
        setFont(new Font("SansSerif", Font.BOLD, 48));
        setFocusable(true);
        addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                startGame();
                repaint();
            }
        });
        addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                switch (e.getKeyCode()) {
                    case KeyEvent.VK_UP:
                        moveUp();
                        break;
                    case KeyEvent.VK_DOWN:
                        moveDown();
                        break;
                    case KeyEvent.VK_LEFT:
                        moveLeft();
                        break;
                    case KeyEvent.VK_RIGHT:
                        moveRight();
                        break;
                }
                repaint();
            }
        });
    }
    @Override
    public void paintComponent(Graphics gg) {
        super.paintComponent(gg);
        Graphics2D g = (Graphics2D) gg;
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        drawGrid(g);
    }
    void startGame() {
        if (gamestate != State.running) {
            score = 0;
            highest = 0;
            gamestate = State.running;
            tiles = new Tile[side][side];
            addRandomTile();
            addRandomTile();
        }
    }
    void drawGrid(Graphics2D g) {
        g.setColor(gridColor);
        g.fillRoundRect(200, 100, 499, 499, 15, 15);
        if (gamestate == State.running) {
            for (int r = 0; r < side; r++) {
                for (int c = 0; c < side; c++) {
                    if (tiles[r][c] == null) {
                        g.setColor(emptyColor);
                        g.fillRoundRect(215 + c * 121, 115 + r * 121, 106, 106, 7, 7);
                    } else {
                        drawTile(g, r, c);
                    }
                }
            }
        } else {
            g.setColor(startColor);
            g.fillRoundRect(215, 115, 469, 469, 7, 7);
            g.setColor(gridColor.darker());
            g.setFont(new Font("SansSerif", Font.BOLD, 128));
            g.drawString("2048", 310, 270);
            g.setFont(new Font("SansSerif", Font.BOLD, 20));
            if (gamestate == State.won) {
                g.drawString("you made it!", 390, 350);
            } else if (gamestate == State.over)
                g.drawString("game over", 400, 350);
            g.setColor(gridColor);
            g.drawString("click to start a new game", 330, 470);
            g.drawString("(use arrow keys to move tiles)", 310, 530);
        }
    }
    void drawTile(Graphics2D g, int r, int c) {
        int value = tiles[r][c].getValue();
        g.setColor(colorTable[(int) (Math.log(value) / Math.log(2)) + 1]);
        g.fillRoundRect(215 + c * 121, 115 + r * 121, 106, 106, 7, 7);
        String s = String.valueOf(value);
        g.setColor(value < 128 ? colorTable[0] : colorTable[1]);
        FontMetrics fm = g.getFontMetrics();
        int asc = fm.getAscent();
        int dec = fm.getDescent();
        int x = 215 + c * 121 + (106 - fm.stringWidth(s)) / 2;
        int y = 115 + r * 121 + (asc + (106 - (asc + dec)) / 2);
        g.drawString(s, x, y);
    }
    private void addRandomTile() {
        int pos = rand.nextInt(side * side);
        int row, col;
        do {
            pos = (pos + 1) % (side * side);
            row = pos / side;
            col = pos % side;
        } while (tiles[row][col] != null);
        int val = rand.nextInt(10) == 0 ? 4 : 2;
        tiles[row][col] = new Tile(val);
    }
    private boolean move(int countDownFrom, int yIncr, int xIncr) {
        boolean moved = false;
        for (int i = 0; i < side * side; i++) {
            int j = Math.abs(countDownFrom - i);
            int r = j / side;
            int c = j % side;
            if (tiles[r][c] == null)
                continue;
            int nextR = r + yIncr;
            int nextC = c + xIncr;
            while (nextR >= 0 && nextR < side && nextC >= 0 && nextC < side) {
                Tile next = tiles[nextR][nextC];
                Tile curr = tiles[r][c];
                if (next == null) {
                    if (checkingAvailableMoves)
                        return true;
                    tiles[nextR][nextC] = curr;
                    tiles[r][c] = null;
                    r = nextR;
                    c = nextC;
                    nextR += yIncr;
                    nextC += xIncr;
                    moved = true;
                } else if (next.canMergeWith(curr)) {
                    if (checkingAvailableMoves)
                        return true;
                    int value = next.mergeWith(curr);
                    if (value > highest)
                        highest = value;
                    score += value;
                    tiles[r][c] = null;
                    moved = true;
                    break;
                } else
                    break;
            }
        }
        if (moved) {
            if (highest < target) {
                clearMerged();
                addRandomTile();
                if (!movesAvailable()) {
                    gamestate = State.over;
                }
            } else if (highest == target)
                gamestate = State.won;
        }
        return moved;
    }
    boolean moveUp() {
        return move(0, -1, 0);
    }
    boolean moveDown() {
        return move(side * side - 1, 1, 0);
    }
    boolean moveLeft() {
        return move(0, 0, -1);
    }
    boolean moveRight() {
        return move(side * side - 1, 0, 1);
    }
    void clearMerged() {
        for (Tile[] row : tiles)
            for (Tile tile : row)
                if (tile != null)
                    tile.setMerged(false);
    }
    boolean movesAvailable() {
        checkingAvailableMoves = true;
        boolean hasMoves = moveUp() || moveDown() || moveLeft() || moveRight();
        checkingAvailableMoves = false;
        return hasMoves;
    }
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            JFrame f = new JFrame();
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.setTitle("2048");
            f.setResizable(true);
            f.add(new Game2048(), BorderLayout.CENTER);
            f.pack();
            f.setLocationRelativeTo(null);
            f.setVisible(true);
        });
    }
}
class Tile {
    private boolean merged;
    private int value;
    Tile(int val) {
        value = val;
    }
    int getValue() {
        return value;
    }
    void setMerged(boolean m) {
        merged = m;
    }
    boolean canMergeWith(Tile other) {
        return !merged && other != null && !other.merged && value == other.getValue();
    }
    int mergeWith(Tile other) {
        if (canMergeWith(other)) {
            value *= 2;
            merged = true;
            return value;
        }
        return -1;
    }
}

I created a 2048 game clone in Java. However, I am only writing the fundamental algorithm for the game such as the movement, the losing condition, and the algorithm to generate a new tile. This algorithm should be generic enough to work not only on 4 x 4 grid, but also on any size of square grid.

Any review / feedback would be greatly appreciated!

Tile Class

/**
 * Class of individual tile unit in 2048 game. Value of zero implies an empty tile.
 * 
 * @author dkurniawan
 */
public class Tile {

    private int value;

    /**
     * Instantiate tile with a value of zero (empty). 
     */
    public Tile(){
        this(0);
    }

    /**
     * Instantiate tile with a specific value.
     * 
     * @param value
     */
    public Tile(int value){
        this.value = value;
    }


    public void setValue(int value){    
        this.value = value; 
    }

    public int getValue(){
        return value;
    }

    /**
     * Two tiles are the same if they have the same value. (Useful for merging tile)
     * 
     * @param tile
     * @return true if two tiles are equal, false otherwise
     */
    public boolean equals(Tile tile){
        return tile.getValue() == this.getValue();  
    }

    /**
     * Add the value of this tile by the value of the tile in the parameter.
     * 
     * @param tile
     */
    public void merge(Tile tile){
        this.setValue(value + tile.getValue());
    }

    /**
     * Set the value to zero. In other words, delete / empty the tile.
     * 
     */
    public void clear(){
        this.setValue(0);
    }

    public String toString(){
        return (Integer.toString(this.getValue()));
    }

}

Grid Class (The main algorithm is in this class)

To swipe the tiles in 2048, the game calls the move method (with Direction enum as a parameter)

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
 * The main game algorithm. The grid contains n x n tiles. Tiles with a value of zero implies an empty tile. 
 * The algorithm operate by passing value to other grid (without moving the object itself. 
 * 
 * @author dkurniawan
 *
 */
public class Grid {


    //size of the grid
    private static final int SIZE = 4;

    private Tile[][] tiles = new Tile[SIZE][SIZE];

    /**
     * Instantiate n x n grid with all zero values (grid with empty tile).
     */
    public Grid(){

        for (int i = 0; i < tiles[0].length; i++){
            for (int j = 0; j < tiles.length; j++){
                tiles[i][j] = new Tile();
            }

        }
    }

    /**
     * Generate a tile with a random value of 2 or 4 in a random position. 
     * 
     * @return true if successfully placed a new tile, false if there is no empty tile left.
     * 
     */
    public boolean generateNewTile(){

        if (!(hasEmptyTile())){
            return false;
        }

        Random random = new Random();

        //iterate until an empty tile if found
        while (true){

            int x = random.nextInt(SIZE);
            int y = random.nextInt(SIZE);

            if (tiles[x][y].getValue() == 0){

                tiles[x][y].setValue(getNewTileValue());
                return true;

            }

        }

    }

    //get tile value of either 2 or 4   
    private int getNewTileValue(){

        Random random = new Random();

        int rng = random.nextInt(2) + 1;

        return (rng * 2);

    }

    /**
     * 2048 movement algorithm. The main idea of the algorithm is to create a group / set of tile according to the direction chosen.
     * For example, if the user want to move the tile to the right, then the group will be the rows of tile. As a result,
     * each row will have the same movement algorithm. These rows will be sent to a general method.
     *  
     * @param direction Determine which direction the player want to slide the tile.
     */
    public void move(Direction direction){

        for (int i = 0; i < SIZE; i++){

            //group of tile
            List<Tile> tileSet = new ArrayList<Tile>();

            for (int j = 0; j < SIZE; j++){

                switch(direction){

                case LEFT: tileSet.add(tiles[i][j]); break;
                case RIGHT: tileSet.add(tiles[i][SIZE - j - 1]); break;
                case UP: tileSet.add(tiles[j][i]); break;
                case DOWN: tileSet.add(tiles[SIZE - j - 1][i]); break;
                default: break;

                }

            }

            if (!(isEmptyTile(tileSet))){
                slide(tileSet); //main tile group algorithm
            }


        }

    }

    private boolean isEmptyTile(List<Tile> tileSet) {

        for (Tile tile: tileSet){

            if (tile.getValue() != 0){
                return false;
            }

        }

        return true;

    }

    //main tile group algorithm
    private void slide(List<Tile> tileSet){

        slideToEdge(tileSet);
        mergeTile(tileSet);

    }

    //slide all tile into the edge, in case there is a zero in between
    private void slideToEdge(List<Tile> tileSet){

        for (int i = 0; i < tileSet.size(); i++){

            if (remainingIsZero(tileSet, i)){
                return;
            }

            while (tileSet.get(i).getValue() == 0){

                slideTo(tileSet, i);

            }

        }

    }

    private boolean remainingIsZero(List<Tile> tileSet, int i) {

        List<Tile> remainingTile = new ArrayList<Tile>();

        for (int j = i; j < tileSet.size(); j++){
            remainingTile.add(tileSet.get(j));
        }

        return (isEmptyTile(remainingTile));

    }

    private void slideTo(List<Tile> tileSet, int index){

        for (int j = index; j < tileSet.size() - 1; j++){

            tileSet.get(j).setValue(tileSet.get(j + 1).getValue());

        }

        tileSet.get(tileSet.size() - 1).clear();

    }

    //Merge tile, if tile in the direction has the same value.
    private void mergeTile(List<Tile> tileSet){

        for (int i = 0; i < tileSet.size() - 1; i++){

            if (tileSet.get(i).equals(tileSet.get(i + 1))){
                tileSet.get(i).merge(tileSet.get(i + 1));
                tileSet.get(i + 1).clear();
                slideTo(tileSet, i + 1);

            }

        }

    }

    /**
     * Check for losing condition. Losing implies no possible move can be made to change the tile.
     * 
     * @return true, if no possible move left
     */
    public boolean noPossibleMove(){    

        if (hasEmptyTile()){
            return false;
        }

        return !(hasEqualNeighbour());

    }

    private boolean hasEmptyTile(){

        for (int i = 0; i < SIZE; i++){
            for (int j = 0; j < SIZE; j++){

                if (tiles[i][j].getValue() == 0){
                    return true;
                }
            }
        }

        return false;

    }

    private boolean hasEqualNeighbour() {

        for (int i = 0; i < SIZE; i++){
            for (int j = 0; j < SIZE; j++){

                //check the tile in the right of the chosen tile. Ignore last column.
                if (j < SIZE - 1){

                    if (tiles[i][j].equals(tiles[i][j + 1])){
                        return true;
                    }

                }

                //check the tile below the chosen tile. Ignore last row.
                if (i < SIZE - 1){

                    if (tiles[i][j].equals(tiles[i + 1][j])){
                        return true;
                    }

                }



            }
        }

        return false;
    }

    public String toString(){

        StringBuilder sb = new StringBuilder();

        for (Tile[] tileRow: tiles){
            for (Tile tile: tileRow){
                sb.append(tile);
                sb.append(" ");
            }
            sb.append("n");
        }

        return sb.toString();

    }

}

Direction Enum

public enum Direction {

    UP, DOWN, LEFT, RIGHT;

}