关于基于MFC的openGL游戏的框架

我写游戏的大概框架，用MFC我是不会了，opengl我用的是glut的框架

enum

{

level1,

level2,

level3,

};

int g_GameStatue=level1;

void Level_Init(int level)

{

//初始化图资源

}

void Level_Release(int level)

{

//清空地图资源

}

void Level_Run(int level)

{

//判断是否完成关卡

//是的话

Level_Release(level);

g_GameStatue=(level++);

}

//游戏主循环

int main()

{

while(1)

{

switch(g_GameStatue)

{

case level1:

static bool init=false;

if(init==false)

Level_Init(level1);

else

Level_Run(level1);

break;

case level2:

static bool init=false;

if(init==false)

Level_Init(level2);

else

Level_Run(level2);

case level3:

static bool init=false;

if(init==false)

Level_Init(level3);

else

Level_Run(level3);

}

Sleep(1);//节省cpu计算量

}

return 0;

}

1回溯算法

7． 迷宫问题

给一个20×20的迷宫、起点坐标和终点坐标，问从起点是否能到达终点。

输入数据：’’表示空格；’X’表示墙。

程序如下：

#include <stdioh>

#include <mathh>

void search(int,int);

int canplace(int,int);

void readdata(); //读入数据

void printresult(); //打印结果

int a[20][20]; //a数组存放迷宫

int s,t;

int main()

{

int row, col;

readdata();

row=s/20;

col=s%20;

search(row,col); //递归搜索

printresult();

}

void search(int row, int col)

{

int r,c;

a[row][col]=1;

r=row; //左

c=col-1;

if(canplace(r,c)) //判断(r,c)位置是否已经走过

search(r,c); //递归搜索(r,c)

r=row+1; //下

c=col;

if(canplace(r,c)) //判断(r,c)位置是否已经走过

search(r,c); //递归搜索(r,c)

r=row; //右

c=col+1;

if(canplace(r,c)) //判断(r,c)位置是否已经走过

search(r,c); //递归搜索(r,c)

r=row-1; //上

c=col;

if(canplace(r,c)) //判断(r,c)位置是否已经走过

search(r,c); //递归搜索(r,c)

}

void printresult()

{

int i,j;

for(i=0;i<20;i++)

{

for(j=0;j<20;j++)

printf("%3d",a[i][j]);

printf("\n");

}

}

void readdata()

{

int i,j;

for(i=0;i<20;i++)

{

for(j=0;j<20;j++)

scanf("%d",&a[i][j]);

}

}

int canplace(int row, int col)

{

if(row>=0&&row<20&&col>=0&&col<20&&a[row][col]==0)

return 1;

else

return 0;

}

2搜索算法

如下图12×12方格图，找出一条自入口（2，9）到出口（11，8）的最短路径。

抱歉，图案粘贴不上

本题给出完整的程序和一组测试数据。状态：老鼠所在的行、列。程序如下：

#include<stdioh>

void readdata(); //读入数据

void init(); //初始化

int search(); //广搜，并在每一个可到达的每一个空格出填上最小步数

int emptyopen(); //判栈是否为空：空：1；非空：0。

int takeoutofopen(); //从栈中取出一个元素，并把该元素从栈中删除

int canmoveto(int,int,int,int,int); //判能否移动到该方向，并带回坐标(r,c)

int isaim(int row, int col); //判断该点是否是目标

int used(int,int); //判断该点是否已经走过

void addtoopen(int,int); //把该点加入到open表

int a[12][12]; //a存放迷宫，0表示空格，-2表示墙。

//广搜时，未找到目标以前到达的空格，填上到达该点的最小步数

int n; //n为迷宫边长，注：若大于12，必须修改一些参数，如a的大小

int open[20],head,tail,openlen=20; //open表

int s,t; //起点和终点

int main()

{

int number;

readdata(); //读取数据

init(); //初始化

number=search(); //广搜并返回最小步数

printf("%d",number); //打印结果

}

int search()

{

int u, row, col, r, c, i, num;

while(!emptyopen()) //当栈非空

{

u=takeoutofopen(); //从栈中取出一个元素，并把该元素从栈中删除

row=u/n; //计算该点的坐标

col=u%n;

num=a[row][col]; //取得该点的步数

for(i=0;i<4;i++)

{

if(canmoveto(row,col,&r,&c,i)) //判能否移动到该方向，并带回坐标(r,c)

{

if(isaim(r,c)) //如果是目标结点

return(num+1); //返回最小步数

if(!used(r,c)) //如果(r,c)还未到达过

{

a[r][c]=num+1; //记录该点的最小步数

addtoopen(r,c); //把该点加入到open表

}

}

}

}

}

