// Tank1.cpp: implementation of the CTank class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "tank.h"
#include "Tank1.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

	
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CTank::CTank()
{
	tempDamage=50;
	sort=0;
	number=-1;
	m_nDoubleBullet=1;
	m_nDirection=UP;
	m_pGame=NULL;
	m_nTankSpeed=2;
	m_nTankLife=200;
	m_nFireSpeed=600;
	m_bmpTank=NULL;
	m_bmpTankState=NULL;
	m_nX=m_nY=x=y=0;
	m_nSkin=0;
	m_nDamage=50;
	m_nStep=0;
	rect.SetRectEmpty();
}

CTank::~CTank()
{
}

BOOL CTank::HeadHaveTank(TankDirection dir)
{
	CRect rct,rc;
	POSITION position;
	CTank *p;
	switch(dir)
	{
	case UP:
		rct.SetRect(x,0,x+TANKWIDTH,y);
		break;
	case DOWN:
		rct.SetRect(x,y+TANKHEIGHT,x+TANKWIDTH,SCREEN_HEIGHT);
		break;
	case LEFT:
		rct.SetRect(0,y,x,y+TANKHEIGHT);
		break;
	case RIGHT:
		rct.SetRect(x+TANKWIDTH,y,SCREEN_WIDTH,y+TANKHEIGHT);
		break;
	}
	position=m_pGame->m_Player.GetHeadPosition();
	while(position)
	{
		p=m_pGame->m_Player.GetNext(position);
		BOOL ret=rc.IntersectRect(&rct,&(p->rect));
		if(ret && rc.Width() > 12 && rc.Height() > 12)
		{
			switch(dir)
			{
			case UP:
				if(HasBlock(m_nX,p->GetY(),m_nX+1,m_nY))
					return FALSE;
			case DOWN:
				if(HasBlock(m_nX,m_nY,m_nX+1,p->GetY()))
					return FALSE;
			case LEFT:
				if(HasBlock(p->GetX(),m_nY,m_nX,m_nY+1))
					return FALSE;
			case RIGHT:
				if(HasBlock(m_nX,m_nY,p->GetX(),m_nY+1))
					return FALSE;
			}
			return TRUE;			
		}
	}
	CRect rcTemp(19*TANKMAPCELL,38*TANKMAPCELL,21*TANKMAPCELL,40*TANKMAPCELL);
	if(rc.IntersectRect(&rct,&rcTemp) && m_nY > 32)
		return TRUE;
	return FALSE;
}

void CTank::TankMove()
{
	   int flag[4];
	   memset(flag,0,4*sizeof(int));
	   
	   BYTE rnd=rand()%150;
	   if(rnd==0 && m_nDirection==LEFT && DownCanGo())
		   m_nDirection=DOWN;
	   if(rnd==1 && m_nDirection==RIGHT && DownCanGo())
		   m_nDirection=DOWN;

	   if(HeadHaveTank(UP))
		   m_nDirection=UP;
	   else if(m_pGame->m_nGameLevel>2 && HeadHaveTank(LEFT))
		   m_nDirection=LEFT;
	   else if(m_pGame->m_nGameLevel>4 && HeadHaveTank(RIGHT))
		   m_nDirection=RIGHT;
	   else if(m_pGame->m_nGameLevel>6 && HeadHaveTank(DOWN))
		   m_nDirection=DOWN;
	   else
	   {
	   
		   BOOL bCanGo=TankMove2(m_nDirection);
			int num=4,index=0;
			int i=m_nDirection;
			flag[i]=1;
			int temp;
		   while(!bCanGo && num--)
		   {
			   while(flag[i])
			   {
	   				flag[i]=0;
				   srand(unsigned(time(NULL)));
				   temp=rand()%3+1;
				   switch(i)
				   {
				   case 0:
					   i=i+temp;
					   break;
				   case 1:
				   case 2:
				   case 3:
					   i=i+temp;
					   if(i>3)i=i%4;
					   break;	
				   }
			   }
			   m_nDirection=(TankDirection)i;
				   flag[i]=1;
			   bCanGo=TankMove2(m_nDirection);
		   }
	   }
	   if(++m_nStep > 30 && HeadHaveTank(m_nDirection))
	   {
		   m_nStep=0;
		   TankMove2(m_nDirection);
		   Shoot();
	   }
}

void CTank::SetTankPos(int x, int y)
{
		m_nX=x;
		m_nY=y;
		this->x=m_nX*TANKMAPCELL;
		this->y=m_nY*TANKMAPCELL;
//		SetCell(CT_TANK);
}

