瞬间记忆力大考验.docx

瞬间记忆力大考验.docx

《瞬间记忆力大考验.docx》由会员分享，可在线阅读，更多相关《瞬间记忆力大考验.docx（28页珍藏版）》请在冰豆网上搜索。

瞬间记忆力大考验

瞬间记忆力大考验

一、课题内容和要求

课题内容：

根据游戏难度，随机产生一个4*4或4*5或6*6的二维数组，填入不同的符号，测试者通过输入坐标，指定记忆中相同的两个（或三个）符号的位置。

正确，则显示符号对应图形，不正确则显示图形后随机关闭（显示时间为1秒）。

记录完成猜测的时间并保留成绩，设置排行榜。

要求：

1.图形组合的瞬间停留，利用菜单提供初级（4*4）、中级（4*5）、高级（6*6）的测试项目。

高级中图形为每组3个，共12组图案。

2.定义用户的结构体，用于记录不同用户的密码、测试成绩，并进行排名。

3．提供相应用户密码的安全测试。

1）如果密码长度小于6位，则不安全

2）如果组成密码的字符只有一类，则不安全

3）如果组成密码的字符有两类，则为中度安全

4）如果组成密码的字符有三类或以上，则为安全

5）通常，可以认为数字、大写字母、小写字母和其它符号为四类不同的字符。

4．用户游戏信息以文件形式保存。

二、需求分析

【1】可操作的主菜单：

输出主菜单，用于显示以选择游戏中不同的功能选项。

根据玩家输入的选项来运行不同的功能，运行不同的函数。

【2】查看游戏排行榜

【3】清空游戏排行榜

【4】注册游戏账号

【5】用游戏账号登陆进行游戏

【6】4*4,4*5,6*6的记忆游戏。

可方便的升级到任意大小的记忆游戏。

【7】查看自己所有的游戏记录（按时间顺序）

【8】游戏中有倒计时功能

【9】提示用户密码强度功能

【10】输入密码是关闭回显

【11】保存所有信息到文件。

程序关闭后，重新打开，信息不会丢失。

三、概要设计

本程序包含一个主体模块，另包括三个子模块，密码强度检验模块、游戏难度选择模块和菜单模块。

游戏开始后，游戏者需先通过以上两个子模块分别设置密码和选择游戏难度，之后根据游戏者的选择进行不同难度游戏。

游戏随机产生一个4*4或4*5或6*6的二维数组，相应地填入8对或10对或12对不同的符号，测试者通过输入坐标，指定记忆中相同的两个符号的位置。

正确，则显示符号对应图形，不正确则显示图形后随机关闭（显示时间为1秒）。

最后记录完成猜测的时间，并保留成绩到指定文件夹。

密码强度检验模块

游戏难度选择模块

四、源程序代码

（部分）

#include

#include

#include

#include

#defineTRUE1

#defineFALSE0

格式化时间函数

YYYY.MM.DDhh:

mm:

ss

*/

char__format_time__[40];

char*getFormatTime（longt）

{

strftime（__format_time__,sizeof（__format_time__）/sizeof（char）,"%Y.%m.%d%H:

%M:

%S",gmtime（&t））;

return__format_time__;

}

//字符最多分类种数

#defineCHAR_MAX_TYPES4

/*

判断字符分类函数

数字、大写字母、小写字母和其它符号为四类不同的字符。

*/

intgetCharType（charch）

{

if（ch>='0'&&ch<='9'）

{

return0;

}

elseif（ch>='a'&&ch<='z'）

{

return1;

}

elseif（ch>='A'&&ch<='Z'）

{

return2;

}

else

{

return3;

}

}

//密码分类等级名称

charPASSWORD_SECURITY_QUOTIETY_NAME[][10]={"不安全","中度安全","安全"};

intgetPasswordSecurityQuotiety（charpass[]）

{

//密码中字符种类

intcharTypeNum=0,isCharTypeExisted[CHAR_MAX_TYPES]={0};

inti;

if（strlen（pass）<6）

{

return0;

}

else

{

//初始化

for（i=0;i

{

isCharTypeExisted[i]=FALSE;

}

//统计字符种类

for（i=0;i

{

if（isCharTypeExisted[getCharType（pass[i]）]==FALSE）

{

isCharTypeExisted[getCharType（pass[i]）]=TRUE;

charTypeNum++;

}

}

//返回密码强度

if（charTypeNum==1）

{

return0;

}

elseif（charTypeNum==2）

{

return1;

}

elseif（charTypeNum>=3）

{

return2;

}

}

}

//输入密码是特别的回显字符

#definePASSWORD_SPECIAL_CHAR'*'

//输入密码函数，关闭回显

