Java學習-第一部分-第二階段-項目實戰：坦克大戰【2】

来源:https://www.cnblogs.com/wenjie2000/archive/2022/09/02/16651070.html
-Advertisement-
Play Games

坦克大戰【2】 筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html) 線程-應用到坦克大戰 坦克大戰0.3版 陸游曾說:紙上得來總覺淺，絕知此事要躬行。前面我要已經瞭解java線程基本知識，現在我們來實際運用一下。 在坦克大戰游戲(0.2 ...


坦克大戰【2】

筆記目錄：(https://www.cnblogs.com/wenjie2000/p/16378441.html)

線程-應用到坦克大戰

坦克大戰0.3版

陸游曾說:紙上得來總覺淺，絕知此事要躬行。前面我要已經瞭解java線程基本知識，現在我們來實際運用一下。
在坦克大戰游戲(0.2版)基礎上添加如下功能:當玩家按一下j鍵,就發射一顆子彈.

分析如何實現當用戶按下J鍵，我們的坦克就發射一顆子彈.
思路

  1. 當發射一顆子彈後，就相當於啟動一個線程
  2. Hero有子彈的對象，當按下J時，我們就啟動一個發射行為(線程)，讓子彈不停的移動，形成一個射擊的效果
  3. 我們MyPanel需要不停的重繪子彈，才能出現該效果.
  4. 當子彈移動到面板的邊界時，就應該銷毀(把啟動的子彈的線程銷毀)

具體代碼如下

Tank

package tankgame03;

public class Tank {
    //坦克左上角坐標
    private int x;
    private int y;
    private int direct;//坦克方向 0上 1右 2下 3左

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    private int speed=1;//坦克速度

    //上右下左移動方法
    public void moveUp(){
        y-=speed;
    }
    public void moveDown(){
        y+=speed;
    }
    public void moveLeft(){
        x-=speed;
    }
    public void moveRight(){
        x+=speed;
    }

    public int getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        this.direct = direct;
    }

    public Tank(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

Hero

package tankgame03;

public class Hero extends Tank {
    Shot shot=null;//射擊行為
    public Hero(int x, int y) {
        super(x, y);
    }
    //射擊
    public void shotEnemyTank(){
        switch (getDirect()){
            case 0://上
                shot=new Shot(getX()+20,getY(),0);
                break;
            case 1://右邊
                shot=new Shot(getX()+50,getY()+30,1);
                break;
            case 2:
                shot=new Shot(getX()+20,getY()+60,2);
                break;
            case 3:
                shot=new Shot(getX()-10,getY()+30,3);
                break;
        }
        new Thread(shot).start();
    }
}

EnemyTank

package tankgame03;

public class Hero extends Tank {
    Shot shot=null;//射擊行為
    public Hero(int x, int y) {
        super(x, y);
    }
    //射擊
    public void shotEnemyTank(){
        switch (getDirect()){
            case 0://上
                shot=new Shot(getX()+20,getY(),0);
                break;
            case 1://右邊
                shot=new Shot(getX()+50,getY()+30,1);
                break;
            case 2:
                shot=new Shot(getX()+20,getY()+60,2);
                break;
            case 3:
                shot=new Shot(getX()-10,getY()+30,3);
                break;
        }
        new Thread(shot).start();
    }
}

Shot

package tankgame03;

public class Shot implements Runnable {
    private int x;
    private int y;
    private int direct;//方向 0上 1右 2下 3左
    private int speed = 10;//子彈速度
    boolean isAlive = true;

    public Shot(int x, int y, int direct) {
        this.x = x;
        this.y = y;
        this.direct = direct;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    @Override
    public void run() {
        while (true) {
            //休眠
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //根據方向移動
            switch (direct) {
                case 0:
                    y -= speed;
                    break;
                case 1:
                    x += speed;
                    break;
                case 2:
                    y += speed;
                    break;
                case 3:
                    x -= speed;
                    break;
            }
            System.out.println("子彈坐標(" + x + "," + y + ")");
            if (x < 0 || x >= 1000 || y < 0 || y >= 750) {
                System.out.println("子彈線程退出");
                isAlive = false;
                break;
            }
        }
    }
}

MyPanel

package tankgame03;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Vector;

////為了監聽鍵盤事件，實現KeyListener
//為了讓Panel不停的重繪子彈，需要將MyPanel實現Runnable ，當做一個線程使用
public class MyPanel extends JPanel implements KeyListener,Runnable {
    Hero hero = null;//定義我的坦克
    Vector<EnemyTank> enemyTanks = new Vector<>();//定義敵人坦克
    int enemyTankSize = 3;

    public MyPanel() {
        hero = new Hero(100, 100);//初始化自己的坦克位置
        for (int i = 0; i < enemyTankSize; i++) {//初始化敵人的坦克位置
            enemyTanks.add(new EnemyTank(100 * (i + 1), 0));
        }

//        hero.setSpeed(5);
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);
        g.fillRect(0, 0, 1000, 750);//黑色背景

        //畫出坦克
        drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 0);

        //畫出敵人坦克
        for (int i = 0; i < enemyTanks.s; i++) {
            //取出坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            enemyTank.setDirect(2);
            drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 1);
        }

        //畫出hero發出的子彈
        if(hero.shot!=null&&hero.shot.isAlive==true){
            g.fill3DRect(hero.shot.getX()-1,hero.shot.getY()-1,3,3,false);
        }
    }

    /**
     * @param x      坦克左上角x坐標
     * @param y      坦克左上角y坐標
     * @param g      畫筆
     * @param direct 坦克方向（上下左右）
     * @param type   坦克類型
     */
    public void drawTank(int x, int y, Graphics g, int direct, int type) {

        switch (type) {
            case 0://我們的坦克
                g.setColor(Color.cyan);
                break;
            case 1://敵人的坦克
                g.setColor(Color.yellow);
                break;
        }
        //根據坦克方向，繪製坦克
        switch (direct) {
            case 0://向上
                g.fill3DRect(x, y, 10, 60, false);//畫出坦克左邊輪子
                g.fill3DRect(x + 30, y, 10, 60, false);//畫出坦克右邊輪子
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x + 20, y);//畫出炮筒
                break;
            case 1://右
                g.fill3DRect(x - 10, y + 10, 60, 10, false);//畫出坦克左邊輪子
                g.fill3DRect(x - 10, y + 40, 60, 10, false);//畫出坦克右邊輪子
                g.fill3DRect(x, y + 20, 40, 20, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x + 50, y + 30);//畫出炮筒
                break;
            case 2://下
                g.fill3DRect(x, y, 10, 60, false);//畫出坦克左邊輪子
                g.fill3DRect(x + 30, y, 10, 60, false);//畫出坦克右邊輪子
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x + 20, y + 60);//畫出炮筒
                break;
            case 3://左
                g.fill3DRect(x - 10, y + 10, 60, 10, false);//畫出坦克左邊輪子
                g.fill3DRect(x - 10, y + 40, 60, 10, false);//畫出坦克右邊輪子
                g.fill3DRect(x, y + 20, 40, 20, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x -10, y + 30);//畫出炮筒
                break;
        }

    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    //處理WDSA鍵按下情況
    @Override
    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_W) {
            //改變坦克方向
            hero.setDirect(0);
            //修改坦克坐標
            hero.moveUp();
        } else if (e.getKeyCode() == KeyEvent.VK_D) {
            hero.setDirect(1);
            hero.moveRight();
        } else if (e.getKeyCode() == KeyEvent.VK_S) {
            hero.setDirect(2);
            hero.moveDown();
        } else if (e.getKeyCode() == KeyEvent.VK_A) {
            hero.setDirect(3);
            hero.moveLeft();
        }

        if(e.getKeyCode()==KeyEvent.VK_J){
            hero.shotEnemyTank();
        }
