PVS实战02

搭建游戏架子

GameCotroller 游戏开始后的控制类
FightLine 把一行的操作 抽取出来 每一行可以添加僵尸 安放植物 僵尸攻击植物 植物攻击僵尸

游戏开始

 public void stratGame(CCTMXTiledMap map, List<ShowPlant> selectPlants){
    this.map = map;
    this.selectPlants = selectPlants;
    loadMap();
    // 添加僵尸

    // 定时器
    // 参数1 方法名(方法带float类型的参数) 参数2 调用方法的对象 参数3 间隔时间 参数4 是否暂停
    CCScheduler.sharedScheduler().schedule("addZombies", this, 1,false);
    // CCCallFunc.action(target, selector)
    // addZombies();

    // 安放植物
    // 僵尸攻击植物
    // 植物攻击僵尸
    progress();
}

解析地图

 private void loadMap() {
    roadPoints = CommonUtils.getMapPoints(map, "road");
    for (int i = 1; i <= 5; i++) {
        List<CGPoint> mapPoints = CommonUtils.getMapPoints(map,
                String.format("tower%02d", i));
        for (int j = 0; j < mapPoints.size(); j++) {
            towers[i - 1][j] = mapPoints.get(j);
        }
    }

}

安放植物

 //判断游戏是否已经开始 开始后就将
    if (GameCotroller.isStart){
        GameCotroller.getInstance().handleTouch(point);
        //返回  下面的逻辑不再执行
        return super.ccTouchesBegan(event);
    }

 public void handleTouch(CGPoint point) {
    //根据标签获得精灵
    CCSprite chose = (CCSprite) map.getParent().getChildByTag(
            FightLayer.TAG_CHOSE);
    //判断是否点击的是选择框
    if (CGRect.containsPoint(chose.getBoundingBox(),point)){
        //判断点击的是那个植物
        for (ShowPlant plant:selectPlants) {
            if (CGRect.containsPoint(plant.getShowSprite().getBoundingBox(),point)){
                // 玩家选择了植物
                selectPlant = plant;
                selectPlant.getShowSprite().setOpacity(150);
                //新建一个即将要安放的植物
                int id = selectPlant.getId();
                switch (id) {
                    case 1:
                        installPlant =new PeasePlant();
                        break;
                    case 4:
                        installPlant = new Nut();
                        break;
                    default:
                        break;
                }
            }

        }

    }else {//说明要安放植物了
        // 玩家有可能安放植物
        if (selectPlant != null) {
            int row = (int) (point.x / 46) - 1; // 1-9 0-8
            int line = (int) ((CCDirector.sharedDirector().getWinSize().height - point.y) / 54) - 1;// 1-5
            // 0-4
            // 限制安放的植物的范围
            if (row >= 0 && row <= 8 && line >= 0 && line <= 4) {

                // 安放植物
                // selectPlant.getShowSprite().setPosition(point);
                // installPlant.setPosition(point); // 坐标需要修改
                installPlant.setLine(line);// 设置植物的行号
                installPlant.setRow(row); // 设置植物的列号

                installPlant.setPosition(towers[line][row]); // 修正了植物的坐标
                FightLine fightLine = lines.get(line);
                if (!fightLine.containsRow(row)) {  // 判断当前列是否已经添加了植物 如果添加了 就不能再添加了
                    fightLine.addPlant(installPlant);// 把植物记录到了行战场中
                    map.addChild(installPlant);
                }
            }
            installPlant = null;
            selectPlant.getShowSprite().setOpacity(255);
            selectPlant = null;// 下次安装需要重新选择
        }

    }



}

对战的实现

package com.sdh.pvzhm.engine;
import com.sdh.pvzhm.bean.AttackPlant;
import com.sdh.pvzhm.bean.BaseElement;
import com.sdh.pvzhm.bean.Bullet;
import com.sdh.pvzhm.bean.Plant;
import com.sdh.pvzhm.bean.Zombies;
import org.cocos2d.actions.CCScheduler;
import org.cocos2d.types.CGPoint;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by hnedpc008 on 2016/9/18.
 */
public class FightLine {
    private int lineNum;

    public FightLine(int lineNum) {
        this.lineNum = lineNum;
        CCScheduler.sharedScheduler()
                .schedule("attackPlant", this, 0.2f, false);
        CCScheduler.sharedScheduler().schedule("createBullet", this, 0.2f,
                false);

        CCScheduler.sharedScheduler().schedule("attackZombies", this, 0.1f,
                false);
    }
    // 判断子弹和僵尸是否产生了碰撞
    public void attackZombies(float t){
        if (zombiesLists.size() > 0 && attackPlants.size() > 0) {
            for(Zombies zombies:zombiesLists){
                float x = zombies.getPosition().x;
                float left=x-20;
                float right=x+20;
                for(AttackPlant attackPlant:attackPlants){
                    List<Bullet> bullets = attackPlant.getBullets();
                    for(Bullet bullet:bullets){
                        float bulletX = bullet.getPosition().x;
                        if(bulletX>left&&bulletX<right){
                            //产生了碰撞
                            zombies.attacked(bullet.getAttack());// 僵尸被攻击, 参数 攻击力
//                          bullet.removeSelf()
                            bullet.setVisible(false);
                            bullet.setAttack(0);
                        }
                    }
                }

            }

        }


    }