int emptyopen()

{

if(head==tail)

return(1);

else

return(0);

}

int takeoutofopen()

{

int u;

if(head==tail)

{

printf("errer: stack is empty");

return(-1);

}

u=open[head++];

head=head%openlen;

return(u);

}

int canmoveto(int row, int col, int p, int q, int direction)

{

int r,c;

r=row;

c=col;

switch(direction)

{

case 0: c--; //左

break;

case 1: r++; //下

break;

case 2: c++; //右

break;

case 3: r--; //上

}

p=r;

q=c;

if(r<0||r>=n||c<0||c>=n) //如果越界返回0

return(0);

if(a[r][c]==0) //如果是空格返回1

return(1);

return(0); //其余情况返回0

}

int isaim(int row, int col)

{

if(rown+col==t)

return(1);

else

return(0);

}

int used(int row, int col)

{

if(a[row][col]==0) // 0表示空格

return(0);

else

return(1);

}

void addtoopen(int row, int col)

{

int u;

u=rown+col;

open[tail++]= u;

tail=tail%openlen;

}

void readdata()

{

int i,j,row,col;

char str[20];

scanf("%d",&n);

scanf("%d%d",&row,&col); //起点坐标

s=rown+col;

scanf("%d%d",&row,&col); //终点坐标

t=rown+col;

gets(str);

for(i=0;i<n;i++)

{

gets(str);

for(j=0;j<n;j++)

if(str[j]=='')

a[i][j]=0; //0表示空格

else

a[i][j]=-2; //－2表示墙

}

}

void init()

{

head=0;

tail=1;

open[0]=s;

}

测试数据如下：

12 10 7 1 8

XXXXXXXXXXXX

XXXXX

XXXXX

XXXXXXXX

XXXX

XXXXXXXXXXX

XXXX

XXXXXXXX

XXX

XXXXXXXXX

XXXXXXXXXX

XXXXXXXXXXXX

没有这样的功能的。

变相解决办法就是你从函数的开始，每一句代码都调用一次GetTickout() ，然后判断时间超过了没

如果超过了就抛出异常。但是这样又会导致GetTickout() 占用太多时间，真正留给你处理业务的时间更少了。

猜测一下，LZ是不是遇到了阻塞函数，阻塞函数的时间不确定，希望设置一个超时的机制。那如果是这样，你思考的方向就错了。

一般API体系里面，如果有阻塞函数，就有非阻塞的函数。比如SOCKET编程里面，有阻塞模式开发，也有非阻塞模式开发。线程同步里面 lock一个线程锁，一般也有一个trylock，然后跟上一个等待时间等等。所以一个框架里面有提供阻塞函数，那么一般也会提供非阻塞函数。

比如WaitForSingleObject 就会加参数 “等待多久”（可选一直等下去）

追问：

就是程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓。

（1） 老鼠形象可以辨认，可用键盘 *** 纵老鼠上下左右移动；

（2） 迷宫的墙足够结实，老鼠不能穿墙而过；

（3） 正确检测结果，若老鼠在规定时间内走到粮仓处，提示成功，并给出一条路径，否则提示失败。

其他都处理好了,请问第三步怎么实现呢，有没有简单一点的处理方式呢？谢谢~

#include<iostream>

using namespace std;

class T //定义描述迷宫中当前位置的结构类型

{

public:

int x; //x代表当前位置的行坐标

int y; //y代表当前位置的列坐标

int dir; //0:无效,1:东,2:南,3:西,4:北

};

class LinkNode //链表结点

{

friend class Stack;

public:

T data;

LinkNode next;

};

class Stack

{

private:

LinkNode top; //指向第一个结点的栈顶指针

public:

Stack(); //构造函数，置空栈

~Stack(); //析构函数

void Push(T e); //把元素data压入栈中

T Pop(); //使栈顶元素出栈

T GetPop(); //取出栈顶元素

void Clear(); //把栈清空

bool empty(); //判断栈是否为空，如果为空则返回1，否则返回0

};

Stack::Stack() //构造函数，置空栈

{

top=NULL;

}

Stack::~Stack() //析构函数

{

}

void Stack::Push(T e) //把元素x压入栈中

{

LinkNode P;

P=new LinkNode;

P->data=e;

P->next=top;

top=P;

}

T Stack::Pop() //使栈顶元素出栈

