游戏编程教程简介 ( Introduction to the Games Programming Tutorials )

This is the first of several games programming Tutorials in C for complete beginners. Instead of concentrating on teaching C then showing example programs they teach C by providing you with complete programs (ie games) in C

这是面向初学者的C语言游戏入门教程中的第一个。 与其专注于C的教学，不如展示示例程序，而是通过为您提供C的完整程序(即游戏)来教C的示例。

保持简单 ( Keeping It Simple )

The first game in the series is a console (i.e. text based game called Star Empires). Star Empires is a simple game where you have to capture all 10 systems in the Galaxy while stopping your AI opponent doing the same.

该系列中的第一款游戏是游戏机(即称为“星际帝国”的基于文本的游戏)。 《星际帝国》是一款简单的游戏，您必须捕获银河中的所有10个系统，同时阻止AI对手也这样做。

You start owning System 0, while your enemy own system 9. The remaining eight systems (1-8) all start neutral. All systems start within a 5 parsec x 5 parsec square so no system is more than 6 parsecs apart. The furthest two points are (0,0) and (4,4). By Pythagoras theorem, the furthest distance apart of any two systems is the square root ((4)² + (4)²) which is the square root of 32 which is about 5.657.

您开始拥有系统0，而敌人拥有系统9。其余八个系统(1-8)都开始处于中立状态。 所有系统均以5秒差距x 5秒差距平方开始，因此，每个系统之间的距离均不得超过6秒差距。 最远的两个点是(0,0)和(4,4)。 根据毕达哥拉斯定理，任何两个系统之间最远的距离是平方根((4) ² +(4) ² )，它是32的平方根，约为5.657。

Please note, this is not the final version and will be amended. Last change: August 21, 2011.

请注意，这不是最终版本，将被修改。 最后更改：2011年8月21日。

回合制和实时 ( Turn Based & Real-Time )

The game is turn based and each turn you give orders to move any number of fleets from any system you own to any other system. If you own more than one system you can order fleets to move from all your systems to the target system. This is done pro rata rounded up so if you own three systems (1,2,3) with 20, 10 and 5 fleets present and you order 10 Fleets to go to system 4 then 6 will go from system 1, 3 from system 2 and 1 from system 3. Each fleet moves 1 parsec per turn.

游戏是基于回合制的，每回合您下达命令将任意数量的舰队从您拥有的任何系统转移到任何其他系统。 如果您拥有多个系统，则可以命令车队从所有系统转移到目标系统。 这是按比例四舍五入完成的，因此，如果您拥有拥有20个，10个和5个机队的三个系统(1,2,3)，并且订购10个机队进入系统4，则6个将从系统1进入系统3系统1。每个车队每转1秒差距。

Each turn lasts 5 seconds though you can alter the speed to speed it up or slow it down by changing the 5 in this line of code to 3 or 7 or whatever you choose. Look for this line of code:

尽管您可以通过将代码行中的5更改为3或7或您选择的任何一种来改变速度来加快或减慢速度，但每转持续5秒。 查找以下代码行：

onesec = clock()+(5*CLOCKS_PER_SEC);

onesec = clock()+(5*CLOCKS_PER_SEC);

C程序设计教程 ( C Programming Tutorial )

This game has been programmed and assumes that you don't know any C programming. I'll introduce C programming features in this and the next two or three tutorials as they progress. First though you'll need a compiler for Windows. Here are two free ones:

该游戏已经编程，并假定您不知道任何C编程。 我将在本教程以及接下来的两三个教程中介绍C编程功能，并逐步进行介绍。 首先，尽管您需要Windows编译器。 这是两个免费的：

• Try CC386

  尝试CC386

• Or Visual C++ 2010 Express

  或Visual C ++ 2010 Express

The CC386 article walks you through creating a project. If you install that compiler then all you have to do is load the Hello World program as described, copy and paste the source code over the example, save it and then hit F7 to compile it and run it. Likewise the Visual C++ 2010 article creates a hello world program. Overwrite it and press F7 to build Star Empires., F5 to run it.

CC386文章将引导您完成创建项目。 如果安装了该编译器，则只需按照说明加载Hello World程序，然后将源代码复制并粘贴到示例中，保存该源代码，然后单击F7进行编译并运行它。 同样，Visual C ++ 2010文章创建了一个hello world程序。 覆盖它，然后按F7键构建“星际帝国”，按F5键运行它。

On the next page - Making Star Empires Work

在下一页 -使《星际帝国》发挥作用

使《星际帝国》发挥作用 ( Making Star Empires Work )

使《星际帝国》发挥作用 ( Making Star Empires Work )

