VC++程序设计实验报告模版.docx

VC++程序设计实验报告模版.docx

《VC++程序设计实验报告模版.docx》由会员分享，可在线阅读，更多相关《VC++程序设计实验报告模版.docx（48页珍藏版）》请在冰点文库上搜索。

VC++程序设计实验报告模版

西安科技大学

《VC++程序设计》

实验报告

题目双人版俄罗斯方块

院、系（部）计算机科学与技术

专业及班级计科1401班

学号1408030126

姓名黄培

日期2016/5/30

1题目要求

双人同时进行的俄罗斯方块

2功能需求

1.双人同时进行的俄罗斯方块

2.方块可进行左右移动，旋转变形，加速下落

3.可以进行游戏难度的选择，分别为简单，中等，高级

3总体设计

3.1系统模块

1.砖块显示模块

2.用户的控制模块，移动，旋转，加速下落

3.游戏难度模块，难度选择，分别为简单，中等，高级

3.2系统业务处理流程

是

否

4详细设计

1.Tetris游戏的矩形框类设计——CBin（主要实现代码）

2.Bin.h

3.#ifndefBIN_H

4.#defineBIN_H

5.classCBin{

6.private:

7.unsignedchar**image;

8.unsignedintwidth;

9.unsignedintheight;

10.

11.public:

12.CBin（unsignedintw,unsignedinth）;

13.~CBin（）;

14.

15.unsignedintgetWidth（）{returnwidth;};

16.unsignedintgetHeight（）{returnheight;};

17.

18.voidgetImage（unsignedchar**destImage）;

19.voidsetImage（unsignedchar**srcImage）;

20.

21.unsignedintremoveFullLines（）;

22.};

23.#endif

Bin.cpp

#include"stdafx.h"

#include"bin.h"

CBin:

:

CBin（unsignedintw,unsignedinth）

{

width=w;

height=h;

image=newunsignedchar*[height];

for（unsignedinti=0;i

{

image[i]=newunsignedchar[width];

for（unsignedintj=0;j

image[i][j]=0;

}

}

CBin:

:

~CBin（）

{

for（unsignedinti=0;i

deleteimage[i];

}

delete[]image;

}

voidCBin:

:

getImage（unsignedchar**destImage）

{

for（unsignedinti=0;i

for（unsignedintj=0;j

destImage[i][j]=image[i][j];

}

voidCBin:

:

setImage（unsignedchar**srcImage）

{

for（unsignedinti=0;i

for（unsignedintj=0;j

image[i][j]=srcImage[i][j];

}

unsignedintCBin:

:

removeFullLines（）

{

unsignedintflag,EmptyLine=0;

unsignedinti,j,m;

for（i=0;i

{

flag=0;

for（j=0;j

{

if（image[i][j]==0）

flag=1;

}

//一行完全被填满

if（flag==0）

{

for（j=0;j

{

image[i][j]=0;

}

//消除整行

for（m=i;m>0;m--）

{

for（j=0;j

{

image[m][j]=image[m-1][j];

}

}

for（j=0;j

{

image[0][j]=0;

}

EmptyLine++;//记录消的行数

i--;

}

}

returnEmptyLine;

}

2.Tetris游戏的砖块类设计

Brick.h

#ifndefBRICK_H

#defineBRICK_H

#include"bin.h"

classCBrick{

protected:

intorientation;

intposX;

intposY;

unsignedcharcolour;

public:

intgetOrientation（）{returnorientation;};

intgetPosX（）{returnposX;};

intgetPosY（）{returnposY;};

unsignedchargetColour（）{returncolour;};

voidsetOrientation（intnewOrient）{orientation=newOrient;};

voidsetPosX（intnewPosX）{posX=newPosX;};

voidsetPosY（intnewPosY）{posY=newPosY;};

voidsetColour（unsignedcharnewColour）{colour=newColour;};

virtualintshiftLeft（CBin*bin）=0;

virtualintshiftRight（CBin*bin）=0;

virtualintshiftDown（CBin*bin）=0;

virtualintrotateClockwise（CBin*bin）=0;

virtualintcheckCollision（CBin*bin）=0;

virtualvoidoperator>>（unsignedchar**binImage）=0;

virtualvoidputAtTop（intnewOrient,intnewPosX）=0;

virtualvoidputAtMid（intnewOrient,intnewPosX）=0;

};

