王者荣耀游戏

游戏运行如下：

sxt

Background

1. package sxt;

3. import java.awt.*;

4. //背景类

5. public class Background extends GameObject{

6. public Background(GameFrame gameFrame) {

7. super(gameFrame);

8. }

10. Image bg = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Map.jpg");

12. public void paintSelf(Graphics g){

13. g.drawImage(bg,0,0,null);

15. }

16. @Override

17. public Rectangle getRec() {

18. return null;

19. }

20. }

Bullet

1. package sxt;

3. import java.awt.*;

5. //子弹类

6. public class Bullet extends GameObject {

8. //发射子弹的游戏元素

9. GameObject attacker;

10. //目标

11. GameObject target;

12. //攻击力

13. int ad;

15. public Bullet(GameFrame gameFrame, GameObject attacker, GameObject target, int ad, int spd) {

16. super(attacker.getX(), attacker.getY(), gameFrame);

17. this.attacker = attacker;

18. this.target = target;

19. setAd(ad);

20. setSpd(spd);

21. }

23. public Bullet(GameFrame gameFrame, GameObject attacker, GameObject target, int ad, int spd, String img) {

24. super(attacker.getX(), attacker.getY(), gameFrame);

25. this.attacker = attacker;

26. this.target = target;

27. setImg(img);

28. setAd(ad);

29. setSpd(spd);

30. }

32. public Bullet() {

33. super();

34. }

36. public void move() {

37. //子弹与目标碰撞，子弹消失，目标减血

38. if (recIntersectsRec(getRec(), target.getRec())) {

39. target.setCurrentHp(target.getCurrentHp() - getAd());

40. gameFrame.removeList.add(this);

41. }

42. int dis = (int) getDis(getX(), getY(), target.getX(), target.getY());

43. if (dis != 0) {

44. int xSpeed = (getSpd() * (target.getX() - getX()) / dis);

45. int ySpeed = (getSpd() * (target.getY() - getY()) / dis);

46. setX(getX() + xSpeed);

47. setY(getY() + ySpeed);

48. }

49. }

51. @Override

52. public void paintSelf(Graphics g) {

53. g.drawImage(getImg(), getX()-16, getY()-16, null);

54. g.setColor(Color.BLACK);

55. g.fillOval(getX()-5, getY()-5, 10, 10);

56. g.drawRect(getX()-5, getY()-5, 10, 10);

57. move();

58. }

60. @Override

61. public Rectangle getRec() {

62. return new Rectangle(getX()-5, getY()-5, 10, 10);

63. }

64. public int getAd() {

65. return ad;

66. }

68. public void setAd(int ad) {

69. this.ad = ad;

70. }

71. }

Champion

1. package sxt;

3. import java.awt.*;

4. import java.awt.event.ActionEvent;

5. import java.awt.event.ActionListener;

6. import java.awt.event.KeyEvent;

8. import javax.swing.JButton;

10. //游戏英雄类

11. public abstract class Champion extends GameObject {

12. // 移动

13. public boolean up, down, left, right;

14. // 移动图集

15. static String[] imgs = new String[8];

16. // 第几张图片

17. int moveCount = 1;

18. //技能图片

19. Image abilityOne;

20. Image abilityTwo;

21. Image abilityThree;

22. //技能冷却时间

23. int coolDownTimeOne;

24. int coolDownTimeTwo;

25. int coolDownTimeThree;

26. //三个技能是否处于冷却状态

27. boolean coolDownOne = true;

28. boolean coolDownTwo = true;

29. boolean coolDownThree = true;

31. static {

32. for (int i = 1; i < 8; i++) {

33. imgs[i] = "C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\move\\" + i + ".png";

34. }

35. }

36. public Champion(GameFrame gameFrame) {

37. super(gameFrame);

39. //定义英雄的图片和坐标

40. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\stand.png");

41. setX(700);

42. setY(3800);

43. setSpd(75);

44. setHp(24000);

45. setDis(250);

46. setAttackCoolDownTime(100);

47. setCurrentHp(getHp());

48. }

50. public void keyPressed(KeyEvent e) {

51. int key = e.getKeyCode();

52. if (key == KeyEvent.VK_D) {

53. right = true;}

54. if (key == KeyEvent.VK_A) {

55. left = true;}

56. if (key == KeyEvent.VK_W) {

57. up = true;}

58. if (key == KeyEvent.VK_S) {

59. down = true;}

60. }

62. public void keyReleased(KeyEvent e) {

63. int key = e.getKeyCode();

64. if (key == KeyEvent.VK_D) {

65. right = false;}

66. if (key == KeyEvent.VK_A) {

67. left = false;}

68. if (key == KeyEvent.VK_W) {

69. up = false;}

70. if (key == KeyEvent.VK_S) {

71. down = false;}

72. }

73. public void move() {

74. if (up) {

75. setY(getY() - getSpd());

76. }

77. if (down) {

78. setY(getY() + getSpd());

79. }

80. if (left) {

81. setX(getX() - getSpd());

82. }

83. if (right) {

84. setX(getX() + getSpd());

85. }

86. if (up || down || left || right) {

87. setImg(imgs[moveCount]);

88. moveCount++;

89. if (moveCount == 8) {

90. moveCount = 1;

91. }

92. } else {

93. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\stand.png");

94. }

95. }

97. //添加三个技能按钮

99. public void addButton() {

100. JButton button1 = new JButton();

101. button1.setSize(100, 100);

102. button1.setLocation(1056, 513);

103. button1.addActionListener(new ActionListener() {

104. @Override

105. public void actionPerformed(ActionEvent e) {

106. abilityOne();

107. }

108. });

109. JButton button2 = new JButton();

110. button2.setSize(100, 100);

111. button2.setLocation(1090, 370);

112. button2.addActionListener(new ActionListener() {

113. @Override

114. public void actionPerformed(ActionEvent e) {

115. abilityTwo();

116. }

117. });

118. JButton button3 = new JButton();

119. button3.setSize(100, 100);

120. button3.setLocation(1220, 300);

121. button3.addActionListener(new ActionListener() {

122. @Override

123. public void actionPerformed(ActionEvent e) {

124. abilityThree();

125. }

126. });

127. gameFrame.add(button1);

128. gameFrame.add(button2);

129. gameFrame.add(button3);

130. }

132. public abstract void abilityOne();

133. public abstract void abilityTwo();

134. public abstract void abilityThree();

135. public abstract void abilityEffect(Graphics g);

137. @Override

138. public void paintSelf(Graphics g) {

139. // 生命值为0

140. if (getCurrentHp() <= 0) {

141. setAlive(false);

142. gameFrame.removeList.add(this);

144. } else {

145. // 添加生命值

146. addHp(g, 30, 80, 80, 20, Color.GREEN);

147. //绘制技能图片

148. g.drawImage(abilityOne, getX() + 360, getY() + 180, null);

149. g.drawImage(abilityTwo, getX() + 400, getY() + 40, null);

150. g.drawImage(abilityThree, getX() + 520, getY() - 30, null);

151. // 绘制图片

152. g.drawImage(this.getImg(), getX() - 33, getY() - 50, null);

153. // 改变画笔颜色

154. g.setColor(Color.GREEN);

155. // 绘制中心圆点

156. g.fillOval(getX(), getY(), 10, 10);

157. // 绘制矩形边框

158. g.drawRect(getX() - 23, getY() - 50, 60, 120);

159. move();

160. abilityEffect(g);

161. }

162. }

164. @Override

165. public Rectangle getRec() {

166. return new Rectangle(getX() - 30, getY() - 60, 60, 120);

167. }

169. }