We need to store infomation on fleets and systems in the game. A fleet is one or more ships with an order to move from one sytem to another. A star system is a number of planets but is more of an abstract entity in this game. We need to hold the following information for a fleet.

我们需要在游戏中将信息存储在舰队和系统上。 舰队是指命令从一个系统转移到另一个系统的一艘或多艘船。 恒星系统是许多行星，但在此游戏中更多地是抽象实体。 我们需要为舰队保留以下信息。

• Origin System (1-10).原始系统(1-10)。
• Destination System (1-10) 目标系统(1-10)
• How Many Ships (1-Many)多少艘船(1对多)
• Turns to Arrive转向到达
• Whose Fleet is it? 0= Player, 9 = Enemy这是谁的舰队？ 0 =玩家，9 =敌人

We will use a struct in C to hold this:

我们将在C中使用一个结构来保存此内容：


int fromsystem;
int fromsystem;
int tosystem;
int tosystem;
int turns;
int turns;
int fleetsize;
int fleetsize;
int owner;
int owner;
};
};

A struct is a collection of data, in this case 5 numbers that we manipulate as one. Each number has a name, eg fromsystem, tosystem. These names are variable names in C and can have underscores like_this but not spaces. In C, numbers are either integer; whole numbers like 2 or 7 these are called ints, or numbers with decimal parts like 2.5 or 7.3333 and these are called floats. In the whole of Star Empires, we only use floats once. In a chunk of code calculating the distance between two places. Every other number is an int.

结构是数据的集合，在这种情况下，我们将5个数字作为一个数字进行处理。 每个数字都有一个名称，例如fromsystem，tosystem。 这些名称是C语言中的变量名称，可以带有下划线like_this，但不能带空格。 在C语言中，数字要么是整数，要么是整数。 像2或7这样的整数称为整数，或者将小数部分称为2.5或7.3333的整数称为浮点数。 在整个《星际帝国》中，我们只使用一次浮动。 在一段代码中计算两个位置之间的距离。 其他所有数字均为整数。

So fleet is the name for a data structure holding five int variables. Now that's for one Fleet. We don't know how many fleets we'll need to hold so we'll allocate generous room for 100 using an array. Think of a struct as like a dinner table with room for five people (ints). An array is like a long row of dinner tables. 100 tables means it can hold 100 x 5 people.

因此，fleet是包含五个int变量的数据结构的名称。 现在是一支舰队。 我们不知道需要保持多少舰队，因此我们将使用数组为100个分配宽敞的空间。 将结构想像成可容纳五个人的餐桌(整数)。 数组就像一排排长餐桌。 100张桌子意味着它可以容纳100 x 5人。

If we were actually serving those 100 dinner tables, we'd need to know which table was which and we do this by numbering. In C, we always numbers elements of arrays starting at 0. The first dinner table (fleet) is number 0, the next one is 1 and the last one is 99. I always remember it as being how many dinner tables is this table from the start? The first one is at the start so is 0 along.

如果我们实际上要提供那100张饭桌，我们需要知道是哪张饭桌，并通过编号来完成。 在C语言中，我们总是对从0开始的数组元素进行编号。第一个饭桌(fleet)为数字0，下一个饭桌为1，最后一个饭桌为99。我一直记得它是该表中有多少个饭桌开始？ 第一个是开始，所以一直是0。

This is how we declare the fleets (ie our dinner tables).

这就是我们宣布船队(即我们的餐桌)的方式。

Read this from left to right. Struct fleet refers to our structure to hold one fleet. The name fleets is the name we give to all the fleets and [100] tells us there are 100 x struct fleet in the fleets variable. Each int occupies 4 locations in memory (called bytes) so one fleet occupies 20 bytes and 100 fleets is 2000 bytes. It's always a good idea to know how much memory our program needs to hold its data.

从左到右阅读。 结构车队是指我们拥有一个车队的结构。 舰队这个名字是我们给所有舰队的名字，[100]告诉我们在舰队变量中有100 x struct舰队。 每个int在内存中占据4个位置(称为字节)，因此一个队列占用20个字节，而100个队列则为2000字节。 知道我们的程序需要多少内存来保存其数据总是一个好主意。

In the struct fleet, each of the ints holds an integer number. This number is stored in 4 bytes and the range of this is from -2,147,483,647 to 2,147,483,648. Most of the time we'll use smaller values. There are ten systems so both fromsystem and tosystem will hold values 0 to 9.

在struct队列中，每个int都有一个整数。 该数字存储在4个字节中，范围从-2,147,483,647到2,147,483,648。 在大多数情况下，我们将使用较小的值。 有十个系统，因此fromsystem和tosystem都将保持值0到9。