voidinputPassword（charstr[]）

{

charch;

inti=0;

fflush（stdin）;

while（（ch=getch（））!

='\r'）

{

//退格键

if（ch==8&&i>0）

{

printf（"\b\b"）;

i--;

continue;

}

str[i++]=ch;

printf（"*"）;

}

printf（"\n"）;

str[i++]='\0';

}

//二维坐标

structPoint

{

intx,y;

};

/*****************************************************************************

****记忆图形结构体

*****************************************************************************/

//二维字符数组的最大尺寸

#defineCHAR_ARRAY_MAX_SIZE6

//二维字符数组中一组字符的大小

#defineCHAR_ARRAY_MAX_GROUP_SIZE3

//可以存放到二维数组中的符号

charCHAR_ARRAY_AVAILABLE_SHOW_CHAR[]=

{

'0','1','2','3','4','5','6','7','8','9',

'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',

'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',

'!

','#','$','%','^','&','（','）','-','_','+','=','[',']','{','}','<','>'

};

//用来遮掩二维数组中的符号的特定符号

#defineCHAR_ARRAY_SPECIAL_SHIELD_CHAR'*'

//用来表示二维数组中特定位置没有符号的特定符号

#defineCHAR_ARRAY_SPECIAL_EMPTY_CHAR'\0'

//要记忆的二维字符数组

structCharArray

{

//要记忆的二维字符数组

chararray[CHAR_ARRAY_MAX_SIZE][CHAR_ARRAY_MAX_SIZE];

//图形是否被关闭标记

intisShield[CHAR_ARRAY_MAX_SIZE][CHAR_ARRAY_MAX_SIZE];

//要记忆的二维字符数组的高

intheight;

//要记忆的二维字符数组的宽

intwidth;

//要记忆的二维字符数组的每组字符数

intgroupSize;

};

//初始化

voidinitCharArray（structCharArray*charArray,inth,intw,ints）;

//打开全部图形

voidsetCharArrayAllShow（structCharArray*charArray）;

//关闭全部图形

voidsetCharArrayAllShield（structCharArray*charArray）;

//指定位置的图形的状态

voidsetCharArrayState（structCharArray*charArray,intstate,structPointpoints[],intn）;

//判断二维数组中是不是全部图形都可见

intisCharArrayAllShow（structCharArray*charArray）;

//判断指定的一组位置上的图形是否相同

intisCharArraySameCharAtPoints（structCharArray*charArray,structPointpoints[],intn）;

//在屏幕显示二维字符数组

voidshowCharArray（structCharArray*charArray,intshowTime）;

//初始化

voidinitCharArray（structCharArray*charArray,inth,intw,ints）

{

inti,j,k;

intisFind;

charch;

intx,y;

charArray->height=h;

charArray->width=w;

charArray->groupSize=s;

srand（time（NULL））;

memset（charArray->array,CHAR_ARRAY_SPECIAL_EMPTY_CHAR,sizeof（charArray->array））;

for（k=0;kheight*charArray->width/charArray->groupSize;k++）

{

//随机产生一个字符

do

{

ch=CHAR_ARRAY_AVAILABLE_SHOW_CHAR[rand（）%sizeof（CHAR_ARRAY_AVAILABLE_SHOW_CHAR）];

isFind=FALSE;

for（i=0;iheight&&!

isFind;i++）

{

for（j=0;jwidth&&!

isFind;j++）

{

if（charArray->array[i][j]==ch）

{

isFind=TRUE;

}

}

}

}while（isFind==TRUE）;

for（i=0;igroupSize;i++）

{

//随机产生一个坐标

do

{

x=rand（）%charArray->width;

y=rand（）%charArray->height;

}while（charArray->array[y][x]!

=CHAR_ARRAY_SPECIAL_EMPTY_CHAR）;

//填入字符

charArray->array[y][x]=ch;

}

}

//关闭全部图形

setCharArrayAllShield（charArray）;

}

//打开全部图形

voidsetCharArrayAllShow（structCharArray*charArray）

{

inti,j;

for（i=0;iheight;i++）

{

for（j=0;jwidth;j++）

{

charArray->isShield[i][j]=FALSE;

}

}

}

//关闭全部图形

voidsetCharArrayAllShield（structCharArray*charArray）

{

inti,j;

for（i=0;iheight;i++）

{

for（j=0;jwidth;j++）

{

charArray->isShield[i][j]=TRUE;

}

}

}

//判断指定的一组位置上的图形是否相同

intisCharArraySameCharAtPoints（structCharArray*charArray,structPointpoints[],intn）