//        this.repaint();
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.repaint();
        }
    }
}

HspTankGame03

package tankgame03;

import javax.swing.*;

public class HspTankGame03 extends JFrame {
    MyPanel mp=null;
    public static void main(String[] args) {
        new HspTankGame03();
    }

    public HspTankGame03() {
        mp=new MyPanel();
        new Thread(mp).start();
        this.add(mp);
        this.setSize(1000,750);
        this.addKeyListener(mp);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
    }
}

坦克大戰0.4版

增加功能[HspTankGame04.java]

  1. 讓敵人的坦克也能夠發射子彈(可以有多顆子彈)
  2. 當我方坦克擊中敵人坦克時，敵人的坦克就消失,如果能做出爆炸效果更好.
  3. 讓敵人的坦克也可以自由隨機的上下左右移動
  4. 控制我方的坦克和敵人的坦克在規定的範圍移動

√特別說明:

  1. 只要能實現就行，方法的好壞後面再說。
  2. 完成上面的任務，不會有沒有講過的知識點，這裡主要是鍛煉靈活運用技術點能力。
  3. 一定要自己先動腦筋想想，試著做做。再聽老師的評講才有意義，時間自己掌控(再次提醒,一定要先自己思考，再看代碼收穫會很大)

思路

讓敵人的坦克也能夠發射子彈(可以有多顆子彈)

  1. 在敵人坦克類，使用Vector保存多個Shot
  2. 當每創建一個敵人坦克對象，給該敵人坦克對象初始化一個shot對象，同時啟動Shot
  3. 在繪製敵人坦克時,需要遍歷敵人坦克對象Vector,繪製所有的子彈,當子彈isLive == false時，就從Vector移除

讓敵人的坦克也可以自由隨機的上下左右移動思路分析

  1. 因為要求敵人的坦克,可以自由移動，因此需要將敵人坦克當做線程使用
  2. 我們需要Enemy Tank implements Runnable
  3. 在run方法寫上我們相應的業務代碼.
  4. 在創建敵人坦克對象時，啟動線程

以下為程式代碼（爆炸效果圖片需要加到編譯文件的根目錄中）
(1).png
(1).png
(2).png
(2).png
(3).png
(3).png

Tank

package tankgame04;

public class Tank {
    //坦克左上角坐標
    private int x;
    private int y;
    private int direct;//坦克方向 0上 1右 2下 3左

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    private int speed=5;//坦克速度

