软著申请源代码

作者：爱笑家 | 发布时间：2020-12-23 19:11:34 收藏本文下载本文

前言围棋不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性.同时它起源于中国，古称“弈”,是我国传统技艺之一。本游戏软件提供了人机对弈，和棋手对弈（局域网对弈）两种模式，局域网模式可以保证多人同时进行游戏。本软件使用 C＃语言编写,在ｗindｏws 7 x64 系统下采用 Visual Ｓtｕdｉｏ 2010 开发和调试，附源码如下。

客户端程序：

/／-—-—-－—－－—－-－-－—－-—ｌogｉn。cs－—----—－-/／ using System;using Sysｔem．Colｌections。Generiｃ；ｕsing Sｙstem。CompｏｎｅｎtMｏｄｅl；ｕsing Ｓystｅm。Dａta;ｕｓｉng Sysｔｅm.Drawｉng；ｕsing Systｅm．Text； using Sｙｓtem．Ｗinｄowｓ．Formｓ；ｎamｅspace ｇｏ｛ｐｕbｌｉc ｐartial claｓs Logiｎ：

Form ｛ public Ｌｏgin（）{ IｎitｉaｌiｚeCｏmｐｏnｅnｔ（）；｝ /／人机对弈 prｉvａｔe ｖｏid buttoｎ1_Click（ｏbｊect senｄer, EvenｔArｇs ｅ）｛ thｉs．Hｉde（）;Playing playing = nｅw Ｐlａying（）； pｌayiｎg.ShowＤialog（）； this.Sｈow（）；

｝ //局域网对弈 priｖａte void ｂuｔton2_Clicｋ（ｏbject sender，EｖentArgｓｅ）｛ thｉｓ.Hide()； FｏrmRoｏm foｒｍroom = nｅｗ FｏrｍＲｏom（）； fｏｒmroｏm.ＳhowDｉａlog（）;ｔhis。Shoｗ()；｝ priｖaｔe void butｔｏn３＿Clｉｃｋ(objｅct ｓender，EｖｅntArgs ｅ)｛ Applicａtiｏn。Ｅxit（）；｝ pｒｉvaｔｅ void ｂuttｏn3＿ＭouｓeEnｔｅr（ｏbjecｔ seｎｄer，EvｅｎtAｒｇs e){ Bｕｔtｏn ｂtn ＝（Button）senｄer;btｎ．ＦoreColor = Color。Ｂlaｃk； btｎ.BackColor ＝ Coloｒ。Whｉte；｝ pｒivaｔe voiｄｂutｔon3_ＭouseＬｅaｖe（oｂject ｓender, EventＡrgs ｅ){ Bｕtton bｔn ＝(Button）seｎdeｒ;ｂｔn。FｏreＣolor ＝ Cｏlor．Wｈｉｔe;ｂtn．BackColor = Ｃoｌｏr.Ｂlaｃk;｝｝

} } /／-－--—--—-——－—－－--——Playiｎg。cs—-———－－—－// uｓing Ｓｙstem;ｕsiｎg Syｓtem。Ｃolｌecｔions。Generiｃ;ｕsing Sysｔｅm。CｏｍｐonentModeｌ;ｕsｉng System。Daｔa； usinｇ Systｅｍ.Drawing； uｓｉnｇ Systeｍ.Teｘt； using Ｓyｓtem.Windoｗs．Forms；ｎamesｐace ｇo ｛ｐublic partial clasｓ Playinｇ : Form { delｅgatｅ voｉd SeｔTextCａllbａck(sｔring tｅxt)； prｉvatｅｅnum Sｔａｔus ｛ NｏtSｔarteｄ = 0，ＩnＧamｅ = １，RemｏveDeａd ＝ 2, FilｌEｍpty = 3，Ended = ４｝ private Sysｔem。Threadiｎg。Tｈreａｄ pc_plaｙ； prｉvaｔｅ Boａrｄ m＿ｂｏａｒd = new Board（）;ｐriｖaｔｅ Cｈｅss.CｈessＴype ｍ＿tuｒn ＝ Chess.ChessTypｅ。Ｂlａck； private int ｍ_sｅｃonｄｓＢｌａｃk = 0;

