C语言暑期实习 第六天

今天，开始研究那个小游戏，后来才知道，叫最初幻想，挺不错的名字，

附程序：

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

* 模块名：ConsoleOut

* 功 能：用于控制台文本输出控制，可控制

* 文本颜色，光标位置

* 作 者：张松

* 日 期：2006.06.27

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

#include <windows.h>

#define BLACK_COLOR 0

#define BLUE_COLOR 1

#define GREEN_COLOR 2

#define RED_COLOR 3

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

/ 功 能：取得系统模块句柄

/ 输入参数：pdll 系统模块名

/ 输出参数：系统模块句柄

/*作 者：李非

/*版 本：v1.0

/*修改日期：2005.09.27

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

HMODULE GetHmodule(char *pdll);

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

/ 功 能：切换控制台窗口为全屏或窗口模式

/ 输入参数：full -- true 表示全屏模式

/ false 表示窗口模式

/ 返回参数：无

/*作 者：李非

/*版 本：v1.0

/*修改日期：2005.09.27

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

void SwitchConsoleWinMode(bool full);

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

/ 功 能：设置控制台文本显示颜色

/ 输入参数：nColorFront --文本前景色

/ nColorBackGroup --文本背景色

/ 返回参数：无

/*作 者：李非

/*版 本：v1.0

/*修改日期：2005.09.27

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

void SetTextColor(int nColorFront, int nColorBackGroup);

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

/ 功 能：设置控制台光标位置

/ 输入参数：nX -- 光标X轴坐标

/ nY -- 光标Y走坐标

/ 返回参数：无

/*作 者：李非

/*版 本：v1.0

/*修改日期：2005.09.27

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

void MoveCursorTo(int nX, int nY);

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

/ 功 能：关闭控制台光标

/ 输入参数：无

/

/ 返回参数：无

/*作 者：李非

/*版 本：v1.0

/*修改日期：2005.09.29

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

void CloseCursor();

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

/ 功 能：打开控制台光标

/ 输入参数：nSize -- 光标大小

/ 返回参数：无

/*作 者：李非

/*版 本：v1.0

/*修改日期：2005.09.29

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

void OpenCursor();

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

/ 功 能：绘制矩形边框

/ 输入参数：title -- 边框标题

/ nX -- 边框左上角X轴坐标

/ nY -- 边框左上角Y轴坐标

/ nWidth -- 边框宽度

/ nHight -- 边框高度

/ frameColor -- 边框前景色

/ bkColor -- 边框背景色

/ 返回参数：无

/*作 者：李非

/*版 本：v1.0

/*修改日期：2005.09.30

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

void CreateSmWindow(char title[],int nX, int nY, int nWidth, int nHight,

int frameColor, int bkColor);

int MenuCtrl(int nLeft,int nUp,char* cTxt[],int nSize,char* lpszTitle);

void sleep( int nWait );

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

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "Element.h"

#include "consoleout.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

Element::Element()

{

}

Element::~Element()

{

}

Element::Element(CMap *map, Point point)

{

host = map;

Location = point;

}

char* Element::GetFace()

{

return "";

}

void Element::Show()

{

MoveCursorTo(Location.X*2,Location.Y);

printf("%s",GetFace());

}

int Element::GetType()

{

return -1;

}

// Element.h: interface for the Element class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_ELEMENT_H__571ACF0B_5A33_4345_8426_862366CF094C__INCLUDED_)

#define AFX_ELEMENT_H__571ACF0B_5A33_4345_8426_862366CF094C__INCLUDED_

#include "Point.h" // Added by ClassView

#include "Map.h" // Added by ClassView

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

class Element

{

public:

virtual int GetType();

void Show();

virtual char* GetFace();

Element(CMap*,Point);

CMap *host;

Point Location;

Element();

virtual ~Element();

};

#endif // !defined(AFX_ELEMENT_H__571ACF0B_5A33_4345_8426_862366CF094C__INCLUDED_)

// Hero.cpp: implementation of the CHero class.

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "Hero.h"

#include "consoleout.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CHero::CHero()

{

}

CHero::~CHero()

{

}

CHero::CHero(CMap *map, Point point):Element(map,point)

{

}

void CHero::GetMsg(char msg)

{

switch(msg)

{

case 'a':

case 's':

case 'd':

case 'w':

this->Move(msg);

break;

/* case 'y':

this->Eat();

break;*/

