ClientThread

package com.client;

import java.applet.Applet;

/**
 * 客户端线程类类
 *
 * @author 翱翔团队
 * @version 1.0.0
 */
public class ClientThread extends JFrame implements Runnable
{
    Socket socket = null; // 定义套接字
    
    JTextArea txtMess = null;// 创建多行文本框
    
    DataInputStream dis = null;// 定义数据输入流
    
    DataOutputStream dos = null;// 定义数据输出流
    
    String name = null;
    
    public static List list = new ArrayList();
    
    static ChessFrame frame = null;
    
    public static List empty = new ArrayList();
    
    // 定义一个logger
    static Logger logger = Logger.getLogger(com.client.ClientThread.class.getName());
    
    /**
     * 线程的构造方法
     *
     * @param socket
     *            套接字
     * @param txtMess
     *            文本域
     * @param name
     *            用户名
     */
    public ClientThread(Socket socket, JTextArea txtMess, String name,
            ChessFrame frame)
    {
        // 传入的套接字
        this.socket = socket;
        // 传入的消息文本域
        this.txtMess = txtMess;
        // 传入的玩家
        this.name = name;
        this.frame = frame;
    }
    
    /**
     * 线程的运行方法
     */
    public void run()
    {
        int count = ServerFrame.getCount();
        ServerFrame.setCount(count++);
        System.out.println("客户端监听消息：" + count);
        logger.info("客户端监听消息:" + count);
        // 实例化输入流
        try
        {
            while (true)
            {
                // 实例化输入数据流
                dis = new DataInputStream(socket.getInputStream());
                dos = new DataOutputStream(socket.getOutputStream());
                // 读取输入流的数据
                String mess = dis.readUTF();
                System.out.println("client receive  mess:" + mess);
                logger.info("client receive mess:" + mess);
                // 以#号分隔字符串
                String[] data = mess.split("#");
                
                // 棋子监听的标志位
                int flag = Integer.parseInt(data[0]);
                
                logger.info("client flag:" + flag);
                System.out.println("client flag:" + flag);
                switch (flag)
                {
                    // 网络同步走棋
                    case TypeListInfo.NET_CHESS:
                        // 点击棋子的id
                        int id = Integer.parseInt(data[1]);
                        // 棋子走动信息
                        String str = name + ":" + "点击"
                                + Map.chessMan[id].getName() + "走到" + data[3]
                                + "行" + data[4] + "列";
                        // 把信息追加到文本域
                        txtMess.append(str + "\n");
                        // 调用网络同步走棋的方法
                        Net_Walk(data);
                        frame.time = 0;// 计时器清0；
                        break;
                    // 网络同步悔棋regret
                    case TypeListInfo.NET_REGRET:
                        String backInfo = data[1] + "#" + data[2] + "#"
                                + data[3] + "#" + data[4] + "#" + data[5] + "#"
                                + data[6];
                        // 把悔棋的信息添加到集合中
                        list.add(backInfo);
                        System.out.println("list大小:" + list.size());
                        int result = JOptionPane.showConfirmDialog(frame,
                                "是否同意悔棋？",
                                "系统提示",
                                JOptionPane.YES_NO_OPTION);
                        if (result == JOptionPane.YES_OPTION)
                        {
                            ActionEventOwn.back(list);
                            dos.writeUTF(TypeListInfo.NET_REGRET_YES + "#ok");
                        }
                        else
                        {
                            dos.writeUTF(TypeListInfo.NET_REGRET_NO + "#no");
                        }
                        break;
                    // 同意网络悔棋
                    case TypeListInfo.NET_REGRET_YES:
                        ActionEventOwn.back(ChessFrame.list);
                        break;
                    // 不同意网络悔棋
                    case TypeListInfo.NET_REGRET_NO:
                        JOptionPane.showMessageDialog(this, "对方不同意悔棋");
                        break;
                    // 网络消息的处理
                    case TypeListInfo.NET_MESS:
                        System.out.println("data[1]:" + mess);
                        txtMess.append(data[1] + "\n");
                        break;
                    // 开始
                    case TypeListInfo.NET_START:
                        ServerFrame.setReady(1);
                        if (!frame.btnStart.isEnabled())
                        {
                            logger.info("client send confirm start mess:"
                                    + TypeListInfo.NET_START_YES + "#123");
                            dos.writeUTF(TypeListInfo.NET_START_YES + "#123");
                        }
                        else
                        {
                            logger.info("client start button isEnabled:"
                                    + frame.btnStart.isEnabled());
                            
                        }
                        break;
                    // 收到开始
                    case TypeListInfo.NET_START_YES:
                        if (!frame.btnStart.isEnabled())
                        {
                            // 计时器线程开启
                            new Thread(new TimeTheread(frame)).start();
                            JOptionPane.showMessageDialog(this, "游戏开始！");
                            
                            logger.info("==========================");
                            logger.info("==========游戏开始========");
                            logger.info("==========================");
                            
                            for (int i = 1; i <= Map.CHESSNUM; i++)
                            {
                                // 棋子设为可见
                                ChessFrame.lblChessMan[i].setVisible(true);
                            }
                        }
                        break;
                    case TypeListInfo.NET_GAME_OVER:

                        JOptionPane.showMessageDialog(this, "你太牛了，轻松解决了对方！");
                        
                        logger.info("==========================");
                        logger.info("==========游戏结束========");
                        logger.info("==========================");
                        
                        break;
                    case TypeListInfo.NET_PEACE:
                        int result2 = JOptionPane.showConfirmDialog(frame,
                                "是否同意求和？",
                                "系统提示",
                                JOptionPane.YES_NO_OPTION);
                        if (result2 == JOptionPane.YES_OPTION)
                        {
                            dos.writeUTF(TypeListInfo.NET_PEACE_YES + "#yes");
                        }
                        else
                        {
                            dos.writeUTF(TypeListInfo.NET_PEACE_NO + "#no");
                        }
                        break;
                    case TypeListInfo.NET_PEACE_YES:
                        JOptionPane.showMessageDialog(this, "对方同意求和");
                        dos.writeUTF(TypeListInfo.NET_PEACE_MESS + "#yes");
                        break;
                    case TypeListInfo.NET_PEACE_NO:
                        JOptionPane.showMessageDialog(this, "对方拒绝求和");
                        break;
                    case TypeListInfo.NET_PEACE_MESS:
                        JOptionPane.showMessageDialog(this, "和局！");
                        for (int i = 1; i <= Map.CHESSNUM; i++)
                        {
                            frame.lblChessMan[i].setVisible(false);
                        }
                        break;
                    case TypeListInfo.NET_WIN:
                        for (int i = 1; i <= Map.CHESSNUM; i++)
                        {
                            ChessFrame.lblChessMan[i].setVisible(false);
                        }
                        break;
                    default:
                        break;
                }
                if (mess.equals(TypeListInfo.IS_EXIT + ""))
                {
                    System.exit(0);
                }
            }// while
        }// try
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }// run()
    
