A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 邵震 于 2013-5-9 20:52 编辑

今天用自习时间更新了一下 添加了悔棋的功能  

优化了一下代码

还把代码分装成多个类了  正好把我对象调用这里好好的学习了一下


第一个小游戏


不是图形界面的 因为不会
不是用集合做的 因为不会
电脑可以用但是是无脑的随机数 因为不会

但是我用二维数组加上循环判断语句做出了一个简单的五子棋小游戏  

可以两个好基友一起玩 能判断输赢

真心的感到很开心 哈哈  

源码附上 一是炫耀  一是求错   

这个真心的是源码 都没经过优化 我这几天会对代码进行优化和封装  

如果大家有什么好的意见或者建议可以回帖给我  谢谢了  有BUG就更好了  

玩法就是输入两个数 从1到15之间的  
可以用15  15回车的方式 输入
或者 15回车 15回车的方式输入
假如有五颗同颜色的棋子连在一起就会停止游戏并提示谁获胜了

不知道为什么  我发的代码没有层次感 源文件附上了
  1. /**
  2. * 五子棋小游戏
  3. * 作者:邵震
  4. * 完成日期:2013年5月8日19点50分,于北京传智播客101自习室。
  5. * 从4月29号开始断断续续打了4,5天。
  6. * 感谢李斌的不厌其烦的帮助。
  7. * 1.0版本:只能实现两人在同一台电脑上下棋。
  8. * 1.1版本:优化了代码,把白棋换成更易于观察的黑方块,增加了悔棋功能。
  9. */
  10. package TestDay26;
  11. import java.util.Scanner;
  12. public class DomePanDuan
  13. {
  14.         public static void main(String[] args)
  15.         {
  16.                 String [][] qiPan = new String [23][23];
  17.                 int [] Arr =new int[6];//这个数组的0和1索引用于记录玩家键盘录入的信息,2和3索引用于记录电脑随机的坐标
  18.                 DaYin d = new DaYin();
  19.                 XiaQi xq = new XiaQi();
  20.                 d.qiPan = qiPan;
  21.                 xq.qiPan= qiPan;
  22.                 xq.Arr  = Arr;
  23.                 d.QiPan();
  24.                 d.DaYinQiPan();
  25.                 xq.RenXiaQi(d);
  26.         }
  27. }
  28. class DaYin
  29. {
  30.         String[][] qiPan;
  31.         public void QiPan()
  32.         {      
  33.                 for(int x=0;x<qiPan.length;x++)
  34.                 {
  35.                         for(int y=0;y<qiPan[x].length;y++)
  36.                                         qiPan[x][y]="╋";
  37.                 }
  38.         }
  39.         public void DaYinQiPan()//用于打印棋盘
  40.         {
  41.                 //用于打印边框
  42.                 String[] Arr1 = {"⑴","⑵","⑶","⑷","⑸","⑹","⑺","⑻","⑼","⑽","⑾","⑿","⒀","⒁","⒂"};
  43.                 System.out.print("邵");
  44.                 for(int x=0;x<Arr1.length;x++)
  45.                 {
  46.                         if(x<Arr1.length-1)
  47.                         {
  48.                                 System.out.print(Arr1[x]+"··");
  49.                         }
  50.                         else
  51.                                 System.out.print(Arr1[x]);       
  52.                 }
  53.                 System.out.println("震");
  54.                 for(int w=4;w<qiPan.length-4;w++)
  55.                 {
  56.                         System.out.print(Arr1[w-4]);
  57.                         for(int n=4;n<qiPan[w].length-4;n++)
  58.                         {
  59.                                 if(n<qiPan.length-5)
  60.                                 {
  61.                                         System.out.print(qiPan[w][n]+"··");
  62.                                 }
  63.                                 else
  64.                                         System.out.print(qiPan[w][n]);
  65.                         }
  66.                         System.out.println(Arr1[w-4]);
  67.                 }
  68.                 System.out.print("出");
  69.                 for(int x=0;x<Arr1.length;x++)
  70.                 {
  71.                         if(x<Arr1.length-1)
  72.                         {
  73.                                 System.out.print(Arr1[x]+"··");
  74.                         }
  75.                         else
  76.                                 System.out.print(Arr1[x]);
  77.                 }
  78.                 System.out.println("品");
  79.         }
  80. }
  81. class XiaQi
  82. {
  83.         String[][] qiPan;
  84.         int[] Arr;
  85.         public void RenXiaQi(DaYin d)//用于人下棋。
  86.         {
  87.                 /*
  88.                  * 悔棋步骤:
  89.                  *                 首先定义两个变量用于保存上局落子的坐标
  90.                  *                 每次输入特定的数字的时候就调用上次的坐标对棋子进行覆盖。
  91.                  */
  92.                 Scanner site =new Scanner(System.in);
  93.                 boolean huanRen = true;//交换玩家出牌
  94.                 boolean xunHuan=true;
  95.                 while(xunHuan)//无限循环,直到游戏结束,或者手动结束。
  96.                 {
  97.                         try
  98.                         {
  99.                                 if(huanRen==true)//判断出牌的玩家
  100.                                         System.out.println("请第一个玩家输入横轴坐标,1到15之间的整数,然后回车。");
  101.                                 else if(huanRen==false)
  102.                                         System.out.println("请第二个玩家输入横轴坐标,1到15之间的整数,然后回车。");
  103.                                 System.out.println("悔棋请输入11521,能返回上次有效输入,每次有效落子后才能悔棋一次。");
  104.                                 Arr[4]=site.nextInt()+3;//因为数组是23*23的,但是四周有4个空位的隐藏格子,所以加三。
  105.                                 if(Arr[4]==11524)
  106.                                 {
  107.                                         qiPan[Arr[2]][Arr[3]]="╋";
  108.                                         d.DaYinQiPan();
  109.                                         if(huanRen == false)
  110.                                         {
  111.                                                 huanRen = true;
  112.                                         }
  113.                                         else
  114.                                         {
  115.                                                 huanRen = false;
  116.                                         }
  117.                                 }
  118.                                 else if(Arr[4]<19 && Arr[4]!=3)//判断坐标时候合法,不合法就报错。
  119.                                 {
  120.                                         Arr[0]=Arr[4];
  121.                                        
  122.                                         if(huanRen==true)//判断出牌的玩家
  123.                                                 System.out.println("请第一个玩家输入横轴坐标,1到15之间的整数,然后回车。");
  124.                                         else if(huanRen==false)
  125.                                                 System.out.println("请第二个玩家输入横轴坐标,1到15之间的整数,然后回车。");
  126.                                         Arr[5]=site.nextInt()+3;
  127.                                         if(Arr[5]==11524)
  128.                                         {
  129.                                                 qiPan[Arr[2]][Arr[3]]="╋";
  130.                                                 d.DaYinQiPan();
  131.                                                 if(huanRen == false)
  132.                                                 {
  133.                                                         huanRen = true;
  134.                                                 }
  135.                                                 else
  136.                                                 {
  137.                                                         huanRen = false;
  138.                                                 }
  139.                                         }
  140.                                         else if(Arr[5]<19 && Arr[5]!=3)
  141.                                         {
  142.                                                 Arr[1]=Arr[5];
  143.                                                 //↓判断合法的坐标上有没有棋子,有则从新录入。
  144.                                                 if(qiPan[Arr[0]][Arr[1]]!="★" && qiPan[Arr[0]][Arr[1]]!="█")
  145.                                                 {
  146.                                                         if(huanRen==true)//判断出牌的玩家
  147.                                                         {
  148.                                                                 qiPan[Arr[0]][Arr[1]]="★";
  149.                                                                 d.DaYinQiPan();//调用打印棋盘的函数打印最新的棋盘。
  150.                                                                 //判断输赢,如果赢了则返回true结束整个程序,如果没赢则返回false继续游戏。
  151.                                                                 boolean jieGuo = WinRen();
  152.                                                                 if(jieGuo == true)
  153.                                                                 {
  154.                                                                         xunHuan = false;
  155.                                                                 }
  156.                                                                 huanRen = false;
  157.                                                         }
  158.                                                         else if(huanRen == false)
  159.                                                         {
  160.                                                                 qiPan[Arr[0]][Arr[1]]="█";
  161.                                                                 d.DaYinQiPan();//☆,█
  162.                                                                 //这里判断的是白旗玩家的输赢。
  163.                                                                 boolean jieGuo = WinRen();
  164.                                                                 if(jieGuo == true)
  165.                                                                 {
  166.                                                                         xunHuan = false;
  167.                                                                 }
  168.                                                                 huanRen = true;
  169.                                                         }
  170.                                                         Arr[2]=Arr[0];
  171.                                                         Arr[3]=Arr[1];
  172.                                                 }
  173.                                                 else
  174.                                                 {
  175.                                                         System.out.println("输入的坐标上有棋子,请重新输入。");
  176.                                                 }
  177.                                         }
  178.                                         else
  179.                                         {
  180.                                                 System.out.println("输入坐标越界,请重新输入。");
  181.                                         }
  182.                                 }
  183.                                 else
  184.                                 {
  185.                                         System.out.println("输入坐标越界,请重新输入。");
  186.                                 }
  187.                         }
  188.                         catch(Exception e)
  189.                         {
  190.                                 e.printStackTrace();
  191.                                 System.out.println("坐标非法,请重新输入。");
  192.                         }
  193.                 }       
  194.         }
  195.         //boolean flag=false;
  196.                         /*
  197.                          *要求:能够进行判断五子棋的输赢。
  198.                          *横向,竖向,斜向任意方向有五颗同颜色的棋子连成直线就判断该颜色棋子代表的玩家获胜。
  199.                          *思路:一个棋子有八个方向可以下棋,抛去对应的放下剩下4个方向。
  200.                          * 假设有x点和y点:
  201.                          * x-4 y-4到x+4 y+4代表捺方向
  202.                          * x-4 y+4到x+4 y-4代表撇方向
  203.                          * x   y-4到x   y+4代表横方向
  204.                          * x-4 y  到x+4 y  代表竖方向
  205.                          * 每次落子后,以当前坐标为原点进行判断
  206.                          * 定义一个变量a,用于保存连续的棋子数
  207.                          * 定义一个循环,循环次数是9次。
  208.                          * 判断每个坐标点上是否是棋子是棋子变量a就加一
  209.                          * 然后继续往下判断如果不等于棋子则变量a归零同时假如循环次数大于5则直接跳出循环,因为剩余长度不足5.
  210.                          * 结束程序的方法 1  返回值到主函数控制
  211.                          *                    2 System.esit(0);
  212.                         */
  213.         public boolean WinRen()
  214.         {
  215.                 String qiZi;
  216.                 String qiZi2;
  217.                 if(qiPan[Arr[0]][Arr[1]]=="★")
  218.                 {
  219.                         qiZi="★";
  220.                         qiZi2="执星星棋子的玩家";
  221.                 }
  222.                 else
  223.                 {
  224.                         qiZi="█";
  225.                         qiZi2="执方块棋子的玩家";
  226.                 }
  227.                 try
  228.                 {
  229.                         int tally1=0;
  230.                         for(int a=0;a<9;a++)//判断左上到右下↖↖↖↖↖↖↖↖↖↖↖↖↖↖↖↖↖↖↖
  231.                         {
  232.                                 int x=4-a;
  233.                                 int y=4-a;
  234.                                 if(qiPan[Arr[0]-x][Arr[1]-y]==qiZi )
  235.                                 {
  236.                                         tally1++;
  237.                                         if(tally1==5)
  238.                                         {
  239.                                                 System.out.println("游戏结束");
  240.                                                 System.out.println(qiZi2+"获胜");
  241.                                                 return true;
  242.                                         }
  243.                                 }
  244.                         }
  245.                         tally1=0;
  246.                         for(int a=0;a<9;a++)//从右上到左下↗↗↗↗↗↗↗↗↗↗↗↗↗↗↗↗↗↗↗↗
  247.                         {
  248.                                 int x=4-a;
  249.                                 int y=4-a;
  250.                                 if(qiPan[Arr[0]-x][Arr[1]+y]==qiZi)
  251.                                 {
  252.                                         tally1++;
  253.                                         if(tally1==5)
  254.                                         {
  255.                                                 System.out.println("游戏结束");
  256.                                                 System.out.println(qiZi2+"获胜");
  257.                                                 return true;
  258.                                         }
  259.                                 }
  260.                         }
  261.                         tally1=0;
  262.                         for(int a=0;a<9;a++)//从上到下方向↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑
  263.                         {
  264.                                 int x=4-a;
  265.                                 if(qiPan[Arr[0]-x][Arr[1]]==qiZi)
  266.                                 {
  267.                                         tally1++;
  268.                                         if(tally1==5)
  269.                                         {
  270.                                                 System.out.println("游戏结束");
  271.                                                 System.out.println(qiZi2+"获胜");
  272.                                                 return true;
  273.                                         }
  274.                                 }
  275.                         }
  276.                         tally1=0;
  277.                         for(int a=0;a<9;a++)//从左到右← ← ← ← ← ← ← ← ← ← ← ← ← ← ← ←
  278.                         {
  279.                                 int y=4-a;
  280.                                 if(qiPan[Arr[0]][Arr[1]+y]==qiZi )
  281.                                 {
  282.                                         tally1++;
  283.                                         if(tally1==5)
  284.                                         {
  285.                                                 System.out.println("游戏结束");
  286.                                                 System.out.println(qiZi2+"获胜");
  287.                                                 return true;
  288.                                         }
  289.                                 }
  290.                         }
  291.                 }
  292.                 catch(Exception e)
  293.                 {
  294.                         System.out.println("等您看到这些消息的时候代表我的小游戏出错了!");
  295.                         System.out.println("有错误,请联系QQ:350158598。");
  296.                         System.out.println("提供BUG有神秘大奖赠送,本人保留随时更改源码权利");
  297.                 }
  298.                 return false;
  299.         }
  300. }