ChampionDaji

1. package sxt;

3. import java.awt.Color;

4. import java.awt.Graphics;

5. import java.awt.Polygon;

6. import java.awt.Toolkit;

7. import java.awt.event.MouseAdapter;

8. import java.awt.event.MouseEvent;

9. import java.util.ArrayList;

10. import java.util.Random;

14. public class ChampionDaji extends Champion {

16. // 技能是否处于释放状态

17. boolean ifAbilityOne = false;

18. boolean ifAbilityTwo = false;

19. // 鼠标监视器

20. MouseMonitor m;

21. // 一技能多边形

22. Polygon p;

23. // 一技能三角函数

24. double sin;

25. double cos;

26. // 一技能已经攻击过的目标

27. ArrayList attacked;

28. // 一技能移动次数

29. int step = 0;

30. // 技能二目标

31. GameObject abilityTwoTarget;

32. // 技能二子弹

33. Bullet abilityTwoBullet;

34. // 三技能的五个子弹，释放三技能后重新定义

35. Bullet[] bulletList = { new Bullet(), new Bullet(), new Bullet(), new Bullet(), new Bullet() };

37. public ChampionDaji(GameFrame gameFrame) {

38. super(gameFrame);

39. abilityOne = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityOne.jpg");

40. abilityTwo = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityTwo.jpg");

41. abilityThree = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityThree.jpg");

42. // 三个技能冷却时间

43. coolDownTimeOne = 3000;

44. coolDownTimeTwo = 5000;

45. coolDownTimeThree = 8000;

46. }

48. public void exit() {

49. this.gameFrame.removeMouseListener(m);

50. }

52. public void abilityOneMove() {

53. p.translate((int) (50 * cos), -(int) (50 * sin));

54. for (GameObject redObj : gameFrame.redList) {

55. // 是红色方小兵 && 发生碰撞 && 没在attacked列表里

56. if (redObj instanceof MinionRed && p.intersects(redObj.getRec()) && attacked.indexOf(redObj) == -1) {

57. // 小兵扣血，添加到attacked里

58. redObj.setCurrentHp(redObj.getCurrentHp() - 400);

59. attacked.add(redObj);

60. }

61. }

62. }

64. @Override

65. public void abilityOne() {

66. if (coolDownOne) {

67. m = new MouseMonitor();

68. p = new Polygon();

69. gameFrame.addMouseListener(m);

70. attacked = new ArrayList();

71. }

72. }

75. public void abilityTwo() {

76. if (coolDownTwo) {

77. boolean find = false;

78. for (GameObject redObj : gameFrame.objList) {

79. // 是红色小兵 && 距离小于250 && 存活

80. if (redObj instanceof MinionRed && recIntersectsCir(redObj.getRec(), getX(), getY(), 250)

81. && redObj.isAlive()) {

82. // 添加子弹

83. abilityTwoBullet = new Bullet(gameFrame, this, redObj, 250, 60, "C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityTwoBullet.png");

84. gameFrame.objList.add(abilityTwoBullet);

85. // 给目标赋值

86. abilityTwoTarget = redObj;

87. // 释放二技能

88. ifAbilityTwo = true;

89. find = true;

90. break;

91. }

92. }

93. if (find) {

94. new AbilityTwoCD().start();

95. find = false;

96. }

97. }

98. }

100. /**

101. * 点击技能三释放技能 先将技能范围内目标储存到targetList里 提前定义五个子弹 技能释放时初始化五个子弹 子弹目标从targetList里随机选择

102. * 如果期间目标死亡，制作一个目标替身，生命值设置为true 子弹与目标或替身碰撞后消失

103. */

104. @Override

105. public void abilityThree() {

106. if (coolDownThree) {

107. // 创建列表来储存目标

108. ArrayList targetList = new ArrayList();

109. // 遍历redList，找到符合条件的目标，储存到列表里

110. for (int i = 0; i < gameFrame.objList.size(); i++) {

111. GameObject target = gameFrame.objList.get(i);

112. // 是红色小兵 && 在技能范围里 && 存活

113. if (target instanceof MinionRed && recIntersectsCir(target.getRec(), getX(), getY(), 250)

114. && target.isAlive()) {

115. targetList.add(target);

116. }

117. }

118. // 找到目标

119. if (targetList.size() != 0) {

120. // 创建五个子弹，随机攻击列表里的目标

121. Random random = new Random();

122. int count = 0; // 统计三技能发射子弹数量

123. while (count < 5) {

124. int r = random.nextInt(targetList.size());

125. if (!targetList.get(r).isAlive()) {

126. GameObject substitute = targetList.get(r);

127. substitute.setAlive(true);

128. bulletList[count] = new Bullet(gameFrame, this, substitute, 150, 60,

129. "C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityTwoBullet.png");

130. } else {

131. bulletList[count] = new Bullet(gameFrame, this, targetList.get(r), 150, 60,

132. "C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\Daji\\abilityTwoBullet.png");

133. }

134. count++;

135. }

136. new AbilityThreeBulletCD().start();

137. // 三技能进入冷却

138. new AbilityThreeCD().start();

139. }

140. }

141. }

143. @Override

144. public void abilityEffect(Graphics g) {

145. if (ifAbilityOne) {

146. g.setColor(Color.RED);

147. g.fillPolygon(p);

148. abilityOneMove();

149. step++;

150. if (step == 10) {

151. step = 0;

152. ifAbilityOne = false;

153. }

154. }

155. if (ifAbilityTwo) {

156. System.out.println(abilityTwoTarget.beControlled);

157. if (abilityTwoBullet.getRec().intersects(abilityTwoTarget.getRec())) {

158. new AbilityControllCD().start();

159. ifAbilityTwo = false;

160. }

161. }

162. }

164. // 技能一冷却时间

165. class AbilityOneCD extends Thread {

166. public void run() {

167. // 将技能一设置为冷却状态

168. coolDownOne = false;

169. // 线程休眠

170. try {

171. // one来表示一技能冷却时间

172. int one = coolDownTimeOne;

173. while (one > 0) {

174. Thread.sleep(1000);

175. System.out.println("一技能冷却时间： " + one / 1000);

176. one -= 1000;

177. }

178. } catch (Exception e) {

179. e.printStackTrace();

180. }

181. // 将技能一设置为攻击状态

182. coolDownOne = true;

183. // 线程终止

184. this.interrupt();

185. }

186. }

188. // 技能二冷却时间

189. class AbilityTwoCD extends Thread {

190. public void run() {

191. // 将技能二设置为冷却状态

192. coolDownTwo = false;

193. // 线程休眠

194. try {

195. // one来表示二技能冷却时间

196. int two = coolDownTimeTwo;

197. while (two > 0) {

198. Thread.sleep(1000);

199. System.out.println("二技能冷却时间： " + two / 1000);

200. two -= 1000;

201. }

202. } catch (Exception e) {

203. e.printStackTrace();

204. }

205. // 将技能二设置为攻击状态

206. coolDownTwo = true;

207. // 线程终止

208. this.interrupt();

209. }

210. }

212. // 技能二控制时间

213. class AbilityControllCD extends Thread {

214. public void run() {

215. abilityTwoTarget.beControlled = true;

216. // 线程休眠

217. try {

218. Thread.sleep(20000);

219. } catch (Exception e) {

220. e.printStackTrace();

221. }

222. abilityTwoTarget.beControlled = false;

223. this.interrupt();

224. }

226. }

227. //技能三冷却状态

228. class AbilityThreeCD extends Thread {

229. public void run() {

230. // 将攻击功能设置为冷却状态

231. coolDownThree = false;

232. // 休眠

233. try {

234. int three = coolDownTimeThree;

235. while (coolDownTimeThree > 0) {

236. Thread.sleep(1000);

237. System.out.println("技能三冷却时间： " + coolDownTimeThree / 1000);

238. coolDownTimeThree -= 1000;

239. }

240. coolDownTimeThree = three;

241. } catch (Exception e) {

242. e.printStackTrace();

243. }

244. // 将攻击功能解除冷却状态

245. coolDownThree = true;

246. // 线程终止

247. this.interrupt();

248. }

249. }

251. class AbilityThreeBulletCD extends Thread {

252. public void run() {

253. // 休眠

254. try {

255. System.out.println("Thread start");

256. gameFrame.objList.add(bulletList[0]);

257. Thread.sleep(100);

258. gameFrame.objList.add(bulletList[1]);

259. Thread.sleep(100);

260. gameFrame.objList.add(bulletList[2]);

261. Thread.sleep(100);

262. gameFrame.objList.add(bulletList[3]);

263. Thread.sleep(100);

264. gameFrame.objList.add(bulletList[4]);

265. } catch (Exception e) {

266. e.printStackTrace();

267. }

268. // 线程终止

269. this.interrupt();

270. }

271. }

273. // 鼠标监视器

274. private class MouseMonitor extends MouseAdapter {

275. @Override

276. public void mousePressed(MouseEvent e) {// 当鼠标点击时

277. int mouseX = e.getX(), mouseY = e.getY(), playerX = 700, playerY = 350;

278. double dis = getDis(mouseX, mouseY, playerX, playerY);

279. // 三角函数

280. cos = (mouseX - playerX) / dis;

281. sin = -(mouseY - playerY) / dis;

282. // 坐标差

283. int difX = (int) (60 * sin);

284. int difY = (int) (60 * cos);

285. p.addPoint(getX() - difX, getY() - difY);

286. p.addPoint(getX() + difX, getY() + difY);

287. p.addPoint(getX() + difX + (int) (20 * cos), getY() + difY - (int) (20 * sin));

288. p.addPoint(getX() - difX + (int) (20 * cos), getY() - difY - (int) (20 * sin));

289. exit();

290. new AbilityOneCD().start();

291. ifAbilityOne = true;

292. }

293. }

294. }

