C++游戏项目《植物大战僵尸》可用于毕业设计，找工作，学习等用途

C++游戏项目《植物大战僵尸》可用于毕业设计，找工作，学习等用途

本人原创，自己当时毕业找工作时历时一个多月独自编写的，全网独一份，也特别适用于毕业设计，绝对与别人的不一样，因为本人亲自编写，没有特别复杂的功能，老师或者面试官一看就是独自原创的。编写不易，请珍惜！

项目描述：
一款益智策略类游戏，实现了原版植物大战僵尸中的第一大关的基本功能，即种植多种植物，将僵尸阻挡在入侵的道路上；僵尸攻击植物，阳光的产生，子弹的移动，僵尸的跳跃，以及多种僵尸与植物之间类的复杂关系的处理等功能。
项目中有清晰地UML类图，可以打印出来，以便给老师等人讲解。

应用技术：
MFC单文档视图，Windows SDK，STL，多态，CxImage显示动态图，双缓冲绘图。

**

下面为整体逻辑的部分代码，获取完整源码，请通过底部的下载链接下载

**

// ZombiesOnTheLawnView.cpp : CZombiesOnTheLawnView 类的实现
//

#include "stdafx.h"
// SHARED_HANDLERS 可以在实现预览、缩略图和搜索筛选器句柄的
// ATL 项目中进行定义，并允许与该项目共享文档代码。
#ifndef SHARED_HANDLERS
#include "ZombiesOnTheLawn.h"
#endif

#include "ZombiesOnTheLawnDoc.h"
#include "ZombiesOnTheLawnView.h"

#include "CmnWaitZombie1.h"
#include "CmnWaitZombie2.h"
#include "CmnWaitZombie3.h"
#include "JmpWaitZombie.h"
#include "RgyWaitZombie.h"

#include "CmnZombieAdvance1.h"
#include "CmnZombieAdvance2.h"
#include "CmnZombieAdvance3.h"
#include "JmpZombieAdvance.h"
#include "RgyZombieAdvance.h"

#include "SunFlower.h"
#include "Cactus.h"
#include "HighNut.h"
#include "EatZmePlt.h"
#include "DouBan.h"
#include "BombBerry.h"

#include "BombGunner.h"
#include "CmnDieZme.h"
#include "RgyDieZme.h"
#include "JmpDieZme.h"

#include "Sys.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CZombiesOnTheLawnView

IMPLEMENT_DYNCREATE(CZombiesOnTheLawnView, CView)

BEGIN_MESSAGE_MAP(CZombiesOnTheLawnView, CView)
	// 标准打印命令
	ON_COMMAND(ID_FILE_PRINT, &CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, &CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, &CView::OnFilePrintPreview)
	ON_WM_TIMER()
	ON_WM_ERASEBKGND()
	ON_COMMAND(ID_32774, &CZombiesOnTheLawnView::OnCreateGame)
	ON_WM_DESTROY()
	ON_WM_LBUTTONDOWN()
END_MESSAGE_MAP()

// CZombiesOnTheLawnView 构造/析构

CZombiesOnTheLawnView::CZombiesOnTheLawnView()
{
	// TODO: 在此处添加构造代码
	bStartfalg = true;
	bPltSltArea = false;
	bShowCar = false;
	IsCursorPlt = false;
	IsHit = false;

	n = 0;
	AdeCarNum = 0;

	nCmnZmeNum = 6;
	nJmpZmeNum = 2;
	nRgyZmeNum = 3;
	//初始化m_lst_SeedPos链表
	InitSeedPos();
	//初始化ArrZmeNum[]
	for(int i = 0;i < 5;i++)
	{
		ArrZmeNum[i] = 0;
	}
}

CZombiesOnTheLawnView::~CZombiesOnTheLawnView()
{
}

BOOL CZombiesOnTheLawnView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: 在此处通过修改
	//  CREATESTRUCT cs 来修改窗口类或样式

	//初始化游戏
	m_hInstance = cs.hInstance;
	back.InitBack(m_hInstance);
	PltSltArea.InitPltSltArea();
  
	return CView::PreCreateWindow(cs);
}
// CZombiesOnTheLawnView 打印

BOOL CZombiesOnTheLawnView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// 默认准备
	return DoPreparePrinting(pInfo);
}

void CZombiesOnTheLawnView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: 添加额外的打印前进行的初始化过程
}

void CZombiesOnTheLawnView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: 添加打印后进行的清理过程
}

// CZombiesOnTheLawnView 诊断

#ifdef _DEBUG
void CZombiesOnTheLawnView::AssertValid() const
{
	CView::AssertValid();
}

void CZombiesOnTheLawnView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CZombiesOnTheLawnDoc* CZombiesOnTheLawnView::GetDocument() const // 非调试版本是内联的
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CZombiesOnTheLawnDoc)));
	return (CZombiesOnTheLawnDoc*)m_pDocument;
}
#endif //_DEBUG

BOOL CZombiesOnTheLawnView::OnEraseBkgnd(CDC* pDC)
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值
	return true;
	return CView::OnEraseBkgnd(pDC);
}
// CZombiesOnTheLawnView 绘制

void CZombiesOnTheLawnView::OnDraw(CDC* pDC)
{
	CZombiesOnTheLawnDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	if (!pDoc)
		return;
	
	// TODO: 在此处为本机数据添加绘制代码
	CDC hMemDC;
	hMemDC.CreateCompatibleDC(pDC);
	
	//创建一个兼容性位图bitmap（因为所有的贴图以及对图片的操作都是建立在位图上的）
	CBitmap MemBitmap;
	MemBitmap.CreateCompatibleBitmap(pDC,1400,600);
	//把图片放到兼容性 DC 里
	hMemDC.SelectObject(&MemBitmap);
	
	//-----------------------
	//显示背景
	back.ShowBack(&hMemDC);
	//显示植物选择区
	if(bPltSltArea)	
	{
		PltSltArea.ShowPltSltArea(&hMemDC);
	}

	//显示所有攻击植物
	ShowAllAtkPlt(&hMemDC);
	
	//显示光标植物
	if(IsCursorPlt)
		ShowCursorPlt(&hMemDC);
	//显示所有炮弹
	ShowAllGunner(&hMemDC);
	//显示所有僵尸
	ShowAllZme(&hMemDC);
	//显示爆炸炮弹
	ShowBombGnr(&hMemDC);
	//显示死亡僵尸
	ShowDieZme(&hMemDC);
	//显示所有太阳
	ShowAllSun(&hMemDC);
	//显示小车
	if(bShowCar)
		ShowCar(&hMemDC);
	//-----------------------
	
	//兼容性DC里的图片传到窗口DC里
	pDC->BitBlt(0,0,1400,600,&hMemDC,0,0,SRCCOPY);

	//删除资源
	MemBitmap.DeleteObject();
	hMemDC.DeleteDC();
}

// CZombiesOnTheLawnView 消息处理程序
void CZombiesOnTheLawnView::InitSeedPos()
{
	SeedPosNode* pSeedPos = NULL;
	for(int i = 0;i < 5;i++)
	{
		for(int j = 0;j < 9;j++)
		{
			pSeedPos = new SeedPosNode;
			pSeedPos->x = 35 + 80*j;
			pSeedPos->y = 87 + 97*i;
			pSeedPos->SeedID = i*9+(j+1);
			pSeedPos->IsSeed = true;
			m_lst_SeedPos.push_back(pSeedPos);
		}
	}
}