priｖatｅ int m＿secondｓWhite = 0;pｒivaｔe Timer ｍ_ｔimｅr = nｅw Tiｍｅr（）； prｉvate Status ｍ_staｔus = Ｓtａtus.ＮoｔStarted； pubｌic Chess．ＣhessTｙpe turn ｛ｇet ｛ retｕｒｎ m_turn；｝ set ｛ｍ_turn = vaｌuｅ;thｉs．SｅtTｕｒn（(ｍ＿tuｒn.ToStｒing（）== ＂Black＂）？＂黑方"：

”白方”）；｝｝ｐublｉc Playinｇ()｛ＩnｉtｉａlｉzeＣomｐoneｎt（）;ｆｌoat h = tｈis．Size。Hｅight—1０;flｏat w = ｔｈiｓ．Siｚｅ．Wiｄth—１４0;m_bｏard。ReSｉze（0, 0, ｗ，h）;m_ｔimｅr.Intervａｌ＝ 1000；ｍ_ｔimer．Tｉcｋ += ｎew EvｅntＨandｌer（tｉmer_Tｉck)； TimeSｐan tm = new TimeＳｐan（0, 0, 0）;ｌabｅｌTimeBlacｋ。Teｘｔ = tm．ToSｔｒｉng()； labeｌTiｍｅWhite．Texｔ = tm。ToStrinｇ（）； lａｂｅｌＴurn。Texｔ = "黑方"；

} ｐｒivaｔe voiｄＳetTurｎ（sｔriｎｇｔext)｛ if(ｔhiｓ.labelＴurn．IｎvokeRequｉrｅd）{ SeｔＴextCalｌｂack ｄ = new SｅｔTeｘtＣalｌｂack（SeｔＴurｎ);tｈis。Invｏke(ｄ, ｎew oｂject[] ｛ texｔ｝）；｝ｅlse { ｔhis.labelＴurn.Ｔeｘt = text；｝ } //计时功能 priｖａtｅ vｏiｄ timer_Tiｃk(oｂject ｓeｎｄｅr, EveｎtArｇs e)｛ｉf（tuｒn == Cheｓs。CheｓsType。Blａck）｛ m_secoｎdsＢlack++； TiｍｅSpan ｔm = new TiｍeSpan（0，0，m＿sｅcondｓＢlacｋ）； labｅlTｉmｅBlａck。Tｅｘt = ｔm。ToString（）； } else ｉf(turn ＝= Chｅss．ChessTｙpe.White)｛ m_seconｄsWｈite++； TimeSpan tm = neｗ TｉｍeSpan(0, 0，m_secoｎｄsＷhiｔe)；

labｅlTimｅWhitｅ.Text ＝ tｍ.ToStrｉｎg()； } if（pc_play！= null &&！pc_play．ＩsＡlive）{ pｃ_pｌａy．Aｂoｒt（）;pc_ｐlａy．Join（）； pc_pｌａy ＝ null;｝｝ priｖate voiｄ OｎForｍＣlicked（obｊect sender, EｖentArgｓ e）{ //棋局结束 if（m_boaｒd．iｓＧaｍeＯver）｛ this.bｕｔｔｏnCａlculate＿Cliｃk(nulｌ，nuｌl）;m_bｏard。isGaｍeOveｒ＝ｆaｌse；ｒetｕrn;｝ //不是轮到黑子的时候禁止下棋ｉf(！ｍ_bｏarｄ。ｓiｎgｌｅ |｜ turｎ == Ｃhesｓ.ＣhesｓTypｅ。White){ ｒetｕrn；｝ //备份棋局 thiｓ。ｍ_board。BaｃkuｐCｈesｓ（）；ＭouseEｖeｎｔAｒgs arｇs = e as MoｕseＥｖｅntＡrｇs；

if(ａrgs！＝ nulｌ)｛ if（argｓ.Clｉｃks == １＆&args．Ｂutｔｏn == ＭoｕｓeＢuｔtｏｎs。Lefｔ）｛／／计算鼠标点击的坐标位置 Chess。ＰOＳ pos = m_boaｒd.maｐＰoiｎtsＴoBoard(args。X, args。Y)；ｉf(ｐoｓ.isValid）｛ /／游戏中ｉｆ（ｍ＿stａtus == Statｕs.NotStaｒtｅd || m_ｓtａtuｓ =＝Ｓｔatｕｓ。ＩｎGaｍe）{ ｉf（m_boａｒd。addCｈｅｓｓ(pｏs，ｔｕrn））{ tuｒn =（turn == Ｃhess．ChesｓTyｐe。Bｌack）? Cｈｅss.ChｅｓsTｙｐe．White ：

Chesｓ．CｈｅssＴｙpe.Ｂlack;if（m_sｔatus == Statuｓ．NoｔＳtaｒted）{ m_ｔｉmeｒ。Ｓｔart（）;m_ｓtatus = Status.IｎGame；｝ Iｎvａlｉdatｅ（）；｝ } ｉf(m_sｔａtｕs =＝Ｓtatｕｓ.ReｍｏveDead）{

m_boａrｄ。tｏggleDeaｄ（poｓ）；Ｉｎvaｌｉｄａｔe（）； } iｆ(ｍ_ｂoard．siｎgｌe）//人机对弈模式 { pｃ＿plaｙ＝ nｅw Sｙstem.Thｒeadｉnｇ。Ｔhreａd（nｅw System.Threａdｉｎg．ThreaｄStａrｔ（ＣomputerPlａy）);ｐc_pｌay.Ｓtart（）;} ｝ } } } deleｇaｔe ｖoiｄ ButｔoｎDelegａte（Buttoｎ bｔn, ｂool ｆlag）；ｐrｉvate void ＳeｔBｕtｔon（Buｔton btn, bool flag){ if（ｂtn.InvｏkeＲequｉreｄ）｛ ButtonＤｅlegate bｕtｔonDelegaｔe = ｎew ＢuｔｔonDelｅgate（SeｔＢｕttoｎ）； this。Iｎｖoke（bｕttonDｅｌegaｔe, nｅw objｅcｔ［］ { ｂtn，flag ｝);} ｅｌsｅ｛ btn．Enabｌed ＝ flag；

｝ } prｉｖatｅ void ＣomputerＰlａｙ（）{ //计算下一步棋Ｃhess．POS poｓ = ｍ_board.Ｐｌay（2, ｔｕrｎ)； if（m_boarｄ。addCheｓs（pos，turｎ）)｛ tｕｒn =（turｎ == Chesｓ。CｈessTypｅ。Blaｃk)？ Chess.CheｓsＴype．Whｉte : Ｃｈｅss．ChessTｙpe．Ｂｌack；ｉf（m_ｓtaｔus ＝= Ｓｔatｕs。ＮｏtStａrted)｛ m＿timｅr.Stａrt（）;ｍ＿ｓtatｕs = Status。IｎGamｅ;} Invaliｄatｅ()； } else { //计算棋局结果ｍ＿stａtus ＝ Sｔatuｓ．FilｌEmｐｔy;m＿ｂoaｒd．fｉllBoardWithCｈess（）； striｎg strＲesult ＝ m_bｏard。cacｌｕlａteＲesulｔ（）； m＿ｂoard．reｍoｖeFilledCheｓs（）； MｅssageBox.Ｓhｏw(sｔrResｕlt, "结果")； m_board.sinｇｌe = false；

ｔhis。SetButtoｎ（this．bｔnＣalｃ, falsｅ）； thｉs。SetButｔon(tｈｉｓ.btnLeｔＯtherＧo, fａｌse)；ｔhiｓ。SeｔBｕttｏn（thｉs。bｔｎＡgaｉn，ｆalse）;ｔhis．ｍ_ｔｉmeｒ.Ｓｔop（）； Iｎvａｌidaｔe（）;｝ } /／显示棋子序号ｐｒivａte ｖoiｄ cｈeckBoｘShｏwＮumber＿ChｅckedChanged（oｂjecｔ sendｅr，EvｅntArｇs e)｛ m_board.showInｄex = chｅcｋBoxSｈowＮumｂｅr.Ｃheckeｄ； Invａlidatｅ（）； } /／让子功能 priｖatｅ vｏid ｂｕttｏnLetＯtheｒGo_Cｌicｋ（object ｓender，EｖｅntＡｒgs ｅ)｛ if（ｔhｉｓ。ｔurn ＝= Cｈess．CｈessTｙpe．Ｂlack){ ｔurn ＝ Cｈess。oｐpｓiteTyｐe(turn）； iｆ（m_ｂｏarｄ.siｎgｌｅ）｛ pc_ｐｌａｙ = new Sｙsｔem。Ｔhrｅading.Tｈread（new System.Ｔhrｅaｄｉng.ThreadStaｒt（CompｕｔerPlay）);pc＿ｐlaｙ。Ｓtaｒt()；｝｝

} //求和功能 prｉvate void bｕttonCａlcuｌａte_Cliｃk（ｏbｊｅct senｄer，EventArgs e）｛ m_ｓｔatｕｓ = Stａｔｕｓ。ＦillＥmpty； m_bｏard。fillＢoaｒdWｉｔhＣhess（）； string ｓtrResuｌｔ = ｍ＿ｂoard．ｃaclulａteResult（）； m_boaｒd。reｍoｖeFiｌledCｈesｓ（）;MessａgeBox．Shoｗ(ｓtｒRｅｓult，＂结果＂)； m_boaｒd.singｌe = falｓe;this.ｂｔnCaｌｃ.Enabled = ｆalse;tｈis．btnＬetOｔｈerＧo.Ｅnａｂleｄ = faｌse;this。btnAｇａiｎ。Enａbled = false；ｔhｉs.ｍ_tｉmer。Stop（）;Ｉｎvalidａte()；｝／／开始游戏 pｒivate ｖoiｄ bｔnStarｔ＿Ｃlｉｃk（object ｓeｎdｅr，EvｅntArｇs e)｛ DｉalogResulｔ rｅsuｌt = ＭessａgｅＢoｘ．Shｏw（”确定要开始新游戏吗?”, ”新游戏"，MessaｇeBｏxButtoｎs.YｅsＮo）;if（ｒesｕｌｔ =＝ＤialogResult．Yｅs）{ m_boaｒd．newGaｍｅ（）； m_boarｄ。sｉｎgle = trｕｅ;//人机对弈 m_seｃonｄsBlａｃk = 0;

ｍ_sｅcｏｎｄsＷhite = 0;TiｍeSpan tｍ＝ nｅw TiｍeSpan(0，0, ０）； lａbelTiｍeＢlack．Texｔ = tm．ToSｔrｉng（）;labelTimeWhｉte。Tｅｘt ＝ tm．ToStrinｇ()； tｕｒｎ = Chｅsｓ．ＣhessTypｅ．Blａck； m＿tｉｍer．Stop（）； m_boａｒd。marｋAllChessAsLive（）； m_stａtus = Stａtｕs．NotStarted;this.btnCalc。Ｅnabled ＝ｔruｅ;ｔhis。bｔnＬｅtOtｈｅｒGo.Enａｂled ＝ true;this.ｂtnAｇａiｎ.Enａbled = ｔrｕe；Ｉnvalidate（）;｝ } //退出功能ｐrｉｖａｔe voiｄ MaiｎFoｒm_FｏrmClｏsinｇ（oｂjecｔ seｎｄeｒ, ＦｏrmClosｉngEvｅntAｒgｓｅ）{ DiａlogＲeｓuｌt ｒesulｔ＝ MessageBｏx.Ｓｈow("你确认要退出游戏吗？”, "提示”, MessagｅＢoｘＢuttons。ＹesNo)； if（rｅｓｕｌt =＝ DiａlogReｓｕlt.Ｎo）{ ｅ．Cancel = tｒue;｝｝ //主窗口大小ｐrivate voiｄ MａinForｍ_SｉzeChａnged（obｊect sender，EventArgs e）{

ｆlｏat h = ｔｈiｓ．Sizｅ．Heｉght-10； float ｗ = thｉs。Sｉze。Width-１40； m_board。ReSize（0, 0，w, h）； Invａlｉｄａte（）； } //画棋盘 pｒoｔected overriｄｅ vｏiｄ OｎPａｉnt(PaintEveｎtAｒgｓ e)｛ Grapｈｉcs g = e．Grａphｉcｓ;m＿boａrｄ.draw（g);} privatｅ void bｔnClose_Ｃｌｉｃｋ（objeｃt sｅnder，EventArgs e）{ ｔhｉs。Ｃloｓe（）； } ／/悔棋功能ｐrivａte vｏid bｔｎAgain_Clｉck（objｅｃt ｓeｎdｅr, EventＡrgs e）{ iｆ(thｉs．m_boaｒｄ.MoveAgain())｛ Invalｉdate（）;｝｝｝｝ //—--－—－-－—-—-———－－—Boarｄ。cs－－----－－-//

usｉｎｇ Sｙｓtｅｍ;ｕsing Ｓystｅm．Ｃｏllecｔｉons.Ｇeneｒｉc;usiｎg Syｓtem．Texｔ； uｓinｇＳystem.Draｗinｇ；ｕsing Ｓystem．ＩＯ;ｕｓing ＣhessＢlｏｃｋ = Ｓystem.Ｃoｌｌｅｃtionｓ.AｒraｙList;using Systｅｍ。Colleｃtions；ｎamespace go { ／// public cｌass Boaｒｄ｛ /// 〈summａry〉 /// 单人模式 /// ＜/sｕmmary＞ pｕblic bool singlｅ = falｓe； /// /// 距离左方边缘的单位长度 /／/ <／sｕmmａry〉ｐrivａｔe ｓｔａtｉc float mａrgin＿ｌefｔ = 10； //／

//／＜/ｓｕmmary>ｐrivａtｅ sｔaｔiｃ floａt gaｐ = 20;/// ＜summary＞ /／/ 棋子大小 /／/ ＜/ｓummaｒｙ＞ privaｔe sｔatic floａｔ chｅssSize = 8;//／／// 棋盘的所有棋子 /// 〈/sｕmｍary>pｒｉｖate Chess［,] m＿Board = new Chess[１9，19]； /／/ //／棋局记录对象 /// <／sｕmmary〉 privａte ＢoａrdRecordｅr m_ｒeｃoｒdeｒ;///

／// ＜／summary>pｒivaｔe Ｃｈeｓｓ m＿LastＣhess；／/／ /// 最后一颗被吃的棋子 /// ＜/summａrｙ〉 privaｔe Ｃhess m＿LａstEattｅn;/// /// 最后被吃棋子备份 //／ /// 当前步数 /// ＜/suｍｍary〉 pｒivaｔe inｔｍ＿currｅntＳｔep;／/／ｐrｉvaｔｅ Chｅsｓ[，] m_Sim＿Ｂoard ＝ neｗ Cheｓs［19，19]； //／〈sumｍａrｙ>/// 模拟最后一颗棋子

/// 〈/summary〉 private Cｈesｓ m＿Ｓim_LａstChｅss； /// 〈summａry〉 //／模拟最后一颗被吃的棋子 /// 〈／sｕmmａry＞ｐｒivaｔe Cheｓｓ m_Sim_LastEatten;//／＜sumｍaｒｙ〉／// 模拟当前步数 //／ /// 棋局结束 /// 〈／summary＞ｐｕbliｃｂool iｓGaｍeOver = ｆalse;/// <ｓumｍａｒｙ>／// 创建棋盘 /// ＜／ｓummarｙ>puｂlic Boarｄ()｛Ｃleaｒ（）；｝ /／／ <ｓumｍａry＞ /// 获取最后一颗棋子

／／／＜／suｍｍａｒy〉 public CｈesｓｌasｔChｅss { gｅt { rｅturn m＿ＬaｓtChess;} } /// ＜sumｍaｒy>/／／获取或设置是否显示棋子的编号／// ＜/sｕmmary＞ public ｂool sｈoｗＩndex { gｅｔ { rｅturｎ m_bＳhoｗIndｅx； } seｔ { ｍ_bShowIndｅｘ = value;｝｝ /// 〈sｕmｍaｒy〉 //／调整棋子在棋盘中的位置，并返回棋子的位置／// 〈／sumｍarｙ>／／/ 〈param naｍｅ=”ｐｏinｔＸ＂〉＜／param>／// 〈param ｎaｍｅ＝＂pｏｉntY"〉<／pａｒam＞ /／/ <／retｕrns>pubｌic Chｅss。POS maｐＰointsToBoａrｄ(fｌoaｔｐoinｔＸ，float ｐoｉntY）｛ｉｎt poｓX = Coｎveｒｔ。ToＩnt32（(pointX-margin_left + gａｐ / 2)/ gａｐ—0．５f）； inｔ posＹ＝ Cｏnｖert.ToＩnt３2（（poinｔＹ—margiｎ_top + gaｐ / ２)／ gaｐ—0．5ｆ）； Cｈess．POS pos ＝ new Cheｓs.POＳ（posX，posＹ）； if（!pｏｓ。isValｉd）pｏs。ｓetＴoIｎｖalid()； return pos;｝

/／/

/// 绘制整个棋局 /// <／summary＞ /// publｉc ｖoｉd draｗ（Grａphics g)｛ dｒawBoｒder（g);drawＣｈess（g);} /／/ ＜summary＞ /// 绘制星位 /// <／summａry〉／/／ <ｐaram nａmｅ=”ｇ"＞<／param>/// 〈ｐａｒam name="posX"〉〈/ｐarａm＞ /／/ ＜param name="posY＂＞〈/paraｍ＞ prｉｖate ｖｏid drawＳtar（Graphｉcｓ g，float pｏsＸ, ｆlｏat posY）｛ Recｔａnｇlｅｒect = new Ｒecｔangle();rect。X = Conｖｅrt.ToＩnt32(margiｎ_lｅft + ｐosX ＊ gap-starSize）;ｒecｔ．Ｙ = Ｃonveｒt.ToInt32（margin＿top ＋ｐoｓY ＊ gap － starＳizｅ）； reｃt。Widtｈ = Coｎvｅrｔ.ToInt3２(stａｒSize ＊ 2）； reｃｔ。Height ＝ Coｎvert.ToInt32(staｒSｉze ＊ 2）； g.FｉlｌElｌiｐsｅ（Brushes。Black, ｒｅｃt）； } /／/ ＜summary〉

／// 绘制棋盘 //／ /// 〈paraｍ name＝＂g＂＞＜/pａｒａm>prｉvａｔe vｏiｄ drａwBｏrdeｒ（Gｒaphiｃs g）｛ //绘制棋盘颜色 Peｎ baｃkgroｕndＰｅn ＝ new Pen（Ｃoｌoｒ。Ｇoldｅnｒoｄ，10)； g。FiｌlRectangle(baｃkgroｕｎｄPen。Ｂrush, maｒgiｎ_left-gaｐ/2，ｍａrgiｎ_top—gap/2，gaｐ * 19，gap ＊１９）； //绘制棋盘线Ｐｅｎ borｄerPｅn = nｅw Pｅn(Cｏlor.Ｂｌack, 1）；ｆor(int i = 0； i 〈 19；ｉ＋+）｛ｇ。DrawLinｅ（bｏrderPen, margin_ｌeft，mａrgin_top + i ＊ gap，margiｎ_left ＋ 18 ＊ gap，margiｎ＿top ＋ i * ｇap);g.DｒawLine(boｒderＰen, maｒgin_leｆt + i * ｇaｐ，margｉｎ_top, marｇiｎ_lｅｆt ＋ i ＊ gａp，ｍaｒgin＿top + 18 * gａp);｝／/ 绘制９个星位 dｒawＳtar（ｇ, 3，3）；ｄrawStar(g，３，9)；ｄrawStar(ｇ, ３, 15)；ｄrawＳtaｒ（g, ９, 3)；ｄrawＳtar（ｇ, ９，９）；ｄｒａｗStar（g, 9，1５）； drａwSｔar（g，１5，3）； draｗStar（ｇ，１5, 9）；

ｄrawStar（ｇ, 15，１５);｝／/／ <ｓuｍmary>/／/ 绘制棋子 /／／〈／summary〉 /// pｒiｖａte voｉｄ draｗChess（Grａpｈicｓ g）｛Ｒectanglｅ rect ＝ nｅw Rectaｎgle（）； StｒingＦoｒmaｔｆormat = nｅw SｔｒingFormat（）；ｆorｍａt。Ａｌiｇnmｅｎt ＝ SｔriｎgＡｌignｍent。Cenｔer； fｏrmat.LineAliｇnｍenｔ = StriｎgAlｉｇnment.Centｅｒ;Fｏｎt fontNumber = ｎew Ｆonｔ("Ariａl Nａrroｗ＂，nｕmbeｒSｉｚe);fｏｒ（iｎt i = 0； i 〈 19； i++)｛ for（int ｊ＝ 0;j <19； j++)｛ｓwitcｈ(ｍ＿Boaｒd［i，ｊ]．tｙpe）｛ caｓe Cｈess．ＣhesｓＴｙｐe．Bｌack：

rect．Ｘ＝ Convert．TｏInｔ３2(maｒgin_left + i * gap—cｈessSize）;ｒect.Y = Ｃonｖｅrt．ToＩnt32(ｍａrgin_toｐ + j * gap-ｃｈessSiｚｅ);rect.Ｗiｄth = Ｃonveｒt。TｏIｎt32（chessSｉze ＊ 2)； rｅct.Heｉｇht ＝Ｃonveｒt.TｏInt32（che

ｓｓＳize * 2)； g.FilｌＥllｉpse(Brusｈes。Blaｃk，rｅｃｔ）；ｉf（m_bSｈｏwＩndｅx &＆ m_Boaｒd ［i，j].sｔep >0）｛ g．DｒawＳtｒing（m＿Ｂoａrｄ［i，j］．step．ＴoSｔｒiｎg(), fontＮuｍｂer, Brushes.Wｈｉtｅ, ｒｅct，foｒmａｔ);} break； cａse Chess。ChｅｓsType.DｅａdBlacｋ：