GameFrame

1. package sxt;

3. import beast.Beast;

5. import java.awt.*;

6. import java.awt.event.ActionEvent;

7. import java.awt.event.ActionListener;

8. import java.awt.event.KeyAdapter;

9. import java.awt.event.KeyEvent;

10. import java.io.File;

11. import java.util.ArrayList;

13. import javax.sound.sampled.AudioInputStream;

14. import javax.sound.sampled.AudioSystem;

15. import javax.sound.sampled.Clip;

16. import javax.sound.sampled.FloatControl;

17. import javax.swing.JButton;

18. import javax.swing.JFrame;

20. public class GameFrame extends JFrame {

21. // 游戏开始 0， 游戏胜利1，游戏失败2

22. int state = 0;

23. // 窗口尺寸

24. final int windowWidth = 1400;

25. final int windowHeight = 700;

26. // 双缓冲图片

27. private Image offScreenImage = null;

28. // 攻击图片

29. private Image attack = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\attack.jpg");

30. //游戏胜利失败图片

31. private Image gameWin = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\gameWin.png");

32. private Image gameLose = Toolkit.getDefaultToolkit().getImage("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\gameLose.png");

33. // 游戏背景

34. Background background = new Background(this);

35. // 游戏玩家

36. Champion player = new ChampionDaji(this);

37. // 双方小兵

38. MinionBlue mb = new MinionBlue(this);

39. MinionRed mr = new MinionRed(this);

40. //野怪

41. public Beast beast = new Beast(this);

42. // 防御塔

43. Turret turret = new Turret(this);

44. // 游戏元素列表

45. public ArrayList objList = new ArrayList<>();

46. ArrayList redList = new ArrayList<>();// 红色方

47. ArrayList blueList = new ArrayList<>();// 蓝色方

48. public ArrayList removeList = new ArrayList<>();// 存放将要删除的元素

50. public void launch() {

51. // 设置尺寸

52. setSize(windowWidth, windowHeight);

53. // 窗口居中

54. setLocationRelativeTo(null);

55. // 关闭事件

56. setDefaultCloseOperation(3);

57. // 用户不能调整窗口大小

58. setResizable(false);

59. // 标题

60. setTitle("王者荣耀");

61. // 窗口可见

62. setVisible(true);

63. // 添加键盘监视器

64. this.addKeyListener(new GameFrame.KeyMonitor());

65. // 添加游戏元素

66. objList.add(background);

67. objList.add(player);

68. objList.addAll(beast.beastList);

69. objList.addAll(turret.turretList);

70. playMusic();

71. for (int i = 0; i < 4; i++) {

72. blueList.add(turret.turretList.get(i));

73. }

74. for (int i = 4; i < 8; i++) {

75. redList.add(turret.turretList.get(i));

76. }

79. /**

80. * 攻击按钮

81. */

82. JButton button = new JButton();

83. button.setSize(130, 132);

84. button.setLocation(1150, 430);

85. button.addActionListener(new ActionListener() {

86. @Override

87. public void actionPerformed(ActionEvent e) {

88. // 按钮事件

89. player.attack(redList);

90. }

91. });

92. this.add(button);

93. player.addButton();

94. while (true) {

96. mb.createMinion(this, blueList);

97. mr.createMinion(this, redList);

98. repaint();

99. try {

100. Thread.sleep(25);

101. } catch (Exception e) {

102. e.printStackTrace();

103. }

104. }

105. }

107. public void paint(Graphics g) {

108. if (offScreenImage == null) {

109. offScreenImage = this.createImage(5984, 4452);

110. }

111. Graphics gImage = offScreenImage.getGraphics();

112. if(state==0){

113. turret.isLive();

114. for (int i = 0; i < objList.size(); i++) {

115. objList.get(i).paintSelf(gImage);

116. }

117. // 绘制攻击图片

118. gImage.drawImage(attack, player.getX() + 500, player.getY() + 100, null);

120. objList.removeAll(removeList);

121. } else if (state ==1) {//游戏胜利

123. gImage.drawImage(gameWin, player.getX()-700, player.getY()-300 , null);

124. } else if (state == 2) {//游戏失败

125. gImage.drawImage(gameLose, player.getX()-700, player.getY()-300, null);

126. }

127. g.drawImage(offScreenImage, -player.getX() + 700, -player.getY() + 350, null);

128. // 添加按钮后不能调用键盘事件 因为程序的焦点变成了按钮 this.requestFocus() 把焦点重新改变到游戏界面上

130. this.requestFocus();

131. }

133. // main方法

134. public static void main(String[] args) {

135. GameFrame gameFrame = new GameFrame();

136. gameFrame.launch();

138. }

139. // 键盘事件

140. private class KeyMonitor extends KeyAdapter {

141. @Override

142. public void keyPressed(KeyEvent e) {

143. int key = e.getKeyCode();

144. player.keyPressed(e);

145. }

147. @Override

148. public void keyReleased(KeyEvent e) {

149. int key = e.getKeyCode();

150. player.keyReleased(e);

151. }

152. }

153. static Clip clip;

154. public static void playMusic() {

155. try

156. {

157. //这里面放 绝对路径，音频必须是wav格式，用音频转换软件 把mp3 转成wav格式

158. File musicPath = new File("C:\\Users\\23839\\IdeaProjects\\PlaneWar\\PlayMusic\\bgm.wav");

160. if(musicPath.exists())

161. {

162. AudioInputStream audioInput = AudioSystem.getAudioInputStream(musicPath);

163. clip = AudioSystem.getClip();

164. clip.open(audioInput);

165. FloatControl gainControl = (FloatControl)clip.getControl(FloatControl.Type.MASTER_GAIN);

166. gainControl.setValue(-20.0f);//设置音量，范围为 -60.0f 到 6.0f

167. clip.start();

168. clip.loop(Clip.LOOP_CONTINUOUSLY);

169. }

170. else

171. {

172. }

173. }

174. catch(Exception ex)

175. {

176. ex.printStackTrace();

177. }

178. }

180. }

