Java桌面游戏—争霸的设计与实现毕业论文

毕业设计（论文）中文摘要

Java桌面游戏—争霸的设计与实现 摘 要：随着计算机日益普及，计算机已然成为人们日常生活的一部分的今天，计算机游戏也越来越成为人们生活中不可或缺的一部分。可以用于游戏开发的计算机语言多种多样，而Java语言只是其中一种。然而Java是现在全球最时髦的开发工具之一,它拥有一套庞大且完善的类库,内置了其他语言需要靠库甚至是操作系统才能支持的功能。Java语言的大部分是为因特网设计的，所以，程序员可以很容易的用Java编写并运行基于Web的游戏。 本设计是一款基于Java的桌面游戏软件。本游戏的大体设计分为游戏引擎设计和游戏界面设计两个模块，游戏引擎设计中主要涉及到了核心模块core包、本地翻译模块translaition包、网络模块net包和人工智能模块ai包的设计与实现。整个系统从操作简便、界面美观、灵活实用的用户要求为出发点。 本文从游戏的背景研究和发展现状开始，详细描述了整个游戏的制作过程。对实现的主要功能以及操作过程进行了重点讨论，开发用到了Java类库中的很多的包以及其中的类，例如java.io包、java.util包、java.net包、javax.swing包、java.awt包等等，文中会对这些包和类的用法进行讲解。 关键词：游戏 Java语言 类库 人工智能 本地翻译 毕业设计（论文）外文摘要

Java Game—King’s Design and Implementation Abstract: With the increasing popularity of computer, the computer has become part of people's daily life today, Computer games have become an integral part of people's lives. The language can be used in the computer game development is diversity, and the java language is only one of them. However, java is the most popular development tools of the world, it also has a huge sound library, built-in the function that the other language need to rely on library or even operating system. Most part of the java language is designed for Internet, so programmers can easily use java to develop and run Web-based games. This design is a desktop game software that based on java. The game ?s design is generally divided into the game engine design and game interface design, and the game engine design mainly related to the core module – core package, local translation module – translation package, network module – net package and artificial intelligence module – ai package‘s design and implementation. The entire system is from the simple operation, beautiful interface, a flexible and practical --user‘s requirements as a starting point. This paper from the game background research and development status, a detailed description of the entire process of producing the game. Implementation of the main functions and the operation of the process were discussed, The development used many packages and classes of the java library, such as the java.lang package, java.util package, javax.swing package, java.awt package and so on, the text will talk about the useage of the packages and classes. Keywords: game; java Language; library; artificial intelligence; Local translators.

目 录

1 引言 .......................................................... 1 1.1 课题的研究背景与意义 ..................................... 1 1.2 Java语言的特点和及其与游戏的结合 ....................... 1 1.2.1 Java语言的特点 ...................................... 1 1.2.2 Java与网络的结合 .................................... 2 1.3 可行性的分析 ............................................ 3 1.3.1 技术可行性 ........................................... 3 1.3.2 经济可行性 ........................................... 4 1.3.3 操作可行性 ........................................... 4 1.3.4 法律可行性 ........................................... 4 2 需求分析 ...................................................... 5 2.1 系统初步分析 ........................................... 5 2.1.1用户需求分析 ......................................... 5 2.1.2功能需求分析 ......................................... 5 2.1.3系统的可靠性和可用性需求分析 ......................... 6 2.2 数据流分析 .............................................. 6 3

总体设计 ................................................... 7 3.1 系统开发 ................................................. 7 3.1.1 系统开发的原则 ....................................... 7

3.1.2 系统设计阶段 ......................................... 7 3.1.3 结构设计阶段 ......................................... 9 4 详细设计 ..................................................... 14 4.1 核心包的设计 ........................................... 14 4.1.1 Card类的设计与实现： ............................... 14 4.1.2 Continent类的设计与实现： .......................... 15 4.1.3 Mission类的设计与实现： ............................ 16 4.1.4 Country类的设计与实现： ............................ 16 4.1.5 Player类的设计与实现： ............................. 17 4.1.6 Statistic类的设计与实现： .......................... 18 4.2 本地翻译包的设计 ....................................... 19 4.2.1 TranslationBoudle类的设计与实现 .................... 19 4.2.2 MapTranslator类的设计与实现 ........................ 20 4.3 网络包的设计 ........................................... 22 4.4 人工智能包的设计 ....................................... 25 4.5 其他工具类的设计 ....................................... 28 4.6 游戏界面的设计 ......................................... 30 5 用户使用手册 ................................................. 37 5.1 系统环境说明 ............................................ 37 5.2 系统简介 ............................................. 37 5.2.1 系统特点 ........................................... 37 5.2.2 操作方法 ........................................... 37 5.3 游戏需要改进的地方 ...................................... 38

结 论 ........................................................... 39 参 考 文 献 ..................................................... 40 致 谢 ........................................................... 41

第1页 共41页

1 引 言

1.1 课题的研究背景与意义

随着计算机日益普及，计算机已然成为人们日常生活的一部分的今天，计算机游戏也越来越成为人们生活中不可或缺的元素。游戏可以简单地理解为调节人们生活节奏和缓解人们生活压力的一种手段。现在理解的游戏基本意义都是娱乐性质较浓，要有特定的行为模式，遵循一定规则以达到游戏者目的的行动。游戏的最初目的就是让游戏者（玩家）在游戏中得到放松。游戏一直存在于人类活动中，如今定义的游戏从早期的猜谜游戏，发展到如今的单机RPG游戏，网络游戏等，已经升华为更高级别意义上的娱乐活动，对人们的感官刺激也越发强烈，得到的乐趣也更多。而对于编写游戏而言，Java终于变得足够成熟了（Java的语言特性和其与游戏的结合请见下一小节）。它现在是一种开发能够在多种平台上运行的中小型游戏的很好的方式。此外，Java支持和其他的库一起工作，而且它的速度变得越来越快。Java并不是以游戏编程为目的而被开发的，事实上，游戏编程可能是Java创造者心中的最后一个目标。在过去，妨碍Java发展的是它的运行环境；浏览器和Java类库一起从本质上决定了Java应该用来写哪种类型的应用程序，而高速的游戏和图象则不在其中。这给Java带来了不好的影响，因为人们注意的不是语言，而是它的运行环境。现在，浏览器已经不能控制一切了，Java作为游戏编程语言的另一个机会到来了。Java在过去有一点超前于它的时代，当时市场的动力落后于Java，但是现在Java可以而且已经取得成功。

据悉，中国民族网络游戏出版工程将在5年内出版100种大型民族网络游戏，总投资预计超过3亿元。信息产业部已将网络游戏通用引擎研究及示范产品纳入国家“863计划”，这是中国首次将网络游戏技术纳入国家科技计划。文化部也向国内12家在网络游戏业的实力厂商首批颁发了《网络文化经营许可证》，加大对网络游戏的监管力度，进口游戏审查制，限制国内对国外的受理措施。科技部制定科技发展规划，将把网络游戏纳入现代服务业并加以扶持。政府态度和政策都是一种信号，表明2005年对本土网络游戏的扶持力度将加大；国内游戏厂商将可获得发展的核心技术平台；政策有利于保护中国游戏软件的自主知识产权；这为网络游戏发展创造了良好的政策环境。