default:

break;

}

}

void CHero::Move(char msg)

{

Point nextPoint = Location.GetNextPoint(msg);

switch(host->pElements[nextPoint.Y][nextPoint.X]->GetType())

{

case 0:

case 8:

host->pElements[Location.Y][Location.X]->Show();

Location = nextPoint;

this->Show();

break;

default:

break;

}

}

char* CHero::GetFace()

{

return "";

}

int CHero::GetType()

{

return 7;

}

// Hero.h: interface for the CHero class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_HERO_H__DF2487A4_6736_49CE_923C_53EC5D53177D__INCLUDED_)

#define AFX_HERO_H__DF2487A4_6736_49CE_923C_53EC5D53177D__INCLUDED_

#include "Point.h" // Added by ClassView

#include "Element.h"

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

class CHero:public Element

{

public:

virtual int GetType();

virtual char* GetFace();

void GetMsg(char);

CHero(CMap*,Point);

CHero();

virtual ~CHero();

private:

void Move(char);

};

#endif // !defined(AFX_HERO_H__DF2487A4_6736_49CE_923C_53EC5D53177D__INCLUDED_)

// Map.cpp: implementation of the CMap class.

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "Map.h"

#include "point.h"

#include "hero.h"

#include "element.h"

#include "stone.h"

#include "road.h"

#include "river.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CMap::CMap()

{

}

CMap::~CMap()

{

delete []mapData;

}

void CMap::LoadMap(char *fileName)

{

FILE *fp = fopen(fileName,"r");

if(fp!=NULL)

{

fscanf(fp,"%d,%d,",&this->Rows,&this->Cols);

mapData = new int[this->Rows*this->Cols];

pElements = new Element**[this->Rows];

for(int nRow=0;nRow<this->Rows;nRow++)

{

pElements[nRow] = new Element*[this->Cols];

for(int nCol=0;nCol<this->Cols;nCol++)

{

fscanf(fp,"%d,",mapData+nRow*this->Cols+nCol);

Point location(nCol,nRow);

pElements[nRow][nCol] = GenerateElementByType(mapData[nRow*this->Cols+nCol],location);

}

}

fclose(fp);

}

}

void CMap::Show()

{

for(int nRow=0;nRow<this->Rows;nRow++)

{

for(int nCol=0;nCol<this->Cols;nCol++)

{

pElements[nRow][nCol]->Show();

}

}

hero->Show();

}

void CMap::GetMsg(char msg)

{

switch(msg)

{

case 'a':

case 's':

case 'd':

case 'w':

hero->GetMsg(msg);

break;

}

}

Element* CMap::GenerateElementByType(int type,Point location)

{

Element *ele;

switch(type)

{

case 1:

ele = new Stone(this,location);

break;

case 7:

hero = new CHero(this,location);

ele = new Road(this,location);

break;

case 8:

ele = new River(this,location);

break;

default:

ele = new Road(this,location);

break;

}

return ele;

}

// Map.h: interface for the CMap class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_MAP_H__056F5E34_0A1C_479E_ADA2_9D9AF88EDB7E__INCLUDED_)

#define AFX_MAP_H__056F5E34_0A1C_479E_ADA2_9D9AF88EDB7E__INCLUDED_

//#include "Element.h" // Added by ClassView

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

class CHero;

class Element;

class Point;

class CMap

{

public:

Element* GenerateElementByType(int type,Point point);

Element ***pElements;

CHero *hero;

void GetMsg(char);

int *mapData;

int Cols;

int Rows;

void LoadMap(char*);

void Show();

CMap();

virtual ~CMap();

};

#endif // !defined(AFX_MAP_H__056F5E34_0A1C_479E_ADA2_9D9AF88EDB7E__INCLUDED_)

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

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "Point.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

Point::Point()

{

}

Point::~Point()

{

}

Point::Point(int x,int y)

{

this->X = x;

this->Y = y;

}

Point Point::GetNextPoint(char msg)

{

Point nextPoint(this->X,this->Y);

switch(msg)

{

case 'a':

nextPoint.X--;

break;

case 'd':

nextPoint.X++;

break;

case 's':

nextPoint.Y++;

break;

case 'w':

nextPoint.Y--;

break;

}

return nextPoint;

}

