PieTTY/pputty/PuTTY 是什麼?

PuTTY 是個小巧方便的 Telnet/SSH 安全遠端連線程式， 但用於非英語系文字時有非常多的問題， 而且它對於初學者來說過於複雜的使用界面也為人詬病已久。 PieTTY 則是源自於 PuTTY ，修正與完整支援亞洲等多國語系字元、 並在使用界面上大幅改進、易學易用的版本。

PieTTY is a free SSH client based on PuTTY and dedicated to multilingual (especially CJK) environments, accessibility, and simpler user interface.

PieTTY 使用 MIT License, 是免費而可自由重新散佈的。 更詳細的歷史或是使用上有問題請見 FAQ 。 關於 PieTTY 為何要支援「Unicode 補完計畫」請見 FAQ。

關於新版的開發

PieTTY 目前仍然常收到各種建議與錯誤報告， 非常感謝大家； 不過除非有安全性的重大錯誤要修正， 否則短時間內 0.3 不會再發行新版， 因為目前要專注在「幫 PuTTY 加上分頁」這項大工程； 完成後會把修正送回官方 PuTTY。 不過這項工程由於實在太大， 暫時也無法估計所需時間。 所以這段期間就請大家繼續使用 0.3.27。

PieTTY 的特色

PieTTY 0.3 系列是修改自 PuTTY 0.57/0.58 的版本，以穩定與修正為主。 主要的特色有:

