npm install
npm run server

|-- src
|   |-- app.ts							## 【程序入口】
|   |-- constant						## 【枚举和常量】
|   |   |-- GameStage.ts				# 游戏状态/阶段
|   |   |-- PokerHand.ts				# 牌型
|   |   |-- PokerPoints.ts				# 牌点数
|   |   |-- PokerSuits.ts				# 牌花色
|   |   |-- SocketGameEvent.ts			# socket游戏事件枚举
|   |   |-- SocketRoomEvent.ts			# socket房间事件枚举
|   |-- controllers						## 【控制器】存放路由对应的程序逻辑
|   |   |-- ExampleController.ts
|   |   |-- GameController.ts			# 游戏相关控制器
|   |   |-- RoomController.ts			# 房间相关控制器
|   |   |-- UserController.ts			# 用户相关控制器（用户登录）
|   |-- data							## 【数据模型】
|   |   |-- Player.ts					# 玩家
|   |   |-- Poker.ts					# 卡牌
|   |   |-- Referee.ts					# 裁判（每个房间都有一个裁判管理游戏流程）
|   |   |-- ResData.ts					# http响应数据对象
|   |   |-- Room.ts						# 房间
|   |   |-- SocketData.ts				# socket通信数据对象
|   |   |-- User.ts						# 用户
|   |-- game							## 【游戏相关】
|   |   |-- PokerManager.ts				# 扑克牌管理，生成一组扑克牌
|   |   |-- RoomManager.ts				# 房间管理
|   |-- middlewares						## 【中间件】
|   |   |-- ErrorHandle.ts				# 异常处理
|   |   |-- NotFound.ts					# 404处理
|   |   |-- Result.ts					# 封装通用响应函数（succ、err、result）
|   |-- routes							## 【http url路由】
|   |   |-- ExampleRoute.ts
|   |   |-- GameRoute.ts
|   |   |-- RoomRoute.ts
|   |   |-- UserRoute.ts
|   |   |-- index.ts					# 自动导入所有路由
|   |-- utils							## 【工具类】
|   |   |-- ArrayUtil.ts				# 数组工具类（数据交互函数）
|   |   |-- PokerUtil.ts				# 扑克牌工具类（排序、牌型校验、牌组比较等）
|   |   |-- RandomUtil.ts				# 随机函数封装
|   |-- websocket						## 【socket管理】
|       |-- GameNotifier.ts				# 游戏相关通知
|       |-- SocketManager.ts			# 用户管理所有socket对象，将user.id和socket对象关联
|-- test								## 单元测试
|   |-- PokerUtil.test.ts				# PokerUtil.ts的测试（测试牌组校验、排序、以及牌组大小比较）
|   |-- TestCode.ts
|-- package-lock.json
|-- package.json

/**
 * 游戏相关的Socket事件
 */
export enum SocketGameEvent {
  CHANGE_STAGE = 'ctx-game-stage',        // 修改游戏阶段
  PREPARE = 'ctx-game-prepare',           // 有人准备/取消准备
  DEAL = 'ctx-game-deal',                 // 系统发牌
  SET_CALL_PLAYER = 'ctx-game-set-call-player',         // 系统通知轮到谁叫地主
  CALL = 'ctx-game-call',                 // 有人叫地主/不叫地主
  SET_LANDLORD = 'ctx-game-set-landlord', // 系统设置地主
  SET_PLAY = 'ctx-game-set-play',         // 系统通知轮到谁出牌
  PLAY_CARDS = 'ctx-game-play-cards',     // 有人出牌/不出牌
  RESULT = 'ctx-game-result',             // 游戏结果
}

/**
 * 游戏阶段
 */
export enum GameStage {
  PREPARATION = 0,        // 准备阶段
  REFEREE_DEEL = 1,       // 发牌阶段
  CALL_LANDLORD = 2,      // 叫地主阶段
  GAMING = 3,             // 游戏中（玩家轮流出牌）
  SETTLEMENT = 4,         // 结算中
}

// Poker.ts
export class Poker implements IPokerVo {
    // ...
    /**
     * 用于比较大小
     */
    public get value() {
        return this.suit + this.pointWeight * 100
    }
    // ...
}

// PokerUtil.ts
 /**
   * 对一副牌从大到小排序
   * @param cards 
   * @returns 
   */