而Java的创建者把Java称为“网络编程语言”，且由于JAVA游戏一般来说简单有趣，并且对用户硬件要求极小，所以JAVA游戏通常对85%的计算机用户都有吸引力。

1.2 Java语言的特点和及其与游戏的结合 1.2.1 Java语言的特点

Java能够取得如此的成功，是因为它在设计时的目标就定位在要解决当今程序员们所面临的众多问题。Java的基本目标之一就是要提高生产率。生产率来源于许多方面，但是Java希望在语言方面相对于它的前辈有明显的提高，从而为程序员提供更大的便利。

1.系统易于表达、易于理解

被设计用来适应问题的“类”，在表达问题的能力上显得更强。这意味着当你编写代

第2页 共41页

码时，你是在用问题空间的术语，而不是计算机——也就是解空间——的术语，来描述解决方案。可以用更高层的概念来处理问题，并且只用一行代码就可以做更多的事。

易于表达所带来的另一个好处就是易于维护，维护在程序生命周期中所占的成本比例极大。如果程序易于理解，那么他必定易于维护。同时，这也降低了创建和维护文档的费用。

2.类库的巨大影响力

创建程序最快捷的方式就是使用已经编写好的代码：类库。Java的主要目标之一就是要使类库更易于使用。这是通过将类库转型为新的数据类型来实现的，因此，引入类库意味着在语言中添加了新的数据类型。因为Java编译器会照管类库的使用方式——确保正确地初始化和回收垃圾，并保证其他方法被正确地调用，因此，你只需专注于你想让类库做些什么，而不必关心应如何去做。

3.错误处理

在C语言中，错误处理一直是一个声名狼籍的问题，而且经常被忽视——经常只能靠上帝保佑了。如果你在构建一个大型的、复杂的程序，那么没有什么比在程序某处暗藏了一个错误，而你却没有任何能够暗示它在何处的线索更糟糕的事情了。Java异常处理便是一种能够确保错误必须被报告，而且对此必须有所响应的机制。

4.大型程序设计

许多传统语言在程序大小和复杂度方面都有内置的限制。例如，BASIC可能对某类问题的解决能力非常强，可以快速地创建解决方案，但是如果程序长度超过数页，或者超出该语言正常的题域之外，它就会像“在非常粘稠的液体中游泳”。它没有明确的界线来表示何时你所使用的语言会导致最终的失败，即使有这样的界线，你也会忽视它。你总不能说：“我的BASIC程序太大了，我不得不用C来重写它！”相反，你会试着将几行代码硬塞进去，以便在程序中增加新功能。因此，不知不觉中，你就付出了额外的开销。

Java具备编写大型程序的能力——也就是说，它消除了小型程序和大型程序之间的复杂度界线。在编写“hello,world”风格的小应用程序时，你当然不必使用OOP，但是当你需要用到时，这些功能随手可得。而且，对小型程序和大型程序，编译器都会一视同仁地、积极地找出因bug而产生的错误。

1.2.2 Java与网络的结合

Java不仅是一种功能强大的、安全的、跨平台的、国际化的编程语言，而且它还在不断地被扩展，以提供更多的 语言功能和类库，能够优雅地处理在传统编程语言中很难解决的问题，例如线程、数据库访问、网络编程和分部式计算。Java是通过applet以及使用Java Web Start来进行客户端编程的。

Applet是只在Web浏览中器运行的小程序，它是作为网页的一部分而自动下载的。当applet被激活时，它便开始执行一个程序，这正是它优雅之处：它提供一种分发软件的方法，一旦用户需要客户端软件时，就自动从服务器把客户端软件分发给用户。用户获取最新版本的客户端软件时不会产生错误，而且也不需要很麻烦的重新安装过程。Java的这种

第3页 共41页

设计方式，使得程序员只需创建单一的程序，而只要一台计算机有浏览器，且浏览器具有内置的Java解释器，那么这个程序就可以自动在这台计算机上运行。由于Java是一种成熟的编程语言，所以在提出对服务器的请求之前和之后，可以在客户端尽可能多地多做些事情。例如，不必跨网络地发送一张请求表单来检查自己是否填写了错误的日期或其他参数，客户端计算机就可以快速地标出错误数据，而不用等待服务器作出标记并给你传回图片。这不仅立即就获得了高速度和快速的响应能力，而且也降低了网络流量和服务器负载，从而不会使整个Internet的速度都慢下来。

Java applet胜过脚本语言程序的优势之一就是，它是以被编译过的形式存在的，因此其源代码对客户端来说是不可见的。另一方面，虽然反编译Java applet并不需要花费多少力气，但是隐藏你的代码通常并不是一个重要的话题。有另外两个因素很重要。如果编译过的applet很大的话，那么就需要额外的时间去下载它。脚本语言程序只是被作为Web页面的一部分文本而集成到了Web页面中。这对Web网站的响应能力来说很重要。另一个因素是非常重要的“学习曲线”问题。如果你是一个Visual BASIC程序员，那么转而学习VBScript可能是最快的解决方案，而且由于它或许能够解决大多数典型的客户/服务器问题，所以你可能很难对学习Java报以公正的态度。如果你已经对脚本语言很有经验了，那么你在考虑使用Java之前，应该先看看JavaScript是否满足你的要求，这样对你会很有好处，因为它们能够更方便地满足你的要求，而且使你更具生产力。

Java引起人们的注意很大程度上始于applet。Java确实是一种通用的编程语言，至少在理论上可以解决各种其他语言能够解决的问题。正像前面指出的那样，可能存在其他更有效的方式去解决客户/服务器问题。当你离开applet的竞技场时，你便步入了通用应用系统的世界，这里的系统都是独立运行的，不需要浏览器，就像其他普通程序一样。在这里，Java的威力不仅在于它的可移植性，还包括它的可编程性。Java已经具备了许多功能，让你创建健壮的程序，而花费的时间比使用Java之前的任何编程语言都更少。

不过，这是好坏参半的事。为Java带来的改进，所付出的代价是降低了执行速度。像任何语言一样，Java也具有不适合解决某类问题的天生的限制。然而，Java是快速进化的语言，而且每当发布一个新版本时，它都会因为能够解决更多的问题而变得越来越具有吸引力。

1.3 可行性的分析

可行性研究的目的，就是用最小的代价在尽可能短的时间内确定问题是否能够解决。要达到这个目的，必须分析几种主要的可能解法的利弊，从而判断原定的系统规模和目标是否现实，系统完成后所能带来的效益是否大到值得投资开发这个系统的程度。因此，可行性研究实质上是要进行一次大大压缩简化了的系统分析和设计的过程，也就是在较高层次上以较抽象的方式进行的系统分析和设计的过程。