void CTank::SetBullet()
{
	ASSERT(sort>=0&&sort<5);
	ASSERT(m_Normal);
	m_Normal->Choose(sort);
	m_Normal->SetDirection(m_nDirection);
	m_Normal->SetPosition(x,y);
	m_Normal->SetGame(m_pGame);
	m_Normal->SetDamage(m_nDamage);
	m_Normal->SetBulletBmp(m_pGame->m_pBulletBuffer);
	m_Normal->SetBelong(Belong());
	if(sort!=0)
	{
		
		if(number>0)number--;
		if(number == 0)
		{
			number=-1;
			sort=0;
			m_nDamage=tempDamage;
		}
	}
}
void CTank::SetGame(CGame *pGame)
{
	m_pGame=pGame;
}

Result CTank::IsWhat(TankDirection direction)
{
	Result rst;
	memset(rst.type,0,3*sizeof(CellType));
	rst.num=0;
	rst.bCanGo=TRUE;

	int i;
	int num=2;

	int m=m_nX;
	int n=m_nY;

	switch(direction)
	{
	case UP:
		if(m_nY==0)
		{
			rst.bCanGo=FALSE;
			return rst;
		}
         n-=1;
        if(x%TANKMAPCELL!=0)num=3;
		else num=2;

		for(i=0;i<num;i++)
		{
			CellType ct=m_pGame->m_TankMap.GetCellType(m+i,n);
			rst.type[i]=ct;
			if(ct.cell!=CT_EMPTY && ct.cell!=CT_TREE && ct.cell!=CT_ICE)
			{
				rst.num++;
				rst.bCanGo=FALSE;
				return rst;
			}
		}
		break;
	case DOWN:

		if(m_nY>=TANKMAPHEIGHT-2)
		{
			rst.bCanGo=FALSE;
			return rst;
		}

		if(y%TANKMAPCELL==0)n+=2;
		else 
		{
			if(m_nY==TANKMAPHEIGHT-3)
			{
				rst.bCanGo=TRUE;
				return rst;
			}
			else n+=3;
		}
        
		if(x%TANKMAPCELL!=0)num=3;
		else num=2;
        
		for(i=0;i<num;i++)
		{
			CellType ct=m_pGame->m_TankMap.GetCellType(m+i,n);
			rst.type[i]=ct;
			if(ct.cell!=CT_EMPTY && ct.cell!=CT_TREE && ct.cell!=CT_ICE)
			{
				rst.num++;
				rst.bCanGo=FALSE;
				return rst;
			}
		}
		break;
	case RIGHT:
		if(m_nX>=TANKMAPWIDTH-2)
		{
			rst.bCanGo=FALSE;
			return rst;
		}

		if(x%TANKMAPCELL==0)m+=2;
		else
		{
			if(m_nX==TANKMAPWIDTH-3)
			{
				rst.bCanGo=TRUE;
				return rst;
			}
			else m+=3;
		}

		if(y%TANKMAPCELL!=0)num=3;
		else num=2;

		for(i=0;i<num;i++)
		{
			CellType ct=m_pGame->m_TankMap.GetCellType(m,n+i);
			rst.type[i]=ct;
			if(ct.cell!=CT_EMPTY && ct.cell!=CT_TREE && ct.cell!=CT_ICE)
			{
				rst.num++;
				rst.bCanGo=FALSE;
				return rst;
			}
		}
		break;
	case LEFT:
		if(m_nX<=0)
		{
			rst.bCanGo=FALSE;
			return rst;
		}

		m-=1;

		if(y%TANKMAPCELL!=0)num=3;
		else num=2;

		for(i=0;i<num;i++)
		{
			CellType ct=m_pGame->m_TankMap.GetCellType(m,n+i);
			rst.type[i]=ct;
			if(ct.cell!=CT_EMPTY && ct.cell!=CT_TREE && ct.cell!=CT_ICE)
			{
				rst.num++;
				rst.bCanGo=FALSE;
				return rst;
			}
		}
		break;
	}
	return rst;
}

