java植物大战僵尸，我家ADC直呼内行，甚至喊出辅助牛逼、666
引言：
作为辅助，带领我家ADC获取胜利是我的第一目标，虽然AD有可能是新手、也有可能是手残党，但是丝毫对我没有影响，因为我会在游戏里面对AD给与无微不至的关怀，正所谓我武能抢人头，文能回首与打野对喷，兵线是你的人头是我的，哈哈！
老java程序员用2天时间开发一个简版植物大战僵尸
对话
正好今天的AD是个新手，我就先带她打打怪、升升级，给他好好上一课！
小AD：明哥，带我上分，我要上最强王者。
明世隐：哇，有志向，你只要会喊明哥牛逼，明哥666就行。
小AD：我最擅长了，666。
明世隐：今天先打打怪升升级，让你提升一下操作水平。
小AD：做什么呀？
明世隐：做个小游戏，植物大战hello kitty，贼好玩。
小AD：没听过，不过听起来有点奇怪！
明世隐：明哥什么时候骗过你呀，你不是前段时候学习了java吗，来我教你。
小AD：可是我学的不咋样呀，肯定做不来。
明世隐：放心有我在，保证万无一失，就做个简单的，你也可以轻松做出来。
小AD：那好吧。
游戏窗体
明世隐：首先创建一个游戏窗体类GameFrame，继承至JFrame，用来显示在屏幕上（window的对象），每个游戏都有一个窗口。
小AD：是不是跟王者打开时候弹出来的游戏窗口一个意思？
明世隐：对的！我们来个GameFrame 添加一个无参构造，里面设置好窗口标题、尺寸、布局等就可以了，看下面的代码。
import java.awt.BorderLayout;
import javax.swing.JFrame;
/*
* 游戏窗体类
*/
public class GameFrame extends JFrame {
public GameFrame() {
setTitle("植物大战僵尸");//设置标题
setSize(906, 655);//设定尺寸
setLayout(new BorderLayout());
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//点击关闭按钮是关闭程序
setLocationRelativeTo(null); //设置居中
setResizable(false); //不允许修改界面大小
}
}明世隐：再创建一个Main类，来启动这个窗口（只要一行设定显示这个窗口的代码即可）。
public class Main {
//主类
public static void main(String[] args) {
GameFrame frame = new GameFrame();
frame.setVisible(true);//设定显示
}
}明世隐：右键运行这个Main类，窗口被打开。
明世隐：怎么样，简单不简单，就这么几句话。
面板容器
小AD：这个好简单，我一听就会了，可是要怎么写游戏呢？
明世隐：这个窗体就好比手机的外壳体，我们需要加上手机屏幕才能显示内容。这里创建一个类GamePanel继承至JPanel，JPanel就是一个面板容器类，我们把这个GamePanel添加到窗体中，然后在GamePanel里面添加上我们要的内容，就会显示出来。当然别忘记了把GamePanel添加到窗体中，这其中GamePanel可以理解为手机的屏幕。
小AD：那要怎么添加呢？
明世隐：简单，只要在Main加入两句话即可（1创建实例，2添加到窗体中）
public class Main {
//主类
public static void main(String[] args) {
GameFrame frame = new GameFrame();
GamePanel panel = new GamePanel(frame);//创建实例
frame.add(panel);//添加到窗体中
frame.setVisible(true);//设定显示
}
}小AD：可是运行看起来和刚才一样啊，没有区别。
游戏背景图
明世隐：那是我没给屏幕上画东西，所以你看不到。
小AD：就跟在白纸上画画一样？
明世隐：是的，明哥来举个例子，首先重写paint(Graphics g)方法，这个方法可以进行2D画图，要做游戏这个方法就特别的重要，而且这个方法不需要我们自己来调用，swing框架会自动调用，只要我们重写这个方法就行，我们在这个方法写了什么内容，就会绘制什么内容出来。
明世隐：先绘制一个背景图吧，怎么用呢，用 g.drawImage(img, x, y, width, height, null); 第一个参数是BufferedImage对象，是根据图片路径加载出来的图片对象，x,y就是绘制的左坐标，width宽度，height高度，其实width, height这两个参数也可以省略，这样就会根据图片的长宽来绘制，如果设定了就有可能会缩放。
小AD：如何获取图片对象呢?
明世隐：明哥写好了一个方法，只要传入图片的路径就可以了。
public static BufferedImage getImg(String path){
//用try方法捕获异常
try {
//io流，输送数据的管道
BufferedImage img = ImageIO.read(GameApp.class.getResource(path));
return img;
}
//异常处理，打印异常
catch (IOException e) {
e.printStackTrace();
}
//没找到则返回空
return null;
}明世隐：绘制一下背景图，只要在paint写入下面的代码既可
BufferedImage bufferedImage = GameApp.getImg("/images/1.png");
g.drawImage((BufferedImage)imageMap.get("1"), -150, 0, null);运行一下看看：
小AD：这么简单就出来了呀！好厉害！
卡牌、积分等辅助框
明世隐：那必须的，我们先来把放卡牌的框、积分牌什么的绘制一下。跟刚才一样，就是找到对应的图片，设定好位置就行。
//绘制背景
g.drawImage((BufferedImage)imageMap.get("1"), -150, 0, null);
//方形卡片盘
g.drawImage((BufferedImage)imageMap.get("2"), 0, 0,446,80, null);
//铲子背景
g.drawImage((BufferedImage)imageMap.get("17"), 446, 2,80,35, null);
//积分盘
g.drawImage((BufferedImage)imageMap.get("12"), 530, -4,128,40, null);
小AD：嗯这个明白了。
卡牌绘制
明世隐：再来把卡牌绘制一下，有了卡牌我们才知道绘制什么植物的，这时候我来创建一个 Card 类，属性有 x、y坐标，width、height长宽，cost需要花费的阳光数（比如创建太阳植物需要50阳光，创建豌豆射手需要100阳光），type表示类型（sun 表示太阳，wandou表示射手植物）。构造函数直接传进去，同时创建draw方法，用来绘制卡牌。
public class Card {
private int x = 0;//x坐标
private int y = 0;//y坐标
private int width = 0;//宽
private int height = 0;//高
private BufferedImage image = null;//图片对象
private int cost = 0;//阳光花费
private String type = "";//类型,可以通过类型来判断创建什么植物
private GamePanel panel=null;
private int index=0;
public Card(int x, int y, int width, int height, BufferedImage image,String type,int cost, int index ,GamePanel panel) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
this.image = image;
this.type=type;
this.cost=cost;
this.index=index;
this.panel=panel;
}
public void draw(Graphics g) {
g.drawImage(image, x, y, width, height, null);
}
}小AD：明哥我不是特别明白，为什么要这么搞呢?
明世隐：这就是面向对象编程的应用，如果我要创建不同的卡牌，只要传入不同的参数既可以做到。
private void initCard() {
int x=0,y=0;
Card card=null;
card = new Card(76,5,50,68,(BufferedImage)imageMap.get("3"),"sun",50,1,this);//向日葵卡牌
plantsCard.add(card);
card = new Card(127,4,50,70,(BufferedImage)imageMap.get("4"),"wandou",100,2,this);//豌豆射手卡牌
plantsCard.add(card);
card = new Card(177,4,50,70,(BufferedImage)imageMap.get("5"),"wallNut",50,3,this);//胡桃卡牌
plantsCard.add(card);
}明世隐：你看上面的3小块代码分别创建了3个卡牌，传入了不同的x坐标，不同的图片，不同的type类型，不同的阳光花费等，但是我们只需要创建同一个Card的实例就行。我们把这些实例对象都添加到定义好的集合 plantsCard 中，然后在paint方法里面循环这个集合，对每个元素执行前面Card类里面draw方法进行绘制。
明世隐：铲子工具一样的道理，只不过我没有用集合来存，而是单独写，因为跟卡牌稍微有点区别。
shovelCard = new ShovelCard(454, 4,68,28,(BufferedImage)imageMap.get("16"), this); 小AD：好像有点明白了。
抽象小例
明世隐：来把植物做出来，因为考虑到植物很多种，有写方法需要公共去调用，我们可以封装抽象类！
小AD：抽象类？是不是形容一个人一样，“你长得很抽象”！
明世隐：哎呀我去，你说我干嘛，我可是英俊潇洒、风流倜傥的辅助，小心我抢你人头。
小AD：明哥我错了！
明世隐：就比如以前军训的时候，教官喊一句报数，我们就一个个都报过去，因为我们每一个都有一个嘴巴，都会报数，我们就可以理解为创建一个抽象类Student，有个抽象方法叫 sayNum， 然后每个我们每个人都继承至Student，然后在具体去实现这个sayNum 方法；
public abstract class Student {
abstract void sayNum();
}再创建子类
public class StudentC extends Student{
int count =0;
public StudentC(int count) {
this.count=count;
}
@Override
void sayNum() {
System.out.println("报数:"+count);
}
}创建main方法测试
public static void main(String[] args) {
List list = new ArrayList();
for (int i = 1; i <= 5; i++) {
list.add(new StudentC(i));
}
Student student=null;
for (int i = 0; i < list.size(); i++) {
student = (Student)list.get(i);
student.sayNum();
}
}
明世隐：上例中我们创建了5个子对象，最后遍历调用方法的时候，可以直接向上转型至父类，然后直接调用，根本不用关心子类具体是什么，就能实现通用。
小AD：有点懵。
植物抽象化
明世隐：那在本例中，要创建 太阳植物、豌豆植物、胡桃果，我们都可以存到一个集合中去处理，给他们定义一个父类，这样处理起来就很方便。
明世隐：创建Plant抽象类，包含绘制、摇摆、射击、清除、种植等抽象方法，然后子类中去进行不同的实现就好。
public abstract class Plant {
public abstract void draw(Graphics g);
abstract void waggle();
abstract void shoot();
public abstract void clear();
public abstract void plant(PlantsRect rect);
}豌豆植物实现
明世隐：来说说豌豆植物类，它继承至Plant类。同样的给它设置 x\y坐标，宽高等常用属性，还需要加入阳光花费、生命值等属性。draw方法的实现和上面讲过的卡牌类是一样的。
private int x = 0;
private int y = 0;
private int width = 0;
private int height = 0;
private int index=0;
private int cost = 0;
private BufferedImage image = null;
private GamePanel panel=null;
private HashMap imageMap=null;
private List zombies = new ArrayList();
private int key=1;
private boolean alive=false;
private int hp=10;
private PlantsRect plantsRect=null;
MusicPlayer musicShoot= null;
public WandouPlant(int x,int y,int width,int height,GamePanel panel) {
this.x=x;
this.y=y;
this.width=width;
this.height=height;
this.panel=panel;
this.imageMap=panel.wandouPlantHashMap;
this.image=(BufferedImage)imageMap.get("("+key+")");
}
@Override
public void draw(Graphics g) {
g.drawImage(image, x, y, width,height, null);
}明世隐：我们来创建一个到图中的格子中去，设置好坐标生命的就可以了。比如我们在100、100坐标的位置创建一个豌豆植物（代码同样放在paint方法里面）。
Plant plant = new WandouPlant(100, 100, 63,70, this);
plant.draw(g);
植物本身动画
小AD：看到了，这个小树苗干嘛用的。
明世隐：它有两个功能，第一会来回摇晃，第二发射子弹进行攻击，但是他没有别的技能不像王者有好几个技能，我们现在来让它动起来，只要在WandouPlant类重写摇晃方法，开启线程让它不停的切换图片即可，能明白吗？
//摇晃动画
@Override
void waggle() {
new Thread(new Runnable() {
@Override
public void run() {
while(alive){
changeImage();
try {
Thread.sleep(110);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
//更换图片
void changeImage(){
key++;
if(key>13){
key=1;
}
this.image=(BufferedImage)imageMap.get("("+key+")");
width = this.image.getWidth();
height = this.image.getHeight();
}小AD：这个我知道，就是图片的不停切换，达到动画的效果呗。
植物射击
明世隐：再来写shoot射击方法，先创建一个Wandou类，属性什么的都差不多，有坐标、宽高这些，就是给他添加一个move方法，只要Wandou实例对象被创建出来就开启线程，一直更改x的位置就行，因为是向右飞行，只要设置x递增就可以，当然如果跑到最右边去了，就清除这对象。
//移动
void move(){
new Thread(new Runnable() {
@Override
public void run() {
while(alive){
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
x+=speed;
//超过范围，豌豆消失
if(x>=panel.gameWidth){
clear();
}
}
}
}).start();
}回到WandouPlant类，射击的话也是采取线程的方式，执行完后睡眠2000毫秒，也就是2秒发射一个子弹（豌豆）
@Override
void shoot() {
//Sun
new Thread(new Runnable() {
@Override
public void run() {
while(alive){
try {
//每2秒发射一个豌豆
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(alive){//防止被吃了还能发射一次子弹
createWandou();
musicShoot=new MusicPlayer("/music/shoot.wav");
musicShoot.play();
}
}
}
private void createWandou() {
Wandou wandou = new Wandou(x+50, y, 28, 28, panel,index);
panel.wandous.add(wandou);
}
}).start();
}
卡牌创建植物
小AD：那明哥，不是应该点击卡牌来创建植物的吗？
明世隐：是的，要先给容器添加事件监听，我采用MouseAdapter 的方式，根据键的值来判断是左键还是右键，如果是左键，则依次去遍历卡牌对象，如果在卡牌的范围内就判断是哪种卡牌被点击了，需要创建一个对应的植物出来，并且跟随鼠标移动。
小AD：怎么判断呢？
明世隐：很简单，就是根据鼠标的坐标，与图片的x\y坐标 、长度、宽度进行比较，当鼠标的x大于卡牌的x，并且鼠标的y大于卡牌的y，并且鼠标的x小于卡牌的x+width，并且鼠标的y小于卡牌的y+height，4个条件都满足就表示在这个卡牌飞范围内，就判断这个卡牌被点击了，然后就根据这个卡牌来创建植物。
小AD：我听不太明白，能说清楚些吗？
明世隐：我画个图你就明白了
从上图我们可以看到，鼠标的位置要是在范围内的话，X1肯定大于X，Y1肯定大于Y，X1 当鼠标点击的时候，调用用 isPoint方法传入鼠标的坐标，就可以判断是否在某个卡牌内，如在就创建对应的植物，根据鼠标的位置，这个能理解不？ 小AD：可以的。 明世隐：我们可以在Card类中，加入新方法，根据不同的卡牌类型创建不同的植物，当卡牌被鼠标点击的时候，调用此方法。 小AD：如何调用呢? 明世隐：这里有几个事情要做 1.判断阳光数量，如果不足，则不能创建。 2.开启创建创建音效。 3.在鼠标坐标处创建对应的植物 4.扣除花费的阳光数 5.判断阳光总数值够不够创建这些卡牌，如果不够的，给他遮罩起来 小AD：怎么把它移动到田里面呢？ 明世隐：然后加入鼠标移动监听 在MouseAdapter里面重写 mouseMoved方法，当鼠标移动就改变新创建的植物的x,y坐标就会跟随鼠标移动。 明世隐：这里要开启一个主线程，用来重绘页面，重绘的线程只有这一个，重绘全部交给主线程，主线程里面只要调用 repaint方法就会重绘了，如果不执行重绘更换图片，改动坐标也是不会动的，因为页面没有刷新。 在mouseMoved方法里面，一直把鼠标的X,Y坐标更新给树苗对象，树苗就这样跟随鼠标移动了。 小AD：明哥，你的草地怎么会变颜色，还有那我要怎么种植物下去呢？ 明世隐：这里需要给田划分好一块块的，每一块绘制一个小方形来区域，这个方形区域很重要，每个植物就是对应种在这个方形上的，怎么来划分呢，就是根据图片的尺寸。 当然这样画的不好看，我用代码计算并绘制出来就清晰了。创建一个PlantsRect 植物背景方形类，跟之前的差不多，只不过不是绘制的图片，而是方形 执行创建 明世隐：AD你看，田被我分成一块块的，植物就种植在每一个方块里面，这样就非常好控制， 当然这里我等会要绘制成透明的，种植时鼠标在小方形点击的时候，植物的坐标更改过去，就完成了种植了。而且可以设置成鼠标移入的时候，变成绿色，如果已经有植物了则变成红色，无法种植。 左图是可以种植的，右图则不能种植，因为已经有植物了。 小AD：明哥你的hello kitty呢？ 明世隐：马上来做，同样以抽象类的方式来做，因为kitty也有多种（但我目前就做了普通的那种）。 这里要注意，是分了5行的，一行行都要有下标，计算的时候就不会出错（下面代码是在1、2、3、4、5随机的行创建）。 然后实现移动方法，让他坐标x递减，同时切换图片，可以达到移动的动画 于是，hello kitty一号粉墨登场了。 小AD：挖槽，你这明明是僵尸。 明世隐：在我眼里这就是hello kitty ，呆萌呆萌的，跟你一样萌，这不是都是金币吗？你在王者里面见到的野怪不都这个德性，这个有比暴君凶猛？ 小AD：你。。。。。 再加入 eat(吃) dead（死亡） 的方法，因为移动，吃、死亡这3个事情都是独立做的，不会在一起，所以每次都要停止之前的线程，启动新的线程。 小AD：是不是他在吃的时候，就鞋带掉了呀，在系鞋带的，所以不能走。 明世隐：对啊，你在王者里面被杨玉环勾住了，你可不得石乐志的往她身边走 ？ 下面来加入豌豆攻击僵尸的判断，因为子弹和僵尸是相向而行的，只要子弹的X坐标，大于或者等于僵尸的坐标，就判断为击中，击中的时候，僵尸血量减去1，子弹消失，当僵尸的血量减完归零的时候，僵尸触发dead方法，进行死亡的动画，然后执行完动画，从屏幕中清除它。 太阳植物的写法和豌豆植物的写法很类似，就是发射子弹变成了发射太阳光，就不重复了。 胡桃的就不说了，再把一些细节处理一些就基本完成了。 小AD：挺好玩的，这些呆萌呆萌的hello kitty，嘻嘻嘻嘻。 新涉世的ADC,怕是没有经历过时间的险恶，于是我决定给他上一课。 （现在僵尸是每5秒出一批，每批随机1-5只，还是蛮好守的，于是我在5波之后 一次性创建20-50只僵尸） 于是屏幕出现了这样的画面 紧接着，一大波僵尸冲了过去 小AD失败了。 不好意思，小AD战绩0-10，我10-0，AD直呼有套路，然后大喊辅助牛b666，但是小AD的编程知识却是长进了不少。 我希望每一位AD经过明世隐的辅助，都能够从0-10，变成10-0，成长为一个优秀的编程者，编程界的一流ADC。 代码下载：老java程序员用2天时间开发一个简版植物大战僵尸 //检查坐标是否图形范围内
public boolean isPoint(int x,int y){
if(x>this.x && y>this.y && x//在对应的坐标出创建对应的植物
public void createPlant(int x, int y,int cost) {
Plant plant = null;
if("sun".equals(type)){//创建太阳植物
plant = new SunPlant(x-31, y-36, 62,72, panel);
}else if("wandou".equals(type)){//创建豌豆植物
plant = new WandouPlant(x-31, y-35, 63,70, panel);
}else if("wallNut".equals(type)){//创建胡桃植物
plant = new wallNutPlant(x-31, y-35, 61,71, panel);
}
plant.setCost(cost);
panel.curPlant=plant;
panel.plants.add(plant);
}Card card=null;
for (int i = 0; i < plantsCard.size(); i++) {
card = (Card)plantsCard.get(i);
if(card.isPoint(x, y)){
if(sunCount
//刷新线程，用来重新绘制页面
private class RefreshThread implements Runnable {
@Override
public void run() {
while (true) {
repaint();
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
植物种植
public class PlantsRect {
private int x=0;
private int y=0;
private int width=0;
private int height=0;
private int index=0;
private Color color=null;
private Plant plant=null;
public PlantsRect(int x,int y,int width,int height,int index) {
this.x=x;
this.y=y;
this.width=width;
this.height=height;
this.index=index;
this.color = RandomColor.getRandomColor();;//随机颜色
//this.color = new Color(0,250,154, 0);//绘制成透明的颜色
}
public void draw(Graphics g) {
Color oColor = g.getColor();
g.setColor(color);
g.fillRect(x, y, width, height);
g.setColor(oColor);
}
//检查坐标是否图形范围内
public boolean isPoint(int x,int y){
if(x>this.x && y>this.y && xprivate void initPlantsRect() {
int x=0,y=0;
PlantsRect pRect=null;
for(int i=1;i<=5;i++){//5行
y = 75+(i-1)*100;
for(int j=1;j<=9;j++){//9列
x = 105+(j-1)*80;
pRect = new PlantsRect(x,y,80,100,i);
plantsRect.add(pRect);
}
}
}
PlantsRect pRect = null;
for (int i = 0; i < plantsRect.size(); i++) {
pRect = (PlantsRect)plantsRect.get(i);
if(pRect.isPoint(x, y)){
if(pRect.getPlant()!=null){//如果已经有植物了
if(curPlant!=null){//不能种植
pRect.setColor(new Color(255,23,13, 190));
}
}else{
if(curPlant!=null){//可以种植
pRect.setColor(new Color(0,250,154, 120));
}
}
}else{
pRect.setColor(new Color(0,250,154, 0));
}
}
实现僵尸
public class GeneralZombie extends Zombie{
private int x = 0;
private int y = 0;
private int width = 0;
private int height = 0;
private BufferedImage image = null;
private GamePanel panel=null;
private HashMap zombieMoveHashMap=null;
private HashMap zombieEatHashMap=null;
private HashMap zombieDeadHashMap=null;
private int key=1;
private boolean alive=false;
private boolean moveFlag=true;
private boolean eatFlag=false;
private boolean deadFlag=false;
private int speed=1;
private int action = 1;//1 移动，2 吃 3 死亡
private int index=0 ;//下标
private int hp=0 ;//血量
private Plant eatPlant=null;//正在吃的植物
MusicPlayer musicEat=null;
MusicPlayer musicDead=null;
public GeneralZombie(int x,int y,int width,int height,GamePanel panel) {
this.x=x;
this.y=y;
this.width=width;
this.height=height;
this.panel=panel;
this.zombieMoveHashMap=panel.zombieMoveHashMap;
this.zombieEatHashMap=panel.zombieEatHashMap;
this.zombieDeadHashMap=panel.zombieDeadHashMap;
this.image=(BufferedImage)zombieMoveHashMap.get("("+key+")");
alive = true;
move();
}
@Override
public void draw(Graphics g) {
g.drawImage(image, x, y, width,height, null);
}
}private void createZombie(Random random){
int x=825;
int y=0;
int index = random.nextInt(5)+1;//随机获取1\2\3\4\5 行数
if(index==1){
y=60;
}else if(index==2){
y=160;
}else if(index==3){
y=260;
}else if(index==4){
y=355;
}else if(index==5){
y=460;
}
Zombie zombie = new GeneralZombie(x, y, 75,119, this);
zombie.setIndex(index);//设置是第几行的僵尸
zombie.setHp(10);//设置血量
zombies.add(zombie);
}僵尸移动
//移动
@Override
void move(){
new Thread(new Runnable() {
@Override
public void run() {
while(alive && moveFlag && !deadFlag){
try {
Thread.sleep(80);
} catch (InterruptedException e) {
e.printStackTrace();
}
x-=speed;
changeImage();
eat();
if(x<100){
System.out.println("结束了");
panel.gameOver();
}
}
}
}).start();
}
僵尸吃和死亡动画
@Override
void dead() {
musicDead=new MusicPlayer("/music/dead.wav");
musicDead.play();
alive=false;
//moveFlag =false;//停止移动动画
action=3;//死亡动作
key=1;//key要重置
deadFlag = true;
//僵尸死亡动画
new Thread(new Runnable() {
@Override
public void run() {
while(deadFlag){
try {
Thread.sleep(80);
} catch (InterruptedException e) {
e.printStackTrace();
}
changeImage();//这个里面会处理僵尸消失
}
}
}).start();
}
@Override
void eat() {
//因为僵尸是向左移动的，判断僵尸的x 小于植物的 x+width 就表示要吃（同时还需要判断僵尸的屁股要大于植物的x，否则植物放到僵尸后面也被吃）
List plants = panel.plants;
Plant plant=null;
for (int i = 0; i < plants.size(); i++) {
plant = (Plant)plants.get(i);
if(x豌豆攻击
//击中
private void hit() {
//因为豌豆是向右飞行的，所以只需判断豌豆的 x_width 大于僵尸的x 就表示击中
List zombies = panel.zombies;
Zombie zombie=null;
for (int i = 0; i < zombies.size(); i++) {
zombie = (Zombie)zombies.get(i);
if(x+width>zombie.getX() && index==zombie.getIndex()){//同一行，且子弹的x+width大于僵尸的X坐标，判断我击中
//僵尸掉血
hitZombie(zombie);
}
}
}
private void hitZombie(Zombie zombie) {
musicHit=new MusicPlayer("/music/hit.wav");
musicHit.play();
//僵尸血量减少
int hp = zombie.getHp();
hp--;
zombie.setHp(hp);
if(hp==0){
//执行僵尸死亡动画
zombie.dead();
panel.curCount+=10;
/*if(panel.curCount>=panel.winCount){
panel.gameWin();
}*/
}
//子弹爆炸
boom();
}
//爆炸
private void boom() {
this.alive=false;
this.image=(BufferedImage)imageMap.get("7");
width=image.getWidth();
height=image.getHeight();
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//子弹消失
clear();
}
}).start();
}
//清除豌豆
void clear(){
this.alive=false;
panel.wandous.remove(this);
}创建阳光植物
阳光植物类
package main.plants;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import main.GamePanel;
public class SunPlant extends Plant {
private int x = 0;
private int y = 0;
private int width = 0;
private int height = 0;
private int index=0;
private int cost = 0;
private BufferedImage image = null;
private GamePanel panel=null;
private HashMap imageMap=null;
private int key=1;
private boolean alive=false;
private int hp=6;
private List zombies = new ArrayList();
private PlantsRect plantsRect=null;
public SunPlant(int x,int y,int width,int height,GamePanel panel) {
this.x=x;
this.y=y;
this.width=width;
this.height=height;
this.panel=panel;
this.imageMap=panel.sunPlantImageMap;
this.image=(BufferedImage)imageMap.get("("+key+")");
}
@Override
public void draw(Graphics g) {
g.drawImage(image, x, y, width,height, null);
}
@Override
void shoot() {
//Sun
new Thread(new Runnable() {
@Override
public void run() {
while(alive){
try {
//每6秒发射一个阳光
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(alive){//防止被吃了还能发射一次阳光
createSun();
}
}
}
private void createSun() {
Sun sun = new Sun(x+width/2-22, y-44, 45, 44, panel);
panel.suns.add(sun);
}
}).start();
}
//摇晃动画
@Override
void waggle() {
new Thread(new Runnable() {
@Override
public void run() {
while(alive){
changeImage();
try {
Thread.sleep(110);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
//更换图片
void changeImage(){
key++;
if(key>18){
key=1;
}
this.image=(BufferedImage)imageMap.get("("+key+")");
width = this.image.getWidth();
height = this.image.getHeight();
}
//种下植物
@Override
public void plant(PlantsRect rect) {
this.x=rect.getX()+10;
this.y=rect.getY()+12;
this.index=rect.getIndex();
this.alive=true;
plantsRect = rect;
//植物摇晃的动画
waggle();
shoot();//定时发射阳光
}
@Override
public void clear() {
alive=false;
//植物占的位置去除
if(plantsRect!=null){
plantsRect.setPlant(null);
plantsRect=null;
}
//移除植物
panel.plants.remove(this);
}
//添加僵尸对象，等植物吃完要通知每一个对象
@Override
public void addZombie(Zombie z) {
zombies.add(z);
}
//通知所有僵尸对象
@Override
public void noteZombie() {
Zombie zombie = null;
//执行通知
for (int i = 0; i < zombies.size(); i++) {
zombie = (Zombie)zombies.get(i);
zombie.noteZombie();
}
//通知完清除这个对象
zombies.clear();
}
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;
}
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
public boolean isAlive() {
return alive;
}
public void setAlive(boolean alive) {
this.alive = alive;
}
public int getCost() {
return cost;
}
public void setCost(int cost) {
this.cost = cost;
}
}
阳光类
package main.plants;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.HashMap;
import main.GamePanel;
import main.common.MusicPlayer;
public class Sun {
private int x = 0;
private int y = 0;
private int width = 0;
private int height = 0;
private BufferedImage image = null;
private GamePanel panel=null;
private HashMap imageMap=null;
private int key=1;
//是否存活
private boolean alive=true;
//向下移动的量
private boolean moveDownFlag = false;
private int moveDown = 0;
//正在向目标移动标示
private boolean moveTarget = false;
//向目标移动的x、y速度
private double mx=0;
private double my=0;
private int downMax = 100;//向下移动的距离
private int count=20;//收集一个得到的分数
MusicPlayer musicPoints=null;
MusicPlayer musicMoneyfalls=null;
public Sun(int x,int y,int width,int height,GamePanel panel) {
this.x=x;
this.y=y;
this.width=width;
this.height=height;
this.panel=panel;
this.imageMap=panel.sunImageMap;
this.image=(BufferedImage)imageMap.get("("+key+")");
//执行动画
waggle();
move();//默认向下移动
}
public void draw(Graphics g) {
g.drawImage(image, x, y, width,height, null);
}
//摇晃动画
void waggle() {
new Thread(new Runnable() {
@Override
public void run() {
while(alive){
changeImage();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
//更换图片
void changeImage(){
key++;
if(key>22){
key=1;
}
this.image=(BufferedImage)imageMap.get("("+key+")");
}
//移动
void move(){//往下移动100
moveDownFlag=true;
new Thread(new Runnable() {
int speed=4;
@Override
public void run() {
while(moveDownFlag){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
moveDown+=speed;
y+=speed;
//阳光静止10秒
if(moveDown>downMax){
moveDownFlag=false;
stop();
}
}
}
}).start();
}
//停止8秒
void stop(){//
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(8000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//阳光消失
clear();
}
}).start();
}
//阳光清除
void clear(){
this.alive=false;
panel.suns.remove(this);
}
//被点击
public void click(){
musicPoints=new MusicPlayer("/music/points.wav");
musicPoints.play();
//向左上角移动
int cx=20,
cy=20;//收集点的X\Y坐标
double angle = Math.atan2((y-cy), (x-cx)); //弧度
//计算出X\Y每一帧移动的距离
mx = Math.cos(angle)*20;
my = Math.sin(angle)*20;
moveTarget = true ;
moveDown=downMax+1;//设定不再向下运动
new Thread(new Runnable() {
@Override
public void run() {
while(moveTarget){
x-=mx;
y-=my;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//停止移动，到达目标位置
if(y<=20||x<=20){
musicMoneyfalls=new MusicPlayer("/music/moneyfalls.wav");
musicMoneyfalls.play();
moveTarget=false;
panel.sunCount+=count;
panel.cardCanUse();
clear();
}
}
}
}).start();
}
//检查坐标是否图形范围内
public boolean isPoint(int x,int y){
if(x>=this.x && y>=this.y && x<=this.x+this.width && y <= this.y + this.height){
return true;
}
return false;
}
public boolean isAlive() {
return alive;
}
public void setAlive(boolean alive) {
this.alive = alive;
}
public int getDownMax() {
return downMax;
}
public void setDownMax(int downMax) {
this.downMax = downMax;
}
}
给AD上课
//创建一大波僵尸 5秒后
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Random random = new Random();
int count = random.nextInt(30)+20;//随机数量的僵尸 20-50
for(int i=0;i代码目录
总结
代码下载