void CZombiesOnTheLawnView::OnCreateGame()
{
	if(bStartfalg)
	{
		// TODO: 在此添加命令处理程序代码
		//随机数
		srand((unsigned int)time(NULL));
		//创建普通等待僵尸
		CreateCmnWaitZme();
		//创建跳高等待僵尸
		CreateJmpWaitZme();
		//创建橄榄球等待僵尸
		CreateRgyWaitZme();

		//创建小车
		CreateCar();
		//背景移动的定时器
		::SetTimer(this->m_hWnd,BACK_LMOVE_TIMER＿ID,1,NULL);
		//僵尸前进的定时器
		::SetTimer(this->m_hWnd,ZOMBIE_ADVANCE,100,NULL);
		//30秒之后创建第一波僵尸前进的定时器
		::SetTimer(this->m_hWnd,CREATE_FIRST_ADEZME,15000/*15000*/,NULL);
		//40秒之后创建第二波僵尸前进的定时器
		::SetTimer(this->m_hWnd,CREATE_SECOND_ADEZME,40000/*30000*/,NULL);
		//100秒之后创建第三波僵尸前进的定时器
		::SetTimer(this->m_hWnd,CREATE_THIRD_ADEZME,100000/*100000*/,NULL);

		//僵尸等待GIF图片的ID加加
		::SetTimer(this->m_hWnd,ZMEWAIT_GIFID_ADD,60,NULL);
		//僵尸前进GIF图片的ID加加
		::SetTimer(this->m_hWnd,ZMEADE_GIFID_ADD,80,NULL);
		//植物GIF图片的ID加加
		::SetTimer(this->m_hWnd,PLT_GIFID_ADD,80,NULL);
		//阳光GIF图片的ID加加
		::SetTimer(this->m_hWnd,SUN_GIFID_ADD,80,NULL);
		//死亡僵尸GIF图片的ID加加
		::SetTimer(this->m_hWnd,DIEZME_GIFID_ADD,80,NULL);

		//发射炮弹的定时器
		::SetTimer(this->m_hWnd,SEND_GUNNER,2000,NULL);
		//炮弹移动的定时器
		::SetTimer(this->m_hWnd,GUNNER_MOVE,1,NULL);
		
		//系统产生阳光的定时器(12s产生25阳光)
		::SetTimer(this->m_hWnd,SYS_PRODUCT_SUN,12000,NULL);

		//向日葵产生阳光的定时器（7s产生25阳光）
		::SetTimer(this->m_hWnd,SUNFLOWER_PRODUCTSUN_TIMEADE,1000,NULL);

		//阳光下落的定时器
		::SetTimer(this->m_hWnd,SUN_FALL_MOVE,1,NULL);
		//阳光收集移动的定时器
		::SetTimer(this->m_hWnd,SUN_COLLLECT_MOVE,5,NULL);
		//植物掉血的定时器
		::SetTimer(this->m_hWnd,PLT_ZME_DOWN_BLOOD,1000,NULL);
		//删除爆炸炮弹的定时器
		::SetTimer(this->m_hWnd,DEL_BOMB_GNR,150,NULL);
		//删除死亡僵尸的定时器
		::SetTimer(this->m_hWnd,DEL_DIE_ZME,8000,NULL);

		//小车前进的定时器
		::SetTimer(this->m_hWnd,CAR_ADE,1,NULL);
		bStartfalg = !bStartfalg;
	}
}
void CZombiesOnTheLawnView::OnTimer(UINT_PTR nIDEvent)
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值
	switch(nIDEvent)
	{
	case BACK_LMOVE_TIMER＿ID:
		BackAndZmeLMove();
		Invalidate(FALSE);
		break;
	case BACK_RMOVE_TIMER＿ID:
		BackAndZmeRMove();
		Invalidate(FALSE);
		break;
	case ZOMBIE_ADVANCE:
		AllZmeAde();
		if(AdeCarNum < 5)
		{
			//僵尸触发小车前进
			CarStartAde();
		}
		//判断僵尸是否侵入房间（游戏结束）
		if(IsGameOver())
		{
			KillAllTimer();
			::MessageBox(NULL,"Game Over!!!","提示",MB_OK);
		}
		break;
	case CREATE_FIRST_ADEZME:
		CreateFrtAdeZme();
		KillTimer(CREATE_FIRST_ADEZME);
		break;
	case CREATE_SECOND_ADEZME:
		CreateScdAdeZme();
		KillTimer(CREATE_SECOND_ADEZME);
		break;
	case CREATE_THIRD_ADEZME:
		CreateTrdAdeZme();
		KillTimer(CREATE_THIRD_ADEZME); 
		::SetTimer(this->m_hWnd,IS_WIN,1000,NULL);
		break;
	case ZMEWAIT_GIFID_ADD:
		ZmeWaitGIFIDAdd();
		break;
	case ZMEADE_GIFID_ADD:
		ZmeAdeGIFIDAdd();
		break;
	case PLT_GIFID_ADD:
		PltGIFIDAdd();
		break;
	case SUN_GIFID_ADD:
		SunGIFIDAdd();
		break;
	case DIEZME_GIFID_ADD:
		DieZmeGIFIDAdd();
		break;
	case SEND_GUNNER:
		SendAllGunner();
		break;
	case GUNNER_MOVE:
		AllGunnerMove();
		break;
	case SYS_PRODUCT_SUN:
		SysProductSun();
		Invalidate(FALSE);
		break;
	case SUNFLOWER_PRODUCTSUN_TIMEADE:
		FwrPdtSunTimeAde();
		Invalidate(FALSE);
	case SUN_FALL_MOVE:
		SunFallMove();
		break;
	case SUN_COLLLECT_MOVE:
		SunCollectMove();
		break;
	case PLT_ZME_DOWN_BLOOD:
		PltAndZmeDownBlood();
		break;
	case DEL_BOMB_GNR:
		DelBombGnr();
		break;
	case DEL_DIE_ZME:
		DelDieZme();
		break;
	case CAR_ADE:
		CarAde();
		break;
	case IS_WIN:
		if(IsWin())
		{
			KillAllTimer();
			::MessageBox(NULL,"胜利了!!!","提示",MB_OK);
		}
		break;
	}
	CView::OnTimer(nIDEvent);
}

void CZombiesOnTheLawnView::SysProductSun()
{
	CSun* pSun = new CSun;

	int x = 20 + rand()%682;

	pSun->SunFallPos = 97*(rand()%5) + 87;

	pSun->InitSun(x,15);

	m_lst_Sun.push_back(pSun);
}
void CZombiesOnTheLawnView::FwrPdtSunTimeAde()
{
	list<CAttackPlt*>::iterator ite_AtkPlt = m_lst_AttackPlt.begin();
	while(ite_AtkPlt != m_lst_AttackPlt.end())
	{
		if((*ite_AtkPlt)->PltStyle == SunFlower)
		{
			if(((CSunFlower*)(*ite_AtkPlt))->FwrPdtSunTime++ >= 7) // 7s 产生一个太阳
			{
				FwrProductSun(((CSunFlower*)(*ite_AtkPlt))->X,((CSunFlower*)(*ite_AtkPlt))->Y);
				((CSunFlower*)(*ite_AtkPlt))->FwrPdtSunTime = 0;
			}
		}
		ite_AtkPlt++;
	}
}
void CZombiesOnTheLawnView::FwrProductSun(int x,int y)
{
	CSun* pSun = new CSun;
	pSun->SunFallPos = y + 40;
	pSun->InitSun(x-20,y);
	m_lst_Sun.push_back(pSun);
}
void CZombiesOnTheLawnView::CreateCar()
{
	CCar* pCar = NULL;
	for(int i = 0;i < 5;i++)
	{
		pCar = new CCar;
		pCar->InitCar(i);
		m_lst_Car.push_back(pCar);
	}
}

void CZombiesOnTheLawnView::CreateCmnWaitZme()
{
	//随机数
	int Num = rand()%(nCmnZmeNum+1);
	CCommonZombie* pCmnZme = NULL;
	//第一种普通等待僵尸
	for(int i = 0;i < Num;i++)
	{
		pCmnZme = new CCmnWaitZombie1;
		pCmnZme->InitZombie();
		m_lst_CmnWaitZme.push_back(pCmnZme);
	}
	nCmnZmeNum -= Num;
	if(nCmnZmeNum != 0)
	{
		Num = rand()%(nCmnZmeNum+1);
		//第二种普通等待僵尸
		for(int i = 0;i < Num;i++)
		{
			pCmnZme = new CCmnWaitZombie2;
			pCmnZme->InitZombie();
			m_lst_CmnWaitZme.push_back(pCmnZme);
		}
		nCmnZmeNum -= Num;
		if(nCmnZmeNum != 0)
		{
			//第三种普通等待僵尸
			for(int i = 0;i < nCmnZmeNum;i++)
			{
				pCmnZme = new CCmnWaitZombie3;
				pCmnZme->InitZombie();
				m_lst_CmnWaitZme.push_back(pCmnZme);
			}
		}
	}
	nCmnZmeNum = 5;
}
void CZombiesOnTheLawnView::CreateJmpWaitZme()
{
	CJumpZombie* pJmpZme = NULL;
	for(int i = 0;i < nJmpZmeNum;i++)
	{
		pJmpZme = new CJmpWaitZombie;
		pJmpZme->InitZombie();
		m_lst_JmpWaitZme.push_back(pJmpZme);
	}
}
void CZombiesOnTheLawnView::CreateRgyWaitZme()
{
	CRugbyZombie* pRgyZme = NULL;
	for(int i = 0;i < nRgyZmeNum;i++)
	{
		pRgyZme = new CRgyWaitZombie;
		pRgyZme->InitZombie();
		m_lst_RgyWaitZme.push_back(pRgyZme);
	}
}

void CZombiesOnTheLawnView::CreateCmnAdeZme(char eZmeType)
{
	CCommonZombie* pCmnZme = NULL;
	switch (eZmeType)
	{
	case CmnWat1:
		pCmnZme = new CCmnZombieAdvance1;
		break;
	case CmnWat2:
		pCmnZme = new CCmnZombieAdvance2;
		break;
	case CmnWat3:
		pCmnZme = new CCmnZombieAdvance3;
		break;
	}
	pCmnZme->InitZombie();
	m_lst_CmnAdeZme.push_back(pCmnZme);
	//对应的道上的僵尸的数目加1
	ArrZmeNum[pCmnZme->RoadID]++;
}
void CZombiesOnTheLawnView::CreateJmpAdeZme(char eZmeType)
{
	CJumpZombie* pJmpZme = new CJmpZombieAdvance;
	pJmpZme->InitZombie();
	m_lst_JmpAdeZme.push_back(pJmpZme);
	//对应的道上的僵尸的数目加1
	ArrZmeNum[pJmpZme->RoadID]++;
}
void CZombiesOnTheLawnView::CreateRgyAdeZme(char eZmeType)
{
	CRugbyZombie* pRgyZme = new CRgyZombieAdvance;
	pRgyZme->InitZombie();
	m_lst_RgyAdeZme.push_back(pRgyZme);
	//对应的道上的僵尸的数目加1
	ArrZmeNum[pRgyZme->RoadID]++;
}

void CZombiesOnTheLawnView::CreateFrtAdeZme()
{
	//一个普通僵尸
	for(int i = 0;i < 1;i++)
	{
		list<CCommonZombie*>::iterator m_ite = m_lst_CmnWaitZme.begin();
		if(m_ite != m_lst_CmnWaitZme.end())
		{
			//创建前进僵尸
			CreateCmnAdeZme((*m_ite)->eZmeType);
			delete(*m_ite);
			m_lst_CmnWaitZme.pop_front();
			nCmnZmeNum -= 1;
		}
		Invalidate(FALSE);
	}
}
void CZombiesOnTheLawnView::CreateScdAdeZme()
{
	//2个普通僵尸
	for(int i = 0;i < 2;i++)
	{
		list<CCommonZombie*>::iterator m_ite = m_lst_CmnWaitZme.begin();
		if(m_ite != m_lst_CmnWaitZme.end())
		{
			//创建前进僵尸
			CreateCmnAdeZme((*m_ite)->eZmeType);
			delete(*m_ite);
			m_lst_CmnWaitZme.pop_front();
			nCmnZmeNum--;
		}
		Invalidate(FALSE);
	}
	//1个橄榄球僵尸
	for(int i = 0;i < 1;i++)
	{
		list<CRugbyZombie*>::iterator m_ite = m_lst_RgyWaitZme.begin();
		if(m_ite != m_lst_RgyWaitZme.end())
		{
			//创建前进僵尸
			CreateRgyAdeZme((*m_ite)->eZmeType);
			delete(*m_ite);
			m_lst_RgyWaitZme.pop_front();
			nRgyZmeNum--;
		}
		Invalidate(FALSE);
	}
}
void CZombiesOnTheLawnView::CreateTrdAdeZme()
{
	//3个普通僵尸
	for(int i = 0;i < 3;i++)
	{
		list<CCommonZombie*>::iterator m_ite = m_lst_CmnWaitZme.begin();
		if(m_ite != m_lst_CmnWaitZme.end())
		{
			//创建前进僵尸
			CreateCmnAdeZme((*m_ite)->eZmeType);
			delete(*m_ite);
			m_lst_CmnWaitZme.pop_front();
			nCmnZmeNum--;
		}
		Invalidate(FALSE);
	}
	//2个橄榄球僵尸
	for(int i = 0;i < 2;i++)
	{
		list<CRugbyZombie*>::iterator m_ite = m_lst_RgyWaitZme.begin();
		if(m_ite != m_lst_RgyWaitZme.end())
		{
			//创建前进僵尸
			CreateRgyAdeZme((*m_ite)->eZmeType);
			delete(*m_ite);
			m_lst_RgyWaitZme.pop_front();
			nRgyZmeNum--;
		}
		Invalidate(FALSE);
	}
	//2个跳高僵尸
	for(int i = 0;i < 2;i++)
	{
		list<CJumpZombie*>::iterator m_ite = m_lst_JmpWaitZme.begin();
		if(m_ite != m_lst_JmpWaitZme.end())
		{
			//创建前进僵尸
			CreateJmpAdeZme((*m_ite)->eZmeType);
			delete(*m_ite);
			m_lst_JmpWaitZme.pop_front();
			nJmpZmeNum--;
		}
		Invalidate(FALSE);
	}
}