• 簡單易用的界面(中英文合一)。 主要的功能都可從選單存取
• 完全相容於傳統 PuTTY，之前的設定全部可直接使用
• 更強的連線整合管理(session management)， 自動儲存設定
• 高度可自訂化(customizable)的視窗顯示效果
• 完整而方便切換的多國語言支援
• 半透明顯示(多種顯示引擎以配合各種硬體配備與視窗立體陰影，配合無框顯示模式效果奇佳 (0.3.27)
• 支援 ssh:// 式的呼叫，可整合系統設定為 ssh:// 與 telnet:// 處理程式(0.3.27)
• 對於各種網址 URL 可直接點選開啟，還有各種可選用的視覺效果
• 支援拖曳檔案 (Drag-n-drop) 即可 SCP 上傳

• 可使用英文等其它字型，而且不用設定字元集(CHARSET) (傳統 PuTTY 則一定要設定正確才行)
• 在非 UTF8 模式下 PieTTY 的游標也能正確顯示 (傳統 PuTTY 會破壞游標上的多位元字元組如Big5中文)
• 重繪螢幕完全不閃動 (PuTTY 在非 UTF8 會閃)

• 內建 Big5-2003 + 中國海字集、 相容Unicode補完計畫2.40版字碼表，免裝 Unicode 補完即可正常剪貼或輸入日文等(0.3.27)
• 內建簡單的漢字(簡繁)轉換，方便閱讀(0.3.27)
• 支援一字雙色的ANSI碼 (台灣 BBS 特有文化)
• 複製文字時可自動將屬性顏色以 ANSI 碼或 IRC 形式加入(0.3.27)， BBS 與 IRC 互貼彩色不是夢！

關於作者 About The Author

Hung-Te Lin 林弘德, 網路上常用的代號是 piaip。
PieTTY 是我自己平日連線到 Solaris 工作站上的必需品， 所以起碼有一個人每天在對最新版做測試 ^^; 也所以，只要有 bug 或是問題，我都會盡量想辦法解決 （尤其是我自己使用上會需要的）。 如果對這個計畫有任何意見， 也歡迎用 email 與我聯絡!

如今却非常热爱软件测试，包括软件测试工具，方法，理论，技术。因为我在3年的测试工作中，深刻体会到软件测试的重要性和趣味性。此时，我已经跳出了“小程序员”的圈子，以软件系统工程的更大视角审视软件测试这项工作。

很长时间以来我一直被下面的问题而困惑，有些问题至今仍然只是具有肤浅的认识，而且，我感觉我做的测试项目越多，阅读的测试书籍越多，我越感到我对软件测试理解的越肤浅。因为我越来越感受到软件测试的广度和深度的无限性，它像大海宽广，像宇宙那样深邃。 为什么要进行软件测试？软件测试的前途如何？软件测试的工具和思想谁更重要？软件测试的最高境界是什么？

软件测试是保证软件质量的重要活动，是软件项目实施的不可缺少的环节。软件测试的直接目的是发现软件中存在的缺陷。此为测试的有效性。

在软件项目没有结束之前的全部软件缺陷主要由软件开发人员负责，因为软件缺陷来自程序员的编程。软件项目结束后的软件缺陷主要由软件测试人员负责，因为软件测试人员没有在软件发布之前的测试中没有发现隐藏的错误。 但这不是绝对的，因为软件项目是一个系统工程，软件质量牵扯到多个部门和人员，以及需求分析，设计，编码等各个环节和过程。软件测试只能证明软件存在缺陷，不能保证软件没有错误。

软件测试不是万能的，因为不可能发现全部的软件缺陷，而且软件的功能和性能不是由测试决定的。此为测试的有限性。

软件测试目前主要以手工测试为主，自动测试工具虽然很多，但实际应用的广度和深度还有很大潜力，自动将有很大的发展空间！。

软件驱动开发的观点说明了测试与编程的关系，测试应该贯穿于软件开发的整个生命周期，编程只是软件开发的一个环节。但往往大家非常重视软件编程，把测试作为编程后的一个辅助环节。这是典型的本末倒置。 软件测试的缺陷管理流程非常重要，报告的软件缺陷的质量，应该由他人验证，做到责任明确，方法简便可行。

软件测试技术不断进步，但总体来看，国内的测试重视程度还不够，但已经发展很快。差不多两年之前，国内计算机书店中关于软件测试的书籍非常稀少，如今却琳琅满目，异彩纷呈。

软件测试是个可以很快入门的职业，门槛不高，但是，不要认为什么人都可以做好软件测试。因为会做和做好是两个概念。软件测试人员最好具有软件开发经验，理解软件工程的知识。这是提高软件测试能力的基础。对于刚刚毕业的学生，如果希望今后从事软件开发，那么，先从事一段时间的测试可能更有利于今后的编程。而对于具有多年编程经验的程序员，如果改行做测试，更容易提高技术。 软件测试不是孤立的活动或过程，需要开发和市场人员的参与和交流，需要软件质量保证人员SQA的积极配合和沟通。

软件测试的技术不断进步，与具体测试技术相比，掌握测试的核心思想比具体技术更重要！测试的最高境界在于运用最简单有效的测试技术，最大限度的发现软件缺陷!

应当承认，目前国内的软件测试工程师的地位和待遇仍然很低，而且不少测试人员存在浮躁的心态（我甚至感到整个软件行业始终存在着浮躁的泡沫）。如何改变这种局面，这应该是个漫长的过程。当整个IT业真正以客户为上帝时，当软件质量成为决定企业生存和发展的决定因素时，当软件测试工程师的测试工作给软件企业带来更大的经济效益时，软件测试工程师才会得到应有的尊重！

软件开发是一项复杂的、创造性的协作式游戏。作为游戏它自然存在着乐趣，所以程序员们才会乐此不疲，前仆后继。首先、这种快乐源于一种创造事物的快乐。其次、这种快乐来自于一种开发出对别人有用的东西时所带来的满足感。第三、快乐源自开发过程中，亲眼看到软件按自己预先设想的那种效果运行时所带来的迷人魅力。第四、快乐源自开发过程中持续学习的快乐。最后、快乐源自开发过程中，我们能象诗人一样，仅凭自己的想像，来建造自己的城堡时带来的快乐。编程的快乐在于它不仅满足了我们内心深处进行创建的渴望，而且还唤醒了每个人内心的情感。不幸的是，同样作为游戏它也有苦恼的一面：首先、苦恼来自追求完美主义。其次、苦恼来自总是由他人来设定目标、供给资源、提供信息。第三、苦恼来自于寻找琐碎的BUG却是一项枯燥的、重复性的活动。第四、人们通常希望在项目接近结束时，能收敛得快一些，然而，情况却是越接近完成，收敛得越慢。最后、苦恼来自当投入大量的辛苦劳动后，产品发布时却面临着陈旧过时的危险。作为软件开发者，我们别无选择，只有适应它们，就这样痛并快乐着地面对每一天。

来自领导的信息只有25%被下级知道并正确理解，从下到上的反馈信息不超过10%，平等交流的信息则可达到90%以上。平等造就信任，信任增进交流。有效地进行适当的意见交流，对一个组织的气候和生产力会产生有益和积极的影响。使顾客满意并和他们面对面地交流，才是蠃得市场的关键。

管理是一种控制性游戏，在游戏面前，你只有二种选择：或者，你确信自己能蠃，于是投入足够多的能量来蠃得一切；或者，你不进行这个游戏，放弃它。然而，作为软件项目管理者，你也应该知道，早投入、高风险才会有高回报。逃避风险是致命的，因为这也会让你得不到与风险同在的利益，久而久之，你就会面临着被市场淘汰的危险。风险是"遭受损失的可能性"，由条件、结果以及周围的环境构成。风险和问题的区别在于：风险是尚未发生的问题，而问题是业也成真的风险，昨天的风险可能会是今天的问题。风险管理主要包括下面几个方面：

第一、风险识别：

从头脑想像中抽取出各种风险并加以筛选，再加上在整个开发过程中，保持持续不断的风险发现机制，以发现新的风险。

第二、风险分析：

对风险出现的可能性和潜在的危害性进行量化分析。

第三、应急计划：

如果识别出的风险真的出现，你将采取的应急措施。

第四、风险缓解：

为了使应急计划得以有效实施，必须在风险转化为真之前所采取的措施。

第五、持续的监控：

跟踪需要管理的风险，寻找风险出现的迹象。

项目面临的某些风险可能是致命的，发生时会使项目严重滞后或直接废弃。这类风险是最需要管理的，但有效的管理它们也许会使你与你的上级发生冲突(如时间上最后期限等)，对于这类风险往往超出了你的管理权限，可以先将它们列为项目假定风险，然后把它们转交给上级来管理。风险可能出自技术、政治、经济、资源或其它各个方面，几乎无所不在，并且会对项目开发、市场占有率或是达到项目目标(如进度、预算、质量等)造成灾难性后果。但在所有软件项目中，通常会共存五大核心风险，分别如下：

第一、缺乏合理的进度安排

这是导致项目滞后的最主要的原因。首先、它源于开发人员们普遍存在的乐观主义精神，我们总是期待在实现过程中不会碰到困难，然而我们的构思是有缺陷的，因此总会发现BUG。

第二.它源于一种错误的认识，人员数量和开发时间是可以互换的，既投入两倍的人数会在一半时间内完成开发工作。然而，这种理论却忽略了随着人数的增加，相应的也会增加新人培训和人们相互交流所需的负担,另外，还有任务重新分配所造成工作中断带来的负担，正如Alistair Cockburn所说："最有效的交流方式是面对面的交流"当3、5个人的时候很容易做到这种交流方式，随着人数的增长，再也很难做到这种交流方式。交流成本的增加与培训新人所需时间成本的增加、以及任务重分配导致工作中断成本的增加，直接导致一种结果：向进度落后的项目中增加人手，只会使进度更加落后。

第三、源于空泛的估算，管理人员特别是高层管理人员为了满足顾客期望的日期而造成的不合理进度安排。如果分配的时间一开始就不够，不管高层领导威胁有多么吓人，工作也无法按时完成，如果人们察觉到管理者可能滥用权力来惩罚自己，他们就会感觉到威胁，没有安全感。安全感的缺乏会让人们反对变化，而在所有成功项目中，变化是唯一不变的要素之一，除非感到安全，否则人们就不会去迎接变化，只会按部就班，这样往往丧失了很多走捷径的好机会，而这些机会原可以大大缩减时间进度的。第四、如果你没有认真估算产品规模，那么你预计的进度就是空中楼阁，唯一的依据只是你的希望。在估计产品规模时，除了正常的时间计算以外，不但应该将"可能需要做"的事情所需工作时间加上，还要将某些"可能不需要做"的事情所需工作时间加上。项目的超期不应归咎于开发者的低效率。

最后、项目的滞后不是一下子造成的，而是在一天天的不知不觉中造成的，有无数种方法可以浪费一天的时间，但是没有任何方法可以拿回一天的时间。高层管理者的不良反应肯定会对信息的完全公开造成压制；相反，仔细区分状态报告、毫无惊慌地接收报告、决不压制下级，将能鼓励诚实的进度汇报，而这会使你在第一时间掌握实际进度，把握先机，及早做出正确的修订，从而避免了晚期才获得这些实际信息时，那种无力挽天时的无奈。此外、也可以在项目管理中设定一个合理的进度安排和一个具有挑战性的期望目标完成时间。期望目标和合理进度不同，期望目标完成时间，可以设为项目完成的成功率在30%左右时的日期，这样很具有挑战性，但不能强迫要求必须完成此期望目标。毕竟，合理进度安排才是更合理的时间安排。另外、需要指出的是现代敏捷方法论对此进行了有效改进，如XP(极限编程)中，就利用用户素材与CRC卡，进行优先级划分并进行快速增量迭代开发，针对原来开发的产品或第一次迭代开发后的原型完成的功能量，来计算功能点，从而估算每个CRC卡的功能点，得到总功能点来推导出比较准确的进度安排。

第二、需求的变化

从项目的角度来说，需求总是向着膨胀的方向在变化。就连去掉某些已经做好的东西，也是一种膨胀，因为它增加了工作量。开发人员交付的是用户满意程度，而不仅仅是实际的产品，用户的实际需要会随着程序的构建和使用而变化。要知道，一个活着的软件必须面对变化，只有死掉的软件才不会有需求变化(没人用了)，我们应该尽早面对现实，而不是逃避，事先为它们做好思想准备。变化是好事不是什么坏事。同样，现代敏捷方法论强调对需求变化的快速响应，如XP(极限编程)就采用快速增量迭代开发，来在短时间内开发出功能不断增强的原型软件提交给用户使用的方法，来快速响应需求的变化。

第三、人员的变更

在我们有些管理者中，总是假设开发者都是可以随便替换的，新员工马上可以取代离去的老员工，多么愚蠢的假设。解雇员工或高的员工替换率最大的影响，是使软件项目失去了连续性。这是在抱着这种假设的团队文化中，大量员工会在项目进行到一半时离开，新来员工往往需要1到3个月的上道时间，在这段时间内，他们做不了什么，还经常需要其它老员工的帮助，从而浪费了其它老员工很多不必要时间，导致项目进展更加缓慢，最终造成项目的很大损失。

另外、还有一种现象在中国软件事业中普遍存在，当正在进行一个项目时，另一个项目由于进度落后或最后期限等原因所致，高层管理者就会从你的团队中抽掉一些人去到另一个项目中补墙。这种拆东墙补西墙的作法，往往导致的结果是两个项目都会落后，因为它不仅十分错误作了团队人员可以随意替换的假设，而且还作了将开发人数与开发所需时间可以互换的错误假设。盲目的认为，投入大量人数后，新人马上会投入新的工作，这样项目开发所需时间就会成倍缩短。在这种组织文化中，是不会形成一支稳定的团队的，成员整天只会忙碌着补自已的墙或为别人补墙，充当着类似消防员的角色，那儿有火那儿就有我们的身影。

同样，现代敏捷方法论非常注重人的能力，如XP中通过权力下放、教练角色、将团队紧密围在一起并结对编程、小团队组成等方式，来组成一个强有力的团队，由于有凝聚力，所以很少有大的人员变动，他们往往可以完成两倍于他们人数所能完成的任务。非常小的团队能够产生非常大的物质生产力，有时候，小团队可以在很短时间内创造奇迹，而大型团队极少能做到。但是，小团队却往往得不到足够的政策支持，从而导致任由团队超编，这是一种病态组织文化所致。作为管理者必须明确知道，拥有一支稳定的、有凝聚力的开发团队是组织最大的财富，而不是障碍。

第四、规约崩溃

这种情况只有两种结果：要么发生，要么不发生，不会有不同程度的影响。但它真的发生时，它会直接毁灭你的整个项目。在项目启动之初，项目各方需要通过一系列商谈来确定需求的范围，规约崩溃就是指这个谈判过程的崩溃。在商谈期间，很多时候当遇到严重冲突时，由于双方都不愿意让步，但又不想放弃这个项目，从而导致这些冲突被掩盖起来。最终项目便朝着一个带着缺陷的、含混不清的目标前进了，被掩盖的问题暂时不会打扰你，但不是永远。尽管你可以含混说明一个产品，但不能含混构造一个产品，所以，最终在项目晚期这些问题将发生，在大半甚至所有预算时间和金钱都已付出的时候，此时，任何一方不再全力支持，都将使项目被取消。任何规格文档中的含糊标志着不同的系统参与者之间存在着未解决的冲突。只要在开发过程中有多个参与者，就一定会有冲突存在。谈判困难而调解容易，如果两个人的利益是完全或部分相斥的，预先做好安排，准备好请双方通过调解来解决冲突。同样，现代敏捷方法论通过客户的积极参与胜过合同谈判的方试，来尽早发现和避免规约崩溃。

第五、低效率

对于项目成功而言，项目人员的素质、人员的组织和管理是比使用的工具或采用的技术方法更重要的因素。团队质量是项目成功最大的决定因素，对人的关注、激励和培养胜过一切。项目管理人员的职责不是要人们去工作，而是给人们创造工作的可能。创造力来自于个人，而不是组织架构和流程，项目管理者面临的中心问题就是如何设计架构和流程，来提高而不是压制人们的主动性和创造力。通过权力的向下委派，从而产生了改进的质量、提高的生产率、高涨的士气，进而使中心的权威实际上得到了加强。就整体而言，组织机构会更加融洽和繁荣。增加加班时间只会降低生产力，压力之下的人们无法更快地思考既也会降低生产力。使用压力和加班的真正原因是为了在项目失败时让人们看上去能好受一些。

正式的过程改进程序需要花钱、花时间，特定的过程改进工作还会延缓项目进度，尽管最终会体现生产力上的收获，它们也不可能抵消花在过程改进上的时间。多种技术的改进程序(如CMM提级)很可能让项目比不实施这些程序完成得更晚，对于人员超编的项目，标准过程会为多余的人们制造出足够的工作，让所有人都忙个不停，尽管很多是无用的，这也导致生产率低下。人员超编的团队往往生产率低下，因为它们团队内部耦合度提高，会议时间、重复劳动和无效工作都会增加。理想的人员安排是在项目的大部分时间里由小型核心团队来做设计工作，在开发的最后阶段再逐渐加入大量人手。如果不大幅度减少调试的时间，就没办法让项目大幅度提前完成，而要成比例减少调试时间，就需要成比例增加设计所需时间，因为绝大多数的错误源于接口缺陷，编码前进行的正规而完善的设计，可以大幅度减少错误。同样，现代敏捷方法论通过注重人、快速迭代开发、自组织的团队和提倡可持续的开发速度，来避免跑的过快导致团队精力耗尽、出现短期行为而导致崩溃的问题，从而保持了稳定的生产率。

精兵简政是失败公司使用的办法，它让员工负担失败的责任。成功公司的目标应该正好相反：兴旺、发达、而人性化。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　
企业的最大风险则与价值相关：在低价值的项目上浪费资源，付出高价值的机会成本，就这是企业最大风险。勇于承担风险是好事，但必须由收益来导航，愿意承担多少风险，必须取决于能获得多少收益。真正的项目评估不是倾向于不断削减成本，来提高价值，而是在风险与价值之间取得平衡点。通过不确定的价值和不确定风险组合效果的净收益图，来指导你把资本投入到最适当的地方。我们每个软件从业人员都必须明白：顾客真正需要的，是我们能够给他的、某种他想得到的利益。

#define M 14
//M为连连看牌的高+2
#define N 10
//N为连连看牌的宽+2

struct point
{
 int x;
 int y;
};

/*********************************************************/

template < typename T, int m, int n > class Matrix
{
protected: 
 T matrix[M][N];
public:
 Matrix();
 Matrix( char* filename );//通过文件里的数据初始化
 void show_matrix();//输出矩阵
 void set_element( int x, int y, T num );//num为元素值
 T get_element( int x, int y );
};

/*********************************************************/

class Linker_Matrix:public Matrix < int, M, N >  //连连看的牌矩阵类
{
 /* matrix[M][N]为牌矩阵；
  从[1][1]开始，到[M-2][N-2]有效;
  外围一圈为预留的配对路径;
  值＝0为无牌，即牌配对之后被消掉的的状态;
  其他值即为牌的类别，相同值的牌方可配对;  
 */
private:
 //time_t curtime;
 point p1,p2,way[ 4 ];
  //p1为起点，p2为终点，way[M+N]用于记录搜索到的路径
 int index;//路径的长度;
 int turn_count;//路径的转弯次数,>2就搜索失败;
 Matrix < int, M, N > visited;
  //是否访问过矩阵类，1:访问过 0:未访问 
public:

 Linker_Matrix();
 Linker_Matrix( int low, int high, int num );
  //随机选择元素初始化，元素值的范围在low－high，
  //每个值有num个;
 Linker_Matrix( int num );
  //随机选择元素初始化，从1开始，每个值有num个;
  
 void show_matrix();
 void count( int low, int high );//统计各个值的个数，测试用;
 bool auto_search();//自动搜索出一对配对的牌
 bool find_way( point p1, point p2 );
  //搜索路径 true－有路径 false－无;  
 void auto_play();//自动完成所有的配对；
 void init_search();//进行搜索前的初始化 
 bool man_search( point p1,  point p2);
 bool is_matched( point p1, point p2 );
  //是否配对 true－配对 false－否;
 int  get_element( int x, int y );
 void get_point(point &p1,point &p2);
  //通过p1,p2提取自动搜索出的匹配两点
 void reShuffle();//重新洗牌;
};

/*********************************************************/

head.cpp

#include "head.h"
#include<iostream.h>
#include<fstream.h>
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#include<time.h>
#include<conio.h>

template < typename T, int m, int n >
Matrix < T, m, n >::Matrix()
{
 for( int i=0; i<m; i++ )
  for( int j=0; j<n; j++ )
   matrix[i][j] = 0;
 
}

template < typename T, int m, int n >
Matrix< T, m, n >::Matrix( char* filename )
{
 ifstream infile(filename);
 
 for( int i=0; i<M; i++ )
  for( int j=0; j<N; j++ )
   infile >> matrix[i][j];
}

template < typename T, int m, int n >
void Matrix< T, m, n >::show_matrix()
{ 
 for( int i=0; i<m; i++ )
 {
  for( int j=0; j<n; j++ )
   cout<< matrix[i][j]<<'\t';
  cout<<endl;
 }
 cout<<endl;
}

template < typename T, int m, int n >
inline void Matrix< T, m, n >::set_element( int x, int y, T element )
{
 matrix[x][y] = element;
}

template < typename T, int m, int n >
T Matrix< T, m, n >::get_element( int x, int y )
{
 return matrix[x][y];
}

/*********************************************************/

Linker_Matrix::Linker_Matrix():Matrix< int, M, N >()
{
 p1.x = p1.y = 0;
 p2.x = p2.y = 0;
 index = 0;
 turn_count = 0;
 //max=0;

 for( int k=0; k<4; k++ )
  way[k].x = way[k].y = 0;
}

Linker_Matrix::Linker_Matrix( int low, int high, int num )
 :Matrix< int, M, N >()
{ 
 
 int m,n;
 time_t curtime; //记录当前时间

 p1.x = p1.y = 0;
 p2.x = p2.y = 0;
 index = 0;

 time(&curtime);//取得当前时间
 //srand(curtime);//用当前时间作种子，产生随机数

 for( int k=0; k<4; k++ )
  way[k].x = way[k].y = 0;

 for( int i=low; i<=high; i++ )
  for( int j=0; j<num; j++ )
  {
   do
   {
    m = rand()%(M-2) + 1;
    n = rand()%(N-2) + 1;
   }
   while( 0==m || 0==n || 0!=matrix[m][n] );
   matrix[m][n]=i;
  }
}

Linker_Matrix::Linker_Matrix(int num ):Matrix< int, M, N >()
{ 
 
 int m,n;
 time_t curtime; //记录当前时间

 p1.x = p1.y = 0;
 p2.x = p2.y = 0;
 index = 0;

 time(&curtime);//取得当前时间
 srand(curtime);//用当前时间作种子，产生随机数

 for( int k=0; k<4; k++ )
  way[k].x = way[k].y = 0;

 for( int i=1; i<=(M-2)*(N-2)/num; i++ )
  for( int j=0; j<num; j++ )
  {
   do
   {
    m = rand()%(M-2) + 1;
    n = rand()%(N-2) + 1;
   }
   while( 0==m || 0==n || 0!=matrix[m][n] );
   matrix[m][n]=i;
  }
}

void Linker_Matrix::show_matrix()
{
 
 for( int i=1; i<M-1; i++ )
 {
  for( int j=1; j<N-1; j++ )
   cout<<matrix[i][j]<<'\t';
  cout<<endl;
 }
 cout<<endl;
}

void Linker_Matrix::count( int low, int high )
{
 int *num,k;

 //动态分配 
 num = new int[ high-low+2 ];
 //初始化
 for( k=0; k<high-low+2; k++ )
  num[k]=0;
 
 //计数
 for( int i=1; i<M-1; i++ )
  for( int j=1; j<N-1; j++ )
   num[ matrix[i][j] ]++;
  
 //输出
 for( k=0; k<high-low+2; k++ )
  cout<<k<<":"<<num[k]<<'\t';
 cout<<endl;

 //销毁
 delete[] num;
}

inline bool Linker_Matrix::is_matched( const point p1, const point p2 )
{
 return matrix[ p1.x ][ p1.y ] == matrix[ p2.x ][ p2.y ];
}

bool Linker_Matrix::auto_search()
{
 int i,j,m,n;
 //static k = 0;
 bool all_is_zero = true;//是否所有元素都为0 true:yes false:no

 for( i=1; i<M-1; i++ )
 for( j=1; j<N-1; j++ )
 {
  if( matrix[i][j]!=0 )//元素不为0时方进行配对
  {
   all_is_zero=false;
   p1.x = i; p1.y = j;

   for( m=1; m<M-1; m++ )
   for( n=1; n<N-1; n++ )
   { 
    if( i!=m || j!=n )//元素不为本身时，方进行搜索路径
    { 
     //k++;
     p2.x=m; p2.y=n;

     init_search();
     /*if(k==29)
     {
      init_search();
      show_matrix();
     }*/
     
     if ( is_matched( p1, p2 ) && find_way( p1, p2 ) )
     /*逻辑式这样写的原因是只要is_matched(p1,p2)为false，
     逻辑式必为false，find_way(p1,p2)就不会执行；
     当两元素数值相同且有路径时，执行下面
     */
     { 
       //show_matrix();
       //cout<<turn_count<<endl;
       //matrix[ p1.x ][ p1.y ] = 0;
       //matrix[ p2.x ][ p2.y ] = 0;
       //k++;
       //cout<<p1.x<<' '<<p1.y<<' '<<p2.x<<' '<<p2.y<<':'<<k<<endl;
       //show_matrix();
       //count(1,21);
       //goto jump;
       //找到一个就退出
      
       return true;
      //}
     }
     
    }/*
    if( k>MAX)//搜索次数过大，强制跳出
        return false;*/
   }
  }
  //jump:  ;
 }

 if( true==all_is_zero )//元素全部为0，返回false
  return false;
 return false;//没有匹配时,返回false
}

bool Linker_Matrix::find_way(  point p1, point p2 )
{
 /*
 本方法是本程序的核心算法，
 作用是以p1为起点，p2为终点进行路径的搜索；*/
 /*采用水平垂直扫描法,先确定两个转折点之间是否相通,再判断
 转折点与相应端点间是否相通
 */

 int i,j;
 int px1,px2,py1,py2;
 int temp;
 bool x_across,y_across;

 //如果相邻
 if( ( p1.x+1==p2.x && p1.y==p2.y )
  || ( p1.x==p2.x && p1.y+1==p2.y )
  || ( p1.x-1==p2.x && p1.y==p2.y )
  || ( p1.x==p2.x && p1.y-1==p2.y ) )
 {
  //把路径记录下来
  //起点
  way[0].x=p1.x;
  way[0].y=p1.y;
  //直线转折点为0
  way[1].x=0;
  way[1].y=0;
  way[2].x=0;
  way[2].y=0;
  //终点
  way[3].x=p2.x;
  way[3].y=p2.y;

  return true;
 }

 //直线连通
 //如果在水平方向上
 if( p1.x==p2.x )
 {
  if(p1.y>p2.y)
  {
   temp=p1.y;
   p1.y=p2.y;
   p2.y=temp;
  }

  for(j=p1.y+1; j<p2.y; j++ )
  {
   if( matrix[p1.x][j]!=0)
   {
    break;
   }
  }

  //如果两点之间相通
  if(j==p2.y &&  matrix[p1.x][j-1]==0 )
  {
   
   //把路径记录下来
   //起点
   way[0].x=p1.x;
   way[0].y=p1.y;
   //直线转折点为0
   way[1].x=0;
   way[1].y=0;
   way[2].x=0;
   way[2].y=0;
   //终点
   way[3].x=p2.x;
   way[3].y=p2.y;

   return true;
  }
 }

 //如果在垂直方向上
 if( p1.y==p2.y )
 {
  if(p1.x>p2.x)
  {
   temp=p1.x;
   p1.x=p2.x;
   p2.x=temp;
  }

  for(i=p1.x+1; i<p2.x; i++ )
  {
   if( matrix[i][p1.y]!=0)
   {
    break;
   }
  }
  //如果两点之间相通
  if(i==p2.x &&  matrix[i-1][p1.y]==0 )
  {

   //把路径记录下来
   //起点
   way[0].x=p1.x;
   way[0].y=p1.y;
   //直线转折点为0
   way[1].x=0;
   way[1].y=0;
   way[2].x=0;
   way[2].y=0;
   //终点
   way[3].x=p2.x;
   way[3].y=p2.y;

   return true;
  }
 }

 
 //折线连通
 /*if( p1.x!=p2.x && p1.y!=p2.y)
 {*/
  if(p1.y>p2.y)
  {
   //两点交换
   temp=p1.x;
   p1.x=p2.x;
   p2.x=temp;

   temp=p1.y;
   p1.y=p2.y;
   p2.y=temp;

  }

 //横向扫描
 for(i=0;i<=M-1;i++)
 {  
  x_across=true;

  //是否水平连通
  for(j=p1.y+1; j<=p2.y-1; j++ )
  {
   if(matrix[i][j]!=0 )
   {
    x_across=false;
    break;
   }
  }

  if(matrix[i][p1.y]!=0  )
  {
   if( i!=p1.x )
    x_across=false;
  }
  if(matrix[i][p2.y]!=0  )
  {
   if( i!=p2.x )
    x_across=false;
  } 
   
  if(x_across)
  {//水平连通才执行下面
  /* for(j=1; j<N-2; j++ )
   {*/
    //检验在垂直上是否连通

   px1=px2=i;
   py1=p1.y;
   py2=p2.y;
   while( px1!=p1.x || px2!=p2.x )
   {
    //如果当前点不空且不为p1点,就跳出循环,从下一行开始检测
    if( matrix[px1][py1]!=0 && (px1!=p1.x || py1!=p1.y) )
     break;

    //如果当前点不空且不为p2点,就跳出循环,从下一行开始检测
    if( matrix[px2][py2]!=0 && (px2!=p2.x || py2!=p2.y) )
     break;

    //如果两点都为空
    //垂直向p1点靠近一格
    if(px1<p1.x)
     px1++;
    else if(px1>p1.x)
     px1--;
    //垂直向p2点靠近一格
    if(px2<p2.x)
     px2++;
    else if(px2>p2.x)
     px2--;
   }
     
   //如果能到达两个端点
   if(px1==p1.x && py1==p1.y && px2==p2.x && py2==p2.y )
   {
    //起点
    way[0].x=p1.x;
    way[0].y=p1.y;
    //两个转折点
    way[1].x=i;
    way[1].y=p1.y;
    way[2].x=i;
    way[2].y=p2.y;
    //终点
    way[3].x=p2.x;
    way[3].y=p2.y; 
    return true;
   }

  }
 }

 if(p1.x>p2.x)
  {
   //两点交换
   temp=p1.x;
   p1.x=p2.x;
   p2.x=temp;

   temp=p1.y;
   p1.y=p2.y;
   p2.y=temp;

  }
 //纵向扫描
 for(j=0;j<=N-1;j++)
 {  
  y_across=true;
  //是否垂直连通
  for(i=p1.x+1; i<=p2.x-1; i++ )
  {
   if(matrix[i][j]!=0)
   {
    y_across=false;
    break;
   }
  }

  if(matrix[p1.x][j]!=0  )
  {
   if( j!=p1.y )
    y_across=false;
  }
  if(matrix[p2.x][j]!=0  )
  {
   if( j!=p2.y )
    y_across=false;
  }
    
  if(y_across)
  {//垂直连通才执行下面
  /* for(j=1; j<N-2; j++ )
   {*/
    //检验在水平上是否连通

   py1=py2=j;
   px1=p1.x;
   px2=p2.x;
   while( py1!=p1.y || py2!=p2.y)
   {
    //如果当前点不空且不为p1点,就跳出循环,从下一行开始检测
    if( matrix[px1][py1]!=0 && (px1!=p1.x || py1!=p1.y) )
     break;

    //如果当前点不空且不为p2点,就跳出循环,从下一行开始检测
    if( matrix[px2][py2]!=0 && (px2!=p2.x || py2!=p2.y) )
     break;

    //如果两点都为空
    //水平向p1点靠近一格
    if(py1<p1.y)
     py1++;
    else if(py1>p1.y)
     py1--;
    //水平向p2点靠近一格
    if(py2<p2.y)
     py2++;
    else if(py2>p2.y)
     py2--;
   }
     
   //如果能到达两个端点
   if(px1==p1.x && py1==p1.y && px2==p2.x && py2==p2.y )
   {
    //起点
    way[0].x=p1.x;
    way[0].y=p1.y;
    //两个转折点
    way[1].x=p1.x;
    way[1].y=j;
    way[2].x=p2.x;
    way[2].y=j;
    //终点
    way[3].x=p2.x;
    way[3].y=p2.y; 
    return true;
   }

  }
 }
 //} 
 return false;

}

void Linker_Matrix::init_search()
{
 visited = Matrix< int, M, N >();
 index = 0;
 turn_count = 0;
}

void Linker_Matrix::auto_play()
{
  while( auto_search() );
}

bool Linker_Matrix::man_search(const point p1, const point p2)
{
 init_search();
 if( find_way( p1, p2 ) )
 {
  matrix[p1.x][p1.y]=0;
  matrix[p2.x][p2.y]=0;
  return true;
 }
 return false;
}

 int Linker_Matrix::get_element( int x, int y )
 {
  return matrix[x][y];
 }

void Linker_Matrix::get_point(point &p1,point &p2)
{
 //if( auto_search() )
 //{
  p1=this->p1;
  p2=this->p2;
  //return true;
 //}
 
 //return false;
}

void Linker_Matrix::reShuffle()
{
 int m,n,k;
 time_t curtime; //记录当前时间

 //p1.x = p1.y = 0;
 //p2.x = p2.y = 0;
 //index = 0;

 time(&curtime);//取得当前时间
 srand(curtime);//用当前时间作种子，产生随机数

 //for( int k=0; k<4; k++ )
 // way[k].x = way[k].y = 0;

 for( int i=1; i<=(M-2); i++ )
 for( int j=1; j<=(N-2); j++ )
 {
  if(matrix[i][j]!=0)
  {
   do
   {
    m = rand()%(M-2) + 1;
    n = rand()%(N-2) + 1;
   }
   while( 0==matrix[m][n] );

   k=matrix[i][j];
   matrix[i][j]=matrix[m][n];
   matrix[m][n]=k;
  }
 }
}

linker.cpp

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include <windows.h>

#include "head.h"
#include "resource.h"

TCHAR szAppName[] = TEXT ("Linker") ;//程序名称
const int xsize=610,ysize=520;
const int TimerID=1;

LRESULT CALLBACK WndProc ( HWND, UINT, WPARAM, LPARAM ) ;

int WINAPI WinMain ( HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow )
{
 HWND         hwnd ;
 MSG          msg ;
 WNDCLASS     wndclass ;
 HACCEL hAccel ;//快捷键表

 wndclass.style         = CS_HREDRAW | CS_VREDRAW ;
 wndclass.lpfnWndProc   = WndProc ;
 wndclass.cbClsExtra    = 0 ;
 wndclass.cbWndExtra    = 0 ;
 wndclass.hInstance     = hInstance ;
 wndclass.hIcon         = LoadIcon (hInstance, MAKEINTRESOURCE (IDI_ICON)) ;
 wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
 wndclass.hbrBackground = (HBRUSH) GetStockObject (WHITE_BRUSH) ;
 wndclass.lpszMenuName  = szAppName ;
 wndclass.lpszClassName = szAppName ;

 if (!RegisterClass (&wndclass))
 {
  MessageBox (NULL, TEXT ("This program requires Windows NT!"),
    szAppName, MB_ICONERROR) ;
  return 0 ;
 }
    
 hwnd = CreateWindow ( szAppName,  // window class name
                          TEXT ("连连看 V1.08.18.01"), // window caption
                          WS_OVERLAPPEDWINDOW &
     ~WS_MAXIMIZEBOX & ~WS_SIZEBOX,// window style
     //没有最大化按钮和无法改变窗口大小
                          CW_USEDEFAULT,  // initial x position
                          CW_USEDEFAULT,  // initial y position
                          xsize,  // initial x size
                          ysize,  // initial y size
                          NULL,    // parent window handle
                          NULL,    // window menu handle
                          hInstance,   // program instance handle
                          NULL ) ;   // creation parameters
    
 ShowWindow (hwnd, iCmdShow) ;
 UpdateWindow (hwnd) ;
    
 hAccel = LoadAccelerators (hInstance, TEXT ("MY_ACCELERATOR")) ;

 while(GetMessage (&msg, NULL, 0, 0))
 {
  if(!TranslateAccelerator (hwnd, hAccel, &msg))
  {
                  TranslateMessage (&msg) ;
                  DispatchMessage (&msg) ;
  }
 }

 return msg.wParam ;
}

BOOL CALLBACK AboutDlgProc (HWND hDlg, UINT message,
                            WPARAM wParam, LPARAM lParam)
{
     switch (message)
     {
     case WM_INITDIALOG :
          return TRUE ;
         
     case WM_COMMAND :
          switch (LOWORD (wParam))
          {
          case IDOK :
          case IDCANCEL :
               EndDialog (hDlg, 0) ;
               return TRUE ;
          }
          break ;
     }
     return FALSE ;
}

LRESULT CALLBACK WndProc ( HWND hwnd, UINT message,
    WPARAM wParam, LPARAM lParam )
{
 HDC  hdc,hdcMem;
 //HBRUSH hBrush ;
 PAINTSTRUCT ps ;//绘图结构
 static RECT  rect,rect2 ;//矩形
 static HBITMAP hBitmap1,hBitmap2;//两个位图文件句柄
 HBITMAP hBitmap3;
 BITMAP  bitmap ;//位图文件
 static int cxBack,cyBack,cxPre,cyPre,cxStart,cyStart;
    //cxBack,cyBack:背景图片大小
    //cxPre,cyPre:牌面图片大小  
 int x,y,i,j,num;

 bool find;//是否有路径标志
 static bool first_started=false;//是否是刚打开程序
 static bool bPrompt=false;//是否提示
 TCHAR    szBuffer[14];
 static HINSTANCE hInstance ;
 static HMENU  hMenu ;//菜单句柄
 static int  iCurrentLevel = IDM_APP_LOW ;//记录游戏难度
 static int  iTime = 100 ;//记录游戏的剩余时间
 static  int  iShuffle=0,iPrompt=0;
  //iShuffle:重新洗牌的剩余次数,iPrompt:提示的剩余次数
 static int iCount=0;//统计消去的对数,用于判断是否胜利
 static Linker_Matrix linker ;//连连看的运算矩阵
 static point  pSelected[2] ;//用于记录选择的两个点
    
 switch (message)
 {
 case WM_CREATE://进行初始化；
  //PlaySound (TEXT ("hellowin.wav"), NULL, SND_FILENAME | SND_ASYNC) ;
  //GetClientRect(hwnd,&rect);

  MoveWindow(hwnd,(GetSystemMetrics(SM_CXSCREEN)-xsize)/2,(GetSystemMetrics(SM_CYSCREEN)-ysize)/2,xsize,ysize,false);
  //将窗口移置屏幕中间

  hInstance = ((LPCREATESTRUCT) lParam)->hInstance ;
  hMenu = GetMenu (hwnd) ;
  pSelected[0].x=pSelected[0].y=0;
  pSelected[1].x=pSelected[1].y=0;

  hBitmap1 = LoadBitmap (hInstance, TEXT ("IDB_BITMAP_BACK"));
  hBitmap2 = LoadBitmap (hInstance, TEXT ("IDB_BITMAP_PRE"));
  

  GetObject (hBitmap1, sizeof (BITMAP), &bitmap) ;

  cxBack = bitmap.bmWidth ;
  cyBack = bitmap.bmHeight/7 ;
  GetObject (hBitmap2, sizeof (BITMAP), &bitmap) ;

  cxPre = bitmap.bmWidth/2 ;
  cyPre = bitmap.bmHeight/42 ;

  //SendMessage(hwnd,WM_COMMAND,IDM_APP_START,0);
  first_started=true;
  
  return 0 ;

 case WM_TIMER:
  if(iTime>0)
   iTime--;

  //使字体所在区域无效化,重绘
  rect.left = 0;
  rect.right = xsize;
  rect.top  = 0;
  rect.bottom = 20;
  InvalidateRect (hwnd, &rect, true) ;
  rect.left = 0;
  rect.right = 0;
  rect.top  = 0;
  rect.bottom = 0;

  if( iTime<=0 )
  {
   iCount=0;
   KillTimer (hwnd, TimerID) ;
   MessageBox (hwnd, TEXT ("时间到，你输了!!"),szAppName, MB_OK | MB_ICONQUESTION) ;
   

   SendMessage(hwnd,WM_COMMAND,IDM_APP_START,0);

   linker=Linker_Matrix();
   InvalidateRect (hwnd, NULL, true) ;
  }
  

  return 0;

 case WM_PAINT:
  hdc = BeginPaint (hwnd, &ps) ;
  
  //GetClientRect (hwnd, &rect) ;
  hdcMem = CreateCompatibleDC (hdc) ;
   
  

  //绘制牌面
  for(i=1; i<=M-2; i++ )
   for(j=1; j<=N-2; j++ )
   {
    num=linker.get_element(i,j);
    if( num!=0 )
    {
    x=i*(cxBack-3);
    y=j*(cyBack-4)-30;
    SelectObject (hdcMem, hBitmap1) ;
    BitBlt (hdc, x, y, cxBack, cyBack, hdcMem, 0, cyBack*(num%6+1), SRCCOPY) ;
    SelectObject (hdcMem, hBitmap2) ;
    BitBlt (hdc, x+1, y+6, cxPre, cyPre, hdcMem,  cxPre, cyPre*num, SRCAND) ;
    BitBlt (hdc, x+1, y+6, cxPre, cyPre, hdcMem,  0, cyPre*num, SRCPAINT) ;
   
    }
   }
  
  //当选中第一张牌时，在上面画个圈
  if(rect.left!=0 && rect.right!=0 && rect.top!=0 && rect.bottom!=0 && bPrompt==false)
  {
   SelectObject (hdc, GetStockObject (GRAY_BRUSH)) ;
   Ellipse(hdc,rect.left ,rect.top ,rect.left+10 ,rect.top+10 );
   rect.left=0;
   rect.right=0 ;
   rect.top=0;
   rect.bottom=0;

  }
  if( first_started==false)
  {
   sprintf(szBuffer,"剩余时间: %d 秒",iTime);
   TextOut (hdc, 0, 0, szBuffer, strlen (szBuffer)) ;
   TextOut (hdc, xsize/5, 0, TEXT("每消去一对剩余时间+2秒"), strlen (TEXT("每消去一对剩余时间+3秒"))) ;
   sprintf(szBuffer,"剩余洗牌次数: %d 次",iShuffle);
   TextOut (hdc, xsize/2+10, 0, szBuffer, strlen (szBuffer)) ;
   sprintf(szBuffer,"剩余提示次数: %d 次",iPrompt);
   TextOut (hdc, xsize/4*3, 0, szBuffer, strlen (szBuffer)) ;
  }

  if(first_started)
  {//第一次打开程序

   /*SendMessage(hwnd,WM_COMMAND,IDM_APP_ABOUT,0);
   //发送 单击关于菜单 消息
   SendMessage(hwnd,WM_COMMAND,IDM_APP_START,0);
   //发送 单击开始游戏菜单 消息，询问是否开始；*/
   hBitmap3 = LoadBitmap (hInstance, TEXT ("IDB_BITMAP_START"));
   GetObject (hBitmap3, sizeof (BITMAP), &bitmap) ;
   cxStart = bitmap.bmWidth;
   cyStart = bitmap.bmHeight;

   SelectObject (hdcMem, hBitmap3) ;
   StretchBlt  (hdc, 0, 0, xsize, ysize, hdcMem, 0,0, cxStart, cyStart,MERGECOPY) ;
   PlaySound (TEXT ("start.wav"), NULL, SND_FILENAME | SND_ASYNC) ;
   //first_started=false;
  }
 
  if(bPrompt)
  {
   SelectObject (hdc, GetStockObject (BLACK_BRUSH)) ;
   Ellipse(hdc,rect.left ,rect.top ,rect.left+10 ,rect.top+10 );
   Ellipse(hdc,rect2.left ,rect2.top ,rect2.left+10 ,rect2.top+10 );
   rect.left=0;
   rect.right=0 ;
   rect.top=0;
   rect.bottom=0;
   rect2.left=0;
   rect2.right=0 ;
   rect2.top=0;
   rect2.bottom=0;

   bPrompt=false;
  }

  DeleteDC (hdcMem) ;
  EndPaint (hwnd, &ps) ;

  return 0 ;
 case WM_INITMENUPOPUP:

  if( first_started==false )
  {
   EnableMenuItem ((HMENU) wParam, IDM_APP_RESHUFFLE,   MF_ENABLED) ;
   EnableMenuItem ((HMENU) wParam, IDM_APP_PROMPT,   MF_ENABLED) ;
  }

  if(iShuffle==0)
   EnableMenuItem ((HMENU) wParam, IDM_APP_RESHUFFLE,  MF_GRAYED) ;
  if(iPrompt==0)
   EnableMenuItem ((HMENU) wParam, IDM_APP_PROMPT,  MF_GRAYED) ;

  
  break;

 case WM_COMMAND :
  switch (LOWORD (wParam))
  {

  case IDM_APP_START://单击开始游戏菜单
   if ( IDYES == MessageBox (hwnd, TEXT ("开始游戏吗？"),
    szAppName, MB_YESNO | MB_ICONQUESTION) )
   //弹出确认窗口，按YES开始游戏
   {
    if ( iCurrentLevel==IDM_APP_LOW )
    {//难度为低
     iTime=90;
     iPrompt=3;
     iShuffle=2;
     linker=Linker_Matrix(6);
    
    }

    if ( iCurrentLevel==IDM_APP_MIDDLE )
    {//难度为中
     iTime=90;
     iPrompt=3;
     iShuffle=2;
     linker=Linker_Matrix(4);
     
    }
    
    if ( iCurrentLevel==IDM_APP_HIGH )
    {//难度为高
     iTime=60;
     iPrompt=3;
     iShuffle=1;
     linker=Linker_Matrix(4);
    
    }
   
    SetTimer (hwnd, TimerID, 1000, NULL) ;
    InvalidateRect (hwnd, NULL, TRUE) ;
    first_started=false;
    iCount=0;

   }
   else
    SendMessage(hwnd,WM_CLOSE,0,0);
   break;

  case IDM_APP_EXIT ://单击退出游戏菜单
   SendMessage(hwnd,WM_CLOSE,0,0);
   break;

  case IDM_APP_ABOUT ://单击关于菜单
   DialogBox (hInstance, TEXT ("AboutBox"), hwnd, AboutDlgProc) ;
   break ;

  case IDM_APP_LOW:
  case IDM_APP_MIDDLE:
  case IDM_APP_HIGH:
   //单击难度菜单
   CheckMenuItem (hMenu, iCurrentLevel, MF_UNCHECKED) ;
   iCurrentLevel = LOWORD (wParam) ;
   CheckMenuItem (hMenu, iCurrentLevel, MF_CHECKED) ;
   break;

  case IDM_APP_RESHUFFLE://单击重新洗牌按钮
   if(iShuffle>0 )
   { 
    iShuffle--;
    linker.reShuffle();
   }
   //if(iShuffle==0)
    //EnableMenuItem ((HMENU) wParam, IDM_APP_RESHUFFLE,  MF_GRAYED) ;
   
   //使文字所在区域无效化,重绘
   /*rect.left = 0;
   rect.right = xsize;
   rect.top  = 0;
   rect.bottom = 20;*/
   InvalidateRect (hwnd, NULL , true) ;
   rect.left = 0;
   rect.right = 0;
   rect.top  = 0;
   rect.bottom = 0;
   break;

  case IDM_APP_PROMPT:
   if(iPrompt>0 && linker.auto_search() )//提示次数>0,且找到匹配
   {
    //pSelected[0].x=pSelected[0].y=0;
    linker.get_point(pSelected[0],pSelected[1]);
    iPrompt--;

    //使文字所在区域无效化,重绘
    rect.left = 0;
    rect.right = xsize;
    rect.top  = 0;
    rect.bottom = 20;
    InvalidateRect (hwnd, &rect, true) ;
    rect.left = 0;
    rect.right = 0;
    rect.top  = 0;
    rect.bottom = 0;
     
    //sprintf(szBuffer," %d %d %d %d",pSelected[0].x,pSelected[0].y,pSelected[1].x,pSelected[1].y);
    //MessageBox (hwnd, szBuffer,szAppName, MB_OK | MB_ICONQUESTION) ;
    
    rect.left = pSelected[0].x*(cxBack-3);
    rect.right = rect.left+(cxBack-3)+3;
    rect.top  = pSelected[0].y *(cyBack-4)-30;
    rect.bottom = rect.top + (cyBack-4)+4;
    //Ellipse(hdc,rect.left ,rect.top ,rect.right ,rect.bottom );
    InvalidateRect (hwnd, &rect, true) ;
    
    rect2.left = pSelected[1].x *(cxBack-3);
    rect2.right = rect2.left+(cxBack-3)+3;
    rect2.top  = pSelected[1].y *(cyBack-4)-30;
    rect2.bottom = rect2.top + (cyBack-4)+4;
    //Ellipse(hdc,rect.left ,rect.top ,rect.right ,rect.bottom );
    InvalidateRect (hwnd, &rect2, true) ;
 
    pSelected[0].x=0;
    pSelected[0].y=0;
    pSelected[1].x=0;
    pSelected[1].y=0;

   }

   bPrompt=true;
   //if(iPrompt==0)
    //EnableMenuItem ((HMENU) wParam, IDM_APP_PROMPT,  MF_GRAYED) ;
   break;
  }
  return 0 ;
 case WM_LBUTTONUP:
  //取得鼠标坐标
  x= LOWORD (lParam)/(cxBack-3);
  y= ( HIWORD (lParam)+30)/(cyBack-4);
  if (x>=1 && x<=M-2 && y>=1 && y<=N-2 && linker.get_element(x,y)!=0 )
  {
  /*
  sprintf(szBuffer,"%d",y);
  MessageBox (hwnd, TEXT (szBuffer),
    szAppName, MB_YESNO | MB_ICONQUESTION) ;*/
  //如果是在第一张牌按下鼠标
  if(pSelected[0].x==0 && pSelected[0].y==0 )
  {
   //hBrush = GetStockObject (GRAY_BRUSH) ;
   //SelectObject (hdc, hBrush) ;
   
   //hdc = BeginPaint (hwnd, &ps) ;
   //SelectObject (hdc, GetStockObject (BLACK_PEN)) ;

   //在该牌上画圆
    rect.left = x *(cxBack-3);
    rect.right = rect.left+(cxBack-3)+3;
    rect.top  = y *(cyBack-4)-30;
    rect.bottom = rect.top + (cyBack-4)+4;
    //Ellipse(hdc,rect.left ,rect.top ,rect.right ,rect.bottom );
    InvalidateRect (hwnd, &rect, true) ;
    //EndPaint (hwnd, &ps) ;
   //把牌的位置记录下来
   pSelected[0].x=x;
   pSelected[0].y=y;
  }
  else
  { //如果是第二张牌上按鼠标

   //把牌的位置记录下来
   pSelected[1].x=x;
   pSelected[1].y=y;

  
   if( (pSelected[0].x!=pSelected[1].x ||
    pSelected[0].y!=pSelected[1].y) &&
    linker.is_matched(pSelected[0],pSelected[1]) )
   {//如果不是同一张牌并且花色一致
    
    //寻找路径
    find=linker.man_search(pSelected[0],pSelected[1])
     || linker.man_search(pSelected[1],pSelected[0]);;

    if(find)
    {//找到

     //GetClientRect (hwnd, &rect) ;
     rect.left = pSelected[0].x *(cxBack-3);
     rect.right = rect.left+(cxBack-3)+3;
     rect.top  = pSelected[0].y *(cyBack-4)-30;
     rect.bottom = rect.top + (cyBack-4)+4;
     InvalidateRect (hwnd, &rect, true) ;

     rect.left = pSelected[1].x *(cxBack-3);
     rect.right = rect.left+(cxBack-3)+3;
     rect.top  = pSelected[1].y *(cyBack-4)-30;
     rect.bottom = rect.top + (cyBack-4)+4;
     InvalidateRect (hwnd, &rect, true) ;

     rect.left=0;
     rect.right=0 ;
     rect.top=0;
     rect.bottom=0;

     iCount++;
     iTime+=2;

     PlaySound (TEXT ("yes.wav"), NULL, SND_FILENAME | SND_ASYNC) ;

     //InvalidateRect (hwnd, NULL, true) ;

    }
    else
    {//没找到
    /*
     sprintf(szBuffer,"%d",find);
     MessageBox (hwnd, TEXT (szBuffer),
     szAppName, MB_YESNO | MB_ICONQUESTION) ;*/

     rect.left = pSelected[0].x *(cxBack-3);
     rect.right = rect.left+(cxBack-3)+3;
     rect.top  = pSelected[0].y *(cyBack-4)-30;
     rect.bottom = rect.top + (cyBack-4)+4;
     InvalidateRect (hwnd, &rect, true) ;

     rect.left=0;
     rect.right=0 ;
     rect.top=0;
     rect.bottom=0;
     PlaySound (TEXT ("no.wav"), NULL, SND_FILENAME | SND_ASYNC) ;
    
    }
    pSelected[0].x=0;
    pSelected[0].y=0;
    pSelected[1].x=0;
    pSelected[1].y=0;

    
   }
   else
   {//同一张牌或花色不一致

    rect.left = pSelected[0].x *(cxBack-3);
    rect.right = rect.left+(cxBack-3)+3;
    rect.top  = pSelected[0].y *(cyBack-4)-30;
    rect.bottom = rect.top + (cyBack-4)+4;
    InvalidateRect (hwnd, &rect, true) ;

    pSelected[0].x=x;
    pSelected[0].y=y;
    pSelected[1].x=0;
    pSelected[1].y=0;

    rect.left = pSelected[0].x *(cxBack-3);
    rect.right = rect.left+(cxBack-3)+3;
    rect.top  = pSelected[0].y *(cyBack-4)-30;
    rect.bottom = rect.top + (cyBack-4)+4;
    InvalidateRect (hwnd, &rect, true) ;
    /*
    rect.left=0;
    rect.right=0 ;
    rect.top=0;
    rect.bottom=0;*/
   }
  

  }
  }

  if( iCount==(M-2)*(N-2)/2 )
  { 
   iCount=0;
   KillTimer (hwnd, TimerID) ;
   MessageBox (hwnd, TEXT ("恭喜你，你赢了!!"),szAppName, MB_OK | MB_ICONQUESTION) ;

   SendMessage(hwnd,WM_COMMAND,IDM_APP_START,0);
  }
  return 0;
  

 case WM_CLOSE://用户关闭程序
  if ( IDYES == MessageBox (hwnd, TEXT ("确认关闭程序"),
    szAppName, MB_YESNO | MB_ICONQUESTION) )
  //弹出确认窗口，按YES退出程序
  {
   PlaySound (TEXT ("close.wav"), NULL, SND_FILENAME | SND_ASYNC) ;
   KillTimer (hwnd, TimerID) ;
   DestroyWindow (hwnd) ;
   Sleep(2000);
  }
  return 0 ;
 case WM_DESTROY:
  
  PostQuitMessage (0) ;
  return 0 ;
 }

 return DefWindowProc (hwnd, message, wParam, lParam) ;
}

GNU Chess is a chess program from the Free Software Foundation.

Version 5

The GNU Chess 5 series is a completely new chess program that shares no code with versions 1-4. GNU Chess 5.00 was announced by Stuart Cracraft and Chua Kong-Sian on 10 October 1999. Here is the announcement that Stuart posted to Usenet.

I'm not involved with the development of GNU Chess 5 and am no longer the GNU Chess FAQ maintainer. The new program looks nice, and I hope the authors continue to develop it.

For information about GNU Chess 5, see the GNU Chess page on the GNU web site. See also the gnu.chess newsgroup.

GNU Chess 5 works with XBoard and WinBoard. The current version of the WinBoard self-installer has both GNU Chess 4 and GNU Chess 5 bundled in with it.

Old versions

Although GNU Chess 4 is no longer being developed, it is still of some interest to folks who like to study and compare chess engines. Here is a small collection of old versions that I've kept. The "Source code" versions can be compiled for Windows to work with WinBoard, or for Unix to work with XBoard. The "Windows ports" use their own custom graphical interface, not WinBoard.

• Source code
  • GNU Chess 4.0 patchlevel 80
  • GNU Chess 4.0 patchlevel 79
  • GNU Chess 4.0 patchlevel 78
  • GNU Chess 4.0 patchlevel 77
  • GNU Chess 4.0 patchlevel 75
  • GNU Chess 3.1+

• Windows ports
  • GNU Chess for Windows 4.15 (Conor McCarthy)
  • GNU Chess for Windows 4.14 (Conor McCarthy)
  • GNU Chess for Windows 3.21 (Daryl Baker)

• Macintosh ports
  • GNU Chess for Macintosh 4.0b5 (Dan Oetting)
    README file / executable / source

Also see Dann Corbit's FTP site for versions of GNU Chess 4 that Dann has patched to fix some bugs.

Information for authors

If you are writing a chess engine and you want it to work with xboard/WinBoard, or if you are writing a user interface and want it to work with these engines, please read the Chess Engine Communication Protocol document, and consider joining the mailing list for engine authors, hosted at http://groups.yahoo.com/group/chess-engines/.

Information for players

Here is a partial list of chess engines (programs that play chess) that work with xboard and/or WinBoard.

I am currently not keeping this list updated. The last update was November 2002. For an up-to-date list of WinBoard engines with information about each one, see Leo Dijksman's web site. For announcements of new engines, see Leo's site and the WinBoard Forum. To be able to use still more engines, see my Extensions and Drivers page for drivers that allow some Auto232 and UCI engines to work with WinBoard. For help getting started with alternative chess engines, see Aaron Tay's FAQ, as well as the other links on my Chess Web Sites page.

Disclaimers: I have not tried most of these engines, so I can't guarantee they will work for you or offer help installing them. Contact the author of each engine if you need help with it beyond what is provided in its documentation. The list is in alphabetical order, not in order of merit.

1. 31337
2. Adam
3. Abrok
4. Alarm (not released yet)
5. Aldebaran
6. Amateur
7. Amundsen
8. Amy
9. Amyan
10. AnMon
11. Ant
12. Arasan
13. Aristarch
14. Armageddon
15. Asterisk
16. Averno
17. Awesome
18. Ax
19. Baby Chess
20. BACE (also known as BCE)
21. Baron
22. Beaches
23. Belzebub
24. Beowulf
25. Bestia
26. Betsy
27. BigBook
28. BigLion
29. Bionic Impakt
30. Blikskottel
31. BremboCE
32. Bringer (also known as Der Bringer)
33. BSC
34. Butcher (also known as Rzeznik)
35. Capture (commercial)
36. Cefap
37. Chad's Chess
38. Chess-Rikus
39. ChessterfieldCL
40. ChessThinker
41. Chezzz
42. Cilian
43. ColChess
44. Comet
45. Cpp1
46. Crafty
47. Crux
48. CyberPagno
49. Damas
50. DChess
51. Deep Bug (bughouse and crazyhouse only)
52. Deep Trouble
53. Defeo (plays a Czech variant of crazyhouse called "tetris holandany")
54. Delfi
55. Dragon
56. Duke
57. Embracer
58. EnginMax
59. Esc
60. EXchess
61. Faile
62. Fauce
63. Fimbulwinter
64. Fortress
65. Francesca
66. Frenzee (formerly ChessCraft)
67. Freyr
68. Gandalf (commercial)
69. Gargamella
70. Gaviota
71. Gedeone
72. Genesis
73. Gerbil
74. Ghost
75. Giveaway Wizard (aka Losing Chess Wizard) - see also
76. GNU Chess
77. Golem
78. Green Light Chess
79. GreKo
80. Grizzly
81. Gromit
82. Gullydeckel
83. Hagrid
84. Holmes
85. Horizon
86. Inmichess
87. Jester
88. KACE
89. Kaissa2
90. KasparovX
91. King of Kings
92. KnightCap - bug fix
93. KnightDreamer
94. Knightx (also known as Techno Chess)
95. La Dame Blanche
96. LadyGambit
97. lambChop
98. LaMoSca
99. LarsenVB
100. Leila
101. List
102. Little Goliath
103. LordKing
104. Madeleine
105. Matheus
106. MFChess
107. Mint
108. Monarch
109. Monik
110. Mooboo
111. Morphy
112. Movei
113. Mr Chess (formerly Dr Chess)
114. MSCP
115. Muriel (aka KDLChess)
116. Mustang
117. Mystery
118. Nejmet
119. Nero
120. Nimzo (commercial)
121. NoonianChess
122. OliThink
123. Ozwald
124. Patzer (commercial)
125. Pentagon - dead link?
126. Pepito
127. Phalanx - alternate link
128. Pharaon (formerly ZChess)
129. Pierre
130. PolarChess
131. PreChess
132. Pyotr
133. Quark
134. Queen
135. Raffaela
136. RDChess
137. Replicant
138. Requiem
139. Resp
140. Rival Chess (also known as NewRival)
141. Robin
142. RoboKewlper
143. Ruffian
144. Sachy
145. SdBC
146. Siboney
147. Sjeng (also plays several chess variants)
148. Skaki
149. Small Potato (also known as unches)
150. SmarThink
151. SnailChess
152. Soldat
153. SOS
154. SSEChess
155. StAndersen
156. Stan's Chess
157. Storm
158. StrategicDeep
159. Sunsetter (also plays bughouse and crazyhouse)
160. Tamerlane
161. Tao
162. Terra
163. The Crazy Bishop
164. The King (commercial, part of Chessmaster 8000) - alternate Web page - how to use with WinBoard.
165. TheLightning
166. Tikov
167. T-Rex
168. Tristram
169. Trynyty
170. TSCP (Tom Kerrigan's Simple Chess Program)
171. Ufim
172. WildCat
173. WJChess
174. Yace
175. YAWCE
176. Zephyr

  说了这么久，都是主程序的调用，而so中应该如何呢？其实也很简单：
  class TMyObj1 : public TMyObj
  {
  public:
    TMyObj1(void);
    ~TMyObj1(void);

    static void onStaticInit(void);
    static void onStaticDestroy(void);
    static const char * getVersion(void);
    static const char * getObjectName(void);
    
    virtual int  func(void);
  };
  
  DECLARE_SO_INTERFACE(TMyObj1);
  
  DECLARE_SO_INTERFACE其实是一个为了方便编写程序而定义的宏:
  #define DECLARE_SO_INTERFACE(x) extern "C" { \
    void onInstallDLL(void);   \
    void onUninstallDLL(void);   \
    const char * onGetVersion(void); \
    const char * onObjectName(void); \
    void * onCreateObject(void ** ppException);  \
   }; \
   void onInstallDLL(void) { x::onStaticInit(); }    \
   void onUninstallDLL(void) { x::onStaticDestroy(); }  \
   const char * onGetVersion(void) { return x::getVersion(); }  \
   const char * onObjectName(void) { return x::getObjectName(); } \
   void * onCreateObject(void ** pException) { \
    try { \
     *pException = NULL; x * p = new x(); return (void *)p; \
    }catch(std::exception & e) { \
     *pException = new std::exception(e); \
     return NULL;  \
    } \
   }
   
  可以看到除了导出onCreateObject函数以外，还导出了：
  TMyObj1::onStaticInit用于载入so的时候执行初始化操作；
  TMyObj1::onStaticDestroy用于卸载so的时候执行清理操作；
  TMyObj1::getVersion 获得对象的版本信息
  TMyObj1::onObjectName 获得对象名信息等
  可以扩展前面的TObjFactory，实现这些功能。

  同理，我们可以做obj2.so：
  class TMyObj2 : public TMyObj
  {
  public:
   TMyObj2(void);
   ~TMyObj2(void);
  
   static void onStaticInit(void);
   static void onStaticDestroy(void);
   static const char * getVersion(void);
   static const char * getObjectName(void);
  
   virtual int  func(void);
  };
  
  DECLARE_SO_INTERFACE(TMyObj2);
  
  
  另外，一个值得讨论的问题是：C++由于没有反射机制，所以无法实现设值注入和构造注入，只能实现接口注入。不过一般来说也已经足够使用了。

目录

1.设计父类时考虑不周到，等到设计或者编写子类