1.3.1 技术可行性

本游戏是在Windows XP环境下开发的，一般的机器配置就可以了，对机器本身没有太高的要求，一般当前学校或个人电脑完全可满足要求，环境只需装上jdk 1.4或以上版本

第4页 共41页

就行了，Java是现在全球最时髦的开发工具之一,它拥有一套庞大且完善的类库,内置了其他语言需要靠库甚至是操作系统才能支持的功能,拥有一个虚拟机。NeatBeans IDE 5.5是SUN公司开发的Java可视化集成开发工具，是目前最优秀的Java集成开发工具之一。

1.3.2 经济可行性

由于本系统使用到的工具一般机器都具备，使用环境也很简单，开发成本低，本课题研究的内容是涉及网络的游戏对战。当今形式下网络游戏俨然已经成为年轻人最时兴的消费方式之一，JAVA一直以来由于其可以“跨平台”以及“一次编译，到处运行”等特点，许多人直接它为网络编程语言，且由于JAVA游戏一般来说简单有趣，并且对用户硬件要求极小，所以JAVA游戏通常对85%的计算机用户都有吸引力。且政府态度和政策都是一种信号，表明2005年对本土网络游戏的扶持力度将加大；国内游戏厂商将可获得发展的核心技术平台；政策有利于保护中国游戏软件的自主知识产权；这为网络游戏发展创造了良好的政策环境。

1.3.3 操作可行性

由于在整个系统的开发过程中从操作简便、界面美观、灵活实用的用户要求为出发点，界面设计时充分考虑玩家的感受，界面比较直观，交互性很好，所以操作起来简单明了。

1.3.4 法律可行性

信息产业部已将网络游戏通用引擎研究及示范产品纳入国家“863计划”，这是中国首次将网络游戏技术纳入国家科技计划。文化部也向国内12家在网络游戏业的实力厂商首批颁发了《网络文化经营许可证》，加大对网络游戏的监管力度，进口游戏审查制，限制国内对国外的受理措施。科技部制定科技发展规划，将把网络游戏纳入现代服务业并加以扶持。政府态度和政策都是一种信号，表明2005年对本土网络游戏的扶持力度将加大；国内游戏厂商将可获得发展的核心技术平台；政策有利于保护中国游戏软件的自主知识产权；这为网络游戏发展创造了良好的政策环境。

第5页 共41页

2 需求分析

所谓系统分析，就是指在整个系统开发工程中，解决“做什么”的问题，把要解决哪些问题，满足用户哪些具体的信息需求调查分析清楚，从逻辑上或是说从信息处理的功能需求上提出系统的方案，即逻辑模型，为下一阶段进行物理方案设计，解决怎么办提供依据。

2.1 系统初步分析 2.1.1 用户需求分析

随着Internet的发展，进入信息时代后快速获得网络共享资源成为很简单的事情，人们对互联网也有了很大的依赖性。网络的普及化使得原本单人的游戏已经不能适应人们的需要，广大的游戏者迫切需要能够和身在异地的朋友一起享受游戏的乐趣。在这种环境下，网络游戏应运而生，越来越多的游戏者投身到网络游戏中。这样带来的问题自然成为越来越多的游戏研究者将研究方向转为网络游戏的研究。

据目前的网络游戏的调研来看，以运动休闲为主的运动类游戏正在受到越来越多玩家的支持和爱戴。但是此类网络游戏中，由Java开发的网络游戏仍然是一个空白页，但是它却是一个迫切需要填补的空白页。而Java由于其天生的语言特性（请见1.2节），很适合用于开发网络游戏，但由于系统环境的问题使得它一直以来未能用于游戏开发，而近来由于Java的发展，它已经摆脱了束缚，浮出了游戏开发的水面，若能在网络上出现高要求多人互动的Java游戏，它将是一项极为伟大的发展。这也正是现在许多玩家迫切要求的。

2.1.2 功能需求分析

系统功能的需求指定系统必须提供的服务。通过需求分析应该划分出系统必须完成的所有功能。本作的功能模块主要包括游戏的引擎设计，游戏的界面设计。

1. 游戏的引擎设计的需求分析：

游戏引擎是游戏的灵魂，也就是这个游戏的框架，它的好坏直接决定着游戏的质量。它是控制所有游戏功能的主程序，包括画面的处理，人工智能的实现，接受玩家的设置，以及网络联机的实现等等。

所以鉴定一个游戏的好坏，从内部设计的原因上说来，是从游戏的引擎设计体现出来的。一个游戏的引擎设计，直接关系到游戏设计的其他方面，诸如游戏的图形系统、声音系统及设计的物理模块等等各个方面。就如一台电脑需要CPU一样，游戏的引擎也是直接牵制着整个游戏的设计。它的主要作用就是处理游戏中的事件，运行游戏中的图象，输出声音及画面，调整游戏的节奏，响应玩家的游戏监听事件等等。所以，游戏的引擎设计是必要的功能模块，而且游戏的引擎设计必须做好，以使得游戏更具有可玩性。游戏程序是一项精度要求很高的程序系统，因为其代码利用率很高。一个实时运行的最终作品，每秒都会运行成千上万行程序，绘图事件等都会以极高的频率在后台等待响应，若有丝毫的差别都将很容易导致程序在运行不久后可能出现严重错误，甚至死循环。因此，其逻辑设计

第6页 共41页

应当相当严谨，需将所有可能发生的事件及意外情况考虑在设计中。

2．游戏界面设计的需求分析：

作为一个游戏吸引玩家的重要方面，游戏的界面要很漂亮，图形动画的设计是非常必要的。本作将采用模拟动画的方式将战争展现在玩家眼前。设计出丰富的战争环境，游戏中为了美观，适用性强，需要采用外部文件引入的图片贴图，而Java中提供了用于处理图片的功能包，使得解决静态或动态、画面背景、屏幕刷新的双缓冲等都有较好的解决方案。

2.1.3 系统的可靠性和可用性需求分析

可靠性需求定量地指定系统的可靠性。例如，游戏在运行过程中不能频繁发生错误而不得不终止游戏。

可用性则与可靠性密切相关，它量化了用户可以使用系统的程度。例如，游戏的运行必须保证随时可以，不能在一段不使用的时间内，游戏产生不可预见的错误而致无法运行等等。

2.2 数据流分析

数据流程分析主要包括对信息的流动、传递、处理、存储等的分析。数据流程分析的目的就是要发现和解决数据流通中的问题。通过对本系统的需求分析，确定了系统的基本功能。整个系统的数据流图如图2-1所示：

