当前位置：Gxlcms > PHP教程 > 坦克大战DEMO

坦克大战DEMO

时间：2021-07-01 10:21:17 帮助过：4人阅读

实现了基本功能....地方坦克寻路做得比较弱智，每个坦克最多能同时发射5发炮弹....敌方有三种兵种，菜单栏没做响应，这个很简单，需要的可以自己加......上传全部代码，仅供学习参考......
  1. package tank.common;
  3. abstract public class Bullet implements Runnable, Common {
  4. private int x, y;
  5. private int speed;
  6. private int direction;
  7. private boolean alive;
  8. protected int power;
  10. public Bullet(int x, int y, int speed, int direction) {
  11. this.x = x;
  12. this.y = y;
  13. this.speed = speed;
  14. this.direction = direction;
  15. alive = true;
  16. }
  18. public void die() {
  19. alive = false;
  20. }
  22. public int getPower() {
  23. return power;
  24. }
  26. public int getX() {
  27. return x;
  28. }
  30. public int getY() {
  31. return y;
  32. }
  34. public boolean isAlive() {
  35. return alive;
  36. }
  38. public void run() {
  39. while (true) {
  40. try {
  41. Thread.sleep(15);
  42. } catch (InterruptedException e) {
  43. // TODO Auto-generated catch block
  44. e.printStackTrace();
  45. }
  46. switch (direction) {
  47. case UP:
  48. y -= speed;
  49. break;
  50. case DOWN:
  51. y += speed;
  52. break;
  53. case RIGHT:
  54. x += speed;
  55. break;
  56. case LEFT:
  57. x -= speed;
  58. break;
  59. }
  60. if (x < 0 || x > WIDTH || y > HEIGHT || y < 0) {
  61. alive = false;
  62. return;
  63. }
  64. }
  65. }
  67. }
  1. package tank.common;
  3. public interface Common {
  4. public static final int UP = 0;
  5. public static final int DOWN = 1;
  6. public static final int RIGHT = 2;
  7. public static final int LEFT = 3;
  8. public static final int WIDTH = 600;
  9. public static final int HEIGHT = 400;
  10. public static final int WATER = 0;
  11. public static final int WALLS = 1;
  12. public static final int STEELS = 2;
  13. public static final int GRASS = 3;
  15. }
  1. package tank.common;
  3. import java.awt.Color;
  4. import java.awt.Point;
  6. public abstract class EnemyTank extends Tank {
  7. private class AutoFire implements Runnable {
  9. @Override
  10. public void run() {
  11. // TODO Auto-generated method stub
  12. while (isAlive()) {
  13. try {
  14. Thread.sleep(500);
  15. } catch (InterruptedException e) {
  16. // TODO Auto-generated catch block
  17. e.printStackTrace();
  18. }
  19. if (Math.random() > shotKey) {
  20. shot();
  21. }
  22. }
  23. }
  25. }
  27. private class AutoMove implements Runnable {
  29. @Override
  30. public void run() {
  31. // TODO Auto-generated method stub
  33. int moves[] = new int[4];
  34. while (isAlive()) {
  35. try {
  36. Thread.sleep(110);
  37. } catch (InterruptedException e) {
  38. // TODO Auto-generated catch block
  39. e.printStackTrace();
  40. }
  41. for (int i = 0; i < 4; ++i) {
  42. moves[i] = judgeHero(i);
  43. }
  44. int direction = 0;
  45. int max = Integer.MIN_VALUE;
  46. for (int i = 0; i < 4; ++i) {
  47. if (moves[i] >= max) {
  48. max = moves[i];
  49. direction = i;
  50. }
  51. }
  52. move(direction);
  53. }
  54. }
  56. }
  58. private double shotKey;
  60. private Point heroPosition;
  62. private Tank hero;
  64. public EnemyTank(int x, int y, Tank hero, int life, int ID) {
  65. super(x, y, Color.cyan);
  66. this.lifes = life;
  67. this.hero = hero;
  68. super.setImageID(ID);
  69. }
  71. private int judgeHero(int direction) {
  72. heroPosition = new Point(hero.getX() + 9, hero.getY() + 9);
  73. int result = 0;
  74. int x = this.getX();
  75. int y = this.getY();
  76. int speed = this.getSpeed();
  77. double distance1 = Math.abs((this.getX() - heroPosition.x)
  78. * (this.getX() - heroPosition.x)
  79. + (this.getY() - heroPosition.y)
  80. * (this.getY() - heroPosition.y));
  81. switch (direction) {
  82. case UP:
  83. y -= speed;
  84. break;
  85. case DOWN:
  86. y += speed;
  87. break;
  88. case RIGHT:
  89. x += speed;
  90. break;
  91. case LEFT:
  92. x -= speed;
  93. break;
  94. }
  95. if (getDirection() == direction) {
  96. result += 5000;
  97. }
  98. if (!canMove(x, y)) {
  99. result -= Integer.MAX_VALUE;
  100. }
  102. double distance2 = Math.abs((x - heroPosition.x) * (x - heroPosition.x)
  103. + (y - heroPosition.y) * (y - heroPosition.y));
  104. if (Math.random() > 0.8) {
  105. result += Math.random() * 20000;
  106. }
  107. result += (distance1 - distance2) * 10;
  108. return result;
  109. }
  111. public void setPosition(int x, int y) {
  112. super.x = x;
  113. super.y = y;
  114. }
  116. public void setShotSpeed(double shotSpeed) {
  117. this.shotKey = shotSpeed;
  118. }
  120. public void startFire() {
  121. new Thread(new AutoFire()).start();
  122. }
  124. public void startMove() {
  125. new Thread(new AutoMove()).start();
  126. }
  128. }
  1. package tank.common;
  3. import java.awt.Color;
  4. import java.util.ArrayList;
  6. import tank.entity.NormalBullet;
  8. public abstract class Tank implements Common {
  9. protected int x;
  11. protected int y;
  13. private Color color;
  15. private int speed;
  17. private int direction;
  19. private ArrayList bullets;
  21. private ArrayList tanks;
  23. private Bullet bullet;
  25. private int maxBulletNum;
  27. private boolean alive;
  29. protected int lifes;
  31. ArrayList walls;
  33. private int tankImageID;
  35. {
  36. speed = 2;
  37. direction = UP;
  38. alive = true;
  39. }
  41. public Tank() {
  42. this.x = 0;
  43. this.y = 0;
  44. color = Color.black;
  45. }
  47. public Tank(int x, int y, Color color) {
  48. this.x = x;
  49. this.y = y;
  50. this.color = color;
  51. maxBulletNum = 5;
  52. bullets = new ArrayList();
  53. walls = new ArrayList();
  54. }
  56. protected boolean canMove(int x, int y) {
  57. if (x < 0 || x > WIDTH - 20 || y < 0 || y > HEIGHT - 20) {
  58. return false;
  59. }
  61. if (tanks == null) {
  62. return true;
  63. }
  65. if (tanks.size() == 1) {
  66. return true;
  67. }
  69. for (int i = 0; i < walls.size(); ++i) {
  70. Wall tempWall = walls.get(i);
  71. if (tempWall.isAlive()) {
  72. if (x >= tempWall.getX() && y >= tempWall.getY()) {
  73. if (x <= tempWall.getX() + 20 && y <= tempWall.getY() + 20) {
  74. return tempWall.canBeWalk();
  75. }
  76. } else if (x >= tempWall.getX() && y <= tempWall.getY()) {
  77. if (x <= tempWall.getX() + 20
  78. && (y + 20) >= tempWall.getY()) {
  79. return tempWall.canBeWalk();
  80. }
  81. } else if (x <= tempWall.getX() && y >= tempWall.getY()) {
  82. if ((x + 20) >= tempWall.getX()
  83. && y <= tempWall.getY() + 20) {
  84. return tempWall.canBeWalk();
  85. }
  86. } else if (x <= tempWall.getX() && y <= tempWall.getY()) {
  87. if ((x + 20) >= tempWall.getX()
  88. && (y + 20) >= tempWall.getY()) {
  89. return tempWall.canBeWalk();
  90. }
  91. }
  92. }
  93. }
  95. for (int i = 0; i < tanks.size(); ++i) {
  96. Tank tempTank = tanks.get(i);
  97. if (tempTank == this)
  98. break;
  99. if (tempTank.isAlive()) {
  100. if (x >= tempTank.getX() && y >= tempTank.getY()) {
  101. if (x <= tempTank.getX() + 20 && y <= tempTank.getY() + 20) {
  102. return false;
  103. }
  104. } else if (x >= tempTank.getX() && y <= tempTank.getY()) {
  105. if (x <= tempTank.getX() + 20
  106. && (y + 20) >= tempTank.getY()) {
  107. return false;
  108. }
  109. } else if (x <= tempTank.getX() && y >= tempTank.getY()) {
  110. if ((x + 20) >= tempTank.getX()
  111. && y <= tempTank.getY() + 20) {
  112. return false;
  113. }
  114. } else if (x <= tempTank.getX() && y <= tempTank.getY()) {
  115. if ((x + 20) >= tempTank.getX()
  116. && (y + 20) >= tempTank.getY()) {
  117. return false;
  118. }
  119. }
  120. }
  121. }
  122. return true;
  123. }
  125. public void damage(int power) {
  126. lifes -= power;
  127. if (lifes <= 0) {
  128. alive = false;
  129. }
  130. }
  132. public ArrayList getBullet() {
  133. return bullets;
  134. }
  136. public Color getColor() {
  137. return color;
  138. }
  140. public int getDirection() {
  141. return direction;
  142. }
  144. public int getImageID() {
  145. return tankImageID;
  146. }
  148. public int getSpeed() {
  149. return speed;
  150. }
  152. public ArrayList getWalls() {
  153. return this.walls;
  154. }
  156. public int getX() {
  157. return x;
  158. }
  160. public int getY() {
  161. return y;
  162. }
  164. public boolean isAlive() {
  165. return alive;
  166. }
  168. public void move(int direction) {
  169. setDirection(direction);
  170. int x = this.x;
  171. int y = this.y;
  172. switch (direction) {
  173. case UP:
  174. y -= speed;
  175. break;
  176. case DOWN:
  177. y += speed;
  178. break;
  179. case RIGHT:
  180. x += speed;
  181. break;
  182. case LEFT:
  183. x -= speed;
  184. break;
  185. }
  186. if (canMove(x, y)) {
  187. this.x = x;
  188. this.y = y;
  189. }
  190. }
  192. public void setAllTanks(ArrayList tanks) {
  193. this.tanks = tanks;
  194. }
  196. public void setDirection(int direction) {
  197. this.direction = direction;
  198. }
  200. final protected void setImageID(int ID) {
  201. this.tankImageID = ID;
  202. }
  204. public void setSpeed(int speed) {
  205. this.speed = speed;
  206. }
  208. public void setWalls(ArrayList wallList) {
  209. this.walls = wallList;
  210. }
  212. public void shot() {
  213. switch (direction) {
  214. case UP:
  215. bullet = new NormalBullet(x + 10, y, UP);
  216. break;
  217. case DOWN:
  218. bullet = new NormalBullet(x + 10, y + 20, DOWN);
  219. break;
  220. case RIGHT:
  221. bullet = new NormalBullet(x + 20, y + 10, RIGHT);
  222. break;
  223. case LEFT:
  224. bullet = new NormalBullet(x, y + 10, LEFT);
  225. break;
  226. }
  227. for (int i = 0; i < bullets.size(); ++i) {
  228. Bullet temp = bullets.get(i);
  229. if (!temp.isAlive()) {
  230. bullets.remove(temp);
  231. }
  232. }
  233. if (bullets.size() >= maxBulletNum) {
  235. } else {
  236. new Thread(bullet).start();
  237. bullets.add(bullet);
  238. }
  240. }
  241. }
  1. package tank.common;
  3. public abstract class Wall {
  4. private int x, y;
  6. private int wallImageID;
  8. private boolean canWalk;
  10. private boolean canFly;
  12. private boolean alive;
  14. private boolean canHit;
  16. public Wall(int x, int y, int ID, boolean walk, boolean fly, boolean Hit) {
  17. this.x = x;
  18. this.y = y;
  19. this.wallImageID = ID;
  20. this.canWalk = walk;
  21. this.canFly = fly;
  22. this.alive = true;
  23. this.canHit = Hit;
  24. }
  26. public boolean canBeFly() {
  27. return canFly;
  28. }
  30. public boolean canBeHit() {
  31. return this.canHit;
  32. }
  34. public boolean canBeWalk() {
  35. return canWalk;
  36. }
  38. public void die() {
  39. alive = false;
  40. }
  42. public int getImageID() {
  43. return wallImageID;
  44. }
  46. public int getX() {
  47. return x;
  48. }
  50. public int getY() {
  51. return y;
  52. }
  54. public boolean isAlive() {
  55. return alive;
  56. }
  58. }
  1. package tank.entity;
  3. public class Bomb {
  4. private int x;
  5. private int y;
  7. private int life = 9;
  9. private boolean alive;
  11. public Bomb(int x, int y) {
  12. this.x = x;
  13. this.y = y;
  14. alive = true;
  15. }
  17. public void decrese() {
  18. if (life > 0) {
  19. life--;
  20. } else {
  21. alive = false;
  22. }
  23. }
  25. public int getLife() {
  26. return life;
  27. }
  29. public int getX() {
  30. return x;
  31. }
  33. public int getY() {
  34. return y;
  35. }
  37. public boolean isAlive() {
  38. return alive;
  39. }
  41. }
  1. package tank.entity;
  3. import tank.common.EnemyTank;
  4. import tank.common.Tank;
  6. public class EnemyTank1 extends EnemyTank {
  8. public EnemyTank1(int x, int y, Tank hero) {
  9. super(x, y, hero, 3, 1);
  10. setSpeed(2);
  11. setShotSpeed(0.8);
  12. }
  13. }
  1. package tank.entity;
  3. import tank.common.EnemyTank;
  4. import tank.common.Tank;
  6. public class EnemyTank2 extends EnemyTank {
  7. public EnemyTank2(int x, int y, Tank hero) {
  8. super(x, y, hero, 5, 2);
  9. setSpeed(3);
  10. setShotSpeed(0.5);
  11. }
  12. }
  1. package tank.entity;
  3. import tank.common.EnemyTank;
  4. import tank.common.Tank;
  6. public class EnemyTank3 extends EnemyTank {
  7. public EnemyTank3(int x, int y, Tank hero) {
  8. super(x, y, hero, 10, 3);
  9. setSpeed(5);
  10. setShotSpeed(0.2);
  11. }
  12. }
  1. package tank.entity;
  3. import tank.common.Wall;
  5. public class Grass extends Wall {
  6. public Grass(int x, int y) {
  7. super(x, y, 3, true, true, false);
  8. }
  9. }
  1. package tank.entity;
  3. import java.awt.Color;
  5. import tank.common.Tank;
  7. public class MyTank extends Tank {
  8. public MyTank(int x, int y) {
  9. super(x, y, Color.yellow);
  10. lifes = 5;
  11. super.setImageID(0);
  12. }
  14. public int getLife() {
  15. return lifes;
  16. }
  18. }
  1. package tank.entity;
  3. import tank.common.Bullet;
  5. public class NormalBullet extends Bullet {
  7. public NormalBullet(int x, int y, int direction) {
  8. super(x, y, 2, direction);
  9. power = 1;
  10. }
  12. }
  1. package tank.entity;
  3. import java.util.ArrayList;
  5. import tank.common.EnemyTank;
  7. public class Stage {
  8. private int totalEnemyNum;
  9. private int leaveEnemyNum;
  10. private int totalHeroLife;
  11. private int leaveHeroLife;
  12. private int level;
  13. private WallContainer wallContainer;
  14. private ArrayList enemeyTanks;
  15. private int activeEnemyTankNum;
  16. private EnemyTank activeEnemyTanks[];
  17. private MyTank hero;
  19. public Stage(int totalEnemyNum, int totalHeroLife, int level,
  20. int activeEnemyTankNum) {
  21. this.totalEnemyNum = totalEnemyNum;
  22. this.totalHeroLife = totalHeroLife;
  23. this.level = level;
  24. this.activeEnemyTankNum = activeEnemyTankNum;
  25. this.leaveEnemyNum = this.totalEnemyNum;
  26. this.leaveHeroLife = this.totalHeroLife;
  27. this.enemeyTanks = new ArrayList();
  28. this.activeEnemyTanks = new EnemyTank[this.activeEnemyTankNum];
  29. this.hero = new MyTank(290, 370);
  30. this.wallContainer = new WallContainer();
  31. }
  33. public void addEnemyTank(EnemyTank tank) {
  34. enemeyTanks.add(tank);
  35. }
  37. public void autoCreateEnemyTank() {
  38. for (int i = 0; i < totalEnemyNum; ++i) {
  39. double key = Math.random();
  40. if (key <= 0.33) {
  41. this.enemeyTanks.add(new EnemyTank1(0, 0, hero));
  42. } else if (key >= 0.66) {
  43. this.enemeyTanks.add(new EnemyTank2(0, 0, hero));
  44. } else {
  45. this.enemeyTanks.add(new EnemyTank3(0, 0, hero));
  46. }
  47. }
  48. }
  50. public int getActiveEnemyTankNum() {
  51. return this.activeEnemyTankNum;
  52. }
  54. public EnemyTank[] getEnemyTank() {
  55. return this.activeEnemyTanks;
  56. }
  58. public MyTank getHeroTank() {
  59. return this.hero;
  60. }
  62. public int getLeaveEnemyNum() {
  63. return this.leaveEnemyNum;
  64. }
  66. public int getLeaveHeroLife() {
  67. return this.leaveHeroLife;
  68. }
  70. public int getLevel() {
  71. return this.level;
  72. }
  74. public WallContainer getWallContainer() {
  75. return this.wallContainer;
  76. }
  78. public boolean isHeroDead() {
  79. if (this.leaveHeroLife <= 0) {
  80. return true;
  81. } else
  82. return false;
  83. }
  85. public EnemyTank popEnemyTank() {
  86. if (leaveEnemyNum > 0) {
  87. this.leaveEnemyNum--;
  88. EnemyTank temp = enemeyTanks.get(enemeyTanks.size() - 1);
  89. enemeyTanks.remove(temp);
  90. return temp;
  91. } else
  92. return null;
  93. }
  95. public MyTank popHero() {
  96. leaveHeroLife--;
  97. MyTank temp = new MyTank(290, 370);
  98. temp.setWalls(wallContainer.getWallList());
  99. return temp;
  100. }
  102. public void setHeroTank(MyTank tank) {
  103. this.hero = tank;
  104. }
  105. }
  1. package tank.entity;
  3. import tank.common.Wall;
  5. public class Steels extends Wall {
  6. public Steels(int x, int y) {
  7. super(x, y, 2, false, false, false);
  8. }
  9. }
  1. package tank.entity;
  3. import java.util.ArrayList;
  5. import tank.common.Common;
  6. import tank.common.Wall;
  8. public class WallContainer implements Common {
  9. private ArrayList data;
  11. public WallContainer() {
  12. data = new ArrayList();
  13. for (int i = 0; i < 28; ++i) {
  14. this.addWall(10 + i * 20, 100, WATER);
  15. if (i == 11) {
  16. i += 4;
  17. }
  18. }
  20. for (int i = 0; i < 28; ++i) {
  21. this.addWall(10 + i * 20, 160, WALLS);
  22. if (i == 12) {
  23. i += 4;
  24. }
  25. }
  27. for (int i = 0; i < 28; ++i) {
  28. this.addWall(10 + i * 20, 220, STEELS);
  29. if (i == 11) {
  30. i += 4;
  31. }
  32. }
  34. for (int i = 0; i < 28; ++i) {
  35. this.addWall(10 + i * 20, 280, GRASS);
  36. if (i == 12) {
  37. i += 4;
  38. }
  39. }
  40. }
  42. public void addWall(int x, int y, int kind) {
  43. switch (kind) {
  44. case WATER:
  45. data.add(new Water(x, y));
  46. break;
  47. case WALLS:
  48. data.add(new Walls(x, y));
  49. break;
  50. case STEELS:
  51. data.add(new Steels(x, y));
  52. break;
  53. case GRASS:
  54. data.add(new Grass(x, y));
  55. break;
  56. }
  57. }
  59. public ArrayList getWallList() {
  60. ArrayList temp = data;
  61. return temp;
  62. }
  64. public boolean isEmpty() {
  65. return data.isEmpty();
  66. }
  68. public void removeDead() {
  69. for (int i = 0; i < data.size(); ++i) {
  70. Wall temp = data.get(i);
  71. if (!temp.isAlive())
  72. data.remove(temp);
  73. }
  74. }
  75. }
  1. package tank.entity;
  3. import tank.common.Wall;
  5. public class Walls extends Wall {
  6. public Walls(int x, int y) {
  7. super(x, y, 1, false, false, true);
  8. }
  9. }
  1. package tank.entity;
  3. import tank.common.Wall;
  5. public class Water extends Wall {
  6. public Water(int x, int y) {
  7. super(x, y, 0, false, true, false);
  8. }
  9. }
  1. package tank.gui;
  3. import javax.swing.JFrame;
  4. import javax.swing.JMenu;
  5. import javax.swing.JMenuBar;
  6. import javax.swing.JMenuItem;
  8. public class TankFrame extends JFrame {
  10. /**
  11. *
  12. */
  13. private static final long serialVersionUID = 1L;
  14. private TankPanel gamePanel;
  16. public TankFrame() {
  17. super("坦克大战————玄雨制作");
  18. this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  19. // 添加游戏主面板
  20. gamePanel = new TankPanel();
  21. this.add(gamePanel);
  22. gamePanel.addMouseListener(gamePanel);
  23. this.addKeyListener(gamePanel);
  25. // 添加菜单栏
  26. JMenuBar menuBar = new JMenuBar();
  27. // ///////////////////////////////
  28. JMenu menu1 = new JMenu("菜单");
  29. menuBar.add(menu1);
  30. JMenuItem itemNewGame = new JMenuItem("新游戏");
  31. menu1.add(itemNewGame);
  32. menu1.addSeparator();
  33. JMenuItem itemList = new JMenuItem("排行榜");
  34. menu1.add(itemList);
  35. menu1.addSeparator();
  36. JMenuItem itemExit = new JMenuItem("退出");
  37. menu1.add(itemExit);
  38. // //////////////////////////////////
  39. JMenu menu2 = new JMenu("设置");
  40. JMenuItem itemSet = new JMenuItem("设置");
  41. menu2.add(itemSet);
  42. menuBar.add(menu2);
  43. // /////////////////////////////////
  44. JMenu menu3 = new JMenu("帮助");
  45. menuBar.add(menu3);
  46. JMenuItem itemInfo = new JMenuItem("关于");
  47. menu3.add(itemInfo);
  48. JMenuItem itemHelp = new JMenuItem("帮助");
  49. menu3.add(itemHelp);
  50. this.setJMenuBar(menuBar);
  52. this.setResizable(false);
  53. this.pack();
  54. this.setVisible(true);
  55. }
  57. }
  1. package tank.start;
  3. import tank.gui.TankFrame;
  5. public class TankStart {
  7. /**
  8. * @param args
  9. */
  10. public static void main(String[] args) {
  11. // TODO Auto-generated method stub
  12. new TankFrame().setLocation(250, 150);
  13. }
  15. }

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！