So implementieren Sie das Minispiel Snake War in Java

1. Entwicklungsumgebung und Spielanzeige

Der Design- und Experimentierprozess von Snake War muss auf dem Windows 10-System und dem Entwicklungstool IntelliJ IDEA Community Edition 2020.3.2 durchgeführt werden ( jdk-15) Vollständiges Schreiben, Kompilieren, Debuggen, Testen usw. des Codes. Die vom Programm benötigten Komponenten wie Kopf, Körper und Hintergrundbilder der Schlange werden alle mit der Bildsoftware Adobe Photoshop 2020 erstellt.

1.1 Hauptschnittstelle des Spiels

1.2 Mobilschnittstelle

#🎜🎜 #

1.3 Belohnungsschnittstelle

1. Das Spiel erreicht 50 Punkte:

#🎜 🎜 #

2. Das Spiel erreicht 100 Punkte:

1.4 F-Beschleunigungsfunktionsschnittstelle

#🎜🎜 #Drücken Wenn F gedrückt wird, erhöht sich die Geschwindigkeit auf 100.

1.5 Todesschnittstelle

2. Anforderungsanalyse#🎜🎜 #Snake Game ist ein kleines Puzzlespiel, das in der täglichen Freizeit, Unterhaltung und anderen Szenarien eingesetzt werden kann. Dieses Spieldesign erfordert Kenntnisse über eindimensionale Arrays, gemeinsame Komponenten in Swing, Ereignisverarbeitung in der GUI (Ereignis-Listener, Tastatur-Listener), Klassenkapselung und -vererbung, statische Variablen, Verpackungsklassen, Zufallszahlen usw.

Die spezifischen Anforderungen sind wie folgt zusammengefasst:

1 Die Initialisierungsoberfläche hat eine Größe von 800 x 800 und die Spieloberfläche sollte in der Mitte des Bildschirms bleiben Das Fenster sollte das Wort „Schlange“ enthalten. Die Spieloberfläche sollte über den erforderlichen Eingabeaufforderungstext verfügen, um den Spielstand und die aktuelle Geschwindigkeit der Schlange anzuzeigen. Die Startoberfläche sollte einen Eingabeaufforderungstext enthalten (tippen Sie auf das Weltraumspiel, um das Spiel zu starten/anzuhalten, und halten Sie F gedrückt, um zu beschleunigen), und die Textfarbe sollte schön sein.

3 die Schlange im Programm (in der Nähe des Panels links), die Richtung der Schlange (Standard ist rechts), die Länge der Schlange (Standard ist 3) und die Position des Essens initialisieren; 4. Implementierung des Startens und Anhaltens des Spiels: gesteuert durch die Leertaste. Das Starten und Anhalten des Spiels;

5. Implementierung der Schlangenbewegungsfunktion: Verwenden Sie W, S, A, D oder &uarr ;, ↓, ←, → um die Bewegungsrichtung der Schlange nach oben, nach links und nach rechts zu steuern;

6 Aktivität: Der Schlangenkopf berührt das äußerste rechte (linke) Ende der Schnittstelle und erscheint am symmetrischen linken (rechten) Ende usw. Wenn der Schlangenkopf das obere (untere) Ende der Schnittstelle berührt, erscheint er am symmetrischen unteres (oberes) Ende;

7. Erkenntnis der Funktion des Schlangenfressens: Während des Spiels, wenn der Schlangenkopf das Essen berührt, Essen. Zu diesem Zeitpunkt sollte die Länge der Schlange um 1 erhöht werden, die Geschwindigkeit sollte um 10 erhöht werden, die Punktzahl sollte um 10 erhöht werden und die Position des Futters wird aktualisiert (zufällige Position); 🎜#8. Implementierung der Schlangenbeschleunigungsfunktion: Wenn die Taste gedrückt wird, beschleunigt die Schlange und der Geschwindigkeitswert erreicht 100; wenn die Taste „F“ losgelassen wird, kehrt die Schlange zur Standardgeschwindigkeit zurück von 10; Wenn die Schlange stirbt, wird das Spiel in der Nähe der Mitte aufgefordert: „Deine kleine Schlange ist gestorben, drücke die Leertaste, um erneut zu beginnen!“ Wenn die Punktzahl 100 erreicht, gibt das Spiel die Meldung „Perfekt!!!“ aus. Wenn die Punktzahl 200 erreicht, wird die Meldung „Niemand kann aufhören!!!“ angezeigt Schlangenkopf;