{

inti,j;

charch=charArray->array[points[0].y][points[0].x];

//判读点是否重合

for（i=0;i

{

for（j=i+1;j

{

if（points[i].x==points[j].x&&points[i].y==points[j].y）

{

returnFALSE;

}

}

}

//判读点所在图形是否相同

for（i=1;i

{

if（charArray->array[points[i].y][points[i].x]!

=ch）

{

returnFALSE;

}

}

returnTRUE;

}

//判断二维数组中是不是全部图形都可见

intisCharArrayAllShow（structCharArray*charArray）

{

inti,j;

for（i=0;iheight;i++）

{

for（j=0;jwidth;j++）

{

if（charArray->isShield[i][j]==TRUE）

{

returnFALSE;

}

}

}

returnTRUE;

}

//在屏幕显示二维字符数组

voidshowCharArray（structCharArray*charArray,intshowTime）

{

inti,j;

time_tstartTime,currentTime,tempTime;

//清屏

system（"cls"）;

printf（"*******************************************\n"）;

printf（"****记忆图形\n"）;

printf（"*******************************************\n"）;

for（i=0;iheight;i++）

{

for（j=0;jwidth;j++）

{

if（charArray->isShield[i][j]）

{

printf（"%c",CHAR_ARRAY_SPECIAL_SHIELD_CHAR）;

}

else

{

printf（"%c",charArray->array[i][j]）;

}

}

printf（"\n"）;

}

printf（"*******************************************\n"）;

startTime=time（NULL）;

tempTime=startTime;

currentTime=startTime;

while（currentTime-startTime

{

//每隔一秒更新一下提示

if（tempTime==currentTime）

{

if（tempTime==startTime）

{

printf（"开始记忆...剩余%2d秒",showTime-（currentTime-startTime））;

}

else

{

printf（"\b\b\b\b%2d秒",showTime-（currentTime-startTime））;

}

tempTime++;

}

currentTime=time（NULL）;

}

}

//全局变量：

游戏玩家链表

structPlayer*_players=NULL;

//全局变量：

当前登陆的游戏玩家

structPlayer_loginPlayer;

//开始一轮游戏

voidstartGame（structGame*game）

{

inti;

//二维数组图形瞬间停留（显示）

setCharArrayAllShow（&game->charArray）;

showCharArray（&game->charArray,GAME_MAX_CHAR_ARRAY_FIRST_SHOW_TIME）;

//遮蔽二维数组图形

setCharArrayAllShield（&game->charArray）;

showCharArray（&game->charArray,0）;

//没有达到猜的次数的上限，继续

while（game->guessPointsTime

{

//让玩家指定相同字符所在的坐标

for（i=0;icharArray.groupSize;i++）

{

//输入行坐标y

do

{

printf（"****输入相同图形所在的第%d个行坐标,范围[1,%d]：

",i+1,game->charArray.height）;

scanf（"%d",&game->guessPoints[game->guessPointsTime][i].y）;

//用户输入的坐标是从1开始的，程序中的坐标是从0开始的，要修正

game->guessPoints[game->guessPointsTime][i].y--;

}while（game->guessPoints[game->guessPointsTime][i].y<0||game->guessPoints[game->guessPointsTime][i].y>=game->charArray.height）;

//输入列坐标x

do

{

printf（"****输入相同图形所在的第%d个列坐标,范围[1,%d]：

",i+1,game->charArray.width）;

scanf（"%d",&game->guessPoints[game->guessPointsTime][i].x）;

//用户输入的坐标是从1开始的，程序中的坐标是从0开始的，要修正

game->guessPoints[game->guessPointsTime][i].x--;

}while（game->guessPoints[game->guessPointsTime][i].y<0||game->guessPoints[game->guessPointsTime][i].y>=game->charArray.width）;

printf（"\n"）;

}

//显示玩家指定位置的二维数组图形

setCharArrayState（&game->charArray,FALSE,game->guessPoints[game->guessPointsTime],game->charArray.groupSize）;

showCharArray（&game->charArray,0）;

//判断指定位置的图形是否相同

if（isCharArraySameCharAtPoints（&game->charArray,game->guessPoints[game->guessPointsTime],game->charArray.groupSize））

{

//记录玩家本次猜字符成功

game->guessPointsResult[game->guessPointsTime]=TRUE;

}

else

{

//记录玩家本次猜字符失败

game->guessPointsResult[game->guessPointsTime]=FALSE;

//显示一会玩家【指定错误】的字符组

showCharArray（&game->charArray,GAME_MAX_CHAR_ARRAY_SHOW_TIME）;

//重新遮盖字符玩家【指定错误】的字符组

setCharArrayState（&game->charArray,TRUE,game->guessPoints[game->guessPointsTime],game->charArray.groupS