//发射炮弹
void CZombiesOnTheLawnView::SendAllGunner()
{
	list<CAttackPlt*>::iterator ite_AtkPlt = m_lst_AttackPlt.begin();
	while(ite_AtkPlt != m_lst_AttackPlt.end())
	{
		//判断这条道上是否有僵尸
		if(ArrZmeNum[(*ite_AtkPlt)->RoadID] >= 1)
		{
			if((*ite_AtkPlt)->PltStyle != EatZmePlt)
				(*ite_AtkPlt)->SendGunner(m_lst_Gunner,(*ite_AtkPlt)->RoadID);
		}
		ite_AtkPlt++;
		Invalidate(FALSE);
	}
}
//种植植物
void CZombiesOnTheLawnView::SeedPlant(SeedPosNode* m_Seed)
{
	//80*97
		//在当前块种植物
		CAttackPlt* pAtkPlt = NULL;
		switch((*ite_CsrCrd)->PltStl)
		{
		case SunFlower:
			pAtkPlt = new  CSunFlower;
			pAtkPlt->InitPlant(m_Seed->x,m_Seed->y,m_Seed->SeedID);
			break;
		case Cactus:
			pAtkPlt = new  CCactus;
			pAtkPlt->InitPlant(m_Seed->x,m_Seed->y,m_Seed->SeedID);
			break;
		case DouBan:
			pAtkPlt = new  CDouBan;
			pAtkPlt->InitPlant(m_Seed->x,m_Seed->y,m_Seed->SeedID);
			break;
		case HighNut:
			pAtkPlt = new  CHighNut;
			pAtkPlt->InitPlant(m_Seed->x,m_Seed->y,m_Seed->SeedID);
			break;
		case EatZmePlt:
			pAtkPlt = new  CEatZmePlt;
			pAtkPlt->InitPlant(m_Seed->x,m_Seed->y,m_Seed->SeedID);
			break;
		case BombBerry:
			pAtkPlt = new  CBombBerry;
			pAtkPlt->InitPlant(m_Seed->x,m_Seed->y,m_Seed->SeedID);
			((CBombBerry*)pAtkPlt)->BombZme(m_lst_CmnAdeZme,m_lst_JmpAdeZme,m_lst_RgyAdeZme);
		}
		m_lst_AttackPlt.push_back(pAtkPlt);
		IsCursorPlt = false;
		m_Seed->IsSeed = false;
}


void CZombiesOnTheLawnView::ZmeWaitGIFIDAdd()
{
	//普通僵尸等待
	list<CCommonZombie*>::iterator ite_CmnZme = m_lst_CmnWaitZme.begin();
	while(ite_CmnZme != m_lst_CmnWaitZme.end())
	{
		(*ite_CmnZme)->nZmeBmpID++;
		if((*ite_CmnZme)->nZmeBmpID >= (*ite_CmnZme)->nZmeBmpNum)
		{
			(*ite_CmnZme)->nZmeBmpID = 0;
		}
		ite_CmnZme++;
		Invalidate(FALSE);
	}
	//跳高僵尸等待
	list<CJumpZombie*>::iterator ite_JmpZme = m_lst_JmpWaitZme.begin();
	while(ite_JmpZme != m_lst_JmpWaitZme.end())
	{
		(*ite_JmpZme)->nZmeBmpID++;
		if((*ite_JmpZme)->nZmeBmpID >= (*ite_JmpZme)->nZmeBmpNum)
		{
			(*ite_JmpZme)->nZmeBmpID = 0;
		}
		ite_JmpZme++;
		Invalidate(FALSE);
	}
	//橄榄球僵尸等待
	list<CRugbyZombie*>::iterator ite_RgyZme = m_lst_RgyWaitZme.begin();
	while(ite_RgyZme != m_lst_RgyWaitZme.end())
	{
		(*ite_RgyZme)->nZmeBmpID++;
		if((*ite_RgyZme)->nZmeBmpID >= (*ite_RgyZme)->nZmeBmpNum)
		{
			(*ite_RgyZme)->nZmeBmpID = 0;
		}
		ite_RgyZme++;
		Invalidate(FALSE);
	}
}
void CZombiesOnTheLawnView::ZmeAdeGIFIDAdd()
{
	//普通僵尸前进
	list<CCommonZombie*>::iterator ite_CmnZmeAde = m_lst_CmnAdeZme.begin();
	while(ite_CmnZmeAde != m_lst_CmnAdeZme.end())
	{
		if((*ite_CmnZmeAde)->IsBomb)
		{
			(*ite_CmnZmeAde)->nZmeBombBmpID++;
			if((*ite_CmnZmeAde)->nZmeBombBmpID >= (*ite_CmnZmeAde)->nZmeBombBmpNum)
			{
				//删除该僵尸
				delete *ite_CmnZmeAde;
				ite_CmnZmeAde = m_lst_CmnAdeZme.erase(ite_CmnZmeAde);
				Invalidate(FALSE);
				continue;
			}
		}else
		{
			if(!(*ite_CmnZmeAde)->IsEating)
			{
				(*ite_CmnZmeAde)->nZmeBmpID++;
				if((*ite_CmnZmeAde)->nZmeBmpID >= (*ite_CmnZmeAde)->nZmeBmpNum)
				{
					(*ite_CmnZmeAde)->nZmeBmpID = 0;
				}
			}else
			{
				(*ite_CmnZmeAde)->nZmeEatBmpID++;
				if((*ite_CmnZmeAde)->nZmeEatBmpID >= (*ite_CmnZmeAde)->nZmeEatBmpNum)
				{
					(*ite_CmnZmeAde)->nZmeEatBmpID = 0;
				}
			}
		}
		ite_CmnZmeAde++;
		Invalidate(FALSE);
	}
	//跳高僵尸前进
	list<CJumpZombie*>::iterator ite_JmpZmeAde = m_lst_JmpAdeZme.begin();
	while(ite_JmpZmeAde != m_lst_JmpAdeZme.end())
	{
		if((*ite_JmpZmeAde)->IsBomb)
		{
			(*ite_JmpZmeAde)->nZmeBombBmpID++;
			if((*ite_JmpZmeAde)->nZmeBombBmpID >= (*ite_JmpZmeAde)->nZmeBombBmpNum)
			{
				//删除该僵尸
				delete *ite_JmpZmeAde;
				ite_JmpZmeAde = m_lst_JmpAdeZme.erase(ite_JmpZmeAde);
				Invalidate(FALSE);
				continue;
			}
		}else
		{
			if(!(*ite_JmpZmeAde)->IsEating)
			{
				if((*ite_JmpZmeAde)->IsJmp)
				{
					(*ite_JmpZmeAde)->nZmeBmpID++;
					if((*ite_JmpZmeAde)->nZmeBmpID >= (*ite_JmpZmeAde)->nZmeBmpNum)
					{
						(*ite_JmpZmeAde)->nZmeBmpID = 0;
					}
				}else
				{
					(*ite_JmpZmeAde)->nZmeNoStkID++;
					if((*ite_JmpZmeAde)->nZmeNoStkID >= (*ite_JmpZmeAde)->nZmeNoStkNum)
					{
						(*ite_JmpZmeAde)->nZmeNoStkID = 0;
					}
				}
			}else
			{
				if(!(*ite_JmpZmeAde)->IsJmp)
				{
					(*ite_JmpZmeAde)->nZmeEatBmpID++;
					if((*ite_JmpZmeAde)->nZmeEatBmpID >= (*ite_JmpZmeAde)->nZmeEatBmpNum)
					{
						(*ite_JmpZmeAde)->nZmeEatBmpID = 0;
					}
				}else
				{
					(*ite_JmpZmeAde)->nZmeJmpingID++;
					if((*ite_JmpZmeAde)->nZmeJmpingID == 10)
						(*ite_JmpZmeAde)->X -= 125;
					if((*ite_JmpZmeAde)->nZmeJmpingID >= (*ite_JmpZmeAde)->nZmeJmpingNum)
					{
						(*ite_JmpZmeAde)->IsJmp = false;
						(*ite_JmpZmeAde)->IsEating = false;
						(*ite_JmpZmeAde)->IsHaveStk = false;
					}
				}
			}
		}
		ite_JmpZmeAde++;
		Invalidate(FALSE);
	}
	//橄榄球僵尸前进
	list<CRugbyZombie*>::iterator ite_RgyZmeAde = m_lst_RgyAdeZme.begin();
	while(ite_RgyZmeAde != m_lst_RgyAdeZme.end())
	{
		if((*ite_RgyZmeAde)->IsBomb)
		{
			(*ite_RgyZmeAde)->nZmeBombBmpID++;
			if((*ite_RgyZmeAde)->nZmeBombBmpID >= (*ite_RgyZmeAde)->nZmeBombBmpNum)
			{
				//删除该僵尸
				delete *ite_RgyZmeAde;
				ite_RgyZmeAde = m_lst_RgyAdeZme.erase(ite_RgyZmeAde);
				Invalidate(FALSE);
				continue;
			}
		}else
		{
			if(!(*ite_RgyZmeAde)->IsEating)
			{
				if((*ite_RgyZmeAde)->blood >= 4)
				{
					(*ite_RgyZmeAde)->nZmeBmpID++;
					if((*ite_RgyZmeAde)->nZmeBmpID >= (*ite_RgyZmeAde)->nZmeBmpNum)
					{
						(*ite_RgyZmeAde)->nZmeBmpID = 0;
					}
				}else
				{
					(*ite_RgyZmeAde)->nZmeNoHatAdeID++;
					if((*ite_RgyZmeAde)->nZmeNoHatAdeID >= (*ite_RgyZmeAde)->nZmeNoHatAdeNum)
					{
						(*ite_RgyZmeAde)->nZmeNoHatAdeID = 0;
					}
				}
			}else
			{
				if((*ite_RgyZmeAde)->blood >= 4)
				{
					(*ite_RgyZmeAde)->nZmeEatBmpID++;
					if((*ite_RgyZmeAde)->nZmeEatBmpID >= (*ite_RgyZmeAde)->nZmeEatBmpNum)
					{
						(*ite_RgyZmeAde)->nZmeEatBmpID = 0;
					}
				}else
				{
					(*ite_RgyZmeAde)->nZmeNoHatEatID++;
					if((*ite_RgyZmeAde)->nZmeNoHatEatID >= (*ite_RgyZmeAde)->nZmeNoHatEatNum)
					{
						(*ite_RgyZmeAde)->nZmeNoHatEatID = 0;
					}
				}
			}
		}
		ite_RgyZmeAde++;
		Invalidate(FALSE);
	}
}
void CZombiesOnTheLawnView::PltGIFIDAdd()
{
	//植物显示
	list<CAttackPlt*>::iterator ite_AtkPlt = m_lst_AttackPlt.begin();
	while(ite_AtkPlt != m_lst_AttackPlt.end())
	{
		if((*ite_AtkPlt)->PltStyle != EatZmePlt)
		{
			if((*ite_AtkPlt)->PltStyle == BombBerry)
			{

				(*ite_AtkPlt)->nPltBmpID++;
				if((*ite_AtkPlt)->nPltBmpID >= (*ite_AtkPlt)->nPltBmpNum)
				{
					//所在的位置可以再次种植
					CanAgainSeed(*ite_AtkPlt);
					//删除草莓
					delete *ite_AtkPlt;
					ite_AtkPlt = m_lst_AttackPlt.erase(ite_AtkPlt);
					Invalidate(FALSE);
					continue;
				} 
			}else
			{
				(*ite_AtkPlt)->nPltBmpID++;
				if((*ite_AtkPlt)->nPltBmpID >= (*ite_AtkPlt)->nPltBmpNum)
				{
					(*ite_AtkPlt)->nPltBmpID = 0;
				} 
			}
		}else
		{
			if(((CEatZmePlt*)(*ite_AtkPlt))->IsStartAttack)
			{
				((CEatZmePlt*)(*ite_AtkPlt))->nEatPltBmpID++;
				if(((CEatZmePlt*)(*ite_AtkPlt))->nEatPltBmpID >= ((CEatZmePlt*)(*ite_AtkPlt))->nEatPltBmpNum)
				{
					((CEatZmePlt*)(*ite_AtkPlt))->nEatPltBmpID = 10;
				} 
			}else
			{
				(*ite_AtkPlt)->nPltBmpID++;
				if((*ite_AtkPlt)->nPltBmpID >= (*ite_AtkPlt)->nPltBmpNum)
				{
					(*ite_AtkPlt)->nPltBmpID = 0;
				} 
			}
		}
		ite_AtkPlt++;
		Invalidate(FALSE);
	}
}
void CZombiesOnTheLawnView::SunGIFIDAdd()
{
	list<CSun*>::iterator ite_Sun = m_lst_Sun.begin();
	while(ite_Sun != m_lst_Sun.end())
	{
		(*ite_Sun)->nSunID++;
		if((*ite_Sun)->nSunID >= (*ite_Sun)->nFramesCount)
		{
			(*ite_Sun)->nSunID = 0;
		}
		ite_Sun++;
		Invalidate(FALSE);
	}
}
void CZombiesOnTheLawnView::DieZmeGIFIDAdd()
{
	list<CDieZombie*>::iterator ite_DieZme = m_lst_DieZme.begin();
	while(ite_DieZme != m_lst_DieZme.end())
	{
		//头掉落
		if((*ite_DieZme)->nZmeHeadBmpID < (*ite_DieZme)->nZmeHeadBmpNum-1)
			(*ite_DieZme)->nZmeHeadBmpID++;
		else
			(*ite_DieZme)->IsShowHead = false;

		//僵尸无头前进的身体
		if(((*ite_DieZme)->nZmeNoHeadAdeID < (*ite_DieZme)->nZmeNoHeadAdeNum-1)&&(!(*ite_DieZme)->IsHitPlt))
			(*ite_DieZme)->nZmeNoHeadAdeID++;
		else
			(*ite_DieZme)->IsShowNoHeadAde = false;

		//无头僵尸吃植物
		if(((*ite_DieZme)->nZmeNoHeadEatID < (*ite_DieZme)->nZmeNoHeadEatNum-1)&&((*ite_DieZme)->IsHitPlt))
			(*ite_DieZme)->nZmeNoHeadEatID++;
		else
			(*ite_DieZme)->IsShowNoHeadEat = false;

		//僵尸倒下的身体
		if(((*ite_DieZme)->nZmeDieBmpID < (*ite_DieZme)->nZmeDieBmpNum-1)&&(!(*ite_DieZme)->IsShowHead)&&(!(*ite_DieZme)->IsShowNoHeadAde)&&(!(*ite_DieZme)->IsShowNoHeadEat))
			(*ite_DieZme)->nZmeDieBmpID++;
		else if((*ite_DieZme)->nZmeDieBmpID >= (*ite_DieZme)->nZmeDieBmpNum-1)
			(*ite_DieZme)->IsShowBody = false;
		ite_DieZme++;
		Invalidate(FALSE);
	}
}