玩家事务1.0进入游戏玩家信息1.1设置玩家卡片类型1.2设置卡片游戏类型军队信息2开始游戏设置信息1.4设置地图地图信息1.3设置游戏类型2.1各个玩家放置军队玩家信息2.2设置进攻者玩家信息2.3设置防守者事务2.4滚动骰子骰子结果3交易卡片卡片信息2.6军队的移动战争结果2.5进行战争游戏信息交易信息战争结果3.2放置军队游戏信息军队信息3.1换算军队没有胜利4判断是否胜利胜利D1 游戏保存文件5游戏结束

图2-1 系统数据流程图

第7页 共41页

3 总体设计

总体设计过程通常由两个主要阶段组成：系统设计阶段，确定系统的具体实现方案；结构设计阶段，确定软件结构和功能模块。

3.1 系统开发 3.1.1 系统开发的原则

经过需求分析阶段的工作，系统必须“做什么”已经清楚了，现在是决定“怎么做”的时候了。总体设计的基本目的就是回答“概括地说，系统应该如何实现？”这个问题，因此，总体设计又称为概要设计或初步设计。通过这个阶段的工作将划分出组成系统的物理元素——程序、文件、数据库、人工过程和文档等等，但是每个物理元素仍然处于黑盒子级，这些黑盒子里的具体内容将在以后仔细设计。总体设计阶段的另一项重要任务是设计软件的结构，也就是要确定系统中每个程序是由哪些模块组成的，以及这些模块相互间的关系。

总体设计过程首先寻找实现目标系统的各种不同的方案，需求分析阶段得到的数据流图是设想各种可能方案的基础。然后从这些供选择的方案中选取若干合理的方案，为每个合理的方案都准备一份系统流程图，列出组成系统的所有物理元素，进行成本/效益分析，并且指定实现此方案的进度计划。通常，设计出初步的软件结构后还要多方改进，从而得到更合理的结构，进行必要的数据库设计，确定测试要求并且制定测试计划。

基于上面的叙述，在详细设计之前先进行总体设计的必要性：可以站在全局高度上，花较少成本，从较抽象的层次上分析比对多种可能的系统方案和软件结构，从中选出最佳方案和最合理的软件结构，从而用较低成本开发出较高质量的软件系统。

3.1.2 系统设计阶段

系统设计阶段的主要目的就是确定软件如何做的问题。主要任务就是确定系统中的大模块和设计方法，确定软件的功能模块和模块的作用，组成，关系等等。

本系统是一款希望可以基于网络的多人对战游戏，当游戏者打开游戏，游戏界面打开，然后玩家可以选择是进行一轮新的游戏，还是选择接着玩上次没玩结束的游戏（如果先前已经玩过该游戏，但没有玩结束，有事了，并且保存了），只需要选择载入游戏就可以；玩家还可以选择是进行单机游戏或是联机游戏，如果选择网络联机玩的话只需要启动服务器等待其他玩家加入就可以了；如果选择了单机游戏，并选择了进行一轮新的游戏，则游戏会出现游戏设置界面，通过该界面玩家可以设置游戏的玩家数量（2-6个）以及游戏的难度，电脑玩家有简单智力的和高智力的，然后玩家可以选择不同的卡片模式和不同的游戏模式（分为统治型、首都型和任务型），并且玩家可以选择不同的游戏地图，游戏的目标是统治全世界，当玩家设置好一切后，可以点击开始游戏，则游戏开始。

游戏开始，游戏画面是一张被分割成多个国家的地图，每个玩家可以轮流在地图上选择自己的地盘和军队的布置，而电脑玩家也会自动放置军队，当每个国家都被放上军队后，才可以重复在一个国家放置多余的军队，当默认的所有军队全都放置好，然后玩家就可以

第8页 共41页

开始统一全球的战争游戏了，而当一方的军队侵略另一边时，游戏程序通过一定的人工智能算法让战争的双方分别产生随机数，然后进行比较，大的一方胜利，而当进攻者与防守者产生的数字一样大时，算是进攻失败，如果进攻胜利，则胜者将占领该国家，并可以选择留守该国家的军队数，而等到下一轮到该玩家进攻时，可以根据该玩家在占领的领土来决定你可以增加多少军队，以及你可以获得的卡片，获得的卡片可以用来交换军队，最后占领全世界（消灭了其他两个玩家）的为胜利者。在游戏过程中如果玩家突然有事无法继续游戏，本游戏可以保存当前游戏状态，当玩家有时间时可以接下去游戏，而无需重新开始，玩家也可以将自己的机器作为服务器，通过网络与网络上的其他玩家一起游戏。本游戏还具有统计的功能，在你游戏过程中或则游戏结束后你可以查看在本局游戏中各个玩家各个方面的战绩的统计（例如每个玩家在游戏过程当中所占领的国家数、军队数、摧毁数、伤亡数、受到进攻的次数等等），游戏中还设置了控制台，玩家可以通过图形显示的按钮进行游戏，也可以通过命令来进行游戏，在游戏菜单栏的帮助中，玩家可以选择命令按扭来显示出游戏中可用的命令菜单，玩家可以通过选择其中的关于了解本游戏的一些信息。 当你赢的了游戏，游戏会告诉你，你胜利了！

关于线程：对象技术提供了一种把程序划分成若干独立部分的方式。通常，还需要把程序转换成彼此分离的、能独立运行的子任务。每一个这样的独立子任务都被称为一个“线程”。每个线程都好象是在独立运行并且有自己的CPU。CPU时间确实是通过某些底层机制进行分配的，不过你一般不考虑这些，这使得编写多线程程序的任务变得容易得多了。多线程有多种用途，不过通常用法是，程序中的某个部分与一个特定的事件或资源联系在一起，而又不想让这种联系阻碍程序其余部分的运行。这时候，可以创建一个与这个事件或者资源相关联的线程，并且让此线程独立于主程序运行。使用并发的最引人瞩目的理由之一就是，产生一个可作出响应的用户界面。考虑一个程序，它要执行某项强烈需用CPU的计算，这样就会导致用户的输入被忽略，也就无法作出响应。问题的实质是：程序需要一边连续进行计算，同时还要把控制权交给用户界面，这样程序才能响应用户的操作。

并发还可以用来优化吞吐量。比如，在等待数据到达输入/输出端口的同时，可以进行其他重要的工作。要是不用线程的话，唯一可行的办法就是不断查询输入/输出端口，这种方法不仅笨拙，而且很困难。

线程模型为编程带来了便利，它简化了在单一程序中同时交织在一起的多个操作的处理。在使用线程时，CPU将轮流给每个线程分配其占用时间。每个线程都觉得自己在一直占用CPU ，但事实上CPU时间是划分成片段分配给了所有线程。例外情况是程序运行在具多个CPU的机器上，但线程的一大好处是可以使你从这个层次抽身出来，即代码不必知道它是运行在具有一个还是多个CPU的机器上。所以线程是一种透明的、可扩展的程序方法，如果程序运行的太慢，为机器增添一个CPU就能很容易地加快程序的运行速度。多任务和多线程往往是使用多处理器系统的最合理方式。