Die grundlegende Operationstabelle lautet wie folgt:

# 🎜🎜#

3. System Design

3.1 Funktionsdesign des Gesamtsystems

Dieses Snake-Programm umfasst im Allgemeinen die Bewegung von Snake-Funktionen: die aktive Beschleunigungsfunktion von Snake, die Funktion zur Beurteilung von Spielregeln, die Funktion zur Steuerung der Hauptschnittstelle und die Funktion von Snake Funktion zum Essen von Lebensmitteln. Die Bewegungsfunktion der Schlange umfasst unter anderem die Schlüsselsteuerung der Bewegungsrichtung und die automatische Bewegung der Schlange; Zu den Hauptfunktionen der Schnittstellensteuerung gehören die Initialisierung der Schlange und die Initialisierung von Nahrungsmitteln. Zu den Funktionen einer gierigen Schlange, die Nahrung frisst, gehören das Wachstum des Schlangenkörpers, die Erhöhung der Schlangengeschwindigkeit, die Erhöhung der Punkte und die Position der Nahrungsauffrischung. Das spezifische Funktionsstrukturdiagramm lautet wie folgt:

3.2 Gesamtsystemprozessdesign

Stellen Sie beim Aufrufen des Snake-Programms zunächst fest, ob die Leertaste gedrückt wird. Wenn die Leertaste gedrückt wird, startet das Spiel. Nach dem Spielstart wird festgestellt, ob eine Tasteneingabe erfolgt, die Bewegungsrichtung der Schlange wird entsprechend den Tasteneinstellungen geändert oder beschleunigt, wenn keine Tastenbetätigung erfolgt, bewegt sich die Schlange weiter ursprüngliche Richtung. Während der Bewegung der Schlange wird beurteilt, ob die Schlange Nahrung gefressen hat. Wenn sie Nahrung gefressen hat, erhöht sich der Spielwert um 10, und auch die Bewegungsgeschwindigkeit der Schlange erhöht sich entsprechend Es wird beurteilt, ob die Schlange stirbt. Wenn die Schlange nicht tot ist, wird weiterhin beurteilt, ob eine Leerzeicheneingabe erfolgt. Andernfalls wird das Spiel angehalten. Es beurteilt weiterhin die Tasten, ändert den Bewegungszustand der Schlange entsprechend den Tasten und setzt das Spiel fort, bis die Schlange stirbt und das Spiel endet. 4. Funktionales Design 4.1 Snake-Bewegungs- und Beschleunigungsfunktionsdesign → Steuern Sie die Bewegungsrichtung der Schlange nach oben, unten, links und rechts, um das Spiel zu spielen. Wenn die F-Taste gedrückt wird, beschleunigt die Schlange.

4.2 Design der Beschleunigungs- und Todesbestimmungsfunktion für das Fressen von Nahrung durch gierige Schlangen

Im Prozess der Nahrungsfressung und Todesbestimmung für gierige Schlangen werden die folgenden Parameter verwendet:

Ein Parameter der Timer-Klasse: Typ int Zeit wird im Programm die Methode timer.setDelay(time) aufgerufen, um die Parameter des Timers zu ändern (je kleiner die Zeit, desto schneller bewegt sich die Schlange);