void CZombiesOnTheLawnView::ShowCar(CDC* pMemDC)
{
	//显示小车
	list<CCar*>::iterator ite_Car = m_lst_Car.begin();
	while(ite_Car != m_lst_Car.end())
	{
		(*ite_Car)->ShowCar(pMemDC);
		ite_Car++;
	}
}
void CZombiesOnTheLawnView::ShowAllZme(CDC* pMemDC)
{

	//显示普通等待僵尸
	if(nCmnZmeNum > 0)
	{
		list<CCommonZombie*>::iterator ite_CmnWaitZme = m_lst_CmnWaitZme.begin();
		while(ite_CmnWaitZme != m_lst_CmnWaitZme.end())
		{
			(*ite_CmnWaitZme)->ShowZombie(pMemDC);
			ite_CmnWaitZme++;
		}
	}
	if(nJmpZmeNum > 0)
	{
		//显示跳高等待僵尸
		list<CJumpZombie*>::iterator ite_JmpWaitZme = m_lst_JmpWaitZme.begin();
		while(ite_JmpWaitZme != m_lst_JmpWaitZme.end())
		{
			(*ite_JmpWaitZme)->ShowZombie(pMemDC);
			ite_JmpWaitZme++;
		}
	}
	if(nRgyZmeNum > 0)
	{
		//显示橄榄球等待僵尸
		list<CRugbyZombie*>::iterator ite_RgyWaitZme = m_lst_RgyWaitZme.begin();
		while(ite_RgyWaitZme != m_lst_RgyWaitZme.end())
		{
			(*ite_RgyWaitZme)->ShowZombie(pMemDC);
			ite_RgyWaitZme++;
		}
	}


	//显示普通前进僵尸
	list<CCommonZombie*>::iterator ite_CmnAdeZme = m_lst_CmnAdeZme.begin();
	while(ite_CmnAdeZme != m_lst_CmnAdeZme.end())
	{
		(*ite_CmnAdeZme)->ShowZombie(pMemDC);
		ite_CmnAdeZme++;
	}
	//显示跳高前进僵尸
	list<CJumpZombie*>::iterator ite_JmpAdeZme = m_lst_JmpAdeZme.begin();
	while(ite_JmpAdeZme != m_lst_JmpAdeZme.end())
	{
		(*ite_JmpAdeZme)->ShowZombie(pMemDC);
		ite_JmpAdeZme++;
	}
	//显示橄榄球前进僵尸
	list<CRugbyZombie*>::iterator ite_RgyAdeZme = m_lst_RgyAdeZme.begin();
	while(ite_RgyAdeZme != m_lst_RgyAdeZme.end())
	{
		(*ite_RgyAdeZme)->ShowZombie(pMemDC);
		ite_RgyAdeZme++;
	}
}
void CZombiesOnTheLawnView::ShowAllAtkPlt(CDC* pMemDC)
{
	//显示攻击植物
	list<CAttackPlt*>::iterator ite_AtkPlt = m_lst_AttackPlt.begin();
	while(ite_AtkPlt != m_lst_AttackPlt.end())
	{
		(*ite_AtkPlt)->ShowPlant(pMemDC);
		ite_AtkPlt++;
	}
}
void CZombiesOnTheLawnView::ShowAllGunner(CDC* pMemDC)
{
	list<CGunner*>::iterator m_iteGur = m_lst_Gunner.begin();
	while(m_iteGur != m_lst_Gunner.end())
	{
		(*m_iteGur)->ShowGunner(pMemDC);
		m_iteGur++;
	}
}
void CZombiesOnTheLawnView::ShowAllSun(CDC* pMemDC)
{
	list<CSun*>::iterator m_iteSun = m_lst_Sun.begin();
	while(m_iteSun != m_lst_Sun.end())
	{
		(*m_iteSun)->ShowSun(pMemDC);
		m_iteSun++;
	}
}
void CZombiesOnTheLawnView::ShowCursorPlt(CDC* pMemDC)
{
	CPoint m_point;
	GetCursorPos(&m_point);
	this->ScreenToClient(&m_point);

	//显示准备种植植物
	ShowReadySeedPlt(pMemDC);

	//显示光标植物
	CDC hTempDC;
	hTempDC.CreateCompatibleDC(pMemDC);

	hTempDC.SelectObject(&(*ite_CsrCrd)->PltBmp);
	switch((*ite_CsrCrd)->PltStl)
	{
	case SunFlower:
		pMemDC->TransparentBlt(m_point.x-45,m_point.y-60,73,74,&hTempDC,0,0,73,74,RGB(255,255,255));
		break;
	case Cactus:
		pMemDC->TransparentBlt(m_point.x-58,m_point.y-70,86,84,&hTempDC,0,0,86,84,RGB(255,255,255));
		break;
	case BombBerry:
		pMemDC->TransparentBlt(m_point.x-45,m_point.y-45,89,68,&hTempDC,0,0,89,68,RGB(255,255,255));
		break;
	case DouBan:
		pMemDC->TransparentBlt(m_point.x-43,m_point.y-57,71,71,&hTempDC,0,0,71,71,RGB(255,255,255));
		break;
	case HighNut:
		pMemDC->TransparentBlt(m_point.x-55,m_point.y-105,83,119,&hTempDC,0,0,83,119,RGB(255,255,255));
		break;
	case EatZmePlt:
		pMemDC->TransparentBlt(m_point.x-55,m_point.y-100,130,114,&hTempDC,0,0,130,114,RGB(255,255,255));
		break;
	}
	
	hTempDC.DeleteDC();
}
//显示准备种植的植物（灰色背景的植物）
void CZombiesOnTheLawnView::ShowReadySeedPlt(CDC* pMemDC)
{
	//显示准备种植植物
	CPoint m_point;
	GetCursorPos(&m_point);
	this->ScreenToClient(&m_point);
	

	CDC hTempDC;
	hTempDC.CreateCompatibleDC(pMemDC);
	
	hTempDC.SelectObject(&(*ite_CsrCrd)->ReadyPltBmp);

	list<SeedPosNode*>::iterator m_iteSeed = m_lst_SeedPos.begin();
	while(m_iteSeed != m_lst_SeedPos.end())
	{
		if(m_point.x > (*m_iteSeed)->x && m_point.x < (*m_iteSeed)->x+80
			&& m_point.y > (*m_iteSeed)->y && m_point.y < (*m_iteSeed)->y+97)
		{
			//判断能否显示准备种植植物
			if((*m_iteSeed)->IsSeed == true)
			{
				//可以显示
				switch((*ite_CsrCrd)->PltStl)
				{
				case SunFlower:
					pMemDC->TransparentBlt((*m_iteSeed)->x + (40-36),(*m_iteSeed)->y + (48 - 37),73,74,&hTempDC,0,0,73,74,RGB(255,255,255));
					break;
				case Cactus:
					pMemDC->TransparentBlt((*m_iteSeed)->x + (40-43),(*m_iteSeed)->y + (48 - 42),86,84,&hTempDC,0,0,86,84,RGB(255,255,255));
					break;
				case DouBan:
					pMemDC->TransparentBlt((*m_iteSeed)->x + (40-35),(*m_iteSeed)->y + (48 - 35),71,71,&hTempDC,0,0,71,71,RGB(255,255,255));
					break;
				case HighNut:
					pMemDC->TransparentBlt((*m_iteSeed)->x + (40-41),(*m_iteSeed)->y + (48 - 75),83,119,&hTempDC,0,0,83,119,RGB(255,255,255));
					break;
				case EatZmePlt:
					pMemDC->TransparentBlt((*m_iteSeed)->x + (40-37),(*m_iteSeed)->y + (48 - 75),130,114,&hTempDC,0,0,130,114,RGB(255,255,255));
					break;
				case BombBerry:
					pMemDC->TransparentBlt((*m_iteSeed)->x + (40-55),(*m_iteSeed)->y + (48 - 57),112,81,&hTempDC,0,0,112,81,RGB(255,255,255));
					break;
				}
				break;
			}else
				//不可以显示
				break;
		}
		m_iteSeed++;
	}
	hTempDC.DeleteDC();
}
void CZombiesOnTheLawnView::ShowBombGnr(CDC* pMemDC)
{
	list<CGunner*>::iterator ite_BombGnr = m_lst_GnrBomb.begin();
	while(ite_BombGnr != m_lst_GnrBomb.end())
	{
		(*ite_BombGnr)->ShowGunner(pMemDC);
		ite_BombGnr++;
	}
}
void CZombiesOnTheLawnView::ShowDieZme(CDC* pMemDC)
{
	list<CDieZombie*>::iterator ite_DieZme = m_lst_DieZme.begin();
	while(ite_DieZme != m_lst_DieZme.end())
	{
		(*ite_DieZme)->ShowZombie(pMemDC);
		ite_DieZme++;
	}
}