游戏中将在很多地方用到多线程，像在进行网络联机时将会使用多线程来是两个玩家可以同步进行游戏，而图形界面也通过多线程同时进行多的程

第9页 共41页

序的进行。

3.1.3 结构设计阶段

1. 经过系统设计阶段的思考和实践，需要对功能结构进行细致的划分。一个程序的结构设计的好坏也是决定其发展的重要指标。对一个程序的模块划分往往也能使程序设计变得简单。

本游戏的模块大致分为游戏引擎和用户界面两大模块而，游戏引擎模块又分为核心包、ai包、网络包、本地翻译包、游戏控制类等等，其功能模块图示如下：

King游戏 游戏引擎 核心模块 AI模块

功能模块介绍：

<1>

用户界面 网络模块 本地翻译模块 游戏控制模块 图3-1 系统功能模块结构图

king.engine.core包：其中包括了一些基本核心的类，例如像表示一个国家

的Country类,表示一个卡片的Card类，表示一个版块的Continent类，表示一个玩家的Player类以及表示一个任务的Mission类等等。

<2> <3> <4>

king.engine.ai包：其中包括了玩家可选择的简单人工智能的电脑玩家和复king.engine.translation包：其中包括了用于将游戏中的语言根据计算机所king.engine.net包：其中包括了将游戏用于网络联机玩用到的类。

杂人工智能的电脑玩家以及不同游戏类型的不同玩家的人工智能。 处的不同的国家翻译成不同的语言的类。

<5> 游戏控制模块：主要包含一些我自己定义的一些接口和过滤器类等工具类。

第10页 共41页

系统用例图见下页：

图3-2 系统用例图

游戏设置用例图：

图3-3 游戏设置用例图

第11页 共41页

网络联机用例图：

图3-4 网络联机游戏用例图

游戏用例图：

图3-5 游戏用例图

第12页 共41页

2. 系统的主要UML图见下页：

图3-2 Risk类的依赖关系图

图3-3 SwingGUIPanel类的依赖关系图

第13页 共41页

图3-4 RikGame类的依赖关系图

第14页 共41页

4 详细设计

详细设计阶段的根本目标是确定应该怎样具体地实现所要求的系统，也就是说，经过这个阶段的设计工作，应该得出对目标系统的精确描述，从而在编码阶段可以把这个描述直接翻译成用某种程序设计语言书写的程序。详细设计的结果基本上决定了最终程序代码的质量。详细设计的目标不仅仅是逻辑上正确地实现每个模块的功能，更重要的是设计出的处理过程应该尽可能简明易懂。结构程序设计技术是实现上述目标的关键技术，因此是详细设计的逻辑基础。

4.1 核心包的设计

游戏中需要经常用到的常有名词有卡片、国家、任务、玩家、版块、统计资料等等，所以我们由此可以确定这些基本的核心类：Card、Continent、Country、Mission、Player、Statistic；

4.1.1 Card类的设计与实现：

在游戏过程中某一些国家中会有卡片，当你没占领了这样的国家的时候，你就能获得卡片，当你获得了几张放在一起可以交易的卡片的时候你就可以用卡片换军队了，所以在该类中有卡片的名字，所属国家等属性，该类的类图如下所示：

图4-1 Card类的类图

Card类的主要代码如下：

public class Card implements Serializable {

??

public Card(String n, Country t) { name = n; Country = t; }

public String getName() { return name; }

public Country getCountry() { return Country; } }

第15页 共41页

4.1.2 Continent类的设计与实现：

游戏中的图片都是世界地图，其中包括几个洲，这些洲再分成一个一个国家，洲有自己的名字和颜色，并且每个洲都有它的对应的价值的军队数，当你占领了一个洲的时候，当下一轮到你进攻的时候，你可以获得相应数目的军队，在其他对象访问该对象时，可以获得它的名字，颜色，价值军队数和所属的玩家，其类图见图4-2所示：

图4-2 Continent类的类图

Continent类的主要代码如下：

public class Continent implements Serializable {

??

public boolean isOwned(Player p) { int ownedByPlayer=0;

for (int c=0; c< territoriesContained.size() ; c++) {

if ( ((Country)territoriesContained.elementAt(c)).getOwner() == p ) { ownedByPlayer++; } }

if ( ownedByPlayer==territoriesContained.size() ) { return true; }else {

return false; } } } if ( ownedByPlayer==territoriesContained.size() ) { return true; }else { return false; } }

?? }

第16页 共41页

}

4.1.3 Mission类的设计与实现：

Mission类主要用来代表在不同模式的游戏当中你的任务，其类图如下所示：

图4-4 Mission类的类图

4.1.4 Country类的设计与实现：

在本游戏中就是以国家为基本单位的，所以它为最核心的类，大部分其他类都需要访问它，其类图如下：

图4-3 Country类的类图

第17页 共41页

其中该类通过其构造函数构造一个任务对象，传递的参数有：任务要消灭的敌人，需要占领的的国家数，在一个版块上需要的最少军队数，第一个需要占领的国家，第二个需要占领的国家，第三个需要占领的国家以及任务的描述，其构造函数代码如下：

public Mission(Player p, int noc, int noa, Continent c1, Continent c2, Continent c3, String d) { player = p; noofcountries = noc; noofarmies = noa; con1 = c1; con2 = c2; con3 = c3; discription = d; }

4.1.5 Player类的设计与实现：

玩家用来代表一个玩家对象，该类也是游戏程序中所要用到的最基本的类，其中玩家的属性有：名字，颜色，玩家任务，玩家类型等，为了后面的统计功能的实现，还在其中增加了已经消灭的敌人向量，所拥有的卡片，所拥有的版块数等等，为了实现网络联机的功能，还增加了玩家的网络地址等等。

而玩家类中有一些重要的方法，像在后面要实现卡片交易，必要能获得玩家所拥有的卡片，还要判断一下玩家多拥有的卡片是否可以进行交易，以及为了实现网络联机要统计功能，必须要获得一些统计数据和玩家的网络地址，具体代码如下：

public Card takeCard() {

Card c=(Card)cardsOwned.firstElement(); cardsOwned.removeElementAt(0); return c; }

public void tradeInCards(Card card1, Card card2, Card card3) {

int noaFORcard = 2;

// 看看你是否可以从拥有的国家中获得额外的军队

if (territoriesOwned.contains( card1.getCountry() ) ) { ((Country)card1.getCountry()).addArmies(noaFORcard); currentStatistic.addReinforcements(noaFORcard); }

else if (territoriesOwned.contains( card2.getCountry() ) ) { ((Country)card2.getCountry()).addArmies(noaFORcard); currentStatistic.addReinforcements(noaFORcard); }

else if (territoriesOwned.contains( card3.getCountry() ) ) { ((Country)card3.getCountry()).addArmies(noaFORcard); currentStatistic.addReinforcements(noaFORcard); }

cardsOwned.remove(card1); cardsOwned.remove(card2); cardsOwned.remove(card3); cardsOwned.trimToSize(); }