GameObject

1. package sxt;

3. import java.awt.*;

4. import java.util.ArrayList;

6. //游戏元素的父类

7. public abstract class GameObject {

8. // 坐标

9. private int x;

10. private int y;

11. // 图片

12. private Image img;

13. // 游戏界面

14. public GameFrame gameFrame;

15. // 速度

16. private int spd;

17. // 初始生命值

18. private int hp;

19. // 当前生命值

20. private int currentHp;

21. // 攻击目标

22. private GameObject target;

23. // 是否有目标

24. private boolean hasTarget = false;

25. // 攻击距离

26. private int dis;

27. // 攻击时间间隔

28. private int attackCoolDownTime;

29. // 攻击是否冷却

30. private boolean attackCoolDown = true;

31. // 是否存活

32. private boolean alive = true;

33. //是否被控制

34. boolean beControlled = false;

36. public GameObject(GameFrame gameFrame) {

37. this.gameFrame = gameFrame;

38. }

40. public GameObject(int x, int y, GameFrame gameFrame) {

41. this.x = x;

42. this.y = y;

43. this.gameFrame = gameFrame;

44. }

46. public GameObject() {

47. }

48. public void addHp(Graphics g, int difX, int difY, int width, int height, Color color) {

49. // 绘制外部轮廓

50. g.setColor(Color.black);

51. g.drawRect(getX() - difX, getY() - difY, width, height);

52. // 填充矩形

53. g.setColor(color);

54. g.fillRect(getX() - difX, getY() - difY, (int) (width * getCurrentHp() / getHp()), height);

55. }

57. public double getDis(int x1, int y1, int x2, int y2) {

58. return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));