void CZombiesOnTheLawnView::BackAndZmeLMove()
{
	list<CCommonZombie*>::iterator ite_CmnZme = m_lst_CmnWaitZme.begin();
	list<CJumpZombie*>::iterator ite_JmpZme = m_lst_JmpWaitZme.begin();	
	list<CRugbyZombie*>::iterator ite_RgyZme = m_lst_RgyWaitZme.begin();	

	//背景与僵尸向左移动
	if(back.X >= -598)
	{
		back.BackLMove();
		//普通僵尸移动
		while(ite_CmnZme != m_lst_CmnWaitZme.end())
		{
			(*ite_CmnZme)->ZombieLMove();
			ite_CmnZme++;
		}
		//跳高僵尸移动
		while(ite_JmpZme != m_lst_JmpWaitZme.end())
		{
			(*ite_JmpZme)->ZombieLMove();
			ite_JmpZme++;
		}
		//橄榄球僵尸移动
		while(ite_RgyZme != m_lst_RgyWaitZme.end())
		{
			(*ite_RgyZme)->ZombieLMove();
			ite_RgyZme++;
		}
	}else
	{
		if(++n > 200)
		{
			::KillTimer(this->m_hWnd,BACK_LMOVE_TIMER＿ID);
			::SetTimer(this->m_hWnd,BACK_RMOVE_TIMER＿ID,1,NULL);
			n = 0;
		}
	}
}
void CZombiesOnTheLawnView::BackAndZmeRMove()
{
	list<CCommonZombie*>::iterator ite_CmnZme = m_lst_CmnWaitZme.begin();
	list<CJumpZombie*>::iterator ite_JmpZme = m_lst_JmpWaitZme.begin();	
	list<CRugbyZombie*>::iterator ite_RgyZme = m_lst_RgyWaitZme.begin();	
	//背景移动
	back.BackRMove();
	//普通僵尸跟着背景移动
	while(ite_CmnZme != m_lst_CmnWaitZme.end())
	{
		(*ite_CmnZme)->ZombieRMove();
		ite_CmnZme++;
	}
	//跳高僵尸移动
	while(ite_JmpZme != m_lst_JmpWaitZme.end())
	{
		(*ite_JmpZme)->ZombieRMove();
		ite_JmpZme++;
	}
	//橄榄球僵尸移动
	while(ite_RgyZme != m_lst_RgyWaitZme.end())
	{
		(*ite_RgyZme)->ZombieRMove();
		ite_RgyZme++;
	}
	if(back.X >= -220)
	{
		::KillTimer(this->m_hWnd,BACK_RMOVE_TIMER＿ID);
		::KillTimer(this->m_hWnd,ZMEWAIT_GIFID_ADD);
		//显示植物卡片区
		bPltSltArea = true;
		//显示小车
		bShowCar = true;
	}
}
void CZombiesOnTheLawnView::AllGunnerMove()
{
	list<CGunner*>::iterator ite_Gur = m_lst_Gunner.begin();
	while(ite_Gur != m_lst_Gunner.end())
	{
		(*ite_Gur)->GunnerMove();

		//判断是否击中僵尸
		GunnerHit(ite_Gur);
		if(IsHit)
		{
			IsHit = false;
			continue;
		}
		//判断子弹是否超出窗口
		if((*ite_Gur)->X > 800)
		{
			delete *ite_Gur;
			ite_Gur = m_lst_Gunner.erase(ite_Gur);
			continue;
		}
		ite_Gur++;
		Invalidate(FALSE);
	}
}
void CZombiesOnTheLawnView::SunFallMove()
{
	list<CSun*>::iterator ite_Sun = m_lst_Sun.begin();
	while(ite_Sun != m_lst_Sun.end())
	{
		if((*ite_Sun)->IsStop == false && (*ite_Sun)->IsCollected == false)
		{
			(*ite_Sun)->SunFall();
			if((*ite_Sun)->Y >= (*ite_Sun)->SunFallPos)
			{
				(*ite_Sun)->IsStop = true;
			}
			Invalidate(FALSE);
		}
		ite_Sun++;
	}
}
void CZombiesOnTheLawnView::SunCollectMove()
{
	list<CSun*>::iterator m_iteSun = m_lst_Sun.begin();
	while(m_iteSun != m_lst_Sun.end())
	{
		//判断阳光是否被鼠标点中
		if((*m_iteSun)->IsCollected)
		{
			(*m_iteSun)->SunMove();
			if((*m_iteSun)->X <= 10 || (*m_iteSun)->Y <= 8)
			{
				//删除阳光，阳光点数增加25
				PltSltArea.SunCount += (*m_iteSun)->SunNum;
				delete (*m_iteSun);
				m_iteSun = m_lst_Sun.erase(m_iteSun);
				Invalidate(FALSE);
				continue;
			}
			Invalidate(FALSE);
		}
		m_iteSun++;
	}
}
void CZombiesOnTheLawnView::AllZmeAde()
{
	//普通僵尸前进
	list<CCommonZombie*>::iterator ite_CmnZmeAde = m_lst_CmnAdeZme.begin();
	while(ite_CmnZmeAde != m_lst_CmnAdeZme.end())
	{
		(*ite_CmnZmeAde)->ZombieAdvance();
		ZmeEatPlt(*ite_CmnZmeAde,NULL,NULL);
		ite_CmnZmeAde++;
		Invalidate(FALSE);
	}   
	//跳高僵尸前进
	list<CJumpZombie*>::iterator ite_JmpZmeAde = m_lst_JmpAdeZme.begin();
	while(ite_JmpZmeAde != m_lst_JmpAdeZme.end()) 
	{
		(*ite_JmpZmeAde)->ZombieAdvance();
		ZmeEatPlt(NULL,*ite_JmpZmeAde,NULL);
		ite_JmpZmeAde++;
		Invalidate(FALSE);
	}
	//橄榄球僵尸前进
	list<CRugbyZombie*>::iterator ite_RgyZmeAde = m_lst_RgyAdeZme.begin();
	while(ite_RgyZmeAde != m_lst_RgyAdeZme.end())
	{
		(*ite_RgyZmeAde)->ZombieAdvance();
		ZmeEatPlt(NULL,NULL,*ite_RgyZmeAde);
		ite_RgyZmeAde++;
		Invalidate(FALSE);
	}
	
	list<CAttackPlt*>::iterator ite_AtkPlt = m_lst_AttackPlt.begin();
	while(ite_AtkPlt != m_lst_AttackPlt.end())
	{
		if((*ite_AtkPlt)->PltStyle == EatZmePlt)
		{
			((CEatZmePlt*)(*ite_AtkPlt))->EatZme(m_lst_CmnAdeZme,m_lst_CmnDwnBldZme,
												 m_lst_JmpAdeZme,m_lst_JmpDwnBldZme,
												 m_lst_RgyAdeZme,m_lst_RgyDwnBldZme);
		}
		ite_AtkPlt++;
	}
	//死亡僵尸前进
	list<CDieZombie*>::iterator ite_DieZme = m_lst_DieZme.begin();
	while(ite_DieZme != m_lst_DieZme.end())
	{
		(*ite_DieZme)->ZombieAde();
		ite_DieZme++;
		Invalidate(FALSE);
	}
}
void CZombiesOnTheLawnView::CarAde()
{
	list<CCar*>::iterator ite_Car = m_lst_Car.begin();
	while(ite_Car != m_lst_Car.end())
	{
		if((*ite_Car)->IsAde)
		{
			(*ite_Car)->CarAde();
			CarHitZme();
		}
		//判断子弹是否超出窗口
		if((*ite_Car)->X > 800)
		{
			delete *ite_Car;
			ite_Car = m_lst_Car.erase(ite_Car);
			continue;
		}
		ite_Car++;
	}
}