public void addPlayersEliminated(Player p) {

第18页 共41页

playersEliminated.add(p); }

public Vector getPlayersEliminated() { return playersEliminated; }

4.1.6 Statistic类的设计与实现：

统计类主要是用来实现游戏的统计功能而设计的类，每个玩家拥有一个统计向量用来记录一些数据，给类里面只要一个包含记录各种数据的整形数组statistic属性，统计数据有国家数，军队数，毁灭数，伤亡数，增强过程，大陆数，国家数，进攻次数，撤退次数，胜利次数等等，该类的类图如下所示：

图4-5 Statistic类的类图

其中的重要方法有结束一轮进攻进行统计endGoStatistics(int a, int b, int c, int d)，向量statistics向量中0位置记录国家数，1记录军队数，2记录毁掉数，3记录伤亡数，4

中其他一些数据的计算方法，具体代码如下：

记录增强数，5记录大陆数，6记录帝国数，7记录进攻次数，8记录撤退次数，9记录胜利的次数，10记录战胜次数，11记录受到进攻的次数：

public void endGoStatistics(int a, int b, int c, int d) {

statistics[0] = a; statistics[1] = b; statistics[5] = c; statistics[6] = d; }

public void addReinforcements(int a) { statistics[4] = statistics[4] + a; }

public void addKill() { statistics[2]++;

第19页 共41页

}

public void addCasualty() { statistics[3]++; }

public void addAttack() { statistics[7]++; }

public void addAttacked() { statistics[11]++; }

public void addRetreat() { statistics[8]++; }

public void addCountriesWon() { statistics[9]++; }

public void addCountriesLost() { statistics[10]++; }

4.2 本地翻译包的设计

本包的设计是为了本游戏的国际化，在游戏过程中可以通过本包中的类实现语言的本地化，本包中包括两个类：TranslationBundle和MapTranslator。

4.2.1 TranslationBoudle类的设计与实现

该类主要是用来获得编写的资源包（这指语言包），然后该类可以通过Java API中的一些方法获得该游戏所处系统的语言环境，然后将游戏中的语言变换成本地语言；

该类中主要用到了java.util.ResourceBundle类，资源包包含特定于语言环境的对象。当程序需要一个特定于语言环境的资源时（如 String），程序可以从适合当前用户语言环境的资源包中装入它。以这种方式可以编写很大程度上独立于用户语言环境的程序代码，它将资源包中大部分（如果不是全部）特定于语言环境的信息隔离开来。

这就使您所编写的程序可以： 轻松地本地化或翻译成不同的语言 一次处理多个语言环境

以后可以轻松地进行修改，支持更多的语言环境

资源包属于这样的系列，其成员共享一个公共的基本名称，但是名称中还有标识其语言环境的其他组件。例如，某个资源包系列的基本名称可能是 \。该系列应该有一个默认资源包，其名称与其系列名相同（ \），并且如果不支持指定的语言环境，则此资源包应该用作最后的手段。然后，此系列可根据需要提供特定于语言环境的成员，例如一个名为 \的德语资源包。

某个系列中的每个资源包都包含相同的项，但是已经针对该资源包所代表的语言环境翻译了各项。例如，\和 \可能有用在取消操作按钮上的 String。在 \中，String 可能含有 \，而在 \中

第20页 共41页

则可能含有 \。

如果不同的国家/地区有不同的资源，则可以进行限定：例如，\是瑞士 (CH) 中包含德语 (de) 的对象。

Translation类中主要的方法有获得资源包和载入资源包，具体实现代码如下：

