游戏编程参数

㈠ linux下的C++游戏编程需要学什么知识

函数是各种编程语言的重要部分，C++编程也不例外。最简单的函数不带参数，返回void（表示不返回任何东西），其它函数可能带一个或几个参数并可能返回一个值。函数名规则与变量名相同。图1.5显示了函数的构成部分。新术语 参数(parameter)是传递给函数的值，用于改变操作或指示操作程度。

函数的构成部分使用函数前，要先进行声明。函数声明或原型(prototype)告诉编译器函数所取的参数个数、每个参数的数据类型和函数返回值的数据类型。清单1.4列示了这个概念。新术语 原型(prototype)是函数外观的声明或其定义的说明。

㈡ C#网络游戏编程

用winform做游戏的书开发应该比较少见吧。

如果你技术上没问题，那看书应该效果不大，因为书是给不会技术的人看的，至于技术学会了如何去实现理论，那永远得自己想。

我是这样想的，
网络上：
网络游戏一般都用UDP进行信息交流，这样可以实现一对多传输，且无需像TCP那样一一建立连接。用UdoClient或直接Socket类进行互交就可以了。
至于传输的内容，是各种游戏中的消息，最好在前几个字节设定消息类型。比如消息类型是出牌，后面的字节就是具体哪张牌。消息类型是指令，后面的字节就是对方是否赢了或者认输等。

游戏界面上：（我觉得这个是难点，网络还是比较容易的）
你需要有一个明了的规划。
数据上：比如每张牌用int还是枚举，每张牌对应的图像存成内置资源还是外部图像。
界面上：2D的话GDI或GDI+就够了，3D要另外调用DirectX API。
处理上：对接受的消息的应对，界面上有什么调整，数据上有什么调整。

㈢ 游戏编程

编程
这是每个游戏编程FAQ里都有的问题。这个问题每星期都会在游戏开发论坛上被问上好几次。这是个很好的问题，但是，没人能给出简单的答案。在某些应用程序中，总有一些计算机语言优于其他语言。下面是几种用于编写游戏的主要编程语言的介绍及其优缺点。希望这篇文章能帮助你做出决定。

1、C语言

如果说FORTRAN和COBOL是第一代高级编译语言，那么C语言就是它们的孙子辈。C语言是Dennis Ritchie在七十年代创建的，它功能更强大且与ALGOL保持更连续的继承性，而ALGOL则是COBOL和FORTRAN的结构化继承者。C语言被设计成一个比它的前辈更精巧、更简单的版本，它适于编写系统级的程序，比如操作系统。在此之前，操作系统是使用汇编语言编写的，而且不可移植。C语言是第一个使得系统级代码移植成为可能的编程语言。

C语言支持结构化编程，也就是说C的程序被编写成一些分离的函数呼叫（调用）的集合，这些呼叫是自上而下运行，而不像一个单独的集成块的代码使用GOTO语句控制流程。因此，C程序比起集成性的FORTRAN及COBOL的“空心粉式代码”代码要简单得多。事实上，C仍然具有GOTO语句，不过它的功能被限制了，仅当结构化方案非常复杂时才建议使用。

正由于它的系统编程根源，将C和汇编语言进行结合是相当容易的。函数调用接口非常简单，而且汇编语言指令还能内嵌到C代码中，所以，不需要连接独立的汇编模块。

优点：有益于编写小而快的程序。很容易与汇编语言结合。具有很高的标准化，因此其他平台上的各版本非常相似。

缺点：不容易支持面向对象技术。语法有时会非常难以理解，并造成滥用。

移植性：C语言的核心以及ANSI函数调用都具有移植性，但仅限于流程控制、内存管理和简单的文件处理。其他的东西都跟平台有关。比如说，为Windows和Mac开发可移植的程序，用户界面部分就需要用到与系统相关的函数调用。这一般意味着你必须写两次用户界面代码，不过还好有一些库可以减轻工作量。

用C语言编写的游戏：非常非常多。

资料：C语言的经典着作是《The C Programming Language》，它经过多次修改，已经扩展到最初的三倍大，但它仍然是介绍C的优秀书本。一本极好的教程是《The Waite Group's C Primer Plus》。

2、C++

C++语言是具有面向对象特性的C语言的继承者。面向对象编程，或称OOP是结构化编程的下一步。OO程序由对象组成，其中的对象是数据和函数离散集合。有许多可用的对象库存在，这使得编程简单得只需要将一些程序“建筑材料”堆在一起（至少理论上是这样）。比如说，有很多的GUI和数据库的库实现为对象的集合。

C++总是辩论的主题，尤其是在游戏开发论坛里。有几项C++的功能，比如虚拟函数，为函数呼叫的决策制定增加了一个额外层次，批评家很快指出C++程序将变得比相同功能的C程序来得大和慢。C++的拥护者则认为，用C写出与虚拟函数等价的代码同样会增加开支。这将是一个还在进行，而且不可能很快得出结论的争论。

我认为，C++的额外开支只是使用更好的语言的小付出。同样的争论发生在六十年代高级程序语言如COBOL和FORTRAN开始取代汇编成为语言所选的时候。批评家正确的指出使用高级语言编写的程序天生就比手写的汇编语言来得慢，而且必然如此。而高级语言支持者认为这么点小小的性能损失是值得的，因为COBOL和FORTRAN程序更容易编写和维护。

优点：组织大型程序时比C语言好得多。很好的支持面向对象机制。通用数据结构，如链表和可增长的阵列组成的库减轻了由于处理低层细节的负担。

缺点：非常大而复杂。与C语言一样存在语法滥用问题。比C慢。大多数编译器没有把整个语言正确的实现。

移植性：比C语言好多了，但依然不是很乐观。因为它具有与C语言相同的缺点，大多数可移植性用户界面库都使用C++对象实现。

使用C++编写的游戏：非常非常多。大多数的商业游戏是使用C或C++编写的。

资料：最新版的《The C++ Programming Language》非常好。作为教程，有两个阵营，一个假定你知道C，另外一个假定你不知道。到目前为止，最好的C++教程是《Who's Afraid of C++》，如果你已经熟知C，那么试一下《Teach Yourself C++》。

3、我该学习C++或是该从C开始

我不喜欢这种说法，但它是继“我该使用哪门语言”之后最经常被问及的问题。很不幸，不存在标准答案。你可以自学C并使用它来写程序，从而节省一大堆的时间，不过使用这种方法有两个弊端：

你将错过那些面向对象的知识，因为它可能在你的游戏中使得数据建模更有效率的东西。

最大的商业游戏，包括第一人称射击游戏很多并没有使用C++。但是，这些程序的作者即使使用老的C的格式，他们通常坚持使用面向对象编程技术。如果你只想学C，至少要自学OO（面向对象）编程技术。OO是仿真（游戏）的完美方法，如果你不学习OO，你将不得不“辛苦”的工作。

4、汇编语言

显然，汇编是第一个计算机语言。汇编语言实际上是你计算机处理器实际运行的指令的命令形式表示法。这意味着你将与处理器的底层打交道，比如寄存器和堆栈。如果你要找的是类英语且有相关的自我说明的语言，这不是你想要的。

确切的说，任何你能在其他语言里做到的事情，汇编都能做，只是不那么简单 — 这是当然，就像说你既可以开车到某个地方，也可以走路去，只是难易之分。话虽不错，但是新技术让东西变得更易于使用。

总的来说，汇编语言不会在游戏中单独应用。游戏使用汇编主要是使用它那些能提高性能的零零碎碎的部分。比如说，毁灭战士整体使用C来编写，有几段绘图程序使用汇编。这些程序每秒钟要调用数千次，因此，尽可能的简洁将有助于提高游戏的性能。而从C里调用汇编写的函数是相当简单的，因此同时使用两种语言不成问题。

特别注意：语言的名字叫“汇编”。把汇编语言翻译成真实的机器码的工具叫“汇编程序”。把这门语言叫做“汇编程序”这种用词不当相当普遍，因此，请从这门语言的正确称呼作为起点出发。