public static sort(cards: Array<IPokerVo>) {
    return cards.sort((c1: IPokerVo, c2: IPokerVo) => {
        const poker1 = new Poker(c1)
        const poker2 = new Poker(c2)
        return poker1.compare(poker2)
    }).reverse()
}

 // PokerUtil.ts
 /**
   * 检测一副牌的牌型（hand会将cards牌组排序）
   * @param cards 
   */
  public static hand(cards: Array<IPokerVo>): PokerHand {
    // 每张牌是否唯一（安全校验）
    if (!this.isOnly(cards)) {
      return PokerHand.NONE
    }
      
    // 排序
    cards = this.sort(cards)

    const count = cards.length
    // 按牌数划分检测逻辑
    if (count === 1) {
      // 单张
      return PokerHand.T_A
    } else if (count === 2) {
      if (this.isSame(cards)) {
        // 对子
        return PokerHand.T_AA
      } else if (this.isRocket(cards)) {
        // 王炸（火箭）
        return PokerHand.T_ROCKET
      }
    } else if (count === 3) {
      if (this.isSame(cards)) {
        // 三张
        return PokerHand.T_AAA
      }
    } else if (count === 4) {
      if (this.isSame(cards)) {
        // 炸弹
        return PokerHand.T_AAAA
      }
      else if (this.isAAAB(cards)) {
        // 三带一
        return PokerHand.T_AAA_B
      }
    } else if (count >= 5) {
      if (this.isABCDE(cards)) {
        // 顺子
        return PokerHand.T_ABCDE
      } else if (this.isAAABB(cards)) {
        // 三带二，三带两对 AAA BC / AAA BBCC
        return PokerHand.T_AAA_BB
      } else if (this.isAABBCC(cards)) {
        // 双顺子 AABBCC
        return PokerHand.T_AABBCC
      } else if (this.isAAABBB(cards)) {
        // 三顺子(飞机) AAABBB
        return PokerHand.T_AAABBB
      }else if (this.isAAABBBCD(cards)) {
        // 飞机带翅膀 AAABBB CD / AAABBB CCDD
        return PokerHand.T_AAABBB_CD
      }
    }

    return PokerHand.NONE
  }

 // PokerUtil.ts
 /**
   * 判断cards2能否压cards1
   * @param cards1 
   * @param cards2
   */
  public static legal(cards1: Array<IPokerVo>, cards2: Array<IPokerVo>): boolean {
    // 获取牌组牌型，并且对牌组进行排序
    const hand1 = this.hand(cards1)
    const hand2 = this.hand(cards2)

    if (hand1 == PokerHand.T_ROCKET || hand2 == PokerHand.NONE) {
      // cards1是王炸，直接false
      // cards2没有牌型，直接false
      return false
    }

    //  && hand2 != PokerHand.NONE
    if (hand1 == PokerHand.NONE) {
      // cards1没有牌型，cards2有牌型（上一个if已确定） 直接true
      return true
    }

    if (hand1 === hand2 && cards1.length === cards2.length) {
      // 牌型相等、并且牌数相同
      switch (hand1) {
        // 单张
        case PokerHand.T_A:
        // 对子
        case PokerHand.T_AA:
        // 三张
        case PokerHand.T_AAA:
        // 炸弹
        case PokerHand.T_AAAA:
        // 顺子
        case PokerHand.T_ABCDE:
        // 双顺子
        case PokerHand.T_AABBCC:
        // 三顺子
        case PokerHand.T_AAABBB:
          // 比较最后一张点数权重的大小
          if (this.compareLastByPointWeight(cards1, cards2) < 0) {
            return true
          }
          break;
        // 飞机带翅膀
        case PokerHand.T_AAABBB_CD:
          const cards1By3 = this.getThreeSomeArr(cards1)
          const cards2By3 = this.getThreeSomeArr(cards2)
          // 比较最后一张点数权重的大小
          if (this.compareLastByPointWeight(cards1By3, cards2By3) < 0) {
            return true
          }
          break;
        // 三带一
        case PokerHand.T_AAA_B:
        // 三带二、三带两对
        case PokerHand.T_AAA_BB:
          const card1 = this.getThreeSome(cards1)
          const card2 = this.getThreeSome(cards2)
          if (!card1 || !card2) {
            throw new Error('no three are the same')
          }
          if (this.compareLastByPointWeight([card1], [card2]) < 0) {
            return true
          }
          break;
      }

    } else if (hand1 !== hand2) {
      // 牌型不相等；牌数可相等，也可不相等
      // cards2是王炸、炸弹，可以直接压
      if (hand2 === PokerHand.T_ROCKET || hand2 === PokerHand.T_AAAA) {
        return true
      }
    }

    // 牌型相等，但是牌数不相等，直接false
    return false
  }

// PokerManager.ts
/**
 * 扑克牌管理类
 */
export default class PokerManager {
  // ...

  // 获取一副牌
  public getDeck(): Poker[] {
    let cards: Array<Poker> = []
    // 花色
    // SPADE = 3,    // 黑桃♠
    // HEARD = 2,    // 红桃♥
    // CLUB = 1,     // 梅花♣
    // DIAMOND = 0,  // 方块♦
    const suits = [PokerSuits.DIAMOND, PokerSuits.CLUB, PokerSuits.HEARD, PokerSuits.SPADE]
    // 牌值
    const points = [
      PokerPoints.P_A, PokerPoints.P_2, PokerPoints.P_3, PokerPoints.P_4, PokerPoints.P_5,
      PokerPoints.P_6, PokerPoints.P_7, PokerPoints.P_8, PokerPoints.P_9, PokerPoints.P_10,
      PokerPoints.P_J, PokerPoints.P_Q, PokerPoints.P_K
    ]

    suits.forEach(suit => {
      points.forEach(point => {
        cards.push(new Poker({ suit, point }))
      })
    })

    // 大小王
    cards.push(new Poker({
      suit: PokerSuits.NONE,
      point: PokerPoints.P_RJ
    }))
    cards.push(new Poker({
      suit: PokerSuits.NONE,
      point: PokerPoints.P_BJ
    }))

    // 洗牌
    this.shuffle(cards)

    return cards
  }

