连连看游戏设计报告

武汉工程大学
计算机科学与工程学院综合设计报告
设计名称：系统软件综合设计
设计题目：手机连连看游戏设计与实现
学生学号：1005090222
专业班级：2010级计算机科学与技术
（计算机科学方向）02班
学生姓名：杨星
学生成绩：
指导教师（职称）：徐银霞（讲师）
课题工作时间：2013.12.30 至2014.1.10
成绩评定表
学生姓名：杨星学号：1005090222 班级：计算机科学02班
答辩记录表
指导教师评语
目录
摘要 (II)
Abstract (III)
第一章课题背景 (1)
1.1 课题背景 (1)
1.2 设计要求 (1)
第二章设计方案论述 (3)
2.1 需求分析 (3)
2.2 模块设计 (3)
第三章详细设计 (5)
3.1 开发环境 (5)
3.2 算法描述 (5)
3.3 类的设计 (7)
第四章设计结果及分析 (9)
4.1 游戏启动测试 (9)
4.2 游戏过程测试 (9)
4.3 游戏结束测试 (10)
总结 (12)
致谢 (13)
参考文献 (14)
附录主要程序代码 (15)
摘要
连连看是一款经典的休闲游戏，将相同的两个图案以三根以内的线连接起来即可消除，规则简单易上手,游戏节奏快，不失乐趣，适合广大人群。

这里设计的连连看游戏实现在windows phone 8手机平台上。

旨在熟悉其基本的开发模式，了解手机平台应用开发与PC平台的不同之处，感受移动平台独特的特性。

作为手机游戏，操作直观，随时随地可进行游戏，更加方便快捷。

游戏实现计时，提示，重新开始等基本功能。

游戏核心算法为计算两个相同图案之间的最短路径。

分图案相邻和不相邻情况。

对于相邻图案直接可消除，对于不相邻图案，通过特定算法求解，寻求最短路径。

失败则无法消除。

游戏基于.NET平台，以Visual Studio Express For Windows Phone工具开发，采用Silverlight框架，用C#程序设计语言设计。

经测试可运行在windows phone 8手机上。

关键词：
连连看；手机游戏；windows phone
Abstract
Snake is a classic casual game.The same two patterns which can be connected within three lines can be eliminated. The rules are simple and approachable and the game is fast-paced,funny, For the majority of the crowd.The game is designed on windows phone 8 mobile platforms. It’s designed to be familiar with the basic pattern of development on windows phone and understand deferecess between PC and moblie platform.Feel the unique characteristics of the mobile platform. As a moblie game, intuitive operation,faster and more convenient,it can be played anywhere.The game must has timing,tips, resumes, and other basic functions. The core algorithm is to calculate the shortest path between two identical patterns.It despites Adjacent and non-adjacent patterns. The adjacent patterns is directly eliminated,where a specific algorithm is needed to seek the shortest path for non-adjacent patterns.If failed,it means patterns are unable to be eliminated.The Game is based on .NET platform,Silverlight framwork and designed by Visual Studio Express For Windows Phone with C# programming language. After testing,the game can be run on windows phone 8 phone.
Keywords:
Snake;moblie game;windows phone
第一章课题背景
1.1课题背景
游戏“连连看”顾名思义就是找出相关联的东西，这个连连看在网上基本是用在小游戏中，就是找出相同的两样东西，在一定的规则之内可以做为相关联处理。

“连连看”的发展经历了从桌面游戏、在线游戏、社交游戏三个过程。

游戏“连连看”是源自台湾的桌面小游戏，自从流入大陆以来风靡一时，也吸引众多程序员开发出多种版本的“连连看”。

这其中，顾方编写的“阿达连连看”以其精良的制作广受好评，这也成为顾方“阿达系列软件”的核心产品。

并于2004年，取得了国家版权局的计算机软件著作权登记证书。

随着Flash应用的流行，网上出现了多种在线Flash版本“连连看”。

如“水晶连连看”、“果蔬连连看”等，流行的“水晶连连看”以华丽界面吸引了一大批的女性玩家。

2008年，随着社交网络的普及和开放平台的兴起，“连连看”被引入了社交网络。

