Beispiele für Spielfunktionen, die in Java Version 2048 implementiert sind

Funktionale Anforderungen: Die Basisschnittstelle von 2048 kann die Spielfunktionen von 2048 realisieren.

Allgemeine Idee: zwei Klassen: Game und GameListener.

Game ist für die Implementierung der Schnittstelle und das Umschreiben der Paint-Methode verantwortlich

GameListener ist für die Verarbeitung von Tastatur und Maus verantwortlich Ereignisse. Die Bewegungsmethode, die Additionsmethode, das Gewinn- oder Verliererurteil und das Erscheinen von Zufallszahlen müssen in der Tastaturüberwachungsmethode implementiert werden.

Implementierungsanalyse: Um das Spiel 2048 umzusetzen, müssen Sie zunächst überlegen, was im Jahr 2048 ist.

Schnittstellenimplementierung:

Die Spieloberfläche von 2048 ist sehr einfach, nur ein paar Quadrate und Zahlen. Um eine solche Schnittstelle zu implementieren, können wir die Verwendung der Zeichenfunktion von Java in Betracht ziehen. Insbesondere wird das von der JFrame-Klasse bereitgestellte Graphics-Objekt zum Zeichnen verwendet. Die 2048-Schnittstelle besteht aus einem großen rechteckigen Hintergrund und vielen kleinen Quadraten mit Zahlen. Die Zeichenmethode des Grafikobjekts kann das Zeichnen von Hintergründen und kleinen Quadraten realisieren. Die Zahlen in den kleinen Quadraten können mit der drawString-Grafikmethode gezeichnet werden. Achten Sie beim Zeichnen einfach auf die Farben. Die wichtigsten für die Schnittstellenimplementierung erforderlichen Klassen sind die JFrame-Klassen.

Der grundlegende Schnittstellenimplementierungscode besteht nur aus einigen Schaltflächen und dergleichen, es gibt nicht viel zu sagen.

private void initUI() {
        setTitle("2048");
        setDefaultCloseOperation(3);
        setSize(600, 700);
        setLocationRelativeTo(null);this.setLayout(null);//添加分数jl2 = new JLabel("分数：0");
        jl2.setFont(new Font("黑体", Font.BOLD, 30));
        jl2.setBounds(20, 30, 200, 50);this.add(jl2);//添加开始按钮ImageIcon start=new ImageIcon("res/start.png");//开始游戏图标，随意替换就好startJB=new JButton(start);
        startJB.setBounds(280, 40, 120, 30);
        startJB.setFocusable(false);
        startJB.setBorderPainted(false);//设置按钮的边框为空startJB.setFocusPainted(false);
        startJB.setContentAreaFilled(false);//设置按钮的边框内填充颜色        //添加退一步按钮ImageIcon back=new ImageIcon("res/backicon.png");//游戏结束图标，随意替换就好backJB=new JButton(back);
        backJB.setBounds(430, 40, 120, 30);
        backJB.setFocusable(false);
        backJB.setBorderPainted(false);
        backJB.setFocusPainted(false);
        backJB.setContentAreaFilled(false);        this.add(startJB);this.add(backJB);
        setVisible(true);
        GameListener gl = new GameListener(this, arry, jl2,startJB,backJB);
        addKeyListener(gl);
        startJB.addActionListener(gl);
        backJB.addActionListener(gl);
    }

Zeichnen von Quadraten und Zahlen:

Das Zeichnen von Quadraten und Zahlen verwendet ebenfalls JFrame Die Leinwand Die Methode des Objekts zum Zeichnen eines Rechtecks ​​ist implementiert.