rｅｃt。X = Ｃonvert．ＴoInt３2（ｍａrｇiｎ＿ｌeft + ｉ＊ gap—ｃhｅｓsＳize);ｒect.Ｙ＝Ｃｏnvｅrt．ToInt3２（mａｒgｉn_ｔｏp + j ＊ｇap—cｈｅsｓＳize）； reｃt。Wiｄｔh = Convｅrｔ.ToInt32(cｈesｓSｉzｅ＊２）;reｃｔ.Ｈeighｔ = Cｏnｖert.ＴｏIｎt32（chesｓSize ＊ 2);inｔ ceｎterＸ = Ｃonverｔ．ToInt３2（margｉn_lｅft + i ＊ｇap)； iｎt ceｎterＹ = Coｎｖert.ToIｎt3２（mａrｇiｎ＿top + j ＊ｇap）； g．FilｌＥllipse(Ｂｒuｓheｓ。Bｌaｃk，ｒect）;ｇ。DrawＬｉｎe（neｗＰen(Colｏr。Red, 3)，ceｎtｅrX—chｅｓsSizｅ / 2，ｃentｅrY-chessSize / 2, ｃｅnｔerX + ｃｈeｓsＳize / ２, ceｎterY + chesｓSｉｚe / 2)； iｆ(m_ｂShowIndｅx ＆＆ｍ_Board［i, ｊ］。sｔep 〉 0）｛ｇ．DrawStｒｉnｇ（m_Ｂoaｒd[i, ｊ]．sｔｅｐ。ToStrｉng（）, ｆonｔＮumbeｒ, Ｂruｓhes。Ｗhｉte，rect，ｆｏｒmat)；｝ breａk；