优点：最小、最快的语言。汇编高手能编写出比任何其他语言能实现的快得多的程序。你将是利用处理器最新功能的第一人，因为你能直接使用它们。

缺点：难学、语法晦涩、坚持效率，造成大量额外代码 — 不适于心脏虚弱者。

移植性：接近零。因为这门语言是为一种单独的处理器设计的，根本没移植性可言。如果使用了某个特殊处理器的扩展功能，你的代码甚至无法移植到其他同类型的处理器上（比如，AMD的3DNow指令是无法移植到其它奔腾系列的处理器上的）。

使用汇编编写的游戏：我不知道有什么商业游戏是完全用汇编开发的。不过有些游戏使用汇编完成多数对时间要求苛刻的部分。

资料：如果你正在找一门汇编语言的文档，你主要要找芯片的文档。网络上如Intel、AMD、Motorola等有一些关于它们的处理器的资料。对于书籍而言，《Assembly Language: Step-By-Step》是很值得学习的。

5、Pascal语言

Pascal语言是由Nicolas Wirth在七十年代早期设计的，因为他对于FORTRAN和COBOL没有强制训练学生的结构化编程感到很失望，“空心粉式代码”变成了规范，而当时的语言又不反对它。Pascal被设计来强行使用结构化编程。最初的Pascal被严格设计成教学之用，最终，大量的拥护者促使它闯入了商业编程中。当Borland发布IBM PC上的 Turbo Pascal时，Pascal辉煌一时。集成的编辑器，闪电般的编译器加上低廉的价格使之变得不可抵抗，Pascal编程了为MS-DOS编写小程序的首选语言。

然而时日不久，C编译器变得更快，并具有优秀的内置编辑器和调试器。Pascal在1990年Windows开始流行时走到了尽头，Borland放弃了Pascal而把目光转向了为Windows 编写程序的C++。Turbo Pascal很快被人遗忘。

最后，在1996年，Borland发布了它的“Visual Basic杀手”— Delphi。它是一种快速的带华丽用户界面的 Pascal编译器。由于不懈努力，它很快赢得了一大群爱好者。

基本上，Pascal比C简单。虽然语法类似，它缺乏很多C有的简洁操作符。这既是好事又是坏事。虽然很难写出难以理解的“聪明”代码，它同时也使得一些低级操作，如位操作变得困难起来。

优点：易学、平台相关的运行（Delphi）非常好。

缺点：“世界潮流”面向对象的Pascal继承者（Mola、Oberon）尚未成功。语言标准不被编译器开发者认同。专利权。

移植性：很差。语言的功能由于平台的转变而转变，没有移植性工具包来处理平台相关的功能。

使用Pascal编写的游戏：几个。DirectX的Delphi组件使得游戏场所变大了。

资料：查找跟Delphi有关的资料，请访问：Inprise Delphi page。

6、Visual Basic

哈，BASIC。回到八十年代的石器时代，它是程序初学者的第一个语言。最初的BASIC形式，虽然易于学习，却是可怕的无组织化，它义无反顾的使用了GOTO充斥的“空心粉式代码”。当回忆起BASIC的行号和GOSUB命令，没有几个人能止住眼角的泪水。

快速前进到九十年代早期，虽然不是苹果公司所希望的巨人，HyperCard仍然是一个在Windows下无法比拟的吸引人的小型编程环境。Windows下的HyperCard克隆品如ToolBook又慢又笨又昂贵。为了与HyperCard一决高下，微软取得了一个小巧的名为Thunder编程环境的许可权，并把它作为Visual Basci 1.0发布，其用户界面在当时非常具有新意。这门语言虽然还叫做Basic（不再是全部大写），但更加结构化了，行号也被去除。实际上，这门语言与那些内置于TRS-80、Apple II及Atari里的旧的ROM BASIC相比，更像是带Basic风格动词的Pascal。

经过六个版本，Visual Basic变得非常漂亮。用户界面发生了许多变化，但依然保留着“把代码关联到用户界面”的主旨。这使得它在与即时编译结合时变成了一个快速原型的优异环境。

优点：整洁的编辑环境。易学、即时编译导致简单、迅速的原型。大量可用的插件。虽然有第三方的DirectX插件，DirectX 7已准备提供Visual Basic的支持。

缺点：程序很大，而且运行时需要几个巨大的运行时动态连接库。虽然表单型和对话框型的程序很容易完成，要编写好的图形程序却比较难。调用Windows的API程序非常笨拙，因为VB的数据结构没能很好的映射到C中。有OO功能，但却不是完全的面向对象。专利权。

移植性：非常差。因为Visual Basic是微软的产品，你自然就被局限在他们实现它的平台上。也就是说，你能得到的选择是：Windows，Windows或Widnows。当然，有一些工具能将VB程序转变成Java。

使用Visual Basic编写的游戏：一些。有很多使用VB编写的共享游戏，还有一些是商业性的。

资料：微软的VB页面有一些信息。

7、Java

Java是由Sun最初设计用于嵌入程序的可移植性“小C++”。在网页上运行小程序的想法着实吸引了不少人的目光，于是，这门语言迅速崛起。事实证明，Java不仅仅适于在网页上内嵌动画 — 它是一门极好的完全的软件编程的小语言。“虚拟机”机制、垃圾回收以及没有指针等使它很容易实现不易崩溃且不会泄漏资源的可靠程序。

虽然不是C++的正式续篇，Java从C++ 中借用了大量的语法。它丢弃了很多C++的复杂功能，从而形成一门紧凑而易学的语言。不像C++，Java强制面向对象编程，要在Java里写非面向对象的程序就像要在Pascal里写“空心粉式代码”一样困难。

优点：二进制码可移植到其他平台。程序可以在网页中运行。内含的类库非常标准且极其健壮。自动分配合垃圾回收避免程序中资源泄漏。网上数量巨大的代码例程。

缺点：使用一个“虚拟机”来运行可移植的字节码而非本地机器码，程序将比真正编译器慢。有很多技术（例如“即时”编译器）很大的提高了Java的速度，不过速度永远比不过机器码方案。早期的功能，如AWT没经过慎重考虑，虽然被正式废除，但为了保持向后兼容不得不保留。越高级的技术，造成处理低级的机器功能越困难，Sun为这门语言增加新的“受祝福”功能的速度实在太慢。

移植性：最好的，但仍未达到它本应达到的水平。低级代码具有非常高的可移植性，但是，很多UI及新功能在某些平台上不稳定。

使用Java编写的游戏：网页上有大量小的Applet，但仅有一些是商业性的。有几个商业游戏使用Java作为内部脚本语言。

资料：Sun的官方Java页面有一些好的信息。IBM也有一个非常好的Java页面。JavaLobby是一个关于Java新闻的最好去处。

8、创作工具

上面所提及的编程语言涵盖了大多数的商业游戏。但是也有一个例外，这个大游戏由于它的缺席而变得突出。

“神秘岛”。没错，卖得最好的商业游戏不是使用以上任何一门语言编的，虽然有人说“神秘岛”99%是使用 3D建模工具制作的，其根本的编程逻辑是在HyperCard里完成的。

多数创作工具有点像Visual Basic，只是它们工作在更高的层次上。大多数工具使用一些拖拉式的流程图来模拟流程控制。很多内置解释的程序语言，但是这些语言都无法像上面所说的单独的语言那样健壮。

优点：快速原型 — 如果你的游戏符合工具制作的主旨，你或许能使你的游戏跑得比使用其他语言快。在很多情况下，你可以创造一个不需要任何代码的简单游戏。使用插件程序，如Shockware及IconAuthor播放器，你可以在网页上发布很多创作工具生成的程序。

缺点：专利权，至于将增加什么功能，你将受到工具制造者的支配。你必须考虑这些工具是否能满足你游戏的需要，因为有很多事情是那些创作工具无法完成的。某些工具会产生臃肿得可怕的程序。

