„Java Mini Game Implementation“: Panzerschlacht (Fortsetzung 3)

Blogbeitrag „Java Mini Game Implementation“: In Tank Battle (Fortsetzung 2) wurde erkannt, dass Panzer Kugeln abfeuern und feindliche Panzer treffen können. In diesem Blogbeitrag werden auf dieser Basis weitere Funktionen implementiert.

Fertiggestelltes Feature: Explosionseffekt hinzugefügt

In der vorherigen Version haben wir den feindlichen Panzer getroffen und der feindliche Panzer ist einfach verschwunden, ohne einen Effekt zu erzeugen, der der Explosion ähnelt, die wir kennen. Als nächstes fügen wir diesen Explosionseffekt hinzu.

vcSjxOLV4tK7uabE3KGjPGJyIC8+DQo8aW1nIGFsdD0="" src="/uploadfile/Collfiles/20160623/20160623091322277.png" title="" />

Zuerst alle, Wir erstellen eine Explosionsklasse Explode.

In der Explosionsklasse gibt es die folgenden Attribute und Methoden

1 Positionsinformationen x, y;

2. Attribute, die identifizieren, ob es lebendig ist

3. Das Bildarray, das die Explosion erzeugt (hier ersetzt durch Durchmesserzeichnung)

Der Code ist wie folgt:

Nachdem wir diese Explosionsklasse geschrieben haben, können wir sie in der TankClient-Klasse testen. Der Code, der zum Testen hinzugefügt werden muss, lautet wie folgt:

<code class="hljs java">    public class Explode {
        //爆炸所在的位置
        private int x;
        private int y;
 
        //爆炸图片的直径
        private int[] diameter={6,20,40,60,20,7};
 
        //标识爆炸对象是否存活的属性
        private boolean live =true;
 
        public boolean isLive() {
            return live;
        }
 
        //标识爆炸显示到第几步了
        private int step = 0;
 
        private TankClient tc;
 
        public Explode(int x ,int y , TankClient tc){
            this.x = x;
            this.y = y;
            this.tc = tc;
        }
 
        /*
         * 让爆炸显示出来
         * */
        public void draw(Graphics g){
            if(!live) return;
            //判断显示到第几步了，如果全部显示完了，则此对象已死，返回
            if(step>=diameter.length){
                live = false;
                step = 0;
                return;
            }
            Color c = g.getColor();
            g.setColor(Color.YELLOW);
            g.fillOval(x, y, diameter[step], diameter[step]);
            g.setColor(c);
            step++;
        }
 
 
    }</code>

Der Test ergab, dass wir einen explosionsähnlichen Effekt beobachteten.

<code class="hljs java">    private Explode explode = new Explode(200,200,this);
    @Override
    public void paint(Graphics g) {
        //炸弹对象
        explode.draw(g);
    }
</code>

Vollständige Funktion: Fügen Sie einen Explosionseffekt hinzu, wenn eine Kugel einen Panzer trifft.

Fügen Sie einen Explosionseffekt hinzu, wenn eine Kugel einen Panzer trifft. Es muss ein Explosionsobjekt hinzugefügt werden. Befolgen Sie daher die beiden folgenden Schritte, um diese Funktion abzuschließen.

1. Explosion sollte in der Sammlungsklasse vorhanden sein.

Fügen Sie den folgenden Code in der TankClient-Klasse hinzu:

<code>与子弹类似，在TankClient类中加入集合
将集合中的爆炸逐一画出（如果死去就去除）
</code>

2. Nachdem eine Kugel einen Panzer getroffen hat, sollte ein Explosionsobjekt generiert und der Explosionssammlung von TankClient hinzugefügt werden .