{

T Temp;

LinkNode P;

P=top;

top=top->next;

Temp=P->data;

delete P;

return Temp;

}

T Stack::GetPop() //取出栈顶元素

{

return top->data;

}

void Stack::Clear() //把栈清空

{

top=NULL;

}

bool Stack::empty() //判断栈是否为空，如果为空则返回1，否则返回0

{

if(top==NULL) return 1;

else return 0;

}

int move[4][2]={{0,1},{1,0},{0,-1},{-1,0}}; //定义当前位置移动的4个方向

bool Mazepath(int maze,int m,int n);

//寻找迷宫maze中从（0，0）到（m,n）的路径

//到则返回true,否则返回false

void PrintPath(Stack p); //输出迷宫的路径

void Restore(int maze,int m,int n); //恢复迷宫

int GetMaze(int &m,int &n); //获取迷宫

//返回存取迷宫的二维指针

int main()

{

int m=0,n=0; //定义迷宫的长和宽

int maze; //定义二维指针存取迷宫

maze=GetMaze(m,n); //调用GetMaze(int &m,int &n)函数，得到迷宫

if(Mazepath(maze,m,n)) //调用Mazepath(int maze,int m,int n)函数获取路径

cout<<"迷宫路径探索成功!\n";

else cout<<"路径不存在!\n";

return 0;

}

int GetMaze(int &m,int &n)//返回存取迷宫的二维指针

{

int maze; //定义二维指针存取迷宫

int i=0,j=0;

cout<<"请输入迷宫的长和宽:";

int a,b;cin>>a>>b; //输入迷宫的长和宽

cout<<"请输入迷宫内容:\n";

m=a;

n=b; //m,n分别代表迷宫的行数和列数

maze=new int [m+2]; //申请长度等于行数加2的二级指针

for(i= 0;i<m+2;i++) //申请每个二维指针的空间

{

maze[i]=new int[n+2];

}

for(i=1;i<=m;i++) //输入迷宫的内容，0代表可通，1代表不通

for(j=1;j<=n;j++)

cin>>maze[i][j];

for(i=0;i<m+2;i++)

maze[i][0]=maze[i][n+1]=1;

for(i=0;i<n+2;i++)

maze[0][i]=maze[m+1][i]=1;

return maze; //返回存贮迷宫的二维指针maze

};

bool Mazepath(int maze,int m,int n)//寻找迷宫maze中从（0，0）到（m,n）的路径

//到则返回true,否则返回false

{

Stack q,p; //定义栈p、q,分别存探索迷宫的过程和存储路径

T Temp1,Temp2;

int x,y,loop;

Temp1x=1;

Temp1y=1;

qPush(Temp1); //将入口位置入栈

pPush(Temp1);

maze[1][1]=-1; //标志入口位置已到达过

while(!qempty()) //栈q非空，则反复探索

{

Temp2=qGetPop(); //获取栈顶元素

if(!(pGetPop()x==qGetPop()x&&pGetPop()y==qGetPop()y))

pPush(Temp2);

//如果有新位置入栈，则把上一个探索的位置存入栈p

for(loop=0;loop<4;loop++) //探索当前位置的4个相邻位置

{

x=Temp2x+move[loop][0]; //计算出新位置x位置值

y=Temp2y+move[loop][1]; //计算出新位置y位置值

if(maze[x][y]==0) //判断新位置是否可达

{

Temp1x=x;

Temp1y=y;

maze[x][y]=-1; //标志新位置已到达过

qPush(Temp1); //新位置入栈

}

if((x==(m))&&(y==(n))) //成功到达出口

{

Temp1x=m;

Temp1y=n;

Temp1dir=0;

pPush(Temp1); //把最后一个位置入栈

PrintPath(p); //输出路径

Restore(maze,m,n); //恢复路径

return 1; //表示成功找到路径

}

}

if(pGetPop()x==qGetPop()x&&pGetPop()y==qGetPop()y)

//如果没有新位置入栈，则返回到上一个位置

{

pPop();

qPop();

}

}

return 0; //表示查找失败，即迷宫无路经

}

void PrintPath(Stack p) //输出路径