    // 需要一直判断
    public void attackPlant(float t) {
        if (zombiesLists.size() > 0 && plants.size() > 0) { // 保证当前行上既有僵尸又有植物
            for (Zombies zombies : zombiesLists) {
                CGPoint position = zombies.getPosition();
                int row = (int) (position.x / 46 - 1); // 获取到僵尸所在的列
                Plant plant = plants.get(row);
                if (plant != null) {
                    zombies.attack(plant);
                }
            }
        }
    }

    public void createBullet(float t) {
        if (zombiesLists.size() > 0 && attackPlants.size() > 0) {
            // 创建子弹
            for (AttackPlant attackPlant : attackPlants) {
                attackPlant.createBullet();// 遍历所有攻击类型植物 创建子弹
            }
        }
    }

    private List<Zombies> zombiesLists = new ArrayList<Zombies>();
    private Map<Integer, Plant> plants = new HashMap<Integer, Plant>();// 管理添加的植物
    // key当前植物所对应的列号
    private List<AttackPlant> attackPlants = new ArrayList<AttackPlant>();

    public void addZombies(final Zombies zombies) {
        zombiesLists.add(zombies);
        zombies.setDieListener(new BaseElement.DieListener() {

            @Override
            public void die() {
                zombiesLists.remove(zombies);
            }
        });
    }

    public void addPlant(final Plant plant) {
        plants.put(plant.getRow(), plant);
        if (plant instanceof AttackPlant) { // 如果发现植物是一个攻击类型的植物,添加到攻击类型植物的集合中
            attackPlants.add((AttackPlant) plant);
        }

        plant.setDieListener(new BaseElement.DieListener() {

            @Override
            public void die() {
                plants.remove(plant.getRow());
                if (plant instanceof AttackPlant) {
                    attackPlants.remove((AttackPlant) plant);
                }
            }
        });

    }

    /**
     * 判断该列上 是否有植物
     *
     * @param row
     */
    public boolean containsRow(int row) {
        return plants.containsKey(row);
    }
}

---

package com.sdh.pvzhm.bean;

import com.sdh.pvzhm.com.sdh.utils.CommonUtils;

import org.cocos2d.actions.CCScheduler;
import org.cocos2d.actions.base.CCAction;
import org.cocos2d.actions.instant.CCCallFunc;
import org.cocos2d.actions.interval.CCMoveTo;
import org.cocos2d.actions.interval.CCSequence;
import org.cocos2d.types.CGPoint;
import org.cocos2d.types.util.CGPointUtil;

/**
 * Created by hnedpc008 on 2016/9/18.
 */
public class PrimaryZombies extends Zombies{
    public PrimaryZombies(CGPoint startPoint, CGPoint endPoint) {
        super("image/zombies/zombies_1/walk/z_1_01.png");
        this.startPoint = startPoint;
        this.endPoint = endPoint;

        setPosition(startPoint);
        move();
    }

    @Override
    public void move() {
        CCAction animate = CommonUtils.getAnimate(
                "image/zombies/zombies_1/walk/z_1_%02d.png", 7, true);
        this.runAction(animate);
        float t = CGPointUtil.distance(getPosition(), endPoint) / speed;
        CCMoveTo moveTo = CCMoveTo.action(t, endPoint);
        CCSequence sequence = CCSequence.actions(moveTo,
                CCCallFunc.action(this, "endGame"));
        this.runAction(sequence);
    }

    public void endGame() {
        this.destroy();
    }





    Plant targetPlant;// 要攻击的目标

    @Override
    public void attack(BaseElement element) {

        if (element instanceof Plant) {
            Plant plant = (Plant) element;
            if (targetPlant == null) {//如果已经锁定目标了 就不要再调用下面的方法了
                targetPlant = plant;// 锁定目标

                stopAllActions();
                // 切换成攻击模式
                CCAction animate = CommonUtils.getAnimate(
                        "image/zombies/zombies_1/attack/z_1_attack_%02d.png",
                        10, true);
                this.runAction(animate);
                //  让植物持续掉血
                CCScheduler.sharedScheduler().schedule("attackPlant", this, 0.5f, false);
            }
        }
    }
    public void attackPlant(float t){

        // 调用植物被攻击的方法
        targetPlant.attacked(attack);
        if(targetPlant.getLife()<0){
            targetPlant=null;// 解锁目标
            CCScheduler.sharedScheduler().unschedule("attackPlant", this);//移除定时任务
            stopAllActions();
            move();// 继续前进
        }
    }

    @Override
    public void attacked(int attack) {
        life-=attack;
        if(life<0){
            destroy();
        }
    }

    @Override
    public void baseAction() {
        // TODO Auto-generated method stub

    }

}