    //上右下左移動方法
    public void moveUp(){
        if(y-speed>0){
            y-=speed;
        }
    }
    public void moveDown(){
        if (y+60+speed<750){
            y += speed;
        }
    }
    public void moveLeft(){
        if (x-10-speed>0){
            x -= speed;
        }
    }
    public void moveRight(){
        if(x-10+60+speed<1000){
            x+=speed;
        }
    }

    public int getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        this.direct = direct;
    }

    public Tank(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

Hero

package tankgame04;
//玩家坦克
public class Hero extends Tank {
    Shot shot=null;//射擊行為
    public Hero(int x, int y) {
        super(x, y);
    }
    //射擊
    public void shotEnemyTank(){
        switch (getDirect()){
            case 0://上
                shot=new Shot(getX()+20,getY(),0);
                break;
            case 1://右邊
                shot=new Shot(getX()+50,getY()+30,1);
                break;
            case 2:
                shot=new Shot(getX()+20,getY()+60,2);
                break;
            case 3:
                shot=new Shot(getX()-10,getY()+30,3);
                break;
        }
        new Thread(shot).start();
    }
}

EnemyTank

package tankgame04;

import java.util.Vector;
//敵方坦克
public class EnemyTank extends Tank implements Runnable {
    //在敵人坦克類，使用Vector保存多個Shot
    Vector<Shot> shots = new Vector<>();
    boolean isLive = true;

    public EnemyTank(int x, int y) {
        super(x, y);
    }

    @Override
    public void run() {
        while (true) {
            //根據坦克方向繼續移動
            for (int i=0;i<30;i++){
                switch (getDirect()) {
                    case 0://向上
                        //讓坦克保持一個方向，走30步
                        moveUp();
                        break;
                    case 1://向右
                        moveRight();
                        break;
                    case 2://向下
                        moveDown();
                        break;
                    case 3://向左
                        moveLeft();
                        break;
                }
                //休眠50毫秒
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //然後隨機的改變坦克方向 0-3
            setDirect((int) (Math.random() * 4));
            if(!isLive){
                break;
            }
        }
    }
}

Shot

package tankgame04;
//射擊事件
public class Shot implements Runnable {
    private int x;
    private int y;
    private int direct;//方向 0上 1右 2下 3左
    private int speed = 10;//子彈速度
    boolean isAlive = true;

    public Shot(int x, int y, int direct) {
        this.x = x;
        this.y = y;
        this.direct = direct;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    @Override
    public void run() {
        while (true) {
            //休眠
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //根據方向移動
            switch (direct) {
                case 0:
                    y -= speed;
                    break;
                case 1:
                    x += speed;
                    break;
                case 2:
                    y += speed;
                    break;
                case 3:
                    x -= speed;
                    break;
            }
//            System.out.println("子彈坐標(" + x + "," + y + ")");
            //當子彈移動到面板的邊界時，就應該銷毀（把啟動的子彈的線程銷毀)
            // 當子彈碰到敵人坦克時，也應該結束線程
            if (x < 0 || x >= 1000 || y < 0 || y >= 750 || isAlive == false) {
//                System.out.println("子彈線程退出");
                isAlive = false;
                break;
            }
        }
    }
}

Bomb

package tankgame04;
//爆炸事件

public class Bomb {
    int x, y;//炸彈的坐標
    int life = 9;//炸彈的生命周期
    boolean isLive = true;//是否還存活

    public Bomb(int x, int y) {
        this.x = x;
        this.y = y;
    }

    //減少爆炸效果的生命值
    public void lifeDown() {//配合出現圖片的爆炸效果
        if (life > 0) {
            life--;
        } else {
            isLive = false;
        }
    }
}

MyPanel

package tankgame04;
//面板
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Vector;

////為了監聽鍵盤事件，實現KeyListener
//為了讓Panel不停的重繪子彈，需要將MyPanel實現Runnable ，當做一個線程使用
public class MyPanel extends JPanel implements KeyListener, Runnable {
    Hero hero = null;//定義我的坦克
    Vector<EnemyTank> enemyTanks = new Vector<>();//定義敵人坦克
    //定義一個Vector ,用於存放多個爆炸效果
    //說明，當子彈擊中坦克時,加入一個Bomb對象到bombs
    Vector<Bomb> bombs = new Vector<>();
    int enemyTankSize = 3;

    //定義三張炸彈圖片，用於顯示爆炸效果
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    public MyPanel() {
        hero = new Hero(100, 100);//初始化自己的坦克位置
        for (int i = 0; i < enemyTankSize; i++) {//初始化敵人的坦克位置
            EnemyTank enemyTank = new EnemyTank(100 * (i + 1), 0);
            enemyTank.setDirect(2);//設置坦克方向
            //啟動敵人坦克線程，讓他們動起來
            new Thread(enemyTank).start();
            Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, 2);//創建敵人子彈
            enemyTank.shots.add(shot);//加入enemyTanks的Vector集合
            //啟動shot對象
            new Thread(shot).start();//敵方子彈移動

            enemyTanks.add(enemyTank);//加入敵方坦克集合
        }
//        hero.setSpeed(5);
        image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/(1).png"));
        image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/(2).png"));
        image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/(3).png"));

        //圖片在被第一次使用時才真正載入
        // 所以會出現第一次爆炸的圖程式找不到還沒載入好圖片導致這次爆炸效果缺失的情況。
        //因此要提前自定義爆炸一次
//        bombs.add(new Bomb(-100,-100));
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);

        g.fillRect(0, 0, 1000, 750);//黑色背景
        //畫出hero坦克
        drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 0);

        //畫出hero發出的子彈
        if (hero.shot != null && hero.shot.isAlive == true) {
            g.fill3DRect(hero.shot.getX() - 1, hero.shot.getY() - 1, 3, 3, false);
        }

        for (int i = 0; i < bombs.size(); i++) {
            //取出炸彈
            Bomb bomb = bombs.get(i);
            //根據當前這個bomb對象的life值去畫出對應的圖片
            if (bomb.life > 6) {
                g.drawImage(image1, bomb.x, bomb.y, 60, 60, this);
            } else if (bomb.life > 3) {
                g.drawImage(image2, bomb.x, bomb.y, 60, 60, this);
            } else {
                g.drawImage(image3, bomb.x, bomb.y, 60, 60, this);
            }
            //讓這個炸彈的生命值減少
            bomb.lifeDown();
            //如果bomb life為0，就從bombs 的集合中刪除
            if (bomb.life <= 0) {
                bombs.remove(bomb);
            }
        }

        //畫出敵人坦克
        for (int i = 0; i < enemyTanks.size(); i++) {
            //取出坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            if (enemyTank.isLive) {//判斷敵方坦克是否存活
                drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 1);
                //畫出 enemyTank所有子彈
                for (int j = 0; j < enemyTank.shots.size(); j++) {
                    //取出子彈
                    Shot shot = enemyTank.shots.get(j);//繪製
                    if (shot.isAlive) { //isAlive = true
                        g.draw3DRect(shot.getX() - 1, shot.getY() - 1, 3, 3, false);
                    } else {
                        //從Vector移除
                        enemyTank.shots.remove(shot);
                    }
                }
            }
        }

    }

    /**
     * @param x      坦克左上角x坐標
     * @param y      坦克左上角y坐標
     * @param g      畫筆
     * @param direct 坦克方向（上下左右）
     * @param type   坦克類型
     */
    public void drawTank(int x, int y, Graphics g, int direct, int type) {

        switch (type) {
            case 0://我們的坦克
                g.setColor(Color.cyan);
                break;
            case 1://敵人的坦克
                g.setColor(Color.yellow);
                break;
        }
        //根據坦克方向，繪製坦克
        switch (direct) {
            case 0://向上
                g.fill3DRect(x, y, 10, 60, false);//畫出坦克左邊輪子
                g.fill3DRect(x + 30, y, 10, 60, false);//畫出坦克右邊輪子
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x + 20, y);//畫出炮筒
                break;
            case 1://右
                g.fill3DRect(x - 10, y + 10, 60, 10, false);//畫出坦克左邊輪子
                g.fill3DRect(x - 10, y + 40, 60, 10, false);//畫出坦克右邊輪子
                g.fill3DRect(x, y + 20, 40, 20, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x + 50, y + 30);//畫出炮筒
                break;
            case 2://下
                g.fill3DRect(x, y, 10, 60, false);//畫出坦克左邊輪子
                g.fill3DRect(x + 30, y, 10, 60, false);//畫出坦克右邊輪子
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x + 20, y + 60);//畫出炮筒
                break;
            case 3://左
                g.fill3DRect(x - 10, y + 10, 60, 10, false);//畫出坦克左邊輪子
                g.fill3DRect(x - 10, y + 40, 60, 10, false);//畫出坦克右邊輪子
                g.fill3DRect(x, y + 20, 40, 20, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x - 10, y + 30);//畫出炮筒
                break;
        }

    }

    //編寫方法,判斷我方的子彈是否擊中敵人坦克
    public void hitTank(Shot s, EnemyTank enemyTank) {
        switch (enemyTank.getDirect()) {
            case 0://上
            case 2://下
                if (s.getX() > enemyTank.getX() && s.getX() < enemyTank.getX() + 40 &&
                        s.getY() > enemyTank.getY() && s.getY() < enemyTank.getY() + 60) {
                    s.isAlive = false;//設置子彈為死亡狀態
                    enemyTank.isLive = false;//設置該坦克為死亡狀態
                    //創建Bomb對象,加入到bombs集合
                    Bomb bomb = new Bomb(enemyTank.getX()-10, enemyTank.getY());
                    bombs.add(bomb);
                    //當我的子彈擊中敵人坦克後,將enemyTank 從lector拿掉
                    enemyTanks.remove(enemyTank);//移除該坦克
                }
                break;
            case 1:
            case 3:
                if (s.getX() > enemyTank.getX() - 10 && s.getX() < enemyTank.getX() + 50 &&
                        s.getY() > enemyTank.getY() + 10 && s.getY() < enemyTank.getY() + 50) {
                    s.isAlive = false;
                    enemyTank.isLive = false;
                }
                break;
        }
    }

    @Override
    public void keyTyped(KeyEvent e) {
    }

    //處理WDSA鍵按下情況
    @Override
    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_W) {
            //改變坦克方向
            hero.setDirect(0);
            //修改坦克坐標
            hero.moveUp();
        } else if (e.getKeyCode() == KeyEvent.VK_D) {
            hero.setDirect(1);
            hero.moveRight();
        } else if (e.getKeyCode() == KeyEvent.VK_S) {
            hero.setDirect(2);
            hero.moveDown();
        } else if (e.getKeyCode() == KeyEvent.VK_A) {
            hero.setDirect(3);
            hero.moveLeft();
        }

        if (e.getKeyCode() == KeyEvent.VK_J) {
            hero.shotEnemyTank();
        }