移植性：因为创作工具是具有专利权的，你的移植性以他们提供的功能息息相关。有些系统，如Director可以在几种平台上创作和运行，有些工具则在某一平台上创作，在多种平台上运行，还有的是仅能在单一平台上创作和运行。

使用创作工具编写的游戏：“神秘岛”和其他一些同类型的探险游戏。所有的Shockwave游戏都在网络上。

资料：Director、HyperCard、SuperCard、IconAuthor、Authorware。

9、易语言

★全中文支持，无需跨越英语门槛。★全可视化编程，支持所见即所得程序界面设计和程序流程编码。★中文语句快速录入。提供多种内嵌专用输入法，彻底解决中文语句输入速度慢的问题。★代码即文档。自动规范强制代码格式转换，任何人编写的任何程序源代码格式均统一。★参数引导技术，方便程序语句参数录入。★无定义类关键字。所有程序定义部分均采用表格填表方式，用户无需记忆此类关键字及其使用格式。★命令格式统一。所有程序语句调用格式完全一致。★语法格式自动检查。自动检查并提示所输入语句的语法格式是否正确，且可自动添加各类名称。★全程提示与帮助。鼠标停留立即显示相关项目提示。编程时提示语法格式，调试时提示变量当前内容，随时按下F1键可得到与当前主题相关详细帮助等。★名称自动管理。用户修改任一名称定义，其它所有包含该名称的程序代码均自动修正。★集成化开发环境。集界面设计、代码编写、调试分析、编译打包等于一体。★学习资源丰富。详细的帮助文件、数十兆的知识库、数万用户的网上论坛、教材已出版发行……

10、结论

你可能希望得到一个关于“我该使用哪种语言”这个问题的更标准的结论。非常不幸，没有一个对所有应用程序都最佳的解决方案。C适于快而小的程序，但不支持面向对象的编程。C++完全支持面向对象，但是非常复杂。Visual Basic与Delphi易学，但不可移植且有专利权。Java有很多简洁的功能，但是慢。创作工具可以以最快的速度产生你的程序，但是仅对某一些类型的程序起作用。最好的方法是决定你要写什么样的游戏，并选择对你的游戏支持最好的语言。“试用三十天”的做法成为工业标准是件好事情。

㈣ 游戏编程应如何入门

这是windows的经典开发模式，推荐参看《windows程序设计》，北京大学出版社的，最最最最经典的windows编程模式。

㈤ 一般游戏编程用什么语言和软件

下面是游戏开发十大编程语言的列表。

1、C类＃

C语言现在被广泛应用于许多游戏引擎中，是最流行的游戏开发语言之一。它有一个XNA框架、一套微软工具和运行时环境，使它特别适合Xbox或windows上的游戏。如果你想使用monogame在几乎任何平台上发布游戏，这是一种很好的语言。

2、C类＋＋

C＋＋是一种面向对象的语言，被认为是最难学习的语言之一，但它是游戏开发人员的重要语言。它允许对硬件和图形进程进行更直接的控制，这对行业很重要，是一些流行游戏引擎的流行语言。它还提供了对参数和内存管理的大量控制，从而提高了游戏的性能和用户体验。

3、Java

Java使用与C＋＋相同的面向对象原则，但提供了更广泛的系统。Java代码通常在Java虚拟机（JVM）上运行，并转换为可在任何系统上执行的通用字节码。因此，Java是为数不多的能够让开发人员为任何给定系统开发游戏的游戏编程语言之一。它是最好的游戏编程语言之一。

4、JavaScript

JavaScript是最流行的游戏编程语言之一，尤其是作为一种在线交互语言。使用JavaScript，可以更容易地将代码与传统的网络技术（如HTML和CSS）集成，从而导致越来越多的跨平台移动游戏。

5、HTML5

HTML5已经成为互联网上最常见的游戏编程语言之一。你今天玩的大多数手机游戏都使用这种标记语言。使用JavaScript很容易创建复杂的基于web的游戏。该语言简单易学，不一定需要学习复杂的算法编程知识，因此成为游戏开发者的热门选择。

6、SQL语言

SQL被玩家用来访问后端帐户并在服务器上执行其他操作。有新的语言，库，框架，特别是AR，VR，图形，物理和游戏。

7、Python

Python是另一种提供OOP方法的语言，是游戏开发人员使用的最易于使用的通用编程语言之一。它有一个pyGame框架，允许程序员快速开发游戏原型。

8、Rust

铁锈被吹捧为C的继承者之一。它主要被Mozilla基金会用作系统编程语言。它具有面向对象到面向数据的方法，有助于游戏开发。

9、UnrealScript

Unrealscript是unreal引擎的本机脚本语言。它结合了面向对象、多重继承和功能丰富的游戏等复杂功能。该语言支持所有主要的游戏平台，如微软Windows、MacOS、Linux、steamos、Android和PlaystationVR。

10、Lua

由于语言结构和语法简单，Lua正成为游戏界最流行的语言之一。它是一种多平台脚本语言，许多现代游戏引擎都使用Lua作为主要的游戏设计编程语言。

㈥ 有哪位做游戏编程的请帮忙解释一下这段代码

mode=life 模式=按照具体参数来设定特效持续时间 这里也可以写loop（循环）waitalldead（等待所有特效消失后特效才能消失）一般用于第一行的mode
model=.../data.........tx_074——s03_2_01.x 特效路径 可以更改路径来做到更改出现的特效
life=2000 这一段 如果上面的是mode=life 下面的life才会起效 “=”后面的数字2000单位是毫秒 1秒=2000 life=2000代表特效持续2秒后消失 [如果上面的mode=loop 这里吧life=2000改成“loop=(你想要这个特效循环的次数)”即可 如果上面mode=waitalldead 下面的life=2000就可以直接删掉了]
num=1 前面的num是特效数量 后面的1 是数量的参数 想在后面增加特效 就在这个num=的原本数量后面+上想加的特效数量 比如要写1个特效进去 原本里面就有一个 那么这里就要填2
delay=0 这个是特效消失时间 一般在这里不需要改 下面的都不要动

往下找到[Instance] 这个代表特效的编号 后面什么都不加 代表第一个特效 后面有个1 代表第二个特效 以此类推
Sound=..\Data\Audio\Skill\yueyetu\paopaotang_start.ogg 这个代表特效附带的音效文件目录 删掉这行特效音效就会消失 改变音效目录特效音效也会跟着改变 没什么好说的
Mode=life 最先需要明白的一点是：这里的mode 优先级低于最上面的mode 如果上面写的mode等于life 且life=xxx 上面的mode=life里已经设定好了特效时间 那么下面不管写什么都没意义 如果上面写的是mofe=waitalldead 下面的mode=life或loop才会成功 写这个mode的方法跟上面说的一样
Loop=life 这个基本上不需要改 除非上面的mode=loop 下面的loop才需要改成1 2 3 4这样的明确数值
Scale=1.1f代表特效大小 后面的参数可以随意调整
DeadRenderTime=300 代表特效消失的时候 消失渐变所需要的时间
Bind =Lefthand //左手
=Righthand //右手
=body //身体
=foot //鼠标点击的地面
Action=Spray //特效在原地
=Follow //特效在身上
ActionTime=0 这个代表特效的出现时间 单位也是毫秒 1s=1000
TrackType=Line 比如你放出一个模型来特效不会跟着你转身而转身 那么用了这个代码之后 特效会跟着你的角度一起转
ParaHeight=0.0f 这个代表特效的转动角度 后面的参数同样可以用来设置需要转动角度的数值

㈦ 如何正确的使用UNITY3D制作FPS游戏

第一部分：简介
这个教程中，我们详细了解下如何制作一个简单的第一人称射击游戏（FPS）。其中将介绍一些基本的3D游戏编程的概念和一些关于怎样如游戏程序员般思考的技巧。