On the next page: Systems and Random Numbers

在下一页：系统和随机数

关于系统和随机数 ( About Systems and Random Numbers )

Each of the neutral systems (1-8) starts with 15 ships (a number I picked out of the air!) to start with and the other two (yours: system 0 and your computer opponent at system 9) have 50 ships each. Each turn the number of ships at a system is increased by 10% rounded down. So after one turn if you don't move them, your 50 will become 55 and each of the neutral systems will have 16 (15 + 1.5 rounded down). Note that fleets moving to another system don't increase in numbers.

每个中立系统(1-8)以15艘船(我是从空中挑出来的！)开始的，其他两个(您是：系统0和您的计算机对手在系统9)有50艘船。 每转一圈，系统中的船只数目将增加10％向下舍入。 因此，如果您不移动它们，一转之后，您的50将变成55，并且每个中立系统将具有16(向下取整15 + 1.5)。 请注意，转移到另一个系统的机队数量没有增加。

Increasing the number of ships this way may seem a little odd, but I've done it to keep the game moving along. Rather than clutter this tutorial with too much on design decisions, I wrote a separate article about the design decisions of Star Empires.

以这种方式增加飞船数量似乎有些奇怪，但我这样做是为了保持游戏的发展。 我写了一篇有关《星际帝国》的设计决策的单独文章，而不是使本教程过多地涉及设计决策。

实施系统 ( Implementing Systems )

At the start we need to generate all the systems and put them on the map, with a maximum of one system in each location, As there are 25 locations on our 5 x 5 grid, we will have ten systems and 15 empty locations. We generate them using the function GenMapSystems() which we'll look at on the next page.

首先，我们需要生成所有系统并将其放置在地图上，每个位置最多有一个系统。由于我们的5 x 5网格上有25个位置，因此我们将有10个系统和15个空位置。 我们使用GenMapSystems()函数生成它们，我们将在下一页中对其进行介绍。

A system is stored in a struct, with the following 4 fields that are all int.

系统存储在结构中，以下四个字段均为int。


    int x,y;
int x,y;
    int numfleets;
int numfleets;
    int owner;
int owner;
};
};

The galaxy (all 10 systems) is stored in another array just like with fleets except we have 10 systems.

除了拥有10个系统外，银河系(所有10个系统)都与舰队一样存储在另一个阵列中。

随机数 ( Random Numbers )

All games need random numbers. C has a built in function rand() that returns a random int. We can force this into a range by passing the maximum number in and using the % operator. (Modulus). This is like clock arithemetic except instead of 12 or 24 we pass in an int number called max.

所有游戏都需要随机数。 C具有内置函数rand()，该函数返回随机int。 我们可以通过传入最大值并使用％运算符来将其强制设置为一个范围。 (模数)。 就像时钟算术一样，只是我们传入一个称为max的整数，而不是12或24。


int Random(int max) {
int Random(int max) {
 return (rand() % max)+1;
return (rand() % max)+1;
}
}

This is an example of a function which is a piece of code wrapped up inside a container. The first line here that starts /* and end */ is a comment. It says what the code does but is ignored by the compiler which reads the C instructions and converts them into instructions that the computer understands and can execute very fast.

这是一个函数示例，该函数是包装在容器内的一段代码。 以/ *开始并以* /结束的第一行是注释。 它说明了代码的作用，但是被编译器忽略，编译器将读取C指令并将其转换为计算机可以理解并可以快速执行的指令。

• Wonder what a compiler is? Read What is a Compiler? (Article)

  想知道什么是编译器？ 阅读什么是编译器？ (文章)

A function is like a mathematical function such as Sin(x). There are three parts to this function:

函数就像数学函数，例如Sin(x)。 此功能分为三个部分：

The int says what type of number it returns (usually int or float). Random is the name of the function and (int max) says that we're passing in an int number. We might use it like this:

整数表示返回的数字类型(通常是整数或浮点数)。 随机是函数的名称，并且(int max)表示我们正在传递一个int数。 我们可以这样使用它：


dice = Random(6); /* returns a random number between 1 and 6 */
dice = Random(6); /* returns a random number between 1 and 6 */

The line:

该行：

On the next page: Generating a Random Start Map

在下一页：生成随机开始图

生成随机开始图 ( Generating a Random Start Map )

This code below generates the start map. That's it shown above.

下面的代码生成开始图。 上面已经显示了。


