server.java

用Java编写的扑克牌游戏（含代码）

        }
      }
      else if (face13[i][number] == 3) {
        cardsum[number] = cardsum[number] + 7;
        cardcomp[0][number] = cardsum[number];
        cardcomp[1][number] = i;
      }
      else if (face13[i][number] == 4) {
        cardsum[number] = cardsum[number] + 11;
        cardcomp[0][number] = cardsum[number];
        cardcomp[1][number] = i;
      }
      else {
        cardsum[number] = cardsum[number] + 0;
      }
    }
    if (shunORnot(number) == 1) {
      cardsum[number] = cardsum[number] + 8;
    }
    for (int j = 0; j < 4; j++) {
      if (suit4[j][number] == 5) {
        cardsum[number] = cardsum[number] + 9;
        cardcomp[0][number] = cardsum[number];
        cardcomp[2][number] = cardcomp[1][number];
        cardcomp[1][number] = j;
      }
      else {
        cardsum[number] = cardsum[number] + 0;
      }
    }
    switch (cardsum[number]) {
      case 0:
        return ("惨了！拿到了一手烂牌！");
      case 3:
        return ("小心！这次只有一对喔。");
      case 6:
        return ("还好！拿到了两对。");
      case 7:
        return ("不错！有三张同点数的牌。");
      case 8:
        return ("好！拿到了顺子！");
      case 9:
        return ("很好！拿到了同花！");
      case 10:
        return ("太好了！拿到了Full house！");
      case 11:
        return ("好极了！有四张同点数的牌！");
      case 17:
        return ("万能的神啊！竟然拿到了同花顺！");
      default:
        break;
    }
    return ("程序运行错误(count)！请赶快与程序员联系！");
  }

  //查看等级的函数checkLevel()
  public void checkLevel(int number) {
    player_level[number] = new StringBuffer();
    if (player_score[number] == 0) {
      player_level[number].append("败家子");
    }
    if (player_score[number] >= 100 && player_score[number] <= 500) {
      player_level[number].append("倒霉蛋");
    }
    if (player_score[number] > 500 && player_score[number] <= 2000) {
      player_level[number].append("新手");
    }
    if (player_score[number] > 2000 && player_score[number] <= 5000) {
      player_level[number].append("好手");
    }
    if (player_score[number] > 5000 && player_score[number] <= 10000) {
      player_level[number].append("高手");
    }
    if (player_score[number] > 10000) {
      player_level[number].append("赌神");
    }
  }

  //检查一副牌是否发完的函数checkCurrentCard()
  public int checkCurrentCard() {
    int tempCard = currentCard;
    if (++tempCard <= 51) {
      return++currentCard;
    }
    else {
      return currentCard;
    }
  }

  //向数组添加牌记录的函数addrecord()
  public void addrecord(int number, Card deck, int order) {
    int j, k;
    for (j = 0; j < 13; j++) {
      if (deck.checkface() == faces[j]) {
        face13[j][number] = face13[j][number] + 1;
        break;
      }
    }
    for (k = 0; k < 4; k++) {
      if (deck.checksuit() == suits[k]) {
        suit4[k][number] = suit4[k][number] + 1;
        break;
      }
    }
    card_name[order][number] = j * 4 + k;
  }

  //将牌记录从数组里面删除的函数deleterecord()
  public void deletecard(int order, int number) {
    face13[card_name[order][number] /
        4][number] = face13[card_name[order][number] / 4][number] - 1;
    suit4[card_name[order][number] %
        4][number] = suit4[card_name[order][number] %
        4][number] - 1;
  }

  //发牌函数dealCard()
  public void dealCard() {
    for (int i = 0; i < 5; i++) {
      addrecord(Player1, deck[++currentCard], i);
      addrecord(Player2, deck[++currentCard], i);
    }
  }

  //检查分数并为下次游戏进行初始化的函数checkNext()
  public void checkNext() {
    for (int i = 0; i < 13; i++) {
      face13[i][Player1] = 0;
      face13[i][Player2] = 0;
    }
    for (int j = 0; j < 4; j++) {
      suit4[j][Player1] = 0;
      suit4[j][Player2] = 0;
    }
    cardsum[Player1] = 0;
    cardsum[Player2] = 0;
    for (int k = 0; k < 3; k++) {
      cardcomp[k][Player1] = -1;
      cardcomp[k][Player2] = -1;
    }
    for (int i = 0; i < 5; i++) {
      card_name[i][Player1] = -1;
      card_name[i][Player2] = -1;
    }
    currentCard = -1;
    for (int i = 0; i < Players.length; i++) {
      player_wager[i] = 0; //赌注
      for (int j = 0; j < 5; j++) {
        card_name[j][i] = -1;
      }
    }
    player_getcard[0] = false;
    player_getcard[1] = false;
    player_wagered[0] = false;
    player_wagered[1] = false;
  }