void CZombiesOnTheLawnView::ZmeEatPlt(CCommonZombie* CmnZme,CJumpZombie* JmpZme,CRugbyZombie* RgyZme)
{
	list<CAttackPlt*>::iterator ite_Plt = m_lst_AttackPlt.begin();
	if(CmnZme != NULL)
	{
		while(ite_Plt != m_lst_AttackPlt.end())
		{
			if(CmnZme->IsHitPlt(*ite_Plt))
			{
				if(!CmnZme->IsEating)
				{
					//显示吃植物的僵尸
					CmnZme->IsEating = true;
					//植物掉血
					(*ite_Plt)->IsDwnBld = true;
				}
				//判断植物是否死亡
				if((*ite_Plt)->IsDie())
				{
					//所在的种植位置可以再次种植
					CanAgainSeed(*ite_Plt);
					//删除该植物
					delete *ite_Plt;
					m_lst_AttackPlt.erase(ite_Plt);
					//吃植物的僵尸显示完毕
					CmnZme->IsEating = false;
					return;
				}
			}
			ite_Plt++;
		}
		return;
	}
	if(JmpZme != NULL)
	{
		while(ite_Plt != m_lst_AttackPlt.end())
		{
			if(JmpZme->IsHitPlt(*ite_Plt))
			{
				if(!JmpZme->IsEating)
				{
					//显示吃植物的僵尸
					JmpZme->IsEating = true;
					//植物掉血
					(*ite_Plt)->IsDwnBld = true;
				}
				//判断植物是否死亡
				if((*ite_Plt)->IsDie())
				{
					//所在的种植位置可以再次种植
					CanAgainSeed(*ite_Plt);
					//删除该植物
					delete *ite_Plt;
					m_lst_AttackPlt.erase(ite_Plt);
					//吃植物的僵尸显示完毕
					JmpZme->IsEating = false;
					return;
				}
			}
			ite_Plt++;
		}
		return;
	}
	if(RgyZme != NULL)
	{
		while(ite_Plt != m_lst_AttackPlt.end())
		{
			if(RgyZme->IsHitPlt(*ite_Plt))
			{
				if(!RgyZme->IsEating)
				{
					//显示吃植物的僵尸
					RgyZme->IsEating = true;
					//植物掉血
					(*ite_Plt)->IsDwnBld = true;
				}
				
				//判断植物是否死亡
				if((*ite_Plt)->IsDie())
				{
					//所在的种植位置可以再次种植
					CanAgainSeed(*ite_Plt);
					//删除该植物
					delete *ite_Plt;
					m_lst_AttackPlt.erase(ite_Plt);
					//吃植物的僵尸显示完毕
					RgyZme->IsEating = false;
					return;
				}
			}
			ite_Plt++;
		}
		return;
	}
}
void CZombiesOnTheLawnView::CanAgainSeed(CAttackPlt* pPlt)
{
	list<SeedPosNode*>::iterator ite_SedPosNode = m_lst_SeedPos.begin();
	while(ite_SedPosNode != m_lst_SeedPos.end())
	{
		if(pPlt->SeedID == (*ite_SedPosNode)->SeedID)
		{
			(*ite_SedPosNode)->IsSeed = true;
		}
		ite_SedPosNode++;
	}
}
void CZombiesOnTheLawnView::CarStartAde()
{
	list<CCommonZombie*>::iterator ite_CmnZmeAde;
	list<CJumpZombie*>::iterator ite_JmpZmeAde;
	list<CRugbyZombie*>::iterator ite_RgyZmeAde;

	list<CCar*>::iterator ite_Car = m_lst_Car.begin();
	while(ite_Car != m_lst_Car.end())
	{
		//普通僵尸
		ite_CmnZmeAde = m_lst_CmnAdeZme.begin();
		while(ite_CmnZmeAde != m_lst_CmnAdeZme.end())
		{
			if(((*ite_CmnZmeAde)->RoadID == (*ite_Car)->RoadID) && ((*ite_CmnZmeAde)->X <= (*ite_Car)->X-20))
			{
				//僵尸触发小车,小车向前移动
				(*ite_Car)->IsAde = true;
				AdeCarNum++;
				break;
			}
			ite_CmnZmeAde++;
		}
		if((*ite_Car)->IsAde)
		{
			ite_Car++;
			continue;
		}
		//跳高僵尸
		ite_JmpZmeAde = m_lst_JmpAdeZme.begin();
		while(ite_JmpZmeAde != m_lst_JmpAdeZme.end())
		{
			if(((*ite_JmpZmeAde)->RoadID == (*ite_Car)->RoadID) && ((*ite_JmpZmeAde)->X <= (*ite_Car)->X-150))
			{
				//僵尸触发小车,小车向前移动
				(*ite_Car)->IsAde = true;
				AdeCarNum++;
				break;
			}
			ite_JmpZmeAde++;
		}
		if((*ite_Car)->IsAde)
		{
			ite_Car++;
			continue;
		}
		//橄榄球僵尸
		ite_RgyZmeAde = m_lst_RgyAdeZme.begin();
		while(ite_RgyZmeAde != m_lst_RgyAdeZme.end())
		{
			if(((*ite_RgyZmeAde)->RoadID == (*ite_Car)->RoadID) && ((*ite_RgyZmeAde)->X <= (*ite_Car)->X+20))
			{
				//僵尸触发小车,小车向前移动
				(*ite_Car)->IsAde = true;
				AdeCarNum++;
				break;
			}
			ite_RgyZmeAde++;
		}
		ite_Car++;
	}
}
void CZombiesOnTheLawnView::CarHitZme()
{
	list<CCommonZombie*>::iterator ite_CmnZmeAde;
	list<CJumpZombie*>::iterator ite_JmpZmeAde;
	list<CRugbyZombie*>::iterator ite_RgyZmeAde;

	list<CCar*>::iterator ite_Car = m_lst_Car.begin();
	while(ite_Car != m_lst_Car.end())
	{
		if(!(*ite_Car)->IsAde)
		{
			ite_Car++;
			continue;
		}
		//普通僵尸
		ite_CmnZmeAde = m_lst_CmnAdeZme.begin();
		while(ite_CmnZmeAde != m_lst_CmnAdeZme.end())
		{
			if((*ite_Car)->RoadID == (*ite_CmnZmeAde)->RoadID)
			{
				if(((*ite_CmnZmeAde)->X >= (*ite_Car)->X-105) && ((*ite_CmnZmeAde)->X <= (*ite_Car)->X-95))
				{
					//小车撞到僵尸，将僵尸添加到死亡僵尸链表里
					CDieZombie* pDieZme = new CCmnDieZme;
					pDieZme->InitZombie((*ite_CmnZmeAde)->X,(*ite_CmnZmeAde)->Y,(*ite_CmnZmeAde)->IsEating);
					m_lst_DieZme.push_back(pDieZme);

					//删除该僵尸 
					delete (*ite_CmnZmeAde);
					ite_CmnZmeAde = m_lst_CmnAdeZme.erase(ite_CmnZmeAde);
					continue;
				}
			}
			ite_CmnZmeAde++;
		}
		//跳高僵尸
		ite_JmpZmeAde = m_lst_JmpAdeZme.begin();
		while(ite_JmpZmeAde != m_lst_JmpAdeZme.end())
		{
			if((*ite_Car)->RoadID == (*ite_JmpZmeAde)->RoadID)
			{
				if(((*ite_JmpZmeAde)->X >= (*ite_Car)->X-210) && ((*ite_JmpZmeAde)->X <= (*ite_Car)->X-200))
				{
					//小车撞到僵尸，将僵尸添加到死亡僵尸链表里
					CDieZombie* pDieZme = new CJmpDieZme;
					pDieZme->InitZombie((*ite_JmpZmeAde)->X,(*ite_JmpZmeAde)->Y,(*ite_JmpZmeAde)->IsEating);
					m_lst_DieZme.push_back(pDieZme);

					//删除该僵尸 
					delete (*ite_JmpZmeAde);
					ite_JmpZmeAde = m_lst_JmpAdeZme.erase(ite_JmpZmeAde);
					continue;
				}
			}
			ite_JmpZmeAde++;
		}
		//橄榄球僵尸
		ite_RgyZmeAde = m_lst_RgyAdeZme.begin();
		while(ite_RgyZmeAde != m_lst_RgyAdeZme.end())
		{
			if((*ite_Car)->RoadID == (*ite_RgyZmeAde)->RoadID)
			{
				if(((*ite_RgyZmeAde)->X >= (*ite_Car)->X-50) && ((*ite_RgyZmeAde)->X <= (*ite_Car)->X-40))
				{
					//小车撞到僵尸，将僵尸添加到死亡僵尸链表里
					CDieZombie* pDieZme = new CRgyDieZme;
					pDieZme->InitZombie((*ite_RgyZmeAde)->X,(*ite_RgyZmeAde)->Y,(*ite_RgyZmeAde)->IsEating);
					m_lst_DieZme.push_back(pDieZme);

					//删除该僵尸 
					delete (*ite_RgyZmeAde);
					ite_RgyZmeAde = m_lst_RgyAdeZme.erase(ite_RgyZmeAde);
					continue;
				}
			}
			ite_RgyZmeAde++;
		}
		ite_Car++;
	}
}
void CZombiesOnTheLawnView::GunnerHit(list<CGunner*>::iterator & ite_Gur)
{
	list<CCommonZombie*>::iterator ite_CmnZme = m_lst_CmnAdeZme.begin();
	list<CJumpZombie*>::iterator ite_JmpZme = m_lst_JmpAdeZme.begin();
	list<CRugbyZombie*>::iterator ite_RgyZme = m_lst_RgyAdeZme.begin();

	//判断子弹是否击中普通僵尸
	while(ite_CmnZme != m_lst_CmnAdeZme.end())
	{
		if((*ite_Gur)->RoadID == (*ite_CmnZme)->RoadID)
		{
			if((*ite_CmnZme)->IsGunnerHit(*ite_Gur))
			{
				//删除子弹并将其添加到爆炸子弹链表里
				if((*ite_Gur)->GnrStyle == DouBanGur)
				{
					CGunner* pGnrBomb = new CBombGunner;
					pGnrBomb->InitGunner((*ite_Gur)->X,(*ite_Gur)->Y);
					m_lst_GnrBomb.push_back(pGnrBomb);
				}
				delete *ite_Gur;
				ite_Gur = m_lst_Gunner.erase(ite_Gur);
				//僵尸掉血
				(*ite_CmnZme)->DownBlood();
				//判断僵尸是否死亡
				if((*ite_CmnZme)->IsDie())
				{
					//道路上的僵尸的数目减一
					ArrZmeNum[(*ite_CmnZme)->RoadID]--;
					//删除僵尸并将其添加到垂死的僵尸链表里
					CDieZombie* pDieZme = new CCmnDieZme;
					pDieZme->InitZombie((*ite_CmnZme)->X,(*ite_CmnZme)->Y,(*ite_CmnZme)->IsEating);
					m_lst_DieZme.push_back(pDieZme);

					delete *ite_CmnZme;
					ite_CmnZme = m_lst_CmnAdeZme.erase(ite_CmnZme);
				}
				IsHit = true;
				return;
			}
		}
		ite_CmnZme++;
	}
	//判断子弹是否击中跳高僵尸
	while(ite_JmpZme != m_lst_JmpAdeZme.end())
	{
		if((*ite_Gur)->RoadID == (*ite_JmpZme)->RoadID)
		{
			if((*ite_JmpZme)->IsGunnerHit(*ite_Gur))
			{
				//删除子弹并将其添加到爆炸子弹链表里
				if((*ite_Gur)->GnrStyle == DouBanGur)
				{
					CGunner* pGnrBomb = new CBombGunner;
					pGnrBomb->InitGunner((*ite_Gur)->X,(*ite_Gur)->Y);
					m_lst_GnrBomb.push_back(pGnrBomb);
				}
				delete *ite_Gur;
				ite_Gur = m_lst_Gunner.erase(ite_Gur);
				//僵尸掉血
				(*ite_JmpZme)->DownBlood();
				//判断僵尸是否死亡
				if((*ite_JmpZme)->IsDie())
				{
					//道路上的僵尸的数目减一
					ArrZmeNum[(*ite_JmpZme)->RoadID]--;
					//删除僵尸并将其添加到垂死的僵尸链表里
					CDieZombie* pDieZme = new CJmpDieZme;
					pDieZme->InitZombie((*ite_JmpZme)->X,(*ite_JmpZme)->Y,(*ite_JmpZme)->IsEating);
					m_lst_DieZme.push_back(pDieZme);

					delete *ite_JmpZme;
					ite_JmpZme = m_lst_JmpAdeZme.erase(ite_JmpZme);
				}
				IsHit = true;
				return;
			}
		}
		ite_JmpZme++;
	}
	//判断子弹是否击中橄榄球僵尸
	while(ite_RgyZme != m_lst_RgyAdeZme.end())
	{
		if((*ite_Gur)->RoadID == (*ite_RgyZme)->RoadID)
		{
			if((*ite_RgyZme)->IsGunnerHit(*ite_Gur))
			{
				//删除子弹并将其添加到爆炸子弹链表里
				if((*ite_Gur)->GnrStyle == DouBanGur)
				{
					CGunner* pGnrBomb = new CBombGunner;
					pGnrBomb->InitGunner((*ite_Gur)->X,(*ite_Gur)->Y);
					m_lst_GnrBomb.push_back(pGnrBomb);
				}
				delete *ite_Gur;
				ite_Gur = m_lst_Gunner.erase(ite_Gur);
				//僵尸掉血
				(*ite_RgyZme)->DownBlood();
				//判断僵尸是否死亡
				if((*ite_RgyZme)->IsDie())
				{
					//道路上的僵尸的数目减一
					ArrZmeNum[(*ite_RgyZme)->RoadID]--;
					//删除僵尸并将其添加到垂死的僵尸链表里
					CDieZombie* pDieZme = new CRgyDieZme;
					pDieZme->InitZombie((*ite_RgyZme)->X,(*ite_RgyZme)->Y,(*ite_RgyZme)->IsEating);
					m_lst_DieZme.push_back(pDieZme);

					delete *ite_RgyZme;
					ite_RgyZme = m_lst_RgyAdeZme.erase(ite_RgyZme);
				}
				IsHit = true;
				return;
			}
		}
		ite_RgyZme++;
	}
}
void CZombiesOnTheLawnView::PltAndZmeDownBlood()
{
	list<CAttackPlt*>::iterator ite_plt = m_lst_AttackPlt.begin();

	while(ite_plt != m_lst_AttackPlt.end())
	{
		if((*ite_plt)->IsDwnBld)
		{
			(*ite_plt)->DownBlood();
		}
		ite_plt++;
	}

	list<CCommonZombie*>::iterator ite_CmnZme = m_lst_CmnDwnBldZme.begin();
	while(ite_CmnZme != m_lst_CmnDwnBldZme.end())
	{
		if((*ite_CmnZme)->blood > 0)
		{
			(*ite_CmnZme)->DownBlood();
		}else
		{
			(*ite_CmnZme)->pEatZmePlt->IsStartAttack = false;
			//删除僵尸
			delete *ite_CmnZme;
			ite_CmnZme = m_lst_CmnDwnBldZme.erase(ite_CmnZme);
			continue;
		}
		ite_CmnZme++;
	}

	list<CJumpZombie*>::iterator ite_JmpZme = m_lst_JmpDwnBldZme.begin();
	while(ite_JmpZme != m_lst_JmpDwnBldZme.end())
	{
		if((*ite_JmpZme)->blood > 0)
		{
			(*ite_JmpZme)->DownBlood();
		}else
		{
			(*ite_JmpZme)->pEatZmePlt->IsStartAttack = false;
			//删除僵尸
			delete *ite_JmpZme;
			ite_JmpZme = m_lst_JmpDwnBldZme.erase(ite_JmpZme);
			continue;
		}
		ite_JmpZme++;
	}

	list<CRugbyZombie*>::iterator ite_RgyZme = m_lst_RgyDwnBldZme.begin();
	while(ite_RgyZme != m_lst_RgyDwnBldZme.end())
	{
		if((*ite_RgyZme)->blood > 0)
		{
			(*ite_RgyZme)->DownBlood();
		}else
		{
			(*ite_RgyZme)->pEatZmePlt->IsStartAttack = false;
			//删除僵尸
			delete *ite_RgyZme;
			ite_RgyZme = m_lst_RgyDwnBldZme.erase(ite_RgyZme);
			continue;
		}
		ite_RgyZme++;
	}
}
void CZombiesOnTheLawnView::DelBombGnr()
{
	list<CGunner*>::iterator ite_BombGnr = m_lst_GnrBomb.begin();
	while(ite_BombGnr != m_lst_GnrBomb.end())
	{
		delete *ite_BombGnr;
		ite_BombGnr = m_lst_GnrBomb.erase(ite_BombGnr);
	}
}
void CZombiesOnTheLawnView::DelDieZme()
{
	list<CDieZombie*>::iterator ite_DieZme = m_lst_DieZme.begin();
	while(ite_DieZme != m_lst_DieZme.end())
	{
		delete *ite_DieZme;
		ite_DieZme = m_lst_DieZme.erase(ite_DieZme);
	}
}
void CZombiesOnTheLawnView::KillAllTimer()
{
	//杀死所有定时器
	//僵尸前进的定时器
	KillTimer(ZOMBIE_ADVANCE);
	//15秒之后创建第一波僵尸前进的定时器
	KillTimer(CREATE_FIRST_ADEZME);
	//30秒之后创建第二波僵尸前进的定时器
	KillTimer(CREATE_SECOND_ADEZME);
	//60秒之后创建第三波僵尸前进的定时器
	KillTimer(CREATE_THIRD_ADEZME);		
	//僵尸等待GIF图片的ID加加
	KillTimer(ZMEWAIT_GIFID_ADD);		
	//僵尸前进GIF图片的ID加加
	KillTimer(ZMEADE_GIFID_ADD);		
	//植物GIF图片的ID加加
	KillTimer(PLT_GIFID_ADD);		
	//阳光GIF图片的ID加加
	KillTimer(SUN_GIFID_ADD);		
	//死亡僵尸GIF图片的ID加加
	KillTimer(DIEZME_GIFID_ADD);		

	//发射炮弹的定时器
	KillTimer(SEND_GUNNER);		
	//炮弹移动的定时器
	KillTimer(GUNNER_MOVE);		
		
	//系统产生阳光的定时器(12s产生25阳光)
	KillTimer(SYS_PRODUCT_SUN);		

	向日葵产生阳光的定时器（24s产生25阳光）
	//KillTimer(SUNFLOWER_PRODUCT_SUN);		

	//阳光下落的定时器
	KillTimer(SUN_FALL_MOVE);		
	//阳光收集移动的定时器
	KillTimer(SUN_COLLLECT_MOVE);		
	//植物掉血的定时器
	KillTimer(PLT_ZME_DOWN_BLOOD);		
	//删除爆炸炮弹的定时器
	KillTimer(DEL_BOMB_GNR);		
	//删除死亡僵尸的定时器
	KillTimer(DEL_DIE_ZME);	
	//判断是否赢得定时器
	KillTimer(IS_WIN);
	//产生阳光的定时器
	KillTimer(SUNFLOWER_PRODUCTSUN_TIMEADE);
}