int i,x,y;
int i,x,y;
    for (x=0;x      for (y=0;y         layout[x][y]=' ';
for (x=0;x for (y=0;y layout[x][y]=' ';
    }
}
    InitSystem(0,0,0,50,0) ;
InitSystem(0,0,0,50,0) ;
    InitSystem(9,4,4,50,1) ;
InitSystem(9,4,4,50,1) ;
    /* Find an empty space for remaining 8 systems*/
/* Find an empty space for remaining 8 systems*/
    for (i=1;i      do {
for (i=1;i do {
        x= Random(5)-1;
x= Random(5)-1;
        y= Random(5)-1;
y= Random(5)-1;
      }
}
      while (layout[x][y] !=' ') ;
while (layout[x][y] !=' ') ;
      InitSystem(i,x,y,15,-1) ;
InitSystem(i,x,y,15,-1) ;
    }
}
}
}

Generating Systems is a matter of adding the player and the opponents systems (at 0,0) and (4,4) and then randomly adding 8 systems in the remaining 23 empty locations.

生成系统只需添加玩家和对手系统(分别为0,0和(4,4))，然后在其余23个空白位置随机添加8个系统即可。

The code uses three int variables defined by the line

该代码使用该行定义的三个int变量

A variable is a location in memory that holds an int value. The variables x and y holds the coordinates of the systems and will hold a value in the range 0-4. The variable i is used for counting in loops.

变量是内存中保存一个int值的位置。 变量x和y保留系统的坐标，并将保留0-4范围内的值。 变量i用于循环计数。

To place the 8 random systems in the 5x5 grid we need to know if a location has a system already and prevent another one being put in the same location. For this we use a simple two dimensional array of characters. The type char is another type of variable in C and holds a single character like 'B' or 'x'.

要将8个随机系统放置在5x5网格中，我们需要知道某个位置是否已有系统，并防止将另一个系统放置在同一位置。 为此，我们使用一个简单的二维字符数组。 char类型是C语言中变量的另一种类型，并包含单个字符，如“ B”或“ x”。

C语言中的数据类型入门 ( Primer on Datatypes in C )

The fundamental type of variables in C are int (integers like 46), char (a single character like 'A'), and float (for holding numbers with floating point like 3.567). Arrays [] are for holding lists of the same element. So char[5][5] defines a list of lists; a two dimensional array of chars. Think of it like 25 Scrabble pieces arranged in a 5 x 5 grid.

C语言中变量的基本类型是int(像46这样的整数)，char(像'A'这样的单个字符)和float(用于保存像3.567这样的浮点数)。 数组[]用于保存相同元素的列表。 因此char [5] [5]定义了一个列表列表； 字符的二维数组。 可以将它想像成以5 x 5网格排列的25个拼字游戏。

现在我们循环！ ( Now We Loop! )

Each char is initially set to a space in a double loop using two for statements. A for statement has three parts. An initialization, a comparison part and a change part.

每个char最初使用两个for语句设置为双循环中的空格。 for语句分为三个部分。 初始化，比较部分和更改部分。


}
}

• x=0; This is the initialization part.x = 0; 这是初始化部分。
• x X
• x++. This is the change part. It adds 1 to x.x ++。 这是零钱的一部分。 将x加1。