{

cout<<"迷宫的路径为\n";

cout<<"括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)\n";

Stack t; //定义一个栈，按从入口到出口存取路径

int a,b;

T data;

LinkNode temp;

temp=new LinkNode; //申请空间

temp->data=pPop(); //取栈p的顶点元素，即第一个位置

tPush(temp->data); //第一个位置入栈t

delete temp; //释放空间

while(!pempty()) //栈p非空，则反复转移

{

temp=new LinkNode;

temp->data=pPop(); //获取下一个位置

//得到行走方向

a=tGetPop()x-temp->datax; //行坐标方向

b=tGetPop()y-temp->datay; //列坐标方向

if(a==1) temp->datadir=1; //方向向下，用1表示

else if(b==1) temp->datadir=2; //方向向右，用2表示

else if(a==-1) temp->datadir=3; //方向向上，用3表示

else if(b==-1) temp->datadir=4; //方向向左，用4表示

tPush(temp->data); //把新位置入栈

delete temp;

}

//输出路径，包括行坐标，列坐标，下一个位置方向

while(!tempty()) //栈非空，继续输出

{

data=tPop();

cout<<'('<<datax<<','<<datay<<','<<datadir<<","; //输出行坐标，列坐标

switch(datadir) //输出相应的方向

{

case 1:cout<<"↓)\n";break;

case 2:cout<<"→)\n";break;

case 3:cout<<"↑)\n";break;

case 4:cout<<"←)\n";break;

case 0:cout<<")\n";break;

}

}

}

void Restore(int maze,int m,int n) //恢复迷宫

{

int i,j;

for(i=0;i<m+2;i++) //遍历指针

for(j=0;j<n+2;j++)

{

if(maze[i][j]==-1) //恢复探索过位置，即把-1恢复为0

maze[i][j]=0;

}

}

示例输出：

测试1：

请输入迷宫的长和宽:5 5

请输入迷宫内容:

0 1 1 0 0

0 0 1 1 0

1 0 0 1 1

1 0 0 1 0

1 1 0 0 0

迷宫的路径为

括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)

(1,1,1,↓)

(2,1,2,→)

(2,2,1,↓)

(3,2,1,↓)

(4,2,2,→)

(4,3,1,↓)

(5,3,2,→)

(5,4,2,→)

(5,5,0,)

迷宫路径探索成功!

测试2：

请输入迷宫的长和宽:9 8

请输入迷宫内容:

0 0 1 0 0 0 1 0

0 0 1 0 0 0 1 0

0 0 0 0 1 1 0 1

0 1 1 1 0 0 1 0

0 0 0 1 0 0 0 0

0 1 0 0 0 1 0 1

0 1 1 1 1 0 0 1

1 1 0 0 0 1 0 1

1 1 0 0 0 0 0 0

迷宫的路径为

括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)

(1,1,1,↓)

(2,1,1,↓)

(3,1,1,↓)

(4,1,1,↓)

(5,1,2,→)

(5,2,2,→)

(5,3,1,↓)

(6,3,2,→)

(6,4,2,→)

(6,5,3,↑)

(5,5,2,→)

(5,6,2,→)

(5,7,1,↓)

(6,7,1,↓)

(7,7,1,↓)

(8,7,1,↓)

(9,7,2,→)

(9,8,0,)

迷宫路径探索成功!

我只会qbasic

不过我还是会Pascal的

下面是四十七和五十一题的：

47:

var

n:integer;a:array[19] of integer;vis:array[19] of boolean;

procedure search(depth:integer);

var i:integer;

begin

if depth>n then begin for i:=1 to n-1 do write(a[i],' ');

writeln(a[n]);exit;end;

for i:=1 to n do if not vis[i] then begin a[depth]:=i;

vis[i]:=true;search(depth+1);vis[i]:=false;end;

end;

begin

readln(n);fillchar(vis,sizeof(vis),false);search(1);

end

51:

var

f:packed array[0100000] of longint;i,x,k,n,m:longint;

w,c:packed array[02000] of longint;

begin

fillchar(f,sizeof(f),0);readln(m,n);

for i:=1 to n do readln(w[i],c[i]);

for i:=1 to n do

for x:=m downto w[i] do

if f[x-w[i]]+c[i]>f[x] then f[x]:=f[x-w[i]]+c[i];

writeln(f[m]);

end

符合要求吗？？

救老鼠出迷宫一款中文的类似华容道的迷宫游戏，只不过这次的主角是一只老鼠。救老鼠出迷宫（Mouse Trap）玩法上和华容道没多大区别，都是移动方块让老鼠可以走出去。救老鼠出迷宫游戏中还会出现如金币等各种道具，利用它们可以解锁多种隐藏功能。有趣且益智。

以上就是关于关于基于MFC的openGL游戏的框架全部的内容，包括:关于基于MFC的openGL游戏的框架、C的迷宫问题、c++ 规定函数执行时间 超时则终止并抛出错误等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！