<code class="hljs cs">    /*
     * 为每个被击中的坦克添加一个爆炸对象
     * */
    private List<explode> explodes = new ArrayList<explode>(); 
 
    @Override
    public void paint(Graphics g) {
        //炸弹对象
        for(int i=0;i<explodes.size();i++){ code="" e="explodes.get(i);" explode=""></explodes.size();i++){></explode></explode></code>

Der Code der hitTank-Methode in der Missile-Klasse lautet wie folgt:

<code class="hljs cs"><code>在Missile类中hitTank方法中添加相关代码
</code></code>

Das Obige erzielt einen Explosionseffekt, wenn eine Kugel den Panzer trifft.

<code class="hljs cs"><code class="hljs java">    public boolean hitTank(Tank t){
        //先判断该坦克是否还是存活，如果已经死了，子弹就不打他了
        if(!t.isLive()){
            return false;
        }
        if(this.getRect().intersects(t.getRect())){//判断是否有碰撞
            //碰撞之后，子弹和该坦克就应该都死了
            this.live = false;//子弹死了
            t.setLive(false);//坦克死了
            Explode e = new Explode(x,y,tc);
            tc.getExplodes().add(e);
            return true;
        }
        else{
            return false;
        }
    }
</code></code>

Abgeschlossene Funktion: Mehrere feindliche Panzer hinzufügen

In der vorherigen Version gab es einen eigenen Panzer und einen feindlichen Panzer, der sich nicht bewegen oder Kugeln abfeuern konnte. Wir werden sterben, sobald wir kämpfen. Das ist langweilig. Daher können wir durch Drücken der A-Taste mehrere feindliche Panzer zur Benutzeroberfläche hinzufügen oder zufällig Panzer generieren.

In unserem eigentlichen Spiel werden Panzer im Allgemeinen zufällig generiert. Wenn wir sie zerstören, wird eine weitere Charge generiert.

Der Implementierungsprozess ist wie folgt:

1. Deklarieren Sie ein List-feindTanks-Objekt in TankClient.java, um eine bestimmte Anzahl feindlicher Panzerobjekte zu speichern.

2. Schreiben Sie die folgende Funktion, um zufällig eine bestimmte Anzahl von Panzern an zufälligen Positionen zu generieren.

3. Zeichnen Sie es einfach in der Zeichenfunktion in TankClient.java.

<code class="hljs cs"><code class="hljs cs">    /*
     * 函数功能：产生敌方坦克
     * */
    public void produceTank(){
 
        int totalNum =r.nextInt(4)+3 ;
 
        for(int i=0;i<totalnum;i++){ code="" enemy="new" int="" tank="" x="(r.nextInt(10)+1)*40;"
         y="(r.nextInt(10)+1)*30;"></totalnum;i++){></code></code>

4. Da es zu diesem Zeitpunkt mehrere feindliche Panzer gibt, wurde in Missile eine hitTanks-Methode (Panzer auflisten) hinzugefügt, um eine Reihe von Panzern zu treffen. Im TankClient wird jede Kugel in Panzer abgefeuert.

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs">    @Override
    public void paint(Graphics g) {
 
        //直接调用坦克类的draw方法
        tk.draw(g); 
 
        /*
         * 将敌方坦克也画出来,如果没有了敌方坦克，则产生一定数量的地方坦克
         * */
        if(enemyTanks.size()==0){
            this.produceTank();
        }
        for(int i=0;i<enemytanks.size();i++){ code="" e="explodes.get(i);" enemy="enemyTanks.get(i);" explode="" i="0;i<explodes.size();i++)
        {" int="" missile="" ms="missiles.get(i);" tank=""></enemytanks.size();i++){></code></code></code>

Abgeschlossene Funktion: Feindliche Panzer intelligenter machen (bewegen)

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs"><code class="hljs java">    public boolean hitTank(Tank t){
        //先判断该坦克是否还是存活，如果已经死了，子弹就不打他了
        if(!t.isLive()){
            return false;
        }
        if(this.getRect().intersects(t.getRect())){//判断是否有碰撞
            //碰撞之后，子弹和该坦克就应该都死了
            this.live = false;//子弹死了
            t.setLive(false);//坦克死了
            Explode e = new Explode(x,y,tc);
            tc.getExplodes().add(e);
            return true;
        }
        else{
            return false;
        }
    }
    /*
     * 一颗子弹打List中的坦克
     * */
    public boolean hitTanks(List<tank> tanks){
        for(int i=0;i<tanks.size();i++){ code="" return=""></tanks.size();i++){></tank></code></code></code></code>

Die vorherige Version konnte nur eine bestimmte zufällige Anzahl von Panzern generieren, diese konnten sich jedoch nicht zufällig bewegen .

Die Änderungen sind wie folgt:

1. Fügen Sie in der Tank-Klasse den folgenden Konstruktor hinzu

2. Verwenden Sie dann das Obige in der Methode „produzierenTank“ im TankClient Klasse Der Konstrukteur jedes neuen feindlichen Panzerobjekts

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs"><code class="hljs java"><code class="hljs java">        
public Tank(int x, int y,boolean good,Direction dir, TankClient tc) {
            this(x,y,good);
            this.dir = dir;
            this.tc = tc;
        }</code></code></code></code></code>

kann sich durch die Schritte 1 und 2 bewegen, aber das reicht nicht aus, da er immer in seine Richtung initialisiert wird. Die Richtung bewegt sich weiter.

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs"><code class="hljs java"><code class="hljs cs">    /*
     * 函数功能：产生敌方坦克
     * */
    public void produceTank(){
 
        int totalNum =r.nextInt(4)+3 ;
 
        for(int i=0;i<totalnum;i++){ code="" dir="dirs[rn];" direction="" dirs="Direction.values();" enemy="new" int="" 
        rn="r.nextInt(dirs.length);" tank="" x="(r.nextInt(10)+1)*40;" y="(r.nextInt(10)+1)*30;"></totalnum;i++){></code></code></code></code></code>

Um dieses Problem zu lösen. Bei der Draw-Methode in der Tank-Klasse legen wir die Anzahl der Bewegungen fest. Wenn die Anzahl der Bewegungen eines feindlichen Panzers den Schritt erreicht, ändern wir zufällig seine Richtung.

Basierend auf der obigen Idee lautet der Code der Zeichenmethode in der Tank-Klasse wie folgt:

Das Obige realisiert die zufällige Bewegung mehrerer feindlicher Panzer.

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs">
<code class="hljs java"><code class="hljs cs"><code class="hljs cs">        //坦克没走step步，随机换一个方向
        private Random r = new Random();
        private int step = r.nextInt(7)+3;
 
 
        public void draw(Graphics g){
            if(!live){      //判断坦克是否存活，如果死了，则不绘画出来，直接返回     
                return ;
            }
            if(!this.good){
                if(step==0){
                    Direction[] dirs =Direction.values();
                    int rn = r.nextInt(dirs.length);
                    this.dir = dirs[rn];
                    step = r.nextInt(7)+3;
                }
            }
 
            Color c = g.getColor();
            if(good){
                g.setColor(Color.RED);
            }
            else{
                g.setColor(Color.BLUE);
            }
 
            g.fillOval(x, y, WIDTH, HEIGHT);
            g.setColor(c);
            //画一个炮筒
            drawGunBarrel(g);
 
            move();//根据键盘按键的结果改变坦克所在的位置
 
            step--;
        }</code></code></code></code></code></code>

Komplette Funktion: Feindliche Panzer feuern Kugeln ab

Diese Version fügt die Funktion hinzu, Kugeln auf feindliche Panzer abzufeuern.

Da unsere Panzer auch Kugeln abfeuern und feindliche Panzer ebenfalls Kugeln abfeuern, muss zwischen Kugeln und Geschossen unterschieden werden. Fügen Sie dem Aufzählungspunkt daher ein gutes Attribut hinzu, um festzustellen, ob das Aufzählungszeichen gut oder schlecht ist.

Die spezifischen Schritte sind wie folgt:

1 Fügen Sie das gute Attribut zur Missile-Klasse hinzu und fügen Sie einen Konstruktor wie folgt hinzu

2. Erzeugen Sie Aufzählungszeichen im Panzerklasse Verwenden Sie in der Methode fire() den obigen Konstruktor, um das Geschoss zu konstruieren. Missile ms = new Missile(x,y,this.ptDir,this.good,this.tc);this.good bezieht sich auf die Qualität des Panzers , Solange der Panzer gut ist, ist das Geschossobjekt gut, andernfalls ist das Geschossobjekt schlecht, das heißt, das Geschossobjekt wird entsprechend der Qualität des Panzers generiert

Tank类中fire方法的具体代码如下：

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs"><code class="hljs java"><code class="hljs cs">
<code class="hljs cs">        public Missile fire(){
            //计算子弹的位置,并利用炮筒的方向来new一个子弹对象
            int x = this.x +(this.WIDTH)/2 - (Missile.WIDTH)/2;
            int y = this.y + (this.HEIGHT)/2 -(Missile.HEIGHT)/2;
            //根据坦克的类型(good)来new与之对应的子弹类型
            Missile ms = new Missile(x,y,this.ptDir,this.good,this.tc);
            return ms;
        }
</code></code></code></code></code></code>

3、更改以上两点，则在Tank类中draw方法中为坏坦克添加发射子弹这一功能。

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs"><code class="hljs java">
<code class="hljs cs"><code class="hljs cs">        public void draw(Graphics g){
            if(!live){      //判断坦克是否存活，如果死了，则不绘画出来，直接返回     
                return ;
            }
            //为坏坦克添加随机的方向
            if(!this.good){
                if(step==0){
                    Direction[] dirs =Direction.values();
                    int rn = r.nextInt(dirs.length);
                    this.dir = dirs[rn];
                    step = r.nextInt(7)+3;
                }
            }
            //根据坦克的好坏来设置不同的颜色
            Color c = g.getColor();
            if(good){
                g.setColor(Color.RED);
            }
            else{
                g.setColor(Color.BLUE);
            }
 
            g.fillOval(x, y, WIDTH, HEIGHT);
            g.setColor(c);
            //画一个炮筒
            drawGunBarrel(g);
 
            move();//根据键盘按键的结果改变坦克所在的位置
 
            step--;
 
            //敌方子弹开火
            if(!this.good&&r.nextInt(40)>38){
                this.tc.getMissiles().add(fire());
            }
 
        }
</code></code></code></code></code></code>

4、此时，经过上面的三步之后，我方和敌方都能够发射子弹了，但是敌方能够打死敌方的坦克。因此，还需要对Missile的hitTank(Tank t)方法进行修正。

即在碰撞检测条件中添加这一条：this.good!=t.isGood()，即只有子弹和坦克不是同一类型的，才能打死对方。

具体完整代码如下：

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs"><code class="hljs java">
<code class="hljs cs"><code class="hljs java">    public boolean hitTank(Tank t){
        //先判断该坦克是否还是存活，如果已经死了，子弹就不打他了
        if(!t.isLive()){
            return false;
        }
        if(this.live&&this.good!=t.isGood()&&this.getRect().intersects(t.getRect())){//判断是否有碰撞
            //碰撞之后，子弹和该坦克就应该都死了
            this.live = false;//子弹死了
            t.setLive(false);//坦克死了
            Explode e = new Explode(x,y,tc);
            tc.getExplodes().add(e);
            return true;
        }
        else{
            return false;
        }
    }
</code></code></code></code></code></code>

5、在Missile的draw方法中，根据子弹的好坏给出不同的颜色。这里采用好子弹采用红色，坏子弹采用蓝色进行区分。

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs"><code class="hljs java">
<code class="hljs cs"><code class="hljs cs">    public void draw(Graphics g){
        //如果该子弹不是存活的，则不进行绘图
        if(!live){
            return ;
        }
        Color c = g.getColor();
        //根据子弹的好坏来设置不同的颜色
        if(this.good){
            g.setColor(Color.RED);
        }
        else{
            g.setColor(Color.BLUE);
        }
 
        g.fillOval(x, y, WIDTH, HEIGHT);
        g.setColor(c);
        move();
    }
</code></code></code></code></code></code>

6、现在差不多就算完成了，但是，我们还需要在TankClient类中的draw方法中做一些改善，例如：1）将我方的坦克置于被敌方子弹攻击的范围内，2）我方坦克被打死之后，应该如何处理。

本项目中，处理的方法为，在我方坦克死亡之后，提示“Game Over，按键A可以复活！！！”字样，并按下键盘A产生一个新的我方坦克。

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs"><code class="hljs java"><code class="hljs cs"><code class="hljs cs">    @Override
    public void paint(Graphics g) {
 
        /*
         * 画出我们自己的坦克，首先判断自己的坦克是否是活的，如果是，则画出来
         * 否则，则提示 Game  Over ,并休眠100000毫秒
         * */
        if(tk.isLive()){
            tk.draw(g); 
        }
        else{
            g.drawString("Game Over,按键A可以复活！！！",GAME_WIDTH/2 , GAME_HEIGHT/2);
        }   
 
        /*
         * 将敌方坦克也画出来,如果没有了敌方坦克，则产生一定数量的地方坦克
         * */
        if(enemyTanks.size()==0){
            this.produceTank();
        }
        for(int i=0;i<enemytanks.size();i++){ code="" e="explodes.get(i);" enemy="enemyTanks.get(i);" explode="" i="0;i<explodes.size();i++){" 
        int="" missile="" ms="missiles.get(i);" tank=""></enemytanks.size();i++){></code></code></code></code></code></code>

在Tank类中的keyReleased方法中添加键盘A的事件。具体代码如下：

<code class="hljs cs"><code class="hljs cs"><code class="hljs cs"><code class="hljs java">
<code class="hljs cs"><code class="hljs cs"><code class="hljs cs">        //键盘按键松下时，也要进行记录
        public void keyReleased(KeyEvent e) {
            int key=e.getKeyCode();
            switch(key){
            case KeyEvent.VK_A:
                produceMainTank();
                break;
            //.....一些其它的case
            }
        }
 
        private void produceMainTank() {
            Tank t=this.tc.getTk();
            if(!t.isLive()){
                int x = r.nextInt(100)+200;
                int y = r.nextInt(150)+300;
                Tank newTank =new Tank(x,y,true,Direction.STOP,this.tc);
                this.tc.setTk(newTank);
            }           
        }
</code></code></code></code></code></code></code>

以上就基本上实现了坦克大战的敌我双方的游戏了。但是，还有一些需要我们完善的功能，例如，加入一些墙等等。在后面，将会慢慢实现。也会在博文中进行记录。

 以上就是《Java小游戏实现》：坦克大战(续三)的内容，更多相关内容请关注PHP中文网（www.php.cn）！