//        this.repaint();
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);//每停0.1s執行一次
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            this.repaint();//刷新面板
            if (hero.shot != null && hero.shot.isAlive) {
                //遍歷敵人所有坦克，實時判斷坦克是否被擊中
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    hitTank(hero.shot, enemyTank);
                }
            }
        }
    }
}

HspTankGame04

package tankgame04;
//窗體
import javax.swing.*;

public class HspTankGame04 extends JFrame {
    MyPanel mp=null;
    public static void main(String[] args) {
        new HspTankGame04();
    }

    public HspTankGame04() {
        mp=new MyPanel();
        new Thread(mp).start();//另外開一線程一直刷新面板內容和麵板中一些需要同時執行的程式
        this.add(mp);
        this.setSize(1000,750);
        this.addKeyListener(mp);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
    }
}

坦克大戰0.5版

√增加功能 [HspTankGame05.java]

  1. 我方坦克在發射的子彈消亡後，才能發射新的子彈.=>擴展(發多顆子彈怎麼辦，改成面板最多只能存在五個自己的子彈)
  2. 讓敵人坦克發射的子彈消亡後，可以再發射子彈
  3. 當敵人的坦克擊中我方坦克時，我方坦克消失，並出現爆炸效果.

我方坦克在發射的子彈消亡後，才能發射新的子彈.=>擴展(發多顆子彈怎麼辦)
思路

  1. 在按下J鍵，我們判斷當前hero對象的子彈，是否已經銷毀
  2. 如果沒有銷毀，就不去觸發shotEnemyTank
  3. 如果已經銷毀，才去觸發shotEnemyTank
  4. 如果要發射多顆子彈，就使用Vector保存