void CZombiesOnTheLawnView::OnLButtonDown(UINT nFlags, CPoint point)
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值
	//------------------点击阳光-------------------
		//----光标点中阳光，收集阳光----
		list<CSun*>::iterator m_iteSun = m_lst_Sun.begin();
		while(m_iteSun != m_lst_Sun.end())
		{
			if(point.x > (*m_iteSun)->X  && point.x < (*m_iteSun)->X+66
			&& point.y > (*m_iteSun)->Y && point.y < (*m_iteSun)->Y+65)
			{
				(*m_iteSun)->IsCollected = true;//已被收集

				(*m_iteSun)->Lx = (float)((*m_iteSun)->X - 10);
				(*m_iteSun)->Wy = (float)((*m_iteSun)->Y -8);
				(*m_iteSun)->nRatio = ((*m_iteSun)->Wy)/((*m_iteSun)->Lx);
				return;
			}
			m_iteSun++;
		}
	//------------------点击植物-------------------
		list<CPlantCard*>::iterator m_ite_Crd = PltSltArea.m_lst_PltCrd.begin(); 
		//----光标位置在卡片区域内，选择植物----
		if(point.x >= 75 && point.x <= 445
			&& point.y >= 7 && point.y <= 80)
		{
			while(m_ite_Crd != PltSltArea.m_lst_PltCrd.end())
			{
				//判断鼠标点击是否在卡片区域内
				if(point.x >= (*m_ite_Crd)->X && point.x <= ((*m_ite_Crd)->X+50)
					&& point.y >= (*m_ite_Crd)->Y && point.y <= ((*m_ite_Crd)->Y+70))
				{
					ite_CsrCrd = m_ite_Crd;
					//判断被选中的植物能不能被种植（阳光够不够）
					if((*m_ite_Crd)->NeedSunCount <= PltSltArea.SunCount)
					{
					//够
						//阳光数目减NeedSunCount
						PltSltArea.SunCount -= (*m_ite_Crd)->NeedSunCount;
						//将选中的植物随鼠标移动
						IsCursorPlt = true;
						return;
					}else
					{
					//不够
						return;
					}
				}
				m_ite_Crd++;
			}
		}
		//----光标位置在草坪区域内，种植植物----
		//判断是否选中植物
			//选种了,种植植物
		if(IsCursorPlt)
		{
			//判断要种植的位置是否已有植物
			list<SeedPosNode*>::iterator m_iteSeed = m_lst_SeedPos.begin();
			while(m_iteSeed != m_lst_SeedPos.end())
			{
				if(point.x > (*m_iteSeed)->x && point.x < (*m_iteSeed)->x+80
					&& point.y > (*m_iteSeed)->y && point.y < (*m_iteSeed)->y+97)
				{
					if((*m_iteSeed)->IsSeed == true)
					{
						//无
						//根据坐标种植植物
						SeedPlant(*m_iteSeed);
						return;
					}else
					{
						//有
						return;
					}
				}
				m_iteSeed++;
			}
			return;
		}else 
		{
			//没选中
		}
	CView::OnLButtonDown(nFlags, point);
}