public class TranslationBundle {

??

static public ResourceBundle getBundle() {

if (TranslationBundle.resBundle == null) { TranslationBundle.loadBundle(); }

return TranslationBundle.resBundle; }

static private void loadBundle() {

if (TranslationBundle.strLanguage == null) { loc = Locale.getDefault(); } else {

loc = new Locale(TranslationBundle.strLanguage); }

try {

TranslationBundle.resBundle =

ResourceBundle.getBundle(\

} catch( java.util.MissingResourceException e) {

System.out.println( \ System.exit( 2); } }

static private void setLanguage(String strLanguage) {

TranslationBundle.strLanguage = strLanguage; } }

4.2.2 MapTranslator类的设计与实现

该类主要是用来将游戏中图片显示中的语言变换成本地语言； 具体实现代码如下：

public class MapTranslator

{

private static ResourceBundle MapResb = null; private static ResourceBundle CardsResb = null; public static void setMap(String strFile) {

String strName = strFile.substring( 0, strFile.lastIndexOf( '.'));

strFile = strName + \+ TranslationBundle.getBundle().getLocale().getLanguage() + \

try {

MapResb = new PropertyResourceBundle( (new URL(king.engine.Risk.mapsdir,strFile)).openStream() );

第21页 共41页

}

catch( IOException ioe ) { try { ??

} catch( MissingResourceException e) { MapResb = null; } } }

public static String getTranslatedMapName(String strOriginal) {

if (MapResb == null) { return strOriginal; }

String strReturn; try {

strReturn = MapResb.getString( strOriginal); } catch(MissingResourceException e) { strReturn = strOriginal; }

return strReturn; }

public static void setCards(String INstrFile) {

String strName = INstrFile.substring( 0, INstrFile.lastIndexOf( '.')); String strFile = strName + \+ TranslationBundle.getBundle().getLocale().getLanguage() + \

try {

CardsResb = new PropertyResourceBundle( (new URL(king.engine.Risk.mapsdir,strFile)).openStream() );

} catch( IOException ioe ) {

if(INstrFile.endsWith(\

{

try {

CardsResb=ResourceBundle.getBundle(\

TranslationBundle.getBundle().getLocale());

} catch( MissingResourceException e) { CardsResb = null; } } } }

public static String getTranslatedMissionName(String strOriginal) {

if (CardsResb == null) { return null; }

String strReturn; try {

strReturn = CardsResb.getString( strOriginal); } catch(MissingResourceException e) { strReturn = null; }

第22页 共41页

}

return strReturn; }

4.3 网络包的设计

游戏中该包的设计主要是用来实现游戏的网络联机游戏的功能的包，其中主要是一组实现两台机子相互连接的类：ChatArea类，ChatDisplayThread类,ChatReader类以及ChatServerThread类。

实现网络连接主要是要用到两个类：java.net.Socket类和java.net.ServerSocket类以及多线程和输入输出等类。

java.net包主要是为实现网络应用程序提供类。

让我们先了解一下什么是套接字的概念，网络套接字非常像电器的插座。网络上各种不同的插头用一个标准形式的方式来传递他们的负载，任何能够理解标准协议的东西都可以“插入”套接字来进行通信。对于电源插座，他并不在乎你插入的是一个电灯还是一个烤面包机，只要他们需要的是60赫兹，115伏电压，他们就将正常的工作。想一想你的电费帐单是怎么产生的：在你的房子和其余的网络之间的某个地方有一个计量表，对于通过那个计量表的每一千瓦能量，你都要付费。所以，即使电能在能量网络中自由的流动，但你的房子里的所有的插座都有一个特定的地址。网络套接字使用了同样的思想，只不过我们讨论的是TCP/IP数据包和IP地址，而不是电器和街道的地址。IP协议是一个低级路由协议，他把数据分成小的数据包并通过网络把他们发送到一个地址，但是他并不保证发送者上述的包能否到达目的地。传输控制协议是一个高级协议，用于把这些包串起来，如果需要，排列后重新发送他们以传送数据。第三个协议，拥护数据报协议和TCP协议很相似，可以直接用来支持快速、无连接的、不可靠的数据抱传输。

Socket类是实现客户端套接字（也可以就叫―套接字‖）。套接字是两台机器之间的通信端点。套接字的实际工作由 SocketImpl 类的实例执行。应用程序通过更改创建套接字实现的套接字工厂可以配置它自身，以创建适合本地防火墙的套接字。

ServerSocket类此类实现服务器套接字。服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果。服务器套接字的实际工作由 SocketImpl 类的实例执行。应用程序可以更改创建套接字实现的套接字工厂来配置它自身，从而创建适合本地防火墙的套接字。

网络包的实现结构图如图4-6（见下页）所示：

第23页 共41页

图4-6 网络包的实现

具体的实现代码如下： ChatArea类：

public class ChatArea extends Thread {

??

public ChatArea(RiskController g) throws Exception { gui = g;

InetAddress iaddr = InetAddress.getLocalHost(); serverSocket = new ServerSocket(port);

gui.sendMessage(\

gui.sendMessage(\ start(); }

public void run() { ?? }

catch (IOException e) { }

gui.sendMessage(\ }

public synchronized void closeSocket() throws IOException { ?? }

第24页 共41页

synchronized void putString(int index, String s) { ??

try { serverSocket.close(); } catch (IOException e) { } }

synchronized String getStrings(int index) { ?? }

synchronized String waitForString(int index) { ?? } }

ChatdisplayThread类：

public class ChatDisplayThread extends Thread { ??

public ChatDisplayThread (Risk r, BufferedReader in) {

risk = r; inChat = in; }

public void run() { String str;

boolean badexit=true; try {

while ((str = inChat.readLine()) != null) {

if (str.length() > 0) {

risk.GameParser(str); } } }

catch (IOException e) { ?? }

if (badexit) { risk.kickedOff(); } } }

ChatReader类：

public class ChatReader extends Thread{

??

ChatReader(BufferedReader in, ChatArea cArea, int index) { super(\ mySocketInput = in; myIndex = index; myChatArea = cArea; }

public void run(){

第25页 共41页

String inputLine; try {

while ((inputLine = mySocketInput.readLine()) != null) myChatArea.putString(myIndex, inputLine); }

catch (IOException e) { } } }

ChatServerThread类：

public class ChatServerThread extends Thread {

??

public ChatServerThread(Socket socket, ChatArea cArea, int me) { super(\ this.socket = socket; myChatArea = cArea; myIndex= me; } public void run() {

String outputLine; try {

PrintWriter outChat = new PrintWriter( socket.getOutputStream(), true); BufferedReader inChat = new BufferedReader( new InputStreamReader(

socket.getInputStream()));

myReaderThread = new ChatReader(inChat, myChatArea, myIndex); myReaderThread.start(); do {

outputLine = myChatArea.waitForString(myIndex); if (outputLine != null)

outChat.println(outputLine); }while (outputLine != null); inChat.close(); outChat.close(); socket.close();

} catch (IOException e) {} } }

4.4 人工智能包的设计

该包主要是用来实现游戏中电脑玩家的人工智能，游戏的电脑玩家可以分为简单ai的玩家和具有复杂ai的玩家：

简单ai电脑玩家只能进行一些简单的判断，向哪个国家进攻和部署多少军队以及如何部署军队都是随机的，而具有复杂ai的电脑玩家能进行复杂的判断，能根据敌人军队的部署来选择放置军队的方式和数量，来选择进攻的方式以及防守的方式；

具体的一些属性和方法见以下类图：

第26页 共41页

图4-6 AIEasy类的类图

图4-7 AIHard类的类图

其中复杂ai的几个重要的判断方法的主要实现代码如下：

1. 判断某一个版块是否大部分被某个玩家占领了的方法mostOwned(Continent w){ }： 方法中定义了一个整型的变量ownedByPlayer来记录被该版快中的一个国家一个玩家所占领，在用for循环方法一个一个检验该版快内的所有国家是否都被某个player给占领了，如果被某个玩家占领的国家数超过了该版快上国家数的一半则算是该玩家大部分占领了该版快，则方法返回true,否则返回false。

第27页 共41页

public boolean mostlyOwned(Continent w) {

int ownedByPlayer=0;

Vector territoriesContained = w.getTerritoriesContained();

for (int c=0; c< territoriesContained.size() ; c++) {

if ( ((Country)territoriesContained.elementAt(c)).getOwner() == player ) { ownedByPlayer++; } }

if ( ownedByPlayer>=(territoriesContained.size()/2) ) { return true; }

else {

return false; } }

2. 用来判断将军队放在哪个大陆上主要方法getPlaceArmies()：

public String getPlaceArmies() { String output;

if ( game.NoEmptyCountries()==false ) {

??

for (int i=0; i

??

}

??

ratio = extraArmiesForContinent - numberOfBorders - (neighborTerritories - numberOfBorders)+(territorynum * 0.9) - (numberofEnemyUnits * 1.2);

if (check <= ratio && hasFreeTerritories(ct) == true) { check = ratio; val = i; } ??

for (int j=0; j

if ( ((Country)ct.elementAt(j)).getOwner() == null ) { name=((Country)ct.elementAt(j)).getColor()+\ picked = true; break; } } }

if (picked == false) { ?? }

?? } else { ??

第28页 共41页

}

String s = keepBlocking(player); if( !s.equals(\ name = s;

String f = freeContinent(player); if( !f.equals(\ name = f; if ( name.equals(\ ??

else if (game.getSetup() )

output = \ else

output = \ }

return output;

}

4.5 其他工具类的设计

为了使游戏的开发能变得方便，我们必须完全依靠Java API中提供的类或接口，我们必须要定义一些自己的工具类和控制类来方便我们的设计，Java语言不像C++或其他一些具有多重继承特性的面向对象编程语言，它是单继承的，所以为了实现与类似与多重继承的功能，必须用到接口，这是接口被开发最主要的目的：

游戏中我们定义一个监听器接口RiskListener和适配器RiskAdapter，其中定义一些常用的方法，具体代码如下： RiskListener：

public interface RiskListener {

public void sendMessage(String output, boolean a, boolean b); public void needInput(int s); public void noInput();

public void setGameStatus(String state); public void newGame(boolean t); public void startGame(boolean s); public void closeGame();

public void setSlider(int min, int c1num, int c2num); public void armiesLeft(int l, boolean s); public void showDice(int n, boolean w); public void showMapPic(java.awt.Image p);

public void showCardsFile(String c, boolean m); public void serverState(boolean s);

public void openBattle(int c1num, int c2num); public void closeBattle();

public void addPlayer(int type, String name, java.awt.Color color, String ip); public void delPlayer(String name);

public void showDiceResults(int[] att, int[] def); public void setNODAttacker(int n); public void setNODDefender(int n); }

第29页 共41页

RiskAdapter类：该适配器类主要是用空实现接口类的，将RiskListener中的方法全实现了，如public void sendMessage(String output, boolean a, boolean b)方法被实现为： public void sendMessage(String output, boolean a, boolean b){ }，其他所有方法类似，虽然它实现了接口中的所有抽象方法，但是没有具体实现方法的内容，这有什么用呢？因为如果你要是其他的程序中实现该接口，你必须要实现其中的多有方法，无论你用不用的上，所以就会导致一些无用功，然而我们定义了这样一个适配器类，你就不用实现接口，可以继承该方法，而重写其中的一些你需要用到的方法，这样就省去了很多的无用功，能节省很多的宝贵时间！

在游戏中还需要通过java输入输出包来读取数据或将数据写入文件保存，这时候需要对文件或数据进行筛选，这时候我们就需要有自己的文件过滤器，所以我们定义一个RiskFileFilter类：

public class RiskFileFilter extends FileFilter {

??

public RiskFileFilter(String ext) { extension = ext; }

public boolean accept(File f) { if (f.isDirectory()) { return true; }

String ext = getExtension(f); if (ext != null) {

if (ext.equals( extension )) { return true; }else {

return false; } }

return false; }

public String getDescription(){ ?? }

public static String getExtension(File f) {?? }

}

最后我们需要主要的类Risk：

public class Risk extends Thread {

??

public Risk(String a,String b) {} public Risk() {}

public void addRiskListener(RiskListener o) {} public void deleteRiskListener(RiskListener o) {} public synchronized void parser(String m) {} public void run() {}

public void GameParser(String mem) {} public void DoEndGo() {}

第30页 共41页

}

public void getInput() {}

public String getAutoDefendString() {} public String whoWon() {}

public static Frame findParentFrame(Container c) {} public static String getNewFile(Frame f,String a) {} public synchronized void kickedOff() { } public Vector getCurrentCards() {}

public boolean isOwnedCurrentPlayerInt(int name) {} public String getCurrentMission() {} public Color[] getPlayerColors() {} public Color getCurrentPlayerColor() {}

public boolean canTrade(String c1, String c2, String c3) {} public RiskGame getGame() {}

public String getCountryName(int c) {} public boolean getAutoEndGo() {} public boolean getAutoDefend() {}

public static Color getTextColorFor(Color c) {}

4.6 游戏界面的设计

一个游戏只有好的界面的才能吸引玩家，要有很好的交互性，所以本游戏的开发过程中就是以操作简便、界面美观、灵活实用的用户要求为出发点的，当玩家进入游戏时，游戏的主界面的设计如下图所示：

第31页 共41页

图4-8 游戏的主界面

本游戏的图形设计都是通过java的javax.swing包开发的。 其主要实现代码SwingGUIFrame如下：

public class SwingGUIFrame {

public static void main(String[] argv) { try {

String os = System.getProperty(\ if ( os != null && os.startsWith(\

UIManager.setLookAndFeel(\

}

else {

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); } }

catch (Exception e) { e.printStackTrace(); }

JFrame gui = new JFrame();

gui.setContentPane( new SwingGUIPanel( new Risk() ) ); gui.setTitle( SwingGUIPanel.product );

gui.setIconImage(Toolkit.getDefaultToolkit().getImage( Risk.class.getResource(\if\

gui.setResizable(false); gui.pack();

gui.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); Dimension frameSize = gui.getSize(); frameSize.height = ((frameSize.height > screenSize.height) ? screenSize.height : frameSize.height);

frameSize.width = ((frameSize.width > screenSize.width) ? screenSize.width : frameSize.width);

gui.setLocation((screenSize.width - frameSize.width) / 2, (screenSize.height - frameSize.height) / 2);

gui.setVisible(true); } }

当你单击选择进行新游戏时，出现游戏设置面板，如图4-9所示； 当你选择载入游戏时，如图4-10 所示； 控制台面板如图4-12所示； 统计面板如图4-13所示； 游戏中的界面如图4-11所示； 卡片交易面板如图4-14所示； 关于面板如图4-15所示；

第32页 共41页

图4-9 游戏设置面板

图4-10 载入游戏面板

第33页 共41页

图4-11 游戏过程中

实现这些界面的是类SwingGUIPanel,其中实现游戏界面的方法主要是GamePaenl()主要实现代码：

public GamePanel() {

pp = new PicturePanel(myrisk); pp.setPreferredSize(mapSize); pp.setMinimumSize(mapSize); pp.setMaximumSize(mapSize);

pp.setBorder(javax.swing.BorderFactory.createLineBorder(new java.awt.Color(0,0,0),1));

pp.addMouseListener(this);

pp.addMouseMotionListener(this);

Dimension gameOptionsSize = new Dimension(PicturePanel.PP_X,25);

gameOptions = new GameOptionsPanel();

gameOptions.setPreferredSize(gameOptionsSize); gameOptions.setMinimumSize(gameOptionsSize); gameOptions.setMaximumSize(gameOptionsSize);

Dimension d = new Dimension(PicturePanel.PP_X , 50);

第34页 共41页

inGameCards = new CardLayout(); inGameInput = new JPanel();

inGameInput.setLayout( inGameCards ); inGameInput.setPreferredSize(d); inGameInput.setMinimumSize(d); inGameInput.setMaximumSize(d);

JPanel nothing = new JPanel(); ??

JPanel results = new JPanel(); ??

JPanel placeArmies = new placeArmiesPanel(); ??

roll = new rollPanel();

JPanel move = new movePanel(); JPanel attack = new attackPanel(); defend = new defendPanel(); ??

// ################### IN GAME ####################### this.setLayout(new java.awt.GridBagLayout()); GridBagConstraints c = new GridBagConstraints(); c.insets = new java.awt.Insets(3, 3, 3, 3); c.fill = GridBagConstraints.BOTH; c.gridx = 0; // col c.gridy = 0; // row

c.gridwidth = 1; // width c.gridheight = 1; // height this.add(gameOptions, c); c.gridx = 0; // col c.gridy = 1; // row

c.gridwidth = 1; // width c.gridheight = 1; // height this.add(pp, c);

c.gridx = 0; // col c.gridy = 2; // row

c.gridwidth = 1; // width c.gridheight = 1; // height this.add(inGameInput, c);

}

第35页 共41页

图4-12 控制台面板

图4-13 统计面板

本文来源：https://www.bwwdw.com/article/ta8g.html