c语言课程设计中国象棋
中国象棋程序课程设计
中国象棋程序课程设计一、课程目标知识目标：1. 学生能够理解中国象棋的基本规则，掌握棋谱的阅读和编写方法。
2. 学生能够描述中国象棋程序的编程思路和算法，了解其运作原理。
3. 学生能够运用所学知识，分析和优化中国象棋程序的性能。
技能目标：1. 学生能够运用编程语言，独立编写一个简单的中国象棋程序。
2. 学生能够通过调试和修改程序，提高程序的稳定性和棋力。
3. 学生能够运用逻辑思维和问题分析能力，解决中国象棋程序中出现的问题。
情感态度价值观目标：1. 学生培养对中国传统文化的热爱，增强民族自豪感。
2. 学生通过团队协作和交流，培养合作精神和沟通能力。
3. 学生在面对挑战时，保持积极的心态，勇于尝试和克服困难。
课程性质：本课程为信息技术与传统文化相结合的课程，旨在培养学生的编程能力、逻辑思维和问题解决能力。
学生特点：初中生，具有一定的信息技术基础，对中国象棋有一定的了解，好奇心强，喜欢探索和挑战。
教学要求：结合学生特点，注重理论与实践相结合，强调学生的动手实践和创新能力，提高学生的综合素质。
通过本课程的学习，使学生能够将所学知识应用于实际编程中，培养他们对中国传统文化的兴趣和热爱。
同时，关注学生的学习过程，将课程目标分解为具体的学习成果，便于教学设计和评估。
二、教学内容1. 中国象棋基本规则及棋谱阅读：讲解中国象棋的历史、棋盘布局、棋子走法及胜负判定方法，使学生了解并掌握棋谱的阅读和编写。
教学内容安排：教材第1章“中国象棋概述”2. 编程基础及中国象棋程序设计思路：介绍编程基础知识，如变量、循环、条件判断等，并讲解中国象棋程序的编程思路和算法。
教学内容安排：教材第2章“编程基础”和第3章“中国象棋程序设计”3. 中国象棋程序编写与调试：指导学生运用所学编程知识，编写简单的中国象棋程序，并通过调试和修改，提高程序的稳定性和棋力。
教学内容安排：教材第4章“程序编写与调试”4. 程序优化与性能分析：教授学生如何分析程序性能，介绍优化方法，使学生在实践中提高中国象棋程序的棋力。
mfc中国象棋课程设计
mfc中国象棋课程设计一、课程目标知识目标：1. 学生能理解中国象棋的基本规则，掌握棋盘布局、棋子走法及各类棋局的命名。
2. 学生能了解中国象棋的历史起源，理解其在中国传统文化中的地位。
3. 学生能掌握MFC（Microsoft Foundation Classes）编程环境下中国象棋游戏的开发基础。
技能目标：1. 学生能运用MFC编程技术，设计并实现一个具有基本功能的中国象棋游戏。
2. 学生通过编程实践，培养逻辑思维能力和问题解决能力。
3. 学生通过团队协作，提高沟通能力和项目协作能力。
情感态度价值观目标：1. 学生培养对中国传统文化的兴趣，弘扬和传承国粹。
2. 学生在编程过程中，树立正确的价值观，遵循编程道德规范。
3. 学生在团队协作中，学会尊重他人，培养团结互助的精神。
课程性质：本课程为信息技术与学科融合课程，结合中国象棋传统文化，培养学生编程兴趣和实践能力。
学生特点：六年级学生具备一定的计算机操作基础和逻辑思维能力，对中国象棋有一定了解。
教学要求：注重理论与实践相结合，以学生为主体，激发学生的学习兴趣和探究精神，培养其团队协作能力和创新意识。
通过本课程的学习，使学生能够将所学知识应用于实际项目中，达到学以致用的目的。
二、教学内容1. 中国象棋基础知识：- 棋盘布局与棋子走法- 常见棋局命名及战术分析- 中国象棋历史与文化背景2. MFC编程基础：- MFC概述与编程环境搭建- MFC常用类及其功能- MFC事件处理与消息映射机制3. 中国象棋游戏设计与实现：- 游戏界面设计- 棋子控制与走法逻辑实现- 棋局胜负判定算法- 游戏规则与提示功能设计4. 项目实践与团队协作：- 学生分组，明确项目任务与分工- 编程实践与功能模块实现- 团队沟通与协作，解决开发过程中遇到的问题- 项目总结与成果展示教学内容安排与进度：第一周：中国象棋基础知识学习，MFC编程环境搭建与基本概念介绍第二周：MFC常用类学习，设计游戏界面第三周：实现棋子控制与走法逻辑，学习棋局胜负判定算法第四周：完善游戏规则与提示功能，进行项目实践与团队协作第五周：项目总结与成果展示，交流与反馈教材关联章节：《信息技术》：《MFC编程与应用》相关章节；《中国象棋》相关章节。
象棋游戏的设计C
中国象棋游戏的设计与实现摘要本文首先研究了中国象棋在计算机中的表示问题;接着讨论如何产生着法一系列相关内容..其次研究了博弈树的极小极大搜索技术及在此基础上发展起来的Alpha-Beta剪枝算法;使用MFC文档视图体系结构和Visual C++开发工具;实现了一个具有一定棋力的中国象棋人机对弈程序..象棋程序的实现可以被分为人工智能和界面程序辅助两大部分..人工智能部分主要体现计算机的下棋思路;既计算机如何进行思考并以最佳走法完成下一步;先由相应的搜索算法进行搜索;并对各种可能的走法进行估值;从中选择胜利面最大的一步；而界面及程序辅助部分主要便于用户通过以前的下棋步骤;更好地调整下棋思路;着法显示使用户能够清楚地知道下棋过程;更准确地把握整个局面..关键词：中国象棋；人工智能；博弈树；Alpha-Beta搜索The Design and Implementation of Chinese ChessAbstractThe implementation of a chess program can be decomposed into two major parts: the artificial intelligence and the user interface and program assist. The part of artificial intelligence shows the way of computer thinking; and which step is the best step would be decided by it. Firstly; the computer uses search algorithms to search; and then evaluates every impossible step; finally choses the best one; the other part is used for the player to adjust his thought to the currently phases. The display of step list makes player know the process of chess distinctly; and let player make a better choice.This paper firstly studies how to represent a chess board in computer; then discusses how to generate legal moves. Secondly; this paper studies the mini-max searching procedure of Game Tree; and the Alpha-Beta pruning algorithm. A Chess-playing system is designed and developed; which is built on the integrated computer MFC SDI document view architecture by using Visual C++.Key words:Chinese chess; Artificial Intelligence; Game tree; Alpha-Beta searching目录论文总页数：22页1引言1.1象棋设计背景和研究意义电脑游戏行业经过二十年的发展;已经成为与影视、音乐等并驾齐驱的全球最重要的娱乐产业之一;其年销售额超过好莱坞的全年收入..游戏;作为一种娱乐活动..早期的人类社会由于生产力及科技的制约;只能进行一些户外的游戏..随着生产力的发展和科技进步;一种新的游戏方式——电子游戏也随之诞生..当计算机发明以后;电子游戏又多了一个新的载体..电子游戏在整个计算机产业的带动下不断地创新、发展着..自从计算机发明;向各个领域发展;到成为我们现在每天工作和生活必不可少的一部分的这个过程中;电子游戏也逐步渗入我们每个人的娱乐活动中..而计算机已经普及的今天;对于可以用计算机进行程序编辑的人来说;开发属于自己的游戏;已经不再是梦想..事实上;个人计算机软件市场的大约80%销售份额是来自游戏软件..棋牌游戏属于休闲类游戏;相对于角色扮演类游戏和即时战略类游戏等其它游戏;具有上手快、游戏时间短的特点;更利于用户进行放松休闲;为人们所喜爱;特别是棋类游戏;方便、快捷、操作简单;在休闲娱乐中占主要位置..作为中华民族悠久文化的代表之一;中国象棋不仅源远流长;而且基础广泛;作为一项智力运动;中国象棋开始走向世界..随着计算机处理速度的飞速提高;人们很早就提出了疑问：计算机是否会超越人类世界国际象棋大师已被计算机打败;计算机已经超过了人类而人工智能是综合性很强的一门边缘学科;它的中心任务是研究如何使计算机去做那些过去只能靠人的智力才能做的工作..因此;对游戏开发过程中的人工智能技术的研究自然也就成了业界的一个热门研究方向..1.2象棋设计研究方法对于象棋来说;核心设计主要包括人工智能算法的以及整个游戏中界面及程序辅助部分的实现;主要用 Visual C++ 进行开发;里面的MFC类库;使游戏开发更加方便;并利用人工智能相关搜索算法实现人工智能的着法生成;从而完善整个游戏的功能..本文的目标是实现一款有着一定下棋水平且交互友好的中国象棋人机对弈程序..该程序功能包括：人机对弈；搜索深度设定；电脑棋力选择悔棋、还原；着法名称显示；整个程序的实现可分为两大部分：一、人工智能算法设计计算机下棋引擎该部分实现了如何让计算机下中国象棋;其中涉及人机对弈的基本理论及思想;是该程序的核心部分;同时也是本项目研究的重点所在..二、界面及程序辅助设计光有下棋引擎尚不能满足人机交互的基本要求;因此还需要一个框架界面来作为引擎的载体;同时提供一些诸如悔棋;还原之类的附属功能程序辅助..下面分别介绍各部分实现..由于界面及程序辅助部分涉及内容宽泛而又繁琐;因而本文只介绍其中重点部分..2人工智能算法设计程序的基本框架：从程序的结构上讲;大体上可以将引擎部分划分为四大块：棋局表示；着法生成；搜索算法；局面评估..程序的大概的思想是：首先使用一个数据结构来描述棋局信息;对某一特定的棋局信息由着法生成器生成当前下棋方所有合法的着法并依次存入着法队列..然后通过搜索算法来逐一读取着法并调用局面评估函数对该着法所产生的后继局面进行评估打分;从中选出一个最有可能导致走棋方取胜的着法..在搜索的过程中还可以采用一些辅助手段来提高搜索的效率..其过程如下所示图1：图 1 程序结构图下面将分别介绍程序各个部分：2.1棋局表示计算机下棋的前提是要让计算机读懂象棋..所谓读懂;即计算机应该能够清楚地了解到棋盘上的局面棋盘上棋子的分布情况以及下棋方所走的每一种着法..因而首先需要设计一套数据结构来表示棋盘上的局面以及着法..对于棋盘局面的表示可采用传统而简单的“棋盘数组”..即用一个910的数组来存储棋盘上的信息;数组的每个元素存储棋盘上是否有棋子..这种表示方法简单易行缺点是效率不是很高..按此方法棋盘的初始情形如下所示：BYTE CChessBoard910 = {R; 0; 0; P; 0; 0; p; 0; 0; r;H; 0; C; 0; 0; 0; 0; c; 0; h;E; 0; 0; P; 0; 0; p; 0; 0; e;A; 0; 0; 0; 0; 0; 0; 0; 0; a;K; 0; 0; P; 0; 0; p; 0; 0; k;A; 0; 0; 0; 0; 0; 0; 0; 0; a;E; 0; 0; P; 0; 0; p; 0; 0; e;H; 0; C; 0; 0; 0; 0; c; 0; h;R; 0; 0; P; 0; 0; p; 0; 0; r};给所有棋子定义一个值：define R_BEGIN R_KINGdefine R_END R_PAWNdefine B_BEGIN B_KINGdefine B_END B_PAWNdefine NOCHESS 0 //没有棋子黑方：define B_KING 1 //黑帅define B_CAR 2 //黑车define B_HORSE 3 //黑马define B_CANON 4 //黑炮define B_BISHOP 5 //黑士define B_ELEPHANT 6 //黑象define B_PAWN 7 //黑卒红方：define R_KING 8 //红将define R_CAR 9 //红车define R_HORSE 10//红马define R_CANON 11//红炮define R_BISHOP 12//红士define R_ELEPHANT 13//红相define R_PAWN 14//红兵判断颜色：define IsBlackx x>=B_BEGIN && x<=B_END//判断某个棋子是不是黑色define IsRedx x>=R_BEGIN && x<=R_END//判断某个棋子是不是红色对于着法的表示;直接借用棋盘数组的下标来记录着法的起点和目标点..至于是什么棋子在走;以及是否吃子、吃的是什么子;在着法结构中并不记录..这些信息由外部读取棋盘上起点、终点的数据获得..着法结构定义如下;其中还包含了对着法的历史得分的记录项;以供后面要讲到的“历史启发”所用..typedef struct{short nChessID; //表明是什么棋子CHESSMANPOS From;//起始位置CHESSMANPOS To; //走到什么位置int Score; //走法的分数}CHESSMOVE;有了对棋盘局面和着法的表示之后;程序才能够完成以下操作：1、生成所有合法着法；2、执行着法、撤销着法；3、针对某一局面进行评估..因而;棋局表示好比是整个程序计算机下棋引擎部分的地基;之后所有的操作都将建立在其基础上..2.2着法生成程序需要让计算机在轮到它走子的时候能够执行一步它认为对它最有利的着法;那前提就是它要有诸多也可能是唯一可供选择的着法;提供所有候选着法的“清单”就是着法生成器所要完成的..之后用搜索函数来搜索“清单”;并用局面评估函数来逐一打分;最后就可以选择出“最佳着法”并执行了..在着法生成器中;采用的基本思想就是遍历整个棋盘一个接一个地查看棋盘上的每个位置点;当发现有当前下棋方的棋子时先判断它是何种类型的棋子;然后根据其棋子类型而相应地找出其所有合法着法并存入着法队列..这里谈到的“合法着法”包括以下几点：1、各棋子按其行子规则行子..诸如马跳“日”字、象走“田”字、士在九宫内斜行等等这里需要特别注意的是卒兵的行子规则会随其所在位置的不同而发生变化——过河后可以左右平移..2、行子不能越出棋盘的界限..当然所有子都不能走到棋盘的外面;同时某些特定的子还有自己的行棋界限;如将、士不能出九宫;象不能过河..3、行子的半路上不能有其它子阻拦除了炮需要隔一个子才能打子之外以及行子的目的点不能有本方的棋子当然不能自己吃自己了..4、将帅不能碰面本程序中只在生成计算机的着法时认为将帅碰面是非法的;而对用户所走的导致将帅碰面的着法并不认为其非法;而只是产生败局罢了..产生了着法后要将其存入着法队列以供搜索之用;由于搜索会搜索多层即考虑双方你来我往好几步;这样才有利于对局面进行评估以尽可能避免“目光短浅”;所以在把着法存入着法队列的时候还要同时存储该着法所属的搜索层数..因此可以将着法队列定义为二维数组m_MoveList880;其中第一个数组下标为层数;第二个数组下标为每一层的全部着法数..关于搜索层数;设定为8;实际使用的是1到7在界面中将其限定为1—7..搜索层数的增加会显着提高电脑的下棋水平当然计算机的棋力在很大程度上也依赖于局面评估..在配置为 1.5G;512M内存的计算机上最多只能搜索4层;再多将导致搜索时间达到令人无法容忍的地步这里还需要特别说明的是;搜索的速度也和着法生成的效率以及局面评估的复杂度有关;因为每分析一个结点都要执行这两种操作..对于每一层的着法数;也就是当前下棋方针对当前局面的所有可选的合法着法;据有关数据统计在象棋实战中一般最多情况下也就五六十种..定义第二个数组下标为80;应当可以保证十分的安全..着法生成为搜索部分提供了“原料”;接下来的任务就交给搜索和局面评估了..2.3搜索算法搜索算法对于整个下棋引擎来说都是至关重要的..它如同程序的心脏;驱动着整个程序..搜索算法的好坏直接影响着程序执行的效率从某种角度上;它影响着计算机的下棋水平..因为;计算机必须在有限的时间内完成思考;搜索速度快意味着在相同的时间内程序可以“看”得更远;“想”的更多..关于棋类对弈程序中的搜索算法;已有成熟的Alpha-Beta搜索算法以及其它一些辅助增强算法还有众多基于Alpha-Beta算法的派生、变种算法在程序中直接借鉴了Alpha-Beta搜索算法并辅以了历史启发..本节先介绍Alpha-Beta搜索算法：在中国象棋里;双方棋手获得相同的棋盘信息..他们轮流走棋;目的就是将死对方;或者避免被将死..由此;可以用一棵“博弈树”图2来表示下棋的过程——树中每一个结点代表棋盘上的一个局面;对每一个局面结点根据不同的走法又产生不同的局面生出新的结点;如此不断直到再无可选择的走法;即到达叶子结点棋局结束..中国象棋的博弈树的模型大概如下图所示;可以把其中连接结点的线段看作是着法;不同的着法自然产生不同的局面..图 2博弈树该树包含三种类型的结点：1、奇数层的中间结点以及根结点;表示轮到红方走棋；2、偶数层的中间结点;表示轮到黑方走棋；3、叶子结点;表示棋局结束..现在让计算机来下中国象棋;它应当选择一步对它最有利的着法最终导致它取胜的着法..获得最佳着法的方法就是“试走”每一种可能的着法;比较它们所产生的不同后果;然后从中选出能够产生对自己最有利的局面的着法..结合上面所讲的博弈树;若给每个结点都打一个分值来评价其对应的局面这一任务由后面所讲的局面评估来完成;那么可以通过比较该分值的大小来判断局面的优劣..假定甲乙两方下棋;甲胜的局面是一个极大值一个很大的正数;那么乙胜的局面就是一个极小值极大值的负值;和棋的局面则是零值或是接近零的值..如此;当轮到甲走棋时他会尽可能地让局面上的分值大;相反轮到乙走棋时他会选尽可能地让局面上的分值小..反映到博弈树上;即如果假设奇数层表示轮到甲方走棋;偶数层表示轮到乙方走棋..那么由于甲方希望棋盘上的分值尽可能大;则在偶数层上会挑选分值最大的结点——偶数层的结点是甲走完一步棋之后的棋盘局面;反映了甲方对棋局形势的要求..同样道理;由于乙方希望棋盘上的分值尽可能小;那么在奇数层上会选择分值最小的结点..这是“最小-最大”Minimax的基本思想..这样搜索函数在估值函数的协助下可以通过在奇数层选择分值最大最小的结点;在偶数层选择分值最小最大的结点的方式来搜索以当前局面为根结点、限定搜索层数以内的整棵树来获得一个最佳的着法..然而不幸的是;博弈树相当庞大它会成指数增长;因而搜索限定层数以内的整棵树是一件相当费时的工作——其时间复杂度为Obn..其中b是分枝因子;即针对各种局面的合法着法的数目的平均值;n是搜索的深度..对于中国象棋而言;在中盘时平均着法数目大约是40种左右;那么搜索4层需要检查250万条路线;搜索5层需要检查1亿条路线;搜索6层需要检查40亿条路线Alpha-Beta搜索能在不影响搜索精度的前提下大幅减少工作量..因为;如果考虑到下棋是一个你来我往的交替进行并且相互“较劲”的过程..由于每一方都会尽可能将局面导向对自己有利而对对方不利的方向假定下棋双方对棋局有着同样的认知;即你认为对你很糟糕的局面;在你的对手看来则是对他很有利的局面;那么某些局面由于能够产生出很糟糕的局面因而根本没有再继续考虑的价值..所以当你看到某个局面有可能产生很糟糕的局面时确切地说这里的“很糟糕”是与之前分析的情况相比较而言的;你应当立刻停止对其剩余子结点的分析——不要对它再抱任何幻想了;如果你选择了它;那么你必将得到那个很糟糕的局面;甚至可能更糟……这样一来便可以在很大程度上减少搜索的工作量;提高搜索效率;这称为“树的裁剪”..下面用图来进一步说明“树的裁剪”..为了简便起见;将博弈树进行了简化——每个结点只有三个分支;实际情况中;刚才讲过在盘中应有大约40个分支..假定棋盘上的局面发展到了结点A图3;现在轮到你走棋了;你是“最大的一方”——即你希望棋局的分值尽可能的高..用搜索两层来看一看“树的裁剪”对提高搜索效率的帮助..图中表示该结点要取子结点中的最大值；表示该结点要取子结点中的最小值..图3 树的裁剪首先;考察结点A的子结点B..结点B所属的这一层是轮到你的对手——“最小者”来走棋了;目的是使得棋局的分值尽可能的小..依次考察结点B的各个子结点;查看它们的分值因为事先约定好了搜索两层;现在已达到搜索深度的要求了;所以就停下来调用局面评估函数来给它打分..结点B的第一个子结点从左到右算起返回10;第二个子结点返回了-5;第三个子结点返回了2..由于结点B这层是你的对手来做选择;假设他一定会做出明智的选择你不能寄希望于你的对手会走出一步“昏招”;那么他会选择返回值为-5的那个结点..-5最终也就成了从结点B传递回的值;即倘若你现在位于结点A选择了产生结点B的走法;使得局面发展到了结点B..那么下一步;你的对手的选择就会使得棋局发展成为分值为-5的那个结点所表示的局面..再来分析结点A的第二个子结点C;结点C与结点B同属一层;它依然是轮到你的对手作选择..依次查看结点C的各个子结点的分值;其第一个子结点返回了-8……采用“裁剪”方法..不必再继续考察结点C的剩余子结点了;因为结点C已经够糟糕的了;不管结点C的剩余子结点有怎样的分值;它最多只能传回-8有可能其剩余子结点中还有分值更小的结点;因而结点C还有可能传回更小的值..而与前面已经分析过的结点B所传回-5相比较;作为“最大一方”的你显然更不愿意看到-8的局面..所以;你当然不会选择相应的着法使得局面发展成为结点 C..因为那样的话;下一步你的对手就会带给你一个分值不高于-8的局面..由此;在不影响搜索质量的前提下避免了搜索“无价值的”结点C的剩余子结点的大量工作;从而节省了宝贵时间;为在同样机器配置下搜索更多的层数提供了可能..“最小-最大”的思想再加上“对树的裁剪”;这就是Alpha-Beta搜索算法的核心..最基本的Alpha-Beta算法的代码如下：int AlphaBetaint depth; int alpha; int beta{if depth == 0 //如果是叶子节点到达搜索深度要求return Evaluate; //则由局面评估函数返回估值GenerateLegalMoves; //产生所有合法着法while MovesLeft //遍历所有着法{MakeNextMove; //执行着法int val = -AlphaBetadepth - 1; -beta; -alpha; //递归调用UnmakeMove; //撤销着法if val >= beta //裁剪return beta;if val > alpha //保留最大值alpha = val;}return alpha;}2.4历史启发及着法排序既然Alpha-Beta搜索算法是在“最小-最大”的基础上引入“树的裁剪”的思想以期提高效率;那么它的效率将在很大程度上取决于树的结构——如果搜索了没多久就发现可以进行“裁剪”了;那么需要分析的工作量将大大减少;效率自然也就大大提高；而如果直至分析了所有的可能性之后才能做出“裁剪”操作;那此时“裁剪”也已经失去了它原有的价值因为你已经分析了所有情况;这时的Alpha-Beta搜索已和“最小-最大”搜索别无二致了..因而;要想保证Alpha-Beta搜索算法的效率就需要调整树的结构;即调整待搜索的结点的顺序;使得“裁剪”可以尽可能早地发生..可以根据部分已经搜索过的结果来调整将要搜索的结点的顺序..因为;通常当一个局面经过搜索被认为较好时;其子结点中往往有一些与它相似的局面如个别无关紧要的棋子位置有所不同也是较好的..由J.Schaeffer所提出的“历史启发”History Heuristic就是建立在这样一种观点之上的..在搜索的过程中;每当发现一个好的走法;就给该走法累加一个增量以记录其“历史得分”;一个多次被搜索并认为是好的走法的“历史得分”就会较高..对于即将搜索的结点;按照“历史得分”的高低对它们进行排序;保证较好的走法“历史得分”高的走法排在前面;这样Alpha-Beta搜索就可以尽可能早地进行“裁剪”;从而保证了搜索的效率..对于着法的排序可以使用各种排序算法;在程序中采用了归并排序..归并排序的空间复杂度为On;时间复杂度为Onlog2n;具有较高的效率..2.5局面评估前文已经讲过了棋局表示、着法生成、搜索算法包括搜索辅助; 在象棋程序中如果说搜索算法是心脏;那么局面评估就是大脑..搜索算法负责驱动整个程序;而局面评估则负责对搜索的内容进行判断和评价..因而搜索与局面评估是整个下棋引擎的核心..首先;先介绍一下在局面评估中需要考虑的因素..就不同的棋类可能要考虑的因素略有差异..在中国象棋中所要考虑的最基本的几个因素包括如下四点：1、子力总和子力是指某一棋子本身所具有的价值..通俗地讲就是一个棋子它值个什么价..例如;车值500的话;那可能马值300;卒值80等等..所以在评估局面时;首先要考虑双方的子力总和的对比..比如红方拥有士象全加车马炮;而黑方只有残士象加双马;则红方明显占优..2、棋子位置棋子位置;或称控制区域;是指某一方的棋子在棋盘上所占据控制的位置..例如;沉底炮、过河卒、以及车占士角等都是较好的棋子位置状态;而窝心马、将离开底线等则属较差的棋子位置状态..3、棋子的机动性棋子的机动性指棋子的灵活度可移动性..例如;起始位置的车机动性较差;所以下棋讲究早出车..同样四面被憋马腿的死马机动性也较差对于一步也不能走的棋子;可以认为其机动性为零..4、棋子的相互关系这一点的分析较为复杂;因为一个棋子与其它子之间往往存在多重关系..如：一个马可能在对方的炮的攻击之下同时它又攻击着对方的车..在程序中;估值函数最后返回的是每一方的总分的差值;而各方的总分就是上面所提到的四个因素的打分的总和..对于子力打分和控制区域打分;只要遍历棋盘;当遇到棋子时简单地去查事先定义好的“子力价值表”和“控制区域价值表”;取出相对应的值进行累加即可这些值的具体设定参考了前人的程序并作了适当的调整;今后仍应根据电脑下棋所反映出的实际问题对这些值作适当修改..对于机动性打分;需要求出各个子总共有多少种走法;然后根据各个子所不同的机动性价值每多一种走法就加一次相应的分数..对棋子间相互关系的打分;要用到以下几个数据：int m_BaseValue15; //存放棋子基本价值int m_FlexValue15; //存放棋子灵活性分值short m_AttackPos109; //存放每一位置被威胁的信息BYTE m_GuardPos109; //存放每一位置被保护的信息BYTE m_FlexibilityPos109;//存放每一位置上棋子的灵活性分值int m_chessValue109; //存放每一位置上棋子的总价值其中计算机会进行所有棋子值的判断;AttackPos和GuardPos分别记录该棋子受到的威胁和被保护的值..当遍历一遍棋盘之后;子力打分、控制区域打分和机动性打分都可以完成;而关系表也可以填完..之后;再根据关系表来具体考察棋子的相互关系;进行关系打分..分析关系时;首先;对王的攻击保护应分离出来单独考虑;因为对王的保护没有任何意义;一旦王被吃掉整个游戏就结束了..其次;对一个普通子;当它既受到攻击又受到保护的时候要注意如下几个问题：1、攻击者子力小于被攻击者子力;攻击方将愿意换子..比如;一个车正遭受一个炮的攻击;那么任何对车的保护都将失去意义——对方肯定乐意用一个炮来换一个车..2、多攻击\单保护的情况;并且攻击者最小子力小于被攻击者子力与保护者子力之和;则攻击方可能以一子换两子..3、三攻击\两保护的情况;并且攻击者子力较小的二者之和小于被攻击者子力与保护者子力之和;则攻击方可能以两子换三子..4、攻击方与保护方数量相同;并且攻击者子力小于被攻击者子力与保护者子力之和再减去保护者中最大子力;则攻击方可能以n子换n子..当然;上述四条只是覆盖了最常见的几种情况;覆盖并不全面..而且;在程序中并没有直接地重新考虑双方兑子之后的控制区域及机动性变化情况之所以说没有“直接地重新考虑”;是因为搜索继续展开结点后仍会考虑这些因素;只是目前不知这样效果是否受影响——考察这两种方法在效果上的差异需要一定数量的试验数据的支持..所以;如果今后要对引擎进行改进;提高程序的下棋水平的话;还应当在此进行研究..2.6程序组装至此;已具备了实现一款中国象棋对弈程序引擎部分的所有要素;将上述模块分别写作.h头文件..如下：Define.h——象棋相关定义..包括棋盘局面和着法的表示..CMoveGenerator.h——着法生成器..就当前局面生成某一方所有合法着法..CSearchEngine.h——搜索部分..使用搜索求出最佳着法..HistoryHeuristic.h——历史启发..Alpha-Beta搜索之补充;以提高搜索效率..——着法排序..对着法按其历史得分进行降序排序;以提高搜索效率..CEveluate.h——局面评估..为某一特定局面进行评分..当实现了引擎部分的各要素时;可先建了一个Win32控制台项目;之后只要再添加一个.cpp文件负责接受用户的输入、调用搜索函数、显示搜索结果;便可简单的测试引擎了采用输入着法的起点坐标和终点坐标的。
c象棋课程设计
c 象棋课程设计一、课程目标知识目标：1. 学生能够理解c象棋的基本规则和棋盘布局。
2. 学生掌握c象棋中的各种棋子的走法和特殊规则。
3. 学生了解c象棋的基本战术和策略。
技能目标：1. 学生能够独立进行c象棋的开局、中局和残局的基本走法。
2. 学生能够运用基本的战术和策略进行c象棋对局。
3. 学生能够分析并解决c象棋中的问题局面，提高解题能力。
情感态度价值观目标：1. 学生培养对c象棋的兴趣和爱好，提高参与度。
2. 学生在c象棋游戏中培养良好的竞技精神和团队合作意识。
3. 学生通过c象棋学习，锻炼逻辑思维和决策能力，培养坚持、耐心和细致的品质。
课程性质：本课程以实践操作为主，结合理论知识，注重培养学生的动手能力和思维能力。
学生特点：六年级学生具备一定的认知能力和逻辑思维，对新鲜事物充满好奇心，喜欢挑战和竞技。
教学要求：教师应注重个体差异，因材施教，引导学生主动参与，培养自主学习和合作学习的能力。
教学过程中，注重启发式教学，激发学生的思维和创造力。
通过实践和比赛，提高学生的技能水平，培养良好的情感态度价值观。
将课程目标分解为具体的学习成果，以便后续的教学设计和评估。
二、教学内容1. c象棋的基本规则与棋盘布局：包括棋盘的行列分布、棋子的种类及初始位置、棋子的走法规则、胜负判定方法等。
教材章节：《c象棋入门》第一章。
2. c象棋的开局、中局和残局技巧：学习各种开局方法，了解其特点和战略意图；分析中局常见局面，掌握棋局发展的基本规律；学习残局攻防技巧，提高胜率。
教材章节：《c象棋入门》第二章、第三章、第四章。
3. c象棋基本战术与策略：学习双车、马、炮等棋子的组合战术，掌握牵制、堵塞、包围等基本战术；了解布局、攻守转换、子力协调等策略。
教材章节：《c象棋入门》第五章。
4. c象棋实战对局分析：通过分析经典对局，了解棋局变化，提高学生的应变能力和决策水平。
教材章节：《c象棋入门》第六章。
5. c象棋练习与比赛：组织学生进行分组练习，开展校内、班级间的c象棋比赛，提高学生的实战经验。
中国象棋课程设计
青岛理工大学C++面向对象课程设计报告院（系）：计算机工程学院专业：软件学生姓名： xxx班级：＿XXX＿学号： XXX题目：中国象棋程序设计起迄日期： 2011.06.30————设计地点：现代教育中心机房指导教师： XXXX完成日期: 2010 年7 月13 日一、课程设计目的面向对象程序设计作为一门软件设计的课程，具有极强的实践性，要求学生具备灵活应用理论知识的能力及面向对象程序设计技能的基础。
所以在《C++面向对象程序设计》课程学习完成后，安排课程设计教学环节。
通过课程设计，学生能了解C++面向对象的设计方法与技巧，有效地、深刻地理解课程内容，体会理论、方法和设计原则；培养分析实际问题和解决问题的能力，具备使用面向对象程序设计开发工具设计实际系统的能力。
通过这次课程设计，能了解并通过自学MFC，掌握一种可视化编程的方法，并通过实践加深对可视化编程与C++面向对象程序设计语言特点的认识与理解。
同时，可以提高运用C++编程语言解决实际问题的能力；提高调查研究、查阅技术文献、资料以及编写软件设计文档的能力。
二、课程设计内容与实现的功能课程设计的题目是中国象棋，所实现的功能是能画出象棋棋盘，在此基础上实现人机对弈。
对弈中符合现实中下棋的规则情况。
三、系统分析与设计1、系统分析中国象棋具有悠久的历史，几千年以来，一直被认为是人们所热爱的休闲活动之一。
象棋具有独特的规则，主要为车行直路，马走狭日，相行田，士相不离老王边，炮翻山，兵、卒只进不退，过河后方能左右行。
程序设计就是把现实中的人与人之间的对弈，改成电脑与人的对弈。
电脑的形为仿照人的形为，正确的走棋，“思考”，下棋。
任务要求，画出棋盘，实现简单的人机对弈。
2、系统设计：概要设计1、数据表示：主要包括棋盘的表示和棋子的表示。
2、走法的产生：包括车马相士炮等的基本走法和检测是否将军，或被将死，还包括检查一种棋子是否还有剩余，判断走法是否和法以及枚举可能有的合法的走法。
c语言课程设计中国象棋
c语言课程设计中国象棋一、教学目标本课程的教学目标是使学生掌握C语言的基本语法和编程技巧，通过中国象棋项目的实践，培养学生运用C语言解决实际问题的能力。
具体目标如下：1.知识目标：–掌握C语言的基本数据类型、运算符、控制结构。
–理解函数的定义和调用。
–学习常用的数据结构和算法，如数组、链表、排序等。
2.技能目标：–能够运用C语言编写简单的程序。
–学会使用调试工具，如GDB，进行程序调试。
–能够独立或合作完成中国象棋项目的开发。
3.情感态度价值观目标：–培养学生的团队合作意识和沟通能力。
–培养学生解决问题、克服困难的决心和勇气。
–培养学生对编程和中国象棋的兴趣和热情。
二、教学内容教学内容将围绕C语言的基本语法、数据结构、算法和中国象棋项目展开。
具体安排如下：1.C语言基本语法：–数据类型、变量和运算符。
–控制结构：条件语句、循环语句。
–函数的定义和调用。
2.数据结构与算法：–数组、链表的基本操作。
–排序算法：冒泡排序、选择排序、插入排序等。
–查找算法：顺序查找、二分查找等。
3.中国象棋项目实践：–中国象棋规则的介绍。
–项目需求分析和设计。
–项目实施和调试。
三、教学方法本课程将采用讲授法、案例分析法、实验法等多种教学方法，以激发学生的学习兴趣和主动性。
1.讲授法：用于讲解C语言的基本语法、数据结构和算法。
2.案例分析法：通过分析典型的中国象棋项目案例，引导学生运用C语言解决实际问题。
3.实验法：让学生亲自动手编写代码、调试程序，提高实际操作能力。
四、教学资源教学资源包括教材、参考书、多媒体资料和实验设备。
1.教材：《C程序设计语言》（K&R）、《C Primer Plus》等。
2.参考书：《数据结构与算法分析：C语言描述》、《算法导论》等。
3.多媒体资料：教学PPT、视频教程、在线编程练习平台等。
4.实验设备：计算机、网络设备、调试工具（如GDB）等。
五、教学评估本课程的教学评估将采用多元化评价方式，全面、客观地评价学生的学习成果。
中国象棋算法设计
正文1、课程设计报告1.1问题描述象棋是一种双方对阵的竞技项目。
棋子共有三十二个，分为红黑两组，各有十六个，由对弈的双方各执一组。
兵种是一样的，分为七种：红方：红方有帅一个，仕、相、车、马、炮各两个，兵五个。
黑方: 黑方有将一个，士、象、车、马、炮各两个，卒五个。
其中帅与将；仕与士；相与象；兵与卒的作用完全相同，仅仅是为了区别红棋和黑棋而已。
棋子活动的场所，叫作"棋盘"。
在长方形的平面上，绘有九条平行的竖线和十条平行的横线相交组成，共有九十个交叉点，棋子就摆在交叉点上。
中间部分，也就是棋盘的第五，第六两横线之间末画竖线的空白地带称为“河界”。
两端的中间，也就是两端第四条到第六条竖线之间的正方形部位，以斜交叉线构成“米”字方格的地方，叫作“九宫”（它恰好有九个交叉点）。
整个棋盘以“河界”分为相等的两部分。
为了比赛记录和学习棋谱方便起见，现行规则规定：按九条竖线从右至左用中文数字一-九来表示红方的每条竖线，用阿拉伯数字‘1’～‘9’来表示黑方的每条竖线。
对弈开始之前，红黑双方应该把棋子摆放在规定的位置。
任何棋子每走一步，进就写“进”，退就写“退”，如果像车一样横着走，就写“平”。
任何棋子在走动时，如果乙方棋子可以到达的位置有对方的棋子，就可以把对方棋子拿出棋盘(称为吃子)而换上自己的棋子。
只有炮的"吃子"方式与它的走法不同：它和对方棋子之间必须隔一个子（无论是自己的还是对方的），具备此条件才能"吃掉"人家。
一定要注意，中隔一个棋子，这个棋子俗称“炮架子”。
帅和将被吃或不能动弹即输棋。
下面是具体的界面：1.2需求分析1、走棋和吃子对局时，由执红棋的一方先走，双方轮流各走一着，直至分出胜、负、和，对局即终了。
轮到走棋的一方，将某个棋子从一个交叉点走到另一个交叉点，或者吃掉对方的棋子而占领其交叉点，都算走一着。
双方各走一着，称为一个回合。
2、各种棋子的走法•帅（将）：帅和将是棋中的首脑，是双方竭力争夺的目标。
c象棋课程设计实验
c 象棋课程设计实验一、教学目标本课程旨在让学生了解象棋的基本规则、棋谱识读、战术技巧以及历史文化，通过学习，使学生掌握象棋的基本技能，提高逻辑思维和策略规划能力。
知识目标包括：掌握象棋的基本规则、棋谱识读、各兵种的走法及用法；技能目标包括：能独立完成棋谱的绘制，运用不同的战术进行对弈；情感态度价值观目标包括：培养学生团队协作精神，增强耐心和毅力，提高文化素养。
二、教学内容教学内容主要包括象棋的基本规则、棋谱识读、战术技巧以及历史文化。
具体安排如下：1.第一课时：象棋概述，了解象棋的起源、发展以及棋盘、棋子构成；2.第二课时：棋谱识读，学习如何识别棋谱、棋谱的绘制方法；3.第三课时：兵种走法及用法，学习各兵种的走法、特殊规则；4.第四课时：基本战术，学习常用的进攻、防守战术；5.第五课时：对弈实战，进行小组内对弈，提高实战能力；6.第六课时：历史文化，了解象棋在中国历史文化中的地位和影响。
三、教学方法为了提高学生的学习兴趣和主动性，本课程采用多种教学方法相结合的方式，包括讲授法、讨论法、案例分析法、实验法等。
1.讲授法：用于讲解象棋的基本规则、棋谱识读、战术技巧以及历史文化；2.讨论法：在学习过程中，鼓励学生发表自己的观点，进行小组讨论，提高团队合作能力；3.案例分析法：通过分析典型的棋局，使学生更好地理解战术的应用；4.实验法：进行实战对弈，提高学生的操作能力和应变能力。
四、教学资源为了支持教学内容和教学方法的实施，丰富学生的学习体验，我们将选择和准备以下教学资源：1.教材：《象棋入门教程》等相关书籍；2.参考书：提供一些关于象棋的历史文化资料，供学生课后阅读；3.多媒体资料：制作精美的课件，生动的棋局视频，以直观展示棋局变化；4.实验设备：提供足够的棋盘、棋子，保证每个学生都能进行实战练习。
五、教学评估为了全面、客观、公正地评估学生的学习成果，我们将采取以下评估方式：1.平时表现：观察学生在课堂上的参与度、提问回答、小组讨论等，记录学生的表现，占总成绩的30%；2.作业：布置相关的象棋题目，要求学生独立完成，占总成绩的20%；3.考试：设置期中考试和期末考试，测试学生对象棋规则、棋谱识读、战术技巧的掌握程度，占总成绩的50%；4.对弈实战：学生进行实战对弈，评估学生的操作能力和应变能力，占总成绩的10%。
C语言知识学习程序源代码-中国象棋
#include<graphics.h> #include<conio.h>#include<string.h>#include<bios.h>#include<stdlib.h>#include"c:\tc\LIB\1.c"#define W 119#define S 115#define A 97#define D 100#define space 32#define UP 72#define DOWN 80#define LEFT 75#define RIGHT 77#define ENTER 13void qipan();void jiemian(int);void guangbiao1(int,int); void guangbiao2(int,int);void xuanzhong(int,int);void gaizi(int,int);char array(int,int);void xiazi(int,int,int,int);/*int panding(char,int,int,int,int);*/main(){int gdriver,gmode,i=0,c=0,x=190,y=190,m,n; char p;FILE *fp;gdriver=DETECT;gmode=0;if((fp=fopen("file.txt","at")) == NULL) {printf("Cannot open file!");system("pause");exit(0);}printf("%d,%d",gdriver,gmode); registerbgidriver(EGAVGA_driver);initgraph(&gdriver,&gmode,"c:\\tc"); cleardevice();while(c!=27){c=getch();clrscr();jiemian(i);if(c==80){fputs("down ",fp);i++;if(i==4){i=0;}}if(i==1){if(c==13){fputs("enter ",fp);qipan();c=getch();while(c!=27){c=getch();if(c==115){fputs("S ",fp);y=y+40; guangbiao1(x,y); guangbiao2(x,y-40);}if(c==119){fputs("W ",fp);y=y-40;guangbiao1(x,y);guangbiao2(x,y+40); }if(c==97){ fputs("A\n",fp);x=x-40;guangbiao1(x,y);guangbiao2(x+40,y); }if(c==100){ fputs("D\n",fp);x=x+40;guangbiao1(x,y);guangbiao2(x-40,y); }if(c==13){fputs("enter\n",fp);xuanzhong(x,y);m=x;n=y;}if(c==32){fputs("space\n",fp);xiazi(m,n,x,y);fputs("gaizi\n",fp);gaizi(m,n);}if(x>350||y>390||x<30||y<30){x=190;y=30;}}}}}getch();closegraph();fclose(fp);restorecrtmode();return 0;}void qipan(){int i,j;setbkcolor(GREEN);cleardevice();setlinestyle(0,0,3);setcolor(1);rectangle(10,10,370,410); rectangle(30,30,350,390);for(i=1;i<8;i++){setlinestyle(0,0,3);line(i*40+30,30,i*40+30,190); line(i*40+30,230,i*40+30,390); }for(j=1;j<9;j++){setlinestyle(0,0,3);line(30,j*40+30,350,j*40+30); }setlinestyle(3,0,3);line(150,30,230,110);line(230,30,150,110);line(150,310,230,390);line(230,310,150,390); setusercharsize(4,1,2,1);settextstyle(1,0,4);outtextxy(70,195,"chinese chess"); red_shuai(190,30);red_shi(150,30);red_shi(230,30);red_xiang(110,30);red_xiang(270,30);red_ma(70,30);red_ma(310,30);red_ju(30,30);red_ju(350,30);red_pao(70,110);red_pao(310,110);red_bing(30,150);red_bing(110,150);red_bing(190,150);red_bing(270,150);red_bing(350,150);black_jiang(190,390);black_shi(150,390);black_shi(230,390);black_xiang(110,390);black_xiang(270,390);black_ma(70,390);black_ma(310,390);black_ju(30,390);black_ju(350,390);black_pao(70,310);black_pao(310,310);black_zu(30,270);black_zu(110,270);black_zu(190,270);black_zu(270,270);black_zu(350,270);setcolor(BLUE);rectangle(400,30,600,320);setcolor(4);settextstyle(1,0,2);outtextxy(420,50,"A->shuai B->shi"); outtextxy(420,80,"C->xiang D->ma"); outtextxy(420,110,"E->ju F->pao"); outtextxy(420,140,"G->bing"); setcolor(8);outtextxy(420,200,"H->jiang I->shi");outtextxy(420,230,"J->xiang K->ma"); outtextxy(420,260,"L->ju M->pao"); outtextxy(420,290,"N->zu");}void jiemian(int i){setbkcolor(GREEN);cleardevice();settextstyle(1,0,8);setcolor(BLUE);outtextxy(50,70,"chinese chess"); settextstyle(0,0,3);setcolor(RED);outtextxy(260,215,"start");outtextxy(260,255,"again"); outtextxy(260,295,"undo"); outtextxy(260,335,"exit");rectangle(250,210+i*40,390,240+i*40); }void guangbiao1(int x,int y){setcolor(WHITE); setlinestyle(0,0,3);line(x-17,y-7,x-17,y-17); line(x-7,y-17,x-17,y-17); line(x+7,y-17,x+17,y-17); line(x+17,y-7,x+17,y-17); line(x-7,y+17,x-17,y+17); line(x-17,y+7,x-17,y+17); line(x+17,y+7,x+17,y+17); line(x+7,y+17,x+17,y+17); }void guangbiao2(int x,int y) {setcolor(GREEN); setlinestyle(0,0,3);line(x-17,y-7,x-17,y-17); line(x-7,y-17,x-17,y-17); line(x+7,y-17,x+17,y-17); line(x+17,y-7,x+17,y-17); line(x-7,y+17,x-17,y+17); line(x-17,y+7,x-17,y+17); line(x+17,y+7,x+17,y+17);line(x+7,y+17,x+17,y+17);}void xuanzhong(int x,int y){setcolor(CYAN);setlinestyle(0,0,3);circle(x,y,15);}void gaizi(int x1,int y1){setlinestyle(0,0,3);setcolor(GREEN);circle(x1,y1,15);setfillstyle(0,3);floodfill(x1,y1,GREEN);setcolor(1);setlinestyle(0,0,3);if((30<x1<350)&&((y1==30)||(y1==230))) {line(x1-18,y1,x1+18,y1);line(x1,y1,x1,y1+18);}if((30<x1<350)&&(y1==390||y1==190)) {line(x1-18,y1,x1+18,y1);line(x1,y1-18,x1,y1);}if((30<y1<390)&&x1==30){line(x1,y1,x1+18,y1);line(x1,y1-18,x1,y1+18);}if((30<y1<390)&&(x1==350)){line(x1-18,y1,x1,y1);line(x1,y1-18,x1,y1+18);}if((x1==30)&&(y1==30)){line(x1,y1,x1+18,y1);line(x1,y1,x1,y1+18);}if((x1==350)&&(y1==30)) {line(x1-18,y1,x1,y1);line(x1,y1,x1,y1+18);}if((x1==30)&&(y1==390)) {line(x1,y1,x1+18,y1);line(x1,y1,x1,y1-18);}if((x1==350)&&(y1==390)) {line(x1,y1,x1-18,y1);line(x1,y1,x1,y1-18);}else{line(x1-18,y1,x1+18,y1); line(x1,y1-18,x1,y1+18); }}char array(int i,int j)char a[13][13];int c,b;c=i;b=j;for(c=1;c<10;c++){for(b=1;b<11;b++){a[c][b]='Z';}}a[1][5]='A';a[1][4]='B';a[1][6]='B';a[1][3]='C';a[1][7]='C';a[1][2]='D';a[1][8]='D';a[1][1 ]='E';a[1][9]='E';a[3][2]='F';a[3][8]='F';a[4][1]=a[4][3]=a[4][5]=a[4][7]=a[4][9]='G';a[10][5]='H';a[10][4]='I';a[10][6]='I';a[10][3]='J';a[10][7]='J';a[10][2]='K';a[10][8]='K'; a[10][1]='L';a[10][9]='L';a[2][3]='M';a[8][3]='M';a[7][1]=a[7][3]=a[7][5]=a[7][7]=a[7][9]='N';return a[i][j];void xiazi(int x6,int y6,int x7,int y7) {switch(array(y6/40+1,x6/40+1)) {case 'A':red_shuai(x7,y7);break;case 'B':red_shi(x6,y7);break;case 'C':red_xiang(x7,y7);break;case 'D':red_ma(x7,y7);break;case 'E':red_ju(x7,y7);break;case 'F':red_pao(x7,y7);break;case 'G':red_bing(x7,y7);break;case 'H':black_jiang(x7,y7);break;case 'I':black_shi(x7,y7);break;case 'J':black_xiang(x7,y7);break;case 'K':black_ma(x7,y7);break;case 'L':black_ju(x7,y7);break;case 'M':black_pao(x7,y7);break;case 'N':black_zu(x7,y7);break;case 'Z':gaizi(x6,x6);break;}}/*int panding(char q,int x,int y,int a,int b) {switch(q){case 'A':if(y>110||x>230||x<150||(a-x)>40||(x-a)>40||(y-b)>40||(b-y)>40)return 0;elsereturn 1;break;case'B':if(((x-a)==40&&(y-b)==40)&&y<=110&&230<x<150||((a-x)==40&&(b-y)==4 0)&&y<=110&&230>x>150)return 1;elsereturn 0;break;case'C':if((((x-a)==80&&(y-b)==80)&&y<=190)&&(array((y+b)/2/40+1,(x+a)/2/40+1,) =='Z')))||(((a-x)==80&&(b-y)==80)&&y<=190)&&(array((y+b)/2/40+1,(x+a)/2/40 +1)=='Z'))))return 1;elsereturn 0;break;case'D':if((((x-a)==80&&(y-b)==40&&(array(y/40+1,(x-40)/40+1)=='Z'))||(((a-x)==80& &(b-y)==40)&&(array(y/40+1,(x+40)/40+1)=='Z'))||(((x-a)==40&&(y-b)==80)(arra y((y-40)/40+1,x/40+1)=='Z'))||(((a-x)==40&&(b-y)==80)&&(array((y+40)/40+1,x/4 0+1)=='z'))))return 1;elsereturn 0;break;case 'E':return 1;break;case 'F':return 1;break;case 'G':if(y<190){if(y>b||x!=a){return 0;}elsereturn 1;}else{if((b-y)>40||(a-x)>40||(x-a)>40||y>b){return 0;}elsereturn 1;}break;case 'H':if(y<310||x>230||x<150||(a-x)>40||(x-a)>40||(y-b)>40||(b-y)>40) return 0;elsereturn 1;break;case'I':if(((x-a)==40&&(y-b)==40)&&y>=310&&230<x<150||((a-x)==40&&(b-y)==40 )&&y>310&&230>x>150)return 1;elsebreak;case'J':if(((((x-a)==80&&(y-b)==80)&&y>=230)&&array(((y+b)/2/40+1,(x+a)/2/40+1) =='Z')))||(((a-x)==80&&(b-y)==80)&&y>=230)&&(array((y+b)/2/40+1,(x+a)/2/40 +1)=='Z'))))return 1;elsereturn 0;break;case'K':if((((x-a)==80&&(y-b)==40&&(array(y/40+1,(x-40)/40+1)=='Z'))||(((a-x)==80& &(b-y)==40)&&(array(y/40+1,(x+40)/40+1)=='Z'))||(((x-a)==40&&(y-b)==80)(arra y((y-40)/40+1,x/40+1)=='Z'))||(((a-x)==40&&(b-y)==80)&&(array((y+40)/40+1,x/4 0+1)=='Z'))return 1;elsereturn 0;break;case 'L':return 1;break;break;case 'N':if(y>230){if(y<b||x!=a){return 0;}elsereturn 1;}else{if(y-b>40||(a-x)>40||(x-a)>40||y<b){return 0;}elsereturn 1;}default:return 0;}}*/。
C语言国际象棋课程设计
C语言国际象棋课程设计一、教学目标本课程的学习目标包括以下三个方面：1.知识目标：通过本课程的学习，学生将掌握C语言的基本语法、数据类型、运算符、控制结构等基础知识，了解国际象棋的规则、战术和策略。
2.技能目标：学生能够运用C语言编写简单的国际象棋游戏程序，分析棋局，实现人机对战。
3.情感态度价值观目标：培养学生对计算机科学的兴趣，增强团队合作意识，培养良好的编程习惯和思维方式。
二、教学内容本课程的教学内容主要包括以下几个部分：1.C语言基础知识：变量、数据类型、运算符、控制结构等。
2.国际象棋规则：棋子的走法、棋局的判定、胜负和和棋。
3.棋局分析：棋局结构、棋型、棋势、开局、中局、残局。
4.C语言编程实践：编写国际象棋游戏程序，实现人机对战。
5.算法与策略：搜索算法、评分算法、开局库、棋局树。
三、教学方法本课程采用讲授法、案例分析法、实验法等多种教学方法：1.讲授法：用于讲解C语言基础知识和国际象棋规则。
2.案例分析法：分析经典棋局，讲解棋型、棋势、开局、中局、残局等。
3.实验法：让学生动手编写国际象棋游戏程序，实现人机对战。
四、教学资源1.教材：《C程序设计原理与应用》、《国际象棋入门教程》。
2.参考书：《C语言编程》、《国际象棋棋局解析》。
3.多媒体资料：国际象棋比赛视频、棋局演示动画。
4.实验设备：计算机、编程环境、网络。
五、教学评估本课程的评估方式包括以下几个方面：1.平时表现：评估学生的课堂参与度、提问回答、团队合作等。
2.作业：评估学生的编程练习、棋局分析报告等作业完成情况。
3.考试：包括期中考试和期末考试，考试内容涵盖C语言知识和国际象棋技能。
4.项目：学生需要完成一个国际象棋游戏编程项目，评估其设计、实现和表达能力。
评估方式应客观、公正，能够全面反映学生的学习成果。
六、教学安排本课程的教学安排如下：1.教学进度：按照教材章节和教学大纲进行教学，确保覆盖所有知识点。
2.教学时间：每周安排两节课，每节课时长为45分钟。
中国象棋 C语言编程
当危险时显示被“将军”
• “将军”情况复杂，如何判断将军呢
判断将军的方法
• 首先得先找到对方老将的位置 • 以移动的子落点位置为起始位置，以对方老将位 置为要移动到的位置，调用规则函数验证，如果 可以吃到，则显示 “将军！”。
调用broad函数
分支思路
1.走子的完成加走子的规则。
各个棋子的移动
• 获取移动位置的方法：运用坐标 • 判断是否合法 • 重新输出整个棋盘
移动的实现方法
• 首先让玩家输入要移动的位置，然后输入要走到 的位置 • 将前者的位置的值赋给后者位置，同时将前者位 置值赋值为0，再次输出各个位置。
判断移动是否合法
双人对弈中国象棋
程序所负责内容介绍
• 计算机生成红黑双方以及棋盘。 • 各个棋子的移动。
• 当危险时显示被“将军”。
分支思路
1.棋盘棋子的制作与输出
计算机生成红黑双方以及棋盘
• 第一想法
• 第二想法→有子无子两种状态分别对应0和非0
输出 对每个位置赋值 非0 判断是否为0 为0
调用shift函数
悔棋程序
Goal! Step 13 Step 2 Step
走之前 保存要 走位置 的棋子 的数学 信息。
走之后 保存要 走到位 置的棋 子的数 学信息
如果悔 棋，将原 来的值重 新覆回到 棋盘中
完成
判断输赢
简单的方法
判断九格宫内 是否存在帅的 数学值
复盘
三维数组a[棋子的步数][横坐标]三 维数组
中国象棋C语言源代码
*--------------------chess.c----------------------*/ #include "dos.h"#include "stdio.h"/*----------------------------------------------------*/ #define RED 7#define BLACK 14#define true 1#define false 0#define SELECT 0#define MOVE 1#define RED_UP 0x1100#define RED_DOWN 0x1f00#define RED_LEFT 0x1e00#define RED_RIGHT 0x2000#define RED_DO 0x3900#define RED_UNDO 0x1000#define BLACK_UP 0x4800#define BLACK_DOWN 0x5000#define BLACK_LEFT 0x4b00#define BLACK_RIGHT 0x4d00#define BLACK_DO 0x1c00#define BLACK_UNDO 0x2b00#define ESCAPE 0x0100#define RED_JU 1#define RED_MA 2#define RED_XIANG 3#define RED_SHI 4#define RED_JIANG 5#define RED_PAO 6#define RED_BIN 7#define BLACK_JU 8#define BLACK_MA 9#define BLACK_XIANG 10#define BLACK_SHI 11#define BLACK_JIANG 12#define BLACK_PAO 13#define BLACK_BIN 14/*----------------------------------------------------*/ int firsttime=1;int savemode;char page_new=0,page_old=0;int finish=false,turn=BLACK,winner=0;int key;int redstate=SELECT,blackstate=SELECT;int board[10][9];/*----------------------------------------------------*/char *chessfile[15]={"","bmp\\rju.wfb", "bmp\\rma.wfb", "bmp\\rxiang.wfb","bmp\\rshi.wfb","bmp\\rjiang.wfb","bmp\\rpao.wfb","bmp\\rbin.wfb","bmp\\bju.wfb", "bmp\\bma.wfb", "bmp\\bxiang.wfb","bmp\\bshi.wfb","bmp\\bjiang.wfb","bmp\\bpao.wfb","bmp\\bbin.wfb"};char *boardfile[10][9]={{"bmp\\11.wfb","bmp\\1t.wfb","bmp\\1t.wfb","bmp\\14.wfb","bmp\\15.wfb","bmp\\16.wfb"," bmp\\1t.wfb","bmp\\1t.wfb","bmp\\19.wfb"},{"bmp\\21.wfb","bmp\\2c.wfb","bmp\\2c.wfb","bmp\\24.wfb","bmp\\25.wfb","bmp\\26.wfb"," bmp\\2c.wfb","bmp\\2c.wfb","bmp\\29.wfb"},{"bmp\\21.wfb","bmp\\3a.wfb","bmp\\3t.wfb","bmp\\34.wfb","bmp\\3t.wfb","bmp\\36.wfb"," bmp\\3t.wfb","bmp\\3a.wfb","bmp\\29.wfb"},{"bmp\\41.wfb","bmp\\4t.wfb","bmp\\4a.wfb","bmp\\4t.wfb","bmp\\4a.wfb","bmp\\4t.wfb","b mp\\4a.wfb","bmp\\4t.wfb","bmp\\49.wfb"},{"bmp\\51.wfb","bmp\\52.wfb","bmp\\5t.wfb","bmp\\54.wfb","bmp\\5t.wfb","bmp\\56.wfb"," bmp\\5t.wfb","bmp\\58.wfb","bmp\\59.wfb"},{"bmp\\61.wfb","bmp\\62.wfb","bmp\\6t.wfb","bmp\\64.wfb","bmp\\6t.wfb","bmp\\66.wfb"," bmp\\6t.wfb","bmp\\68.wfb","bmp\\69.wfb"},{"bmp\\71.wfb","bmp\\7t.wfb","bmp\\7a.wfb","bmp\\7t.wfb","bmp\\7a.wfb","bmp\\7t.wfb","b mp\\7a.wfb","bmp\\7t.wfb","bmp\\79.wfb"},{"bmp\\81.wfb","bmp\\8a.wfb","bmp\\8t.wfb","bmp\\84.wfb","bmp\\85.wfb","bmp\\86.wfb"," bmp\\8t.wfb","bmp\\8a.wfb","bmp\\89.wfb"},{"bmp\\91.wfb","bmp\\9t.wfb","bmp\\9t.wfb","bmp\\9t.wfb","bmp\\95.wfb","bmp\\9t.wfb","b mp\\9t.wfb","bmp\\9t.wfb","bmp\\99.wfb"},{"bmp\\101.wfb","bmp\\102.wfb","bmp\\102.wfb","bmp\\104.wfb","bmp\\105.wfb","bmp\\10 6.wfb","bmp\\108.wfb","bmp\\108.wfb","bmp\\109.wfb"}};char cursor[14][14]={0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,255,255,255,255,255,255,255,0,0,1,1,1,1,0,255,255,255,255,255,255,0,0,1,1,1,1,1,0,255,255,255,255,255,255,0,0,1,1,1,1,1,0,255,255,255,255,255,255,255,0,0,1,1,1,1,0,255,255,255,255,255,255,255,255,0,0,1,1,1,0,255,255,255,255,255,255,255,255,255,0,0,1,1,0,255,255,0,255,255,255,255,255,255,255,0,0,1,0,255,0,1,1,0,255,255,255,255,255,255,255,0,0,0,1,1,1,1,0,255,255,255,255,255,0,1,0,1,1,1,1,1,1,0,255,255,255,0,1,1,1,1,1,1,1,1,1,1,0,255,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1};struct pos{int x;int y;}position[10][9],redcurpos,redtemppos,redoldpos,blackcurpos,blacktemppos,blackoldpos; /*----------------------------------------------------*/selectpage(register char page) /*换页函数*/{union REGS r;r.x.ax=0x4f05;r.x.bx=0;r.x.dx=page; /*选择页面*/int86(0x10,&r,&r);}unsigned char set_SVGA_mode(int vmode) /*设置SVGA屏幕模式*/{union REGS r;r.x.ax=0x4f02;r.x.bx=vmode;int86(0x10,&r,&r);return(r.h.ah);}unsigned int get_SVGA_mode() /*获取当前SVGA屏幕模式*/{union REGS r;r.x.ax=0x4f03;int86(0x10,&r,&r);return(r.x.bx);}drawbmp(int start_x,int start_y,char filename[]){char buffer[640];int i,j,k,n,r,g,b,width,length;long position;FILE *fp;if((fp=fopen(filename,"rb"))==NULL){printf("Error! Can't open file!");getch();return;}fseek(fp,28,SEEK_SET);fread(&i,2,1,fp);if(i!=8) /*检查是否为256色位图*/{puts("Error!Can't find bitmap!");fclose(fp);getch();exit(0);}fseek(fp,18,SEEK_SET);fread(&width,4,1,fp);fread(&length,4,1,fp);if(firsttime){fseek(fp,54,SEEK_SET);for(i=0;i<256;i++) /*按照该图片的DAC色表设置色彩寄存器*/{b=fgetc(fp);g=fgetc(fp);r=fgetc(fp); /*获取R、G、B分量*/outportb(0x3c8,i);outportb(0x3c9,r>>2); /*右移是要转化为VGA的6位寄存器形式*/ outportb(0x3c9,g>>2);outportb(0x3c9,b>>2);fgetc(fp);}}elsefseek(fp,300,SEEK_SET);k=(width%4)?(4-width%4):0; /*宽度修正值*/for(j=length-1+start_x;j>=start_x;j--){fread(buffer,width,1,fp);for(i=start_y,n=0;i<width+start_y;i++,n++){position=j*640l+i; /*计算要显示点的显存位置*/page_new=position/65536; /*计算显示页*/if(page_new!=page_old) /*当显示页不同时更换页面，提高一定的输出速度*/{selectpage(page_new);page_old=page_new;}pokeb(0xa000,position%65536,buffer[n]); /*写到显存位置*/}fseek(fp,k,SEEK_CUR); /*每行绘制完后修正宽度*/}fclose(fp);}init(){savemode=get_SVGA_mode(); /*先保存原来的屏幕模式*/set_SVGA_mode(0x101); /*硬件无关性初始化屏幕为640*480 256色模式*/ }end(){set_SVGA_mode(savemode); /*恢复屏幕*/}/*----------------------------------------------------*/initpos(){int i,j;for(i=0;i<10;i++)for (j=0;j<9;j++){position[i][j].x=35+i*39;position[i][j].y=43+j*40;}}initchessmap(){board[0][0]=BLACK_JU;board[0][1]=BLACK_MA;board[0][2]=BLACK_XIANG;board[0][3]=BLACK_SHI;board[0][4]=BLACK_JIANG;board[0][5]=BLACK_SHI;board[0][6]=BLACK_XIANG;board[0][7]=BLACK_MA;board[0][8]=BLACK_JU;board[2][1]=BLACK_PAO;board[2][7]=BLACK_PAO;board[3][0]=BLACK_BIN;board[3][2]=BLACK_BIN;board[3][4]=BLACK_BIN;board[3][6]=BLACK_BIN;board[3][8]=BLACK_BIN;board[9][0]=RED_JU;board[9][1]=RED_MA;board[9][2]=RED_XIANG;board[9][3]=RED_SHI;board[9][4]=RED_JIANG;board[9][5]=RED_SHI;board[9][6]=RED_XIANG;board[9][7]=RED_MA;board[9][8]=RED_JU;board[7][1]=RED_PAO;board[7][7]=RED_PAO;board[6][0]=RED_BIN;board[6][2]=RED_BIN;board[6][4]=RED_BIN;board[6][6]=RED_BIN;board[6][8]=RED_BIN;}initdrawchess(){int i,j;;for(i=0;i<10;i++)for(j=0;j<9;j++){if(board[i][j])drawbmp(position[i][j].x,position[i][j].y,chessfile[board[i][j]]); }}drawcursor(struct pos p){int i,j,n,m,x,y;long thisposition;x=position[p.x][p.y].x+20;y=position[p.x][p.y].y+25;for(j=13-1+x,m=13;j>=x;j--,m--){for(i=y,n=0;i<13+y;i++,n++){thisposition=j*640l+i; /*计算要显示点的显存位置*/page_new=thisposition/65536; /*计算显示页*/if(page_new!=page_old) /*当显示页不同时更换页面，提高一定的输出速度*/ {selectpage(page_new);page_old=page_new;}if(cursor[m][n]!=1)if(cursor[m][n]==0)pokeb(0xa000,thisposition%65536,0);elseif(turn==RED)pokeb(0xa000,thisposition%65536,153);elsepokeb(0xa000,thisposition%65536,255);}}}drawselecursor(struct pos p){int i,j,n,m,x,y;long thisposition;x=position[p.x][p.y].x+20;y=position[p.x][p.y].y+25;for(j=13-1+x,m=13;j>=x;j--,m--){for(i=y,n=0;i<13+y;i++,n++){thisposition=j*640l+i; /*计算要显示点的显存位置*/page_new=thisposition/65536; /*计算显示页*/if(page_new!=page_old) /*当显示页不同时更换页面，提高一定的输出速度*/ {selectpage(page_new);page_old=page_new;}if(cursor[m][n]!=1)pokeb(0xa000,thisposition%65536,0);}}}/*----------------------------------------------------*/int getkey(){int press;while(bioskey(1) == 0);press=bioskey(0);press=press&0xff00;return(press);}/*--------------------红方操作--------------------*/int redcanselect(){int x,y;x=redcurpos.x;y=redcurpos.y;if(board[x][y]>=RED_JU&&board[x][y]<=RED_BIN)return 1;elsereturn 0;}int redcanmove(){int i,j,min,max,oldx,oldy,x,y;oldx=redoldpos.x;oldy=redoldpos.y;x=redcurpos.x;y=redcurpos.y;/*case1 目标位置是否是自己人*/if(board[x][y]>=RED_JU&&board[x][y]<=RED_BIN)return 0;/* 军、马、炮、相、士、将、卒的走法正确性的判断*/ switch(board[oldx][oldy]){case RED_BIN: /*完成*/if(oldx>=5){ if(y!=oldy||(oldx-x)!=1) return 0;}else{ if(x==(oldx-1)&&y==oldy) return 1;elseif(x==oldx&&y==(oldy+1)) return 1;elseif(x==oldx&&y==(oldy-1)) return 1;elsereturn 0;}break;case RED_JIANG: /*完成*/if(x!=oldx&&y!=oldy) return 0;if(x!=oldx)if((x-oldx)>1||(oldx-x)>1) return 0;else if(x<7) return 0;else if(y!=oldy)if((y-oldy)>1||(oldy-y)>1) return 0;else if(y<3||y>5) return 0;break;case RED_JU: /*完成*/if(x!=oldx&&y!=oldy) return 0;else if(x!=oldx){ min=(x>oldx)?oldx:x;max=(x>oldx)?x:oldx;for(i=min+1;i<max;i++)if(board[i][y]!=0) return 0;}else if(y!=oldy){ min=(y>oldy)?oldy:y;max=(y>oldy)?y:oldy;for(i=min+1;i<max;i++)if(board[x][i]!=0) return 0;}break;case RED_MA: /*完成*/if((x-oldx)==2&&((y-oldy)==1||(oldy-y)==1)) {if(board[oldx+1][oldy]!=0) return 0;}elseif((oldx-x)==2&&((y-oldy)==1||(oldy-y)==1)) {if(board[oldx-1][oldy]!=0) return 0;}elseif((y-oldy)==2&&((x-oldx)==1||(oldx-x)==1)) {if(board[oldx][oldy+1]!=0) return 0;}elseif((oldy-y)==2&&((x-oldx)==1||(oldx-x)==1)) {if(board[oldx][oldy-1]!=0) return 0;}elsereturn 0;break;case RED_PAO: /*完成*/if(x!=oldx&&y!=oldy) return 0;if(board[x][y]==0){if(x!=oldx){ min=(x>oldx)?oldx:x;max=(x>oldx)?x:oldx;for(i=min+1;i<max;i++)if(board[i][y]!=0) return 0; }else if(y!=oldy){ min=(y>oldy)?oldy:y; max=(y>oldy)?y:oldy;for(i=min+1;i<max;i++)if(board[x][i]!=0) return 0; }}else{if(x!=oldx){ min=(x>oldx)?oldx:x; max=(x>oldx)?x:oldx;for(i=min+1,j=0;i<max;i++) if(board[i][y]!=0) j++;if(j!=1) return 0;}else if(y!=oldy){ min=(y>oldy)?oldy:y; max=(y>oldy)?y:oldy;for(i=min+1,j=0;i<max;i++) if(board[x][i]!=0) j++;if(j!=1) return 0;}}break;case RED_SHI: /*完成*/if(oldx==9||oldx==7){if(x!=8||y!=4) return 0;} else if(oldx==8){if(x==9&&y==3) return 1; elseif(x==9&&y==5) return 1; elseif(x==7&&y==3) return 1; elseif(x==7&&y==5) return 1; else return 0;}else return 0;break;case RED_XIANG: /*完成*/ if(x<5) return 0;if(x!=oldx&&y!=oldy){if((x-oldx)==2&&(y-oldy)==2){i=oldx+1;j=oldy+1;}else if((x-oldx)==2&&(oldy-y)==2) {i=oldx+1;j=oldy-1;}else if((oldx-x)==2&&(y-oldy)==2) {i=oldx-1;j=oldy+1;}else if((oldx-x)==2&&(oldy-y)==2) {i=oldx-1;j=oldy-1;}else return 0;if(board[i][j]!=0) return 0;}else return 0;break;}return 1;}。
C语言程序源代码---中国象棋
#include<graphics.h>#include<conio.h>#include<string.h>#include<bios.h>#include<stdlib.h>#include"c:\tc\LIB\1.c"#define W 119#define S 115#define A 97#define D 100#define space 32#define UP 72#define DOWN 80#define LEFT 75#define RIGHT 77#define ENTER 13void qipan();void jiemian(int);void guangbiao1(int,int);void guangbiao2(int,int);void xuanzhong(int,int);void gaizi(int,int);char array(int,int);void xiazi(int,int,int,int);/*int panding(char,int,int,int,int);*/main(){int gdriver,gmode,i=0,c=0,x=190,y=190,m,n; char p;FILE *fp;gdriver=DETECT;gmode=0;if((fp=fopen("file.txt","at")) == NULL) {printf("Cannot open file!");system("pause");exit(0);}printf("%d,%d",gdriver,gmode); registerbgidriver(EGAVGA_driver);initgraph(&gdriver,&gmode,"c:\\tc"); cleardevice();while(c!=27){c=getch();clrscr();jiemian(i);if(c==80){fputs("down ",fp);i++;if(i==4){i=0;}}if(i==1){if(c==13){fputs("enter ",fp);qipan();c=getch();while(c!=27){c=getch();if(c==115){fputs("S ",fp);y=y+40;guangbiao1(x,y);guangbiao2(x,y-40);}if(c==119){fputs("W ",fp);y=y-40;guangbiao1(x,y);guangbiao2(x,y+40);}if(c==97){ fputs("A\n",fp);x=x-40;guangbiao1(x,y);guangbiao2(x+40,y);}if(c==100){ fputs("D\n",fp);x=x+40;guangbiao1(x,y);guangbiao2(x-40,y);}if(c==13){fputs("enter\n",fp);xuanzhong(x,y);m=x;n=y;}if(c==32){fputs("space\n",fp);xiazi(m,n,x,y);fputs("gaizi\n",fp);gaizi(m,n);}if(x>350||y>390||x<30||y<30){x=190;y=30;}}}}}getch();closegraph();fclose(fp);restorecrtmode();return 0;}void qipan(){int i,j;setbkcolor(GREEN);cleardevice();setlinestyle(0,0,3);setcolor(1);rectangle(10,10,370,410);rectangle(30,30,350,390);for(i=1;i<8;i++){setlinestyle(0,0,3);line(i*40+30,30,i*40+30,190);line(i*40+30,230,i*40+30,390);}for(j=1;j<9;j++){setlinestyle(0,0,3);line(30,j*40+30,350,j*40+30);}setlinestyle(3,0,3);line(150,30,230,110);line(230,30,150,110);line(150,310,230,390);line(230,310,150,390); setusercharsize(4,1,2,1); settextstyle(1,0,4);outtextxy(70,195,"chinese chess"); red_shuai(190,30);red_shi(150,30);red_shi(230,30);red_xiang(110,30);red_xiang(270,30);red_ma(70,30);red_ma(310,30);red_ju(30,30);red_ju(350,30);red_pao(70,110);red_pao(310,110);red_bing(30,150);red_bing(110,150);red_bing(190,150);red_bing(270,150);red_bing(350,150);black_jiang(190,390);black_shi(150,390);black_shi(230,390);black_xiang(110,390);black_xiang(270,390);black_ma(70,390);black_ma(310,390);black_ju(30,390);black_ju(350,390);black_pao(70,310);black_pao(310,310);black_zu(30,270);black_zu(110,270);black_zu(190,270);black_zu(270,270);black_zu(350,270);setcolor(BLUE);rectangle(400,30,600,320);setcolor(4);settextstyle(1,0,2);outtextxy(420,50,"A->shuai B->shi"); outtextxy(420,80,"C->xiang D->ma"); outtextxy(420,110,"E->ju F->pao"); outtextxy(420,140,"G->bing"); setcolor(8);outtextxy(420,200,"H->jiang I->shi"); outtextxy(420,230,"J->xiang K->ma"); outtextxy(420,260,"L->ju M->pao"); outtextxy(420,290,"N->zu");}void jiemian(int i){setbkcolor(GREEN); cleardevice();settextstyle(1,0,8);setcolor(BLUE);outtextxy(50,70,"chinese chess"); settextstyle(0,0,3);setcolor(RED);outtextxy(260,215,"start"); outtextxy(260,255,"again"); outtextxy(260,295,"undo"); outtextxy(260,335,"exit"); rectangle(250,210+i*40,390,240+i*40); }void guangbiao1(int x,int y){setcolor(WHITE);setlinestyle(0,0,3);line(x-17,y-7,x-17,y-17);line(x-7,y-17,x-17,y-17);line(x+7,y-17,x+17,y-17);line(x+17,y-7,x+17,y-17);line(x-7,y+17,x-17,y+17);line(x-17,y+7,x-17,y+17);line(x+17,y+7,x+17,y+17);line(x+7,y+17,x+17,y+17);}void guangbiao2(int x,int y){setcolor(GREEN);setlinestyle(0,0,3);line(x-17,y-7,x-17,y-17);line(x-7,y-17,x-17,y-17);line(x+7,y-17,x+17,y-17);line(x+17,y-7,x+17,y-17);line(x-7,y+17,x-17,y+17);line(x-17,y+7,x-17,y+17);line(x+17,y+7,x+17,y+17);line(x+7,y+17,x+17,y+17);}void xuanzhong(int x,int y){setcolor(CYAN);setlinestyle(0,0,3);circle(x,y,15);}void gaizi(int x1,int y1){setlinestyle(0,0,3);setcolor(GREEN);circle(x1,y1,15);setfillstyle(0,3);floodfill(x1,y1,GREEN);setcolor(1);setlinestyle(0,0,3);if((30<x1<350)&&((y1==30)||(y1==230))) {line(x1-18,y1,x1+18,y1);line(x1,y1,x1,y1+18);if((30<x1<350)&&(y1==390||y1==190)) {line(x1-18,y1,x1+18,y1);line(x1,y1-18,x1,y1);}if((30<y1<390)&&x1==30){line(x1,y1,x1+18,y1);line(x1,y1-18,x1,y1+18);}if((30<y1<390)&&(x1==350)){line(x1-18,y1,x1,y1);line(x1,y1-18,x1,y1+18);}if((x1==30)&&(y1==30)){line(x1,y1,x1+18,y1);line(x1,y1,x1,y1+18);}if((x1==350)&&(y1==30)){line(x1-18,y1,x1,y1);line(x1,y1,x1,y1+18);}if((x1==30)&&(y1==390)){line(x1,y1,x1+18,y1);line(x1,y1,x1,y1-18);}if((x1==350)&&(y1==390)){line(x1,y1,x1-18,y1);line(x1,y1,x1,y1-18);}else{line(x1-18,y1,x1+18,y1);line(x1,y1-18,x1,y1+18);}}char array(int i,int j)char a[13][13];int c,b;c=i;b=j;for(c=1;c<10;c++){for(b=1;b<11;b++){a[c][b]='Z';}}a[1][5]='A';a[1][4]='B';a[1][6]='B';a[1][3]='C';a[1][7]='C';a[1][2]='D';a[1][8]='D';a[1][1]='E';a[1][9]='E';a[3][2]='F';a[3][8]='F';a[4][1]=a[4][3]=a[4][5]=a[4][7]=a[4][9]='G';a[10][5]='H';a[10][4]='I';a[10][6]='I';a[10][3]='J';a[10][7]='J';a[10][2]='K';a[10][8]='K';a[10][1]='L';a[10][ 9]='L';a[2][3]='M';a[8][3]='M';a[7][1]=a[7][3]=a[7][5]=a[7][7]=a[7][9]='N';return a[i][j];}void xiazi(int x6,int y6,int x7,int y7){switch(array(y6/40+1,x6/40+1)){case 'A':red_shuai(x7,y7);break;case 'B':red_shi(x6,y7);break;case 'C':red_xiang(x7,y7);break;case 'D':red_ma(x7,y7);break;case 'E':red_ju(x7,y7);break;case 'F':red_pao(x7,y7);break;case 'G':red_bing(x7,y7);break;case 'H':black_jiang(x7,y7);break;case 'I':black_shi(x7,y7);break;case 'J':black_xiang(x7,y7);break;case 'K':black_ma(x7,y7);break;case 'L':black_ju(x7,y7);break;case 'M':black_pao(x7,y7);break;case 'N':black_zu(x7,y7);break;case 'Z':gaizi(x6,x6);break;}}/*int panding(char q,int x,int y,int a,int b){switch(q){case 'A':if(y>110||x>230||x<150||(a-x)>40||(x-a)>40||(y-b)>40||(b-y)>40)return 0;elsereturn 1;break;case'B':if(((x-a)==40&&(y-b)==40)&&y<=110&&230<x<150||((a-x)==40&&(b-y)==40)&&y<=110& &230>x>150)return 1;elsereturn 0;break;case'C':if((((x-a)==80&&(y-b)==80)&&y<=190)&&(array((y+b)/2/40+1,(x+a)/2/40+1,)=='Z')))||(((a-x)==80&&(b-y)==80)&&y<=190)&&(array((y+b)/2/40+1,(x+a)/2/40+1)=='Z'))))return 1;elsereturn 0;break;case'D':if((((x-a)==80&&(y-b)==40&&(array(y/40+1,(x-40)/40+1)=='Z'))||(((a-x)==80&&(b-y)==40)&&(array(y/40+1,(x+40)/40+1)=='Z'))||(((x-a)==40&&(y-b)==80)(array((y-40)/40+1,x/40+1)==' Z'))||(((a-x)==40&&(b-y)==80)&&(array((y+40)/40+1,x/40+1)=='z'))))return 1;elsereturn 0;break;case 'E':return 1;break;case 'F':return 1;break;case 'G':if(y<190){if(y>b||x!=a){return 0;}elsereturn 1;}else{if((b-y)>40||(a-x)>40||(x-a)>40||y>b){return 0;}elsereturn 1;}break;case 'H':if(y<310||x>230||x<150||(a-x)>40||(x-a)>40||(y-b)>40||(b-y)>40)return 0;elsereturn 1;break;case'I':if(((x-a)==40&&(y-b)==40)&&y>=310&&230<x<150||((a-x)==40&&(b-y)==40)&&y>310&& 230>x>150)return 1;elsereturn 0;break;case'J':if(((((x-a)==80&&(y-b)==80)&&y>=230)&&array(((y+b)/2/40+1,(x+a)/2/40+1)=='Z')))||(((a-x )==80&&(b-y)==80)&&y>=230)&&(array((y+b)/2/40+1,(x+a)/2/40+1)=='Z'))))return 1;elsereturn 0;break;case'K':if((((x-a)==80&&(y-b)==40&&(array(y/40+1,(x-40)/40+1)=='Z'))||(((a-x)==80&&(b-y)==40) &&(array(y/40+1,(x+40)/40+1)=='Z'))||(((x-a)==40&&(y-b)==80)(array((y-40)/40+1,x/40+1)==' Z'))||(((a-x)==40&&(b-y)==80)&&(array((y+40)/40+1,x/40+1)=='Z'))return 1;elsereturn 0;break;case 'L':return 1;break;case 'M':return 1;break;case 'N':if(y>230){if(y<b||x!=a){return 0;}elsereturn 1;}else{if(y-b>40||(a-x)>40||(x-a)>40||y<b){return 0;}elsereturn 1;}default:return 0;}}*/精品。
中国象棋C代码
中国象棋#include<stdio.h>#include<conio.h>#include<string.h>#include<stdlib.h>#include<windows.h>int x, y, i, j, k, p, q, num = 1, round; //象棋游戏的全局变量int px1 = 0, py1 = 0, px2 = 0, py2 = 0;int ck_x, ck_y, ck_t; //基本参数char ch, tn = 'O', tn1 = 'N', tp, tp1;char ck_1[9][3] ={"車","馬","相","仕","帥","砲","兵","+-"}; //取棋子时只判断前8合法char ck_2[9][3] ={"车","马","象","士","将","炮","卒","+-"};//下棋子时判断多一个空位合法char check[3];void ckm1(char* tp,char* tp1,char* tn,char* tn1,int *num,int *if_ov,char map[100][100]) {//象棋函数判断将方下棋是否合法check[0] = *tp; check[1] = *tp1; check[2] = '\0';char a,b;for ( i = 0; i < 8; i++){ if ( strcmp(ck_2[i],check) == 0){ *tp = *tn; *tp1 = *tn1; *tn = 'O'; *tn1 = 'N';if( i < 7){ printf(" 将方的%s被吃",ck_2[i]); Sleep(500); }*num = *num + 1;for( k = 4; k <= 8; k = k + 2)//判断将是否死亡{for(j = 15; j <= 23; j= j+ 4){ if (map[k][j] == ck_2[4][0] && map[k][j+1] == ck_2[4][1]){ px2 = k; py2 = j; break; }}if( j <= 23) break;}if( k == 10){printf(" 将被将死帥方获得胜利\n"); printf("按任意键返回菜单");getch( ); *if_ov = 1; return;}for( k = 18; k <= 22; k = k + 2) //判断帥是否死亡{for(j = 15; j <= 23; j= j+ 4){if(map[k][j] == ck_1[4][0] && map[k][j+1] == ck_1[4][1]){px1 = k; py1 = j; break; }}if( j <= 23) break;}if ( k == 24){printf(" 帥被将死将方获得胜利\n"); printf("按任意键返回菜单");getch( ); *if_ov = 1; return;}if ( py1 == py2){for( k = px2 + 2; k <= px1 - 2; k = k +2) {if(map[k][py1] != '+') break;}if( k == px1){if(round == 1) printf(" 帥方对将将方胜利");else if( round == 2) printf(" 将方对将帥方胜利");printf("按任意键返回菜单"); getch( ); *if_ov = 1; return;}}break;}} // for ( i = 0; i < 8; i++)循环结束if( i == 8) {printf("不合法的走法\n"); Sleep(500); }}void ckm2(char* tp,char* tp1,char* tn,char* tn1,int *num,int *if_ov,char map[100][100]) {//象棋函数判断帥方下棋是否合法check[0] = *tp; check[1] = *tp1; check[2] = '\0';char a,b;for ( i = 0; i < 8; i++){if ( strcmp(ck_1[i],check) == 0){ *tp = *tn; *tp1 = *tn1; *tn = 'O'; *tn1 = 'N';if( i < 7) {printf(" 帥方的%s被吃",ck_1[i]); Sleep(500); }*num = *num + 1;for( k = 4; k <= 8; k = k + 2) //判断将是否死亡{for(j = 15; j <= 23; j= j+ 4){if(map[k][j] == ck_2[4][0] && map[k][j+1] == ck_2[4][1]){px2 = k; py2 = j; break; }}if( j <= 23) break;}if( k == 10){printf(" 将被将死帥方获得胜利\n");printf("按任意键返回菜单"); getch( );*if_ov = 1; return;}for( k = 18; k <= 22; k = k + 2) //判断帥是否死亡{for(j = 15; j <= 23; j= j+ 4){if(map[k][j] == ck_1[4][0] && map[k][j+1] == ck_1[4][1]){px1 = k; py1 = j; break; }}if( j <= 23) break;}if( k == 24){printf(" 帥被将死将方获得胜利\n");printf("按任意键返回菜单"); getch( );*if_ov = 1; return;}if( py1 == py2){for( k = px2 + 2; k <= px1 - 2; k = k +2) {if(map[k][py1] != '+') break; }if( k == px1){if(round == 1) printf(" 帥方对将将方胜利");else if( round == 2) printf(" 将方对将帥方胜利");printf("按任意键返回菜单"); getch( ); *if_ov = 1; return;}}break;}} // for ( i = 0; i < 8; i++)循环结束if( i == 8) {printf("不合法的走法\n"); Sleep(500); }}void xiangqi( )//象棋主程序{char map[100][100]= { "[[===================================]]","[| ①帥【象棋】②将|]","[[===================================]]","[[-----------------------------------]]","[[ 车—-马—-象—-士—-将—-士—-象—-马—-车]]","[[ | | | | \\ | / | | | | ]]","[[ +-—-+-—-+-—-+-—-+-—-+-—-+-—-+-—-+-]]","[[ | | | | / | \\ | | | | ]]","[[ +-—-炮—-+-—-+-—-+-—-+-—-+-—-炮—-+-]]","[[ | | | | | | | | | ]]","[[ 卒—-+-—-卒—-+-—-卒—-+-—-卒—-+-—-卒]]","[[ | | | | | | | | | ]]","[[ +-—-+-—-+-—-+-—-+-—-+-—-+-—-+-—-+-]]","[[===================================]]","[[ +-—-+-—-+-—-+-—-+-—-+-—-+-—-+-—-+-]]","[[ | | | | | | | | | ]]","[[ 兵—-+-—-兵—-+-—-兵—-+-—-兵—-+-—-兵]]","[[ | | | | | | | | | ]]","[[ +-—-砲—-+-—-+-—-+-—-+-—-+-—-砲—-+-]]","[[ | | | | \\ | / | | | | ]]","[[ +-—-+-—-+-—-+-—-+-—-+-—-+-—-+-—-+-]]","[[ | | | | / | \\ | | | | ]]","[[ 車—-馬—-相—-仕—-帥—-仕—-相—-馬—-車]]","[[-----------------------------------]]","[[===================================]]"};int if_ov = 0;system("mode con cols=42 lines=32"); //迷你界面system("color 70");printf("[[==================================]]\n");printf("[[ -------------------------------- ]]\n");printf("[[ | | ]]\n");printf("[[ | 【<<游戏规则>>】| ]]\n");printf("[[ | | ]]\n");printf("[[ |------------------------------| ]]\n");printf("[[ | 控制wasd双方轮流控制指针下棋| ]]\n");printf("[[ |------------------------------| ]]\n");printf("[[ | 键盘输入大小写‘M ’| ]]\n");printf("[[ | 都视为确认下棋| ]]\n");printf("[[ |------------------------------| ]]\n");printf("[[ | 为了方便区分棋子| ]]\n");printf("[[ | 先手方全设为繁体复杂字体| ]]\n");printf("[[ |------------------------------| ]]\n");printf("[[ |------------------------------| ]]\n");printf("[[ | 我已阅读规则，按任意键继续| ]]\n");printf("[[ |------------------------------| ]]\n");printf("[[==================================]]\n");getch( );system("mode con cols=42 lines=32"); //迷你界面system("color 70");for ( i = 0; i < 27; i++){ puts(map[i]); Sleep(100); }x = 6, y = 19; tp = map[x][y]; tp1 = map[x][y+1];while(num){ if (num % 2 == 1 &&num / 2 % 2 == 0){ printf(" 现在是'帥'的回合\n");round = 1; } else if( num %2 == 1){ printf(" 现在轮到'将'的回合了\n");round = 2; }ch = getch( );if ( ch == 's') //下移{ if ( map[x+1][y]!= '-'){map[x][y] =tp; map[x][y+1] = tp1;x = x + 2; tp = map[x][y]; tp1 = map[x][y+1];map[x][y] = tn; map[x][y+1] = tn1;}}else if ( ch == 'a') //左移{ if (map[x][y-1]!=' '){map[x][y] =tp; map[x][y+1] = tp1;y = y - 4; tp = map[x][y]; tp1 = map[x][y+1];map[x][y] = tn; map[x][y+1] = tn1;}}else if ( ch == 'w') //上移{ if ( map[x-1][y]!= '-'){map[x][y] =tp; map[x][y+1] = tp1;x = x - 2; tp = map[x][y]; tp1 = map[x][y+1];map[x][y] = tn; map[x][y+1] = tn1;}}else if ( ch == 'd') //右移{ if (map[x][y+2]!=']'){map[x][y] =tp; map[x][y+1] = tp1;y = y + 4; tp = map[x][y]; tp1 = map[x][y+1];map[x][y] = tn; map[x][y+1] = tn1;}}else if( ch == 'm' || ch =='M')//M确认要移动的棋子，或确认要移到的目的地{ if (num % 2 == 1 && tp != '+' && tp1 != '-') //取子{check[0] = tp; check[1] = tp1; check[2] = '\0';if ( round == 1){ for ( i = 0; i < 7; i++) //将方{ if ( strcmp(ck_1[i],check) == 0){tn = tp; tn1 = tp1; tp = '+'; tp1 = '-';ck_x = x; ck_y = y; ck_t = 10 + i;num++; break;}}if( i == 7){ printf("这不是你的棋子\n"); Sleep(500); }}else if( round == 2){for ( i = 0; i < 7; i++) //帅方{ if( strcmp(ck_2[i],check) == 0){tn = tp; tn1 = tp1; tp = '+'; tp1 = '-';ck_x = x; ck_y = y; ck_t = 20 + i;num++; break;}}if( i == 7){ printf("这不是你的棋子\n"); Sleep(500); }}}else if( num % 2 == 0) //放子{ char ck_1[8][3] ={"车","马","象","士","将","炮","卒","+-"};char ck_2[8][3] ={"俥","馬","相","仕","帥","軳","兵","+-"};//中界楚河上下坐标12 15 往下2 往右4if ( ck_t < 20){if( ck_t == 10) //车的走法规范(将方){ if((x == ck_x && y == ck_y)){tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if( y == ck_y ){ if( x > ck_x){ for(j = ck_x + 2; j < x;j = j + 2){ if(map[j][y] == '+'); else{printf("不合法的下法\n"); Sleep(500); break; }}if( j >= x) ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);}if( x < ck_x){ for(j = ck_x - 2; j > x;j = j - 2){ if(map[j][y] == '+'); else{printf("不合法的下法\n"); Sleep(500); break; }}if( j <= x) ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);}}else if( x == ck_x ){if( y > ck_y){for(j = ck_y + 4; j < y;j = j + 4){if(map[x][j] == '+'); else {printf("不合法的下法\n"); Sleep(500); break; }}if( j >= y) ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);}if( y < ck_y){for(j = ck_y - 4; j > y;j = j - 4){ if(map[x][j] == '+'); else { printf("不合法的下法\n"); Sleep(500); break; }}if( j <= y) ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);}}else { printf("不合法的下法\n"); Sleep(500); }}if( ck_t == 11) //马的走法规范{if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if( (abs( x - ck_x) == 2&& abs( y - ck_y) == 8)&& map[ck_x][(y+ck_y)/2] =='+') {ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map); }else if( (abs( x - ck_x) == 4&& abs( y - ck_y) == 4)&& map[(x + ck_x)/2][ck_y] == '+' ) {ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map); }else { printf("不合法的下法\n");Sleep(500); }}if( ck_t == 12) //相的走法规范{ if((x == ck_x && y == ck_y)){tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if( x >= 15 &&(abs(y - ck_y) == 8 && abs(x - ck_x) == 4)){if((x == 22 && (y == 11 || y == 27))||(x == 18 &&( y == 3 || y == 19 || y == 35)) ||(x == 14 && (y == 11|| y ==27))){ if( map[(x+ck_x)/2][(y+ck_y)/2] == '+')ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else {printf("棋子卡住，不可执行"); Sleep(500); }}else {printf("不合法的下法\n");Sleep(500); }}else {printf("不合法的下法\n"); Sleep(500); }}if( ck_t == 13) //士的走法规范{ if((x == ck_x && y == ck_y)){tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if( abs(x - ck_x)== 2 && abs( y - ck_y) == 4 &&((x==22 && (y == 15 || y == 23)) || ( x == 20 && y == 19) || ( x == 18 && ( y == 15 || y == 23)))){ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map); }else { printf("不合法的下法\n"); Sleep(500); }}if( ck_t == 14) //将的走法规范{ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if( ((abs(x - ck_x)== 2 && abs( y - ck_y) == 0 )|| (abs(x - ck_x)== 0 && abs( y - ck_y) == 4)) && x >= 18 && x <= 22 && y >= 15 && y <= 23 ){ ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map); }else { printf("不合法的下法\n"); Sleep(500); }}if( ck_t == 15) //炮的走法规范{ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if( y == ck_y ){ int check_pao = 0;if( x > ck_x){ for(j = ck_x + 2; j<= x ;j = j+ 2){ if(map[j][y] == '+' ); else check_pao++;}if(check_pao == 1&& tp == '+') // 直线行走但不可吃棋子ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else if( check_pao == 2 && tp != '+') //跳跃吃棋ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n"); Sleep(500); }}else { for(j = ck_x - 2; j>= x;j = j - 2){ if(map[j][y] == '+' ); else { check_pao++;} }if(check_pao == 1&& tp == '+') //直线行走但不可吃棋子ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else if( check_pao == 2 && tp != '+') //跳跃吃棋ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n"); Sleep(500); }}}else if( x == ck_x ){ int check_pao = 0;if( y > ck_y){ for(j = ck_y + 4; j<= y ;j = j+4){ if(map[x][j] == '+' ); else check_pao++;}if(check_pao == 1&& tp == '+') //直线行走但不可吃棋子ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else if( check_pao == 2 && tp != '+') //跳跃吃棋ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n"); Sleep(500); }}else {for(j = ck_y - 4; j>= y;j = j - 4){if(map[x][j] == '+' ); else check_pao++;}if(check_pao == 1&& tp == '+') //直线行走但不可吃棋子ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else if( check_pao == 2 && tp != '+') //跳跃吃棋ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n"); Sleep(500); }}}else { printf("不合法的下法\n");Sleep(500); }}if( ck_t == 16) //卒的走法规范{ if ( x >= 14){ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if( x == ck_x - 2 && y == ck_y)ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n"); Sleep(500); }}else{ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if((x - ck_x == 0 && abs(y-ck_y) ==4) ||( x - ck_x == -2 && abs(y-ck_y) == 0)) ckm1(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n"); Sleep(500); }}}}else { if( ck_t == 20) //车的走法规范(帅方){ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if( y == ck_y ){ if( x > ck_x){ for(j = ck_x + 2; j < x;j = j + 2){ if(map[j][y] == '+'); else {printf("不合法的下法\n"); Sleep(500); break; } }if( j >= x) ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);}if( x < ck_x){ for(j = ck_x - 2; j > x;j = j - 2){ if(map[j][y] == '+'); else { printf("不合法的下法\n"); Sleep(500); break; } }if( j <= x) ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);}}else if( x == ck_x ){ if( y > ck_y){ for(j = ck_y + 4; j < y;j = j + 4){ if(map[x][j] == '+'); else { printf("不合法的下法\n"); Sleep(500); break; } }if( j >= y) ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);}if( y < ck_y){ for(j = ck_y - 4; j > y;j = j - 4){ if(map[x][j] == '+'); else { printf("不合法的下法\n");Sleep(500); break; } }if( j <= y) ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);}}else { printf("不合法的下法\n"); Sleep(500); }}if( ck_t == 21) //马的走法规范{ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n");printf("还是你的回合"); Sleep(500);}else if( (abs( x - ck_x) == 2&& abs( y - ck_y) == 8)&&map[ck_x][(y+ck_y)/2] =='+'){ ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map); }else if( (abs( x - ck_x) == 4&& abs( y - ck_y) == 4)&&map[(x + ck_x)/2][ck_y] == '+' ){ ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map); }else { printf("不合法的下法\n");Sleep(500); }}if( ck_t == 22) //相的走法规范{ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n");printf("还是你的回合"); Sleep(500);}else if( x <= 12 && (abs(y - ck_y) == 8 && abs(x - ck_x) == 4)){ if((x == 4 && (y == 11 || y == 27))||(x == 8 && ( y == 3 || y == 19 || y == 35)) ||(x == 12 && (y == 11|| y ==27))){ if( map[(x+ck_x)/2][(y+ck_y)/2] == '+')ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("棋子卡住，不可执行");Sleep(500); }}else {printf("不合法的下法\n");Sleep(500); }}else { printf("不合法的下法\n");Sleep(500); }}if( ck_t == 23) //士的走法规范{ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n");printf("还是你的回合"); Sleep(500);}else if( abs(x - ck_x)== 2 && abs( y - ck_y) == 4 &&((x==4 &&(y == 15 || y == 23)) || ( x == 6 && y == 19) || ( x == 8 && ( y == 15 || y == 23)))) { ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map); }else { printf("不合法的下法\n");Sleep(500); }}if( ck_t == 24) //将的走法规范{ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n");printf("还是你的回合"); Sleep(500);}else if( ((abs(x - ck_x)== 2 && abs( y - ck_y) == 0 )|| (abs(x - ck_x)== 0 && abs( y - ck_y) == 4)) && x >= 4 && x <= 8 && y >= 15 && y <= 23 ){ ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map); }else {printf("不合法的下法\n");Sleep(500); }}if( ck_t == 25) //炮的走法规范{ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n");printf("还是你的回合"); Sleep(500);}else if( y == ck_y ){ int check_pao = 0;if( x > ck_x){ for(j = ck_x + 2; j<= x ;j = j+ 2){ if(map[j][y] == '+' ); else check_pao++;}if(check_pao == 1&& tp == '+') //直线行走但不可吃棋子ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else if( check_pao == 2 && tp != '+') //跳跃吃棋ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n");Sleep(500); }}else { for(j = ck_x - 2; j>= x;j = j - 2){ if(map[j][y] == '+' ); else { check_pao++;} }if(check_pao == 1&& tp== '+') //直线行走但不可吃棋子ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else if( check_pao == 2 && tp != '+') //跳跃吃棋ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n");Sleep(500); }}}else if( x == ck_x ){ int check_pao = 0;if( y > ck_y){ for(j = ck_y + 4; j<= y ;j = j+4){ if(map[x][j] == '+' ); else check_pao++;}if(check_pao == 1&& tp == '+') //直线行走但不可吃棋子ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else if( check_pao == 2 && tp != '+') //跳跃吃棋ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n");Sleep(500); }}else{ for(j = ck_y - 4 ; j>= y;j = j - 4){ if(map[x][j] == '+' ); else check_pao++;}if(check_pao ==1&& tp == '+') //直线行走但不可吃棋子ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else if( check_pao == 2&& tp != '+') //跳跃吃棋ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n");Sleep(500); }}}else { printf("不合法的下法\n");Sleep(500); }}if( ck_t == 26) //卒的走法规范{ if( x <= 12){ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n"); printf("还是你的回合"); Sleep(500);}else if( x == ck_x + 2 && y == ck_y)ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n");Sleep(500); }}else{ if((x == ck_x && y == ck_y)){ tp = tn; tp1 = tn1; tn = 'O'; tn1 = 'N'; num--;printf("三思而后行\n");printf("还是你的回合"); Sleep(500);}else if((x - ck_x == 0 && abs(y-ck_y) ==4) ||( x - ck_x == 2&& abs(y-ck_y) == 0))ckm2(&tp,&tp1,&tn,&tn1,&num,&if_ov,map);else { printf("不合法的下法\n");Sleep(500); }}}}}}system("cls");if( if_ov) return;for(i = 0; i < 27; i++)puts(map[i]);}Sleep(5000);}int main( ){while(1){xiangqi( );printf("\n 重来，请按键.\n");getch( );}return 0;}。
中国象棋(CS版)
中国象棋（C/S版）1．设计内容及要求1.1 中国象棋的基本要求设计C/S网络版中国象棋，也就是客户端与服务器端都是java应用程序。
具体要求如下：(1)中国象棋是双方在有着9调竖线和10条横线的棋盘上对弈，竖线和横线的交叉称为棋点或对弈点，每个棋子都是在棋点上行走，而不是在方格中行走。
(2) 河界将棋盘分成两等份，每一边都有一块有9个点组成的九宫，棋子“将”，“帅”和“士”只能在九宫内移动，并且“将”和“帅”每一步只可以水平或垂直移动一个棋点；“士”只能在九宫内移动，并且它每一步只可以沿着对角线移动一个棋点；“象”必须一次沿着对角线方向走两个棋点，但它不能过河也不能跳过或穿越障碍，即“象”不能别眼，“马”没一步只可以水平或垂直移动两个棋点，但必须按对角线向左或向右移动。
中国象棋的“马”不能跳过障碍，即马不能别腿。
“车”可以水平或垂直方向移动人一个无障碍的点。
“炮”移动起来和车类似，但它必须跳过一个棋子来吃掉对方的一个棋子，被跳过的那个棋子称为桥或者屏风。
“兵”每步只能向前移动一个棋子过河以后，它便增加了向左右移动的能力，并不允许向后移动。
(3) 用户开始运行程序后，进入用户登录界面，用户输入正确的用户名和密码才可以进入中国象棋主界面。
(4) 用户进入主界面后，单击“建立主机”按钮，就把该计算机作为主机，等待其他用户登录到这台主机后，才可以进行对弈。
(5) 当有用户登录到这台主机上士，用户单击“开始”按钮就可以开始想起对弈了，在对弈过程中，用户可以单击“悔棋”按钮，就可以实现悔棋，用户还可以单击“认输”按钮，向对方认输。
(6) 如果用户赢了，用户的积分就会增加。
(7) 用户在对弈过程中可以聊天。
1.2 需实现的主要功能(1) 用户登录验证功能。
(2) 每一个用户可以把自己的计算机做为主机。
(3) 每一个用户可以寻找主机，并且与主机建立连接。
(4) 用户在对弈过程中，可以悔棋，而且可以认输。
(5) 没一个用户都用积分，当赢了比赛后，用户的积分就会增加。
C语言编写象棋程序代码上课讲义
C语言编写象棋程序代码/*--------------------chess.c----------------------*/ #include "dos.h"#include "stdio.h"/*----------------------------------------------------*/ #define RED 7#define BLACK 14#define true 1#define false 0#define SELECT 0#define MOVE 1#define RED_UP 0x1100#define RED_DOWN 0x1f00#define RED_LEFT 0x1e00#define RED_RIGHT 0x2000#define RED_DO 0x3900#define RED_UNDO 0x1000#define BLACK_UP 0x4800#define BLACK_DOWN 0x5000#define BLACK_LEFT 0x4b00#define BLACK_RIGHT 0x4d00#define BLACK_DO 0x1c00#define BLACK_UNDO 0x2b00#define ESCAPE 0x0100#define RED_JU 1#define RED_MA 2#define RED_XIANG 3#define RED_SHI 4#define RED_JIANG 5#define RED_PAO 6#define RED_BIN 7#define BLACK_JU 8#define BLACK_MA 9#define BLACK_XIANG 10#define BLACK_SHI 11#define BLACK_JIANG 12#define BLACK_PAO 13#define BLACK_BIN 14/*----------------------------------------------------*/ int firsttime=1;int savemode;char page_new=0,page_old=0;int finish=false,turn=BLACK,winner=0;int key;int redstate=SELECT,blackstate=SELECT;int board[10][9];/*----------------------------------------------------*/char *chessfile[15]={"","bmp\\rju.wfb", "bmp\\rma.wfb","bmp\\rxiang.wfb","bmp\\rshi.wfb","bmp\\rjiang.wfb","bmp\\rpao.wfb","bmp\\rbin.wfb","bmp\\bju.wfb", "bmp\\bma.wfb","bmp\\bxiang.wfb","bmp\\bshi.wfb","bmp\\bjiang.wfb","bmp\\bpao.wfb","bmp\\bbin.wfb"};char *boardfile[10][9]={{"bmp\\11.wfb","bmp\\1t.wfb","bmp\\1t.wfb","bmp\\14.wfb","bmp\\15.wfb","bmp\\1 6.wfb","bmp\\1t.wfb","bmp\\1t.wfb","bmp\\19.wfb"},{"bmp\\21.wfb","bmp\\2c.wfb","bmp\\2c.wfb","bmp\\24.wfb","bmp\\25.wfb","bmp\\ 26.wfb","bmp\\2c.wfb","bmp\\2c.wfb","bmp\\29.wfb"},{"bmp\\21.wfb","bmp\\3a.wfb","bmp\\3t.wfb","bmp\\34.wfb","bmp\\3t.wfb","bmp\\3 6.wfb","bmp\\3t.wfb","bmp\\3a.wfb","bmp\\29.wfb"},{"bmp\\41.wfb","bmp\\4t.wfb","bmp\\4a.wfb","bmp\\4t.wfb","bmp\\4a.wfb","bmp\\4t .wfb","bmp\\4a.wfb","bmp\\4t.wfb","bmp\\49.wfb"},{"bmp\\51.wfb","bmp\\52.wfb","bmp\\5t.wfb","bmp\\54.wfb","bmp\\5t.wfb","bmp\\5 6.wfb","bmp\\5t.wfb","bmp\\58.wfb","bmp\\59.wfb"},{"bmp\\61.wfb","bmp\\62.wfb","bmp\\6t.wfb","bmp\\64.wfb","bmp\\6t.wfb","bmp\\6 6.wfb","bmp\\6t.wfb","bmp\\68.wfb","bmp\\69.wfb"},{"bmp\\71.wfb","bmp\\7t.wfb","bmp\\7a.wfb","bmp\\7t.wfb","bmp\\7a.wfb","bmp\\7t .wfb","bmp\\7a.wfb","bmp\\7t.wfb","bmp\\79.wfb"},{"bmp\\81.wfb","bmp\\8a.wfb","bmp\\8t.wfb","bmp\\84.wfb","bmp\\85.wfb","bmp\\8 6.wfb","bmp\\8t.wfb","bmp\\8a.wfb","bmp\\89.wfb"},{"bmp\\91.wfb","bmp\\9t.wfb","bmp\\9t.wfb","bmp\\9t.wfb","bmp\\95.wfb","bmp\\9t .wfb","bmp\\9t.wfb","bmp\\9t.wfb","bmp\\99.wfb"},{"bmp\\101.wfb","bmp\\102.wfb","bmp\\102.wfb","bmp\\104.wfb","bmp\\105.wfb"," bmp\\106.wfb","bmp\\108.wfb","bmp\\108.wfb","bmp\\109.wfb"}};char cursor[14][14]={0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,255,255,255,255,255,255,255,0,0,1,1,1,1,0,255,255,255,255,255,255,0,0,1,1,1,1,1,0,255,255,255,255,255,255,0,0,1,1,1,1,1,0,255,255,255,255,255,255,255,0,0,1,1,1,1,0,255,255,255,255,255,255,255,255,0,0,1,1,1,0,255,255,255,255,255,255,255,255,255,0,0,1,1,0,255,255,0,255,255,255,255,255,255,255,0,0,1,0,255,0,1,1,0,255,255,255,255,255,255,255,0,0,0,1,1,1,1,0,255,255,255,255,255,0,1,0,1,1,1,1,1,1,0,255,255,255,0,1,1,1,1,1,1,1,1,1,1,0,255,0,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1};struct pos{int x;int y;}position[10][9],redcurpos,redtemppos,redoldpos,blackcurpos,blacktemppos,blackold pos;/*----------------------------------------------------*/selectpage(register char page) /*换页函数*/{union REGS r;r.x.ax=0x4f05;r.x.bx=0;r.x.dx=page; /*选择页面*/int86(0x10,&r,&r);}unsigned char set_SVGA_mode(int vmode) /*设置SVGA屏幕模式*/{union REGS r;r.x.ax=0x4f02;r.x.bx=vmode;int86(0x10,&r,&r);return(r.h.ah);}unsigned int get_SVGA_mode() /*获取当前SVGA屏幕模式*/ {union REGS r;r.x.ax=0x4f03;int86(0x10,&r,&r);return(r.x.bx);}drawbmp(int start_x,int start_y,char filename[]){char buffer[640];int i,j,k,n,r,g,b,width,length;long position;FILE *fp;if((fp=fopen(filename,"rb"))==NULL){printf("Error! Can't open file!");getch();return;}fseek(fp,28,SEEK_SET);fread(&i,2,1,fp);if(i!=8) /*检查是否为256色位图*/{puts("Error!Can't find bitmap!");fclose(fp);getch();exit(0);}fseek(fp,18,SEEK_SET);fread(&width,4,1,fp);fread(&length,4,1,fp);if(firsttime){fseek(fp,54,SEEK_SET);for(i=0;i<256;i++) /*按照该图片的DAC色表设置色彩寄存器*/{b=fgetc(fp);g=fgetc(fp);r=fgetc(fp); /*获取R、G、B分量*/outportb(0x3c8,i);outportb(0x3c9,r>>2); /*右移是要转化为VGA的6位寄存器形式*/outportb(0x3c9,g>>2);outportb(0x3c9,b>>2);fgetc(fp);}}elsefseek(fp,300,SEEK_SET);k=(width%4)?(4-width%4):0; /*宽度修正值*/for(j=length-1+start_x;j>=start_x;j--){fread(buffer,width,1,fp);for(i=start_y,n=0;i<width+start_y;i++,n++){position=j*640l+i; /*计算要显示点的显存位置*/page_new=position/65536; /*计算显示页*/if(page_new!=page_old) /*当显示页不同时更换页面，提高一定的输出速度*/ {selectpage(page_new);page_old=page_new;}pokeb(0xa000,position%65536,buffer[n]); /*写到显存位置*/}fseek(fp,k,SEEK_CUR); /*每行绘制完后修正宽度*/}fclose(fp);}init(){savemode=get_SVGA_mode(); /*先保存原来的屏幕模式*/set_SVGA_mode(0x101); /*硬件无关性初始化屏幕为640*480 256色模式*/}end(){set_SVGA_mode(savemode); /*恢复屏幕*/ }/*----------------------------------------------------*/ initpos(){int i,j;for(i=0;i<10;i++)for (j=0;j<9;j++){position[i][j].x=35+i*39;position[i][j].y=43+j*40;}}initchessmap(){board[0][0]=BLACK_JU;board[0][1]=BLACK_MA;board[0][2]=BLACK_XIANG;board[0][3]=BLACK_SHI;board[0][4]=BLACK_JIANG;board[0][5]=BLACK_SHI;board[0][6]=BLACK_XIANG;board[0][7]=BLACK_MA;board[0][8]=BLACK_JU;board[2][1]=BLACK_PAO;board[2][7]=BLACK_PAO;board[3][0]=BLACK_BIN;board[3][2]=BLACK_BIN;board[3][4]=BLACK_BIN;board[3][6]=BLACK_BIN;board[3][8]=BLACK_BIN;board[9][0]=RED_JU;board[9][1]=RED_MA;board[9][2]=RED_XIANG;board[9][3]=RED_SHI;board[9][4]=RED_JIANG;board[9][5]=RED_SHI;board[9][6]=RED_XIANG;board[9][7]=RED_MA;board[9][8]=RED_JU;board[7][1]=RED_PAO;board[7][7]=RED_PAO;board[6][0]=RED_BIN;board[6][2]=RED_BIN;board[6][4]=RED_BIN;board[6][6]=RED_BIN;board[6][8]=RED_BIN;}initdrawchess(){int i,j;;for(i=0;i<10;i++)for(j=0;j<9;j++){if(board[i][j])drawbmp(position[i][j].x,position[i][j].y,chessfile[board[i][j]]);}}drawcursor(struct pos p){int i,j,n,m,x,y;long thisposition;x=position[p.x][p.y].x+20;y=position[p.x][p.y].y+25;for(j=13-1+x,m=13;j>=x;j--,m--){for(i=y,n=0;i<13+y;i++,n++){thisposition=j*640l+i; /*计算要显示点的显存位置*/page_new=thisposition/65536; /*计算显示页*/if(page_new!=page_old) /*当显示页不同时更换页面，提高一定的输出速度*/ {selectpage(page_new);page_old=page_new;}if(cursor[m][n]!=1)if(cursor[m][n]==0)pokeb(0xa000,thisposition%65536,0);elseif(turn==RED)pokeb(0xa000,thisposition%65536,153);elsepokeb(0xa000,thisposition%65536,255);}}}drawselecursor(struct pos p){int i,j,n,m,x,y;long thisposition;x=position[p.x][p.y].x+20;y=position[p.x][p.y].y+25;for(j=13-1+x,m=13;j>=x;j--,m--){for(i=y,n=0;i<13+y;i++,n++){thisposition=j*640l+i; /*计算要显示点的显存位置*/page_new=thisposition/65536; /*计算显示页*/if(page_new!=page_old) /*当显示页不同时更换页面，提高一定的输出速度*/ {selectpage(page_new);page_old=page_new;}if(cursor[m][n]!=1)pokeb(0xa000,thisposition%65536,0);}}}/*----------------------------------------------------*/int getkey(){int press;while(bioskey(1) == 0);press=bioskey(0);press=press&0xff00;return(press);}/*--------------------红方操作--------------------*/int redcanselect(){int x,y;x=redcurpos.x;y=redcurpos.y;if(board[x][y]>=RED_JU&&board[x][y]<=RED_BIN)return 1;elsereturn 0;}int redcanmove(){int i,j,min,max,oldx,oldy,x,y;oldx=redoldpos.x;oldy=redoldpos.y;x=redcurpos.x;y=redcurpos.y;/*case1 目标位置是否是自己人*/if(board[x][y]>=RED_JU&&board[x][y]<=RED_BIN)return 0;/* 军、马、炮、相、士、将、卒的走法正确性的判断*/ switch(board[oldx][oldy]){case RED_BIN: /*完成*/if(oldx>=5){ if(y!=oldy||(oldx-x)!=1) return 0;}else{ if(x==(oldx-1)&&y==oldy) return 1;elseif(x==oldx&&y==(oldy+1)) return 1;elseif(x==oldx&&y==(oldy-1)) return 1;elsereturn 0;}break;case RED_JIANG: /*完成*/if(x!=oldx&&y!=oldy) return 0;if(x!=oldx)if((x-oldx)>1||(oldx-x)>1) return 0;else if(x<7) return 0;else if(y!=oldy)if((y-oldy)>1||(oldy-y)>1) return 0;else if(y<3||y>5) return 0;break;case RED_JU: /*完成*/if(x!=oldx&&y!=oldy) return 0;else if(x!=oldx){ min=(x>oldx)?oldx:x;max=(x>oldx)?x:oldx;for(i=min+1;i<max;i++)if(board[i][y]!=0) return 0;}else if(y!=oldy){ min=(y>oldy)?oldy:y;max=(y>oldy)?y:oldy;for(i=min+1;i<max;i++)if(board[x][i]!=0) return 0;}break;case RED_MA: /*完成*/if((x-oldx)==2&&((y-oldy)==1||(oldy-y)==1)) {if(board[oldx+1][oldy]!=0) return 0;}elseif((oldx-x)==2&&((y-oldy)==1||(oldy-y)==1)) {if(board[oldx-1][oldy]!=0) return 0;}elseif((y-oldy)==2&&((x-oldx)==1||(oldx-x)==1)) {if(board[oldx][oldy+1]!=0) return 0;}elseif((oldy-y)==2&&((x-oldx)==1||(oldx-x)==1)) {if(board[oldx][oldy-1]!=0) return 0;}elsereturn 0;break;case RED_PAO: /*完成*/ if(x!=oldx&&y!=oldy) return 0;if(board[x][y]==0){if(x!=oldx){ min=(x>oldx)?oldx:x;max=(x>oldx)?x:oldx;for(i=min+1;i<max;i++)if(board[i][y]!=0) return 0;}else if(y!=oldy){ min=(y>oldy)?oldy:y;max=(y>oldy)?y:oldy;for(i=min+1;i<max;i++)if(board[x][i]!=0) return 0;}}else{if(x!=oldx){ min=(x>oldx)?oldx:x;max=(x>oldx)?x:oldx;for(i=min+1,j=0;i<max;i++)if(board[i][y]!=0) j++;if(j!=1) return 0;}else if(y!=oldy){ min=(y>oldy)?oldy:y;max=(y>oldy)?y:oldy;for(i=min+1,j=0;i<max;i++)if(board[x][i]!=0) j++;if(j!=1) return 0;}}break;case RED_SHI: /*完成*/ if(oldx==9||oldx==7){if(x!=8||y!=4) return 0;}else if(oldx==8){if(x==9&&y==3) return 1;elseif(x==9&&y==5) return 1;elseif(x==7&&y==3) return 1;elseif(x==7&&y==5) return 1;else return 0;}else return 0;break;case RED_XIANG: /*完成*/if(x<5) return 0;if(x!=oldx&&y!=oldy){if((x-oldx)==2&&(y-oldy)==2){i=oldx+1;j=oldy+1;}else if((x-oldx)==2&&(oldy-y)==2){i=oldx+1;j=oldy-1;}else if((oldx-x)==2&&(y-oldy)==2){i=oldx-1;j=oldy+1;}else if((oldx-x)==2&&(oldy-y)==2){i=oldx-1;j=oldy-1;}else return 0;if(board[i][j]!=0) return 0;}else return 0;break;}return 1;}redup(){int x,y,n;if(redcurpos.x>0){redcurpos.x--;x=position[redtemppos.x][redtemppos.y].x;y=position[redtemppos.x][redtemppos.y].y;if(board[redtemppos.x][redtemppos.y]==0)drawbmp(x,y,boardfile[redtemppos.x][redtemppos.y]);elseif(!(redtemppos.x==redoldpos.x&&redtemppos.y==redoldpos.y&&redstate==MOVE )){n=board[redtemppos.x][redtemppos.y];drawbmp(x,y,chessfile[n]);}if(redtemppos.x==redoldpos.x&&redtemppos.y==redoldpos.y&&redstate==MOVE) drawselecursor(redoldpos);drawcursor(redcurpos);redtemppos.x=redcurpos.x;redtemppos.y=redcurpos.y;}}reddown(){int x,y,n;if(redcurpos.x<9){redcurpos.x++;x=position[redtemppos.x][redtemppos.y].x;y=position[redtemppos.x][redtemppos.y].y;if(board[redtemppos.x][redtemppos.y]==0)drawbmp(x,y,boardfile[redtemppos.x][redtemppos.y]);elseif(!(redtemppos.x==redoldpos.x&&redtemppos.y==redoldpos.y&&redstate==MOVE )){n=board[redtemppos.x][redtemppos.y];drawbmp(x,y,chessfile[n]);}if(redtemppos.x==redoldpos.x&&redtemppos.y==redoldpos.y&&redstate==MOVE) drawselecursor(redoldpos);drawcursor(redcurpos);redtemppos.x=redcurpos.x;redtemppos.y=redcurpos.y;}}redleft(){int x,y,n;if(redcurpos.y>0){redcurpos.y--;x=position[redtemppos.x][redtemppos.y].x;y=position[redtemppos.x][redtemppos.y].y;if(board[redtemppos.x][redtemppos.y]==0)drawbmp(x,y,boardfile[redtemppos.x][redtemppos.y]);elseif(!(redtemppos.x==redoldpos.x&&redtemppos.y==redoldpos.y&&redstate==MOVE )){n=board[redtemppos.x][redtemppos.y];drawbmp(x,y,chessfile[n]);}if(redtemppos.x==redoldpos.x&&redtemppos.y==redoldpos.y&&redstate==MOVE) drawselecursor(redoldpos);drawcursor(redcurpos);redtemppos.x=redcurpos.x;redtemppos.y=redcurpos.y;}}redright(){int x,y,n;if(redcurpos.y<8){redcurpos.y++;x=position[redtemppos.x][redtemppos.y].x;y=position[redtemppos.x][redtemppos.y].y;if(board[redtemppos.x][redtemppos.y]==0)drawbmp(x,y,boardfile[redtemppos.x][redtemppos.y]);elseif(!(redtemppos.x==redoldpos.x&&redtemppos.y==redoldpos.y&&redstate==MOVE )){n=board[redtemppos.x][redtemppos.y];drawbmp(x,y,chessfile[n]);}if(redtemppos.x==redoldpos.x&&redtemppos.y==redoldpos.y&&redstate==MOVE) drawselecursor(redoldpos);drawcursor(redcurpos);redtemppos.x=redcurpos.x;redtemppos.y=redcurpos.y;}}reddo(){int i,j,x,y,n;if(redstate==SELECT&&redcanselect()){if(board[redcurpos.x][redcurpos.y]<=RED&&board[redcurpos.x][redcurpos.y]>0) {redstate=MOVE;drawselecursor(redcurpos);redoldpos.x=redcurpos.x;redoldpos.y=redcurpos.y;}}else if(redstate==MOVE&&redcanmove()){x=position[redoldpos.x][redoldpos.y].x;y=position[redoldpos.x][redoldpos.y].y;drawbmp(x,y,boardfile[redoldpos.x][redoldpos.y]);x=position[redcurpos.x][redcurpos.y].x;y=position[redcurpos.x][redcurpos.y].y;n=board[redoldpos.x][redoldpos.y];drawbmp(x,y,chessfile[n]);if(board[redcurpos.x][redcurpos.y]==BLACK_JIANG){winner=RED;finish=1;return;}board[redcurpos.x][redcurpos.y]=n;board[redoldpos.x][redoldpos.y]=0;for(i=0;i<=2;i++)for(j=3;j<=5;j++)if(board[i][j]==BLACK_JIANG){x=i;y=j;}for(i=x+1,j=y,n=0;i<=9;i++){if(board[i][j]==RED_JIANG&&n==0){winner=BLACK;finish=1;break;}else if(board[i][j]!=0) n++;}turn=BLACK;blackstate=SELECT;drawcursor(blackcurpos);drawbmp(30,438,"bmp\\bzq.wfb"); /*转交控制权给黑方*/ }}redundo(){int x,y,n;if(redstate==MOVE){x=position[redoldpos.x][redoldpos.y].x;y=position[redoldpos.x][redoldpos.y].y;n=board[redoldpos.x][redoldpos.y];drawbmp(x,y,chessfile[n]);redoldpos.x=redcurpos.x;redoldpos.y=redcurpos.y;drawcursor(redcurpos);redstate=SELECT;}}/*--------------------黑方操作----------------------*/int blackcanselect(){int x,y;x=blackcurpos.x;y=blackcurpos.y;if(board[x][y]>=BLACK_JU&&board[x][y]<=BLACK_BIN)return 1;elsereturn 0;}int blackcanmove(){int i,j,min,max,oldx,oldy,x,y;oldx=blackoldpos.x;oldy=blackoldpos.y;x=blackcurpos.x;y=blackcurpos.y;/*case1 目标位置是否是自己人*/if(board[x][y]>=BLACK_JU&&board[x][y]<=BLACK_BIN) return 0;/* 军、马、炮、相、士、将、卒的走法正确性的判断*/ switch(board[oldx][oldy]){case BLACK_JU: /*完成*/if(x!=oldx&&y!=oldy) return 0;else if(x!=oldx){ min=(x>oldx)?oldx:x;max=(x>oldx)?x:oldx;for(i=min+1;i<max;i++)if(board[i][y]!=0) return 0;}else if(y!=oldy){ min=(y>oldy)?oldy:y;max=(y>oldy)?y:oldy;for(i=min+1;i<max;i++)if(board[x][i]!=0) return 0;}break;case BLACK_MA: /*完成*/if((x-oldx)==2&&((y-oldy)==1||(oldy-y)==1)){if(board[oldx+1][oldy]!=0) return 0;}elseif((oldx-x)==2&&((y-oldy)==1||(oldy-y)==1)){if(board[oldx-1][oldy]!=0) return 0;}elseif((y-oldy)==2&&((x-oldx)==1||(oldx-x)==1)){if(board[oldx][oldy+1]!=0) return 0;}elseif((oldy-y)==2&&((x-oldx)==1||(oldx-x)==1)){if(board[oldx][oldy-1]!=0) return 0;}elsereturn 0;break;case BLACK_PAO: /*完成*/if(x!=oldx&&y!=oldy) return 0;if(board[x][y]==0){if(x!=oldx){ min=(x>oldx)?oldx:x;max=(x>oldx)?x:oldx;for(i=min+1;i<max;i++)if(board[i][y]!=0) return 0;}else if(y!=oldy){ min=(y>oldy)?oldy:y;max=(y>oldy)?y:oldy;for(i=min+1;i<max;i++)if(board[x][i]!=0) return 0;}}else{j=0;if(x!=oldx){ min=(x>oldx)?oldx:x;max=(x>oldx)?x:oldx;for(i=min+1;i<max;i++)if(board[i][y]!=0) j++;if(j!=1) return 0;}else if(y!=oldy){ min=(y>oldy)?oldy:y;max=(y>oldy)?y:oldy;for(i=min+1;i<max;i++)if(board[x][i]!=0) j++;if(j!=1) return 0;}}break;case BLACK_XIANG:if(x>4) return 0;if(x!=oldx&&y!=oldy){if((x-oldx)==2&&(y-oldy)==2){i=oldx+1;j=oldy+1;}else if((x-oldx)==2&&(oldy-y)==2){i=oldx+1;j=oldy-1;}else if((oldx-x)==2&&(y-oldy)==2) {i=oldx-1;j=oldy+1;}else if((oldx-x)==2&&(oldy-y)==2) {i=oldx-1;j=oldy-1;}else return 0;if(board[i][j]!=0) return 0;}else return 0;break;case BLACK_SHI:if(oldx==0||oldx==2){if(x!=1||y!=4) return 0;}else if(oldx==1){if(x==0&&y==3) return 1;elseif(x==0&&y==5) return 1;elseif(x==2&&y==3) return 1;elseif(x==2&&y==5) return 1;else return 0;}else return 0;break;case BLACK_JIANG:if(x!=oldx&&y!=oldy) return 0;if(x!=oldx)if((x-oldx)>1||(oldx-x)>1) return 0;else if(x>2) return 0;else if(y!=oldy)if((y-oldy)>1||(oldy-y)>1) return 0;else if(y<3||y>5) return 0;break;case BLACK_BIN:if(oldx<=4){ if(y!=oldy||(x-oldx)!=1) return 0;}else{ if(x==(oldx+1)&&y==oldy) return 1; elseif(x==oldx&&y==(oldy+1)) return 1; elseif(x==oldx&&y==(oldy-1)) return 1;elsereturn 0;}break;}return 1;}blackup(){int x,y,n;if(blackcurpos.x>0){blackcurpos.x--;x=position[blacktemppos.x][blacktemppos.y].x;y=position[blacktemppos.x][blacktemppos.y].y;if(board[blacktemppos.x][blacktemppos.y]==0)drawbmp(x,y,boardfile[blacktemppos.x][blacktemppos.y]);elseif(!(blacktemppos.x==blackoldpos.x&&blacktemppos.y==blackoldpos.y&&blackstat e==MOVE)){n=board[blacktemppos.x][blacktemppos.y];drawbmp(x,y,chessfile[n]);}if(blacktemppos.x==blackoldpos.x&&blacktemppos.y==blackoldpos.y&&blackstate ==MOVE)drawselecursor(blackoldpos);drawcursor(blackcurpos);blacktemppos.x=blackcurpos.x;blacktemppos.y=blackcurpos.y;}}blackdown(){int x,y,n;if(blackcurpos.x<9){blackcurpos.x++;x=position[blacktemppos.x][blacktemppos.y].x;y=position[blacktemppos.x][blacktemppos.y].y;if(board[blacktemppos.x][blacktemppos.y]==0)drawbmp(x,y,boardfile[blacktemppos.x][blacktemppos.y]);elseif(!(blacktemppos.x==blackoldpos.x&&blacktemppos.y==blackoldpos.y&&blackstat e==MOVE)){n=board[blacktemppos.x][blacktemppos.y];drawbmp(x,y,chessfile[n]);}if(blacktemppos.x==blackoldpos.x&&blacktemppos.y==blackoldpos.y&&blackstate ==MOVE)drawselecursor(blackoldpos);drawcursor(blackcurpos);blacktemppos.x=blackcurpos.x;blacktemppos.y=blackcurpos.y;}}blackleft(){int x,y,n;if(blackcurpos.y>0){blackcurpos.y--;x=position[blacktemppos.x][blacktemppos.y].x;y=position[blacktemppos.x][blacktemppos.y].y;if(board[blacktemppos.x][blacktemppos.y]==0)drawbmp(x,y,boardfile[blacktemppos.x][blacktemppos.y]);elseif(!(blacktemppos.x==blackoldpos.x&&blacktemppos.y==blackoldpos.y&&blackstat e==MOVE)){n=board[blacktemppos.x][blacktemppos.y];drawbmp(x,y,chessfile[n]);}if(blacktemppos.x==blackoldpos.x&&blacktemppos.y==blackoldpos.y&&blackstate ==MOVE)drawselecursor(blackoldpos);drawcursor(blackcurpos);blacktemppos.x=blackcurpos.x;blacktemppos.y=blackcurpos.y;}blackright(){int x,y,n;if(blackcurpos.y<8){blackcurpos.y++;x=position[blacktemppos.x][blacktemppos.y].x;y=position[blacktemppos.x][blacktemppos.y].y;if(board[blacktemppos.x][blacktemppos.y]==0)drawbmp(x,y,boardfile[blacktemppos.x][blacktemppos.y]);elseif(!(blacktemppos.x==blackoldpos.x&&blacktemppos.y==blackoldpos.y&&blackstat e==MOVE)){n=board[blacktemppos.x][blacktemppos.y];drawbmp(x,y,chessfile[n]);}if(blacktemppos.x==blackoldpos.x&&blacktemppos.y==blackoldpos.y&&blackstate ==MOVE)drawselecursor(blackoldpos);drawcursor(blackcurpos);blacktemppos.x=blackcurpos.x;blacktemppos.y=blackcurpos.y;}}blackdo(){int i,j,x,y,n;if(blackstate==SELECT&&blackcanselect()){if(board[blackcurpos.x][blackcurpos.y]<=BLACK&&board[blackcurpos.x][blackcurp os.y]>0){blackstate=MOVE;drawselecursor(blackcurpos);blackoldpos.x=blackcurpos.x;blackoldpos.y=blackcurpos.y;}else if(blackstate==MOVE&&blackcanmove()){x=position[blackoldpos.x][blackoldpos.y].x;y=position[blackoldpos.x][blackoldpos.y].y;drawbmp(x,y,boardfile[blackoldpos.x][blackoldpos.y]);x=position[blackcurpos.x][blackcurpos.y].x;y=position[blackcurpos.x][blackcurpos.y].y;n=board[blackoldpos.x][blackoldpos.y];drawbmp(x,y,chessfile[n]);if(board[blackcurpos.x][blackcurpos.y]==RED_JIANG){winner=BLACK;finish=1;return;}board[blackcurpos.x][blackcurpos.y]=n;board[blackoldpos.x][blackoldpos.y]=0;for(i=0;i<=2;i++)for(j=3;j<=5;j++)if(board[i][j]==BLACK_JIANG){x=i;y=j;}for(i=x+1,j=y,n=0;i<=9;i++){if(board[i][j]==RED_JIANG&&n==0){winner=RED;finish=1;break;}else if(board[i][j]!=0) n++;}turn=RED;redstate=SELECT;drawcursor(redcurpos);drawbmp(30,438,"bmp\\rzq.wfb"); /*转交控制权给红方*/ }}blackundo(){int x,y,n;if(blackstate==MOVE){x=position[blackoldpos.x][blackoldpos.y].x; y=position[blackoldpos.x][blackoldpos.y].y; n=board[blackoldpos.x][blackoldpos.y];drawbmp(x,y,chessfile[n]);blackoldpos.x=blackcurpos.x;blackoldpos.y=blackcurpos.y;drawcursor(blackcurpos);blackstate=SELECT;}}/*----------------------------------------------------*/ start(){drawcursor(blackcurpos);drawbmp(30,438,"bmp\\bzq.wfb");while(!finish){key=getkey();switch(key){case RED_UP:if(turn==RED)redup();break;case RED_DOWN:if(turn==RED)reddown();break;case RED_LEFT:if(turn==RED)redleft();break;case RED_RIGHT:if(turn==RED)redright();break;case RED_DO:if(turn==RED)reddo();break;case RED_UNDO:if(turn==RED)redundo();break;case BLACK_UP:if(turn==BLACK)blackup();break;case BLACK_DOWN:if(turn==BLACK)blackdown();break;case BLACK_LEFT:if(turn==BLACK)blackleft();break;case BLACK_RIGHT:if(turn==BLACK)blackright();break;case BLACK_DO:if(turn==BLACK)blackdo();break;case BLACK_UNDO:if(turn==BLACK)blackundo();break;case ESCAPE: finish=1;break; }}}main(){init();initpos();initchessmap();drawbmp(0,0,"bmp\\board.wfb"); initdrawchess();/*初始化光标位置*/redcurpos.x=redoldpos.x=redtemppos.x=9;redcurpos.y=redoldpos.y=redtemppos.y=8;blackcurpos.x=blackoldpos.x=blacktemppos.x=0; blackcurpos.y=blackoldpos.y=blacktemppos.y=0; /*开始*/start();if(winner==RED)drawbmp(200,200,"bmp\\redwin.wfb");else if(winner==BLACK)drawbmp(200,200,"bmp\\blackwin.wfb");elsedrawbmp(200,200,"bmp\\exit.wfb");getch();end();}。
12 C++课程设计_中国象棋
中国象棋实训指南游戏规则对局时，由执红棋的一方先走，双方轮流各走一着，直至分出胜、负、和，对局即终了。
轮到走棋的一方，要将某个棋子从一个交叉点走到另一个交叉点，或者吃掉对方的棋子而占领其交叉点，都算走一着。
双方各走一着，称为一个回合。
实验准备打开FunCode，创建一个新的java项目。
注意：项目名称必须为英文和数字，且不能有空格。
点击“项目”-〉“导入地图模板”，从对话框中选取名称为ChineseChess的模板导入。
导入成功后，界面如下：查看模板设置。
模板设置中有如下几点，在项目开发时需要用到：精灵的名称，创建精灵对象时，通过精灵名称把对象和精灵图片绑定在一起。
点击“运行游戏”按钮，运行游戏。
类的设计游戏中能直接看到的精灵：各种棋子、虽然不同种类的棋子行走的规则不一样，但是他们具有共同的特点,可以抽象出一个棋子类，然后不同的棋子继承棋子类，分别实现自己不同的方法。
游戏流程主流程游戏分四个状态：未开始、开始、运行和结束。
CGameMain类是控制游戏流程的类，游戏屏幕每刷新一次，调用一次该类的GameMainLoop方法。
GameMainLoop根据m_iGameState的值分别调用该类的GameInit、GameRun和GameEnd方法。
这三个方法对应初始化游戏、游戏运行和游戏结束这三个状态。
GameInit只执行一次。
执行后修改游戏状态。
屏幕刷新后，进入状态2，开始执行GameRun方法。
GameRun一直被执行。
当任意一方棋子的帅(将)成为隐藏状态的时候，游戏结束，另外一方获得胜利。
调用GameEnd执行一次，清除本局游戏数据，恢复游戏未开始状态。
游戏初始化完成游戏初始工作，界面上的工作：对双方棋子进行布局,以及更新走子方。
游戏运行游戏运行中，需要实时的更新框架的位置,棋子的状态,赢家的状态游戏结束把所有棋子状态置为隐藏。
鼠标点击事件本游戏中，游戏的主要互动方式为鼠标点击操作,当玩家触发点击事件时会出现以下情况（一）点击红方棋子在点击红方棋子时会有以下两种情况1)此时轮到红方走子，则选中点击的棋子2)此时轮到黑方走子，调用黑方选中棋子的吃方法（二）点击黑方棋子在点击黑方棋子时会出现以下两种情况1)此时轮到黑方走子,则选中点击的棋子2)此时轮到红方走子,则调用红方选中棋子的吃方法（三）点击其他敌方在点击其他敌方时会出现以下两种情况1)已经选中有棋子,则调用棋子移动的方法2)没有选中棋子,则不做处理实验任务任务一完成类的定义根据下方表格，完成以下各个类的定义。
C语言课程设计-中国象棋
C语言课程设计-中国象棋南昌航空大学借息工程学院课程设计说明书课程名称：C语言课程设计设计3目：中国象棋专计算机科学与技术班级：业：姓名: 学号：一评分: 指导教师：2012年6月26日I摘要II前言m功能描述IV配置要求v总体设计（个人负责模块）一、功能模块设计二、数据结构设计三、函数功能描述四、代码实现五、运行结果VI小结I摘要中国象棋是一款很古老、很受欢迎的游戏,其开发过程有一定的技巧和方法，其中涉及到函数调用、二维数组、键盘操作等方面的知识。
本游戏的开发者需要基本掌握复杂情况下函数的编写以及调用能力、二维数组的运用能力、复杂算法的设计能力等。
II前言中国象棋是一款经典的智力游戏，具有悠久的历史，I摘要早在战国时期就有了关于中国象棋的记载，经过几千年的流传，目前仍然是中国家喻户晓的棋类游戏，颇受欢迎。
因此，我们决定借这次机会通过用C语言将中国象棋实现出来，当然，我们也借鉴了前人的一些技巧经验。
有不足之处，希望老师能够谅解，我们以后将会再接再厉。
m功能描述本人负责棋子帅（将）、象（相）、士（仕）、卒（兵）子函数的编写，它们的所能实现的功能分别是:（1）帅（将）：控制棋子帅（将）能符合现实情况下的游戏规则而行走，例如帅（将）只能在规定范围内向上或向左、右、下行走一格,最后返回一个行走正确或行走错误的数据。
（2）象（相）：控制棋子象（相）能符合现实情况下的游戏规则而行走，例如象（相）只能在自己领域内走“田”字格，且中间不能有其他棋子阻挡，最后返回一个行走正确或行走错误的数据。
（3）士（仕）：控制棋子士（仕）能符合现实情况下的游戏规则而行走，例如士（仕）只能在规定范围内斜着跨一格，然后返回一个行走正确或行走错误的数据。
（4）卒（兵）：控制棋子卒（兵）能符合现实情况下的游戏规则而行走，例如卒（兵）只能一次走一格，同时在自己领域内只能向前走，而在对方领域内可向前、左、右方向走一格，最后返回一个行走正确或行走错误的数据。
c象棋课程设计
c 象棋课程设计一、教学目标本课程旨在让学生了解象棋的基本规则、棋谱识读、棋局策略，通过教学使学生掌握象棋的基本技能，培养学生的逻辑思维能力和策略规划能力。
在情感态度价值观方面，培养学生团队合作精神，增强学生对中国传统文化的认识和兴趣。
二、教学内容教学内容主要包括象棋的基本规则、棋谱识读、棋局策略、经典棋局分析等。
具体安排如下：1.象棋的基本规则：介绍象棋的棋盘、棋子、走法等基本知识。
2.棋谱识读：教授如何阅读和编写棋谱，使学生能够通过棋谱进行棋局分析和学习。
3.棋局策略：教授如何进行棋局策略规划，包括攻防技巧、棋局节奏的掌控等。
4.经典棋局分析：分析一些著名的棋局，让学生从中学习棋局策略和高水平的棋艺。
三、教学方法结合象棋课程的特点，采用讲授法、讨论法、案例分析法等教学方法。
在教学过程中，通过生动的讲解、实例分析、学生之间的讨论和互动，激发学生的学习兴趣和主动性。
同时，学生进行实战对弈，提高学生的实际操作能力和策略规划能力。
四、教学资源为了支持教学内容和教学方法的实施，准备以下教学资源：1.教材：《象棋入门教程》等适合学生水平的象棋教材。
2.参考书：提供一些象棋高级教程和棋谱集，供学生深入学习和参考。
3.多媒体资料：制作课件和教学视频，辅助讲解和展示棋局。
4.实验设备：提供足够的象棋棋盘和棋子，供学生进行实战对弈和练习。
五、教学评估本课程的评估方式包括平时表现、作业、考试等。
平时表现主要评估学生的课堂参与度、学习态度和对弈表现；作业包括棋谱分析、棋局策略设计等；考试包括理论知识考核和实战对弈考核。
评估方式客观、公正，全面反映学生的学习成果。
六、教学安排本课程的教学进度安排合理、紧凑，确保在有限的时间内完成教学任务。
教学时间安排考虑学生的作息时间，尽量安排在学生精力充沛的时间段。
教学地点选在安静、舒适的教室，提供足够的象棋棋盘和棋子。
同时，教学安排还考虑学生的兴趣爱好，适时一些有趣的象棋活动，提高学生的学习兴趣。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
南昌航空大学信息工程学院课程设计说明书课程名称： C语言课程设计设计题目：中国象棋专业：计算机科学与技术班级:______姓名：学号:___评分：指导教师：2012 年 6月26日目录Ⅰ摘要Ⅱ前言Ⅲ功能描述Ⅳ配置要求Ⅴ总体设计（个人负责模块）一、功能模块设计二、数据结构设计三、函数功能描述四、代码实现五、运行结果Ⅵ小结Ⅰ摘要中国象棋是一款很古老、很受欢迎的游戏，其开发过程有一定的技巧和方法，其中涉及到函数调用、二维数组、键盘操作等方面的知识。
本游戏的开发者需要基本掌握复杂情况下函数的编写以及调用能力、二维数组的运用能力、复杂算法的设计能力等。
Ⅱ前言中国象棋是一款经典的智力游戏，具有悠久的历史，早在战国时期就有了关于中国象棋的记载，经过几千年的流传，目前仍然是中国家喻户晓的棋类游戏，颇受欢迎。
因此，我们决定借这次机会通过用C语言将中国象棋实现出来，当然，我们也借鉴了前人的一些技巧经验。
有不足之处，希望老师能够谅解，我们以后将会再接再厉。
Ⅲ功能描述本人负责棋子帅（将）、象（相）、士（仕）、卒（兵）子函数的编写，它们的所能实现的功能分别是：（1）帅（将）：控制棋子帅（将）能符合现实情况下的游戏规则而行走，例如帅（将）只能在规定范围内向上或向左、右、下行走一格，最后返回一个行走正确或行走错误的数据。
（2）象（相）：控制棋子象（相）能符合现实情况下的游戏规则而行走，例如象（相）只能在自己领域内走“田”字格，且中间不能有其他棋子阻挡，最后返回一个行走正确或行走错误的数据。
（3）士（仕）：控制棋子士（仕）能符合现实情况下的游戏规则而行走，例如士（仕）只能在规定范围内斜着跨一格，然后返回一个行走正确或行走错误的数据。
（4）卒（兵）：控制棋子卒（兵）能符合现实情况下的游戏规则而行走，例如卒（兵）只能一次走一格，同时在自己领域内只能向前走，而在对方领域内可向前、左、右方向走一格，最后返回一个行走正确或行走错误的数据。
Ⅳ配置要求(1) 硬件配置CPU ：≥Pentium III 600 内存：≥64MB硬盘剩余空间：≥128MB (2) 软件环境Visual C++6.0及其以上版本Ⅴ 总体设计（个人负责模块）本人为小组成员，负责的模块是：棋子帅（将）、象（相）、士（仕）、卒（兵）子函数的设计与编写。
一、系统模块设计1、系统模块图本人所负责的模块共有四个小项目组成，分别是控制棋子正确行走的帅（将）、象（相）、士（仕）、卒（兵）子函数。
（1）帅（将）该子函数主要负责控制维持棋子帅（将）的正确行走，返回正确或错误的数据信息。
（2）象（相）该子函数主要负责控制维持棋子象（相）的正确行走，返回正确或错误的数据信息。
（3）士（仕）该子函数主要负责控制维持棋子士（仕）的正确行走，返回正确或错误的数据信息。
（4）卒（兵）该子函数主要负责控制维持棋子卒（兵）的正确行走，返回正确或错误的数据信息。
调 调用 调 调 调用用 用用图1. 系统模块图2、任务执行流程图在玩家进行游戏移动棋子帅（将）、象（相）、士（仕）、卒（兵）的时候，主函数调用这几个子函数的执行流程图均为：图2. 任务执行流程图二、数据结构设计四个子函数均定义了局部变量x1,x2,y1,y2,table[][10]，通过主函数调用将玩家从键盘输入的值传递给x1,x2,y1,y2. table[][10]是在主函数中定义的一个二维数组，在子函数中同样控制棋盘的输出。
三、函数功能描述1.chekshuai ( )函数原型：int checkshuai(int x1,int y1,int x2,int y2,int table[][10]) checkshuai( )函数控制棋子帅（将）的正确行走，通过主函数将初始位置的坐标x1,y1与目标位置的坐标x2,y2传递给该子函数，从而判别帅（将）的行走是否符合规则。
2.checkxiang ( )函数原型：int checkxiang(int x1,int y1,int x2,int y2,int table[][10])checkxiang( )函数控制棋子象（相）的正确行走，通过主函数将初始位置的坐标x1,y1与目标位置的坐标x2,y2传递给该子函数，从而判别象（相）的行走是否符合规则。
3.checkshi ( )函数原型：int checkshi(int x1,int y1,int x2,int y2,int table[][10])checkshi( )函数控制棋子士（仕）的正确行走，通过主函数将初始位置的坐标x1,y1与目标位置的坐标x2,y2传递给该子函数，从而判别士（仕）的行走是否符合规则。
4.checkbing ( )函数原型：int checkbing(int x1,int y1,int x2,int y2,int table[][10])checkbing( )函数控制棋子士（仕）的正确行走，通过主函数将初始位置的坐标x1,y1与目标位置的坐标x2,y2传递给该子函数，从而判别士（仕）的行走是否符合规则。
四、代码实现1. 帅（将）int checkshuai(int x1,int y1,int x2,int y2,int table[][10]){if ((x2<8 || x2>10 || y2<4 ||y2>6)&&(x2<1 || x2>3 || y2<4|| y2>6))//控制棋子的行走范围是在自己领域的九宫格内{printf("\n将或者帅是不能移出九宫区域的,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else if ((abs(x2-x1)==1)&&(abs(y2-y1)==1))// 控制棋子的行走只能是直线{printf("\n将或者帅是不能走斜线的哦,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else if (table[x2][y2]*table[x1][y1]>0)// 控制棋子只能覆盖对方棋子以分清敌我{printf("\n自己不能吃掉自己呀,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else if ((abs(x2-x1)>=2)||(abs(y2-y1)>=2))// 控制棋子每次只能跨越一格{printf("\n将或者帅不能一次走多格呀,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else return 1; // 若未遇到错误则返回1继续进行游戏}2. 象（相）int checkxiang(int x1,int y1,int x2,int y2,int table[][10]){if ((abs(x2-x1))!=2 || (abs(y2-y1))!=2)// 控制棋子的行走路线为田字格对角线{printf("\n相(象)只能走田字呀,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else if ((table[x1][y1]>0 &&x2>5)||(table[x1][y1]<0 &&x2<5)) // 控制棋子只能在自己领域内移动{printf("\n相(象)不能渡过楚河汉界呀,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else if (table[(x1+x2)/2][(y1+y2)/2]!=0)// 当棋子移动路径上有其他棋子阻挡时棋子不能移动{printf("\n您要移动的路径上有其他棋挡着呢,不能移动,重新输入吧!\n"); return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else if (table[x2][y2]*table[x1][y1]>0)// 控制棋子只能覆盖对方棋子以分清敌我{printf("\n自己不能吃掉自己呀,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else return 1; // 若未遇到错误则返回1继续进行游戏}3. 士（仕）int checkshi(int x1,int y1,int x2,int y2,int table[][10]){if ((x2<8 || x2>10 || y2<4 ||y2>6)&&(x2<1 || x2>3 || y2<4|| y2>6)) //控制棋子的行走范围是在自己领域的九宫格内{printf("\n士或者仕是不能移出九宫区域的,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else if (table[x2][y2]*table[x1][y1]>0)// 控制棋子只能覆盖对方棋子以分清敌我{printf("\n自己不能吃掉自己呀,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else if ((abs(x2-x1)>=2)||(abs(y2-y1)>=2))// 控制棋子每次只能跨越一格{printf("\n士或者仕不能一次走多格呀,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else if (!((abs(x2-x1)==1)&&(abs(y2-y1)==1)))// 控制棋子行走路径只能是沿着一格的对角线{printf("\n士或者仕只能斜着走呀,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}else return 1; // 若未遇到错误则返回1继续进行游戏}4. 卒（兵）int checkbing(int x1,int y1,int x2,int y2, int table[][10]){if(table[x1][y1]>0)// 兵（卒）是否是甲方棋子（在上方）{if(table[x2][y2]>0)// 控制棋子只能覆盖对方棋子以分清敌我{printf("\n拜托，不能自己吃自己!!!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}if(x1<6)// 此时兵（卒）没过河{if((y1==y2)&&(x2-x1==1))// 控制棋子只能向前走{return 1; // 若符合规则则继续游戏}else{printf("\n兵(卒)过河前只能向前走,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}}else// 若此时兵（卒）已过河{if(((y1==y2)&&(x2-x1==1))||((y1-y2==1)&&(x2==x1))||((y2-y1==1)&&(x2==x1))) //控制棋子过河后只能向前或者向左、右移动{return 1; // 若符合规则则继续游戏}else{printf("\n兵(卒)过河后只能向前走或者平移,不能后退,重新输入吧!\n"); return 0; // 规则错误后出现提示信息并且返回0进行重新输入}}}else//判断兵是否在乙方（在下方）{if(table[x2][y2]<0)// 控制棋子只能覆盖对方棋子以分清敌我{printf("\n拜托,自己不能吃自己!!!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}if(x1>5)// 如果兵（卒）没过河{if((y1==y2)&&(x1-x2==1))// 控制棋子只能向前走return 1; // 若符合规则则继续游戏else{printf("\n兵(卒)过河前只能向前走,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}}else// 如果兵（卒）已过河{if(((y1==y2)&&(x1-x2==1))||((y1-y2==1)&&(x2==x1))||((y2-y1==1)&&(x2==x1))) //控制棋子过河后只能向前或者向左、右移动return 1; // 若符合规则则继续游戏else{printf("\n兵(卒)过河后只能向前走或者平移,不能后退,重新输入吧!\n");return 0; // 规则错误后出现提示信息并且返回0进行重新输入}}}}五、运行结果1、游戏进入初始界面进入游戏后显示的初始界面截图如下图：图3. 游戏初始界面2、游戏进行中的界面如下显示了游戏进行中的界面截图：图4. 游戏进行过程中界面3、游戏结束完成游戏后结束的界面截图：图5.游戏结束界面Ⅵ小结两周的课程设计结束了，这次的课程设计不仅检验了我们所学的知识，同时也培养了大家如何去把一件事情认认真真的做好。