“连连看”与个人空间相结合，被快速的传播，成为一款热门的社交游戏，其中以开发者Jonevey在Manyou开放平台上推出的“宠物连连看”最为流行。

网络小游戏、网页游戏越来越受网民欢迎，除了玩的方法简单外（不像其他游戏还需要注册下载繁琐过程），很多游戏不乏经典。

连连看游戏就是典型。

不管走到哪个网页游戏网站，连连看游戏总是排在受玩家欢迎排名的前5位，休闲、趣味、益智是连连看玩不厌的精华，且不分男女老少、工薪白领，是一款适合大众的经典网络、单机休闲小游戏。

Windows Phone具有桌面定制、图标拖拽、滑动控制等一系列前卫的操作体验。

其主屏幕通过提供类似仪表盘的体验来显示新的电子邮件、短信、未接来电、日历约会等，让人们对重要信息保持时刻更新。

它还包括一个增强的触摸屏界面，更方便手指操作；以及一个最新版本的IE Mobile浏览器——该浏览器在一项由微软赞助的第三方调查研究中，和参与调研的其它浏览器和手机相比，可以执行指定任务的比例超过48%。

Windows Phone，力图打破人们与信息和应用之间的隔阂，提供适用于人们包括工作和娱乐在内完整生活的方方面面，最优秀的端到端体验。

随着手机用户的日益剧增，手机《连连看》已成为游戏爱好者，娱乐休闲的游戏之一，连连看游戏操作简单易玩，规则简单容易上手。

游戏速度节奏快，画面清晰可爱，适合细心的玩家。

丰富的道具和公共模式的加入，增强游戏的竞争性。

多样式的地图，使玩家在各个游戏水平都可以寻找到挑战的目标，长期地保持游戏的新鲜感。

Windows Phone作为一款全新的系统，它新颖而独特，其开发模式也有较大不同，引入了许多新的概念。

在该平台上实现连连看小游戏是一项新的尝试，旨在了解其基本开发模式及框架，对该平台下的应用开发有初步的认知。

1.2 设计要求
设计实现连连看游戏的基本功能，主要解决的问题有以下几个方面：
游戏界面设计，游戏整体界面生动友好，整体视觉感受舒服。

游戏开始时，随机生成图案，要求相同图案个数为偶数个，初始必须存在至少一对
可消除图案。

游戏过程中，判断用户选择的两个图案是否能够消除，如果能够消除则给出最短消除路径。

游戏具备提示功能，即用户可以寻求提示，程序给出可消除的一对图案。

游戏结束规则为计时结束，游戏失败或全部图案消除完成，游戏获胜。

游戏具备重新开始，暂停等基本功能。

第二章设计方案论述
2.1 需求分析
用户进入游戏时，默认开始一局新游戏。

程序会载入图案，通过特定算法排列生成图案列表。

该列表是合法的，即初始状态存在至少一对可消除图案，并且每种图案为偶数个。

同时游戏显示剩余待消除图案总数，游戏开始计时，计时条不断缩短。

游戏中用户点击一个图案时，图案呈现被选中状态。

等待用户选择第二个图案时，判断图案是否能够消除。

如果不能消除则取消选中，如果能够消除，则给出最短路径图示，然后消除图案。

用户可以通过底部的刷新按钮来重新开始一局游戏。

在游戏中如果遇到困难可点击底部的提示按钮，程序将提示一对可消除的图案。

同时游戏具备道具功能，点击底部的地雷按钮，可自动消除一对图案。

以上功能按钮都有3次使用次数限制。

用户可点击手机的Back键来主动结束并退出游戏。

游戏的胜负判定规则为，如果计时条计时完毕尚存在图案未消除，则游戏失败。

如果用户在计时结束前消除了全部图案，则游戏胜利。

2.2 模块设计
根据对“连连看”游戏的分析，该游戏可分为三个模块：算法模块、界面显示模块、菜单控制模块。

如图2.1所示。

图2.1 游戏模块图
算法模块主要实现两个算法：图案的产生设计和图片路径处理设计。

图案的产生设计采用随机数算法，按照偶数对图案规则来生成图案列表，然后寻找是否存在一对可消除的图案，如果不存在则称为“死锁”，即游戏一开始就无法进行下去，此时重新随机生成图案直到生成合法的图案列表。