public void buffPaint(Graphics g) {
        Image image = createImage(600, 600);
        Graphics g2 = image.getGraphics();
        g2.setColor(Color.LIGHT_GRAY);
        Graphics2D g2d = (Graphics2D) g2;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        g2.fillRoundRect(0, 0, Draw2048.RD, Draw2048.RD, 20, 20);
        g2.setColor(Color.GRAY);for (int r = 0; r < arry.length; r++) {for (int c = 0; c < arry[r].length; c++) {
                g2.fillRect(20 + c * (Draw2048.D + Draw2048.space), 20 + r* (Draw2048.D + Draw2048.space), Draw2048.D, Draw2048.D);
            }
        }for (int r = 0; r < arry.length; r++) {for (int c = 0; c < arry[r].length; c++) {if (arry[r][c] != 0) {
                    g2.setColor(255, 250, 240);
                    g2.fillRect(20 + c * (Draw2048.D + Draw2048.space), 20 + r* (Draw2048.D + Draw2048.space), Draw2048.D,
                            Draw2048.D);
                    g2.setColor(new Color(0, 191, 255));
                    g2.setFont(new Font("楷体", Font.BOLD, Draw2048.FSIZE));
                    g2.drawString(arry[r][c] + "", 50 + c* (Draw2048.D + Draw2048.space), 90 + r* (Draw2048.D + Draw2048.space));
                }
            }
        }
        g.drawImage(image, 50, 150, this);
    }

Draw2048是一个接口，里面定义了关于方格绘制的相关常量，D方格边长，space方格间间隔。RD背景大矩形的边长。使用接口的好处就是使得界面的更改（如改成5*5的格子）可以更加方便的实现，提高程序的扩展性。另外界面需要不断的更新，所以要调用paint方法不断的重绘。如果直接把这里的绘制写在paint方法中，不断的重绘会使得界面一直在闪烁。这里的解决方案就是使用图片缓冲，先在图片中绘制好，在把图片一次性绘制出来，这样就不会出现界面的闪烁问题了。

Bewegungsumsetzung:

Wenn Sie die Quadrate bewegen möchten, können Sie dies tun Betrachten Sie es Die Methode besteht darin, die Zeichenfläche neu zu zeichnen. Die Zahlen im Quadrat werden in einem zweidimensionalen Array gespeichert. Lassen Sie den Wert des Arrays einfach jedes Mal ändern, wenn Sie es verschieben, und zeichnen Sie dann die Daten basierend auf dem Wert des Arrays in die Schnittstelle. Natürlich können wir uns beim Spielen nicht auf unsere Gedanken verlassen, um sie zu steuern. Wir brauchen ein Eingabegerät, also eine Tastatur. Daher muss die Schnittstelle um eine Tastaturüberwachung erweitert werden. Wenn der Benutzer unterschiedliche Tasten drückt, werden unterschiedliche Bewegungsalgorithmen implementiert. Es ist zu beachten, dass Sie beim Schreiben des entsprechenden Bewegungsalgorithmus in der Listening-Klasse die Verwendung und das Ende von -Schleifen (insbesondere die Verwendung von Break-Anweisungen) klären müssen, da sonst verschiedene Fehler auftreten. Die mobile Implementierung erfordert die Verwendung der Klasse keyListener.

Die Umsetzung der Aufwärtsbewegung ist ähnlich. Denken Sie einfach selbst darüber nach:

<span style="font-size: 16px"><span style="color: #0000ff"><span style="color: #339966">//向上移动的算法</span><br/>for</span> (<span style="color: #0000ff">int</span> r = 0; r < arry.length; r++<span style="color: #000000">) </span><span style="color: #0000ff">for</span> (<span style="color: #0000ff">int</span> c = 0; c < arry[r].length; c++<span style="color: #000000">) {</span><span style="color: #0000ff">if</span> (arry[r][c] > max)<span style="color: #008000">//</span><span style="color: #008000">找出数组最大值，用于判断玩家的方块是否达到2048</span>max =<span style="color: #000000"> arry[r][c];</span><span style="color: #0000ff">if</span> (arry[r][c] == 0<span style="color: #000000">) {</span><span style="color: #0000ff">for</span> (<span style="color: #0000ff">int</span> r1 = r + 1; r1 < arry[c].length; r1++<span style="color: #000000">) </span><span style="color: #0000ff">if</span> (arry[r1][c] != 0<span style="color: #000000">) {
                                arry[r][c] </span>=<span style="color: #000000"> arry[r1][c];
                                arry[r1][c] </span>= 0<span style="color: #000000">;
                                count</span>++<span style="color: #000000">;<span style="color: #339966">//判断是否发生移动，并且作为输赢判断的标准之一</span></span><span style="color: #0000ff">break</span><span style="color: #000000">;
                            }
                    　　}
                }</span>