复制代码
wanwan1_1.zip (2.74 KB, 下载次数: 49)



评分

参与人数 1技术分 +1 黑马币 +3 收起 理由
Sword + 1 + 3 赞一个!

查看全部评分

23 个回复

倒序浏览
本帖最后由 邵震 于 2013-5-9 21:41 编辑

游戏开始咯



下了两步棋  先手是五角星  后手是方块



输入11521可以悔棋 但是只能悔棋一次



连续五颗同颜色的棋子就结束游戏


点评

你竟然真的去打了额。。。佩服佩服!!  发表于 2013-5-9 00:37
回复 使用道具 举报
支持,回头下下来玩一玩。嘿嘿
回复 使用道具 举报
代码这么长啊,佩服啊。我什么时候才能这样啊
回复 使用道具 举报
支持一下,老邵~~
回复 使用道具 举报
真够强大的,佩服。
就2处小小的字打错了而已。
回复 使用道具 举报
顶一下,支持下LZ,O(∩_∩)O~
回复 使用道具 举报
顶个~ 继续加油!
回复 使用道具 举报
为毛当年我去回帖的时候,,没人去下载我的。。。RP不佳吗???????
回复 使用道具 举报
{:soso_e179:}
回复 使用道具 举报
呵呵 其实 可以 学学图形界面 去试试 用图形界面来写
回复 使用道具 举报
有空了玩一下!
回复 使用道具 举报
感谢老邵
回复 使用道具 举报
老骚可以啊,呵呵,加油哇。
回复 使用道具 举报
这个叼,刘意得收你为入门弟子了
回复 使用道具 举报
强大 ,,,,,,顶!
回复 使用道具 举报
好厉害 还有好可爱的不会!~
回复 使用道具 举报
楼主威武。。。。。。。。。。。
回复 使用道具 举报
看到悔棋功能和没有gui实现就猜是五子棋{:soso_e113:}
回复 使用道具 举报
Sword 金牌黑马 2013-5-13 11:17:27
20#
赞一个,希望继续看到你的作品{:soso_e113:}
回复 使用道具 举报
12下一页
您需要登录后才可以回帖 登录 | 加入黑马