Tank

package tankgame05;
//坦克
public class Tank {
    //坦克左上角坐標
    private int x;
    private int y;
    private int direct;//坦克方向 0上 1右 2下 3左
    boolean isLive = true;//是否存活

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    private int speed=2;//坦克速度

    //上右下左移動方法
    public void moveUp(){
        if(y-speed>0){
            y-=speed;
        }
    }
    public void moveDown(){
        if (y+60+speed<750){
            y += speed;
        }
    }
    public void moveLeft(){
        if (x-10-speed>0){
            x -= speed;
        }
    }
    public void moveRight(){
        if(x-10+60+speed<1000){
            x+=speed;
        }
    }

    public int getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        this.direct = direct;
    }

    public Tank(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

Hero

package tankgame05;

import java.util.Vector;

//玩家坦克
public class Hero extends Tank {
    Shot shot = null;//射擊行為
    //發射多個子彈
    Vector<Shot> shots = new Vector<>();

    public Hero(int x, int y) {
        super(x, y);
    }

    //射擊
    public void shotEnemyTank() {

        //發多顆子彈怎麼辦，控制在我們的面板上，最多只有5顆
        if (shots.size()==5){
            return;
        }
        switch (getDirect()) {
            case 0://上
                shot = new Shot(getX() + 20, getY(), 0);
                break;
            case 1://右邊
                shot = new Shot(getX() + 50, getY() + 30, 1);
                break;
            case 2:
                shot = new Shot(getX() + 20, getY() + 60, 2);
                break;
            case 3:
                shot = new Shot(getX() - 10, getY() + 30, 3);
                break;
        }
        //把新創建的shot放入到shots
        shots.add(shot);
        //啟動我們的Shot線程
        new Thread(shot).start();
    }
}

EnemyTank

package tankgame05;

import java.util.Vector;

//敵方坦克
public class EnemyTank extends Tank implements Runnable {
    //在敵人坦克類，使用Vector保存多個Shot
    Vector<Shot> shots = new Vector<>();


    public EnemyTank(int x, int y) {
        super(x, y);
    }

    @Override
    public void run() {
        while (true) {

            //這裡我們判斷如果shots size() =0，創建一顆子彈，放入到
            //shots集合，並啟動
            if (isLive && shots.size() <= 5) {//所以敵人同時只能存在五個子彈
                Shot s = null;
                switch (getDirect()) {
                    case 0://上
                        s = new Shot(getX() + 20, getY(), 0);
                        break;
                    case 1://右邊
                        s = new Shot(getX() + 50, getY() + 30, 1);
                        break;
                    case 2:
                        s = new Shot(getX() + 20, getY() + 60, 2);
                        break;
                    case 3:
                        s = new Shot(getX() - 10, getY() + 30, 3);
                        break;
                }
                shots.add(s);
                new Thread(s).start();
            }

            //根據坦克方向繼續移動
            for (int i = 0; i < 30; i++) {
                switch (getDirect()) {
                    case 0://向上
                        //讓坦克保持一個方向，走30步
                        moveUp();
                        break;
                    case 1://向右
                        moveRight();
                        break;
                    case 2://向下
                        moveDown();
                        break;
                    case 3://向左
                        moveLeft();
                        break;
                }
                //休眠50毫秒
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //然後隨機的改變坦克方向 0-3
            setDirect((int) (Math.random() * 4));
            if (!isLive) {
                break;
            }
        }
    }
}

Shot

package tankgame05;
//射擊事件
public class Shot implements Runnable {
    private int x;
    private int y;
    private int direct;//方向 0上 1右 2下 3左
    private int speed = 10;//子彈速度
    boolean isAlive = true;

    public Shot(int x, int y, int direct) {
        this.x = x;
        this.y = y;
        this.direct = direct;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    @Override
    public void run() {
        while (true) {
            //休眠
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //根據方向移動
            switch (direct) {
                case 0:
                    y -= speed;
                    break;
                case 1:
                    x += speed;
                    break;
                case 2:
                    y += speed;
                    break;
                case 3:
                    x -= speed;
                    break;
            }
//            System.out.println("子彈坐標(" + x + "," + y + ")");
            //當子彈移動到面板的邊界時，就應該銷毀（把啟動的子彈的線程銷毀)
            // 當子彈碰到敵人坦克時，也應該結束線程
            if (x < 0 || x >= 1000 || y < 0 || y >= 750 || isAlive == false) {
//                System.out.println("子彈線程退出");
                isAlive = false;
                break;
            }
        }
    }
}

Bomb

package tankgame05;
//爆炸事件

public class Bomb {
    int x, y;//炸彈的坐標
    int life = 9;//炸彈的生命周期
    boolean isLive = true;//是否還存活

    public Bomb(int x, int y) {
        this.x = x;
        this.y = y;
    }

    //減少爆炸效果的生命值
    public void lifeDown() {//配合出現圖片的爆炸效果
        if (life > 0) {
            life--;
        } else {
            isLive = false;
        }
    }
}

MyPanel

package tankgame05;
//面板

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Vector;

////為了監聽鍵盤事件，實現KeyListener
//為了讓Panel不停的重繪子彈，需要將MyPanel實現Runnable ，當做一個線程使用
public class MyPanel extends JPanel implements KeyListener, Runnable {
    Hero hero = null;//定義我的坦克
    Vector<EnemyTank> enemyTanks = new Vector<>();//定義敵人坦克
    //定義一個Vector ,用於存放多個爆炸效果
    //說明，當子彈擊中坦克時,加入一個Bomb對象到bombs
    Vector<Bomb> bombs = new Vector<>();
    int enemyTankSize = 3;

    //定義三張炸彈圖片，用於顯示爆炸效果
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    public MyPanel() {
        hero = new Hero(800, 100);//初始化自己的坦克位置
        for (int i = 0; i < enemyTankSize; i++) {//初始化敵人的坦克位置
            EnemyTank enemyTank = new EnemyTank(100 * (i + 1), 0);
            enemyTank.setDirect(2);//設置坦克方向
            //啟動敵人坦克線程，讓他們動起來
            new Thread(enemyTank).start();

//            Shot shot = new Shot(enemyTank.getX() + 20, enemyTank.getY() + 60, 2);//創建敵人子彈
//            enemyTank.shots.add(shot);//加入enemyTanks的Vector集合
//            //啟動shot對象
//            new Thread(shot).start();//敵方子彈移動

            enemyTanks.add(enemyTank);//加入敵方坦克集合
        }
//        hero.setSpeed(5);
        image1 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/(1).png"));
        image2 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/(2).png"));
        image3 = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/(3).png"));

        //圖片在被第一次使用時才真正載入
        // 所以會出現第一次爆炸的圖程式找不到還沒載入好圖片導致這次爆炸效果缺失的情況。
        //因此要提前自定義爆炸一次
//        bombs.add(new Bomb(-100,-100));
    }

    @Override
    public void paint(Graphics g) {
        super.paint(g);

        g.fillRect(0, 0, 1000, 750);//黑色背景
        if (hero!=null&&hero.isLive){//畫出hero坦克
            drawTank(hero.getX(), hero.getY(), g, hero.getDirect(), 0);
        }

        //畫出hero發出的子彈
//        if (hero.shot != null && hero.shot.isAlive == true) {
//            g.fill3DRect(hero.shot.getX() - 1, hero.shot.getY() - 1, 3, 3, false);
//        }
        //將hero的子彈集合shots ,遍歷取出繪製
        for (int i = 0; i < hero.shots.size(); i++) {
            Shot shot = hero.shots.get(i);
            if (shot != null && shot.isAlive) {
                g.fill3DRect(shot.getX() - 1, shot.getY() - 1, 3, 3, false);
            }else {//如果該shot對象已經無效,就從shots集合中拿掉
                hero.shots.remove(shot);
            }
        }

        for (int i = 0; i < bombs.size(); i++) {
            //取出炸彈
            Bomb bomb = bombs.get(i);
            //根據當前這個bomb對象的life值去畫出對應的圖片
            if (bomb.life > 6) {
                g.drawImage(image1, bomb.x, bomb.y, 60, 60, this);
            } else if (bomb.life > 3) {
                g.drawImage(image2, bomb.x, bomb.y, 60, 60, this);
            } else {
                g.drawImage(image3, bomb.x, bomb.y, 60, 60, this);
            }
            //讓這個炸彈的生命值減少
            bomb.lifeDown();
            //如果bomb life為0，就從bombs 的集合中刪除
            if (bomb.life <= 0) {
                bombs.remove(bomb);
            }
        }

        //畫出敵人坦克
        for (int i = 0; i < enemyTanks.size(); i++) {
            //取出坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            if (enemyTank.isLive) {//判斷敵方坦克是否存活
                drawTank(enemyTank.getX(), enemyTank.getY(), g, enemyTank.getDirect(), 1);
                //畫出 enemyTank所有子彈
                for (int j = 0; j < enemyTank.shots.size(); j++) {
                    //取出子彈
                    Shot shot = enemyTank.shots.get(j);//繪製
                    if (shot.isAlive) { //isAlive = true
                        g.draw3DRect(shot.getX() - 1, shot.getY() - 1, 3, 3, false);
                    } else {
                        //從Vector移除
                        enemyTank.shots.remove(shot);
                    }
                }
            }
        }

    }

    /**
     * @param x      坦克左上角x坐標
     * @param y      坦克左上角y坐標
     * @param g      畫筆
     * @param direct 坦克方向（上下左右）
     * @param type   坦克類型
     */
    public void drawTank(int x, int y, Graphics g, int direct, int type) {

        switch (type) {
            case 0://我們的坦克
                g.setColor(Color.cyan);
                break;
            case 1://敵人的坦克
                g.setColor(Color.yellow);
                break;
        }
        //根據坦克方向，繪製坦克
        switch (direct) {
            case 0://向上
                g.fill3DRect(x, y, 10, 60, false);//畫出坦克左邊輪子
                g.fill3DRect(x + 30, y, 10, 60, false);//畫出坦克右邊輪子
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x + 20, y);//畫出炮筒
                break;
            case 1://右
                g.fill3DRect(x - 10, y + 10, 60, 10, false);//畫出坦克左邊輪子
                g.fill3DRect(x - 10, y + 40, 60, 10, false);//畫出坦克右邊輪子
                g.fill3DRect(x, y + 20, 40, 20, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x + 50, y + 30);//畫出炮筒
                break;
            case 2://下
                g.fill3DRect(x, y, 10, 60, false);//畫出坦克左邊輪子
                g.fill3DRect(x + 30, y, 10, 60, false);//畫出坦克右邊輪子
                g.fill3DRect(x + 10, y + 10, 20, 40, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x + 20, y + 60);//畫出炮筒
                break;
            case 3://左
                g.fill3DRect(x - 10, y + 10, 60, 10, false);//畫出坦克左邊輪子
                g.fill3DRect(x - 10, y + 40, 60, 10, false);//畫出坦克右邊輪子
                g.fill3DRect(x, y + 20, 40, 20, false);//畫出坦克蓋子
                g.fillOval(x + 10, y + 20, 20, 20);//畫出圓形蓋子
                g.drawLine(x + 20, y + 30, x - 10, y + 30);//畫出炮筒
                break;
        }

    }

    //如果我們的坦克可以發射多個子彈
    //在判斷我方子彈是否擊中敵人坦克時，就需要把我們的子彈集合中
    //所有的子彈，都取出和敵人的所有坦克，進行判斷
    public void hitEnemyTank(){
        //遍歷我們的子彈
        for (int j = 0; j < hero.shots.size(); j++) {
            Shot shot = hero.shots.get(j);
            if (shot != null && shot.isAlive) {
                //遍歷敵人所有坦克，實時判斷坦克是否被擊中
                for (int i = 0; i < enemyTanks.size(); i++) {
                    EnemyTank enemyTank = enemyTanks.get(i);
                    hitTank(shot, enemyTank);
                }
            }
        }
    }

    //編寫方法,判斷我方的子彈是否擊中敵人坦克
    //什麼時候判斷我方的子彈是否擊中敵人坦克 ?run方法
    public void hitTank(Shot s, Tank enemyTank) {
        switch (enemyTank.getDirect()) {
            case 0://上
            case 2://下
                if (s.getX() > enemyTank.getX() && s.getX() < enemyTank.getX() + 40 &&
                        s.getY() > enemyTank.getY() && s.getY() < enemyTank.getY() + 60) {
                    s.isAlive = false;//設置子彈為死亡狀態
                    enemyTank.isLive = false;//設置該坦克為死亡狀態
                    //創建Bomb對象,加入到bombs集合
                    Bomb bomb = new Bomb(enemyTank.getX() - 10, enemyTank.getY());
                    bombs.add(bomb);
                    //當我的子彈擊中敵人坦克後,將enemyTank 從lector拿掉
                    enemyTanks.remove(enemyTank);//移除該坦克
                }
                break;
            case 1:
            case 3:
                if (s.getX() > enemyTank.getX() - 10 && s.getX() < enemyTank.getX() + 50 &&
                        s.getY() > enemyTank.getY() + 10 && s.getY() < enemyTank.getY() + 50) {
                    s.isAlive = false;
                    enemyTank.isLive = false;
                }
                break;
        }
    }
    //判斷敵方的子彈是否擊中我方坦克
    public void hitHeroTank(){
        //遍歷敵方子彈
        for (int i = 0; i < enemyTanks.size(); i++) {
            EnemyTank enemyTank = enemyTanks.get(i);
            for (int j = 0; j < enemyTank.shots.size(); j++) {
                Shot shot = enemyTank.shots.get(j);
                hitTank(shot,hero);
            }
        }
    }


    @Override
    public void keyTyped(KeyEvent e) {
    }

    //處理WDSA鍵按下情況
    @Override
    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_W) {
            //改變坦克方向
            hero.setDirect(0);
            //修改坦克坐標
            hero.moveUp();
        } else if (e.getKeyCode() == KeyEvent.VK_D) {
            hero.setDirect(1);
            hero.moveRight();
        } else if (e.getKeyCode() == KeyEvent.VK_S) {
            hero.setDirect(2);
            hero.moveDown();
        } else if (e.getKeyCode() == KeyEvent.VK_A) {
            hero.setDirect(3);
            hero.moveLeft();
        }

        if (e.getKeyCode() == KeyEvent.VK_J) {
            //判斷hero的子彈是否銷毀,發射一顆子彈
//            if (hero.shot == null || !hero.shot.isAlive) {
//                hero.shotEnemyTank();
//            }
            //發射多顆子彈
            hero.shotEnemyTank();
        }
//        this.repaint();
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(100);//每停0.1s執行一次
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            hitEnemyTank();//檢測子彈是否打中坦克
            hitHeroTank();
            this.repaint();//刷新面板

        }
    }
}