    /**
     * 网络同步走棋的方法
     *
     * @param data
     *            字符串数组
     */
    public static void Net_Walk(String[] data)
    {
        /**
         * 6#1(棋子id)#2(棋子id)#3(row)#4(col)
         */
        // 当前棋子的id
        int id1 = Integer.parseInt(data[1]);
        // 目标位置棋子的id
        int id2 = Integer.parseInt(data[2]);
        // 目标位置的行
        int row = Integer.parseInt(data[3]);
        // 目标位置的列
        int col = Integer.parseInt(data[4]);
        // 影子的原始位置横坐标
        int x0 = Integer.parseInt(data[5]);
        // 原始位置的纵坐标
        int y0 = Integer.parseInt(data[6]);
        // 棋子的宽度
        int chessWidth = ChessFrame.CHESSWIDTH;
        // 棋子的高度
        int chessHeight = ChessFrame.CHESSHEIGHT;
        // 棋子的目标位置
        Location tagert = Map.location[row][col];
        int x = Map.location[row][col].getX();// 获取x坐标位置
        int y = Map.location[row][col].getY();// 获取y坐标位置
        if (id1 == id2)
        {
            ChessFrame.lblEdge1.setBounds(x0, y0, 55, 55);
            ChessFrame.lblEdge2.setBounds(x, y, 55, 55);
            // 同步走棋
            ChessFrame.lblChessMan[id1].setBounds(tagert.getX(),
                    tagert.getY(),
                    chessWidth,
                    chessHeight);
            // 棋子可见
            ChessFrame.lblChessMan[id1].setVisible(true);
            // 保存位置
            Map.chessMan[id1].setLocation(tagert);
        }
        else
        {
            ChessFrame.lblEdge1.setBounds(x0, y0, 55, 55);
            ChessFrame.lblEdge2.setBounds(x, y, 55, 55);
            // 吃棋
            ChessFrame.lblChessMan[id1].setBounds(tagert.getX(),
                    tagert.getY(),
                    chessWidth,
                    chessHeight);
            ChessFrame.lblChessMan[id1].setVisible(true);
            ChessFrame.lblChessMan[id2].setVisible(false);
            Map.chessMan[id2].setDisplay(false);
            Map.chessMan[id1].setLocation(tagert);
            if (ChessFrame.chessSecClick == 17
                    || ChessFrame.chessSecClick == 18)
            {
                try
                {
                    ChessFrame.gameOver = Applet.newAudioClip(new File(
                            "music/gameover.wav").toURI().toURL());
                    ChessFrame.gameOver.play();
                    ChessFrame.win = Applet.newAudioClip(new File(
                            "music/gamewin.wav").toURI().toURL());
                    ChessFrame.win.play();
                    ChessFrame.lblChessMan[ChessFrame.chessFirClick].setVisible(false);
                    ChessFrame.dos.writeUTF(TypeListInfo.NET_WIN + "#ok");
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
                JOptionPane.showMessageDialog(frame, "玩家"
                        + Map.chessMan[ChessFrame.chessFirClick].getPlayer()
                        + "赢");
            }
        }
        /**
         * 判断将军
         */
        if (Map.killKing(id1))
        {
            try
            {
                ChessFrame.general = Applet.newAudioClip(new File(
                        "music/General.wav").toURI().toURL());
                ChessFrame.general.play();
                
            }
            catch (Exception ex)
            {
                ex.printStackTrace();
            }
            JOptionPane.showMessageDialog(frame, "将军");
        }
        selectPlayer();
        // 悔棋的信息
        
    }
    
    /**
     * 选择玩家的方法
     *
     */
    public static void selectPlayer()
    {
        if (ChessFrame.playerSelect == 1)
        {
            // 选择玩家2
            ChessFrame.playerSelect = 2;
            // 黑将不可见
            ChessFrame.lblGeneral1.setVisible(false);
            // 红将可见
            ChessFrame.lblGeneral2.setVisible(true);
        }
        else
        {
            // 选择玩家1
            ChessFrame.playerSelect = 1;
            // 黑将不可见
            ChessFrame.lblGeneral2.setVisible(false);
            // 红将可见
            ChessFrame.lblGeneral1.setVisible(true);
        }
        // 设置客户端是否能够点击
        ChessFrame.enable = true;
    }
}// ClientThread