managers.cpp

支持局域网对战的飞行棋

// Managers.cpp: implementation of the Managers class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "program.h"
#include "Managers.h"

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
/*
* 函数名称：Managers()
* 函数介绍：初始化程序
* 输入参数：无
* 输出参数：无
* 返回值  ：无
*/
Managers::Managers()
{
	int i;
	for(i=0;i<4;i++)
	{
		GameOver[i]=true;
	}
	for(i=0;i<4;i++)
	{
		Planes[i].Color=0;
		Planes[i].image=IDB_GREENPLANE;
		PlReady[i]=false;
	}
	for(i=4;i<8;i++)
	{
		Planes[i].Color=1;
		Planes[i].image=IDB_REDPLANE;
		PlReady[i]=false;
	}
	for(i=8;i<12;i++)
	{
		Planes[i].Color=2;
		Planes[i].image=IDB_YELLOWPLANE;
		PlReady[i]=false;
	}
	for(i=12;i<16;i++)
	{
		Planes[i].Color=3;
		Planes[i].image=IDB_BLUEPLANE;
		PlReady[i]=false;
	}

	PAUSE=true;
	Game_State=-1;
}

Managers::~Managers()
{

}
////////////////////////////////////////////////////////////////////////
/*
* 函数名称：DoMsg(int steps, 当前点的格子步数
                  int state, 当前格子所有的状态
                  int action,动作
                  int roll)  ROLL的点数
* 函数介绍：消息响应
* 输入参数：action 0为鼠标经过 1为鼠标左键，2鼠标右件,3表示ROLL之后的判断
* 输出参数：bool
* 返回值  ：是否响应成功
*/
bool Managers::DoMsg(int steps, int state,int action,int roll)
{
	if(PAUSE)
		return false;
	Chess *pl;
	if(state==4)//已经到达目的地，降落了
		return false;
	if (action==1)
	{
		if((pl=Search(steps,state))==NULL)//找到目标飞机
			return false;
		if(roll<1 || roll>6 || state<0 || state>4 || steps<0 || steps> 56) //数据非法
			return false;
		PlLast=*pl;//把当前信息拷贝到PlLast中去
		PlThis=pl;//把当前改变的飞机的地址传到PlThis中
		if(state==0)//还停在飞机场，需要Roll到6才能准备起飞
		{
			if(roll!=6)
				return false;
			pl->state=1;
		}
		return true;
	}
	else if(action==3)//自动走
	{
		if(PlAuto!=NULL)
		{
			PlThis=PlAuto;
			PlLast=*PlAuto;
			return true;
		}
		else
		{
			int k;
			for(k=Game_State*4;k<Game_State*4+4;k++)
				if(Planes[k].state!=0 && Planes[k].state!=4)
					break;

			if(k==Game_State*4+4)
			{
				if(roll==6)
					return false;
				do
				{
					Game_State=(Game_State+1)%4;
				}
				while(GameOver[Game_State]);
				return true;
			}
		}
	}
	return false;
}
////////////////////////////////////////////////////////////////////////
/*
* 函数名称：UpData(int roll)
* 函数介绍：游戏更新
* 输入参数：roll的值，因为ROLL到6可以连续走棋
* 输出参数：bool
* 返回值  ：true成功
*/
bool Managers::UpData(int roll)
{

	Chess &p=(*PlThis);//让P代替PlThis存的值，提高效率，节约代码
	if(p.step==OverStep(p.Color)+6 && p.state==3)
	{
		p.state=4;
	}
	int k;
	if(Game_State>=0 && Game_State<4 && p.state==2)//判断飞行中的碰撞以及跳棋问题
	{
		PlBack=GoBack(PlThis,roll);//看看是不是有人要回家了
		if(PlBack==PlThis)
			return true;//更新结束，他绝对没发让游戏结束
		
		if(p.step==(DefStep(p.Color)+18)%52)
		{
			p.step=(p.step+12)%52;
			PlBack=GoBack(PlThis,roll);
			if(PlBack==PlThis)
				return true;//更新结束，他绝对没发让游戏结束
		}
		else if((p.step+3)%4==p.Color && p.step!=OverStep(p.Color))
		{
			p.step=(p.step+4)%52;
			PlBack=GoBack(PlThis,roll);
			if(PlBack==PlThis)
				return true;//更新结束，他绝对没发让游戏结束
		}
		if(p.step==(DefStep(p.Color)+18)%52)
		{
			p.step=(p.step+12)%52;
			PlBack=GoBack(PlThis,roll);
			if(PlBack==PlThis)
				return true;//更新结束，他绝对没发让游戏结束
		}
	}

	//判断是否有玩家胜利，是否游戏结束
	for(k=Game_State*4;k<Game_State*4+4;k++)
	{
		if(Planes[k].state!=4)
			break;
	}
	if(k==Game_State*4+4)
	{
		GameOver[Game_State]=NumOfWiner;
		NumOfWiner++;
	}
	else if(roll!=6)
	{
		do
		{
			Game_State=(Game_State+1)%4;
		}
		while(GameOver[Game_State]);
	}
	if(NumOfWiner==1)//有3个玩家下玩就全部结束
	{
		Game_State=8;
		PAUSE=true;
		MessageBox(GetActiveWindow(),"胜利!恭喜你顺利完成任务","游戏结束",0);
	}
	return true;
}
////////////////////////////////////////////////////////////////////////
/*
* 函数名称：GameStart()
* 函数介绍：游戏开始初始化
* 输入参数：无
* 输出参数：无
* 返回值  ：无
*/
void Managers::GameStart()
{
	PlAuto=NULL;
	NumOfWiner=0;
	int i;
	Game_State=0;
	for(i=0;i<4;i++)
		GameOver[i]=false;
	for(i=0;i<4;i++)
	{
		Planes[i].state=0;
		Planes[i].step=51;
		PlReady[i]=true;
		Planes[i].dou=0;
	}
	for(i=4;i<8;i++)
	{
		Planes[i].state=0;
		Planes[i].step=12;
		PlReady[i]=true;
		Planes[i].dou=0;
	}
	for(i=8;i<12;i++)
	{
		Planes[i].state=0;
		Planes[i].step=25;
		PlReady[i]=true;
		Planes[i].dou=0;
	}
	for(i=12;i<16;i++)
	{
		Planes[i].state=0;
		Planes[i].step=38;
		PlReady[i]=true;
		Planes[i].dou=0;
	}
	PAUSE=false;
}
////////////////////////////////////////////////////////////////////////
/*
* 函数名称：Search(int step, int state)
* 函数介绍：查找在第step步，在state状态是否存在一个飞机
* 输入参数：step 步数 state 状态
* 输出参数：Chess *
* 返回值  ：找到的话则是那个飞机地址，没找到是NULL
*/
Chess * Managers::Search(int step, int state)
{
	Chess *p=Planes;
	int k;
	for(k=0;k<16;k++)
	{
		if(p->state==state && p->step==step && p->Color==Game_State)
			return p;
		p++;
	}
	return NULL;
}
////////////////////////////////////////////////////////////////////////
/*
* 函数名称：GoBack(Chess *p)
* 函数介绍：判断飞机P的移动是否造成有飞机被打回家
* 输入参数：Chess *p 飞机P的地址
* 输出参数：Chess *
* 返回值  ：被打回去的飞机地址，没飞机被打回去返回NULL
*/
Chess * Managers::GoBack(Chess *p,int roll)
{
	int i;
	int dou=0;//记录碰装时，被碰的有几个重叠
	int Che=0;//记录碰撞时，被碰的是几号
	if(p->state!=2)
		return NULL;
	for(i=0;i<16;i++)//判断飞机是否相撞
		if(Planes[i].step==p->step && Planes[i].state==2 && Planes+i != p)
												//最后一句表示不是同一架飞机
		{
			if(Planes[i].Color==p->Color)//颜色相同，重叠之
			{
				p->dou=Planes[i].dou++;
				PlAuto=NULL;//没有给任何飞机自动走的机会
				return NULL;
			}
			else //颜色不同，打回去；（重叠了多个不同颜色的就该自己回去了）
			{
				dou++;
				Che=Che*100+i+1;
			}
		}
	p->dou=0;//没有自己的飞机重叠，改回0
	if(dou==1)
	{
		Che--;
		Planes[Che].state=0;
		Planes[Che].step=DefStep(Planes[Che].Color);//回到出发点
		return Planes+Che;
	}
	if(dou>=2)
	{
		if(roll!=6)//全部飞机都得回家
		{
			while(Che!=0)
			{
				i=Che%100-1;
				Che/=100;
				Planes[i].state=0;
				Planes[i].step=DefStep(Planes[i].Color);
			}
			p->state=0;
			p->step=DefStep(p->Color);
			PlAuto=NULL;//没有给任何飞机自动走的机会
			return p;
		}
		else
		{
			PlAuto=p;//P可以停在多架飞机上，没人回家，而且下次P必须自动走一次
			return NULL;
		}
	}
	PlAuto=NULL;//没有给任何飞机自动走的机会
	return NULL;
}
////////////////////////////////////////////////////////////////////////
/*
* 函数名称：DefStep(int color)
* 函数介绍：得到不同颜色飞机的起飞步数
* 输入参数：color 飞机颜色（不同的阵营）
* 输出参数：int
* 返回值  ：出生所在步数
*/
int Managers::DefStep(int color)
{
	if(color==0)
		return 51;
	if(color==1)
		return 12;
	if(color==2)
		return 25;
	if(color==3)
		return 38;
	return 0;
}
////////////////////////////////////////////////////////////////////////
/*
* 函数名称：OverStep(int color)
* 函数介绍：得到不同颜色飞机的降落步数
* 输入参数：color 飞机颜色（不同的阵营）
* 输出参数：int
* 返回值  ：降落所在步数
*/
int Managers::OverStep(int color)
{
	if(color==0)
		return 49;
	if(color==1)
		return 10;
	if(color==2)
		return 23;
	if(color==3)
		return 36;
	return 0;
}