59. }

61. // 矩形矩形碰撞检测

62. public boolean recIntersectsRec(Rectangle r1, Rectangle r2) {

63. return r1.intersects(r2);

64. }

66. public boolean recIntersectsCir(Rectangle rec, int x, int y, int r) {

67. // 矩形于圆相交： 圆心到至少一个矩形定点的距离小于r

68. if ((getDis(x, y, rec.x, rec.y) < r) || (getDis(x, y, rec.x, rec.y + rec.height) < r)

69. || (getDis(x, y, rec.x + rec.width, rec.y) < r)

70. || (getDis(x, y, rec.x + rec.width, rec.y + rec.height) < r)) {

71. return true;

72. }

73. return false;

74. }

76. // 攻击方法

77. public void attack(ArrayList gameObjList) {

78. if (hasTarget) {

79. // 目标离开范围后寻找新的目标

80. if (!recIntersectsCir(target.getRec(), getX(), getY(), getDis())) {

81. setHasTarget(false);

82. }

83. // 目标死亡，寻找新目标

84. else if (!target.isAlive()) {

85. setHasTarget(false);

86. } else if (isAttackCoolDown() && isAlive()) {

87. Bullet bullet = null;

88. // 防御塔攻击

89. if (Turret.class.isAssignableFrom(getClass())) {

90. bullet = new Bullet(gameFrame, this, getTarget(), 500, 50);

91. }

92. // 小兵攻击

93. else if (Minion.class.isAssignableFrom(getClass())) {

94. bullet = new Bullet(gameFrame, this, getTarget(), 50, 30);

95. }

96. // 玩家攻击

97. else if (this instanceof Champion) {

98. bullet = new Bullet(gameFrame, this, getTarget(), 500, 50);

99. }

100. gameFrame.objList.add(bullet);

101. // 线程开始

102. new AttackCD().start();

103. }

104. } else {

105. // 遍历列表

106. for (GameObject obj : gameObjList) {

107. // 判断攻击范围（圆形）与敌方（矩形）是否相交

108. if (recIntersectsCir(obj.getRec(), getX(), getY(), getDis())) {

109. // 找到目标

110. setTarget(obj);

111. setHasTarget(true);

112. // 跳出循环

113. break;

114. }

115. }

116. // 玩家是否在攻击范围内

117. if (!hasTarget && gameObjList == gameFrame.blueList) {

118. if (recIntersectsCir(gameFrame.player.getRec(), getX(), getY(), getDis())) {

119. // 找到目标

120. setTarget(gameFrame.player);

121. setHasTarget(true);

122. }

123. }

124. else {

125. //野怪是否在攻击范围内

126. for (GameObject obj : gameFrame.beast.beastList) {

127. // 判断攻击范围（圆形）与敌方（矩形）是否相交

128. if (recIntersectsCir(obj.getRec(), getX(), getY(), getDis())) {

129. // 找到目标

130. setTarget(obj);

131. setHasTarget(true);

132. // 跳出循环

133. break;

134. }

135. }

136. }

137. }

138. }

140. //public abstract void addTurret();

142. class AttackCD extends Thread {

143. public void run() {

144. // 将攻击功能设置为冷却状态

145. setAttackCoolDown(false);

146. // 线程休眠

147. try {

148. Thread.sleep(attackCoolDownTime);

149. } catch (Exception e) {

150. e.printStackTrace();

151. }

152. // 将攻击功能设置为攻击状态

153. setAttackCoolDown(true);

154. // 线程终止

155. this.interrupt();

156. }

157. }

159. // 绘制元素

160. public abstract void paintSelf(Graphics g);

162. // 返回矩形

163. public abstract Rectangle getRec();

164. public int getX() {

165. return x;

166. }

167. public void setX(int x) {

168. this.x = x;

169. }

170. public int getY() {

171. return y;

172. }

173. public void setY(int y) {

174. this.y = y;

175. }

176. public Image getImg() {

177. return img;

178. }