  /**
   * 洗牌
   * @param cards 
   */
  public shuffle(cards: Poker[]) {
    // 两两随机交换
    for (let i = 0; i < cards.length; i++) {
      const i1 = RandomUtil.getRangeInt(0, cards.length)
      const i2 = RandomUtil.getRangeInt(0, cards.length)
      // 交换
      ArrayUtil.swap(cards, i1, i2)
    }
  }
}

// Peferee.ts
/**
 * 裁判类
 * 管理房间的游戏流程和规则
 */
export default class Referee {
  private players: Array<Player | undefined> = []         // 玩家集合

  /**
   * 发牌
   */
  public deal() {
    // 生成一副扑克牌
    const cards = PokerManager.instance.getDeck()

    // 取出3张地主牌
    this._landlordCards = []
    for (let i = 0; i < 3; i++) {
      const card = cards.pop()
      if (card != undefined) {
        this._landlordCards.push(card)
      }
    }

    // 发牌
    for (let i = 0; i < 3; i++) {
      const player = this.players[i]
      if (player === undefined) {
        throw new Error(`[referee] player is undefined`)
      }
      player.initCards(cards.splice(0, 17)) // 17张牌
      // console.log('[referee] player.cards:', player.cards)
    }

    // 设为发牌阶段
    this.stage = GameStage.REFEREE_DEAL

  }
}

//Referee.ts
 /**
   * 获取下一个叫地主的玩家
   * 说明：
   * - 地主归属权为最后一个执行【叫地主】的玩家；
   * - 所有人都不叫地主，那么第一个开始执行【叫地主/不叫地主】操作的玩家不需要再执行操作，直接返回null，系统要重新发牌
   * - 仅有1人叫地主，那么ta不需要再执行一次【叫地主/不叫地主】操作，直接归属ta为地主，并且函数返回null
   * - 2人及以上（包含所有人）叫地主，那么第一次【叫地主】的玩家，需要再执行一次【叫地主/不叫地主】操作
   * @returns 玩家对象 | null；玩家对象表示下一个执行【叫地主/不叫地主的玩家】；null表示没有下一个玩家了，叫地主环节结束。
   * 可以通过get landlordPlayer() 获取地主玩家对象
   */
  public nextCallLandloardPlayer(): Player | null {
    // 结束叫地主阶段
    if (this.isEndCall) {
      return null
    }

    // 往右遍历为顺时针
    this.currentRoundPlayerIndex++
    if (this.currentRoundPlayerIndex >= this.players.length) {
      this.currentRoundPlayerIndex = 0
    }

    // 表示轮完了一圈
    if (this.beginCallPlayerIndex == this.currentRoundPlayerIndex) {
      this.isEndCall = true

      // 判断是否还需要由第一个【叫地主】的玩家确定地主归属权
      if (this.isAllPlayerNotCallLand()) {
        // 没人叫地主，直接返回null
        return null
      } else if (this.isOnePlayerCallLand()) {
        console.log('this.isOnePlayerCallLand():', true)
        // 只有一人叫地主，并且返回null
        return null
      } else {
        // 2个或以上玩家叫地主，将由第一个执行【叫地主】的玩家决定地主归属权
        this.currentRoundPlayerIndex = this._firstCallLandPlayerIndex
      }
    }

    // 当前回合玩家对象
    const player = this.players[this.currentRoundPlayerIndex]
    if (player === undefined) {
      throw new Error(`[referee] player is undefined`)
    }

    return player
  }

npm test

// SocketManger.ts
/**
 * 客户端socket对象管理类
 * 根据用户id保存对应的socket对象，方便http和socket进行关系对应
 * 注意：用户连接时必须在auth中携带用户uid才可以socket连接
 */
export default class SocketManager {
  private clientSockets: Map<uid, Socket>                 // 根据用户id保存用户socket对象
  private connectCallbacks: Set<ConnectCallbackFn>        // 连接回调函数集合

  private _io: Server = null!

  /**
   * 客户端连接回调
   * @param socket 
   */
  private onConnect(socket: Socket): void {
    // 获取用户id
    const { uid } = socket.handshake.auth
    // 无用户id，则不需进行下面的步骤（无效登录连接）
    // token校验...
    if (uid == null) {
      socket.disconnect()
      return
    }
    console.log('[socket] client connected, its uid is:', uid, socket.id)
    // 保存socket
    this.clientSockets.set(uid, socket)
    // 通知监听事件
    this.connectCallbacks.forEach(fn => { fn(uid, socket) })
    // 监听离开
    socket.on('disconnect', this.onDisconnect(uid, socket))
  }
}