通常我们认为，纯C（即不使用C艹）很难实现跨平台的游戏。这是由于它支持的图形库非常少，一般需要调用系统句柄才能进行图形化。但是很显然这是一个及其费时费力还容易出错的方式。所以，在这篇文章里，我希望给大家介绍一些比较轻松的制作C语言的跨平台游戏的方式。

I. 游戏引擎的选择

引擎绝对是个好东西，它帮你简化了许多繁琐而重复的构建阶段的实现。所以我们通常希望有一个好用的引擎。这里有我能找到的所有跨平台C语言库。

• Curses: 这是一个非常之古老的图形库，只支持命令行的图形编成。好在它学习简单、轻量便捷、函数丰富，它依然是新手学习游戏逻辑最佳的选择。它支持Windos(Ncurcesw), Linux(Ncurses,curses), MacOS(Ncurses), 移动端大部分的终端模拟器, 和你能找到的许多古老系统(如Dos)。
• SDL: 额，这位老朋友就不用介绍了吧。如果有些游戏编程的基础，它会让你感到很亲切。它应该支持所有有图形界面的操作系统。
• OpenGL: 如果你是一位C语言高手，想做高质量3D游戏，不要犹豫，就是它了。它同样支持所有有图形界面的操作系统。因为OpenGL是一个“标准”，由你的显卡生产商实现，所以使用时需借助一个窗口库和一个函数查找库来编程。你可以感受到搭建编辑环境所带来的痛苦，非常不推荐新手使用！
• 其他：TBOX， LCUI， 这两个都是跨平台的。

II. 游戏逻辑的研究

不管你采用了哪个图形库，游戏逻辑都不会变化太多。以下是一个适用与所有游戏的游戏逻辑。

1. 导入图形库
2. 读入所有信息、模型
3. 初始化所有设置，显示开始界面
4. 开始游戏主循环：输入、处理、绘制、刷新、暂停等
5. 达到退出条件，显示结束界面
6. 保存所有信息
7. 退出

这套流程/逻辑可以用于几乎所有游戏。

其实很推荐使用流程图来理清思路。

特别要注意各种“边界”值。即你想要把数轴的原点归为哪边？这个问题可以用文氏图来解决。

III. 游戏编程的推荐编程范式 和 方式

虽说编程范式没有最好与最坏之分，但绝对有适合一定领域的编程范式。这里，我们通常建议使用函数式编程。

编程方式，即编程规范。有些人认为开发过程越快就越好，可事情远没有这么简单。比如你为了快速开发使用了a,b,c ...... x,y,z共26个变量，结果你有一段时间去做别的项目了，回来拾起旧项目时一脸蒙蔽:"这都啥玩意阿？"。所以，应该把代码写得易于阅读，层次分明，注释有用。（这里表扬Python）

IV. 一个“简单”的例子

这是一个“简单”的打飞机游戏，使用C语言和Ncurses库开发。不管你承认与否，这真的是一个开始游戏编程的极好的地方。

编译时记得链接上你的Ncurses库

/*
Finished Version 0.1
Complitet: cd Desktop && gcc -o test01.out Shooter01.c -lncurses && ./test01.out
*/

#include <ncurses.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>


/* Global */
int HEIGHT, WIDTH, MAP_Y, MAP_X, MAP_HEIGHT, MAP_WIDTH, Timer, Hp, Score, Energy;

struct Pos *Bullets;
struct Pos *Enemies;
int Bullets_len, Bullets_full;
int Enemies_len, Enemies_full;


/* == Structs ==  */
struct Pos
{
	int x;
	int y;
};


/* == Tools ==  */

/* == Starting & Ending == */
void starting(void)
{
	initscr();
	
	// 准备工作
	noecho(); // 取消回显
    raw(); // 取消缓冲区
    nodelay(stdscr, 1); // 对于getch()不等待
    keypad(stdscr, 1); // 可以读取特殊字符
    curs_set(0); // 光标不可见
    getmaxyx(stdscr, HEIGHT, WIDTH); // 获取屏幕长宽
    
    // 初始化游戏
    Timer = 0;
    Hp = 3;
    Score = 0;
    Energy = 100;
    
    MAP_HEIGHT = 30;
    MAP_WIDTH = 42;
    
    Bullets_len =30;
	Bullets_full=0;
	Bullets = (struct Pos *)malloc(Bullets_len * sizeof(struct Pos));
	for(int bullet=0; bullet<Bullets_len; bullet++)
	{
		Bullets[bullet].x=-1;
		Bullets[bullet].y=-1;
	}
	
	Enemies_len =30;
	Enemies_full=0;
	Enemies = (struct Pos *)malloc(Enemies_len * sizeof(struct Pos));
	for(int enemy=0; enemy<Enemies_len; enemy++)
	{
		Enemies[enemy].x=-1;
		Enemies[enemy].y=-1;
	}
    
    MAP_Y = 2;
    MAP_X = (WIDTH-MAP_WIDTH)/2;
    
    // 开始界面
    char title[] = "= Shooter v0.1 =";
    mvprintw(HEIGHT/2, (WIDTH-strlen(title))/2, "%s", title);
    char message[] = "[Press any key to start]";
    mvprintw(HEIGHT-3, (WIDTH-strlen(message))/2, "%s", message);
    char tips[] = "Moving: W A (Energy-1)          Shooting: J (Energy-5)          Quit: Q          Get Energy by killing enemies!";
    mvprintw(HEIGHT-1, (WIDTH-strlen(tips))/2, "%s", tips);
    refresh();
    
    while(getch()==ERR)
    {
    	usleep(1000);
    }
    clear(); //清屏
    refresh();
}