Parameter zum Aufzeichnen, ob die Schlange tot ist oder nicht: boolescher Typ isDied (wahr, die Schlange stirbt), wenn falsch, wird die Schlange leben), der Standardwert ist falsch; (ursprünglich 0), das Programm durchläuft die Steuerung jedes Mal, wenn Sie etwas essen, um 10 Punkte hinzuzufügen. Die Koordinaten des Schlangenkopfes: SnakeX[0] und SnakeY[0] vom Typ int, die die Horizontale und Vertikale speichern Koordinaten des Schlangenkopfes bzw.

• Die Koordinaten des Schlangenkörpers: int[] Typ „snakeX[i]“ und „snakeY[i]“ speichern jeweils die horizontalen und vertikalen Koordinaten jedes Schlangenkörpers (i≠0);
  Koordinaten von Lebensmitteln: Int-Typen foodX und foodY speichern jeweils die horizontalen und vertikalen Koordinaten des Lebensmittels. Die Koordinaten foodX und foodY sind alle Zufallszahlen, die mit der nextInt()-Methode in der Random-Klasse generiert werden, also die Koordinaten des Lebensmittels zufällig.

• Ich werde nicht näher auf die Verwendung der oben genannten Parameter eingehen.
• 4.2.1 Design der Nahrungsfress-Beschleunigungsfunktion der gierigen Schlange
  Wenn die Koordinaten des Schlangenkopfes SnakeX[0] und SnakeY[0] gleich den Koordinaten von foodX bzw. foodY sind, erhöht sich die Punktzahl um 10 und Die Länge des Schlangenkörpers erhöht sich um 1. Verringern Sie die Zeit des Timer-Parameters um 10, um die Extrapunkte zu erreichen, nachdem die Schlange Nahrung gefressen hat, verlängern Sie den Schlangenkörper und beschleunigen Sie die Funktion. Das Flussdesigndiagramm dieser Funktion lautet wie folgt:
4.2.2 Design der Schlangentodbestimmungsfunktion

• Wenn die gierige Schlange sich selbst frisst, stirbt die Schlange, das heißt, der Schlangenkopf koordiniert SnakeX[0] und SnakeY[0] Wenn sie gleich den Schlangenkörperkoordinaten SnakeX[i] bzw. SnakeY[i] sind, stirbt die Schlange. Zu diesem Zeitpunkt isDied=! ist gestorben.

• 4.3 Design der aktiven Beschleunigungsfunktion von Snake
• Die aktive Beschleunigungsfunktion von Snake bedeutet, dass sich die Schlange schneller bewegt, wenn Sie sie während des Spiels gedrückt halten und loslassen schneller wiederherstellen. Dies wird hauptsächlich durch den Tastatur-Listener in der GUI erreicht: keyPressed() und keyReleased() überwachen jeweils den Vorgang des Drückens der F-Taste und des Loslassens der F-Taste. Zweitens wird im Programm der Parameter time verwendet, indem die Methode timer.setDelay(time) aufgerufen wird (Timer ist ein Objekt der Timer-Klasse), um die Frequenz des Timers zu ändern und so den Effekt zu erzielen die Schlange zu beschleunigen.

4.4 Design der Snake Reward Mechanism-Funktion

Die Snake Reward Mechanism-Funktion wird hauptsächlich mithilfe der Auswahlstruktur und des Pinselwerkzeugs in der Methode paintComponent(Graphics g) implementiert. Wenn das Spiel eine bestimmte Punktzahl erreicht, ruft das Programm die Methode g.drawString("XXX", SnakeX[0], SnakeY[0]) im Pinselwerkzeug auf, um Eingabeaufforderungstext an der Position des Schlangenkopfes zu zeichnen. 5. Projektstruktur und Projektdurchführung 5.1 Projektstruktur und Beziehung zwischen Klassen

Diese Klasse ist eine statische Klasse, die hauptsächlich die Bildobjekte der Snake-Komponente speichert.

package snakegame;

import javax.swing.*;
import java.net.URL;

