Exemples de fonctions de jeu implémentées dans Java version 2048

Exigences fonctionnelles : L'interface de base de 2048 peut réaliser les fonctions de jeu de 2048.

Idée générale : deux classes : Game et GameListener.

Game est responsable de l'implémentation de l'interface et de la réécriture de la méthode paint

GameListener est responsable du traitement du clavier et de la souris événements. La méthode de mouvement, la méthode d'addition, le jugement gagnant ou perdant et l'apparition de nombres aléatoires doivent être implémentés dans la méthode de surveillance du clavier.

Analyse de la mise en œuvre : Pour mettre en œuvre le jeu 2048, vous devez d'abord considérer ce qu'il y a dans 2048 ?

Implémentation de l'interface :

L'interface du jeu de 2048 est très simple, juste quelques carrés et chiffres. Pour implémenter une telle interface, on peut envisager d'utiliser la fonction de dessin de Java. Plus précisément, l'objet Graphics fourni par la classe JFrame est utilisé pour le dessin. L'interface 2048 se compose d'un grand fond rectangulaire et de nombreux petits carrés contenant des chiffres. La méthode de dessin de l'objet Graphics permet de réaliser le dessin d'un arrière-plan et de petits carrés. Les nombres dans les petits carrés peuvent être dessinés à l’aide de la méthode graphique drawString. Faites juste attention aux couleurs lorsque vous dessinez. Les principales classes requises pour l'implémentation de l'interface sont les classes JFrame.

Le code d'implémentation de base de l'interface est juste quelques boutons et autres, rien à dire.

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);
    }

Dessin de carrés et de chiffres :

Le dessin de carrés et de chiffres utilise également JFrame La toile La méthode de l'objet pour dessiner un rectangle est implémentée.

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方法中，不断的重绘会使得界面一直在闪烁。这里的解决方案就是使用图片缓冲，先在图片中绘制好，在把图片一次性绘制出来，这样就不会出现界面的闪烁问题了。

Mise en œuvre du mouvement :

Si vous souhaitez faire bouger les carrés, vous pouvez Considérez-le La méthode consiste à utiliser le redessin du plan de travail. Les nombres du carré sont stockés dans un tableau à deux dimensions. Laissez simplement la valeur du tableau changer à chaque fois que vous le déplacez, puis dessinez les données vers l'interface en fonction de la valeur du tableau. Bien sûr, lorsque nous jouons à des jeux, nous ne pouvons pas compter sur nos pensées pour les contrôler. Nous avons besoin d’un périphérique de saisie, c’est-à-dire d’un clavier. Par conséquent, la surveillance du clavier doit être ajoutée à l'interface. Lorsque l'utilisateur appuie sur différentes touches, différents algorithmes de mouvement sont mis en œuvre. Il est à noter que lors de l'écriture de l'algorithme de mouvement correspondant dans la classe d'écoute, vous devez clarifier l'utilisation et la fin des boucles (notamment l'utilisation des instructions break) , sinon divers bugs apparaîtront. L’implémentation mobile nécessite l’utilisation de la classe keyListener.

Ce qui suit est la mise en œuvre du mouvement ascendant. Le mouvement dans d'autres directions est similaire. Pensez-y vous-même :

<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>

.

Grâce à la boucle double couche, parcourez chaque valeur si elle est 0, vous pouvez monter. Parcourez la colonne où se trouve la valeur, recherchez la première valeur qui n'est pas 0 et déplacez cette valeur (c'est-à-dire échangez les valeurs des deux nombres). Après le déplacement, quittez la boucle interne et continuez à parcourir la valeur suivante.

Ajout de nombres :

Utilisez un algorithme indépendant pour parcourir le tableau, ajoutez deux nombres adjacents dans la direction du déplacement, puis One est mis à 0. L'implémentation de l'algorithme ici est très similaire à l'algorithme de déplacement Ce qui nécessite également une attention particulière, c'est l'utilisation de break et de boucle . Une autre chose à noter est que l'addition des nombres doit être complétée avant de déplacer les nombres, sinon il y aura des espaces dans les nombres après le mouvement.

<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>

Il parcourt également chaque valeur du tableau. Si cette valeur n'est pas 0, alors. Recherchez les valeurs adjacentes de la même ligne et additionnez-les ensemble pour terminer la boucle la plus interne. Si les deux valeurs adjacentes de sont différentes, termine également la boucle la plus interne. L'utilisation de deux instructions break évite de sauter et d'ajouter entre les nombres.

Jugement de gagner ou de perdre :

La règle gagnante pour 2048 est que le nombre ajouté apparaît 2048, il vous suffit donc de juger si il y en a un dans le tableau. Tant que le nombre est égal à 2048, si c'est le cas, les informations gagnantes correspondantes seront affichées.

La règle perdante pour 2048 est que l'interface est pleine (le tableau est plein et il n'y a pas de numéro mobile à ajouter). Ma méthode de jugement personnel consiste à ajouter le nombre de variables globales pour déterminer si le tableau est plein. Si le compte est égal à 0, cela signifie que le mouvement et l'addition ne peuvent pas être effectués. Si le tableau est plein, on peut considérer que le joueur a perdu.

L'apparition de nombres aléatoires :

La condition d'apparition de nombres aléatoires est le mouvement ou l'addition, le décompte est donc utilisé pour le jugement. Si la condition est établie, l’algorithme correspondant est appelé.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!