bool CZombiesOnTheLawnView::IsGameOver()
{
	//普通僵尸
	list<CCommonZombie*>::iterator ite_CmnZmeAde = m_lst_CmnAdeZme.begin();
	while(ite_CmnZmeAde != m_lst_CmnAdeZme.end())
	{
		if((*ite_CmnZmeAde)->X <= -150)
		{
			return true;
		}
		ite_CmnZmeAde++;
	}
	//跳高僵尸前进
	list<CJumpZombie*>::iterator ite_JmpZmeAde = m_lst_JmpAdeZme.begin();
	while(ite_JmpZmeAde != m_lst_JmpAdeZme.end()) 
	{
		if((*ite_JmpZmeAde)->X <= -280)
		{
			return true;
		}
		ite_JmpZmeAde++;
	}
	//橄榄球僵尸前进
	list<CRugbyZombie*>::iterator ite_RgyZmeAde = m_lst_RgyAdeZme.begin();
	while(ite_RgyZmeAde != m_lst_RgyAdeZme.end())
	{
		if((*ite_RgyZmeAde)->X <= -156)
		{
			return true;
		}
		ite_RgyZmeAde++;
	}
	return false;
}
bool CZombiesOnTheLawnView::IsWin()
{
	list<CCommonZombie*>::iterator ite_CmnZmeAde = m_lst_CmnAdeZme.begin();
	list<CJumpZombie*>::iterator ite_JmpZmeAde = m_lst_JmpAdeZme.begin();
	list<CRugbyZombie*>::iterator ite_RgyZmeAde = m_lst_RgyAdeZme.begin();

	if(ite_CmnZmeAde == m_lst_CmnAdeZme.end() && ite_JmpZmeAde == m_lst_JmpAdeZme.end() && ite_RgyZmeAde == m_lst_RgyAdeZme.end())
	{
		return true;
	}
	return false;
}
void CZombiesOnTheLawnView::OnDestroy()
{
	CView::OnDestroy();
	//清空普通僵尸链表
	list<CCommonZombie*>::iterator ite_CmnWaitZme = m_lst_CmnWaitZme.begin();
	while(ite_CmnWaitZme != m_lst_CmnWaitZme.end())
	{
		delete (*ite_CmnWaitZme);
		ite_CmnWaitZme++;
	}
	list<CCommonZombie*>::iterator ite_CmnAdeZme = m_lst_CmnAdeZme.begin();
	while(ite_CmnAdeZme != m_lst_CmnAdeZme.end())
	{
		delete (*ite_CmnAdeZme);
		ite_CmnAdeZme++;
	}
	//清空跳高僵尸链表
	list<CJumpZombie*>::iterator ite_JmpWaitZme = m_lst_JmpWaitZme.begin();
	while(ite_JmpWaitZme != m_lst_JmpWaitZme.end())
	{
		delete (*ite_JmpWaitZme);
		ite_JmpWaitZme++;
	}
	list<CJumpZombie*>::iterator ite_JmpAdeZme = m_lst_JmpAdeZme.begin();
	while(ite_JmpAdeZme != m_lst_JmpAdeZme.end())
	{
		delete (*ite_JmpAdeZme);
		ite_JmpAdeZme++;
	}
	//清空橄榄球僵尸链表
	list<CRugbyZombie*>::iterator ite_RgyWaitZme = m_lst_RgyWaitZme.begin();
	while(ite_RgyWaitZme != m_lst_RgyWaitZme.end())
	{
		delete (*ite_RgyWaitZme);
		ite_RgyWaitZme++;
	}
	list<CRugbyZombie*>::iterator ite_RgyAdeZme = m_lst_RgyAdeZme.begin();
	while(ite_RgyAdeZme != m_lst_RgyAdeZme.end())
	{
		delete (*ite_RgyAdeZme);
		ite_RgyAdeZme++;
	}
	//清空小车链表
	list<CCar*>::iterator ite_Car = m_lst_Car.begin();
	while(ite_Car != m_lst_Car.end())
	{
		delete (*ite_Car);
		ite_Car++;
	}
	//清空种植区坐标链表
	list<SeedPosNode*>::iterator ite_SedPosNode = m_lst_SeedPos.begin();
	while(ite_SedPosNode != m_lst_SeedPos.end())
	{
		delete (*ite_SedPosNode);
		ite_SedPosNode++;
	}
	//清空攻击植物链表
	list<CAttackPlt*>::iterator ite_AtkPlt = m_lst_AttackPlt.begin();
	while(ite_AtkPlt != m_lst_AttackPlt.end())
	{
		delete (*ite_AtkPlt);
		ite_AtkPlt++;
	}
	//清空炮弹链表
	list<CGunner*>::iterator ite_Gunner = m_lst_Gunner.begin();
	while(ite_Gunner != m_lst_Gunner.end())
	{
		delete (*ite_Gunner);
		ite_Gunner++;
	}
	//清空太阳链表
	list<CSun*>::iterator ite_Sun = m_lst_Sun.begin();
	while(ite_Sun != m_lst_Sun.end())
	{
		delete (*ite_Sun);
		ite_Sun++;
	}
	//清空炮炸子弹链表
	list<CGunner*>::iterator ite_GnrBomb = m_lst_GnrBomb.begin();
	while(ite_GnrBomb != m_lst_GnrBomb.end())
	{
		delete (*ite_GnrBomb);
		ite_GnrBomb++;
	}
	//清空死亡僵尸链表
	list<CDieZombie*>::iterator ite_DieZme = m_lst_DieZme.begin();
	while(ite_DieZme != m_lst_DieZme.end())
	{
		delete (*ite_DieZme);
		ite_DieZme++;
	}
	//清空掉血僵尸链表
	list<CCommonZombie*>::iterator ite_CmnDwnBldZme = m_lst_CmnDwnBldZme.begin();//普通掉血僵尸
	while(ite_CmnDwnBldZme != m_lst_CmnDwnBldZme.end())
	{
		delete (*ite_CmnDwnBldZme);
		ite_CmnDwnBldZme++;
	}
	list<CJumpZombie*>::iterator ite_JmpDwnBldZme = m_lst_JmpDwnBldZme.begin();//普通掉血僵尸
	while(ite_JmpDwnBldZme != m_lst_JmpDwnBldZme.end())
	{
		delete (*ite_JmpDwnBldZme);
		ite_JmpDwnBldZme++;
	}
	list<CRugbyZombie*>::iterator ite_RgyDwnBldZme = m_lst_RgyDwnBldZme.begin();//普通掉血僵尸
	while(ite_RgyDwnBldZme != m_lst_RgyDwnBldZme.end())
	{
		delete (*ite_RgyDwnBldZme);
		ite_RgyDwnBldZme++;
	}
}

【网盘下载】
【提取码】：uzwd

评论回复慢。有问题请直接加QQ：1776323096