cａse Ｃhess．CｈｅssType。Ｗｈite: rect。X = Cｏnveｒt.ToＩnt3２(mａrgiｎ_leｆt + i * gap-chessSizｅ）;recｔ.Y = Convert。ToＩnt3２(marｇｉn_ｔoｐ + j * gａp-cｈesｓSize）；ｒｅct。Wｉｄth ＝Ｃonvert．ＴｏInt32（ｃhｅｓｓSize * 2）;reｃt.Hｅight ＝ Cｏｎｖert。ToInｔ32(chｅssＳｉze * 2）； g.FｉllEｌｌipsｅ（Bruｓhｅs．White，rect）； if（ｍ＿bＳhowIndex ＆&m＿Boａrd［i, j］。ｓtep ＞ 0）{ g.ＤrawＳtring（ｍ_Board［i, ｊ]．ｓtep.ToSｔriｎg（），ｆonｔＮｕmber，Brusｈes。Ｂlacｋ，rect，fｏrmat）；｝ bｒeak;cａse Chｅss．CheｓｓTｙpe.DｅadWhite：

rect．Ｘ = Convert。TｏInt３2（mａrgiｎ＿ｌeｆt + ｉ * ｇap-cheｓsSizｅ)；ｒect.Y = Coｎｖeｒt.ToInｔ3２（mａrgin＿tｏp ＋ｊ * ｇａp － chｅssSｉze)； reｃｔ。Ｗiｄｔh = Conveｒｔ.ToInt32（cｈesｓSize * 2);rect。Heigｈt = Coｎｖert.TｏInt３２(cheｓsSｉze ＊２）； centeｒX ＝ Conｖerｔ．ToInt32(margin_lefｔ + i * ｇａp）； centerY ＝ Convert．ToIｎt32（margin＿ｔｏｐ + ｊ＊ gａp）； g．FillEllipse（Brushes．Ｗｈite, rect）;g.DrawLiｎｅ（neｗ Peｎ（Cｏlｏr。Rｅd, 3)，cenｔerX －ｃhessSｉze / 2, cｅnterY—ｃｈessＳｉze / ２, centerX + ｃhｅssSｉze / 2, centerY ＋ chessＳize / 2）；

if（ｍ_ｂＳhｏｗIndｅｘ＆＆ m_Boarｄ［i，ｊ］。stｅp 〉 0）｛ g。DｒawＳｔring(m＿Ｂｏard[ｉ，ｊ].steｐ。ＴoStｒｉng(), ｆoｎtNumｂｅｒ，Brushｅｓ。Bｌacｋ，rect，foｒmat);} break； caｓe Ｃhess。ＣhesｓTypｅ.ＭaybeBlack: rect。X = Ｃonvｅrt．TｏＩnt32（marｇin_lefｔ＋ i ＊ｇaｐ－ｃhesｓSizｅ / 2）;rect.Y ＝ Cｏnｖeｒt。ＴoInt3２（maｒgｉn_ｔｏｐ + j * ｇap—cheｓsSize ／ 2）;rｅｃt.Width = Convert。TｏIｎt3２（chｅssSizｅ）;recｔ。Ｈeiｇｈt = Convｅrt.ToＩnt32（chessSize）;g。FillＲectanglｅ(Brushes.Bｌａck，rｅct）； break； casｅ Chess．ChessType。MayｂeＷｈiｔe: rect。X = Convert．ＴoInt32（mａrｇiｎ_ｌeft ＋ i ＊ gap—chｅsｓSiｚe ／２）;ｒect.Y = Ｃonｖert。ＴｏIｎｔ32（mａrgｉn_tｏp + j ＊ gap － chｅssSize ／ 2）；ｒect.Widtｈ＝Ｃoｎverｔ。TｏInt32（ｃhessSizｅ)； reｃt．Ｈｅight = Conveｒｔ．ToInt３2（ｃhｅsｓSize);g.FilｌRｅctａnｇle(Bｒuｓhｅｓ。Ｗｈite，ｒecｔ）;ｂreａk;casｅＣhｅss。ＣhｅｓsType。MaybePenｄiｎg：

ｒect.X = Cｏnvert.ＴoInt３2（marｇiｎ_ｌefｔ＋ i ＊ gaｐ—chesｓＳizｅ／ 2）；

ｒect.Y = Conveｒt．ToInｔ32（ｍargin_top + j * ｇａp － cheｓｓSize ／ 2）；ｒｅcｔ.Widｔh = Cｏnvert．ＴｏＩnt32（cｈessSize);rｅct。Hｅｉght ＝Ｃonveｒｔ。ToInt3２(chesｓSizｅ）;g．FｉｌlRｅctａnｇle(Brushes。Ｙｅｌｌｏｗ，recｔ）； break； } ｝｝｝ /// ＜sumｍaｒy〉 /／/ 增加一颗棋子在棋盘上 /／/ /／/ ＜returｎs＞〈/retuｒns＞ publｉｃ booｌ addＣｈess（Ｃｈesｓ．POS pos，Cｈesｓ．ChessType ｔype){ if（ｔhiｓ.m_currentStep ＞ 361)｛ｔｈis。isＧａｍeOvｅr = trｕｅ； reｔurｎ falsｅ;｝／／只允许放黑棋或白棋 if(typｅ！= Cｈｅss.ChessＴｙpｅ．Bｌaｃk &＆ type！＝ Cｈｅｓｓ.ChessType.Ｗｈite）

return ｆａlｓｅ； // 只允许在空位置上放棋子。

if(m＿Bｏａrｄ[pos．pｏsX，ｐos.ｐosY］.tｙpｅ！＝ Chess.ChesｓType.Empty）return faｌse；／／设置当前位置的棋子的类型 m_Bｏard［ｐos.posX, poｓ。pｏsY］．tｙpe = tｙpe； #rｅｇion 判断是否可以提子 bｏol bEaｔ = false； bｏol bValidＳｔｅp = ｔrue;//当棋子的左方有空位，并且该位置棋子的棋子是对方的棋子时，执行以下代码 iｆ(pos．hasLｅft ＆＆ｍ_Boaｒｄ［ｐos．poｓX—1，pos。posY］．type =＝ Chess.ｏppsiteＴｙｐe（tｙpe)）｛ // ｂEaｔ = tｒyToEat（ｐos, nｅw Chｅss。PＯS（poｓ.posX-1, ｐos．ｐosY), rｅf bＶaｌidStep)|｜ bEａt;ｉf（！ｂＶalｉdＳteｐ）retｕrｎｆａｌse； } ／／当棋子的右方有空位,并且该位置棋子的棋子是对方的棋子时,执行以下代码 if（pｏs.ｈasRiｇhｔ＆&ｍ_Board［ｐos。ｐosＸ + １，pos.posY]．type ＝= Chｅss。oｐpｓｉｔｅType(type))｛ bEaｔ = ｔryToEaｔ(pos, neｗＣhｅｓｓ。POS（ｐoｓ.pｏｓX + 1, pos．pｏsY）, reｆ bValidStｅp)｜｜ bEaｔ；ｉf(！bValidStep）return fａlｓe； }

//当棋子的上方有空位，并且该位置棋子的棋子是对方的棋子时，执行以下代码 if（pｏs．hａsUp &＆ｍ_Boａrd［pos。ｐosＸ，ｐoｓ。posＹ－１］.tｙpe == Ｃhess.oppsiteTyｐe(ｔｙpe））｛ bEａｔ = ｔrｙTｏＥａt（pｏs，neｗ Cｈesｓ。POS(pos.ｐosX, ｐos．posＹ-1)，ｒef ｂValidSｔep）|｜ bEat； if（！ｂValidSｔep)rｅtｕrn faｌsｅ；｝ /／当棋子的下方有空位,并且该位置棋子的棋子是对方的棋子时，执行以下代码ｉf（pos.hａsＤowｎ &&m_Boａrｄ［pｏs。pｏsX，pos.pｏsＹ＋ 1].ｔｙpｅ =＝ Chesｓ。oｐpsitｅTyｐe(type)）{ bＥａｔ = ｔｒyToEａt(pos, new Cｈess.ＰOＳ(ｐoｓ.posX, poｓ。posY + 1）, ｒeｆ bVaｌidStep）|| bEaｔ； if（！bVａliｄStep)ｒeturn ｆａlse;｝＃eｎdｒeｇion if(！bEaｔ）m＿LastＥaｔten.ｐoｓ。ｓetＴoInvaｌid（）； // 判断相连的棋子是否还有气。

ＡrrayLiｓt chessBlock;iｆ(！iｓＬiｖｅ(pｏs, ｏut chesｓBlock))｛ returｎ false;} m_LastＣhess。ｐos = pos;m_LastＣhesｓ.ｔyｐｅ = type；

m_ＬasｔChesｓ。step ＝ m_cｕrreｎtStep；ｍ_rｅcordｅr。addStｅp(ｎｅw Chess（pｏs，type, m_ｃｕrｒenｔSteｐ）);m_Ｂoarｄ［pos.ｐosX，poｓ。pｏsY］．ｓtep ＝ m_currentSｔeｐ;m_Boａｒd［pos。posX, poｓ．pｏsＹ]．ｐｏs ＝ｐｏs； m＿curｒentＳtep++； retｕrn ｔruｅ；｝ /// ＜summａrｙ>／// 加载文件中的棋局 /// 〈／summary>/／/ ＜param name=”ｓｔｒFilｅ”＞public ｂool loadＢｏａrdFｒom sｔｒFiｌe)｛ iｆ（!Uｔils.is（sｔrFiｌe））returｎ falｓe； Chｅｓs。CheｓsＴype［,] newBｏard = new Chｅｓs.ChessType［１９, 19］;StreamReader freader = new SｔreａmReader（sｔｒFiｌe）；ｆｏr(int i = 0;i 〈 19； i++)｛ string ｓtrLｉnｅ = ｆrｅａder。ReadＬinｅ();iｆ(strＬine。Lｅngtｈ！= 1９）ｒeturｎｆaｌsｅ； for（int ｊ = 0;j ＜１9； j+＋)｛ Cheｓs.ＣhesｓType type = Cｈesｓ。ChessＴype.Emptｙ;

swｉtch（strLｉne［ｊ]）｛ case "0＇: tyｐe = Ｃheｓｓ.ＣhessTｙpｅ.Empty;bｒeａｋ;case ＇1’：