然后呈现出来，开始计时，游戏开始。

图片路径处理设计分两种情况考虑。

用户选择的两个图案不同，则无法消除，取消选中。

当用户选择
两个相同图案时，如果两个图案相邻，则直接消除；如果不相邻，则按广度优先算法寻找两个图案之间的最短路径。

如果成功，则显示最短路径并消除图案；如果失败则无法消除，取消选中。

菜单模块显示基本的游戏控制及道具辅助功能。

游戏控制菜单包括计数，计时功能。

计数器显示当前存在的待消除图案总个数，提醒用户剩余数量。

计时器采用倒数计时，以计时条的形式显示，随着时间计时条变短。

道具辅助功能包括三个按钮。

刷新按钮可重新开始一局游戏。

地雷按钮可自动消除一对可消除的图案。

提示按钮可提示一对可消除图案的路径。

界面显示模块表现整体界面布局。

计时条以及计数器在顶部显示，底部显示三个辅助道具按钮。

中间为游戏区域，规模为8x11大小的图案矩阵。

图案采用不同颜色的豆豆，较为直观可爱。

用户选中图案时，图案会呈现选中状态，消除过程中会显示虚线形式的消除路径。

游戏启动过程中，会显示开发者信息画面形成过渡。

游戏具备完整的游戏图标及不同尺寸的磁贴。

第三章详细设计
3.1 开发环境
微软的Windows Phone平台在界面展示方面采用了新的Metro概念，Metro的意思是地铁。

在这个平台上的意思就是，希望大家在类似地铁中、飞机场等人群比较多的地方能够很容易的按照一些简单的指示图到达自己想要到的地方，讲究简洁、易懂。

因此微软在Windows Phone中引入这个概念目的就是能够以最简单的方式表达给用户最想知道的信息。

全景视图是微软Windows Phone区别于其他开发平台的有一大亮点，从这一点上就可以看出微软在用户体验方面下了很大的功夫。

之前，用户如果浏览更多的信息时往往会在几个页面中来回切换，浪费了大家选择的时间和精力，但是这个浏览方式很方便的让用户通过左右滑动就可以继续查看自己想要看的内容。

微软在用户体验方面极大的满足了消费者的需求，在开发者方面通过提供统一的硬件设备，易用的开发工具以及丰富的开发文档，极大的缩短了开发者的开发周期，而且上手非常的容易。

游戏设计为在windows phone 8平台下运行，采用微软官方开发工具Visual Studio 2012 Express For Windows Phone SDK进行开发。

该工具集成了windows phone模拟器，并自带Visual Studio 2012 Express版开发工具。

同时利用windows 8自带的Hyper-v虚拟机模拟windows phone系统，方便调试程序。

游戏基于.NET平台，采用Silverlight框架进行开发。

以xaml语言描述游戏界面，C#程序设计语言书写游戏逻辑。

3.2 算法描述
在检验两个方块能否消掉的时候，我们要让两个方块同时满足两个条件才行，就是两者配对并且连线成功。

如图所示
分 3 种情况：从下面的这三种情况，我们可以知道，需要三个检测，这三个检测分别检测一条直路经。

这样就会有三条路经。

若这三条路经上都是空按钮，那么就刚好是三种直线（两个转弯点）把两个按钮连接起来了。

相邻图案可直接消除。

若不相邻的先在第一个按钮的同行找一个空按钮。

找到后看第二个按钮横向到这个空按钮所在的列是否有按钮。

没有的话再看第一个按钮到与它同行的那个空按钮之间是否有按钮。

没有的话，再从与第一个按钮同行的那个空按钮竖向到与第二个按钮的同行看是否有按钮。

没有的话路经就通了可以消了。

若上一步失败后，再在第一个按钮的同列找一个空按钮。

找到后看第二个按钮竖向到这个空按钮所在的行是否有按钮没有的话，再看第一个按钮到与它同列的那个空按钮之间是否有按钮。

没有的话，再从与第一个按钮同列的那个空按钮横向到与第二个按钮同列看是否有按钮。