Durchlaufen Sie die Doppelschichtschleife durch jeden Wert. Wenn er 0 ist, können Sie nach oben gehen. Durchlaufen Sie die Spalte, in der sich der Wert befindet, suchen Sie den ersten Wert, der nicht 0 ist, und verschieben Sie diesen Wert (dh tauschen Sie die Werte der beiden Zahlen aus). Verlassen Sie nach der Verschiebung die innere Schleife und fahren Sie mit dem Durchlaufen des nächsten Werts fort.

Addition von Zahlen:

Verwenden Sie einen unabhängigen Algorithmus, um das Array zu durchlaufen, addieren Sie zwei benachbarte Zahlen in Bewegungsrichtung und dann ist Eins auf 0 gesetzt. Die Algorithmusimplementierung ist hier dem Bewegungsalgorithmus sehr ähnlich Was ebenfalls Aufmerksamkeit erfordert, ist die Verwendung von Break und Loop . Beachten Sie außerdem, dass die Addition der Zahlen vor dem Verschieben der Zahlen abgeschlossen sein muss, da sonst nach dem Verschieben Leerzeichen in den Zahlen entstehen.

<span style="font-size: 16px"><span style="color: #0000ff"><span style="color: #339966">//向左的相加算法</span><br>for</span> (<span style="color: #0000ff">int</span> r = 0; r < arry.length; r++<span style="color: #000000">)</span><span style="color: #0000ff">for</span> (<span style="color: #0000ff">int</span> c = 0; c < arry[r].length; c++<span style="color: #000000">)</span><span style="color: #0000ff">if</span> (arry[r][c] != 0<span style="color: #000000">)</span><span style="color: #0000ff">for</span> (<span style="color: #0000ff">int</span> c1 = c + 1; c1 < arry[r].length; c1++<span style="color: #000000">)</span><span style="color: #0000ff">if</span> (arry[r][c] ==<span style="color: #000000"> arry[r][c1]) {
                    arry[r][c] </span>*= 2<span style="color: #000000">;
                    score </span>+=<span style="color: #000000"> arry[r][c];
                    arry[r][c1] </span>= 0<span style="color: #000000">;
                    count</span>++<span style="color: #000000">；<span style="color: #339966">//判断是否发生相加，并作为输赢判断条件之一。</span></span><span style="color: #0000ff">break</span><span style="color: #000000">;
                    } </span><span style="color: #0000ff">else</span> <span style="color: #0000ff">if</span> (arry[r][c1] != 0<span style="color: #000000">) {                      </span><span style="color: #0000ff">break</span><span style="color: #000000">;
                    }</span></span>

Es durchläuft auch jeden Wert des Arrays, wenn dieser Wert nicht 0 ist Suchen Sie die benachbarten -Werte derselben Zeile und addieren Sie sie, um die innerste Schleife zu beenden. Wenn die beiden benachbarten Werte von unterschiedlich sind, beendet auch die innerste Schleife. Durch die Verwendung von zwei Break-Anweisungen wird das Springen und Addieren zwischen Zahlen vermieden.

Beurteilung von Sieg oder Niederlage:

Die Gewinnregel für 2048 lautet, dass die hinzugefügte Zahl 2048 erscheint, Sie müssen also nur beurteilen, ob Es gibt eine im Array. Solange die Zahl gleich 2048 ist, werden in diesem Fall die entsprechenden Gewinninformationen ausgegeben.

Die Verliererregel für 2048 ist, dass die Schnittstelle voll ist (das Array ist voll und es werden keine Zahlen verschoben oder hinzugefügt). Meine persönliche Beurteilungsmethode besteht darin, die globale Variablenanzahl hinzuzufügen, um festzustellen, ob das Array voll ist. Wenn count gleich 0 ist, bedeutet dies, dass Bewegung und Addition nicht ausgeführt werden können. Wenn das Array voll ist, kann davon ausgegangen werden, dass der Spieler verloren hat.

Das Erscheinen von Zufallszahlen:

Die Bedingung für das Erscheinen von Zufallszahlen ist Bewegung oder Addition, daher wird die Zählung zur Beurteilung herangezogen. Ist die Bedingung erfüllt, wird der entsprechende Algorithmus aufgerufen.

Das obige ist der detaillierte Inhalt vonBeispiele für Spielfunktionen, die in Java Version 2048 implementiert sind. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!