void ending(void)
{
	
	// 结束界面
    char title[] = "= Game Over =";
    mvprintw(HEIGHT/2, (WIDTH-strlen(title))/2, "%s", title);
    char message[] = "[Press any key to quit]";
    mvprintw(HEIGHT-2, (WIDTH-strlen(message))/2, "%s", message);
    refresh();
    
    while(getch()==ERR)
    {
    	usleep(1000);
    }
    clear(); //清屏
    refresh();
	endwin();
	
	exit(0);
}


/* Operation */
// 出界判定
int on_map(int x, int y)
{
	if(x<0 || x>=MAP_WIDTH || y<0 || y>=MAP_HEIGHT)
	{
		return 0;
	}
	else return 1;
}


void new_bullet(struct Pos player)
{
	// 加大内存
	if(Bullets_len==Bullets_full)
	{
		Bullets = realloc(Bullets, Bullets_len + 30*sizeof(struct Pos));
		for(int index=Bullets_len; index<Bullets_len+30; index++)
		{
			Bullets[index].x=-1;
			Bullets[index].y=-1;
			
		}
	}
	// 新建子弹
	for(int index=0; index<Bullets_len; index++)
	{
		if(Bullets[index].x==-1) //x=-1就算空位
		{
			Bullets[index].x=player.x+1;
			Bullets[index].y=player.y-1;
			Bullets_full++;
			break;
		}
	}
}

// 销毁子弹
void destroy_bullet(int bullet)
{
	Bullets[bullet].x=-1;
	Bullets[bullet].y=-1;
	Bullets_full--;
}

// 移动子弹
void move_bullets(void)
{
	for(int bullet=0; bullet<Bullets_len; bullet++)
	{
		if(on_map(Bullets[bullet].x, Bullets[bullet].y) && Bullets[bullet].x!=-1)
		{
			Bullets[bullet].y--;
		}
		else if(Bullets[bullet].x!=-1)
		{
			destroy_bullet(bullet);
			continue;
		}
		
	}
}


void new_enemies(int sum)
{
	// 加大内存
	if(Enemies_len==Enemies_full)
	{
		Enemies = realloc(Enemies, Enemies_len + 30*sizeof(struct Pos));
		for(int index=Enemies_len; index<Enemies_len+30; index++)
		{
			Enemies[index].x=-1;
			Enemies[index].y=-1;
			
		}
	}
	// 新建对手
	for(int index=0; index<Enemies_len; index++)
	{
		if(Enemies[index].x==-1) //x=-1就算空位
		{
			srand(Timer);
			
			Enemies[index].x=rand()%MAP_WIDTH;
			Enemies[index].y=0;
			Enemies_full++;
			break;
		}
	}
}

// 销毁对手
void destroy_enemy(int enemy)
{
	Enemies[enemy].x=-1;
	Enemies[enemy].y=-1;
	Enemies_full--;
	Score += 1;
}

// 移动对手
void move_enemies(void)
{
	for(int enemy=0; enemy<Enemies_len; enemy++)
	{
		if(on_map(Enemies[enemy].x, Enemies[enemy].y))
		{
			Enemies[enemy].y++;
		}
		else if(Enemies[enemy].x!=-1)
		{
			destroy_enemy(enemy);
		}
		
	}
}

// 撞击判定
void judge_hits(struct Pos player)
{
	for(int enemy=0; enemy<Enemies_len; enemy++)
	{
		if(on_map(Enemies[enemy].x, Enemies[enemy].y))
		{
			for(int bullet=0; bullet<Bullets_len; bullet++)
			{
				if(on_map(Bullets[bullet].x, Bullets[bullet].y))
				{
					if(abs(Bullets[bullet].x-Enemies[enemy].x)<=1 && Bullets[bullet].y==Enemies[enemy].y) // 对手与子弹
					{
						destroy_bullet(bullet);
						destroy_enemy(enemy);
						Score+=99;
						Energy+=10;
					}
				}
			}
			
			// 玩家与对手
			if(abs(player.x+1-Enemies[enemy].x)<=1 && player.y==Enemies[enemy].y)
			{
				Hp-=1;
				destroy_enemy(enemy);
				Score-=99999;
				Energy+=100;
			}
		}
	}	
	
}


/* == Drawing == */