没有的话路经就通了，可以消了。

若以上两步都失败，说明这两个按钮不可以消去。

具体判断流程见下图。

图3.1 流程图
将图片成对的显示在场景中，运用一个数组以数字标记的形式来记录加载的图片是哪种图片，在每次加载图片的时候是一张图片连续加载两次，以保证加载图片成对。

然后用数组的随机方法将数组打乱。

判断两图是否能够相连，两图能相连的所有情况：
(1)(2)
(3)
图3.2 图案相连情况
3.3 类的设计
游戏主要功能实现被分为两个类。

MainPage.xaml用来描述游戏界面，其映射到MainPage类，该类实现菜单模块和界面模块。

算法模块则在Game类实现。

MainPage页面是程序启动后展示的主页面，MainPage类定义了界面所有控件的表现方式及其行为。

该类用SlideBar控件实现计时条，通过类库中的计时器类来计时，并更新SlideBar的值，以实现计时功能。

计数器采用图片控件，将数字以预先设计好的图片形式显示出来。

整个游戏区域为一块画布，采用Canvas容器控件绝对布局。

每个图案为一个图片控件，以方阵形式显示在画布中，构成8x11大小的图案矩阵。

图案为不同颜色的豆豆，其选中状态为添加暗色背景。

底部道具按钮皆采用图片控件表现。

MainPage类实现了所有的UI及其变化形式，以及UI与逻辑的交互功能。

对于用户的操作，MainPage类响应对应操作的行为，并调用Game类公开的方法进行逻辑处理，根据处理结果更新游戏界面信息。

Game类实现了游戏过程控制，整个游戏逻辑由该类控制。

其控制游戏计时，计数，响应道具按钮的功能。

实现游戏的主要算法。

图案的产生设计和图案的最短路径求取都在该类实现。

Game类对外公开一系列方法：刷新，提示，计时，计数，判断能否消除，判断游戏是否结束等，供MainPage类调用。

类的设计遵循MVVM模式基本思想。

界面与逻辑相分离。

界面描述采用xaml纯界面描述语言设计，界面控制在其对应的类MainPage中实现。

Game类实现逻辑。

MainPage 类实现了逻辑与界面的联系。

整个工程项目结构如图所示。

其中Assets下为游戏程序图标，images文件夹存放游戏界面所有图片资源。

App类控制应用程序生命周期，由编译工具自动生成。

LocalozedString类处理国际化语言相关问题，不在本设计讨论范围之内。

SplashScreenImage是游戏启动画面。

图3-3 项目工程
第四章设计结果及分析
4.1 游戏启动测试
代码编写完毕后，在windows phone虚拟机上进行游戏测试。

以下模拟的是WVGA 512RAM模式下的测试。

开始游戏后，游戏启动画面展示游戏名称，开发信息。

如图4.1所示。

进入游戏画面，默认开始一局新游戏，如图4.2所示。

游戏可以正常进行，计时条会显示倒计时，计数器显示剩余图案数目。

从测试截图中可以看到，游戏正常启动，在启动画面展示完毕后正常开始了一局新游戏。

游戏随机生成了消除图案列表，玩家可以找到两两配对的图案进行消除。

图4.1 启动画面图4.2 游戏开始界面
4.2 游戏过程测试
在游戏过程中，随着时间的变化，计时条不断的缩短，提示着玩家剩余时间。

右上角的计数器随着玩家消除图案不断减小，记录着剩余图案的数目。

当玩家选择两个可消
除的图案时，图案呈现选中状态，并显示最短虚线路径，随后图案消失。

经过观察，程序所给出的最短路径皆是合法的。

随着游戏的进行，玩家如果需要寻求帮助，可点击右下角的提示按钮，程序正确的给出了提示可消除的两个图案的之间的最短路径提示。

而玩家点击地雷按钮时，则会直接消除一对可消除的图案。

游戏左下角为重新开始按钮，点击之后程序放弃当前游戏，重新开始了一局新游戏。

并且以上按钮每点击一次后，按钮计数减一。

当计数为0时，点击该按钮将不再实现对应功能。

限制了玩家寻求帮助次数，增加游戏乐趣。