classCIBrick:

publicCBrick{

public:

intshiftLeft（CBin*bin）;

intshiftRight（CBin*bin）;

intshiftDown（CBin*bin）;

introtateClockwise（CBin*bin）;

intcheckCollision（CBin*bin）;

voidoperator>>（unsignedchar**binImage）;

voidputAtTop（intnewOrient,intnewPosX）;

voidputAtMid（intnewOrient,intnewPosX）;

};

classCLBrick:

publicCBrick{

public:

intshiftLeft（CBin*bin）;

intshiftRight（CBin*bin）;

intshiftDown（CBin*bin）;

introtateClockwise（CBin*bin）;

intcheckCollision（CBin*bin）;

voidoperator>>（unsignedchar**binImage）;

voidputAtTop（intnewOrient,intnewPosX）;

voidputAtMid（intnewOrient,intnewPosX）;

};

classCSBrick:

publicCBrick{

public:

intshiftLeft（CBin*bin）;

intshiftRight（CBin*bin）;

intshiftDown（CBin*bin）;

introtateClockwise（CBin*bin）;

intcheckCollision（CBin*bin）;

voidoperator>>（unsignedchar**binImage）;

voidputAtTop（intnewOrient,intnewPosX）;

voidputAtMid（intnewOrient,intnewPosX）;

};

classCOBrick:

publicCBrick{

public:

intshiftLeft（CBin*bin）;

intshiftRight（CBin*bin）;

intshiftDown（CBin*bin）;

introtateClockwise（CBin*bin）;

intcheckCollision（CBin*bin）;

voidoperator>>（unsignedchar**binImage）;

voidputAtTop（intnewOrient,intnewPosX）;

voidputAtMid（intnewOrient,intnewPosX）;

};

#endif

Brick.cpp

intCIBrick:

:

shiftLeft（CBin*bin）

{

intposX;

posX=getPosX（）;

setPosX（posX-1）;

if（checkCollision（bin）==0）{

setPosX（posX）;

return0;

}

return1;

}

intCIBrick:

:

shiftDown（CBin*bin）

{

intposY;

posY=getPosY（）;

setPosY（posY+1）;

if（checkCollision（bin）==0）{

setPosY（posY）;

return0;

}

return1;

}

intCIBrick:

:

shiftRight（CBin*bin）

{

intposX;

posX=getPosX（）;

setPosX（posX+1）;

if（checkCollision（bin）==0）{

setPosX（posX）;

return0;

}

return1;

}

intCIBrick:

:

rotateClockwise（CBin*bin）

{

intorientation,oldOrientation;

orientation=getOrientation（）;

oldOrientation=orientation;

if（orientation==3）

orientation=0;

else

orientation=orientation+1;

setOrientation（orientation）;

if（checkCollision（bin）==0）{

setOrientation（oldOrientation）;

return0;

}

return1;

}

intCIBrick:

:

checkCollision（CBin*bin）

{

intwidth;

intheight;

unsignedchar**image;

intorientation;

intposX;

intposY;

width=bin->getWidth（）;

height=bin->getHeight（）;

image=newunsignedchar*[height];

for（inti=0;i

{

image[i]=newunsignedchar[width];

}

bin->getImage（image）;

orientation=getOrientation（）;

posX=getPosX（）;

posY=getPosY（）;

//I-brick状态0

if（orientation==0）

{

//砖块碰到边界

if（（posX<0）||

（posX>width-1）||

（posY<1）||

（posY+2>height-1））

return0;

//砖块碰到其他固定砖块

if（（image[posY-1][posX]!

=0）||

（image[posY][posX]!

=0）||

（image[posY+1][posX]!

=0）||

（image[posY+2][posX]!

=0））

return0;

}

//状态1

if（orientation==1）

{

if（（posX<2）||

（posX+1>width-1）||

（posY<0）||

（posY>height-1））

return0;

if（（image[posY][posX-2]!

=0）||

（image[posY][posX-1]!

=0）||

（image[posY][posX]!

=0）||

（image[posY][posX+1]!

=0））

return0;

}

//状态2

if（orientation==2）

{

if（（posX<0）||

（posX>width-1）||

（posY<2）||

（posY+1>height-1））

return0;

if（（image[posY-2][posX]!

=0）||

（image[posY-1][posX]!

=0）||

（image[posY][posX]!

=0）||

（image[posY+1][posX]!

=0））

return0;

}

if（orientation==3）

{

if（（posX<1）||

（posX+2>width-1）||

（posY<0）||

（posY>height-1））

return0;

if（（image[posY][posX-1]!

=0）||

（image[posY][posX]!

=0）||

（image[posY][posX+1]!

=0）||

（image[posY][posX+2]!

=0））

return0;

}

return1;

}