// 画地图
void draw_map(void)
{
	mvprintw(MAP_Y-1, MAP_X-1, "###########################################");
	
	for(int index=MAP_Y-1; index<=MAP_Y+MAP_HEIGHT; index++)
	{
		mvprintw(index, MAP_X-1, "#");
		mvprintw(index, MAP_X+MAP_WIDTH, "#");
	}
	
	mvprintw(MAP_Y+MAP_HEIGHT, MAP_X-1, "###########################################");
}

// 画玩家
void draw_player(struct Pos pos, struct Pos last_pos)
{
	char player[]="/|\\";
	mvprintw(MAP_Y+pos.y, MAP_X+pos.x, "%s", player);
}

// 画子弹
void draw_bullets(void)
{
	for(int bullet=0; bullet<Bullets_len; bullet++)
	{
		if(on_map(0, Bullets[bullet].y))
		{
			mvprintw(MAP_Y+Bullets[bullet].y, MAP_X+Bullets[bullet].x, "^");
		}
	}

}

// 画对手
void draw_enemies(void)
{
	for(int enemy=0; enemy<Enemies_len; enemy++)
	{
		if(on_map(0, Enemies[enemy].y))
		{
			mvprintw(MAP_Y+Enemies[enemy].y, MAP_X+Enemies[enemy].x, "V");
		}
	}

}



int main(void)
{
    starting();
    
    char input;
    
    struct Pos player_pos, player_last_pos;
    player_pos.x = MAP_WIDTH/2-1;
    player_last_pos.x = player_pos.x;
    player_pos.y = MAP_HEIGHT-2;
    player_last_pos.y = player_pos.y;
    
    Bullets_full=0;
    
    // 游戏主循环
    while(1)
    {
    	// Inputs
    	input = getch();
    	if(input=='q')
    	{
    		break;
    	}
    	
    	if(input=='a' && on_map(player_pos.x-2, 0) && Energy>=1)
    	{
    		player_last_pos.x = player_pos.x;
    		player_pos.x-=2;
    		Energy--;
    	}
    	if(input=='d' && on_map(player_pos.x+2+3, 0) && Energy>=1)
    	{
    		player_last_pos.x = player_pos.x;
    		player_pos.x+=2;
    		Energy--;
    	}
    	if(input=='j' && Energy>=5)
    	{
    		new_bullet(player_pos);
    		Energy-=5;
    	}
    	
    	// Draw
    	clear();
    	draw_map();
    	
    	mvprintw(MAP_Y+MAP_HEIGHT+2, MAP_X-1, "Hp: %d", Hp);
    	mvprintw(MAP_Y+MAP_HEIGHT+2, MAP_X+MAP_WIDTH-20, "Score: %d", Score);
    	mvprintw(MAP_Y+MAP_HEIGHT+3, MAP_X-1, "Energy: %d", Energy);
    	draw_player(player_pos, player_last_pos);
    	draw_bullets();
    	draw_enemies();
    	
    	// Update
    	move_bullets();
    	if(Timer%20==0)	new_enemies(1);
    	if(Timer%10==0)	move_enemies();
    	judge_hits(player_pos);
    	if(Hp<1) ending();
    	
    	// Tests
    	mvprintw(1, MAP_X+MAP_WIDTH+2, "Screen WIDTH, HEIGHT: %d, %d", WIDTH, HEIGHT);
    	mvprintw(2, MAP_X+MAP_WIDTH+2, "MAP X,Y: %d, %d", MAP_X, MAP_Y);
    	mvprintw(3, MAP_X+MAP_WIDTH+2, "MAP WIDTH, HEIGHT: %d, %d", MAP_WIDTH, MAP_HEIGHT);
    	mvprintw(4, MAP_X+MAP_WIDTH+2, "Bullets Len, Full: %d, %d", Bullets_len, Bullets_full);
    	mvprintw(5, MAP_X+MAP_WIDTH+2, "Enemies Len, Full: %d, %d", Enemies_len, Enemies_full);
    	mvprintw(7, MAP_X+MAP_WIDTH+2, "Player Pos: %d, %d", player_pos.x, player_pos.y);
    	mvprintw(8, MAP_X+MAP_WIDTH+2, "Timer: %d", Timer);
    	
    	mvprintw(1, 1, "Bullets:");
    	for(int index=0; index<Bullets_len; index++)
    	{
    		mvprintw(2+index/3, 2+15*(index%3), "%d: %d, %d", index, Bullets[index].x, Bullets[index].y);
    	}
    	
    	mvprintw(Bullets_len/3+3, 1, "Enemies:");
    	for(int index=0; index<Enemies_len; index++)
    	{
    		mvprintw(Bullets_len/3+4+index/3, 2+15*(index%3), "%d: %d, %d", index, Enemies[index].x, Enemies[index].y);
    	}
    	
    	// Time
    	refresh();
    	Timer++;
    	usleep(15000);
    	
	}
	
    ending();
    return 0;
}