游戏过程与设计要求一致，并未出现异常情况，三个道具辅助功能按钮也正确的实现了相应的功能。

图4.3 游戏过程图4.4 底部按钮功能
4.3 游戏结束测试
在计时条结束前，玩家消除了游戏区域所有的图案，游戏提示胜利。

可以看到此时右上角剩余图案计数为0。

而如果计时结束，游戏区域尚存在图案，游戏提示失败。

程序正确的给出了游戏胜负的判定。

结果如下图所示。

图4.5 游戏胜利图4.6 游戏失败
总结
通过此次课程设计，使我更加扎实的掌握了有关软件设计方面的知识，在设计过程中虽然遇到了一些问题，但经过一次又一次的思考，一遍又一遍的检查终于找出了原因所在，也暴露出了前期我在这方面的知识欠缺和经验不足。

实践出真知，通过亲自动手制作，使我们掌握的知识不再是纸上谈兵。

在课程设计过程中，我们不断发现错误，不断改正，不断领悟，不断获龋最终的检测调试环节，本身就是在践行“过而能改，善莫大焉”的知行观。

这次课程设计终于顺利完成了，在设计中遇到了很多问题，最后在小组成员的积极讨论分析下，终于游逆而解。

在今后社会的发展和学习实践过程中，一定要不懈努力，不能遇到问题就想到要退缩，一定要不厌其烦的发现问题所在，然后一一进行解决，只有这样，才能成功的做成想做的事，才能在今后的道路上劈荆斩棘，而不是知难而退，那样永远不可能收获成功，收获喜悦，也永远不可能得到社会及他人对你的认可。

此次课程设计，从理论到实践，在这段日子里，可以说得是苦多于甜，但是可以学到很多很多的东西，同时不仅可以巩固了以前所学过的知识，而且学到了很多在书本上所没有学到过的知识。

通过这次课程设计使我懂得了理论与实际相结合是很重要的，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，从理论中得出结论，才能真正为社会服务，从而提高自己的实际动手能力和独立思考的能力。

在设计的过程中遇到问题，可以说得是困难重重，但可喜的是最终都得到了解决。

实验过程中，也对团队精神的进行了考察，让我们在合作起来更加默契，在成功后一起体会喜悦的心情。

果然是团结就是力量，只有互相之间默契融洽的配合才能换来最终完美的结果。

致谢
首先我要感谢我的老师在课程设计上给予我的指导、提供给我的支持和帮助，这是我能顺利完成这次报告的主要原因，更重要的是老师帮我解决了许多技术上的难题，让我能把系统做得更加完善。

在此期间，我不仅学到了许多新的知识，而且也开阔了视野，提高了自己的设计能力。

其次，我要感谢我的小组成员。

设计过程中遇到很多问题，他们发现并改成了我所忽视的错误。

他们及时的完成了自己的分工，并对我所负责的部分给予莫大的帮助，让我少走了很多弯路。

如果不是他们的帮助，相信很难在两周时间内顺利地完成这次课程设计。

同时在他们身上，学会了什么是团队合作精神。

课程设计的成功离不开团队成员的合作。

总之，如果没有老师和同学的热心帮助，我一个人无法完成任务。

再次对我的老师和同学们，表示诚挚的谢意。