//计算胜算的函数winChance()
  public float winChance(int number) {
    switch (cardcomp[0][number]) {
      case 1:
        return ( (float) winchance[0] * (cardcomp[1][number] - 4) * 100 / 8 /
                2598960);
      case 3:
        return ( (float) (winchance[0] +
                          winchance[1] * (cardcomp[1][number] + 1) / 13) * 100 /
                2598960);
      case 6:
        return ( (float) (winchance[0] + winchance[1] +
                          winchance[2] * ( (cardcomp[1][number]) / 12) *
                          ( (cardcomp[2][number] + 1) / 13)) * 100 / 2598960);
      case 7:
        return ( (float) (winchance[0] + winchance[1] + winchance[2] +
                          winchance[3] * (cardcomp[1][number] + 1) / 13) * 100 /
                2598960);
      case 8:
        return ( (float) (winchance[0] + winchance[1] + winchance[2] +
                          winchance[3] +
                          winchance[4] * (cardcomp[1][number] + 1) / 13) * 100 /
                2598960);
      case 9:
        return ( (float) (winchance[0] + winchance[1] + winchance[2] +
                          winchance[3] + winchance[4] +
                          winchance[5] * ( (cardcomp[1][number] + 1) / 4) *
                          ( (cardcomp[2][number] - 4) / 8)) * 100 / 2598960);
      case 10:
        return ( (float) (winchance[0] + winchance[1] + winchance[2] +
                          winchance[3] + winchance[4] + winchance[5] +
                          winchance[6] * (cardcomp[1][number] + 1) / 13) * 100 /
                2598960);
      case 11:
        return ( (float) (winchance[0] + winchance[1] + winchance[2] +
                          winchance[3] + winchance[4] + winchance[5] +
                          winchance[6] +
                          winchance[7] * (cardcomp[1][number] + 1) / 13) * 100 /
                2598960);
      case 17:
        return ( (float) (winchance[0] + winchance[1] + winchance[2] +
                          winchance[3] + winchance[4] + winchance[5] +
                          winchance[6] + winchance[7] +
                          winchance[8] * ( (cardcomp[1][number] + 1) / 4) *
                          ( (cardcomp[2][number] - 3) / 9)) * 100 / 2598960);
      default:
        break;
    }
    return 100;
  }

  public static void main(String args[]) {
    Server app = new Server();
    app.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    });
  }

  class Player
      extends Thread {
    private Socket connection;
    private DataInputStream input;
    private DataOutputStream output;
    private int player_number, other_player_number;
    public Player(Socket socket, int number) {
      player_number = number;
      other_player_number = (player_number + 1) % 2;
      connection = socket;
      try {
        input = new DataInputStream(connection.getInputStream());
        output = new DataOutputStream(connection.getOutputStream());
        message_area.append("玩家" + (player_number + 1) + "加入游戏\n");
        player_connect_status[number] = true;
        player_getcard[number] = false;
      }
      catch (IOException e) {}
    }

    public void run() {
      if (player_connect_status[other_player_number] == true) {
        message_area.append("更新状态\n");
        for (int i = 0; i < Players.length; i++) {
          try {
            Players[i].output.writeInt(UpdateStatus);
            Players[i].output.writeUTF(player_level[i].toString());
            Players[i].output.writeUTF(player_level[Players[i].
                                       other_player_number].toString());
            Players[i].output.writeInt(player_score[i]);
            Players[i].output.writeInt(player_score[Players[i].
                                       other_player_number]);
          }
          catch (IOException E) {}
        }
      }
      while (true) {
        try {
          int operate = input.readInt();
          if (operate == GetCard) {
            player_getcard[player_number] = true;
            message_area.append("玩家"+ (player_number+1)+"要牌\n");
            if (player_getcard[Players[player_number].other_player_number] == true) {
              message_area.append("发牌\n");
              shuffle();
              dealCard();
              for (int i = 0; i < 2; i++) {
                Players[i].output.writeInt(GetCard);
                for (int j = 0; j < 5; j++) {
                  Players[i].output.writeInt(card_name[j][i]);
                }
                checkLevel(i);
                Players[i].output.writeUTF(player_level[i].toString());
                Players[i].output.writeInt(player_score[i]);
                Players[i].output.writeUTF(count(i));
                player_winchance[i] = winChance(i);
                Players[i].output.writeFloat(player_winchance[i]);
              }
            }
          }
          else if (operate == ChangeCard) {
            int card_number = input.readInt();
            synchronized (card_name) {
              deletecard(card_number, player_number);
              addrecord(player_number, deck[checkCurrentCard()], card_number);
              output.writeInt(ChangeCard);
              output.writeInt(card_number);
              output.writeInt(card_name[card_number][player_number]);
              player_score[player_number] = player_score[player_number] - 100;
              output.writeInt(player_score[player_number]);
              output.writeUTF(count(player_number));
              player_winchance[player_number] = winChance(player_number);
              output.writeFloat(player_winchance[player_number]);
            }
            message_area.append("玩家" + (player_number + 1) + "换牌\n");
          }
          else if (operate == PeekCard) {
            int card_number = input.readInt();
            synchronized (card_name) {
              output.writeInt(PeekCard);
              output.writeInt(card_number);
              output.writeInt(card_name[card_number][other_player_number]);
              player_score[player_number] = player_score[player_number] - 100;
              output.writeInt(player_score[player_number]);
            }
            message_area.append("玩家" + (player_number + 1) + "偷看牌\n");
          }
          else if (operate == Wager) {
            player_wagered[player_number] = true;
            player_wager[player_number] = input.readInt();
            player_score[player_number] = player_score[player_number] -
                player_wager[player_number];
            message_area.append("玩家" + (player_number + 1) + "下注" +
                                player_wager[player_number] + "\n");
            if (player_wagered[other_player_number] == true) {
              cardCompare();
              for (int i = 0; i < Players.length; i++) {
                Players[i].output.writeInt(Wager);
                for (int j = 0; j < 5; j++) {
                  Players[i].output.writeInt(card_name[j][Players[i].
                                             other_player_number]);
                }
                Players[i].output.writeUTF(count(i));
                Players[i].output.writeUTF(player_compare_result[i].toString());
                checkLevel(Players[i].player_number);
                Players[i].output.writeUTF(player_level[i].toString());
                Players[i].output.writeUTF(player_level[Players[i].
                                           other_player_number].toString());
                Players[i].output.writeInt(player_score[i]);
                Players[i].output.writeInt(player_score[Players[i].
                                           other_player_number]);
              }
              checkNext();
            }
          }
        }
        catch (IOException E) {}
      }
    }
  }
}

class Card {
  private String face;
  private String suit;
  public Card(String f, String s) {
    face = f;
    suit = s;
  }

  public String checkface() {
    return face;
  }

  public String checksuit() {
    return suit;
  }
}