BOOL CTank::TankMove2(TankDirection direction)
{
	if(!m_pGame)return FALSE;
//    ASSERT(x>=0&&x<=SCREEN_WIDTH-TANKWIDTH);
//	ASSERT(y>=0&&y<=SCREEN_HEIGHT-TANKHEIGHT);

	MapxyTonXnY();

	int index=2;
	int Num=direction-m_nDirection;
	Result rst;
	Obj object;
	if(Num==0)
		rst=IsWhat(m_nDirection); 
	if((Num!=0)||(Num==0 && rst.bCanGo))
	{
	//判斷以下邊界問題
	  if(Num==0)
	  {
		if(m_nY==0&&m_nDirection==UP)return FALSE;
		if(m_nX==0&&m_nDirection==LEFT)return FALSE;
		if(m_nX==TANKMAPWIDTH-2&&m_nDirection==RIGHT)return FALSE;
		if(m_nY==TANKMAPHEIGHT-2&&m_nDirection==DOWN)return FALSE;      
	  }
	
  }
	if(Num==0)
	{
		switch(m_nDirection)
		{
			case UP:
				object=HasObject(x,y-m_nTankSpeed);
				if(!object.has)
				{
					if(rst.bCanGo)
					{
						y-=m_nTankSpeed;
						if(y<0)y=0;
					}
					else 
					{
						if(y-m_nY*TANKMAPCELL>0)
						{
							y-=m_nTankSpeed;
							if(y<=m_nY*TANKMAPCELL)y=m_nY*TANKMAPCELL;
						}
						else return FALSE;
					}
				}
				else return FALSE;
				break;
			case DOWN:
				object=HasObject(x,y+m_nTankSpeed);
				if(!object.has)
				{
					if(rst.bCanGo)
					{
						y+=m_nTankSpeed;
						if(y>=SCREEN_HEIGHT-TANKHEIGHT)y=SCREEN_HEIGHT-TANKHEIGHT;
					}
					else 
					{
						if(m_nY>=TANKMAPHEIGHT-2)return FALSE;
						if((y+TANKHEIGHT)%TANKMAPCELL!=0)
						{
							index=3;
							y+=m_nTankSpeed;
							if(y>=min(SCREEN_HEIGHT-TANKHEIGHT,(m_nY+index)*TANKMAPCELL-TANKHEIGHT))y=min(SCREEN_HEIGHT-TANKHEIGHT,(m_nY+index)*TANKMAPCELL-TANKHEIGHT);
						}
						else return FALSE;
					}
				}
				else return FALSE;
				break;
			case RIGHT:
				object=HasObject(x+m_nTankSpeed,y);
				if(!object.has)
				{
					if(rst.bCanGo)
					{
						x+=m_nTankSpeed;	
						if(x>=SCREEN_WIDTH-TANKWIDTH)x=SCREEN_WIDTH-TANKWIDTH;
					}
					else
					{
						if(m_nX>=TANKMAPWIDTH-2)return FALSE;
						if((x+TANKWIDTH)%TANKMAPCELL!=0)
						{
							index=3;
							x+=m_nTankSpeed;
							if(x>=min(SCREEN_WIDTH-TANKWIDTH,(m_nX+index)*TANKMAPCELL-TANKWIDTH))x=min(SCREEN_WIDTH-TANKWIDTH,(m_nX+index)*TANKMAPCELL-TANKWIDTH);
						}
						else return FALSE;
					}
				}
				else return FALSE;
				break;
			case LEFT:
				object=HasObject(x-m_nTankSpeed,y);
				if(!object.has)
				{
					if(rst.bCanGo)
					{
						x-=m_nTankSpeed;	
						if(x<0)x=0;
					}
					else
					{
						
						if(x-m_nX*TANKMAPCELL>0)
						{
							x-=m_nTankSpeed;
							if(x<=m_nX*TANKMAPCELL)x=m_nX*TANKMAPCELL;
						}
						else return FALSE;
					}
				}
			   else return FALSE;
				break;
		}
	    MapxyTonXnY();
		this->SetRect();
		return	TRUE;
	}
  else
  {
	  m_nDirection=direction;
	  SetRect();
	  return TRUE;
  }
  return FALSE;
 }

void CTank::Shoot()
{
	if(m_nDoubleBullet==1)
	{
		 m_Normal=new CNormalBullet;
		 if(m_Normal)
		 {
			 SetBullet();
			 m_pGame->m_BulletList.AddHead(m_Normal);
			 m_pGame->m_wavShoot.Play();
		 }
	}
	else
	{
		m_Normal=new CNormalBullet;
		if(m_Normal)
		{
			m_Normal->Choose(sort);
			m_Normal->SetDirection(m_nDirection);
			switch(m_nDirection)
			{
			case UP:
				m_Normal->Setx(x);
				m_Normal->Sety(y-BULLETHEIGHT);
				break;
			case DOWN:
				m_Normal->Setx(x);
				m_Normal->Sety(y+TANKHEIGHT);
				break;
			case LEFT:
				m_Normal->Setx(x-BULLETWIDTH);
				m_Normal->Sety(y);
				break;
			case RIGHT:
				m_Normal->Setx(x+TANKWIDTH);
				m_Normal->Sety(y);
				break;
			}
				
			m_Normal->SetGame(m_pGame);
			m_Normal->SetDamage(m_nDamage);
			m_Normal->SetBulletBmp(m_pGame->m_pBulletBuffer);
			m_Normal->SetBelong(Belong());
			m_pGame->m_BulletList.AddHead(m_Normal);
		}

	   m_Normal=new CNormalBullet;
   		if(m_Normal)
		{
			m_Normal->Choose(sort);
			m_Normal->SetDirection(m_nDirection);
			switch(m_nDirection)
			{
			case UP:
				m_Normal->Setx(x+TANKWIDTH-BULLETWIDTH);
				m_Normal->Sety(y-BULLETHEIGHT);
				break;
			case DOWN:
				m_Normal->Setx(x+TANKWIDTH-BULLETWIDTH);
				m_Normal->Sety(y+TANKHEIGHT);
				break;
			case LEFT:
				m_Normal->Setx(x-BULLETWIDTH);