So (for (x=0;x

因此(对于(x = 0; x

Inside the for (x loop is a for y loop that does the same for y. This y loop happens for each value of X. When X is 0, Y will loop from 0 to 4, when X is 1, Y will loop and so on. This means that every one of the 25 locations in the layout array is initialized to a space.

在for(x循环内是一个for y循环，该循环对于y也是相同的。此y循环发生在X的每个值上。当X为0时，Y将从0循环到4，当X为1时，Y循环并意思是说，布局数组中25个位置中的每一个都被初始化为一个空格。

After the for loop the function InitSystem is called with five int parameters. A function has to be defined before it is called or the compiler won't know how many parameters it should have. InitSystem has these five parameters.

在for循环之后，将使用五个int参数调用InitSystem函数。 必须在调用函数之前定义函数，否则编译器将不知道应具有多少个参数。 InitSystem具有这五个参数。

On the next page: Generating a Random Start Map Continues...

在下一页：继续生成随机开始图...

继续生成随机开始图 ( Generating a Random Start Map Continues )

These are the parameters to InitSystem.

这些是InitSystem的参数。

• systemindex - a value from 0 -9.systemindex-0 -9之间的值。
• x and y - coordinates of the system (0-4).x和y-系统坐标(0-4)。
• numships - how many ships there are at this system.数量-此系统上有多少艘船。
• owner. Who owns a system. 0 means the player, 9 means the enemy.所有者。 谁拥有系统。 0表示玩家，9表示敌人。

So the line InitSystem(0,0,0,50,0) initializes system 0 at locations x=-0,y=0 with 50 ships to owner 0.

因此，InitSystem(0,0,0,50,0)行在位置x = -0，y = 0的位置初始化了系统0，其中50艘船发给了所有者0。

C has three types of loop, while loops, for loops and do loops and we use for and do in the function GenMapSystems. Here we have to place the remaining 8 systems somewhere in the galaxy.

C具有三种循环类型，而while循环，for循环和do循环，我们在GenMapSystems函数中使用for和do。 在这里，我们必须将剩余的8个系统放置在银河系中的某个位置。


        x= Random(5)-1;
x= Random(5)-1;
        y= Random(5)-1;
y= Random(5)-1;
    }
}
   while (layout[x][y] !=' ') ;
while (layout[x][y] !=' ') ;
   InitSystem(i,x,y,15,0) ;
InitSystem(i,x,y,15,0) ;
}
}

There are two nested loops in this code. The outside loop is a for statement that counts up the i variable from an initial value of 1 to a final value of 8. We'll use i to refer to the system. Remember we've already initialzed system 0 and 9, so now we're initialising systems 1-8.

此代码中有两个嵌套循环。 外部循环是一个for语句，它将i变量从初始值1递增到最终值8。我们将使用i来引用系统。 请记住，我们已经初始化了系统0和9，所以现在我们要初始化系统1-8。

Everything from the do { to the while (layout[x][y] is the second loop. It's syntax is do {something} while (condition is true); So we assign random values to x and y, each value in the range 0-4. Random(5) returns a value in the range 1 to 5, subtracting 1 gets the range 0-4.

从do {到while(layout [x] [y]是第二个循环。它的语法是do {something} while(条件为true);”，所以我们为x和y分配随机值，每个值在范围内0-4。Random(5)返回范围为1到5的值，减去1则得到范围为0-4。

We don't want to put two systems at the same coordinates so this loop is looking for a random location that has a space in it. If there is a system there, the layout[x][y] will not be a space. When we call InitSystem it puts a different value there. BTW != means not equal to and == means equal to.

我们不想将两个系统放置在相同的坐标上，因此此循环正在查找其中具有空格的随机位置。 如果那里有系统，则layout [x] [y]将不会有空格。 当我们调用InitSystem时，它将在其中放置一个不同的值。 BTW！=表示不等于，==等于。

When the code reaches the InitSystem after while (layout[x][y] != ' '), x and y definitely refer to a place in layout that has a space in it. So we can call InitSystem and then go round the for loop to find a random location for the next system until all 8 systems have been placed.

当代码在while(layout [x] [y]！='')之后到达InitSystem时，x和y绝对引用布局中具有空格的位置。 因此，我们可以调用InitSystem，然后绕过for循环以查找下一个系统的随机位置，直到所有8个系统都已放置。

The first call to InitSystem sets up system 0 at location 0,0 (the top left of the grid) with 50 fleets and woned by me. The second call initialises system 9 at location 4,4 (bottom right) with 50 fleets and it's owned by player 1. We'll look closely at what InitSystem actually does in the next tutorial.

第一次调用InitSystem时，在50个机队的位置0,0(网格的左上方)设置了系统0，这是我赢得的。 第二次调用将初始化9在系统4,4(右下)的位置，该系统有50个车队，并且由玩家1拥有。我们将在下一个教程中仔细研究InitSystem的实际操作。

#define ( #define )

These lines declare literal values. It's customary to put them in upper case. Everywhere the compiler sees MAXFLEETS, it uses the value 100. Change them here and it applies everywhere:

这些行声明文字值。 通常将它们大写。 编译器在所有看到MAXFLEETS的地方都使用值100。在此处进行更改，然后将其应用于所有地方：

• #define WIDTH 80＃定义宽度80
• #define HEIGHT 50＃定义高度50
• #define MAXLEN 4＃定义MAXLEN 4
• #define MAXFLEETS 100＃定义MAXFLEETS 100
• #define MAXSYSTEMS 10#define MAXSYSTEMS 10
• #define FIGHTMARKER 999#define FIGHTMARKER 999

结论 ( Conclusion )

In this tutorial, We've covered variables and the use of int, char and struct to group them plus array to create a list. Then simple looping using for and do. If you examine the source code, the same structures are seen time after time.

在本教程中，我们介绍了变量以及使用int，char和struct对其进行分组以及使用数组创建列表的方法。 然后使用for和do进行简单循环。 如果您检查源代码，就会一次又一次看到相同的结构。

• for (i=0;i 对于(i = 0; i
• for (i=0;i 对于(i = 0; i

Tutorial Twowill look at aspects of C mentioned in this tutorial.

教程二将研究本教程中提到的C方面。