////////////////////////////////////////////////////////////////////////
/*
* 函数名称：StepUp(Chess *pl, int roll)
* 函数介绍：飞机向前进
* 输入参数：pl 飞机 roll点数
* 输出参数：bool
* 返回值  ：是否成功移动
*/
bool Managers::StepUp(Chess *pl, int roll)
{
	int ro=roll;
	if(pl->state==1 && roll!=0)
		pl->state=2;
	while(ro!=0 && pl->state==2)
	{
		pl->step++;
		if(ro>0)
			ro--;
		else
			ro++;
		if(pl->step==OverStep(pl->Color)+1)//判断飞机是否该降落
		{
			pl->state=3;
		}
		else if(SearchTwice(pl->step,pl->Color))
		{
			if(roll==6)
				ro=0;
			else
				ro*=-1;
		}
		else if(pl->step>51)
			pl->step-=52;
	}
	if(pl->state==3 && ro!=0)
	{
		int k;
		k=OverStep(pl->Color)+6;//飞机降落点
		if(pl->step+ro==k)
		{
			pl->step=k;
			pl->state=4;
		}
		else if(pl->step+ro<k)
			pl->step+=ro;
		else
		{
			pl->step=k-ro+(k-pl->step);
		}
	}
	return true;
}

////////////////////////////////////////////////////////////////////////
/*
* 函数名称：SearchTwice(int step,int notcolor)
* 函数介绍：搜索在step的地方是否存在2个或以上不是notcolor的飞机重叠(只有state==2才算)
* 输入参数：step 步数，notcolor 重叠飞机不能是的颜色
* 输出参数：bool
* 返回值  ：是否存在
*/
bool Managers::SearchTwice(int step,int butcolor)
{
	int k,i;
	i=0;
	for(k=0;k<16;k++)
		if(Planes[k].state==2 && Planes[k].step==step && Planes[k].Color!=butcolor)
			i++;
	if(i>1)
		return true;
	return false;
}

////////////////////////////////////////////////////////////////////////
/*
* 函数名称：OneStep(int gh, int roll)
* 函数介绍：飞机一次只非一步
* 输入参数：gh 向前飞还是向后飞，roll 丢的色子数
* 输出参数：int
* 返回值  ：下一步是向前飞还是向后飞
*/
int Managers::OneStep(int gh, int roll)
{
	Chess *pl=PlThis;
	if(pl->state==1)
		pl->state=2;
	if(pl->state==2)
	{	
		if(SearchTwice(pl->step,pl->Color) && pl!=PlAuto)
		{
			if(roll!=6)
			{
				pl->step-=gh;
				gh*=-1;
			}
			else
			{
				return 1;
			}
		}
		else
		{
			pl->step+=gh;
		}
		if(pl->step==OverStep(pl->Color)+1)//判断飞机是否该降落
		{
			pl->state=3;
		}
		else if(pl->step>51)
			pl->step-=52;
		else if(pl->step<0)
			pl->step=51;
	}
	else if(pl->state==3)
	{
		int k;
		k=OverStep(pl->Color)+6;//飞机降落点
		if(pl->step==k)
		{
			pl->step--;
			gh=-1;
		}
		else
		{
			pl->step+=gh;
		}
	}
	return gh;
}