179. public void setImg(String img) {

180. this.img = Toolkit.getDefaultToolkit().getImage(img);

181. }

182. public int getSpd() {

183. return spd;

184. }

185. public void setSpd(int spd) {

186. this.spd = spd;

187. }

188. public int getHp() {

189. return hp;

190. }

191. public void setHp(int hp) {

192. this.hp = hp;

193. }

194. public int getCurrentHp() {

195. return currentHp;

196. }

197. public void setCurrentHp(int currentHp) {

198. this.currentHp = currentHp;

199. }

200. public GameObject getTarget() {

201. return target;

202. }

203. public void setTarget(GameObject target) {

204. this.target = target;

205. }

206. public boolean isHasTarget() {

207. return hasTarget;

208. }

209. public void setHasTarget(boolean hasTarget) {

210. this.hasTarget = hasTarget;

211. }

212. public int getDis() {

213. return dis;

214. }

215. public void setDis(int dis) {

216. this.dis = dis;

217. }

218. public int getAttackCoolDownTime() {

219. return attackCoolDownTime;

220. }

221. public void setAttackCoolDownTime(int attackCoolDownTime) {

222. this.attackCoolDownTime = attackCoolDownTime;

223. }

224. public boolean isAttackCoolDown() {

225. return attackCoolDown;

226. }

227. public void setAttackCoolDown(boolean attackCoolDown) {

228. this.attackCoolDown = attackCoolDown;

229. }

230. public boolean isAlive() {

231. return alive;

232. }

233. public void setAlive(boolean alive) {

234. this.alive = alive;

235. }

236. }

Minion

1. package sxt;

3. import java.awt.*;

4. import java.util.ArrayList;

6. public abstract class Minion extends GameObject{

8. // 是否生成下一个小兵

9. private boolean nextMinion = true;

10. // 是否生成下一波小兵

11. private boolean nextLine = true;

12. // 生成小兵数量

13. private int minionCount = 0;

14. // 是否检测到目标

15. private boolean ifFindTarget = false;

17. public Minion(GameFrame gameFrame) {

18. super(gameFrame);

19. setHp(800);

20. setCurrentHp(getHp());

21. setDis(100);

22. setAttackCoolDownTime(2000);

23. }

25. /**

26. * (1325, 3750) (4425, 3750) (5050, 3125) (5050, 1125)

27. */

29. public abstract void move(ArrayList objList);

31. public void findTarget(ArrayList objList) {

32. for (GameObject obj : objList) {

33. if (recIntersectsCir(obj.getRec(), getX(), getY(), 200)) {

34. setTarget(obj);

35. setIfFindTarget(true);

36. }

37. }

38. if (objList == gameFrame.blueList) {

39. if (recIntersectsCir(gameFrame.player.getRec(), getX(), getY(), 200)) {

40. setTarget(gameFrame.player);

41. setIfFindTarget(true);

42. }

43. }

44. }

46. public void moveToTarget() {

47. int dis = (int) getDis(getX(), getY(), getTarget().getX(), getTarget().getY());

48. if(dis!=0) {

49. int xSpeed = (getSpd() * (getTarget().getX() - getX()) / dis);

50. int ySpeed = (getSpd() * (getTarget().getY() - getY()) / dis);

51. setX(getX() + xSpeed);

52. setY(getY() + ySpeed);

53. }

54. }

56. public void createMinion(GameFrame gameFrame, ArrayList minionList) {

57. if (nextLine) {

58. if (nextMinion) {

59. // 蓝色方小兵

60. if (minionList == this.gameFrame.blueList) {

61. MinionBlue mb = new MinionBlue(gameFrame);

62. gameFrame.objList.add(mb);

63. minionList.add(mb);

64. }

65. // 红色方小兵

66. else {

67. MinionRed mr = new MinionRed(gameFrame);

68. gameFrame.objList.add(mr);

69. minionList.add(mr);

70. }

71. minionCount++;

72. new NextMinion().start();

73. }

74. if (minionCount == 3) {

75. minionCount = 0;

76. new NextLine().start();

77. }

78. }

79. }

81. // 每个小兵生成时间

82. class NextMinion extends Thread {

83. public void run() {

84. nextMinion = false;

85. // 休眠1.5s

86. try {

87. Thread.sleep(1500);

88. } catch (Exception e) {

89. e.printStackTrace();

90. }

91. nextMinion = true;

92. // 线程终止

93. this.interrupt();

94. }

95. }

97. // 每波小兵生成时间

98. class NextLine extends Thread {

99. public void run() {

100. nextLine = false;

101. // 休眠15s

102. try {

103. Thread.sleep(15000);

104. } catch (Exception e) {

105. e.printStackTrace();

106. }

107. nextLine = true;

108. // 线程终止

109. this.interrupt();

110. }

111. }

113. @Override

114. public void paintSelf(Graphics g) {

115. // 生命值为0

116. if (getCurrentHp() <= 0) {

117. setAlive(false);

118. gameFrame.removeList.add(this);

119. if (this instanceof MinionBlue) {

120. gameFrame.blueList.remove(this);

121. } else {

122. gameFrame.redList.remove(this);

123. }

124. } else {

125. // 添加生命值

126. if (this instanceof MinionBlue) {

127. this.addHp(g, 17, 28, 45, 10, Color.GREEN);

128. } else {

129. this.addHp(g, 17, 28, 45, 10, Color.RED);

130. }

131. g.drawImage(getImg(), getX() - 16, getY() - 16, null);

132. g.setColor(Color.RED);

133. g.fillOval(getX(), getY(), 10, 10);

134. g.drawRect(getX() - 16, getY() - 16, 45, 45);

135. g.drawOval(getX() - 200, getY() - 200, 400, 400);

136. // 小兵移动

137. if (!beControlled) {

138. if (this instanceof MinionBlue) {

139. move(gameFrame.redList);

140. } else {

141. move(gameFrame.blueList);

142. }

143. }

144. }

145. }

147. @Override

148. public Rectangle getRec() {

149. return new Rectangle(getX() - 16, getY() - 16, 45, 45);

150. }

152. public boolean isIfFindTarget() {

153. return ifFindTarget;

154. }

155. public void setIfFindTarget(boolean ifFindTarget) {

156. this.ifFindTarget = ifFindTarget;

157. }

159. }