前提

这个教程假定你已经熟悉软件Unity基本操作，掌握了基本的脚本概念。

创建新工程
下载FPS_Tutorial.zip压缩文件，解压，在Unity中打开工程文件。
从Unity安装目录导入Standard Assets资源包。
导入工程后，你会在Unity工程面板中的“Standard Assets”文件夹下看见这些资源内容。当我们导入新资源时，最好安装按照资源功能对其分组，例如：火箭、爆炸、音频等。

设置游戏环境
导入资源后，你会注意到在工程面板中有许多文件夹。
工程面板中，从文件夹“Object/mainLevelMesh”中选择“mainLevelMesh”。
在参数面板，FBXImporter选项中，你会发现“Generate Colliders”选项，勾选此选项。如果不做这一步，游戏中玩家会穿越地面直接掉下深渊（实际是开启“碰撞”，产生交互）
把“mainLevelMesh”拖放到场景中。
场景中不需要添加灯光，这关全部场景已经全部应用了灯光贴图。整个场景对所有灯光进行了灯光贴图渲染，使用了“预烘焙阴影”。灯光贴图对显示效果有很大帮助，特别是复杂灯光环境。
下面可以在场景中添加一个角色了。

添加主要角色
下面在场景中增加一个可以操控的角色物体。Unity针对第一人称射击游戏预置了许多内置的控制器，在工程面板Standard Assets->;Prefabs下。
添加第一人称控制器，点击工程面板Standard Assets旁边的小三角，弹出资源列表。找到Prefabs文件夹，点击小三角形，弹出资源列表。把“First person controller”拖到场景里。

这时场景中会出现一个代表玩家的圆柱体，三个大箭头代表物体在3D空间中的位置（如果没有看见箭头，选择物体，按“W”键），白色面代表物体当前视角。现在FPS控制器处于默认视角位置，通过移动它可以改变游戏视野。把角色移动到游戏环境关卡地面上面的位置。

Main Camera现在已经没有用处了，可以删掉了。
点击“Play”键，现在应该可以通过使用鼠标和键盘在本关卡地形中四处移动了（光标或者“W,A,S,D”）
现在我们创建了一个非常简单的FSP，下面我们给角色添加武器。

增加武器
下面我们将给游戏角色一个类似榴弹的物体，可以在游戏中发射。要实现这个功能，需要创建一些脚本语言来在Unity中告知这个武器如何动作。

那么我们具体要实现什么呢？我们要使游戏角色能在摄像机的任意位置开火。但是，我们还是首先来思考一下游戏角色和武器。游戏角色游戏中是第一人称的视角，所以摄像机的位置与眼睛平行。如果玩家使用武器射击，武器应该是在角色的手部位置开火而不是眼睛的位置。这样我们就要增加一个“game object”（游戏物体）来代表榴弹发射器，同时把它放置在游戏角色手持武器时武器所处的位置。这样就保证了开火的位置没有问题。

创建武器发射器
首先，创建一个“game object”代表榴弹发射器。游戏物体是3D世界中的任一物体（角色、关卡、声音），零件就是游戏物体的属性。因此我们还需要对游戏物体添加零件：
从主菜单栏选择GameObject>Great Empty，并在层级面板中（Hierarchy）命名为“Launcher”。注意，空物体在场景中是看不见的，只是用它来作放置飞弹发射器。

现在在场景中把视野推近到FPS控制器，便于我们放置武器发射器。
层级面板中选择FPS控制器，确保鼠标处于场景视图中，按“F”键。使窗口以当前选择的物体为中心。
层级面板中选择发射器，主菜单栏选择Game Object>Move to view。注意发射器如何移动到FPS控制器附近的。然后使用手柄，把发射器移动到大概角色手部的位置。

注意：可以通过设置这个物体的位置来设定游戏角色是左撇子还是右撇子，不需要写代码。
使Unity窗口模式是“2by3”模式（window>Layouts>2by3），点击播放键（play）。确保层级面板中点选了发射器，四处移动角色，同时观察场景窗口。你将发现发射器并没有随着角色一起运动（现在再次点击播放键停止运行游戏）
下面来解决这个问题，层级面板中，把发射器拖放到FPS控制器下面的主摄像机上。弹出的对话框点击“是”。再次运行游戏，观察场景窗口，发射器已经和角色运动一致了。这样我们就把发射器与摄像机关联起来了。

创建飞弹
下面我们来创建在玩家点击开火键时能够发射出来的飞弹。
我们先用一个简单物体-球体-代替飞弹。Unity主菜单栏点击Assets>Creat>;Prefab创建一个预制（Prefab）物体，命名为“Missile”
创建一个球体（GameObject>Create Object>Sphere）
层级面板中，拖放球体到飞弹预制物体上（Missile），这时预制物体图标会变化。你可以从层级面板中删除球体。

技巧：游戏运行中产生的任何游戏物体都应该是预制物体（Prefab）。
编写飞弹发射器脚本
FPS控制器是一个包含了几个游戏物体和部件的预制物体。FPS控制器本身是一个只能沿Y轴旋转的圆柱体，因此，如果我们直接把发射器脚本赋予FPS控制器的话，是实现不了上下开火的。所以我们把脚本赋予控制器中的能够四周转动的主摄像机。

下面我们来编写第一个描述发射器行为的JavaScript代码。
点击Assets>Greate>JavaScript，创建一个空的JavaScript文档。一个名为“NewBehaviourScript”资源将会出现在工程面板中，把它更名为“MissileLauncher”

技巧：通过Unity>;Preferences点击External Script Editor，可以自定义外部脚本编辑器。
工程面板中创建一个“WeaponScripts”文件夹，放置我们所有的武器脚本。把MissileLauncher脚本和飞弹预制物体（Missile Prefab）拖到这个文件中。

