Question

这个记忆游戏作为2个玩家/客户，一个是'X'，另一个是'O'。我的游戏使用4x4网格，在对（1到8）上填充随机数，当第一个玩家已经将其作为网格填充随机数时启动它，但是当我开始第二个玩家时，网格填充了不同的数字，我想要随机两个玩家网格中的数字相等。

我是否必须更改函数setArrayListText（）上的代码，或者添加/修改某些代码实例？

Cliente.java（客户端）

Servidor.java（服务器）

public class Cliente extends JFrame implements ActionListener,Runnable
{
    ...    
    private JPanel boardPanel, panel2;
    private JButton[] gameBtn = new JButton[16];
    private JPanel gamePnl = new JPanel();
    ...
    public void start2() 
    {
        try 
        {
            connection  = new Socket(InetAddress.getByName("localhost"), 5000 );
            output = new ObjectOutputStream(connection.getOutputStream());
            input = new ObjectInputStream(connection.getInputStream());

            inputThread = new Thread( this );
            inputThread.start();

            MsgIdt msg = new MsgIdt();
            msg.envia(output);
            System.out.println(msg);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    ...
    public void createGUI()
    {
        for (int i = 0; i < gameBtn.length; i++)
        {
            gameBtn[i] = new JButton(ButtonIcon);
            gameBtn[i].addActionListener(this);
        }
    ...

    public void createJPanels()
    {
        gamePnl.setLayout(new GridLayout(4, 4));
        TrataRato tr = new TrataRato();
        for (int i = 0; i < gameBtn.length; i++)
        {
            gamePnl.add(gameBtn[i]);              
            gameBtn[i].addMouseListener(tr);      
        }  
   ...  
    }

    // You will need to fit this properly in your client class
    public List<Integer> listReciever() throws IOException
    {  
        List<Integer> lista = new ArrayList<>();
        int size = input.readInt(); 
        for(int i = 0; i < size; i++)
        {
            lista.add(input.readInt());
        }
        return lista;
    }

Player.java

  public class Servidor extends JFrame 
  {
       private ArrayList<Integer> gameList = new ArrayList<Integer>(); 

       public Servidor () 
       {
            super( "Tic-Tac-Toe Server" );
            Container cont = getContentPane();
            board = new byte[9];
            players = new Player[2];
            currentPlayer = 0;
            try
            {
                server = new ServerSocket(5000, 2 );
            } 
            catch (IOException e) 
            {
                e.printStackTrace();
                System.exit( 1 );
            }
            output = new TextArea(10, 30);
            output.setEditable(false);
            JScrollPane sp = new JScrollPane(output);
            cont.add( "Center", sp);
            display("Tic-Tac-Toe Server running.");
            addWindowListener(new ProcessaJanela());
            setVisible(true);
            pack();
       }

       public void execute() 
       {
            for ( int i = 0 ; i < players.length; i++ ) 
            {
                try 
                {
                    players[i] = new Player( server.accept(), this, i );
                    players[i].start();
                    ++numberOfPlayers;
                } 
                catch ( IOException e) 
                {
                    e.printStackTrace();
                    System.exit( 1 );
                }
            }
            setTurn();
       }

       public int getNumberOfPlayers() 
       {
            return numberOfPlayers;
       }

       public int getCurrentPlayer() 
       {
            return currentPlayer;
       }

       public int getWinner() 
       {
            return winner;
       }

       public boolean getGameOver()
       {
            return gameOver;
       }

       public void setArrayListText() // generates random numbers
       { 
           java.util.List<Integer> lista = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8);
           Collections.shuffle(lista);
           gameList.addAll(lista);
       }    
       public void gridclients() throws IOException
       {
            players[0].sendList(gameList);
            players[1].sendList(gameList);
       }

       public void setTurn()
       {
            try
            {          
                players[currentPlayer].setTurn("OK");
                players[(currentPlayer == 0 ? 1 : 0 )].setTurn("NOK");

            }
            catch (Exception e)
            { 
                e.printStackTrace();
            } 
        }
        ...
    }
    ...

Answer 1

你的问题是你在客户端洗牌，当你有2个客户端运行它们彼此分开运行时shuffle会给你不同的结果，所以你应该在服务器上传输shuffling逻辑，服务器会生成网格然后发送它适用于两个玩家。

我不喜欢使用ObjectOutputStream，特别是在发送更复杂的对象时，这种方法容易出现大错误和失败，使用原始数据总是更好，并使用DataOutputStream / DataInputStream发送它。

假设您在服务器端的客户端处理程序是Player类，因为您正在发送Socket

发送列表的服务器方法应该在Player class：

中

public void sendList(List<Integer> gameList) throws IOException {
   output.writeInt(gameList.size()); 
   for(int i = 0; i < gameList.size(); i++){
       output.writeInt(gameList.get(i)); 
   }
}

然后，您将sendList中的Servidor class为这两位玩家发送player[0].sendList(gameList); player[1].sendList(gameList);，如下所示：

// You will need to fit this properly in your client class
public List<Integer> listReciever(){  
List<Integer> list = new ArrayList<>();
int size = input.readInt(); 
for(int i = 0; i < size; i++){
       list.add(input.readInt());
}

客户收到：

{{1}}

内存游戏两个玩家Java客户端服务器

1 个答案: