陈韵霖

UID: 399, 注册于 2025-9-16 13:33:55, 最后登录于 2026-4-15 15:42:12, 目前离线.

解决了 89 道题目，RP: 62.55 (No. 88)

个人简介

该用户太懒，这里啥也没写 (´・ω・｀)

来源于黄子峻
不可抄袭
狼人杀游戏
#include<bits/stdc++.h>
#include<windows.h>
#include<conio.h>
using namespace std;
const int daytime=0,night=1;
int day=0, during_time=daytime, player_number, my_number;
HWND hwnd=GetForegroundWindow();
const int blue=0,yellow=1,red=2,green=3,purple=4,white=5;//颜色常量
void color(int c){
```
switch(c){
```

	case red:SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);break;

	case green:SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);break;

	case yellow:SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED |FOREGROUND_GREEN);break;

	case blue:SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_BLUE);break;

	case white:SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED |FOREGROUND_GREEN | FOREGROUND_BLUE);break;

	case purple:SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED |FOREGROUND_BLUE);break;

```
}
```
}
int idx_police=-1;
void gotoxy(int x,int y){
```
COORD position;
```
```
position.X=x;
```
```
position.Y=y;
```

SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), position);

}
void init_Show_Window(){
```
system("mode con lines=60 cols=188"); 
```

ShowWindow(hwnd,SW_MAXIMIZE);//窗口最大化

DeleteMenu(GetSystemMenu(GetConsoleWindow(), FALSE), SC_CLOSE, MF_BYCOMMAND);

DrawMenuBar(GetConsoleWindow());//删除×字符

}
/玩家类/
const int nvwu=0,cunmin=1,yuyanjia=2,langren=3,lieren=4,shouwei=5,good=6,die=1,life=2;
class player{
public:
```
int type;
```
```
int die_or_life;
```
```
int how(){
```
```
	return die_or_life;
```
```
}
```
```
int is_light;//是否已经公布 
```
```
int killer;
```
};
player players[1000];
/转换白天模式/
void change_daytime(){
```
during_time=daytime;
```
```
day++;
```
}
/转换黑夜模式/
void change_night(){
```
during_time=night;
```
}
int nnvwu=0,ncunmin=0,nyuyanjia=0,nlangren=0,nlieren=0,nshouwei=0;
int idxnvwu,idxshouwei,idxyuyanjia,idxlieren,idxlangren[4]={-1,-1,-1,-1};
/b是否在Arr中/
bool is_include(int arr[],int b,int l){
```
for(int i=0;i<l;i++){
```
```
	if(arr[i]==b)
```
```
		return true;
```
```
}
```
```
return false;
```
}
/初始化人数/
void init_players(){
```
my_number=rand()%player_number;
```
```
if(player_number==12) nlangren=4;
```
```
else if(player_number>=10) nlangren=3;
```
```
else nlangren=2;
```
```
for(int i=0;i<player_number;i++)
```
```
{
```
```
	players[i].die_or_life=life;
```
```
	players[i].is_light=0;
```
```
	players[i].type=-1;
```
```
	players[i].killer=2147483647;
```
```
}
```
for(int i=0;i<nlangren;i++)
{
```
   int p=rand()%player_number;
```
```
   if(!is_include(idxlangren,p,4))
```

   	idxlangren[i]=p,players[p].type=langren;

```
   else
```
```
   	i--;
```
```
   Sleep(rand()%80+100);
```
}
if(player_number==12)
{
```
   do{
```
```
   	idxshouwei=rand()%player_number;
```

   }while(players[idxshouwei].type!=-1);

   players[idxshouwei].type=shouwei;

}
do{
```
   idxnvwu=rand()%player_number;
```
}while(players[idxnvwu].type!=-1);
players[idxnvwu].type=nvwu;
if(player_number>=10)
{
```
   do{
```
```
   	idxlieren=rand()%player_number;
```

   }while(players[idxlieren].type!=-1);

```
   players[idxlieren].type=lieren;   
```
}
do{
```
   idxyuyanjia=rand()%player_number;
```
}while(players[idxyuyanjia].type!=-1);
players[idxyuyanjia].type=yuyanjia;
for(int i=0;i<player_number;i++)
```
   if(players[i].type==-1)
```
```
   	players[i].type=cunmin,
```
```
   	ncunmin++;
```
if(players[my_number].type==langren)
{
```
   for(int i=0;i<nlangren;i++)
```
```
   {
```
```
   	players[idxlangren[i]].is_light=1;
```
```
   }
```
}
players[my_number].is_light=1;
}
/在屏幕上打印东西/
void print(){
gotoxy(0,0);
cout<<"作者：洛谷393864";
gotoxy(90,0);
if(during_time==night)
```
   color(red);
```
else
```
   color(blue);
```
printf("第%d天 | ",day);
if(during_time==night) cout<<"黑夜";
else cout<<"白天";
gotoxy(0,3);
color(blue);
cout<<" 我的号位:"<<my_number+1;
for(int i=0;i<player_number;i++){
```
   gotoxy(i*8+1,4);
```
```
   if(i==idx_police) color(yellow);
```
```
   else color(blue);
```
```
   cout<<i+1<<"号位"; 
```
```
   gotoxy(i*8+1,5);
```
```
   if(players[i].how()==die){
```
```
   	color(red);
```
```
   	cout<<"死 亡";
```
```
   }else{
```
```
   	color(green);
```
```
   	cout<<"存 活";
```
```
   }
```
```
   gotoxy(i*8+1,6);
```
```
   color(blue);
```
```
   if(players[i].is_light){
```
```
   	if(players[i].is_light==1){
```
```
   		switch(players[i].type){
```

   			case nvwu: cout<<"女 巫";break;

   			case yuyanjia: cout<<"\b预言家";break;

   			case cunmin: cout<<"村 民";break;

   			case langren:cout<<"狼 人"; break;

   			case lieren:cout<<"猎 人"; break;

   			case shouwei:cout<<"守 卫"; break;

```
   		}   
```
```
   	}else{
```
```
   		cout<<"好人";
```
```
   	}
```
```
   }else{
```
```
   	cout<<"未知";
```
```
   }
```
}
}
/判断是否结束,没结束返回0 好人胜利返回1 狼人胜利返回2 平局返回3/
int is_end(){
int die_bad=0;
int die_people=0;
int die_god=0;
for(int i=0;i<player_number;i++){

   if((players[i].type == nvwu || players[i].type == yuyanjia || players[i].type == shouwei)&&players[i].die_or_life==die)

```
   	die_god++;
```

   else if(players[i].type == langren && players[i].die_or_life==die)

```
   	die_bad++;
```

   else if(players[i].type == cunmin && players[i].die_or_life==die)

```
   	die_people++;
```
}
if((die_baddie_people || die_baddie_god)&&(die_bad>=nlangren))
```
   return 3;
```
if(die_bad>=nlangren)
```
   return 1;
```
if(die_people>=ncunmin||die_god>=(player_number>=10 ? 3:2))
```
   return 2;
```
return 0;
}
/游戏开始前的骚操作/
void before_game(){
srand(time(NULL));
init_Show_Window();
color(green);
cout<<"欢迎来到狼人杀游戏\t\t\t为了更好的游戏体验,请右键点击上方↑↑,点击"属性",点击"字体"栏目,将字体修改为宋体或新宋体,将字号改为20\n作者：洛谷393864\n请勿私自转载,违者依法追究法律责任注：10 11 12人局开设猎人 12人局开设守卫警长\n______________________\n";
cout<<"请输入玩家人数(8-12人):";
cin>>player_number;
while(player_number<8||player_number>12)
{ cout<<"请重新输入！\n"; cin>>player_number; }
system("cls");
cout<<"初始化身份中，请稍等.";
for(int i=0;i<6;i++){
```
   for(int j=0;j<12;j++){
```
```
   	cout<<".";
```
```
   	Sleep(50);
```
```
   }   
```

   cout<<"\b\b\b\b\b\b\b\b\b\b\b\b            \b\b\b\b\b\b\b\b\b\b\b\b";

}
system("cls");
init_players();
cout<<"我的号位:"<<my_number+1<<endl
<<"我的身份:";
switch(players[my_number].type){
```
   case nvwu: cout<<"女巫\n";break;
```

   case yuyanjia: cout<<"预言家\n";break;

   case cunmin: cout<<"村民\n";break;

   case langren:cout<<"狼人\n";break;

   case lieren:cout<<"猎人\n"; break;

   case shouwei:cout<<"守卫\n";break;

}
change_daytime();
system("pause");
system("cls");
cout<<"游戏加载中.";int ppppp=rand()%3+2;
for(int i=0;i<ppppp;i++){
```
   for(int j=0;j<6;j++){
```
```
   	cout<<".";
```
```
   	Sleep(rand()%100+150);
```
```
   }   
```

   cout<<"\b\b\b\b\b\b      \b\b\b\b\b\b";

}
print();
}
/每一天开始前的操作/
void something_before_everyday(){
change_night();
system("cls");
print();
gotoxy(0,7);
cout<<"________________________";
gotoxy(0,8);
color(white);
cout<<"天黑~请闭眼~~~\n";
}
/守卫操作/
int shouweishou=0;
int ShouWei(){
color(blue);
cout<<"守卫~请睁眼~~\n";
Sleep(1500);
cout<<"你要守护的是?\n";
if(players[my_number].type==shouwei&&players[my_number].die_or_life == life){
```
   cin>>shouweishou;
```

   while(!(shouweishou>=1&&shouweishou<=player_number&&players[shouweishou-1].die_or_life == life)){

```
   	cout<<"请重新输入！\n";
```
```
   	cin>>shouweishou;
```
```
   }
```

   cout<<"你今晚要守护的是"<<shouweishou<<"号\n";

```
   Sleep(1500); 
```
```
   shouweishou--;
```
}else{

   if(players[idxshouwei].die_or_life == life){

```
   	shouweishou=rand()%10;
```

   	while(!(shouweishou>=1&&shouweishou<=player_number&&players[shouweishou-1].die_or_life == life)){

```
   		shouweishou=rand()%10;
```
```
   	}
```
```
   }
```
}
Sleep(2000);
cout<<"守卫请闭眼"<<endl<<endl;
return shouweishou;
}
/狼人操作/
int LangRen(){
int langrensha=-1;
color(red);
cout<<"狼人~请睁眼~~~\n";
Sleep(1500);
cout<<"你们今晚要杀~谁~~??\n";
if(players[my_number].type==langren&&players[my_number].die_or_life == life){
```
   cin>>langrensha;
```

   while(!(langrensha>=1&&langrensha<=player_number&&players[langrensha-1].die_or_life==life)){

```
   	cout<<"请重新输入!\n";
```
```
   	cin>>langrensha;
```
```
   }
```

   cout<<"你们今晚要杀的是"<<langrensha--<<"号\n";

```
   Sleep(3500);
```
}else{

   while(langrensha==-1 || players[langrensha].die_or_life == die || players[langrensha].type==langren){

```
   	langrensha=rand()%player_number;
```
```
   }
```
```
   Sleep(3000);
```
}
cout<<"狼人请~闭眼~~\n\n";
return langrensha;
}
/女巫操作/
int nvwujiu=0,nvwudu=0,is_nvwujiu=0,is_nvwudu=0;
int NvWu(int langrensha){
color(purple);
cout<<"女巫~~请睁眼~~\n";
Sleep(2000);
if(players[my_number].type==nvwu&&players[my_number].die_or_life == life){
```
   if(is_nvwujiu) 
```

   	cout<<"你已经用过解药\n",Sleep(1500);

```
   else
```
```
   {
```

   	cout<<"今晚"<<langrensha+1<<"号死了,你想用解药吗？(1想 / 2不想)\n";

```
   	int is_nvwujie=0;
```
```
   	cin>>is_nvwujie;
```

   	while(is_nvwujie!=1&&is_nvwujie!=2){

```
   		cout<<"请重新输入\n";
```
```
   		cin>>is_nvwujie;
```
```
   	} 
```
```
   	if(is_nvwujie==1) {
```
```
   		Sleep(1000);
```

   		cout<<"已经解救"<<langrensha+1<<"号\n";

```
   		nvwujiu=langrensha;
```
```
   	}
```
```
   	is_nvwujiu=1;
```
```
   }
```
```
   Sleep(1500);
```

   if(::is_nvwudu) cout<<"你已经用过毒药\n",Sleep(1500);

```
   else
```
```
   {
```

   	cout<<"你想用毒药吗？（1想 / 2不想）\n";

```
   	Sleep(1500);
```
```
   	int is_nvwudu=0;
```
```
   	cin>>is_nvwudu;
```
```
   	while(is_nvwudu!=1&&is_nvwudu!=2){
```
```
   		cout<<"请重新输入\n";
```
```
   		cin>>is_nvwudu;
```
```
   	}   
```
```
   	if(is_nvwudu==1){
```
```
   		Sleep(1500);
```
```
   		cout<<"你想毒死谁？\n"; 
```
```
   		cin>>nvwudu;
```

   		while(!(nvwudu>=1&&nvwudu<=player_number&&players[nvwudu].die_or_life==life)){

```
   			cout<<"请重新输入\n";
```
```
   			cin>>nvwudu; 
```
```
   		}
```
```
   		nvwudu--;
```
```
   		Sleep(1500);
```

   		cout<<"已经毒死了"<<nvwudu+1<<"号\n";

```
   	}
```
```
   	::is_nvwudu=1;
```
```
   }   
```
}else{

   if(players[idxnvwu].die_or_life == life){

```
   	if(!is_nvwujiu)
```
```
   	{
```
```
   		int is_jiu=rand()%8;
```
```
   		if(is_jiu==0){
```
```
   			nvwujiu=langrensha;
```
```
   			is_nvwujiu=1;
```
```
   		}   
```
```
   	}
```
```
   	if(!is_nvwudu)
```
```
   	{
```
```
   		int is_du=rand()%4;
```
```
   		if(is_du==0){
```
```
   			int num=rand()%player_number;
```
```
   			nvwudu=num;
```
```
   			is_nvwudu=1;
```
```
   		}
```
```
   	}
```
```
   }
```
}
cout<<"女巫~请闭眼~~\n\n";
return nvwujiu*10000+nvwudu;//传回两个变量，“加密”操作
}
int yuyanjiabixutoupiao=-1;
/预言家操作/
void YuYanJia(){
color(green);
cout<<"预言家~请睁眼~~\n";
Sleep(2000);
if(players[my_number].type==yuyanjia&&players[my_number].die_or_life == life){

   cout<<"请问你想查验谁的身份\n";

```
   int p;
```
```
   cin>>p;
```
```
   while(!(p>=1&&p<=player_number)){
```
```
   	cout<<"请重新输入！\n";
```
```
   	cin>>p;
```
```
   }
```
```
   Sleep(2000);
```
```
   cout<<p<<"号的身份是——";
```
```
   Sleep(1000);
```
```
   if(players[p-1].type == langren){
```
```
   	cout<<"狼人\n";
```
```
   	players[p-1].is_light = 1;
```
```
   }else{
```
```
   	cout<<"好人\n";
```
```
   	players[p-1].is_light = 2;
```
```
   }
```
}else{
```
   int p=-1;
```

   while(p==-1||players[p].die_or_life==die||p==idxlieren)

```
   	p=rand()%player_number;
```

   if(players[p].type==langren)//锁定目标!

```
   {
```
```
   	yuyanjiabixutoupiao=p;
```
```
   }
```
}
cout<<"预言家~~请闭眼~~\n";
}
/黑夜操作/
int LANGRENSHA=-1,NVWUDU=-1,NVWUJIU=-1,SHOUWEISHOU=-1;
void Night(){
LANGRENSHA=-1,NVWUDU=-1,NVWUJIU=-1,SHOUWEISHOU=-1;
//如果有12人局，添加守卫
if(player_number==12){
```
   SHOUWEISHOU=ShouWei();
```
```
   Sleep(2000);
```
}
/狼人部分/
LANGRENSHA=LangRen();
Sleep(3500);
/女巫部分/
int nvwu=NvWu(LANGRENSHA);
NVWUDU=nvwu%10+nvwu/10%10;
NVWUJIU=nvwu/10000%10+nvwu/100000%10;
Sleep(3000);
/预言家部分/
YuYanJia();
Sleep(2000);
}
/猎人操作/
void Lieren(){
int lierendai=-1;
cout<<idxlieren+1<<"号是猎人\n";
players[idxlieren].is_light = 1;
Sleep(1000);
if(idxlieren==my_number){
```
   cout<<"你想带走几号？\n";
```
```
   cin>>lierendai;
```

   while(lierendai<1||lierendai>player_number||players[lierendai].die_or_life==die){

```
   	cout<<"请重新输入！\n";
```
```
   	cin>>lierendai;
```
```
   }
```
```
   lierendai--;
```
}else{
```
   lierendai=rand()%player_number;
```

   while(players[lierendai].die_or_life == die){

```
   	lierendai=rand()%player_number;
```
```
   }
```
}
Sleep(2000);
cout<<"猎人选择带走"<<lierendai+1<<"号\n";
Sleep(2000);
players[lierendai].die_or_life = die;
}
void police_die();
/判断谁死了/
void panduansiwang(){
system("cls");
print();
gotoxy(0,7);
cout<<"________________________\n";
Sleep(3000);
color(white);
cout<<"天亮了\n";
Sleep(2000);
gotoxy(0,9);
cout<<"昨晚";
bool is_die[15]={false},is_die_lieren=false,flag=false;
for(int i=0;i<player_number;i++)
{
```
   if(players[i].die_or_life==life)
```
```
   {
```
```
   	if(i==LANGRENSHA||i==NVWUDU) {
```

   		if(players[i].type==lieren) is_die_lieren=true;

   		players[i].killer= (i==LANGRENSHA ? langren:nvwu);

```
   		players[i].die_or_life=die;
```
```
   		is_die[i]=true;
```
```
   	}
```
```
   	if(i==SHOUWEISHOU||i==NVWUJIU) {
```

   		if(players[i].type==lieren) is_die_lieren=false;

```
   		players[i].killer=-1;
```
```
   		players[i].die_or_life=life;
```
```
   		is_die[i]=false;
```
```
   	}   
```
```
   }
```
}
bool is_police_die=false;
for(int i=0;i<player_number;i++)
{
```
   if(is_die[i])
```
```
   {
```
```
   	if(flag) cout<<"和"<<i+1<<"号";
```
```
   	else cout<<i+1<<"号",flag=true;
```
```
   	if(i==idx_police) 
```
```
   		is_police_die=true;
```
```
   }
```
}
if(flag) cout<<"死了\n";
else cout<<"是平安夜\n";
if(is_die_lieren) Lieren();
if(is_police_die) police_die();
}
/选警长/
void choose_police(){
system("cls");
print();
color(blue);
gotoxy(0,7);
cout<<"________________________\n";
color(yellow);
cout<<"下面开始选举警长，各位不能选举自己~\n";
int tong[100]={0},cannot[100],must[100]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
memset(cannot,-1,sizeof(cannot));
CHOOSE:
color(yellow);
Sleep(1500);
for(int i=0;i<player_number;i++)
{

   if(players[i].die_or_life==life&&!is_include(cannot,i,player_number))

```
   {
```
```
   	if(i==my_number)
```
```
   	{
```
```
   		cout<<"你要选举几号？\n";
```
```
   		int n;
```
```
   		cin>>n;
```

   		while(n<1||n>player_number||n==i+1||players[n-1].die_or_life==die||!is_include(must,n-1,player_number))

```
   		{
```
```
   			cout<<"请重新输入!\n";
```
```
   			cin>>n;
```
```
   		}
```

   		cout<<i+1<<"号选举"<<n--<<"号\n";

```
   		tong[n]++;
```
```
   	}
```
```
   	else
```
```
   	{
```
```
   		int n=rand()%player_number;
```

   		while(n==i||players[n].die_or_life==die||!is_include(must,n,player_number))

```
   			n=rand()%player_number;
```

   		cout<<i+1<<"号选举"<<n+1<<"号\n";

```
   		tong[n]++;
```
```
   	}
```
```
   	Sleep(1500);
```
```
   }
```
}
int idx_max=-1,maxn=-1,len=0;
for(int i=0;i<player_number;i++)
```
   if(maxn<tong[i])
```
```
   {
```
```
   	maxn=tong[i];
```
```
   	idx_max=i;
```
```
   }
```
int maxn_arr[15]={0};
for(int i=0;i<player_number;i++)
{
```
   if(tong[i]==maxn)
```
```
   {
```
```
   	maxn_arr[len++]=i;
```
```
   }
```
}
color(blue);
if(len>1)
{
```
   for(int i=0;i<len;i++)
```
```
   {
```
```
   	if(i==len-1)
```
```
   	{
```

   		cout<<maxn_arr[i]+1<<"号平票\n";

```
   	}
```
```
   	else
```
```
   	{
```
```
   		cout<<maxn_arr[i]+1<<"号,";
```
```
   	}
```
```
   }
```
```
   for(int i=0;i<len;i++)
```
```
   	cannot[i]=maxn_arr[i];
```
```
   for(int i=0;i<player_number;i++)
```
```
   {
```
```
   	if(is_include(cannot,i,len))
```
```
   		must[i]=i;
```
```
   	else
```
```
   		must[i]=-1;
```
```
   }
```
```
   color(white);
```
```
   goto CHOOSE;
```
}
cout<<"恭喜"<<idx_max+1<<"号当选警长\n";
Sleep(3000);
idx_police=idx_max;
return;
}
/投票/
int toupiao(){
int tong[100]={0},cannot[100]={},must[100]={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
memset(cannot,-1,sizeof(cannot));
gotoxy(0,7);
color(blue);
cout<<"________________________\n";
color(white);
cout<<"下面进入投票环节\n";
memset(tong,0,sizeof(tong));
Sleep(2000);
TOUPIAO:
for(int i=0;i<player_number;i++){

   if(players[i].die_or_life == life&&!is_include(cannot,i,player_number)){

```
   	if(i==my_number){
```
```
   		color(white);
```
```
   		cout<<"你要投几号？\n";
```
```
   		int n;
```
```
   		cin>>n;
```

   		while(!(n>=1&&n<=player_number&&is_include(must,n-1,player_number))){

```
   			cout<<"请重新输入！\n";
```
```
   			cin>>n;
```
```
   		}
```
```
   		Sleep(2000);
```

   		cout<<setw(2)<<my_number+1<<"号投了"<<setw(2)<<n<<"号";

   		if(my_number==n-1) color(red),cout<<"快来看！这有个疯子投自己！";

   		if(i==idx_police) color(yellow),cout<<"(警长)\n"; else cout<<"\n";

```
   		if(i==idx_police) tong[n-1]++;
```
```
   		tong[n-1]++;
```
```
   	}else{
```
```
   		color(white);
```
```
   		int t=-1;
```

   		while(t==-1 || players[t].die_or_life == die || t==i || !is_include(must,t,player_number)){

   			if(i==idxyuyanjia&&yuyanjiabixutoupiao!=-1)

```
   			{
```
```
   				t=yuyanjiabixutoupiao;
```
```
   				yuyanjiabixutoupiao=-1;
```
```
   				continue;
```
```
   			}
```
```
   			t=rand()%player_number;
```

   			if(is_include(idxlangren,i,nlangren))

```
   			{
```
```
   				if(players[t].type == langren)
```
```
   					t=-1;
```
```
   			}
```
```
   		}
```

   		cout<<setw(2)<<i+1<<"号"<<"投了"<<setw(2)<<t+1<<"号";

   		if(i==idx_police) cout<<"(警长2票)\n"; else cout<<"\n";

```
   		if(i==idx_police) tong[t]++;
```
```
   		tong[t]++;  
```
```
   	}
```
```
   	Sleep(rand()%1000+1000);
```
```
   }
```
}
int idx_max=-1,maxn=-1,len=0;
for(int i=0;i<player_number;i++)
```
   if(maxn<tong[i])
```
```
   {
```
```
   	maxn=tong[i];
```
```
   	idx_max=i;
```
```
   }
```
int maxn_arr[15]={0};
for(int i=0;i<player_number;i++)
{
```
   if(tong[i]==maxn)
```
```
   {
```
```
   	maxn_arr[len++]=i;
```
```
   }
```
}
color(blue);
if(len>1)
{
```
   for(int i=0;i<len;i++)
```
```
   {
```
```
   	if(i==len-1)
```
```
   	{
```

   		cout<<maxn_arr[i]+1<<"号平票\n";

```
   	}
```
```
   	else
```
```
   	{
```
```
   		cout<<maxn_arr[i]+1<<"号,";
```
```
   	}
```
```
   }
```
```
   for(int i=0;i<len;i++)
```
```
   	cannot[i]=maxn_arr[i];
```
```
   for(int i=0;i<player_number;i++)
```
```
   {
```
```
   	if(is_include(cannot,i,len))
```
```
   		must[i]=i;
```
```
   	else
```
```
   		must[i]=-1;
```
```
   }
```
```
   color(white);
```
```
   goto TOUPIAO;
```
}
cout<<idx_max+1<<"号"<<"出局\n";
Sleep(4000);
players[idx_max].die_or_life = die;
players[idx_max].killer = good;
return idx_max;
}
/警长死亡/
void police_die(){
color(yellow);
int type;
if(idx_police==my_number)
{
```
   Sleep(1550);
```

   cout<<"你是想撕毁警徽还是移交警徽？（撕毁输入1，移交输入2)";

```
   cin>>type;
```
```
   while(!(type==1||type==2))
```
```
   {
```
```
   	cout<<"请重新输入！\n";
```
```
   	cin>>type;
```
```
   }
```
}
else{
```
   type=rand()%3+1;
```
}
if(type==1)
{
```
   cout<<"警长选择撕毁警徽\n";
```
```
   Sleep(1000);
```
```
   idx_police=-1;
```
}
else
{
```
   int lucky=-1;
```

   while(lucky==-1||players[lucky].die_or_life==die)

```
   	lucky=rand()%player_number;
```

   cout<<"警长选择把警徽移交给"<<lucky+1<<"号\n";

```
   Sleep(1500);
```
```
   idx_police=lucky; 
```
}
}
/故事的最后/
void the_end(){
system("cls");
switch(is_end()){

   case 1:cout<<"好人胜利\n\n"; break;

   case 2:cout<<"狼人胜利\n\n"; break;

   case 3:cout<<"本局平局\n\n"; break;

}
for(int i=0;i<player_number;i++){
```
   cout<<i+1<<"号位:\t";
```
```
   switch(players[i].type){
```
```
   	case nvwu: cout<<"女巫\t";break;
```

   	case yuyanjia: cout<<"预言家\t";break;

   	case cunmin: cout<<"村民\t";break;

   	case langren:cout<<"狼人\t";break;

   	case lieren:cout<<"猎人\t"; break;

   	case shouwei:cout<<"守卫\t";break;

```
   } 
```
```
   cout<<"最终";
```
```
   switch(players[i].killer){
```

   	case nvwu:cout<<"被女巫毒死\n"; break;

   	case langren:cout<<"被狼人杀死\n"; break;

   	case good:cout<<"被投票出局\n"; break;

   	case lieren:cout<<"被猎人带走\n";break;

```
   	default :cout<<"存活\n";
```
```
   }
```
```
   cout<<endl;
```
}
}
/主函数/
int main(){
int wheel=0;
before_game();
while(!is_end()){
```
   //黑夜准备 
```
```
   something_before_everyday();
```
```
   Sleep(1500); 
```
```
   //黑夜部分 
```
```
   Night(); //进入黑夜！ 
```
```
   change_daytime(); //换天 
```
```
   //天亮了 
```
```
   panduansiwang();//判断谁死了 
```
```
   Sleep(2000);
```
```
   system("cls");
```
```
   print();
```
```
   if(is_end()) break;
```
```
   //选警长 
```
```
   if(!wheel&&player_number==12)
```
```
   {
```
```
   	choose_police();
```
```
   	system("cls");
```
```
   	print();
```
```
   }
```
```
   //投票环节 
```

   int idx_max=toupiao();//票数最多的人

```
   if(idx_max==idx_police){
```
```
   	police_die();
```
```
   }
```

   if(players[idx_max].type==lieren){//启动猎人程序

```
   	Lieren();
```
```
   	if(is_end()) break;
```
```
   }
```
```
   system("cls");
```
```
   print(); 
```
```
   wheel++;
```
}
the_end();
system("pause");
return 0;
}
贪吃蛇游戏
#include <stdio.h>
#include <Windows.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#define ROW 22 //游戏区行数
#define COL 42 //游戏区列数
#define KONG 0 //标记空（什么也没有）
#define WALL 1 //标记墙
#define FOOD 2 //标记食物
#define HEAD 3 //标记蛇头
#define BODY 4 //标记蛇身
#define UP 72 //方向键：上
#define DOWN 80 //方向键：下
#define LEFT 75 //方向键：左
#define RIGHT 77 //方向键：右
#define SPACE 32 //暂停
#define ESC 27 //退出
//蛇头
struct Snake
{
```
int len; //记录蛇身长度
```
```
int x; //蛇头横坐标
```
```
int y; //蛇头纵坐标
```
}snake;
//蛇身
struct Body
{
```
int x; //蛇身横坐标
```
```
int y; //蛇身纵坐标
```
}body[ROW*COL]; //开辟足以存储蛇身的结构体数组
int face[ROW][COL]; //标记游戏区各个位置的状态
//隐藏光标
void HideCursor();
//光标跳转
void CursorJump(int x, int y);
//初始化界面
void InitInterface();
//颜色设置
void color(int c);
//从文件读取最高分
void ReadGrade();
//更新最高分到文件
void WriteGrade();
//初始化蛇
void InitSnake();
//随机生成食物
void RandFood();
//判断得分与结束
void JudgeFunc(int x, int y);
//打印蛇与覆盖蛇
void DrawSnake(int flag);
//移动蛇
void MoveSnake(int x, int y);
//执行按键
void run(int x, int y);
//游戏主体逻辑函数
void Game();
int max, grade; //全局变量
int main()
{
#pragma warning (disable:4996) //消除警告
```
max = 0, grade = 0; //初始化变量
```

system("title 贪吃蛇"); //设置cmd窗口的名字

system("mode con cols=84 lines=23"); //设置cmd窗口的大小

```
HideCursor(); //隐藏光标
```

ReadGrade(); //从文件读取最高分到max变量

```
InitInterface(); //初始化界面
```
```
InitSnake(); //初始化蛇
```

srand((unsigned int)time(NULL)); //设置随机数生成起点

```
RandFood(); //随机生成食物
```
```
DrawSnake(1); //打印蛇
```
```
Game(); //开始游戏
```
```
return 0;
```
}
//隐藏光标
void HideCursor()
{

CONSOLE_CURSOR_INFO curInfo; //定义光标信息的结构体变量

curInfo.dwSize = 1; //如果没赋值的话，光标隐藏无效

curInfo.bVisible = FALSE; //将光标设置为不可见

HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); //获取控制台句柄

SetConsoleCursorInfo(handle, &curInfo); //设置光标信息

}
//光标跳转
void CursorJump(int x, int y)
{

COORD pos; //定义光标位置的结构体变量

```
pos.X = x; //横坐标
```
```
pos.Y = y; //纵坐标
```

HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE); //获取控制台句柄

SetConsoleCursorPosition(handle, pos); //设置光标位置

}
//初始化界面
void InitInterface()
{
```
color(6); //颜色设置为土黄色
```
```
for (int i = 0; i < ROW; i++)
```
```
{
```
```
    for (int j = 0; j < COL; j++)
```
```
    {
```
```
        if (j == 0 || j == COL - 1)
```
```
        {
```

            face[i][j] = WALL; //标记该位置为墙

```
            CursorJump(2 * j, i);
```
```
            printf("■");
```
```
        }
```

        else if (i == 0 || i == ROW - 1)

```
        {
```

            face[i][j] = WALL; //标记该位置为墙

```
            printf("■");
```
```
        }
```
```
        else
```
```
        {
```

            face[i][j] = KONG; //标记该位置为空

```
        }
```
```
    }
```
```
}
```
```
color(7); //颜色设置为白色
```
```
CursorJump(0, ROW);
```
```
printf("当前得分:%d", grade);
```
```
CursorJump(COL, ROW);
```
```
printf("历史最高得分:%d", max);
```
}
//颜色设置
void color(int c)
{

SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), c); //颜色设置

//注：SetConsoleTextAttribute是一个API（应用程序编程接口）

}
//从文件读取最高分
void ReadGrade()
{

FILE* pf = fopen("贪吃蛇最高得分记录.txt", "r"); //以只读的方式打开文件

```
if (pf == NULL) //打开文件失败
```
```
{
```

    pf = fopen("贪吃蛇最高得分记录.txt", "w"); //以只写的方式打开文件

    fwrite(&max, sizeof(int), 1, pf); //将max写入文件（此时max为0），即将最高得分初始化为0

```
}
```

fseek(pf, 0, SEEK_SET); //使文件指针pf指向文件开头

fread(&max, sizeof(int), 1, pf); //读取文件当中的最高得分到max当中

```
fclose(pf); //关闭文件
```
```
pf = NULL; //文件指针及时置空
```
}
//更新最高分到文件
void WriteGrade()
{

FILE* pf = fopen("贪吃蛇最高得分记录.txt", "w"); //以只写的方式打开文件

```
if (pf == NULL) //打开文件失败
```
```
{
```

    printf("保存最高得分记录失败\n");

```
    exit(0);
```
```
}
```

fwrite(&grade, sizeof(int), 1, pf); //将本局游戏得分写入文件当中

```
fclose(pf); //关闭文件
```
```
pf = NULL; //文件指针及时置空
```
}
//初始化蛇
void InitSnake()
{

snake.len = 2; //蛇的身体长度初始化为2

snake.x = COL / 2; //蛇头位置的横坐标

snake.y = ROW / 2; //蛇头位置的纵坐标

```
//蛇身坐标的初始化
```
```
body[0].x = COL / 2 - 1;
```
```
body[0].y = ROW / 2;
```
```
body[1].x = COL / 2 - 2;
```
```
body[1].y = ROW / 2;
```
```
//将蛇头和蛇身位置进行标记
```
```
face[snake.y][snake.x] = HEAD;
```
```
face[body[0].y][body[0].x] = BODY;
```
```
face[body[1].y][body[1].x] = BODY;
```
}
//随机生成食物
void RandFood()
{
```
int i, j;
```
```
do
```
```
{
```

    //随机生成食物的横纵坐标

```
    i = rand() % ROW;
```
```
    j = rand() % COL;
```

} while (face[i][j] != KONG); //确保生成食物的位置为空，若不为空则重新生成

face[i][j] = FOOD; //将食物位置进行标记

```
color(12); //颜色设置为红色
```

CursorJump(2 * j, i); //光标跳转到生成的随机位置处

```
printf("●"); //打印食物
```
}
//判断得分与结束
void JudgeFunc(int x, int y)
{

//若蛇头即将到达的位置是食物，则得分

if (face[snake.y + y][snake.x + x] == FOOD)

```
{
```
```
    snake.len++; //蛇身加长
```
```
    grade += 10; //更新当前得分
```
```
    color(7); //颜色设置为白色
```
```
    CursorJump(0, ROW);
```

    printf("当前得分:%d", grade); //重新打印当前得分

    RandFood(); //重新随机生成食物

```
}
```

//若蛇头即将到达的位置是墙或者蛇身，则游戏结束

else if (face[snake.y + y][snake.x + x] == WALL || face[snake.y + y][snake.x + x] == BODY)

```
{
```

    Sleep(1000); //留给玩家反应时间

```
    system("cls"); //清空屏幕
```
```
    color(7); //颜色设置为白色
```

    CursorJump(2 * (COL / 3), ROW / 2 - 3);

```
    if (grade > max)
```
```
    {
```

        printf("恭喜你打破最高记录，最高记录更新为%d", grade);

```
        WriteGrade();
```
```
    }
```
```
    else if (grade == max)
```
```
    {
```

        printf("与最高记录持平，加油再创佳绩", grade);

```
    }
```
```
    else
```
```
    {
```

        printf("请继续加油，当前与最高记录相差%d", max - grade);

```
    }
```

    CursorJump(2 * (COL / 3), ROW / 2);

```
    printf("GAME OVER");
```

    while (1) //询问玩家是否再来一局

```
    {
```
```
        char ch;
```

        CursorJump(2 * (COL / 3), ROW / 2 + 3);

```
        printf("再来一局?(y/n):");
```
```
        scanf("%c", &ch);
```
```
        if (ch == 'y' || ch == 'Y')
```
```
        {
```
```
            system("cls");
```
```
            main();
```
```
        }
```

        else if (ch == 'n' || ch == 'N')

```
        {
```

            CursorJump(2 * (COL / 3), ROW / 2 + 5);

```
            exit(0);
```
```
        }
```
```
        else
```
```
        {
```

            CursorJump(2 * (COL / 3), ROW / 2 + 5);

            printf("选择错误，请再次选择");

```
        }
```
```
    }
```
```
}
```
}
//打印蛇与覆盖蛇
void DrawSnake(int flag)
{
```
if (flag == 1) //打印蛇
```
```
{
```
```
    color(10); //颜色设置为绿色
```
```
    CursorJump(2 * snake.x, snake.y);
```
```
    printf("■"); //打印蛇头
```

    for (int i = 0; i < snake.len; i++)

```
    {
```

        CursorJump(2 * body[i].x, body[i].y);

```
        printf("□"); //打印蛇身
```
```
    }
```
```
}
```
```
else //覆盖蛇
```
```
{
```

    if (body[snake.len - 1].x != 0) //防止len++后将(0, 0)位置的墙覆盖

```
    {
```

        //将蛇尾覆盖为空格即可

        CursorJump(2 * body[snake.len - 1].x, body[snake.len - 1].y);

```
        printf("  ");
```
```
    }
```
```
}
```
}
//移动蛇
void MoveSnake(int x, int y)
{

DrawSnake(0); //先覆盖当前所显示的蛇

face[body[snake.len - 1].y][body[snake.len - 1].x] = KONG; //蛇移动后蛇尾重新标记为空

face[snake.y][snake.x] = BODY; //蛇移动后蛇头的位置变为蛇身

//蛇移动后各个蛇身位置坐标需要更新

for (int i = snake.len - 1; i > 0; i--)

```
{
```
```
    body[i].x = body[i - 1].x;
```
```
    body[i].y = body[i - 1].y;
```
```
}
```

//蛇移动后蛇头位置信息变为第0个蛇身的位置信息

```
body[0].x = snake.x;
```
```
body[0].y = snake.y;
```
```
//蛇头的位置更改
```
```
snake.x = snake.x + x;
```
```
snake.y = snake.y + y;
```
```
DrawSnake(1); //打印移动后的蛇
```
}
//执行按键
void run(int x, int y)
{
```
int t = 0;
```
```
while (1)
```
```
{
```
```
    if (t == 0)
```

        t = 3000; //这里t越小，蛇移动速度越快（可以根据次设置游戏难度）

```
    while (--t)
```
```
    {
```

        if (kbhit() != 0) //若键盘被敲击，则退出循环

```
            break;
```
```
    }
```
```
    if (t == 0) //键盘未被敲击
```
```
    {
```

        JudgeFunc(x, y); //判断到达该位置后，是否得分与游戏结束

```
        MoveSnake(x, y); //移动蛇
```
```
        Sleep(5000);
```
```
    }
```
```
    else //键盘被敲击
```
```
    {
```

        break; //返回Game函数读取键值

```
    }
```
```
}
```
}
//游戏主体逻辑函数
void Game()
{

int n = RIGHT; //开始游戏时，默认向后移动

int tmp = 0; //记录蛇的移动方向

goto first; //第一次进入循环先向默认方向前进

```
while (1)
```
```
{
```
```
    n = getch(); //读取键值
```

    //在执行前，需要对所读取的按键进行调整

```
    switch (n)
```
```
    {
```
```
    case UP:
```

    case DOWN: //如果敲击的是“上”或“下”

        if (tmp != LEFT&&tmp != RIGHT) //并且上一次蛇的移动方向不是“左”或“右”

```
        {
```

            n = tmp; //那么下一次蛇的移动方向设置为上一次蛇的移动方向

```
        }
```
```
        break;
```
```
    case LEFT:
```

    case RIGHT: //如果敲击的是“左”或“右”

        if (tmp != UP&&tmp != DOWN) //并且上一次蛇的移动方向不是“上”或“下”

```
        {
```

            n = tmp; //那么下一次蛇的移动方向设置为上一次蛇的移动方向

```
        }
```
```
    case SPACE:
```
```
    case ESC:
```
```
    case 'r':
```
```
    case 'R':
```
```
        break; //这四个无需调整
```
```
    default:
```

        n = tmp; //其他键无效，默认为上一次蛇移动的方向

```
        break;
```
```
    }
```

first: //第一次进入循环先向默认方向前进

```
    switch (n)
```
```
    {
```
```
    case UP: //方向键：上
```

        run(0, -1); //向上移动（横坐标偏移为0，纵坐标偏移为-1）

        tmp = UP; //记录当前蛇的移动方向

```
        break;
```
```
    case DOWN: //方向键：下
```

        run(0, 1); //向下移动（横坐标偏移为0，纵坐标偏移为1）

        tmp = DOWN; //记录当前蛇的移动方向

```
        break;
```
```
    case LEFT: //方向键：左
```

        run(-1, 0); //向左移动（横坐标偏移为-1，纵坐标偏移为0）

        tmp = LEFT; //记录当前蛇的移动方向

```
        break;
```
```
    case RIGHT: //方向键：右
```

        run(1, 0); //向右移动（横坐标偏移为1，纵坐标偏移为0）

        tmp = RIGHT; //记录当前蛇的移动方向

```
        break;
```
```
    case SPACE: //暂停
```

        system("pause>nul"); //暂停后按任意键继续

```
        break;
```
```
    case ESC: //退出
```
```
        system("cls"); //清空屏幕
```

        color(7); //颜色设置为白色

```
        CursorJump(COL - 8, ROW / 2);
```
```
        printf("  游戏结束  ");
```

        CursorJump(COL - 8, ROW / 2 + 2);

```
        exit(0);
```
```
    case 'r':
```
```
    case 'R': //重新开始
```
```
        system("cls"); //清空屏幕
```

        main(); //重新执行主函数

```
    }
```
```
}
```
}
战斗机游戏
#include
#include<windows.h>
#include<conio.h>
#include<time.h>
#include
using namespace std;
typedef struct Frame
{
```
COORD position[2];
```
```
int flag;
```
}Frame;
void SetPos(COORD a)
{

HANDLE out=GetStdHandle(STD_OUTPUT_HANDLE);

```
SetConsoleCursorPosition(out, a);
```
}
void SetPos(int i, int j)
{
```
COORD pos={i, j};
```
```
SetPos(pos);
```
}
void HideCursor()
{

CONSOLE_CURSOR_INFO cursor_info = {1, 0};

SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);

}
void drawRow(int y, int x1, int x2, char ch)
{
```
SetPos(x1,y);
```
```
for(int i = 0; i <= (x2-x1); i++)
```
```
    cout<<ch;
```
}
void drawRow(COORD a, COORD b, char ch)
{
```
if(a.Y == b.Y)
```
```
    drawRow(a.Y, a.X, b.X, ch);
```
```
else
```
```
{
```
```
    SetPos(0, 25);
```

    cout<<"error code 01：无法填充行，因为两个坐标的纵坐标(x)不相等";

```
    system("pause");
```
```
}
```
}
void drawCol(int x, int y1, int y2, char ch)
{
```
int y=y1;
```
```
while(y!=y2+1)
```
```
{
```
```
    SetPos(x, y);
```
```
    cout<<ch;
```
```
    y++;
```
```
}
```
}
void drawCol(COORD a, COORD b, char ch)
{
```
if(a.X == b.X)
```
```
    drawCol(a.X, a.Y, b.Y, ch);
```
```
else
```
```
{
```
```
    SetPos(0, 25);
```

    cout<<"error code 02：无法填充列，因为两个坐标的横坐标(y)不相等";

```
    system("pause");
```
```
}
```
}
void drawFrame(COORD a, COORD b, char row, char col)
{
```
drawRow(a.Y, a.X+1, b.X-1, row);
```
```
drawRow(b.Y, a.X+1, b.X-1, row);
```
```
drawCol(a.X, a.Y+1, b.Y-1, col);
```
```
drawCol(b.X, a.Y+1, b.Y-1, col);
```
}
void drawFrame(int x1, int y1, int x2, int y2, char row, char col)
{
```
COORD a={x1, y1};
```
```
COORD b={x2, y2};
```
```
drawFrame(a, b, row, col);
```
}
void drawFrame(Frame frame, char row, char col)
{
```
COORD a = frame.position[0];
```
```
COORD b = frame.position[1];
```
```
drawFrame(a, b, row, col);
```
}
void drawPlaying()
{
```
drawFrame(0, 0, 48, 24, '=', '|');
```
```
drawFrame(49, 0, 79, 4, '-', '|');
```
```
drawFrame(49, 4, 79, 9, '-', '|');
```
```
drawFrame(49, 9, 79, 20, '-', '|');
```
```
drawFrame(49, 20, 79, 24, '-', '|');
```
```
SetPos(52, 6);
```
```
cout<<"得分：";
```
```
SetPos(52, 7);
```
```
cout<<"称号：";
```
```
SetPos(52,10);
```
```
cout<<"操作方式：";
```
```
SetPos(52,12);
```

cout<<"  a,s,d,w 控制战机移动。";

```
SetPos(52,14);
```
```
cout<<"  p 暂停游戏。";
```
```
SetPos(52,16);
```
```
cout<<"  e 退出游戏。";
```
}
int random(int a, int b)
{
```
int c=(rand() % (a-b))+ a;
```
```
return c;
```
}
COORD random(COORD a, COORD b)
{
```
int x=random(a.X, b.X);
```
```
int y=random(a.Y, b.Y);
```
```
COORD c={x, y};
```
```
return c;
```
}
bool judgeCoordInFrame(Frame frame, COORD spot)
{
```
if(spot.X>=frame.position[0].X)
```
```
    if(spot.X<=frame.position[1].X)
```

        if(spot.Y>=frame.position[0].Y)

            if(spot.Y<=frame.position[0].Y)

```
                return true;
```
```
return false;
```
}
void printCoord(COORD a)
{

cout    <<"( "<<a.X<<" ， "<<a.Y<<" )";

}
void printFrameCoord(Frame a)
{
```
printCoord(a.position[0]);
```
```
cout    <<" - ";
```
```
printCoord(a.position[1]);
```
}
int drawMenu()
{
```
SetPos(30, 1);
```
```
cout<<"P l a n e  W a r";
```
```
drawRow(3, 0, 79, '-');
```
```
drawRow(5, 0, 79, '-');
```
```
SetPos(28, 4);
```
```
cout<<"w 和 s 选择， k 确定";
```
```
SetPos(15, 11);
```
```
cout<<"1. 简单的敌人";
```
```
SetPos(15, 13);
```
```
cout<<"2. 冷酷的敌人";
```
```
drawRow(20, 0, 79, '-');
```
```
drawRow(22, 0, 79, '-');
```
```
SetPos(47, 11);
```
```
cout<<"简单的敌人：";
```
```
SetPos(51, 13);
```

cout<<"简单敌人有着较慢的移动速度。";

```
SetPos(24, 21);
```
```
cout<<"制作：LJF神犇";
```
```
int j=11;
```
```
SetPos(12, j);
```
```
cout<<">>";
```
```
while(1)
```
```
{    if( _kbhit() )
```
```
    {    
```
```
        char x=_getch();
```
```
        switch (x)
```
```
        {
```
```
        case 'w' :
```
```
                {    
```
```
                    if( j == 13)
```
```
                    {
```
```
                        SetPos(12, j);
```
```
                        cout<<"　";
```
```
                        j = 11;
```
```
                        SetPos(12, j);
```
```
                        cout<<">>";
```

                        SetPos(51, 13);

                        cout<<"　　　　　　　　　　　　";

                        SetPos(47, 11);

                        cout<<"简单的敌人：";

                        SetPos(51, 13);

                        cout<<"简单敌人有着较慢的移动速度，容易对付。";

```
                    }
```
```
                    break;
```
```
                }
```
```
        case 's' :
```
```
                {    
```
```
                    if( j == 11 )
```
```
                    {
```
```
                        SetPos(12, j);
```

                        cout<<"　";

```
                        j = 13;
```
```
                        SetPos(12, j);
```
```
                        cout<<">>";
```

                        SetPos(51, 13);

                        cout<<"　　　　　　　　　　　　　　";

                        SetPos(47, 11);

                        cout<<"冷酷的敌人：";

                        SetPos(51, 13);

                        cout<<"冷酷的敌人移动速度较快，难对付哟！！！";

```
                    }
```
```
                    break;
```
```
                }
```
```
        case 'k' :
```
```
                {    
```

                    if (j == 8)    return 1;

```
                    else return 2;
```
```
                }
```
```
        }
```
```
    }
```
```
}
```
}
class Game
{
public:
```
COORD position[10];
```
```
COORD bullet[10];
```
```
Frame enemy[8];
```
```
int score;
```
```
int rank;
```
```
int rankf;
```
```
string title;
```
```
int flag_rank;
```
```
Game ();
```
```
void initPlane();
```
```
void initBullet();
```
```
void initEnemy();
```
```
void planeMove(char);
```
```
void bulletMove();
```
```
void enemyMove();
```
```
void drawPlane();
```
```
void drawPlaneToNull();
```
```
void drawBullet();
```
```
void drawBulletToNull();
```
```
void drawEnemy();
```
```
void drawEnemyToNull();
```
```
void drawThisBulletToNull( COORD );
```
```
void drawThisEnemyToNull( Frame );
```
```
void Pause();
```
```
void Playing();
```
```
void judgePlane();
```
```
void judgeEnemy();
```
```
void Shoot();
```
```
void GameOver();
```
```
void printScore();
```
};
Game::Game()
{
```
initPlane();
```
```
initBullet();
```
```
initEnemy();
```
```
score = 0;
```
```
rank = 25;
```
```
rankf = 0;
```
```
flag_rank = 0;
```
}
void Game::initPlane()
{
```
COORD centren={39, 22};
```

position[0].X=position[5].X=position[7].X=position[9].X=centren.X;

```
position[1].X=centren.X-2;    
```

position[2].X=position[6].X=centren.X-1;

position[3].X=position[8].X=centren.X+1;

```
position[4].X=centren.X+2;
```
```
for(int i=0; i<=4; i++)
```
```
    position[i].Y=centren.Y;
```
```
for(int i=6; i<=8; i++)
```
```
    position[i].Y=centren.Y+1;
```
```
position[5].Y=centren.Y-1;
```
```
position[9].Y=centren.Y-2;
```
}
void Game::drawPlane()
{
```
for(int i=0; i<9; i++)
```
```
{
```
```
    SetPos(position[i]);
```
```
    if(i!=5)
```
```
        cout<<"O";
```
```
    else if(i==5)
```
```
        cout<<"|";        
```
```
}
```
}
void Game::drawPlaneToNull()
{
```
for(int i=0; i<9; i++)
```
```
{
```
```
    SetPos(position[i]);
```
```
    cout<<" ";
```
```
}    
```
}
void Game::initBullet()
{
```
for(int i=0; i<10; i++)
```
```
    bullet[i].Y = 30;
```
}
void Game::drawBullet()
{
```
for(int i=0; i<10; i++)
```
```
{
```
```
    if( bullet[i].Y != 30)
```
```
    {
```
```
        SetPos(bullet[i]);
```
```
        cout<<"'";    
```
```
    }
```
```
}
```
}
void Game::drawBulletToNull()
{
```
for(int i=0; i<10; i++)
```
```
    if( bullet[i].Y != 30 )
```
```
        {
```

            COORD pos={bullet[i].X, bullet[i].Y+1};

```
            SetPos(pos);
```
```
            cout<<" ";
```
```
        }    
```
}
void Game::initEnemy()
{
```
COORD a={1, 1};
```
```
COORD b={45, 15};
```
```
for(int i=0; i<8; i++)
```
```
{
```

    enemy[i].position[0] = random(a, b);

    enemy[i].position[1].X = enemy[i].position[0].X + 3;

    enemy[i].position[1].Y = enemy[i].position[0].Y + 2;

```
}
```
}
void Game::drawEnemy()
{
```
for(int i=0; i<8; i++)
```

    drawFrame(enemy[i].position[0], enemy[i].position[1], '-', '|');

}
void Game::drawEnemyToNull()
{
```
for(int i=0; i<8; i++)
```
```
{
```

    drawFrame(enemy[i].position[0], enemy[i].position[1], ' ', ' ');

```
}        
```
}
void Game::Pause()
{
```
SetPos(61,2);
```
```
cout<<"               ";
```
```
SetPos(61,2);
```
```
cout<<"暂停中...";
```
```
char c=_getch();
```
```
while(c!='p')
```
```
    c=_getch();
```
```
SetPos(61,2);
```
```
cout<<"         ";
```
}
void Game::planeMove(char x)
{
```
if(x == 'a')
```
```
    if(position[1].X != 1)
```
```
        for(int i=0; i<=9; i++)
```
```
            position[i].X -= 2;
```
```
if(x == 's')
```
```
    if(position[7].Y != 23)
```
```
        for(int i=0; i<=9; i++)
```
```
            position[i].Y += 1;
```
```
if(x == 'd')
```
```
    if(position[4].X != 47)
```
```
        for(int i=0; i<=9; i++)
```
```
            position[i].X += 2;
```
```
if(x == 'w')
```
```
    if(position[5].Y != 3)
```
```
        for(int i=0; i<=9; i++)
```
```
            position[i].Y -= 1;
```
}
void Game::bulletMove()
{
```
for(int i=0; i<10; i++)
```
```
{
```
```
    if( bullet[i].Y != 30)
```
```
    {
```
```
        bullet[i].Y -= 1;
```
```
        if( bullet[i].Y == 1 )
```
```
        {
```

            COORD pos={bullet[i].X, bullet[i].Y+1};

            drawThisBulletToNull( pos );

```
            bullet[i].Y=30;
```
```
        }
```
```
    }
```
```
}
```
}
void Game::enemyMove()
{
```
for(int i=0; i<8; i++)
```
```
{
```
```
    for(int j=0; j<2; j++)
```
```
        enemy[i].position[j].Y++;
```
```
    if(24 == enemy[i].position[1].Y)
```
```
    {
```
```
        COORD a={1, 1};
```
```
        COORD b={45, 3};
```

        enemy[i].position[0] = random(a, b);

        enemy[i].position[1].X = enemy[i].position[0].X + 3;

        enemy[i].position[1].Y = enemy[i].position[0].Y + 2;

```
    }
```
```
}
```
}
void Game::judgePlane()
{
```
for(int i = 0; i < 8; i++)
```
```
    for(int j=0; j<9; j++)
```

        if(judgeCoordInFrame(enemy[i], position[j]))

```
        {
```
```
            SetPos(62, 1);
```
```
            cout<<"坠毁";
```

            drawFrame(enemy[i], '+', '+');

```
            Sleep(1000);
```
```
            GameOver();
```
```
            break;
```
```
        }
```
}
void Game::drawThisBulletToNull( COORD c)
{
```
SetPos(c);
```
```
cout<<" ";
```
}
void Game::drawThisEnemyToNull( Frame f )
{
```
drawFrame(f, ' ', ' ');
```
}
void Game::judgeEnemy()
{
```
for(int i = 0; i < 8; i++)
```
```
    for(int j = 0; j < 10; j++)
```

        if( judgeCoordInFrame(enemy[i], bullet[j]) )

```
        {
```
```
            score += 5;
```

            drawThisEnemyToNull( enemy[i] );

```
            COORD a={1, 1};
```
```
            COORD b={45, 3};
```

            enemy[i].position[0] = random(a, b);

            enemy[i].position[1].X = enemy[i].position[0].X + 3;

            enemy[i].position[1].Y = enemy[i].position[0].Y + 2;

            drawThisBulletToNull( bullet[j] );

```
            bullet[j].Y = 30;
```
```
        }
```
}
void Game::Shoot()
{
```
for(int i=0; i<10; i++)
```
```
    if(bullet[i].Y == 30)
```
```
    {
```
```
        bullet[i].X = position[5].X;
```
```
        bullet[i].Y = position[5].Y-1;
```
```
        break;
```
```
    }
```
}
void Game::printScore()
{
```
if(score == 120 && flag_rank == 0)
```
```
{
```
```
    rank -= 3;
```
```
    flag_rank = 1;
```
```
}
```

else if( score == 360 && flag_rank == 1)

```
{
```
```
    rank -= 5;
```
```
    flag_rank = 2;
```
```
}
```

else if( score == 480 && flag_rank == 2)

```
{
```
```
    rank -= 5;
```
```
    flag_rank = 3;
```
```
}
```
```
int x=rank/5;
```
```
SetPos(60, 6);
```
```
cout<<score;
```
```
if( rank!=rankf )
```
```
{
```
```
    SetPos(60, 7);
```
```
    if( x == 5)
```
```
        title="初级飞行员";
```
```
    else if( x == 4)
```
```
        title="中级飞行员";
```
```
    else if( x == 3)
```
```
        title="高级飞行员";
```
```
    else if( x == 2 )
```
```
        title="王牌飞行员";
```
```
    cout<<title;
```
```
}
```
```
rankf = rank;
```
}
void Game::Playing()
{
```
drawEnemy();
```
```
drawPlane();
```
```
int flag_bullet = 0;
```
```
int flag_enemy = 0;
```
```
while(1)
```
```
{
```
```
    Sleep(8);
```
```
    if(_kbhit())
```
```
    {
```
```
        char x = _getch();
```

        if ('a' == x || 's' == x || 'd' == x || 'w' == x)

```
        {
```
```
            drawPlaneToNull();
```
```
            planeMove(x);
```
```
            drawPlane();
```
```
            judgePlane();
```
```
        }            
```
```
        else if ('p' == x)
```
```
            Pause();
```
```
        else if( 'k' == x)
```
```
            Shoot();
```
```
        else if( 'e' == x)
```
```
        {
```
```
            GameOver();
```
```
            break;
```
```
        }
```
```
    }
```
```
    if( 0 == flag_bullet )
```
```
    {
```
```
        bulletMove();
```
```
        drawBulletToNull();
```
```
        drawBullet();
```
```
        judgeEnemy();
```
```
    }            
```
```
    flag_bullet++;
```
```
    if( 5 == flag_bullet )
```
```
        flag_bullet = 0;
```
```
    if( 0 == flag_enemy )
```
```
    {
```
```
        drawEnemyToNull();
```
```
        enemyMove();            
```
```
        drawEnemy();
```
```
        judgePlane();
```
```
    }
```
```
    flag_enemy++;
```
```
    if( flag_enemy >= rank )
```
```
        flag_enemy = 0;
```
```
    printScore();
```
```
}
```
}
void Game::GameOver()
{
```
system("cls");                
```
```
COORD p1={28,9};
```
```
COORD p2={53,15};
```
```
drawFrame(p1, p2, '=', '|');
```
```
SetPos(36,12);
```
```
string str="Game Over!";
```
```
for(int i=0; i<str.size(); i++)
```
```
{
```
```
    Sleep(80);
```
```
    cout<<str[i];
```
```
}
```
```
Sleep(1000);
```
```
system("cls");
```
```
drawFrame(p1, p2, '=', '|');
```
```
SetPos(31, 11);
```

cout<<"击落敌机："<<score/5<<" 架";

```
SetPos(31, 12);
```
```
cout<<"得　　分："<<score;
```
```
SetPos(31, 13);
```
```
cout<<"获得称号："<<title;
```
```
SetPos(30, 16);
```
```
Sleep(1000);
```

cout<<"继续？ 是（y）| 否（n）制作：熊猫熊猫";

as:
```
char x=_getch();
```
```
if (x == 'n')
```
```
    exit(0);
```
```
else if (x == 'y')
```
```
{
```
```
    system("cls");
```
```
    Game game;
```
```
    int a = drawMenu();
```
```
    if(a == 2)
```
```
        game.rank = 20;
```
```
    system("cls");
```
```
    drawPlaying();
```
```
    game.Playing();
```
```
}
```
```
else goto as;
```
}
int main()
{
```
srand((int)time(0));
```
```
HideCursor();
```
```
Game game;
```
```
int a = drawMenu();
```
```
if(a == 2)
```
```
    game.rank = 20;
```
```
system("cls");
```
```
drawPlaying();
```
```
game.Playing();
```
}
木兰诗唧唧复唧唧，木兰开飞机，开的什么机？波音747！问女何所思，问女何所忆。女亦有所思，没钱买飞机。昨夜见军帖，要用轰炸机，飞机十二架，架架买不起。阿爷无大钱，木兰无金银，愿去买钢铁，从此造飞机。东市买图纸，西市买螺丝，南市买玻璃，北市买铁皮。旦辞爷娘去，暮宿旧机库，不闻爹娘唤女声，但闻铁皮摩擦滋啦声。旦辞机库去，暮至军营旁，不闻爹娘唤女声，但闻将军大呼哈哈哈。万里开飞机，关山一下没。热气传机翼，日光照玻璃。将军被吓死，壮士魂已飞。飞来撞天子，天子躺病床．策勋十二转，赏赐俩耳光。可汗问所欲，木兰不愿进牢房；愿开747，飞着回故乡。爹娘闻女来,端起机关枪；阿姊闻妹来，当户举手枪；小弟闻姊来,磨刀霍霍向爹娘。开我机舱门，进我飞机舱，脱我战时袍，换上飞行装, 多装手榴弹，对外架机枪。出门埋炸弹，亲友皆惊忙：离别十二年,不知木兰变猖狂。疯子脚蹬地，呆子眼紧闭，两人并排走，谁能说我不正常?
语文老师一回头，鲁迅甘为孺子牛；
数学老师一回头，六元六次都能求；
英语老师一回头， Sorry加上三克油；
物理老师一回头，一根杠杆撬地球；
化学老师一回头，二氧化碳变汽油；
劳动老师一回头，破铜烂铁来走秀；
体育老师一回头，黛玉也能踢足球；
政治老师一回头，全班同学都梦游；
美术老师一回头，蒙娜丽莎也风流；
音乐老师一回头，贝多芬呀也不牛；
信息老师一回头，带着学生玩网游。

通过的题目
2

3

4

5

8
9

17

120

143

203
1060

1271

1475

1875

2853
2854

2855

2856

2857
最近活动
最近编写的题解

This person is lazy and didn't write any solutions.

模拟: 6
计算几何: 5
字符串: 3
语言入门: 2
素数判断: 1
质数: 1
筛法: 1
数学: 1
排序: 1
数组: 1
高精度: 1
图论: 1
分支结构: 1

陈韵霖

个人简介

通过的题目

最近活动

最近编写的题解

题目标签

状态

开发

支持

关于

陈韵霖

个人简介

通过的题目

最近活动

最近编写的题解

题目标签

状态

开发

支持

关于

还没有账户？

登录