我们来看看飞弹发射器的完整JavaScript脚本。
进一步思考一下，我们到底想实现什么效果？我们要检测玩家是否按了开火键，然后产生一枚飞弹，然后把它沿着玩家朝向的方向按照一定的速度发射出去。我们仔细的解剖一下脚本：
var projectile: Rigibody;
var speed=20;
function Update( )
{
这是脚本的开头部分，定义了一些属性，开启了“Update”的功能
if(Input.GetButtonDown(“Fire1”))

首先我们要检测玩家是否按了开火键，“开火1”映射的是鼠标左键和当前配置的键盘上的按键（可以通过主菜单栏的Editor>;Project Settings>Input设定）
{
var instantiatedProjectile: Rigidbody=Instantiate(
projectile, transform.position,transform.rotation);

我们用变量来定义产生的物体。变量的类型是Rigibody（刚体），因为飞弹是具有物理属性的。
Unity中产生新物体使用的函数是Instantiate，它有三个参数，分别是：产生的物体、产生物体的3D空间位置、物体的旋转。它还有另一个语法结构，参照API手册，这里我们只使用这种结构。

第一个参数，projectile，代表我们想创建的物体。那么到底发射什么物体？具体产生的物体是可以手动设定的。实现方法：把Projectile定义为函数的外部变量，这样就可以在参数面板中显示出来。发射的物体也可以通过代码来创建，但如果你想使一个变量可调的话，还是用上面的方法。

第二个参数，transform.position，使产生的物体与发射器的空间位置一致。为什么就是发射器呢？因为如果要使飞弹产生的位置没有问题，脚本就要关联给发射器。（transform读取的transform数据就是被赋予脚本的游戏物体transform数据）

第三个参数transform.rotation，与第二个类似，只是它的值与发射器的旋转值是一样的。

代码的下一部分使飞弹产生运动。为了实现运动，我们要赋予飞弹一个速度，但是在哪个方向上（X，Y，Z）产生速度呢？在场景中，点击FPS控制器，出现运动箭头（如果没有出现，按“W”键），其中一个箭头是红色、一个是绿色、一个是蓝色。红色代表X轴，绿色代表Y轴，蓝色代表Z轴。因为蓝色指向的方向，与玩家面朝的方向一致，所以我们要在Z轴上给飞弹一个速度。

（Velocity）速度是instantiatedProjectile的一个属性。我们怎么知道的呢？因为instantiatedProjectile是刚体的一种，如果我们看看API手册，我们就会知道速度是刚体的属性中的一种。同时也看看刚体的其它属性。要设置速度，我们就必须在各个轴向上设定数值。但还有个小问题。3D空间中的物体一般使用两种坐标模型：本地坐标系和世界坐标系。在本地坐标系中，物体的轴向只与物体本身有关。在世界坐标系中，轴向是绝对的，例如：向上，对所有物体来讲向上的方向都是一样的。

Rigidbody.Vellocity刚体物体速度必须使用世界坐标系。因此，定义速度时，需要把本地坐标系中的Z轴（朝前的方向）向转换成世界坐标系中的相应方向。可以用函数transform.TransformDirection，它有三个向量作为自变量。变量speed也应该定义成外部变量，便于后面在编辑器中直接调节数值。

最后，我们要关闭飞弹与游戏角色之间的碰撞。如果不这样做的话，飞弹产生的时候就可能与角色发生碰撞。可以在API手册IgnoreCollision下查询详细信息。

MissileLauncher.js全部完整代码如下：

把脚本MissileLauncher赋予FPS控制器中的发射器。在层级面板中点击发射器，检查一下参数面板下面是否显示了MissileLauncher script。
先前创建的飞弹的预制物体还没有与脚本中的变量projectile创建关联，我们需要在编辑器中创建一下。变量projectile只能与刚体关联，因此，首先我们要赋予飞弹一个Rigidbody。

工程面板中点击飞弹，然后从主菜单栏选择Components>;Physics>Rigidbody。这样将会给我们想开火发射的飞弹一个刚体属性。我们必须确保想在游戏中发射的物体类型与脚本中外部变量要求的物体类型是同一类型的物体。

创建飞弹与脚本中变量projectile的链接。首先在层级面板中点击发射器，然后把飞弹的预制物体从工程面板中拖拽放置在发射器参数面板中MissileLauncher script部分上。

运行游戏的话，你会发现点击开火键可以发出一个受重力影响的小球了。
飞弹爆炸
下面，当飞弹与其他物体发生碰撞时，增加一个爆炸效果。要实现这个效果，我们要编写一段新脚本赋予飞弹。
创建一个新脚本，命名为Projectile。拖放到工程面板的WeaponScripts文件夹下。

那么我们想要脚本Projectile实现什么样的效果呢？我们要检测飞弹是否发生碰撞，然后在碰撞点产生一个爆炸效果。代码如下：

函数OnCollisionEnter内的程序代码的作用是计算被赋予脚本的物体是否与其他物体发生碰撞。

在函数OnCollisionEnter中我们主要是要实现在3D空间中飞弹发生碰撞的点产生一个新爆炸。那么在何处了碰撞的呢？函数OnCollisionEnter就有个记录这个信息的功能。碰撞发生的点的信息储存在变量ContactPoint中。

这里我们使用函数Instantiate来创建一个爆炸。我们已经知道函数instatiate有三个参数：（1）产生的物体（2）物体的3D空间位置

（3）物体的旋转。
第一个参数，后面我们将会赋给一个带粒子系统的游戏物体。同时我们还想通过编辑器来实现这个功能，所以我们把变量设置为外部变量。
第二个参数，爆炸产生的点的位置，就是碰撞发生的位置。
第三个参数，爆炸旋转的设置，需要解释一下。我们需要爆炸体的Y轴方向与飞弹和其他物体发生碰撞的那个表面的法线方向一致。这就是说如果是墙面那么爆炸就面向外，如果是地板就朝上。那么实际上我们就是要使爆炸体在本地坐标系的Y轴与飞弹与之碰撞的物体的表面法线方向（世界坐标系）一致。

最后，我们要让飞弹碰撞后就从游戏中消失，通过函数Destroy（）实现，它的参数是gameObject（gameObject代表被赋予这个脚本的物体）。
Projectile.js全部代码如下：

把脚本赋予飞弹预制物体（Missile prefab）。
下面我们要创建飞弹发生碰撞时所产生爆炸的爆炸效果物体。
首先，创建一个新的预制物体（命名为Explosion）用来存放爆炸效果资源。
标准资源包中（standard asset）有个不错的爆炸预制物体，粒子系统和灯光都设置好了。把这个爆炸预制物体（在Standard Assets/Particles/explosion中）拖放到层级面板。

调节这个爆炸效果的各个参数直到你觉得满意，然后把它从层级面板中拖放到工程面板中的爆炸预制物体（Explosion Prefab）中。
现在把爆炸配置给飞弹：
点选飞弹预制物体（Missile Prefab），在参数面板Explosion变量栏，拖放工程面板中的爆炸到上面。

定义爆炸的行为
下面我们要再创建一个脚本来定义爆炸自身的特性。
创建一个新的脚本-Explosion，放在Weapons文件夹中，双击脚本进行编辑。

脚本中另一个常用函数称为Start（）。当它配置给的物体是在游戏中产生的时候，函数Start（）中的代码只被执行一次。我们要实现的效果就是在一定时间后，在游戏中删除爆炸。我们通过函数Destroy（）的第二个参数实现，它的作用是定义执行删除前的时间长度。

变量explosionTime设置成外部变量，方便调节。
新建脚本插入以上代码时，要删除函数Update（）。
把脚本Explosion赋予给爆炸预制物体。

音效
目前的游戏世界太安静了，让我们给爆炸效果增加点音效。
首先，给爆炸预制（Prefab）添加一段音频。
给爆炸添加音效前，我们首先要添加一个音源部件（Audio Source），在主菜单点击Component—Audio—Audio Source。你会发现音源部件有一个Audio Clip的属性。
把“RocketLauncherImpact”音效添加给爆炸预制体的AudioClip外部变量。Unity支持多种音频格式。
运行游戏，发射飞弹的时候就有声音了！

添加图形界面
下面我们来添加GUI，有点像头部显示设备（HUD）。我们要做的GUI非常简单，就一个准星。
添加一个准星：
工程栏中创建一个GUI的文件夹。
创建一个新脚本，命名为“准星”（Crosshair），拖到GUI文件夹。
Crosshair中写入下面的脚本：

首先我们设定了两个变量。第一个变量是定义我们将要用可选的方式来选择图形纹理。第二个变量定义了一个方形区间，它是图形纹理在屏幕上的位置范围。
在start( ) 中函数用来设定图形纹理在屏幕上的位置。函数中，有四个参数，用来定义方形区域的大小和位置。第一个参数定义了方形区域的左边框，第二个是底边框，第三和第四个参数定义了宽和高。

OnGUI( )函数中，使用GUI类程序来让图形显示在屏幕上。DrawTexture( )函数的参数position和crosshairTexture将使准星显示在屏幕的中央位置。
保存脚本。
创建一个新的空物体，命名为“GUI”。
把脚本“Crosshair”赋予给GUI物体。
点选GUI物体，把在文件夹Texturelaim下的欲使用的图形拖放到参数面板变量Crosshair Texture中。
运行游戏，屏幕中就会有准星显示了。

物理特效：
现在，我们想要游戏中的物体效果越真实越好，这是通过添加物理特效实现的。在这一节中，我们将在环境中添加一些物体，他们能被飞弹击中后有相应的反应。首先有几个新概念要解释下。

校正（Update）
先前，我们在函数Update（）中写入代码，这样可以在每一帧都执行其中的代码。其中有个例子是检测玩家点击开火键。帧速并不是一个固定值，它是根据场景复杂度等因素来定的。各帧之间的时间差会导致不稳定的物体反应。因此，如果想在场景中添加有物理反应的物体（刚体等），代码就应该写在函数FixedUpdate（）中。Unity中deltaTime的值用来测定渲染两个连续帧的所用时间。

一般而言，函数Update与FixedUpdate之间的区别如下：
Update（）-其中的代码通常用于角色行为、游戏逻辑等。这个函数中的deltaTime值并不是固定的。
FixedUpdate（）-其中的代码通常用于刚体物体（物理属性的行为）。函数中deltaTime的值通常是固定的。
FixedUpdate函数被调用的频率是主菜单中Edit-Project Settings-Time的FixedTimestep属性确定的，当然也是可以更改的。第二个属性Time Scale是读取每秒的帧速和相应的倒数值。

技巧：定义FixedTimestep值时，要注意把握好一个平衡：值越小，物理效果越真实越好，但影响游戏运行速度。应该同时确保游戏运行速度和物理效果的真实性。
最后说一下yield，它相当于暂停当前正在执行的函数。
回到游戏，我们想实现的效果：
使玩家可以发射飞弹（已经实现了）。

如果飞弹与其它刚体物体发生碰撞，检测其范围类是否有其它被赋予刚体属性的物体。
对爆炸冲击力范围内的每个刚体物体，均给予一个upwards方向上的力，使它们对飞弹产生反应。
让我们看看修改后的爆炸脚本（Explosion Javascript）

首先检测下飞弹落点周围是否有带碰撞器的物体。函数Physics.OverlapSphere（）有两个参数：3D位置和半径值，然后返回一组检测到的在半径内的碰撞器的数组。

一旦得到这些数组后，就会对每个对应碰撞器的刚体物体一个在特定方向上的力。

然后我们在飞弹的炸点处，向上的方向增加一个力（ExplosionPower）。但是，爆炸效果是随着距离而递减的，作用力大小不能在整个半径内都一样。圆周位置的刚体物体受到的作用力应该比炸点中心处小。函数把这种效果也考虑在内的。通过调节外部变量explosionPower和explosionRadius的值，可以较容易的得到想要的效果。

㈧ 编写游戏程序

做网络游戏 视频教材基本上都是国外的,你能不能看懂英语很重要
我给你的建议:
先学编程(VC或者C) 然后学习图形图象 其中有opengl 和dx 看你的方向如何.其中会有很多算法需要学习,所以数学很重要,这个时候你能做成一些场景了 然后学习脚本编程... 当然网络编程要会哦
很漫长的过程,数学,物理,艺术,都会涉及到哦..

OPENGL宝典 vc++ 游戏编程 XX游戏脚本编程 关卡设计............
------------------------
我以前的回答。单机游戏和网络游戏的基础都是编程
先学语言。只是你初中生数学不够。。。

㈨ 一种C语言小游戏程序设计(程序已经附上)

"扫雷"小游戏C代码

#include<stdio.h>
#include<math.h>
#include<time.h>
#include<stdlib.h>
main( )
{char a[102][102],b[102][102],c[102][102],w;
int i,j; /*循环变量*/
int x,y,z[999]; /*雷的位置*/
int t,s; /*标记*/
int m,n,lei; /*计数*/
int u,v; /*输入*/
int hang,lie,ge,mo; /*自定义变量*/
srand((int)time(NULL)); /*启动随机数发生器*/
leb1: /*选择模式*/
printf(" 请选择模式： 1.标准 2.自定义 ");
scanf("%d",&mo);
if(mo==2) /*若选择自定义模式，要输入三个参数*/
{do
{t=0; printf("请输入 行数 列数 雷的个数 ");
scanf("%d%d%d",&hang,&lie,&ge);
if(hang<2){printf("行数太少 "); t=1;}
if(hang>100){printf("行数太多 ");t=1;}
if(lie<2){printf("列数太少 ");t=1;}
if(lie>100){printf("列数太多 ");t=1;}
if(ge<1){printf("至少要有一个雷 ");t=1;}
if(ge>=(hang*lie)){printf("雷太多了 ");t=1;}
}while(t==1);
}
else{hang=10,lie=10,ge=10;} /*否则就是选择了标准模式(默认参数)*/
for(i=1;i<=ge;i=i+1) /*确定雷的位置*/
{do
{t=0; z[i]=rand( )%(hang*lie);
for(j=1;j<i;j=j+1){if(z[i]==z[j]) t=1;}
}while(t==1);
}
for(i=0;i<=hang+1;i=i+1) /*初始化a,b,c*/
{for(j=0;j<=lie+1;j=j+1) {a[i][j]='1'; b[i][j]='1'; c[i][j]='0';} }
for(i=1;i<=hang;i=i+1)
{for(j=1;j<=lie;j=j+1) {a[i][j]='+';} }
for(i=1;i<=ge;i=i+1) /*把雷放入c*/
{x=z[i]/lie+1; y=z[i]%lie+1; c[x][y]='#';}
for(i=1;i<=hang;i=i+1) /*计算b中数字*/
{for(j=1;j<=lie;j=j+1)
{m=48;
if(c[i-1][j-1]=='#')m=m+1; if(c[i][j-1]=='#')m=m+1;
if(c[i-1][j]=='#')m=m+1; if(c[i+1][j+1]=='#')m=m+1;
if(c[i][j+1]=='#')m=m+1; if(c[i+1][j]=='#')m=m+1;
if(c[i+1][j-1]=='#')m=m+1; if(c[i-1][j+1]=='#')m=m+1;
b[i][j]=m;
}
}
for(i=1;i<=ge;i=i+1) /*把雷放入b中*/
{x=z[i]/lie+1; y=z[i]%lie+1; b[x][y]='#';}

lei=ge; /*以下是游戏设计*/
do
{leb2: /*输出*/
system("cls");printf(" ");

printf(" ");
for(i=1;i<=lie;i=i+1)
{w=(i-1)/10+48; printf("%c",w);
w=(i-1)%10+48; printf("%c ",w);
}
printf(" |");
for(i=1;i<=lie;i=i+1){printf("---|");}
printf(" ");
for(i=1;i<=hang;i=i+1)
{w=(i-1)/10+48; printf("%c",w);
w=(i-1)%10+48; printf("%c |",w);
for(j=1;j<=lie;j=j+1)
{if(a[i][j]=='0')printf(" |");
else printf(" %c |",a[i][j]);
}
if(i==2)printf(" 剩余雷个数");
if(i==3)printf(" %d",lei);
printf(" |");
for(j=1;j<=lie;j=j+1){printf("---|");}
printf(" ");
}

scanf("%d%c%d",&u,&w,&v); /*输入*/
u=u+1,v=v+1;
if(w!='#'&&a[u][v]=='@')
goto leb2;
if(w=='#')
{if(a[u][v]=='+'){a[u][v]='@'; lei=lei-1;}
else if(a[u][v]=='@'){a[u][v]='?'; lei=lei+1;}
else if(a[u][v]=='?'){a[u][v]='+';}
goto leb2;
}
a[u][v]=b[u][v];

leb3: /*打开0区*/
t=0;
if(a[u][v]=='0')
{for(i=1;i<=hang;i=i+1)
{for(j=1;j<=lie;j=j+1)
{s=0;
if(a[i-1][j-1]=='0')s=1; if(a[i-1][j+1]=='0')s=1;
if(a[i-1][j]=='0')s=1; if(a[i+1][j-1]=='0')s=1;
if(a[i+1][j+1]=='0')s=1; if(a[i+1][j]=='0')s=1;
if(a[i][j-1]=='0')s=1; if(a[i][j+1]=='0')s=1;
if(s==1)a[i][j]=b[i][j];
}
}
for(i=1;i<=hang;i=i+1)
{for(j=lie;j>=1;j=j-1)
{s=0;
if(a[i-1][j-1]=='0')s=1; if(a[i-1][j+1]=='0')s=1;
if(a[i-1][j]=='0')s=1; if(a[i+1][j-1]=='0')s=1;
if(a[i+1][j+1]=='0')s=1; if(a[i+1][j]=='0')s=1;
if(a[i][j-1]=='0')s=1; if(a[i][j+1]=='0')s=1;
if(s==1)a[i][j]=b[i][j];
}
}
for(i=hang;i>=1;i=i-1)
{for(j=1;j<=lie;j=j+1)
{s=0;
if(a[i-1][j-1]=='0')s=1; if(a[i-1][j+1]=='0')s=1;
if(a[i-1][j]=='0')s=1; if(a[i+1][j-1]=='0')s=1;
if(a[i+1][j+1]=='0')s=1; if(a[i+1][j]=='0')s=1;
if(a[i][j-1]=='0')s=1; if(a[i][j+1]=='0')s=1;
if(s==1)a[i][j]=b[i][j];
}
}
for(i=hang;i>=1;i=i-1)
{for(j=lie;j>=1;j=j-1)
{s=0;
if(a[i-1][j-1]=='0')s=1; if(a[i-1][j+1]=='0')s=1;
if(a[i-1][j]=='0')s=1; if(a[i+1][j-1]=='0')s=1;
if(a[i+1][j+1]=='0')s=1;if(a[i+1][j]=='0')s=1;
if(a[i][j-1]=='0')s=1; if(a[i][j+1]=='0')s=1;
if(s==1)a[i][j]=b[i][j];
}
}

for(i=1;i<=hang;i=i+1) /*检测0区*/
{for(j=1;j<=lie;j=j+1)
{if(a[i][j]=='0')
{if(a[i-1][j-1]=='+'||a[i-1][j-1]=='@'||a[i-1][j-1]=='?')t=1;
if(a[i-1][j+1]=='+'||a[i-1][j+1]=='@'||a[i-1][j+1]=='?')t=1;
if(a[i+1][j-1]=='+'||a[i+1][j-1]=='@'||a[i+1][j-1]=='?')t=1;
if(a[i+1][j+1]=='+'||a[i+1][j+1]=='@'||a[i+1][j+1]=='?')t=1;
if(a[i+1][j]=='+'||a[i+1][j]=='@'||a[i+1][j]=='?')t=1;
if(a[i][j+1]=='+'||a[i][j+1]=='@'||a[i][j+1]=='?')t=1;
if(a[i][j-1]=='+'||a[i][j-1]=='@'||a[i][j-1]=='?')t=1;
if(a[i-1][j]=='+'||a[i-1][j]=='@'||a[i-1][j]=='?')t=1;
}
}
}
if(t==1)goto leb3;
}

n=0; /*检查结束*/
for(i=1;i<=hang;i=i+1)
{for(j=1;j<=lie;j=j+1)
{if(a[i][j]!='+'&&a[i][j]!='@'&&a[i][j]!='?')n=n+1;}
}
}
while(a[u][v]!='#'&&n!=(hang*lie-ge));

for(i=1;i<=ge;i=i+1) /*游戏结束*/
{x=z[i]/lie+1; y=z[i]%lie+1; a[x][y]='#'; }
printf(" ");
for(i=1;i<=lie;i=i+1)
{w=(i-1)/10+48; printf("%c",w);
w=(i-1)%10+48; printf("%c ",w);
}
printf(" |");
for(i=1;i<=lie;i=i+1){printf("---|");}
printf(" ");
for(i=1;i<=hang;i=i+1)
{w=(i-1)/10+48; printf("%c",w);
w=(i-1)%10+48; printf("%c |",w);
for(j=1;j<=lie;j=j+1)
{if(a[i][j]=='0')printf(" |");
else printf(" %c |",a[i][j]);
}
if(i==2)printf(" 剩余雷个数");
if(i==3)printf(" %d",lei); printf(" |");
for(j=1;j<=lie;j=j+1) {printf("---|");}
printf(" ");
}
if(n==(hang*lie-ge)) printf("你成功了! ");
else printf(" 游戏结束! ");
printf(" 重玩请输入1 ");
t=0;
scanf("%d",&t);
if(t==1)goto leb1;
}

/*注：在DEV c++上运行通过。行号和列号都从0开始，比如要确定第0行第9列不是“雷”，就在0和9中间加入一个字母，可以输入【0a9】三个字符再按回车键。3行7列不是雷，则输入【3a7】回车；第8行第5列是雷，就输入【8#5】回车，9行0列是雷则输入【9#0】并回车*/

㈩ C++游戏编程的目录

第1章 概观程序设计 1
1.1 程序设计发展历程 1
1.1.1 什么是计算机程序 1
1.1.2 计算机程序语言的发展历史 2
1.2 程序设计思想 4
1.2.1 结构化程序设计思想 4
1.2.2 面向对象程序设计思想 5
本章小结 8
第2章 开发环境简介 9
2.1 Visual Studio .NET集成开发环境 9
2.1.1 创建项目 10
2.1.2 创建文件 12
2.1.3 项目属性设置 12
2.1.4 编译和运行 13
2.1.5 调试 14
2.1.6 辅助工具 14
2.1.7 解决方案资源管理器 18
2.1.8 类视图 19
2.1.9 文件视图 20
2.1.10 资源视图 20
2.1.11 帮助文档的使用 28
2.2 Linux下的开发环境 28
2.2.1 Vi编辑器的基本使用 29
2.2.2 Vi编辑器的命令 29
2.2.3 Vi编辑器环境设置 32
2.2.4 g++编译程序的方法 33
2.2.5 g++编译程序的选项 33
2.2.6 运行应用程序 38
2.2.7 帮助文档的使用 38
2.3 CodeBlocks集成开发工具介绍 38
2.3.1 创建工程 39
2.3.2 创建文件 39
2.3.3 项目属性设置 39
2.3.4 编译及运行 40
2.4 绘图函数库的使用 41
本章小结 41
第3章 基本数据类型 42
3.1 基本程序组成结构 42
3.1.1 一个基本的C++程序 42
3.1.2 基本输入输出 43
3.2 字符集和关键字 47
3.3 C++的数据类型概述 49
3.4 基本数据类型 51
3.4.1 整型数据 51
3.4.2 浮点型数据 52
3.4.3 字符型数据 53
3.4.4 bool类型 56
3.4.5 void类型 58
3.4.6 常量与变量 58
3.5 类型转换 61
3.5.1 隐式类型转换 62
3.5.2 强制类型转换 64
本章小结 64
第4章 运算符与表达式 66
4.1 概述 66
4.2 运算符和表达式 66
4.2.1 运算符和表达式的种类 66
4.2.2 左值和右值 67
4.3 算术运算符和算术表达式 68
4.4 自增和自减运算符 69
4.5 赋值运算符和赋值表达式 71
4.5.1 赋值运算符与赋值运算 71
4.5.2 复合赋值运算符 72
4.5.3 赋值表达式 72
4.6 关系运算符和关系表达式 73
4.7 逻辑运算符和逻辑表达式 75
4.7.1 逻辑运算符 75
4.7.2 逻辑表达式 76
4.8 sizeof运算符 76
4.9 条件运算符和条件表达式 77
4.10 逗号运算符和逗号表达式 78
4.11 优先性和结合性 79
本章小结 80
习题 80
第5章 程序的结构 81
5.1 顺序结构 81
5.2 分支结构程序设计 82
5.2.1 if…else…结构 82
5.2.2 switch语句 86
5.2.3 goto语句 89
5.3 循环结构程序设计 90
5.3.1 for语句 90
5.3.2 while语句 94
5.3.3 do-while语句 96
5.3.4 循环的嵌套 97
5.4 break、continue语句 98
5.4.1 break语句 98
5.4.2 continue语句 100
本章小结 101
习题 101
第6章 宏和编译预处理 102
6.1 宏定义 103
6.2 头文件包含 108
6.3 条件编译 110
6.4 其他预处理指令 115
本章小结 119
习题 119
第7章 数组 120
7.1 为何需要数组 120
7.2 声明数组 121
7.3 访问数组元素 122
7.4 数组的初始化 124
7.5 数组应用举例 125
7.5.1 选择排序 125
7.5.2 冒泡排序 127
7.5.3 更多排序算法 129
7.6 字符串与字符数组 131
7.7 数组作为函数参数 133
7.8 二维数组 134
7.8.1 二维数组的定义 134
7.8.2 二维数组中元素的引用 135
7.8.3 二维数组的初始化 135
7.8.4 二维数组程序举例 136
7.9 多维数组 138
7.9.1 多维数组的定义 139
7.9.2 多维数组的引用 139
本章小结 141
习题 141
第8章 函数与程序结构 142
8.1 函数的概念 142
8.2 函数定义 143
8.3 函数声明 145
8.4 函数调用 147
8.5 变量的作用域类型 149
8.5.1 局部变量 149
8.5.2 全局变量 151
8.6 变量的存储类型 152
8.6.1 动态存储变量 152
8.6.2 静态存储变量 153
8.7 函数返回值 153
8.8 默认函数参数 155
8.9 内联函数 158
8.10 函数重载 160
8.11 作用域 163
8.11.1 局部作用域 163
8.11.2 函数作用域 164
8.11.3 函数原型作用域 165
8.12 可见性与生命期 165
8.12.1 可见性 165
8.12.2 生命期 167
8.12.3 补充说明 168
8.13 综合应用举例 168
8.14 递归函数 170
8.14.1 递归函数举例 170
8.14.2 递归调用过程分析 171
8.14.3 递归程序设计方法 172
8.15 程序文件结构 174
8.15.1 头文件 174
8.15.2 文件作用域 176
8.15.3 多文件结构 176
8.15.4 外部存储类型 177
本章小结 179
习题 179
第9章 指针和引用 180
9.1 指针的概念 180
9.2 指针声明和赋值 182
9.3 通过指针访问数据 185
9.4 指针运算 187
9.5 动态内存分配 190
9.5.1 malloc()和free()函数 191
9.5.2 new和delete运算符 193
9.5.3 指针与数组 194
9.6 动态内存分配的应用 198
9.6.1 应用举例1 198
9.6.2 应用举例2 199
9.7 const指针 204
9.8 指针作为函数参数 208
9.9 指针函数 213
9.10 函数指针 215
9.11 指针数组 219
9.12 指向指针的指针 223
9.13 常见的内存错误及其对策 226
9.14 引用的定义 227
9.15 使用引用访问数据 232
9.16 引用与指针对比 235
9.17 引用做函数的参数 236
9.18 应用举例3 239
9.19 返回引用 240
9.20 函数调用作为左值 244
9.21 const限定的引用 246
9.22 返回堆中变量的引用 248
本章小结 250
习题 250
第10章 结构、联合、枚举 252
10.1 自定义数据类型概述 252
10.2 结构的定义 253
10.3 结构初始化 255
10.4 访问结构成员 257
10.5 结构与数组 258
10.6 结构与指针 264
10.7 结构与引用 266
10.8 在函数中使用结构 267
10.9 结构的复杂形式 273
10.10 链表 275
10.11 联合 279
10.12 枚举 285
本章小结 294
习题 294
第11章 类与对象 296
11.1 抽象概述 296
11.2 类的概念 297
11.3 类的定义 298
11.3.1 类与结构 298
11.3.2 类的声明 299
11.3.3 类成员的访问控制 300
11.3.4 数据成员 303
11.3.5 成员函数 304
11.3.6 重载成员函数 306
11.3.7 类定义的注意事项 307
11.3.8 类声明和类定义 308
11.4 对象 309
11.4.1 类与对象的区别和联系 309
11.4.2 对象的声明 309
11.4.3 访问数据成员 310
11.4.4 调用成员函数 310
11.5 综合应用 313
11.6 构造函数 314
11.6.1 为何需要构造函数 314
11.6.2 构造函数的定义 316
11.6.3 带参数构造函数 317
11.6.4 默认构造函数 318
11.6.5 重载构造函数 319
11.7 类对象成员的初始化 320
11.8 析构函数 323
11.8.1 为何需要析构函数 323
11.8.2 析构函数的定义 324
11.8.3 何时需要使用析构函数 325
11.9 堆栈和内存分配 325
11.9.1 内存管理概述 325
11.9.2 变量与对象的空间分配时机与初始化327
11.9.3 为什么使用new/delete操作符 328
11.10 拷贝构造函数 329
11.10.1 程序出错的原因分析 329
11.10.2 拷贝构造函数 332
11.10.3 默认拷贝构造函数 334
11.10.4 浅拷贝与深拷贝 334
11.11 临时对象和无名对象 337
11.11.1 临时对象 337
11.11.2 无名对象 338
11.12 const成员 339
本章小结 340
习题 341
第12章 静态成员与友元 342
12.1 静态成员 342
12.1.1 为何需要静态成员 342
12.1.2 静态成员变量 343
12.1.3 静态成员函数 345
12.2 友元 346
12.2.1 为何需要友元 346
12.2.2 友元函数 347
12.2.3 友元类 348
第13章 继承与多态 351
13.1 继承与派生的概念 352
13.2 继承的实现方式 354
13.3 继承类的构造与析构 355
13.3.1 继承类的构造 355
13.3.2 构造函数的参数传递 357
13.4 基类访问控制 360
13.5 多态与虚函数 362
13.5.1 为什么使用虚函数 363
13.5.2 虚函数 364
13.5.3 重载、隐藏与覆盖 365
13.5.4 虚函数的限制 368
13.6 多继承 370
13.6.1 多继承的实现 371
13.6.2 多继承的二义性 371
13.6.3 多继承的构造顺序 373
13.7 虚基类 374
13.7.1 虚基类的定义 375
13.7.2 虚基类的构造函数和初始化376
本章小结 376
习题 377
第14章 运算符重载 378
14.1 为何要重载运算符 378
14.2 运算符重载的实现 379
14.2.1 成员函数运算符重载 380
14.2.2 友元函数运算符重载 382
14.3 单目运算符和双目运算符 383
14.4 引用返回和值返回 386
14.5 常见的运算符重载 391
14.5.1 赋值与比较运算符 391
14.5.2 递增与递减运算符 392
14.5.3 数组存取标识符 393
本章小结 395
习题 395
第15章 模板 396
15.1 为何需要模板 396
15.2 函数模板 397
15.2.1 函数模板的概念 397
15.2.2 函数模板的定义 398
15.2.3 函数模板的实例化 399
15.2.4 重载模板函数 399
15.3 类模板 401
15.3.1 类模板的定义 401
15.3.2 使用类模板 403
15.4 综合应用 404
本章小结 406
第16章 标准模板库 407
16.1 标准模板库的基本组成 407
16.2 标准命名空间 408
16.3 容器 409
16.3.1 顺序容器 409
16.3.2 关系式容器 411
16.4 迭代器 413
16.5 算法 415
本章小结 418
第17章 I/O流 419
17.1 流的概念 419
17.2 I/O标准流类 421
17.2.1 标准流的设备名 421
17.2.2 原理 421
17.3 输入输出的格式控制 423
17.3.1 用ios类的成员函数进行格式控制 423
17.3.2 使用格式控制符进行格式控制 427
17.4 输入输出运算符的重载 429
17.4.1 重载输出运算符 429
17.4.2 重载输入运算符 430
17.5 文件流 431
17.5.1 打开文件 432
17.5.2 关闭文件 434
17.5.3 写入文件 435
17.5.4 读取文件 435
17.5.5 常用操作和状态检测 436
17.5.6 读写随机文件 438
17.5.7 二进制文件的处理 440
本章小结 442
习题 442
第18章 异常处理 443
18.1 传统的错误处理方式 443
18.2 异常处理的思想 445
18.3 异常处理的实现方式 447
18.4 构造和析构中的异常抛出 448
18.5 异常规格说明 449
18.6 标准异常 451
本章小结 452
附录A 程序的写作风格 453