voidCIBrick:

:

operator>>（unsignedchar**binImage）

{

intorientation;

intposX;

intposY;

unsignedcharcolour;

posX=getPosX（）;

posY=getPosY（）;

orientation=getOrientation（）;

colour=getColour（）;

//状态0

if（orientation==0）

{

binImage[posY-1][posX]=colour;

binImage[posY][posX]=colour;

binImage[posY+1][posX]=colour;

binImage[posY+2][posX]=colour;

}

//状态1

if（orientation==1）

{

binImage[posY][posX-2]=colour;

binImage[posY][posX-1]=colour;

binImage[posY][posX]=colour;

binImage[posY][posX+1]=colour;

}

//状态2

if（orientation==2）

{

binImage[posY-2][posX]=colour;

binImage[posY-1][posX]=colour;

binImage[posY][posX]=colour;

binImage[posY+1][posX]=colour;

}

//状态3

if（orientation==3）

{

binImage[posY][posX-1]=colour;

binImage[posY][posX]=colour;

binImage[posY][posX+1]=colour;

binImage[posY][posX+2]=colour;

}

}

voidCIBrick:

:

putAtTop（intnewOrient,intnewPosX）

{

setPosX（newPosX）;

setOrientation（newOrient）;

switch（newOrient）

{

case0:

setPosY

（1）;break;

case1:

setPosY（0）;break;

case2:

setPosY

（2）;break;

case3:

setPosY（0）;break;

}

}

voidCIBrick:

:

putAtMid（intnewOrient,intnewPosX）

{

setPosX（newPosX-3）;

setOrientation（newOrient）;

switch（newOrient）

{

case0:

setPosY（9）;break;

case1:

setPosY（8）;break;

case2:

setPosY（10）;break;

case3:

setPosY（8）;break;

}

}

///////////////////CLBrick/////////////

intCLBrick:

:

shiftLeft（CBin*bin）

{

intposX;

posX=getPosX（）;

setPosX（posX-1）;

if（checkCollision（bin）==0）{

setPosX（posX）;

return0;

}

return1;

}

intCLBrick:

:

shiftDown（CBin*bin）

{

intposY;

posY=getPosY（）;

setPosY（posY+1）;

if（checkCollision（bin）==0）{

setPosY（posY）;

return0;

}

return1;

}

intCLBrick:

:

shiftRight（CBin*bin）

{

intposX;

posX=getPosX（）;

setPosX（posX+1）;

if（checkCollision（bin）==0）{

setPosX（posX）;

return0;

}

return1;

}

intCLBrick:

:

rotateClockwise（CBin*bin）

{

intorientation,oldOrientation;

orientation=getOrientation（）;

oldOrientation=orientation;

if（orientation==3）

orientation=0;

else

orientation=orientation+1;

setOrientation（orientation）;

if（checkCollision（bin）==0）{

setOrientation（oldOrientation）;

return0;

}

return1;

}

intCLBrick:

:

checkCollision（CBin*bin）

{

intwidth;

intheight;

unsignedchar**image;

intorientation;

intposX;

intposY;

width=bin->getWidth（）;

height=bin->getHeight（）;

image=newunsignedchar*[height];

for（inti=0;i

{

image[i]=newunsignedchar[width];

}

bin->getImage（image）;

orientation=getOrientation（）;

posX=getPosX（）;

posY=getPosY（）;

if（orientation==0）

{

if（（posX<0）||

（posX+1>width-1）||

（posY<1）||

（posY+1>height-1））

return0;

if（（image[posY-1][posX]!

=0）||

（image[posY][posX]!

=0）||

（image[posY+1][posX]!

=0）||

（image[posY+1][posX+1]!

=0））

return0;

}

if（orientation==1）