enemy.java
上传用户:jhzhutan
上传日期:2021-03-28
资源大小:374k
文件大小:9k
源码类别:

射击游戏

开发平台:

Java

  1. import java.awt.*;
  2. //Download:http://www.codefans.net
  3. public class enemy implements Actor{
  4. public final int UP = 0;
  5. public final int DOWN = 1;
  6. public final int LEFT = 2;
  7. public final int RIGHT = 3;
  8. public final int size = 12;
  9. public final Rectangle map = new Rectangle(35, 35, 452, 452);
  10. public static int freezedTime;
  11. public static int freezedMoment;
  12. public int numberOfBullet;
  13. public int coolDownTime;
  14. public int type;
  15. public int speed;
  16. public int direction;
  17. public int interval;
  18. public int health;;
  19. public int xPos, yPos, xVPos, yVPos;
  20. public Rectangle border;
  21. public boolean flashing;
  22. public double firePosibility;
  23. public Image[] textures;
  24. public ServerModel gameModel;
  25. public enemy(int type,  boolean flashing, int xPos, int yPos, ServerModel gameModel){
  26. this.type = type;
  27. this. xPos = xPos;
  28. this.yPos = yPos;
  29. this.flashing = flashing;
  30. this.gameModel = gameModel;
  31. //setup common attribute shared by all enemy tanks
  32. interval = (int)(Math.random()*200);
  33. direction = (int)(Math.random()*4);
  34. numberOfBullet = 1;
  35. xVPos = xPos;
  36. yVPos = yPos;
  37. border = new Rectangle(xPos - size, yPos - size, 25, 25);
  38. //setup unique attributes according to different type of enemies, e.g apperance, speed,
  39. if(type ==1 ){
  40. firePosibility = 0.95;
  41. speed = 2;
  42. textures = new Image[8];
  43. for(int i = 0; i < 8; i++)
  44. textures[i] = gameModel.textures[38+i];
  45. }else if(type == 2){
  46. firePosibility = 0.95;
  47. speed = 4;
  48. textures = new Image[8];
  49. for(int i = 0; i < 8; i++)
  50. textures[i] = gameModel.textures[2+i];
  51. }else if(type == 3){
  52. firePosibility = 0.9;
  53. speed = 2;
  54. textures = new Image[8];
  55. for(int i = 0; i < 8; i++)
  56. textures[i] = gameModel.textures[10+i];
  57. }else{
  58. firePosibility = 0.95;
  59. health = 3;
  60. speed = 2;
  61. textures = new Image[20];
  62. for(int i = 0; i < 20; i++)
  63. textures[i] = gameModel.textures[18+i];
  64. }
  65. }
  66. public void move(){
  67.        if(gameModel.gamePaused){
  68.          writeToOutputLine();
  69.     return;
  70. }
  71.       if(freezedTime > ServerModel.gameFlow - freezedMoment){
  72.     writeToOutputLine();
  73.     return;
  74. }
  75.        //the enemy tank will keep moving in the same direction for a random periord(if doesnt interact with other objects)
  76.         //at the end of each period, it will change to a new direction
  77.         if(interval > 0)
  78.          interval--;
  79.         if(interval == 0){
  80. interval = (int)(Math.random()*200);
  81. int newDirection = (int)(Math.random()*4);
  82. if(direction != newDirection){
  83. if(direction/2 != newDirection/2){
  84. xPos = xVPos; yPos = yVPos;
  85. border.x = xPos - size; border.y = yPos - size;
  86. }
  87. direction = newDirection;
  88. }
  89. }
  90. //decide whether to fire a bullet, the decition is made completely random, but the enemy tank cant fire a second
  91. //bullet if the first one is not destroyed
  92. if(coolDownTime > 0)
  93. coolDownTime--;
  94. if(Math.random() > firePosibility && coolDownTime == 0 && numberOfBullet > 0){
  95. //make bullet direction
  96. int c = direction;
  97. //make bullet position
  98. int a, b;
  99. if(direction == UP){
  100. a = xPos; b = yPos - size;
  101. }else if(direction == DOWN){
  102. a = xPos; b = yPos + size;
  103. }else if(direction == LEFT){
  104. a = xPos - size; b = yPos;
  105. }else{
  106. a = xPos + size; b = yPos;
  107. }
  108. //make bullet speed
  109. int d;
  110. if(type == 3){
  111. d = 12;
  112. }else{
  113. d = 7;
  114. }
  115. //add bullet
  116. gameModel.addActor(new bullet(a,b,c,d,1, this, gameModel));
  117. coolDownTime = 7;
  118. if(type == 3)
  119. coolDownTime = 5;
  120. numberOfBullet--;
  121. }
  122. //save current position  information, if the new move is determined not valid later, then change
  123. //the position back
  124. int xPosTemp = xPos;
  125. int yPosTemp = yPos;
  126. Rectangle borderTemp = new Rectangle(xPosTemp - size, yPosTemp - size, 25,25);
  127. //defind the next border of the enemy tank, assume its next move is valid according to its direction;
  128. if(direction == UP){
  129. yPos-=speed;
  130. }else if(direction == DOWN){
  131. yPos+=speed;
  132. }else if(direction == LEFT){
  133. xPos-=speed;
  134. }else{
  135. xPos+=speed;
  136.     }
  137. //update border
  138. border.y = yPos - size;
  139. border.x = xPos - size;
  140. //check if the next border will intersect with map border, if does then generate a new random direction
  141. if(!border.intersects(map)){
  142. direction = (int)(Math.random()*4);
  143. interval = (int)(Math.random()*250);
  144. xPos = xVPos; yPos = yVPos;
  145. border.x = xPos - size; border.y = yPos - size;
  146. writeToOutputLine();
  147. return;
  148. }
  149. //check if the next border intersects with other objects in the map, eg, player controled tank, wall, etc...
  150. for(int i = 0; i < gameModel.actors.length; i++){
  151. if(gameModel.actors[i] != null){
  152. if(this != gameModel.actors[i] ){
  153. if(border.intersects(gameModel.actors[i].getBorder())){
  154. //with static objects, eg walls, rivers
  155. if(gameModel.actors[i].getType().equals("steelWall") || gameModel.actors[i].getType().equals("wall")){
  156. if(!gameModel.actors[i].walldestoried()){
  157. for(int j = 0;j < gameModel.actors[i].getDetailedBorder().length; j++){
  158. if( gameModel.actors[i].getDetailedBorder()[j] != null){
  159. if(gameModel.actors[i].getDetailedBorder()[j].intersects(border)){
  160. if(Math.random() > 0.90)
  161. direction = (int)(Math.random()*4);
  162. xPos = xVPos; yPos = yVPos;
  163. border.x  = xPos - size; border.y = yPos - size;
  164. writeToOutputLine();
  165. return;
  166. }
  167. }
  168. }
  169. }
  170. }else if(gameModel.actors[i].getType().equals("river") || gameModel.actors[i].getType().equals("base")){
  171. if(Math.random() > 0.90)
  172. direction = (int)(Math.random()*4);
  173. xPos = xVPos; yPos = yVPos;
  174. border.x  = xPos - size; border.y = yPos - size;
  175. writeToOutputLine();
  176. return;
  177. }
  178. //with moving objects, eg other tanks
  179. if(gameModel.actors[i].getType().equals("Player") || gameModel.actors[i].getType().equals("enemy")){
  180. if(!borderTemp.intersects(gameModel.actors[i].getBorder())){
  181. xPos = xPosTemp;
  182. yPos = yPosTemp;
  183. border.x = xPos - size; border.y = yPos - size;
  184. int newDirection = (int)(Math.random()*4);
  185. if(direction != newDirection){
  186. if(direction/2 != newDirection/2){
  187. xPos = xVPos; yPos = yVPos;
  188. border.x = xPos - size; border.y = yPos - size;
  189. }
  190. direction = newDirection;
  191. }
  192. writeToOutputLine();
  193. return;
  194. }
  195. }
  196. }
  197. }
  198. }
  199. }
  200. ///find the virtual position of the tank,  virtual position is used to adjust tank 's real position when it makes a 90 degrees turning.
  201. int a = (xPos - 10)/25;
  202. int b = (xPos - 10)%25;
  203. if(b < 7)
  204. b = 0;
  205. if(b > 18)
  206. b = 25;
  207. if((b < 19 && b > 6) || xPos < 17 || xPos > 492)
  208. b = 13;
  209. xVPos = a*25 + b + 10;
  210. int c = (yPos - 10)/25;
  211. int d = (yPos - 10)%25;
  212. if(d < 7)
  213. d = 0;
  214. if(d > 18)
  215. d = 25;
  216. if((d < 19 && d > 6) || yPos < 17 || yPos > 492)
  217. d = 13;
  218. yVPos = c*25 + d + 10;
  219. writeToOutputLine();
  220. }
  221. public void writeToOutputLine(){
  222. //write changes to outputLine
  223. gameModel.outputLine+="n"+ xPos + "," + yPos + ",";
  224. int textureIndex = 0;
  225. if(flashing && gameModel.gameFlow%10 > 4){
  226. if(type == 1)
  227. textureIndex = 42+ direction;
  228. else if(type == 2)
  229. textureIndex = 6 + direction;
  230. else if(type == 3)
  231. textureIndex = 14 + direction;
  232. else
  233. textureIndex = 34 + direction;
  234. }else{
  235. if(type == 1)
  236. textureIndex = 38 + direction;
  237. else if(type == 2)
  238. textureIndex = 2 + direction;
  239. else if(type == 3)
  240. textureIndex = 10 + direction;
  241. else{
  242. if(health == 3)
  243. textureIndex = 18 + direction;
  244. else if(health == 2)
  245. textureIndex = 22 + direction;
  246. else if(health == 1)
  247. textureIndex = 26 + direction;
  248. else
  249. textureIndex = 30 + direction;
  250. }
  251. }
  252. gameModel.outputLine+= "" + textureIndex + ";";
  253. }
  254. //determine what will happen if the enemy tank hit buy a bullet
  255. public void hurt(){
  256. if(flashing)
  257. gameModel.addActor(new powerUp(gameModel));
  258. flashing = false;
  259. boolean death = false;
  260. if(type != 4 )
  261. death = true;
  262. else{
  263. if(health == 0)
  264. death = true;
  265. else{
  266. if(health == 3){
  267. for(int i = 0; i < 4; i++)
  268. textures[i] = textures[4+i];
  269. }else if(health == 2){
  270. for(int i = 0; i < 4; i++)
  271. textures[i] = textures[8+i];
  272. }else if(health == 1){
  273. for(int i = 0; i < 4; i++)
  274. textures[i] = textures[12+i];
  275. }
  276. health--;
  277. }
  278. }
  279. if(death){
  280. level.NoOfEnemy--;
  281. level.deathCount++;
  282. gameModel.removeActor(this);
  283. gameModel.addActor(new bomb(xPos, yPos, "big", gameModel));
  284. }
  285. }
  286. public String getType(){
  287. return "enemy";
  288. }
  289. public void draw(Graphics g){
  290. if(flashing && gameModel.gameFlow%10 > 4)
  291. g.drawImage(textures[textures.length-4+direction], xPos - size, yPos - size, null);
  292. else
  293. g.drawImage(textures[direction], xPos - size, yPos - size, null);
  294. }
  295. public Rectangle getBorder(){
  296. return border;
  297. }
  298. //unused method
  299. public Rectangle[] getDetailedBorder(){return null;}
  300. public boolean walldestoried(){return false;}
  301. }