// Point.h: interface for the Point class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_POINT_H__76044070_9E51_4AF9_86AE_DC7288DF7123__INCLUDED_)

#define AFX_POINT_H__76044070_9E51_4AF9_86AE_DC7288DF7123__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

class Point

{

public:

Point GetNextPoint(char);

Point(int,int);

int Y;

int X;

Point();

virtual ~Point();

};

#endif // !defined(AFX_POINT_H__76044070_9E51_4AF9_86AE_DC7288DF7123__INCLUDED_)

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

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "River.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

River::River()

{

}

River::~River()

{

}

char* River::GetFace()

{

return "≈";

}

River::River(CMap *map, Point point):Element(map,point)

{

}

int River::GetType()

{

return 8;

}

// River.h: interface for the River class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_RIVER_H__B6DFCDBB_682B_4179_ABE6_DCD6B5DD9016__INCLUDED_)

#define AFX_RIVER_H__B6DFCDBB_682B_4179_ABE6_DCD6B5DD9016__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include "Element.h"

class River : public Element

{

public:

virtual int GetType();

River(CMap*,Point);

virtual char* GetFace();

River();

virtual ~River();

};

#endif // !defined(AFX_RIVER_H__B6DFCDBB_682B_4179_ABE6_DCD6B5DD9016__INCLUDED_)

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

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "Road.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

Road::Road()

{

}

Road::~Road()

{

}

char* Road::GetFace()

{

return " ";

}

Road::Road(CMap *map, Point point):Element(map,point)

{

}

int Road::GetType()

{

return 0;

}

// Road.h: interface for the Road class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_ROAD_H__697D0E77_1996_46EB_B7F8_5A25FFCAA609__INCLUDED_)

#define AFX_ROAD_H__697D0E77_1996_46EB_B7F8_5A25FFCAA609__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include "Element.h"

class Road : public Element

{

public:

virtual int GetType();

Road(CMap*,Point);

virtual char* GetFace();

Road();

virtual ~Road();

};

#endif // !defined(AFX_ROAD_H__697D0E77_1996_46EB_B7F8_5A25FFCAA609__INCLUDED_)

// stdafx.cpp : source file that includes just the standard includes

// Test10.pch will be the pre-compiled header

// stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"

// TODO: reference any additional headers you need in STDAFX.H

// and not in this file

// stdafx.h : include file for standard system include files,

// or project specific include files that are used frequently, but

// are changed infrequently

//

#if !defined(AFX_STDAFX_H__406F7DEA_77AB_4743_AD6F_9C584D869C17__INCLUDED_)

#define AFX_STDAFX_H__406F7DEA_77AB_4743_AD6F_9C584D869C17__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers

#include <stdio.h>

// TODO: reference additional headers your program requires here

//{{AFX_INSERT_LOCATION}}

// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_STDAFX_H__406F7DEA_77AB_4743_AD6F_9C584D869C17__INCLUDED_)

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

//

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "Stone.h"

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

Stone::Stone()

{

}

Stone::~Stone()

{

}

char* Stone::GetFace()

{

return "▓";

}

Stone::Stone(CMap *map, Point point):Element(map,point)

{

}

int Stone::GetType()

{

return 1;

}

// Stone.h: interface for the Stone class.

//

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_STONE_H__347D00EA_8309_4711_93F4_98F99F8CD1A2__INCLUDED_)

#define AFX_STONE_H__347D00EA_8309_4711_93F4_98F99F8CD1A2__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

#include "point.h"

#include "Element.h"

class Stone : public Element

{

public:

virtual int GetType();

Stone(CMap*,Point);

virtual char* GetFace();

Stone();

virtual ~Stone();

};

#endif // !defined(AFX_STONE_H__347D00EA_8309_4711_93F4_98F99F8CD1A2__INCLUDED_)

// Test10.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

#include "conio.h"

#include "map.h"

#include "consoleout.h"

void main()

{

CloseCursor();

CMap *map = new CMap();

map->LoadMap("d:\\map.txt");

map->Show();

while(true)

{

char msg = getch();

if('Q'==msg)

{

break;

}

map->GetMsg(msg);

}

delete map;

OpenCursor();

}

这些代码，正在测试。。。。。。