MinionBlue

1. package sxt;

3. import java.util.ArrayList;

5. public class MinionBlue extends Minion{

7. public MinionBlue(GameFrame gameFrame) {

8. super(gameFrame);

9. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\minion\\blue.jpg");

10. setX(1325);

11. setY(3750);

12. }

14. @Override

15. public void move(ArrayList objList) {

16. if(isIfFindTarget()) {

17. //离开检测范围

18. if(!recIntersectsCir(getTarget().getRec(), getX(), getY(), 200)) {

19. setIfFindTarget(false);

20. }else {

21. if(!isHasTarget()) {

22. moveToTarget();

23. }

24. attack(objList);

25. }

26. }else {

27. findTarget(objList);

28. //原路线移动

29. if(getX() < 4425) {

30. setSpd(5);

31. setX(getX() + getSpd());

32. }else if(getX() < 5100 && getX() >= 4425) {

33. setSpd(20);

34. setX(getX() + getSpd());

35. setY(getY() - getSpd());

36. }else if(getX() >= 4900) {

37. setSpd(18);

38. setY(getY() - getSpd());

39. }

40. }

41. }

42. }

MinionRed

1. package sxt;

3. import java.util.ArrayList;

5. public class MinionRed extends Minion {

6. public MinionRed(GameFrame gameFrame) {

7. super(gameFrame);

8. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\minion\\red.jpg");

9. setX(5050);

10. setY(1125);

11. }

13. @Override

14. public void move(ArrayList objList) {

15. if (isIfFindTarget()) {

16. // 离开检测范围

17. if (!recIntersectsCir(getTarget().getRec(), getX(), getY(), 200)) {

18. setIfFindTarget(false);

19. } else {

20. if (!isHasTarget()) {

21. moveToTarget();

22. }

23. attack(objList);

24. }

25. } else {

26. findTarget(objList);

27. // 原路线移动

28. if (getY() < 3125) {

29. setSpd(28);

30. setY(getY() + getSpd());

31. } else if (getY() < 3750 && getY() >= 3125) {

32. setSpd(20);

33. setY(getY() + getSpd());

34. setX(getX() - getSpd());

35. } else if (getY() >= 3750) {

36. setSpd(25);

37. setX(getX() - getSpd());

38. }

39. }

40. }

45. }

Turret

1. package sxt;

3. import java.awt.*;

4. import java.util.ArrayList;

5. //防御塔类

6. public class Turret extends GameObject{

8. ArrayList turretList = new ArrayList<>();

9. public Turret turretBlueOne;

10. public Turret turretBlueTwo;

11. public Turret turretBlueThree;

12. public Turret turretBlueBase;

13. public Turret turretRedOne;

14. public Turret turretRedTwo;

15. public Turret turretRedThree;

16. public Turret turretRedBase;

18. public Turret(GameFrame gameFrame) {

19. super(gameFrame);

20. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\turret.png");

22. // 初始化八个防御塔

23. turretList.add(turretBlueOne = new TurretBlue(1860, 3790, gameFrame));

24. turretList.add(turretBlueTwo = new TurretBlue(2650, 3820, gameFrame));

25. turretList.add(turretBlueThree = new TurretBlue(3995, 3830, gameFrame));

26. turretList.add(turretBlueBase = new TurretBlue(1130, 3650, gameFrame));

27. turretList.add(turretRedOne = new TurretRed(5100, 3030, gameFrame));

28. turretList.add(turretRedTwo = new TurretRed(5120, 2100, gameFrame));

29. turretList.add(turretRedThree = new TurretRed(5060, 1570, gameFrame));

30. turretList.add(turretRedBase = new TurretRed(4850, 1100, gameFrame));

32. }

34. public Turret(int x, int y, GameFrame gameFrame) {

35. super(x, y, gameFrame);

36. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\turret.png");

37. setHp(6000);

38. setCurrentHp(getHp());

39. setAttackCoolDownTime(1000);

40. setDis(300);

41. }

42. public void isLive(){

43. if(gameFrame.turret.turretBlueBase.getCurrentHp()==0){

44. gameFrame.state=2;

45. }

46. if(gameFrame.turret.turretRedBase.getCurrentHp()==0){

47. gameFrame.state=1;

48. }

49. }

50. @Override

51. public void paintSelf(Graphics g) {

52. // 生命值为0

53. if (getCurrentHp() <= 0) {

54. setAlive(false);

55. gameFrame.removeList.add(this);

56. if (this instanceof TurretBlue) {

57. gameFrame.blueList.remove(this);

58. } else {

59. gameFrame.redList.remove(this);

60. }

61. } else {

62. // 添加生命值

63. if (this instanceof TurretBlue) {

64. this.addHp(g, 50, 130, 100, 20, Color.GREEN);

65. attack(gameFrame.redList);

66. } else {

67. this.addHp(g, 50, 130, 100, 20, Color.RED);

68. attack(gameFrame.blueList);

69. }

70. g.drawImage(getImg(), getX() - 50, getY() - 100, null);

71. g.fillOval(getX(), getY(), 10, 10);

72. g.drawRect(getX() - 50, getY() - 100, 100, 180);

73. g.drawOval(getX() - 300, getY() - 300, 600, 600);

74. }

75. }

77. @Override

78. public Rectangle getRec() {

79. return new Rectangle(getX() - 50, getY() - 100, 100, 180);

80. }

81. }

TurretBlue