参考文献
[1]林政．深入浅出Windows Phone 8 应用开发[M] ．北京：清华大学出版社，2010．200-205．
[2]李晓洁．手机游戏开发全书[M]．北京：清华大学出版社，2005．307-314．
[3]张德富．算法设计与分析[M]．北京：国防工业出版社，2009．105-110．
[4]周家安．Windows Phone 8 开发技巧与案例精解[M]．北京：机械工业出版社，2013.450-461．
附录主要程序代码using System;
using System.Collections.Generic;
using System.Windows;
namespace LianLianKan
{
public class Game
{
private const int GAME_MODE_LEVEL = 1;
private const int GAME_MODE_CHALLENGE = 2;
private const int GAME_LEVEL_DEFAULT = 12;
private const int GAME_LEVE_MIN = 1;
private const int GAME_LEVEL_MAX = 12;
private const int RANDOM_EXCHANGE_TIME = 200;
private int rowAmount;
private int columAmount;
private int blockType;
private int[,] gameZoneMatrix;
private int gameMode;
private int gameLevel;
private int blockAmount;
private int finishBlockAmount;
private double remainTime;
private int score;
private int refreshTime;
private int bombTime;
private int remindTime;
private int REFRESH_TIME = 3;
private int BOMB_TIME = 3;
private int REMIDN_TIME = 3;
public Game(int rowAmount, int columAmount, int blockType)
{
this.rowAmount = rowAmount;
this.columAmount = columAmount;
this.blockType = blockType;
this.initGameBasicInfo(1, 12);
this.initGameZoneMatrix();
this.initUserGameInfo();
}
private void initGameBasicInfo(int gameMode, int gameLevel)
{
this.gameMode = gameMode;
this.gameLevel = gameLevel;
this.blockAmount = 30 + 4 * gameLevel;
}
private void initGameZoneMatrix()
{
this.gameZoneMatrix = new int[this.rowAmount, this.columAmount];
this.clearGameZoneMatrix();
this.randomArrangeValuePairInGameZoneMatrix();
this.randomExchangeValuePointInGameZoneMatrix();
}
private void clearGameZoneMatrix()
{
for (int i = 0; i < this.rowAmount; i++)
{
for (int j = 0; j < this.columAmount; j++)
{
this.gameZoneMatrix[i, j] = 0;
}
}
}
private void randomArrangeValuePairInGameZoneMatrix()
{
Random random = new Random();
int num = this.blockAmount / 2;
int num2 = 1;
int num3 = 1;
int num4 = this.rowAmount / 2;
for (int i = 1; i <= num; i++)
{
int num5 = random.Next() % this.blockType + 1;
this.gameZoneMatrix[num2, num3] = num5;
this.gameZoneMatrix[num4, num3] = num5;
num3++;
if (num3 >= this.columAmount - 1)
{
num3 = 1;
num2++;
num4++;
}
}
}
private void randomExchangeValuePointInGameZoneMatrix()
{
Random random = new Random();
int num = this.rowAmount - 2;
int num2 = this.columAmount - 2;
for (int i = 1; i <= 200; i++)
{
int num3 = random.Next() % num + 1;
int num4 = random.Next() % num2 + 1;
int num5 = random.Next() % num + 1;
int num6 = random.Next() % num2 + 1;
int num7 = this.gameZoneMatrix[num3, num4];
this.gameZoneMatrix[num3, num4] = this.gameZoneMatrix[num5, num6];
this.gameZoneMatrix[num5, num6] = num7;
}
}
private void initUserGameInfo()
{
this.finishBlockAmount = 0;
this.remainTime = 100.0;
this.score = 0;
this.refreshTime = this.REFRESH_TIME;
this.bombTime = this.BOMB_TIME;
this.remindTime = this.REMIDN_TIME;
}
public int[,] getGameZoneMatrix()
{
return this.gameZoneMatrix;
}
public int getFinishBlockAmount()
{
return this.finishBlockAmount;
}
public double getRemainTime()
{
return this.remainTime;
}
public int getScore()
{
return this.score;
}
public int getRefreshTime()
{
return this.refreshTime;
}
public int getBombTime()
{
return this.bombTime;
}
public int getRemindTime()
{
return this.remindTime;
}
public int getRemainBlockAmount()
{
return this.blockAmount - this.finishBlockAmount;
}
public List<Point> findPathBetweenPoints(Point startPoint, Point endPoint)
{
List<Point> list = new List<Point>();
if (this.isTwoPointsOwnTheSameValue(startPoint, endPoint))
{
list = this.findPathInLine(startPoint, endPoint);
if (list.Count == 0)
{
list = this.findPathInRectangle(startPoint, endPoint);
if (list.Count == 0)
{
list = this.findPath(startPoint, endPoint);
}
}
}
return list;
}
private bool isTwoPointsOwnTheSameValue(Point point1, Point point2)
{
int num = (int)point1.X;
int num2 = (int)point1.Y;
int num3 = (int)point2.X;
int num4 = (int)point2.Y;
bool result = false;
if (this.gameZoneMatrix[num, num2] == this.gameZoneMatrix[num3, num4]) {
result = true;
}
return result;
}
private List<Point> findPathInLine(Point startPoint, Point endPoint)
{
List<Point> list = new List<Point>();
if (this.isTwoPointsInLine(startPoint, endPoint))
{
if (this.canTwoPointsBeConnected(startPoint, endPoint))
{
list.Add(startPoint);
list.Add(endPoint);
}
}
return list;
}
private List<Point> findPathInRectangle(Point startPoint, Point endPoint) {
List<Point> list = new List<Point>();
int num = (int)startPoint.X;
int num2 = (int)startPoint.Y;
int num3 = (int)endPoint.X;
int num4 = (int)endPoint.Y;
Point point = new Point((double)num, (double)num4);
Point point2 = new Point((double)num3, (double)num2);
if (this.canThreePointsBeConnected(startPoint, endPoint, point))
{
list.Add(startPoint);
list.Add(point);
list.Add(endPoint);
}
else
{
if (this.canThreePointsBeConnected(startPoint, endPoint, point2))
{
list.Add(startPoint);
list.Add(point2);
list.Add(endPoint);
}
}
return list;
}
private List<Point> findPath(Point startPoint, Point endPoint)
{
List<Point> list = new List<Point>();
List<Point> list2 = new List<Point>();
Point[] xPointArrayOfPoint = this.getXPointArrayOfPoint(startPoint);
Point[] yPointArrayOfPoint = this.getYPointArrayOfPoint(startPoint);
Point[] xPointArrayOfPoint2 = this.getXPointArrayOfPoint(endPoint);
Point[] yPointArrayOfPoint2 = this.getYPointArrayOfPoint(endPoint);
int pointPairDistanceInXAxis = this.getPointPairDistanceInXAxis(xPointArrayOfPoint, xPointArrayOfPoint2, startPoint, endPoint, list);
int pointPairDistanceInYAxis = this.getPointPairDistanceInYAxis(yPointArrayOfPoint, yPointArrayOfPoint2, startPoint, endPoint, list2);
List<Point> result;
if (list.Count > 0 && list2.Count > 0)
{
if (pointPairDistanceInXAxis <= pointPairDistanceInYAxis)
{
result = list;
}
else
{
result = list2;
}
}
else
{
if (list.Count > 0 && list2.Count == 0)
{
result = list;
}
else
{
if (list.Count == 0 && list2.Count > 0)
{
result = list2;
}
else
{
result = new List<Point>();
}
}
}
return result;
}
private Point[] getXPointArrayOfPoint(Point point)
{
int num = (int)point.X;
int num2 = (int)point.Y;
Point[] array = new Point[this.rowAmount];
array[num] = this.generateEmptyPoint();
bool flag = false;
for (int i = num - 1; i >= 0; i--)
{
if (flag)
{
array[i] = this.generateEmptyPoint();
}
else
{
if (this.gameZoneMatrix[i, num2] != 0)
{
flag = true;
array[i] = this.generateEmptyPoint();
}
else
{
array[i] = new Point((double)i, (double)num2);
}
}
}
flag = false;
for (int i = num + 1; i < this.rowAmount; i++)
{
if (flag)
{
array[i] = this.generateEmptyPoint();
}
else
{
if (this.gameZoneMatrix[i, num2] != 0)
{
flag = true;
array[i] = this.generateEmptyPoint();
}
else
{
array[i] = new Point((double)i, (double)num2);
}
}
}
return array;
}
private Point[] getYPointArrayOfPoint(Point point)
{
int num = (int)point.X;
int num2 = (int)point.Y;
Point[] array = new Point[this.columAmount];
array[num2] = this.generateEmptyPoint();
bool flag = false;
for (int i = num2 - 1; i >= 0; i--)
{
if (flag)
{
array[i] = this.generateEmptyPoint();
}
else
{
if (this.gameZoneMatrix[num, i] != 0)
{
flag = true;
array[i] = this.generateEmptyPoint();
}
else
{
array[i] = new Point((double)num, (double)i);
}
}
}
flag = false;
for (int i = num2 + 1; i < this.columAmount; i++)
{
if (flag)
{
array[i] = this.generateEmptyPoint();
}
else
{
if (this.gameZoneMatrix[num, i] != 0)
{
flag = true;
array[i] = this.generateEmptyPoint();
}
else
{
array[i] = new Point((double)num, (double)i);
}
}
}
return array;
}
private int getPointPairDistanceInXAxis(Point[] startPointArray, Point[] endPointArray, Point startPoint, Point endPoint, List<Point> pointPathList)
{
int num = (int)startPoint.X;
int num2 = (int)endPoint.X;
int num3 = 10000;
Point point = default(Point);
Point point2 = default(Point);
bool flag = false;
for (int i = 0; i < this.rowAmount; i++)
{
Point point3 = startPointArray[i];
Point point4 = endPointArray[i];
if (!this.isEmptyPoint(point3) && !this.isEmptyPoint(point4))
{
if (this.canTwoPointsBeConnected(point3, point4))
{
flag = true;
int num4 = Math.Abs(i - num) + Math.Abs(i - num2);
if (num3 > num4)
{
num3 = num4;
point = point3;
point2 = point4;
}
}
}
}
int result;
if (flag)
{
pointPathList.Add(startPoint);
pointPathList.Add(point);
pointPathList.Add(point2);
pointPathList.Add(endPoint);
result = num3;
}
else
{
result = -1;
}
return result;
}
private int getPointPairDistanceInYAxis(Point[] startPointArray, Point[] endPointArray, Point startPoint, Point endPoint, List<Point> pointPathList)
{
int num = (int)startPoint.Y;
int num2 = (int)endPoint.Y;
int num3 = 10000;
Point point = default(Point);
Point point2 = default(Point);
bool flag = false;
for (int i = 0; i < this.columAmount; i++)
{
Point point3 = startPointArray[i];
Point point4 = endPointArray[i];
if (!this.isEmptyPoint(point3) && !this.isEmptyPoint(point4))
{
if (this.canTwoPointsBeConnected(point3, point4))
{
flag = true;
int num4 = Math.Abs(i - num) + Math.Abs(i - num2);
if (num3 > num4)
{
num3 = num4;
point = point3;
point2 = point4;
}
}
}
}
int result;
if (flag)
{
pointPathList.Add(startPoint);
pointPathList.Add(point);
pointPathList.Add(point2);
pointPathList.Add(endPoint);
result = num3;
}
else
{
result = -1;
}
return result;
}
private bool canThreePointsBeConnected(Point startPoint, Point endPoint, Point tempPoint)
{
int num = (int)tempPoint.X;
int num2 = (int)tempPoint.Y;
bool result = false;
if (this.gameZoneMatrix[num, num2] == 0)
{
if (this.canTwoPointsBeConnected(startPoint, tempPoint) && this.canTwoPointsBeConnected(tempPoint, endPoint))
{
result = true;
}
}
return result;
}
private bool canTwoPointsBeConnected(Point point1, Point point2)
{
int num = (int)point1.X;
int num2 = (int)point1.Y;
int num3 = (int)point2.X;
int num4 = (int)point2.Y;
bool result = true;
if (num == num3)
{
int num5 = num;
int num6;
int num7;
if (num2 > num4)
{
num6 = num4 + 1;
num7 = num2;
}
else
{
num6 = num2 + 1;
num7 = num4;
}
for (int i = num6; i < num7; i++)
{
if (this.gameZoneMatrix[num5, i] != 0)
{
result = false;
break;
}
}
}
else
{
int num8 = num2;
int num9;
int num10;
if (num > num3)
{
num9 = num3 + 1;
num10 = num;
}
else
{
num9 = num + 1;
num10 = num3;
}
for (int i = num9; i < num10; i++)
{
if (this.gameZoneMatrix[i, num8] != 0)
{
result = false;
break;
}
}
}
return result;
}
public void refreshGameZoneMatrix()
{
this.randomExchangeValuePointInGameZoneMatrix(); }
public List<Point> findPathOfRandomBlockPair()
{
Random random = new Random();
List<Point> list = new List<Point>();
do
{
List<Point> list2 = new List<Point>();
do
{
int type = random.Next() % this.blockType + 1;
list2 = this.getPointListOfCertainType(type);。