type ＝ Chess.ChessTｙpe。Blacｋ； breａk； case "2": ｔype = Cｈess。ChｅssType。Whiｔe； break； default：

retｕｒn fａlse;} newBｏａｒd[ｊ，i］ = ｔype； } } fｏr（int ｉ = 0;i ＜ 19； i＋+）{ for(ｉnｔ j = 0;ｊ＜ 19；ｊ++){ m_Bｏard[i，j］.ｔypｅ = nｅwBoarｄ[ｉ，j];｝｝ rｅｔurn ｔｒue;｝／／/ <ｓｕmｍary〉 /／／保存棋局到文件中

/// <／sｕmmary＞ /// 〈param ｎamｅ＝”ｓｔrＦiｌｅ”〉〈/param〉 /／/ ＜/returns〉 public bｏol ｓaｖeBoaｒｄTo strＦｉlｅ){ fi ＝ｎew（sｔrFile）;if(ｆｉ．Exisｔs)fi．Deｌeｔe()； SｔreaｍＷriter sw = fi。CreateTexｔ（）;for（int ｉ＝ 0;i 〈 19;ｉ＋+）｛ StringBuilｄer sｔｒLinｅ＝ｎew StｒｉngBuiｌｄer(20）；ｆor(int ｊ = 0； j <１9;j++）｛ cｈａr cｈ;ch ＝（ｍ_Bｏａｒd［ｊ，i］.tｙpe == Chess.CｈeｓsＴyｐe．Empty)? "0" :（m_Boａｒｄ［ｊ，i].tｙpｅ =＝ Chess．ChｅssTｙpe.Ｂlack）？＇1" ：

’2＇；ｓtrLiｎe.Appenｄ(cｈ）；｝ sw．WｒiteLine（sｔrLine)；｝ sw。Cｌｏse（）； return trｕｅ;} /// 〈suｍmary〉 /// ／// /// 〈param naｍe="sｔrFile”〉<／pａｒａm>

／／／＜reｔｕrns〉＜/retuｒns〉ｐubｌiｃ boｏｌ lｏadStｅp strFile）｛ m_reｃordeｒ．ｌoaｄFroｍ);iｎt totａlSteps = m_recｏｒdｅr．totalＳtｅps;if（totalＳtｅps 〉０）｛ clearＢｏard（）;ｆor(inｔ i = 0； i ＜/ｐaram＞ /// 〈returns＞〈／reｔurns＞ｐubｌic ｂooｌ saveStepsTo strFile）｛ retｕrn ｍ_reｃorｄer．saveTo）;｝

／// ／// 重新开局 /// ＜/ｓummary>pｕｂlic ｖoid newGaｍe(){ cｌeａｒ（）；｝／// ／／／填充棋子用以计算得分 /// public void fillBoarｄWithCｈeｓs（）｛ for(int i = 0;i ＜ 19;i++){ ｆor（ｉnt j = 0;j <１9;j++）{ if（m_Boaｒd［ｉ, ｊ]。tｙpe ＝= Cｈess．CｈessＴyｐｅ.Ｅmｐty）｛ＣheｓsBlｏｃk blocｋ； findBloｃk（nｅｗ Chess。ＰＯＳ(i，j), out ｂlock）； if（bloｃｋ。Cｏunt 〉 0）｛ Cｈess.CｈessＴｙｐe tｙｐe = Cheｓs．ＣｈeｓsTyｐe。Emptｙ； foreach(Chｅss。POS pos in blｏｃｋ）

｛ if(poｓ。hasLefｔ)｛ Cheｓs.ChessType nｅwＴype ＝ｍ_Ｂoard［pos.poｓX-1，pos.posＹ]。type； if（tｙpe == Cｈeｓｓ。ChesｓＴype。Eｍpty &&（neｗＴｙpe ＝= Cｈess.ＣｈｅsｓTyｐe.Blａck || nｅwTyｐe =＝ Cｈess.CheｓｓTｙpe。Whiｔe)）{ ｔyｐe ＝ newＴype；｝ eｌse { if(type!＝ Chｅss。ＣhesｓＴype.Eｍpｔｙ＆＆ typｅ == Ｃhess。ｏpｐsiteTｙpe（neｗTｙpe））｛ tｙpe = Cheｓs。ＣｈessTｙpｅ.ＭaybｅＰendinｇ； bｒeａk;｝｝｝ if(ｐoｓ。hａsRｉｇht）｛ Chｅsｓ.CheｓｓType nｅwＴyｐe = ｍ_Board［pos.ｐｏsX + 1，pos.pｏｓY］．tyｐｅ;iｆ(type =＝ Chess。CｈessＴｙ

pe.Empty &＆（ｎeｗType =＝ Cｈess。ＣｈｅssType.Ｂｌack |｜ newType == Cｈess.ChesｓＴype。White))｛ tyｐe = neｗType；｝ｅlsｅ｛ if（ｔｙpe！= Ｃheｓs。CｈessＴyｐe．Emｐty &&tyｐe == Chess.oppsiteType(newＴype））{ typｅ = Chess.ＣhessTｙpe．MaybｅPendｉng； break;} ｝ } ｉf（ｐｏs。haｓUp）｛ Chｅｓs。CheｓｓType nｅwTyｐe ＝ｍ＿Board［pｏs。posX，poｓ。posY-1］.type;iｆ（ｔypｅ＝＝ Chess。ChｅssTypｅ。Ｅmpty &＆(nｅｗType ＝＝ Chess.ChessType.Blaｃk |｜ nｅwType ＝= Cｈeｓs.ChesｓType。Whitｅ））｛ type ＝ nｅwTyｐe；｝ elsｅ { ｉf（tｙpe！＝ Chｅss。

ChesｓTyｐｅ。Empty ＆＆ｔｙpe == Chｅss.oppｓitｅＴype（nｅｗType））｛ｔyｐe = Chｅss．CｈessType。MａｙｂePenｄｉｎｇ；ｂｒeak；｝ } } if（pｏs.ｈａsDown){ Cｈeｓs。ＣｈessTyｐe nｅｗType = m＿Boａrd[pos。pｏsX，poｓ。ｐosY ＋ 1］。typｅ;iｆ（tyｐe =＝Ｃheｓs。ＣhｅssType。Eｍpｔy &＆（ｎewTｙpｅ == Chesｓ．CｈeｓsType.Bｌａck |｜ newＴypｅ == Ｃhｅsｓ．ＣｈessＴypｅ。Whｉｔe）)｛ｔｙpe = newType;} else ｛ｉf(tyｐe！= Ｃｈess．ＣｈessTyｐe。Ｅｍptｙ &＆ type ＝= Chess.oｐpsiteＴype（newTｙpｅ））｛ type = Cheｓs.CｈessTyｐe。ＭaybePｅndinｇ；ｂrｅak； } ｝

｝｝ｉf（tｙpe == Cｈesｓ．ＣhessＴｙpe。Ｂlack)type ＝Ｃheｓs。ＣhessType．MａybｅBlaｃk； else if（tyｐe ＝= Chess。CｈessTypｅ．Ｗｈiｔｅ）tｙpe = Chesｓ．ChessTyｐｅ.MａybeWｈｉte； elｓe tｙpe = Cｈeｓs．ChesｓTｙｐe．MaｙbePｅndiｎg；ｆorｅach（Ｃｈess.POS posToFill in ｂloｃk）｛ｍ_Boarｄ［pｏsToFiｌl.posX，posToＦｉll。posY］。type = tyｐe； } ｝｝ } ｝ } /// pｕblic vｏid fillBoaｒｄWithChessOｎＳim（）{ fｏr(iｎt i = ０； i ＜ 19； i++)｛ for（ｉｎt j = 0； j <１９;j＋＋）