1. package sxt;

2. //蓝方防御塔

3. public class TurretBlue extends Turret{

4. public TurretBlue(GameFrame gameFrame){

5. super(gameFrame);

6. }

7. public TurretBlue(int x,int y,GameFrame gameFrame){

8. super(x,y,gameFrame);

9. }

10. }

TurretRed

1. package sxt;

2. //蓝方防御塔

3. public class TurretRed extends Turret{

4. //有参构造

5. public TurretRed(GameFrame gameFrame){

6. super(gameFrame);

7. }

8. public TurretRed(int x,int y,GameFrame gameFrame){

9. super(x,y,gameFrame);

10. }

11. }

beast

Bear

1. package beast;

2. import sxt.GameFrame;

3. public class Bear extends Beast {

4. public Bear(int x, int y, GameFrame gameFrame) {

5. super(x, y, gameFrame);

6. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\beast\\bear.jpg");

7. width = 85;

8. height = 112;

9. setDis(65);

10. }

12. }

Beast

1. package beast;

3. import java.awt.Color;

4. import java.awt.Graphics;

5. import java.awt.Rectangle;

6. import java.util.ArrayList;

8. import sxt.*;

10. public class Beast extends GameObject {

12. public ArrayList beastList = new ArrayList<>();

13. int width;

14. int height;

15. // 复活的元素

16. Beast beast = null;

18. public Beast(GameFrame gameFrame) {

19. super(gameFrame);

20. beastList.add(new RedBuff(3045, 3170, gameFrame));

21. beastList.add(new Bear(2800, 2855, gameFrame));

22. beastList.add(new Bird(3570, 3380, gameFrame));

23. beastList.add(new Xiyi(4585, 2365, gameFrame));

24. beastList.add(new BlueBuff(4025, 2295, gameFrame));

25. beastList.add(new Wolf(4235, 1945, gameFrame));

26. }

28. public Beast(int x, int y, GameFrame gameFrame) {

29. super(x, y, gameFrame);

30. setHp(1000);

31. setCurrentHp(getHp());

32. beast = this;

33. }

36. @Override

37. public void paintSelf(Graphics g) {

38. if (getCurrentHp() <= 0) {

39. System.out.println("beast die");

40. setAlive(false);

41. gameFrame.removeList.add(this);

42. gameFrame.beast.beastList.remove(this);

43. new ReviveCD().start();

44. } else {

45. // 添加生命值

46. addHp(g, width / 2, 80, width, 20, Color.GREEN);

47. g.drawImage(getImg(), getX() - width / 2, getY() - height / 2, null);

48. g.setColor(Color.RED);

49. g.fillOval(getX(), getY(), 10, 10);

50. g.drawOval(getX() - getDis(), getY() - getDis(), 2 * getDis(), 2 * getDis());

51. }

52. }

54. @Override

55. public Rectangle getRec() {

56. return new Rectangle(getX() - width / 2, getY() - height / 2, width, height);

57. }

58. //野怪复活

59. class ReviveCD extends Thread {

60. public void run() {

61. // 线程休眠

62. try {

63. Thread.sleep(5000);

64. } catch (Exception e) {

65. e.printStackTrace();

66. }

67. Beast reviveBeast;

68. if (beast instanceof RedBuff) {

69. reviveBeast = new RedBuff(3045, 3170, gameFrame);

70. } else if (beast instanceof Bear) {

71. reviveBeast = new Bear(2800, 2855, gameFrame);

72. } else if (beast instanceof Bird) {

73. reviveBeast = new Bird(3570, 3380, gameFrame);

74. } else if (beast instanceof Xiyi) {

75. reviveBeast = new Xiyi(4585, 2365, gameFrame);

76. } else if (beast instanceof BlueBuff) {

77. reviveBeast = new BlueBuff(4025, 2295, gameFrame);

78. } else {

79. reviveBeast = new Wolf(4235, 1945, gameFrame);

80. }

81. gameFrame.objList.add(reviveBeast);

82. gameFrame.beast.beastList.add(reviveBeast);

83. }

84. }

86. }

Bird

1. package beast;

2. import sxt.GameFrame;

3. public class Bird extends Beast {

4. public Bird(int x, int y, GameFrame gameFrame) {

5. super(x, y, gameFrame);

6. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\beast\\红隼.jpg");

7. width = 122;

8. height = 98;

9. setDis(125);

10. }

12. }

BlueBuff

1. package beast;

2. import sxt.GameFrame;

3. public class BlueBuff extends Beast {

4. public BlueBuff(int x, int y, GameFrame gameFrame) {

5. super(x, y, gameFrame);

6. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\beast\\blueBuff.jpg");

7. width = 142;

8. height = 176;

9. setDis(70);

10. }

12. }

RedBuff

1. package beast;

2. import sxt.GameFrame;

3. public class RedBuff extends Beast {

4. public RedBuff(int x, int y, GameFrame gameFrame) {

5. super(x, y, gameFrame);

6. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\beast\\redBuff.jpg");

7. width = 103;

8. height = 150;

9. setDis(70);

10. }

11. }

Wolf

1. package beast;

2. import sxt.GameFrame;

3. public class Wolf extends Beast {

5. public Wolf(int x, int y, GameFrame gameFrame) {

6. super(x, y, gameFrame);

7. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\beast\\wolf.jpg");

8. width = 145;

9. height = 140;

10. setDis(65);

11. }

13. }

Xiyi

1. package beast;

2. import sxt.GameFrame;

3. public class extends Beast {

5. public Xiyi(int x, int y, GameFrame gameFrame) {

6. super(x, y, gameFrame);

7. setImg("C:\\Users\\24465\\Desktop\\王者荣耀图片(1)\\王者荣耀图片\\beast\\蜥蜴.jpg");

8. width = 111;

9. height = 65;

10. setDis(125);

11. }

12. }