//Images类用于封装图片路径以及获取图片（使用静态对象便于用类名直接访问）
public class Images {
    //将图片的路径封装成一个对象
    public static URL bodyURL=Images.class.getResource("/snake_images/body.jpg");
    public static URL backURL=Images.class.getResource("/snake_images/back.jpg");
    public static URL snakeDownURL=Images.class.getResource("/snake_images/snakeDown.jpg");
    public static URL snakeLeftURL=Images.class.getResource("/snake_images/snakeLeft.jpg");
    public static URL snakeRightURL=Images.class.getResource("/snake_images/snakeRight.jpg");
    public static URL snakeUpURL=Images.class.getResource("/snake_images/snakeUp.png");
    public static URL foodURL=Images.class.getResource("/snake_images/food.jpg");
    //将图片封装为程序中的对象
    public static ImageIcon bodyImg=new ImageIcon(bodyURL);
    public static ImageIcon backImg=new ImageIcon(backURL);
    public static ImageIcon snakeDownImg=new ImageIcon(snakeDownURL);
    public static ImageIcon snakeUpImg=new ImageIcon(snakeUpURL);
    public static ImageIcon snakeRightImg=new ImageIcon(snakeRightURL);
    public static ImageIcon snakeLeftImg=new ImageIcon(snakeLeftURL);
    public static ImageIcon foodImg=new ImageIcon(foodURL);
}

5.2.2 HighestScore

Diese Klasse implementiert die Funktion für die höchste Punktzahl in der Geschichte.

package snakegame;

import org.w3c.dom.Text;

import java.io.*;

//该类用于给游戏添加历史最高分功能
public class HighestScore {
    static int score = 0;//最高分的存储

    public void highest() throws IOException {
        //得分为最高分时存储
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(String.valueOf(Text.class.getResourceAsStream("贪吃蛇大作战/score.txt"))));
        if (GamePanel.score > score) {
            score = GamePanel.score;
            String s1 = String.valueOf(score);
            bos.write(s1.getBytes());
        }
        bos.close();
    }

    //用于游戏开始时从文件读取最高分的值
    public void readHighest() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(String.valueOf(Text.class.getResourceAsStream("贪吃蛇大作战/score.txt"))));
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys)) != -1) {
            System.out.print(new String(bys, 0, len));//测试用
            String s2 = new String(bys, 0, len);
            score = Integer.valueOf(s2);
        }
        bis.close();
    }
}

5.2.3 GamePanel-Klasse

Diese Klasse wird verwendet, um das Snake-Spielpanel zu zeichnen und spezifische Logikfunktionen des Spiels zu implementieren.

package snakegame;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.IOException;
import java.util.Random;

//贪吃蛇游戏面板的绘制
public class GamePanel extends JPanel {
    Timer timer;
    int time=100;
    static int score;//记录游戏分数
    //蛇属性部分
    boolean isDied;
    int length;//设置蛇长
    String direction;//蛇头朝向
    //分别储存蛇身的X，Y坐标
    int[] snakeX=new int[300];
    int[] snakeY=new int[300];
    //判断游戏是否开始
    boolean isStart=false;
    int foodX,foodY;//食物的X，Y坐标
    //贪吃蛇初始化方法
    public void init(){
        length=3;
        snakeX[0]=175;
        snakeY[0]=275;
        snakeX[1]=150;
        snakeY[1]=275;
        snakeX[2]=125;
        snakeY[2]=275;
        foodX=300;
        foodY=400;
        score=0;
        isDied=false;//蛇默认状态为活着
        direction="R";//U,D,L,R分别表示蛇头朝向上，下，左，右
    }