HspTankGame05

package tankgame05;
//窗體

import javax.swing.*;

public class HspTankGame05 extends JFrame {
    MyPanel mp=null;
    public static void main(String[] args) {
        new HspTankGame05();
    }

    public HspTankGame05() {
        mp=new MyPanel();
        new Thread(mp).start();//另外開一線程一直刷新面板內容和麵板中一些需要同時執行的程式
        this.add(mp);
        this.setSize(1016,789);
        this.addKeyListener(mp);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
    }
}

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 設計模式之（6）——建造者模式
    定義：建造者模式也稱為生成器模式，將一個個簡單對象一步步構造成一個複雜的對象，將複雜對象的構建和它的表示分離，使得同樣的構建過程有不同的表示； 主要解決：系統中複雜對象的創建過程，通常由各個部分的子對象採用一定的演算法構成；由於需求的變化 ，這個複雜對象的各個部分通常面臨著劇烈的變化，但是將他們組合在 ...
  • 詳解 Serverless 架構的 6 大應用場景
    Serverless 架構將成為未來雲計算領域重要的技術架構，將會被更多的業務所採納。進一步深究，Serverless 架構在什麼場景下有優秀的表現，在什麼場景下可能表現得並不是很理想呢？或者說，有哪些場景更適合 Serverless 架構呢？ ...
  • Java集合---ArrayList
    集合和數組的區別 共同點：都是存儲數據的容器 不同點：數組的容量是固定的，集合的容量是可變的 ArrayList的構造方法和添加方法 public ArrayList() 創建一個空的集合對象 構造一個初始容量為 10 的空列表。 public boolean add(E element) 將指定的 ...
  • Windows OpenGL ES 圖像伽馬線
    目錄 一.OpenGL ES 圖像伽馬線 1.原始圖片 2.效果演示 二.OpenGL ES 圖像伽馬線源碼下載 三.猜你喜歡 零基礎 OpenGL ES 學習路線推薦 : OpenGL ES 學習目錄 >> OpenGL ES 基礎 零基礎 OpenGL ES 學習路線推薦 : OpenGL ES ...
  • Python學習：import的正確用法
    import語句用來導入其他python文件（稱為模塊module），使用該模塊里定義的類、方法或者變數，從而達到代碼復用的目的。 將要建立文件的結構為： Tree |____ m1.py |____ m2.py |____ Branch |____m3.py |____m4.py 首先，先建立一個 ...
  • x64dbg 配置插件SDK開發環境
    x64dbg 是一款開源的應用層反彙編調試器，旨在對沒有源代碼的可執行文件進行惡意軟體分析和逆向工程，同時 x64dbg 還允許用戶開發插件來擴展功能，插件開發環境的配置非常簡單，如下將簡單介紹x64dbg是如何配置開發環境以及如何開發插件的。 ...
  • 彩虹女神躍長空,Go語言進階之Go語言高性能Web框架Iris項目實戰-完善用戶管理EP04
    書接上回，上一回我們完成了用戶管理頁面的構建，並且通過前端的Vue.js框架動態地獲取表單數據，同時非同步請求後端Iris介面進行入庫操作，過程中使用函數封裝可復用的邏輯。 本回我們將繼續完善用戶管理功能。 唯一索引 雖然在之前的章節中已經完成了用戶添加（註冊）的功能，然而我們忽略了一個重要的細節，那 ...
  • SpringMvc(一)-初識
    1、環境搭建 1.1 jar包 <spring.version>4.3.18.RELEASE</spring.version> <!-- spring-mvc begin --> <dependency> <groupId>org.springframework</groupId> <artifac ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類