｛ｉf（this。m_Sim＿Board[i，j].type == Ｃhｅss．ChessＴype。Emｐty）｛ ChesｓBloｃｋｂlocｋ;findBlockOｎSim（neｗＣheｓs.POS（ｉ，j）, ｏut bｌｏck)； if(block．Ｃｏｕnt >０）{ Chｅss．CheｓsＴｙpe tyｐe = Cheｓｓ.ChesｓTyｐe.Ｅｍpty； foreaｃh(Ｃhess。ＰOS pos ｉn blocｋ)｛ｉf(pos。hasLeft)｛ Cｈess。CｈesｓTyｐｅ newTｙpe = thｉs．m_Sim_Boaｒd［pos．posX-１，pos。poｓY].typｅ； if（ｔype == Cheｓs。CｈｅssType．Eｍｐtｙ &＆(nｅwTｙpe =＝ Cｈess．ChessＴypｅ．Blａck ｜｜ neｗType == Cheｓｓ.CｈessTypｅ。Wｈite)）{ type = nｅwTｙｐe;} elsｅ { iｆ（type!= Chess。CheｓsTypｅ。Ｅmpty ＆＆

tｙpe =＝ Chｅsｓ。opｐsiteTypｅ（nｅｗTｙｐe））｛ tyｐe ＝ Cheｓs．CheｓsTypｅ.ＭaybePendinｇ； bｒeak； } ｝｝ if（pos．hasＲight）｛ Chesｓ.ChessＴypｅｎｅwTyｐe = this.m_Sｉm＿Ｂoard［pｏs.ｐｏsX ＋ 1，pos.ｐｏｓY].tyｐe； iｆ(ｔypｅ＝= Chess．ChessTypｅ.Eｍpty ＆＆（ｎewType ＝= Ｃheｓｓ．ＣhessＴypｅ.Blａｃk ｜｜ newＴype == Chess.ChessType.Whitｅ）)｛ tｙpe = nｅwＴype;｝ else ｛ｉｆ(tyｐe!= Cｈess.ＣhｅssＴype。Ｅmpty ＆＆ type == Cｈｅｓs。oppsiteTypｅ(newTypｅ）)...