开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 棋牌游戏 > 查看源码
ServeOneClient.java
资源名称：java五子棋.zip　[点击查看]
上传用户：ptnike
上传日期：2007-06-15
资源大小：61k
文件大小：25k
源码类别：

棋牌游戏

开发平台：

Java

ServeOneClient.java：源码内容
  1. import java.io.*;
  2. import java.net.*;
  4. /**
  5.  * <p>Title: chess server</p>
  6.  * <p>Description: chess server</p>
  7.  * <p>Copyright: Copyright (c) 2003</p>
  8.  * <p>Company: e-top</p>
  9.  * @author cylix
  10.  * @version 1.0
  11.  */
  13. public class ServeOneClient extends Thread{
  14.     private Socket socket;
  15.     private String player=null;
  16.     protected ObjectInputStream in;
  17.     protected ObjectOutputStream out;
  18.     public ServeOneClient(Socket s)
  19.         throws IOException {
  20.         socket = s;
  21.         //System.out.println("server socket begin ...");
  23.         in =new ObjectInputStream(
  24.             socket.getInputStream());
  25.         // Enable auto-flush:
  26.         out = new ObjectOutputStream(
  27.             socket.getOutputStream());
  28.         //System.out.println("server socket in and out ...");
  30.         // If any of the above calls throw an
  31.         // exception, the caller is responsible for
  32.         // closing the socket. Otherwise the thread
  33.         // will close it.
  34.         start(); // Calls run()
  35.     }
  36.     public void run() {
  38.         Message obj=new Message();
  39.         while (true) {
  40.             try {
  41.                 obj =(Message)in.readObject();
  42.                 // write message by doMessage() function
  43.                 doMessage(obj);
  44.             }catch(ClassNotFoundException er){}
  45.             catch(IOException e){}
  46.         }
  47.     /*
  48.         System.out.println("closing...");
  49.         try {
  50.             socket.close();
  51.         }catch (IOException e) {}
  52.      */
  54.     }
  55.     /**
  56.      * deal with messages
  57.      * @param msg
  58.      * @return 1= victory request 2=socket closeed
  59.      */
  60.     public int doMessage(Message msg){
  61.         //System.out.println("doMessage begin...type="+msg.type);
  62.         switch(msg.type){
  63.             case 1:{//new connect to the server
  64.                 sendNewPlayer(msg); //here client must reply with type==10
  65.                 addPlayer(msg);     // msg.msg == new player's name
  66.                 break;
  67.             }
  68.             case 2:{// put chessman
  69.                 putChessman(msg);
  70.                 break;
  71.             }
  72.             case 3:{//request for another to play
  73.                 requestAnother(msg);
  74.                 break;
  75.             }
  76.             case 4:{
  77.                 denyRequest(msg);
  78.                 break;
  79.             }
  80.             case 5:{
  81.                 acceptRequest(msg);
  82.                 break;
  83.             }
  84.             case 6:{//send victory
  85.                 checkVictory(msg);
  86.                 break;
  87.             }
  88.             case 7:{//send disconnection
  89.                 getdisconnect(msg);
  90.                 break;
  91.             }
  92.             case 8:{//save game
  93.                 break;
  94.             }
  95.             case 12:{//setting information
  96.                 boolean flag=true;
  97.                 setting(msg,flag);
  98.                 break;
  99.             }
  100.             case 13:{
  101.                 boolean flag=false;
  102.                 setting(msg,flag);
  103.                 break;
  104.             }
  105.             case 19:{
  106.                 playerRefresh(msg);
  107.                 break;
  108.             }
  109.             case 20:{
  110.                 try{
  111.                     this.out.writeObject(msg);
  112.                 }catch(IOException e){
  113.                     e.printStackTrace();
  114.                 }
  115.                 break;
  116.             }
  117.             default:{
  118.             }
  119.         }//end switch
  120.         return 0; // end correctly
  121.     }
  122.     /**
  123.      * judge game and update all client's panel
  124.      * type = 7 sender will close game
  125.      * @param msg
  126.      */
  127.     public void getdisconnect(Message msg){
  128.         Group gg = null;
  129.         Player pp = null;
  130.         String str=null;
  131.         //if disconnector in a group
  132.         for(int i=0;i<Server.groupList.size();i++){
  133.             gg = (Group)Server.groupList.get(i);
  134.             if(this.equals(gg.selfSocket)==true){
  135.                 //send gg.player win
  136.                 msg.type=6; // gg.player win
  137.                 try{
  138.                     gg.playerSocket.out.writeObject(msg);
  139.                 }catch(IOException e){
  140.                     e.printStackTrace();
  141.                 }
  142.                 sendLeftMsg(gg.self);
  143.                 //update groupList
  144.                 Server.groupList.remove(gg);
  145.                 return;
  146.             }
  147.             if(this.equals(gg.playerSocket)==true){
  148.                 msg.type=6;
  149.                 try{
  150.                     gg.selfSocket.out.writeObject(msg);
  151.                 }catch(IOException e){
  152.                     e.printStackTrace();
  153.                 }
  154.                 sendLeftMsg(gg.player);
  155.                 Server.groupList.remove(gg);
  156.                 return;
  157.             }
  158.         }
  160.         // if disconnector in the playerList
  161.         for(int i=0;i<Server.playerList.size();i++){// find disconnector
  162.             pp = (Player)Server.playerList.get(i);
  163.             if(this.equals(pp.selfSocket)==true){
  164.                 break;
  165.             }
  166.         }
  167.         sendLeftMsg(pp.self);
  168.         Server.playerList.remove(pp); // remove disconnector from list
  169.         updateClient();
  170.     }
  171.     private void sendLeftMsg(String str){
  172.         char cc;
  173.         for(int i=0;i<50;i++){
  174.             cc=str.charAt(i);
  175.             if(cc!='')
  176.                 System.out.print(cc);
  177.             else break;
  178.         }
  179.         System.out.print(" has left server ...n");
  181.     }
  182.     /**
  183.      * deny request of play
  184.      * type ==4 msg == requestor's name
  185.      * @param msg
  186.      */
  187.     public void denyRequest(Message msg){
  188.         String denyName=null;
  189.         Player pp=null;
  190.         for(int i=0;i<Server.playerList.size();i++){
  191.             pp = (Player)Server.playerList.get(i);
  192.             if(this.equals(pp.selfSocket)==true){
  193.                 denyName = new String(pp.self);
  194.                 break;
  195.             }
  196.         }
  197.         for(int i=0;i<Server.playerList.size();i++){
  198.             pp = (Player)Server.playerList.get(i);
  199.             if(arrayMatchString(msg.msg,pp.self)==true){
  200.                 Message ms = new Message();
  201.                 ms.type=4;
  202.                 strToCharArray(denyName,ms.msg);
  203.                 try{// requestor 's socket send msg to it's client
  204.                     pp.selfSocket.out.writeObject(ms);
  205.                 }catch(IOException er){
  206.                     er.printStackTrace();
  207.                 }
  208.                 break;
  209.             }
  210.         }
  212.     }
  213.     /**
  214.      * B accept request of A server will update List
  215.      * type ==5 msg == A's name
  216.      * @param msg
  217.      */
  218.     public void acceptRequest(Message msg){
  219.         Player pps=null,ppd=null;//ppd = B pps = A
  220.         String acceptName=null;
  221.         for(int i=0;i<Server.playerList.size();i++){
  222.             ppd = (Player)Server.playerList.get(i);
  223.             if(this.equals(ppd.selfSocket)==true){
  224.                 break;
  225.             }
  226.         }
  227.         for(int i=0;i<Server.playerList.size();i++){
  228.             pps = (Player)Server.playerList.get(i);
  229.             if(arrayMatchString(msg.msg,pps.self)==true){
  230.                 break;
  231.             }
  232.         }
  234.         Message ss = new Message();
  235.         ss.type=14; // for B to set color and settings
  236.         ss.color=msg.color;
  237.         try{
  238.             ppd.selfSocket.out.writeObject(ss);
  239.         }catch(IOException e){
  240.             e.printStackTrace();
  241.         }
  242.         ss.type=5; // B's accept A's requestion
  243.         strToCharArray(ppd.self,ss.msg);
  244.         try{
  245.             pps.selfSocket.out.writeObject(ss);
  246.         }catch(IOException e){
  247.             e.printStackTrace();
  248.         }
  249.         //upload list display here, server will update Arraylist
  250.         Group p1 = new Group();
  251.         p1.self=new String(pps.self);
  252.         p1.selfSocket = pps.selfSocket;
  253.         p1.selfColor = pps.color;
  254.         p1.player = new String(ppd.self);
  255.         p1.playerSocket = ppd.selfSocket;
  256.         if(p1.selfColor==1){
  257.             p1.playerColor = 2;
  258.         }else{
  259.             p1.playerColor = 1;
  260.         }
  261.         p1.Setting = pps.setting;
  262.         Server.groupList.add(p1);
  264.         ///System.out.println(p1.self+p1.selfColor+" player "+p1.player+p1.playerColor);
  266.         if(Server.playerList.size()==2){
  267.             msg.type=15;
  268.             try{
  269.                 pps.selfSocket.out.writeObject(msg);
  270.                 ppd.selfSocket.out.writeObject(msg);
  271.             }catch(IOException e){
  272.                 e.printStackTrace();
  273.             }
  274.         }
  275.         Server.playerList.remove(pps);
  276.         Server.playerList.remove(ppd);
  278.         //System.out.println(" after create a group,playerlist size  = "+Server.playerList.size());
  280.         updateClient();
  281.     }
  282.     /**
  283.      * update client List when new group create or player left
  284.      */
  285.     public void updateClient(){
  286.         Message msg = new Message();
  287.         Player pp = null,ppm = null;
  288.         for(int i=0;i<Server.playerList.size();i++){
  289.             pp = (Player)Server.playerList.get(i);
  290.             msg.type=15;   //update client player list box
  291.             try{  //clear client list box
  292.    //             System.out.println("clear "+pp.self+"'s list box");
  293.                 pp.selfSocket.out.writeObject(msg);
  294.             }catch(IOException e){
  295.                 e.printStackTrace();
  296.             }
  297.             for(int j=0;j<Server.playerList.size();j++){
  298.                 ppm=(Player)Server.playerList.get(j);
  299.                 strToCharArray(ppm.self,msg.msg);
  300.                 msg.type=9;
  301.                 try{
  302.                     //System.out.println("updating ..."+pp.self+" list box about"+ppm.self);
  303.                     pp.selfSocket.out.writeObject(msg);
  304.                 }catch(IOException e){
  305.                     e.printStackTrace();
  306.                 }
  307.             }
  308.         }
  309.         // later ,group player 's list box will be updateed here
  310.     }
  311.     /**
  312.      * judge whether arr[] is equal to str
  313.      * @param arr
  314.      * @param str
  315.      * @return
  316.      */
  317.     private boolean arrayMatchString(char []arr,String str){
  318.         for(int i=0; i<50 && str.charAt(i)!='';i++){
  319.             if(arr[i]!=str.charAt(i))
  320.                 return false;
  321.         }
  322.         return true;
  323.     }
  324.     /**
  325.      * type ==3
  326.      * @param msg
  327.      */
  328.     public void requestAnother(Message msg){
  329.         Player pp = null;  // receiver
  330.         Player spp = null; // sender
  331.         String senderName=null;
  332.         // get sender's name
  333.         for(int i=0;i<Server.playerList.size();i++){
  334.             spp = (Player)Server.playerList.get(i);
  335.             if(this.equals(spp.selfSocket)==true){
  336.                 senderName = new String(spp.self);
  337.                 //System.out.println("requestor 's name = "+senderName);
  338.                 break;
  339.             }
  340.         }
  341.         for(int i=0;i<Server.playerList.size();i++){
  342.             pp = (Player)Server.playerList.get(i);
  343.             if(arrayMatchString(msg.msg,pp.self)==true){
  344.                 Message ms = new Message();
  345.                 strToCharArray(senderName,ms.msg);
  346.                 ms.type=3;
  347.                 if(spp.color==1){
  348.                     ms.color = 2; //set another's color
  349.                 }
  350.                 else{
  351.                     ms.color = 1;
  352.                 }
  353.                 ms.setting=spp.setting;
  354.                 try{// player B socket send msg to B's Client
  355.                     pp.selfSocket.out.writeObject(ms);
  356.                     //System.out.println("type= "+ms.type+"  "+pp.self+ " send msg to name = "+ms.msg[0]+"with B's color"+ms.color);
  357.                 }catch(IOException er){
  358.                     er.printStackTrace();
  359.                 }
  360.                 break;
  361.             }
  362.         }
  363.     }
  364.     // convert string to array which is end with ''
  365.     public void strToCharArray(String str,char [] arr){
  366.         int i=0;
  367.         for(i=0;i<str.length()&&i<49;i++){
  368.             arr[i] = str.charAt(i);
  369.         }
  370.         arr[i]='';
  371.     }
  372.     /**
  373.      * setting information flag
  374.      * @param msg
  375.      */
  376.     public void setting(Message msg,boolean flag){
  377.         int i=0;
  378.         Player pp=null;
  379.         for(i=0;i<Server.playerList.size();i++){
  380.             pp =(Player) Server.playerList.get(i);
  381.             if(this.equals(pp.selfSocket)==true){
  382.                 if(flag==true)
  383.                     pp.setting=msg.setting;
  384.                 else
  385.                     pp.color=msg.color;
  386.                 //System.out.println("setting "+pp.setting+"color = "+pp.color);
  387.             }
  388.         }
  390.     }
  392.     /**
  393.      * filter array 's black space which is end of the array
  394.      * @param arr
  395.      * @param str
  396.      */
  397.     public String arrayToString(char [] arr){
  398.         int i=0,length=0;
  399.         while(arr[i]!='' && i<50){
  400.             i++;
  401.         }
  402.         length=i;
  403.         char [] ss = new char[length];
  404.         for(i=0;i<length;i++){
  405.             ss[i]=arr[i];
  406.         }
  407.         String str = new String(ss);
  408.         return str;
  409.         //System.out.println("arraytoString "+str+"length = "+length);
  410.     }
  412.     /**
  413.      * add new player to all client's Player List
  414.      * ... read server player list and send msg to everyone of them
  415.      * @param player
  416.      */
  417.     public void sendNewPlayer(Message player){
  418.         Player pp=null;
  419.         player.type=9;
  420. //        System.out.println("send new Player ...");
  421.         for(int i=0;i<Server.playerList.size();i++){
  422.             pp=(Player)Server.playerList.get(i);
  423.             try{
  424.                 if(pp.self!=null){//send message to all but itself
  425.                     //System.out.println(pp.self+" add list "+player.msg[0]+"i = "+i);
  426.                     pp.selfSocket.out.writeObject(player);
  427.                 }
  428.             }catch(IOException e){
  429.                 e.printStackTrace();
  430.             }
  431.         }
  432.     }
  433.     /**
  434.      * a player end a game and wait for a new one
  435.      * @param msg
  436.      */
  437.     public void playerRefresh(Message player){
  438.         Player ppo = new Player();
  439.         Player pp = null;
  440.         ppo.color = player.color;
  441.         ppo.self = new String(player.msg);
  442.         ppo.selfSocket = this;
  443.         Server.playerList.add(ppo);
  445.         for(int i=0;i<Server.playerList.size();i++){
  446.             pp = (Player)Server.playerList.get(i);
  447.             if(this.equals(pp.selfSocket)==false){
  448.                 Message msg = new Message();
  449.                 strToCharArray(pp.self, msg.msg);
  450.                 msg.type = 9;
  451.                 msg.color = pp.color;
  452. //                System.out.println("refresh " + pp.self + "serverlist size " +
  453.   //                                 Server.playerList.size());
  454.                 try {
  455.                     this.out.writeObject(msg);
  456.                 }
  457.                 catch (IOException e) {
  458.                     e.printStackTrace();
  459.                 }
  460.             }
  461.         }
  462.         Message ms = new Message();
  463.         strToCharArray(ppo.self, ms.msg);
  464.         ms.type=10;
  465.         try{
  466.             this.out.writeObject(ms);
  467.         }catch(IOException e){
  468.             e.printStackTrace();
  469.         }
  470.         //Message ms = new Message();
  471.         player.type=10;
  472.         for(int i=0 ;i<Server.playerList.size();i++){
  473.             pp = (Player)Server.playerList.get(i);
  474.             if(this.equals(pp.selfSocket)!=true){
  475.                 try{
  476.                     pp.selfSocket.out.writeObject(player);
  477.                 }catch(IOException e){
  478.                     e.printStackTrace();
  479.                 }
  481.             }
  482.         }
  484.     }
  485.     /**
  486.      * add the new player to server playerList
  487.      * @param player
  488.      */
  489.     public void addPlayer(Message player){
  490.         int i=0;
  491.         Player pp=null,tp=null;
  493.         for(i=0;i<Server.playerList.size();i++){
  494.             pp=(Player)Server.playerList.get(i);
  495.             if(this.equals(pp.selfSocket)==true){
  496.                 //System.out.println("match socket ok and send to itself...");
  497.                 pp.self = new String(player.msg);
  498.                 try{
  499.                     for (int j = 0; j < Server.playerList.size(); j++) {
  500.                         Message temp = new Message();
  501.                         tp = (Player) Server.playerList.get(j);
  502.                         if (tp.self != null) {
  503.                             strToCharArray(tp.self, temp.msg);
  504.                             //temp.coordinateX=(byte)j;
  505.                             temp.type = 10; //reply for type==1
  506.                             //System.out.println("host "+pp.self+" add list to client name = "+temp.coordinateX+temp.msg[0]);
  507.                             pp.selfSocket.out.writeObject(temp);
  508.                         }
  509.                     }
  510.                    // out.writeObject(player);
  511.                 }catch(IOException e){
  512.                     e.printStackTrace();
  513.                 }
  514.                 break;
  515.             }
  516.         }/*
  517.         System.out.print("welcome ");
  518.         int k=0;
  519.         while(true){
  520.             if(player.msg[k]!='')
  521.                 System.out.print(player.msg[k++]);
  522.             else break;
  523.         }
  524.         System.out.println();*/
  525.         //System.out.println(" at "+pp.selfSocket.socket.toString());
  526.     }
  527.     public Socket getSocket(){
  528.         return socket;
  529.     }
  530.     /**
  531.      * check whether msg sender is win
  532.      * type=6 msg = winner 's name
  533.      * @param msg
  534.      */
  535.     public void checkVictory(Message msg){
  537.     }
  538.     /**
  539.      * type = 2 ,(msg.coordinateX,msg.coordinateY).msg.color
  540.      * @param msg
  541.      */
  542.     public void putChessman(Message msg){
  543.         Group gg = new Group();
  544.         ServeOneClient soc=null;
  545.         String tName=null;
  546.         int color=0;
  547.         // modify server board
  548.         for(int i=0;i<Server.groupList.size();i++){
  549.             gg = (Group)Server.groupList.get(i);
  550.             if(this.equals(gg.selfSocket)==true){
  551.                 soc = gg.playerSocket;
  552.                 tName = new String(gg.player);
  553.                 color = gg.selfColor;
  554.                 break;
  555.             }
  556.             if(this.equals(gg.playerSocket)==true){
  557.                 soc = gg.selfSocket;
  558.                 tName = new String(gg.self);
  559.                 color = gg.playerColor;
  560.                 break;
  561.             }
  562.         }
  563.         gg.board[msg.coordinateX][msg.coordinateY]=color;
  565.         // whether someone win the game
  566.         if(judge(gg,msg.coordinateX,msg.coordinateY)==true){// a man win
  567.             // tell the two and remove them form the group list
  568.             try{
  569.                 msg.type=6;  // win the game
  570.                 this.out.writeObject(msg);// tell this ,he win the game
  571.                 msg.type=17; // failed in the game
  572.                 soc.out.writeObject(msg); // tell soc ,he failed
  573. //                System.out.println("send failed to "+tName);
  574.             }catch(IOException e){
  575.                 e.printStackTrace();
  576.             }
  577.             Server.groupList.remove(gg); // remove from list
  578.             return;
  579.         }
  580.         // send msg to another player
  581.         try{
  582.             //System.out.println("server put chess man "+msg.coordinateX+","+msg.coordinateY);
  583.             soc.out.writeObject(msg);
  584.         }catch(IOException e){
  585.             e.printStackTrace();
  586.         }
  588.     }
  589.     /**
  590.      * judge if a man win the game
  591.      * @param gg a group for judge
  592.      * @param x  the newest kid's x coordinate
  593.      * @param y  the newest kid's y coordinate
  594.      * @return
  595.      */
  596.     private boolean judge(Group gg,int x,int y){
  597.         int i = 0, j = 0, count = 0;
  598.         int color=gg.board[x][y];
  599.         // x direction
  600.         for (i = 0, count = 0; x - i >= 0 && i < 5; i++) {
  601.             if (color == gg.board[x - i][y]) {
  602.                 count++;
  603.             }
  604.             else {
  605.                 break;
  606.             }
  607. //          System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  608.             if (count == 5)
  609.                 return true;
  610.         }
  611.         for (i = 1; x + i < 15 && i < 5; i++) {
  612.             if (color == gg.board[x + i][y]) {
  613.                 count++;
  614.             }
  615.             else {
  616.                 break;
  617.             }
  618.             if (count == 5)
  619.                 return true;
  620.         }
  621.         // y direction
  622.         for (i = 0, count = 0; y - i >= 0 && i < 5; i++) {
  623.             if (color == gg.board[x][y - i]) {
  624.                 count++;
  625.             }
  626.             else {
  627.                 break;
  628.             }
  629. //            System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  630.             if (count == 5)
  631.                 return true;
  632.         }
  633.         for (i = 1; y + i < 15 && i < 5; i++) {
  634.             if (color == gg.board[x][y + i]) {
  635.                 count++;
  636.             }
  637.             else {
  638.                 break;
  639.             }
  640. //        System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  641.             if (count == 5)
  642.                 return true;
  643.         }
  644.         // '' direction
  645.         for (i = 0, count = 0; x - i >= 0 && y - i >= 0 && i < 5; i++) {
  646.             if (color == gg.board[x - i][y - i]) {
  647.                 count++;
  648.             }
  649.             else {
  650.                 break;
  651.             }
  652. //            System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  653.             if (count == 5)
  654.                 return true;
  655.         }
  656.         for (i = 1; x + i < 15 && y + i < 15 && i < 5; i++) {
  657.             if (color == gg.board[x + i][y + i]) {
  658.                 count++;
  659.             }
  660.             else {
  661.                 break;
  662.             }
  663. //          System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  664.             if (count == 5) {
  665.                 return true;
  666.             }
  667.         }
  668.         // '/' direction
  669.         for (i = 0, count = 0; x + i < 15 && y - i >= 0 && i < 5; i++) {
  670.             if (color == gg.board[x + i][y - i]) {
  671.                 count++;
  672.             }
  673.             else {
  674.                 count = 0;
  675.             }
  676. //          System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  677.             if (count == 5)
  678.                 return true;
  679.         }
  680.         for (i = 1; x - i >= 0 && y + i < 15 && i < 5; i++) {
  681.             if (color == gg.board[x - i][y + i]) {
  682.                 count++;
  683.             }
  684.             else {
  685.                 break;
  686.             }
  687. //            System.out.println("( "+x+" , "+y+" )"+"count = "+count);
  688.             if (count == 5) {
  689.                 return true;
  690.             }
  691.         }
  692.         return false;
  693.     }
  694.     /**
  695.      * judge if a man win the game
  696.      * @param gg a group for judge
  697.      * @param x  the newest kid's x coordinate
  698.      * @param y  the newest kid's y coordinate
  699.      * @return
  700.      */
  701. /*    private boolean judge(Group gg,int x,int y){
  703.         int borderX=0,borderY=0,counter=0,i=0;
  704.         int color=gg.board[x][y];
  705.         if(x-4<0)            borderX=0;
  706.         else            borderX=x-4;
  707.         if(y-4<0)            borderY=0;
  708.         else            borderY=y-4;
  711.         // x direction
  712.         while(borderX+i<x+5 && borderX+i<15){
  713.             if(color==gg.board[borderX+i][y]){
  714.                 counter++;
  715.             }else{
  716.                 counter=0;
  717.             }
  718.             i++;
  719.             if(counter==5){
  720. //                System.out.println("color "+color+gg.board[borderX+i][y]+"return form x "+(borderX+i)+","+y+"x,y"+x+","+y);
  721.                 return true;
  722.             }
  723.         }
  724.         // y direction
  725.         i=0;counter=0;
  726.         while(borderY+i<y+5 && borderY+i<15){
  727.             if(color==gg.board[x][borderY+i]){
  728.                 counter++;
  729.             }else{
  730.                 counter=0;
  731.             }
  732.             i++;
  733.             if(counter==5){
  734. //                System.out.println("color "+color+gg.board[x][borderY+i]+"return form y "+x+","+(borderY+i)+","+y+"x,y"+x+","+y);
  735.                 return true;
  736.             }
  737.         }
  738.         // '' direction
  739.         if(borderX>borderY)
  740.             borderX = x-(y-borderY);
  741.         else
  742.             borderY = y-(x-borderX);
  743.         i=0;counter=0;
  744.         while(borderX+i<x+5 && borderY+i<y+5 && borderY+i<15&&borderX+i<15){
  745.             if(color==gg.board[borderX+i][borderY+i]){
  746. //                System.out.println("coordinate  \  "+(borderX+i)+","+(borderY+i)+","+y+"x,y"+x+","+y);
  747.                 counter++;
  748.             }else{
  749.                 counter=0;
  750.             }
  751.             i++;
  752.             if(counter==5){
  753. //                System.out.println("return form  \  "+(borderX+i)+","+(borderY+i)+","+y+"x,y"+x+","+y);
  754.                 return true;
  755.             }
  756.         }
  757.         // '/' direction
  758.         if(x+4>=15){
  759.             borderX = 14;
  760.         }
  761.         else{
  762.             borderX = x+4;
  763.         }
  764.         if(borderX-x<y-borderY){
  765.             borderY = y - (borderX - x);
  766.         }
  767.         else{
  768.             borderX = x + (y - borderY);
  769.         }
  770.         i=0;counter=0;
  771.         while(borderX-i>x-5 && borderY+i<y+5 && borderX-i>=0 && borderY+i<15){
  772.             if(color==gg.board[borderX-i][borderY+i]){
  773.                 counter++;
  774.             }else{
  775.                 counter=0;
  776.             }
  777.             i++;
  778.             if(counter==5){
  779. //                System.out.println("color "+color+gg.board[borderX-i][borderY+i]+"return form '/'   "+(borderX-i)+","+(borderY+i)+","+y+"x,y"+x+","+y);
  780.                 return true;
  781.             }
  782.         }
  783.         return false;
  784.     }
  785. */
  787. } ///:-)