    //构造方法
    public GamePanel() throws IOException {
        init();

        if(GamePanel.score>HighestScore.score){
            new HighestScore().highest();
        }
        //焦点定位到当前面板
        this.setFocusable(true);
        //监听器的实现部分
        this.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                super.keyPressed(e);
                int keyCode = e.getKeyCode();
                //按下空格以开始游戏，以及方向键的控制
                if (keyCode == KeyEvent.VK_SPACE) {
                    if(isDied){
                        init();
                    }else {
                        isStart = !isStart;
                        repaint();//重绘
                    }
                } else if (keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_W) {
                    direction = "U";
                } else if (keyCode == KeyEvent.VK_DOWN || keyCode == KeyEvent.VK_S) {
                    direction = "D";
                } else if (keyCode == KeyEvent.VK_LEFT || keyCode == KeyEvent.VK_A) {
                    direction = "L";
                } else if (keyCode == KeyEvent.VK_RIGHT || keyCode == KeyEvent.VK_D) {
                    direction = "R";
                }
            }
        });
        //贪吃蛇加速功能的实现
        this.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                int keyCode=e.getKeyCode();
                if(keyCode==KeyEvent.VK_F){
                    time=10;
                    timer.setDelay(time);//按下F时加速
                }
            }

            @Override
            public void keyReleased(KeyEvent e) {
                int keyCode=e.getKeyCode();
                if(keyCode==KeyEvent.VK_F){
                    time=100;
                    timer.setDelay(time);//松开F键减速恢复默认速度
                }
            }
        });
        //对定时器进行初始化，并实现监听器
            timer = new Timer(time, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    //当游戏处于开始状态且蛇活着时蛇活动，且后一节身子到前一节身子的位置上（每一节身子为25乘25像素）
                    if (isStart && isDied == false) {
                        //蛇身运动部分
                        for (int i = length - 1; i > 0; i--) {
                            snakeX[i] = snakeX[i - 1];
                            snakeY[i] = snakeY[i - 1];
                        }
                        //蛇头运动部分
                        if ("D".equals(direction)) {
                            snakeY[0] += 25;
                        }
                        if ("U".equals(direction)) {
                            snakeY[0] -= 25;
                        }
                        if ("L".equals(direction)) {
                            snakeX[0] -= 25;
                        }
                        if ("R".equals(direction)) {
                            snakeX[0] += 25;
                        }
                        //防止超出边界
                        if (snakeX[0] > 750) {
                            snakeX[0] = 25;
                        }
                        if (snakeX[0] < 25) {
                            snakeX[0] = 750;
                        }
                        if (snakeY[0] < 100) {
                            snakeY[0] = 725;
                        }
                        if (snakeY[0] > 725) {
                            snakeY[0] = 100;
                        }
                        //吃食物的动作,吃食物加10分且蛇身变长,蛇的速度提升10
                        if ((snakeX[0] == foodX && snakeY[0] == foodY)) {
                            length++;//蛇身长度加1
                            foodX = (new Random().nextInt(30) + 1) * 25;//随机生成X坐标[25,750]
                            foodY = (new Random().nextInt(26) + 4) * 25;//随机生成Y坐标[100,725]
                            score += 10;//吃一次食物积分加10
                            try {
                                new HighestScore().highest();
                            } catch (IOException ioException) {
                                ioException.printStackTrace();
                            }
                            if(time>10)
                                timer.setDelay(time-=10);//吃一次食物速度增加10
                        }
                        //蛇的死亡机制判定
                        for (int i = 1; i < length; i++) {
                            if (snakeX[0] == snakeX[i] && snakeY[0] == snakeY[i]) {
                                isDied = !isDied;
                            }
                        }
                        repaint();
                    }
                }
            });
            timer.start();//定时器启动
    }

    //绘制面板部分
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        //填充背景颜色
        this.setBackground(new Color(164, 219, 246));
        //绘制初始蛇头的图片（默认右方朝向）
        Images.backImg.paintIcon(this,g,10,10);
        //调整画笔的颜色并绘制一个矩形面板
        g.setColor(new Color(219,226,219));
        g.fillRect(10,70,770,685);
        //蛇头的绘制;上下左右不同情况
        if("L".equals(direction)){
            Images.snakeLeftImg.paintIcon(this,g,snakeX[0],snakeY[0]);
        }
        if("R".equals(direction)){
            Images.snakeRightImg.paintIcon(this,g,snakeX[0],snakeY[0]);
        }
        if("U".equals(direction)){
            Images.snakeUpImg.paintIcon(this,g,snakeX[0],snakeY[0]);
        }
        if("D".equals(direction)){
            Images.snakeDownImg.paintIcon(this,g,snakeX[0],snakeY[0]);
        }
        //蛇身的绘制
        for(int i=1;i<length;i++) {
            Images.bodyImg.paintIcon(this, g, snakeX[i], snakeY[i]);
        }
        //食物绘制
       Images.foodImg.paintIcon(this,g,foodX,foodY);
        //游戏的文字提示语
        if(!isStart&&!isDied){
            g.setColor(new Color(12, 191, 222));
            g.setFont(new Font("楷体",Font.BOLD,40));
            g.drawString("轻按空格以开始/暂停游戏！",150,330);
            g.setColor(new Color(246, 2, 31));
            g.setFont(new Font("宋体",Font.CENTER_BASELINE,30));
            g.drawString("按住F以加速",300,380);
        }
        //游戏的得分显示
        g.setColor(new Color(248, 4, 74));
        g.setFont(new Font("楷体",Font.BOLD,30));
        g.drawString("得分:"+score,420,90);
        //游戏的最高分展示模块
        try {
            new HighestScore().readHighest();
        } catch (IOException e) {
            e.printStackTrace();
        }
        g.setColor(new Color(183, 25, 238));
        g.setFont(new Font("楷体",Font.BOLD,30));
        g.drawString("历史最高分:"+HighestScore.score,10,90);
        //蛇的速度提示
        g.setColor(new Color(248, 136, 36));
        g.setFont(new Font("楷体",Font.BOLD,30));
        g.drawString("当前速度:"+String.valueOf(110-time),550,90);
        //游戏的奖励鼓励机制
        if(score==10){
            g.setColor(new Color(127, 232, 20));
            g.setFont(new Font("微软雅黑",Font.BOLD,50));
            g.drawString("Good!",snakeX[0],snakeY[0]);
        }
        else if(score==50){
            g.setColor(new Color(17, 231, 250));
            g.setFont(new Font("微软雅黑",Font.BOLD,50));
            g.drawString("Good!!!",snakeX[0],snakeY[0]);
        }else if(score==100){
            g.setColor(new Color(248, 196, 6));
            g.setFont(new Font("微软雅黑",Font.BOLD,50));
            g.drawString("Perfect!!!",snakeX[0],snakeY[0]);
        }else if(score==200){
            g.setColor(new Color(248, 245, 26));
            g.setFont(new Font("微软雅黑",Font.BOLD,50));
            g.drawString("无人能挡!!!",snakeX[0],snakeY[0]);
        }
        //小蛇死亡时面板的绘制
        if(isDied){
            g.setColor(new Color(6, 115, 248));
            g.setFont(new Font("微软雅黑",Font.BOLD,30));
            g.drawString("你的小蛇已经死亡，按下空格重新开始！",170,330);
        }
    }
}

5.2.4 Klasse starten

Das Gesamtlayout der Seite und der Eingang des Programms.

package snakegame;

import javax.swing.*;
import java.awt.*;
import java.io.IOException;

//贪吃蛇总体界面布局以及程序的主方法
public class Start {
    public static void main(String[] args) throws IOException {
        JFrame jf=new JFrame("贪吃蛇");
        //获取屏幕的大小，并使用数据使窗口位置居中
        int width= Toolkit.getDefaultToolkit().getScreenSize().width;
        int height= Toolkit.getDefaultToolkit().getScreenSize().height;
        jf.setBounds((width-800)/2,(height-800)/2,800,800);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.setResizable(false);//设置窗口大小不能更改
        //添加GamePanel面板
        GamePanel panel=new GamePanel();
        jf.add(panel);
        jf.setVisible(true);
    }
}

Das obige ist der detaillierte Inhalt vonSo implementieren Sie das Minispiel Snake War in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!