Dream使用说明书

import { Room, Delayed, Client } from "colyseus";
import { type, Schema, MapSchema, ArraySchema } from '@colyseus/schema';

// 一个回合的时间(秒)
const TURN_TIMEOUT = 10
// 棋盘宽度
const BOARD_WIDTH = 3

class Player extends Schema {
    @type('string')
    id: string
    @type('string')
    name: string
}

// 状态同步的内容
class State extends Schema {
    @type('string')
    currentTurn: string
    @type({map: Player })
    players = new MapSchema<Player>()
    @type(['number'])
    board: number[] = new ArraySchema<number>(0, 0, 0, 0, 0, 0, 0, 0, 0);
    @type('string')
    winner: string
    @type('boolean')
    draw: boolean
}


export class TicTacTocRoom extends Room<State> {
	maxClients = 2
	randomMoveTimeout: Delayed

	onCreate (options: any) {
        this.setState(new State())
        // 消息回调
        this.onMessage("*", this.messageHandler.bind(this))

	}

	messageHandler(client: Client, type: any, message: any) {
		// 当前已经有赢家或者为平局
		if (this.state.winner || this.state.draw) {
			return
		}
		// 当前玩家的回合
		if (client.sessionId === this.state.currentTurn) {
		let data: any = message
		const playerIds = Object.keys(this.state.players)
		const index = data.x + BOARD_WIDTH * data.y
		if (this.state.board[index] === 0) {
			const move = (client.sessionId === playerIds[0]) ? 1 : 2
			this.state.board[index] = move
			if (this.checkWin(data.x, data.y, move)) {
			this.state.winner = client.sessionId
			} else if (this.checkBoardComplete()) {
			this.state.draw = true;
			} else {
			// 获取另一个玩家的id
			const otherPlayerSessionId = (client.sessionId === playerIds[0]) ? playerIds[1] : playerIds[0]
			// 设置当前的轮回
			this.state.currentTurn = otherPlayerSessionId
			// 开启自动移动定时器
			this.setAutoMoveTimeout()
			}
		}
		}
	}

	onJoin (client: Client, options: any) {
		let player = new Player()
		player.id = client.sessionId
		player.name = options.name || this.randomName()
		this.state.players[client.sessionId] = player
		if (Object.keys(this.state.players).length === 2) {
			// 当前的turn
			this.state.currentTurn = client.sessionId
			this.setAutoMoveTimeout()
			// 锁定当前的房间
			this.lock()
		}
	}

	randomName() {
		return ~~(Math.random() * 10000) + ''
	}

	// 设置自动移动的定时器
	setAutoMoveTimeout() {
		if (this.randomMoveTimeout) {
			this.randomMoveTimeout.clear()
		}
		this.randomMoveTimeout = this.clock.setTimeout(() => this.doRandomMove(), TURN_TIMEOUT * 1000)
	}

  	// 随机移动
	doRandomMove() {
		const sessionId = this.state.currentTurn
		for (let x=0; x<BOARD_WIDTH; x++) {
			for (let y=0; y<BOARD_WIDTH; y++) {
			const index = x + BOARD_WIDTH * y;
			if (this.state.board[index] === 0) {
				this.messageHandler({ sessionId } as Client, 'pos' ,{ x, y })
				return;
			}
			}
		}
	}

  	// 检测当前的底板是否已经满了
	checkBoardComplete() {
		return this.state.board.filter(item => item === 0).length === 0;
	}

	// 检测是否成功
	checkWin (x: number, y: number, move: number) {
		let won = false
		let board = this.state.board
		// 横向
		for(let y = 0; y < BOARD_WIDTH; y++){
			const i = x + BOARD_WIDTH * y
			if (board[i] !== move) { break }
			if (y == BOARD_WIDTH-1) {
				won = true
			}
		}

		// 纵向
		for(let x = 0; x < BOARD_WIDTH; x++){
			const i = x + BOARD_WIDTH * y
			if (board[i] !== move) { break }
			if (x == BOARD_WIDTH-1) {
				won = true;
			}
		}

		// 交叉
		if(x === y) {
			for (let xy = 0; xy < BOARD_WIDTH; xy++){
			const i = xy + BOARD_WIDTH * xy
			if (board[i] !== move) { break }
			if (xy == BOARD_WIDTH-1) {
				won = true;
			}
			}
		}

		for (let x = 0; x < BOARD_WIDTH; x++) {
			const y = (BOARD_WIDTH - 1) - x
			const i = x + BOARD_WIDTH * y
			if (board[i] !== move) { break }
			if (x == BOARD_WIDTH - 1){
				won = true
			}
		}

		return won
	}

	onLeave (client: Client, consented: boolean) {
		// 删除当前离开的玩家
		delete this.state.players[ client.sessionId ]
		// 清除自动移动的定时器
		if (this.randomMoveTimeout) {
			this.randomMoveTimeout.clear()
		}
		// 获取剩余玩家
		let remainingPlayerIds = Object.keys(this.state.players)
		if (remainingPlayerIds.length > 0) {
			// 设置当前玩家为赢家
			this.state.winner = remainingPlayerIds[0]
		}
	}

	onDispose() {

	}

}

import OXChess from "./OXChess";

const {ccclass, property} = cc._decorator;

const enum ResultType {
    WIN,
    LOSE,
    DRAW
}

const enum GameState {
    NON,
    MATCH,
    GAME,
    RESULT
}

@ccclass
export default class TicTacToe extends cc.Component {
    client: Colyseus.Client
    room: Colyseus.Room
    gameState: GameState = GameState.NON

    @property() host: string = ''
    @property(cc.Node) boardNode: cc.Node = null
    @property(cc.Node) matchingLayer: cc.Node = null
    @property(cc.Node) resultLayer: cc.Node = null
    @property(cc.Label) turnLabel: cc.Label = null
    @property(cc.Label) timeLabel: cc.Label = null
    @property(cc.Label) resultLabel: cc.Label = null
    @property(cc.Button) matchBtn: cc.Button = null
    @property(cc.EditBox) nameEditBox: cc.EditBox = null
    @property(cc.Label) yourName: cc.Label = null
    @property(cc.Label) otherName: cc.Label = null
    curTurn: string
    turnTimer: any
    time: number = 0
    playerMap: Map<string, {name: string, id: string}> = new Map<string, {name: string, id: string}>()

    start() {
        this.matchBtn.node.on('click', () => {
            this.resultLayer.active = false
            this.matchBtn.node.active = false
            this.startMatch()
        })

        this.boardNode.children.forEach((node: cc.Node, i: number) => {
            node.on(cc.Node.EventType.TOUCH_START, () => {
                if (this.gameState != GameState.GAME) {
                    return
                }
                this.room.send('pos', { x: (i % 3) , y: ~~(i / 3)})
            })
        })
        this.client = new Colyseus.Client(this.host)
    }


    startMatch() {
        this.gameState = GameState.MATCH
        this.matchingLayer.active = true
        this.nameEditBox.node.active = false
        this.client.joinOrCreate('tictactoc', {name: this.nameEditBox.string}).then(room => {
            this.room = room
            room.state.players.onAdd = (player: any) => {
                this.playerMap.set(player.id, player)
                if (room.sessionId === player.id) {
                    this.yourName.string = player.name
                } else {
                    this.otherName.string = player.name
                }
            }
            room.state.players.onChange = (player: any) => {
                this.playerMap.set(player.id, player)
            }
            room.state.players.onRemove= (player: any) => {
                this.playerMap.delete(player.id)
            }

            room.onStateChange(state => {
                if (this.gameState == GameState.MATCH && Object.keys(room.state.players).length === 2) {
                    this.curTurn = state.currentTurn
                    this.startGame()
                }
                if (state.draw) {
                    this.gameResult(ResultType.DRAW)
                }
                if (state.winner) {
                    if (this.room.sessionId === state.winner) {
                        this.gameResult(ResultType.WIN)
                    } else {
                        this.gameResult(ResultType.LOSE)
                    }
                }
                if (this.gameState == GameState.GAME) {
                    this.turnLabel.string = this.room.sessionId === state.currentTurn ? '你的回合' : '对手回合'
                }
                // 棋局
                this.boardNode.children.forEach((node: cc.Node, i: number) => {
                    let chess = node.getComponent(OXChess)
                    if (this.gameState == GameState.GAME && chess.getCurIndex() == 0 && state.board[i] != 0) {
                        this.changeTurn()
                    }
                    chess.setIcon(state.board[i])
                })
            })
        }) as any
    }

    startGame() {
        this.gameState = GameState.GAME
        this.matchingLayer.active = false
        
        this.changeTurn()
    }

    gameResult(type: ResultType) {
        this.gameState = GameState.RESULT
        this.matchBtn.node.active = true
        this.resultLayer.active = true
        this.nameEditBox.node.active = true
        this.yourName.string = ''
        this.otherName.string = ''
        this.playerMap.clear()
        switch(type) {
            case ResultType.WIN: {
                this.resultLabel.string = '赢就是这样简单'
                break
            }
            case ResultType.LOSE: {
                this.resultLabel.string = '失败也是一种进步'
                break
            }
            case ResultType.DRAW: {
                this.resultLabel.string = '和棋是一种态度'
                break
            }
        }
        this.turnLabel.string = '未知'
        this.timeLabel.string = '0'
        if (this.turnTimer) {
            clearInterval(this.turnTimer)
        }
    }

    changeTurn() {
        this.time = 10
        this.timeLabel.string = this.time + ''
        if (this.turnTimer) {
            clearInterval(this.turnTimer)
        }
        this.turnTimer = setInterval(() => {
            this.time--
            if (this.time < 0) {
                this.time = 0
            }
            this.timeLabel.string = this.time + ''
        }, 1000)
    }
    // update (dt) {}
}

const {ccclass, property} = cc._decorator;

@ccclass
export default class OXChess extends cc.Component {

    @property([cc.SpriteFrame])
    chessIcons: cc.SpriteFrame[] = []

    @property(cc.Sprite)
    icon: cc.Sprite = null

    curIndex: number = 0

    setIcon(id: number) {
        switch(id) {
            case 0: {
                this.icon.spriteFrame = null
                break
            }
            case 1: {
                this.icon.spriteFrame = this.chessIcons[0]
                break
            }
            case 2: {
                this.icon.spriteFrame = this.chessIcons[1]
                break
            }
        }
        this.curIndex = id
    }

    getCurIndex() {
        return this.curIndex
    }
}

import { Room, Delayed, Client } from "colyseus";
import { type, Schema, MapSchema, ArraySchema } from '@colyseus/schema';

// 一个回合的时间
const TURN_TIMEOUT = 10
// 棋盘宽度
const BOARD_WIDTH = 13

class Player extends Schema {
    @type('string')
    id: string
    @type('string')
    name: string
}

const boardMap = [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]

// 状态同步的内容
class State extends Schema {
    @type('string')
    currentTurn: string
    @type({map: Player })
    players = new MapSchema<Player>()
    @type(['number'])
    board: number[] = new ArraySchema<number>(...boardMap)
    @type('string')
    winner: string
    @type('boolean')
    draw: boolean
}


export class FiveRoom extends Room<State> {
    maxClients = 2
    randomMoveTimeout: Delayed

    onCreate (options: any) {
        this.setState(new State())
        // 消息回调
        this.onMessage("pos", this.posMessageHandler.bind(this))
        this.onMessage("ai", (client: Client, message: any) => {
            this.posMessageHandler(client, this.useAiMove())
        })
    }

    posMessageHandler(client: Client, message: any) {
        // 当前已经有赢家或者为平局
        if (this.state.winner || this.state.draw) {
            return
        }
        // 当前玩家的回合
        if (client.sessionId === this.state.currentTurn) {
            let data: any = message
            const playerIds = Object.keys(this.state.players)
            const index = data.x + BOARD_WIDTH * data.y
            if (this.state.board[index] === 0) {
            const move = (client.sessionId === playerIds[0]) ? 1 : 2
            this.state.board[index] = move
            if (this.checkWin(data.x, data.y, move)) {
                this.state.winner = client.sessionId
            } else if (this.checkBoardComplete()) {
                this.state.draw = true;
            } else {
                // 获取另一个玩家的id
                const otherPlayerSessionId = (client.sessionId === playerIds[0]) ? playerIds[1] : playerIds[0]
                // 设置当前的轮回
                this.state.currentTurn = otherPlayerSessionId
                // 开启自动移动定时器
                this.setAutoMoveTimeout()
            }
            }
        }
    }

    onJoin (client: Client, options: any) {
        let player = new Player()
        player.id = client.sessionId
        player.name = options.name || this.randomName()
        this.state.players[client.sessionId] = player
        if (Object.keys(this.state.players).length === 2) {
            // 当前的turn
            this.state.currentTurn = client.sessionId
            this.setAutoMoveTimeout()
            // 锁定当前的房间
            this.lock()
        }
    }

    randomName() {
        return ~~(Math.random() * 10000) + ''
    }

    // 设置自动移动的定时器
    setAutoMoveTimeout() {
        if (this.randomMoveTimeout) {
            this.randomMoveTimeout.clear()
        }
        this.randomMoveTimeout = this.clock.setTimeout(() => this.doRandomMove(), TURN_TIMEOUT * 1000)
    }

    useAiMove() : {x: number, y: number} {
        const playerIds = Object.keys(this.state.players)
        const move = (this.state.currentTurn === playerIds[0]) ? 1 : 2
        let maxX = 0,
			maxY = 0,
			maxWeight = 0,
			i, j, tem
		for (i = 14; i >= 0; i--) {
			for (j = 14; j >= 0; j--) {
				if (this.getChessColor(i, j) !== 0) {
					continue
				}
				tem = this.computeWeight(i, j, move)
				if (tem > maxWeight) {
					maxWeight = tem
					maxX = i
					maxY = j
				}
			}
		}
        return {x: maxX, y: maxY}
    }

    // 随机移动
    doRandomMove() {
        // 当前的id
        const sessionId = this.state.currentTurn
        this.posMessageHandler({ sessionId } as Client, this.useAiMove())
        
        // for (let x=0; x<BOARD_WIDTH; x++) {
        //     for (let y=0; y<BOARD_WIDTH; y++) {
        //         const index = x + BOARD_WIDTH * y;
        //         if (this.state.board[index] === 0) {
        //             this.messageHandler({ sessionId } as Client, 'pos' ,{ x, y })
        //             return;
        //         }
        //     }
        // }
    }

    //计算下子至i,j的权重
    computeWeight(i: number, j: number, move: number) {
        var weight = 14 - (Math.abs(i - 7) + Math.abs(j - 7)), //基于棋盘位置权重
            pointInfo: any = {},	//某点下子后连子信息
            chessColor = move
        //x方向
        pointInfo = this.putDirectX(i, j, chessColor);
        weight += this.weightStatus(pointInfo.nums, pointInfo.side1, pointInfo.side2, true);//AI下子权重
        pointInfo = this.putDirectX(i, j, -chessColor);
        weight += this.weightStatus(pointInfo.nums, pointInfo.side1, pointInfo.side2, false);//player下子权重
        //y方向
        pointInfo = this.putDirectY(i, j, chessColor);
        weight += this.weightStatus(pointInfo.nums, pointInfo.side1, pointInfo.side2, true);//AI下子权重
        pointInfo = this.putDirectY(i, j, -chessColor);
        weight += this.weightStatus(pointInfo.nums, pointInfo.side1, pointInfo.side2, false);//player下子权重
        //左斜方向
        pointInfo = this.putDirectXY(i, j, chessColor);
        weight += this.weightStatus(pointInfo.nums, pointInfo.side1, pointInfo.side2, true);//AI下子权重
        pointInfo = this.putDirectXY(i, j, -chessColor);
        weight += this.weightStatus(pointInfo.nums, pointInfo.side1, pointInfo.side2, false);//player下子权重
        //右斜方向
        pointInfo = this.putDirectYX(i, j, chessColor);
        weight += this.weightStatus(pointInfo.nums, pointInfo.side1, pointInfo.side2, true);//AI下子权重
        pointInfo = this.putDirectYX(i, j, -chessColor);
        weight += this.weightStatus(pointInfo.nums, pointInfo.side1, pointInfo.side2, false);//player下子权重
        return weight;
    }
    // 下子到i，j X方向 结果: 多少连子 两边是否截断
    putDirectX(i: number, j: number, chessColor: number) {
		var m, n,
			nums = 1,
			side1 = false,
			side2 = false
		for (m = j - 1; m >= 0; m--) {
			if (this.getChessColor(i, m) === chessColor) {
				nums++;
			}
			else {
				if (this.getChessColor(i, m) === 0) {
					side1 = true;
				}
				break;
			}
		}
		for (m = j + 1; m < 15; m++) {
			if (this.getChessColor(i, m) === chessColor) {
				nums++;
			}
			else {
				if (this.getChessColor(i, m)=== 0) {
					side2 = true;
				}
				break;
			}
		}
		return {"nums": nums, "side1": side1, "side2": side2}
    }
    
    // 下子到i，j Y方向 结果
	putDirectY(i: number, j: number, chessColor: number) {
		let m, n,
			nums = 1,
			side1 = false,
			side2 = false
		for (m = i - 1; m >= 0; m--) {
			if (this.getChessColor(m, j) === chessColor) {
				nums++
			} else {
				if (this.getChessColor(m, j) === 0) {
					side1 = true
				}
				break
			}
		}
		for (m = i + 1; m < 15; m++) {
			if (this.getChessColor(m, j) === chessColor) {
				nums++
			} else {
				if (this.getChessColor(m, j) === 0) {
					side2 = true
				}
				break
			}
		}
		return {"nums": nums, "side1": side1, "side2": side2}
    }
    
    //下子到i，j XY方向 结果
	putDirectXY(i: number, j: number, chessColor: number) {
		let m, n,
			nums = 1,
			side1 = false,
			side2 = false;
		for (m = i - 1, n = j - 1; m >= 0 && n >= 0; m--, n--) {
			if (this.getChessColor(m, n) === chessColor) {
				nums++
			} else {
				if (this.getChessColor(m, n) === 0) {
					side1 = true
				}
				break
			}
		}
		for (m = i + 1, n = j + 1; m < 15 && n < 15; m++, n++) {
			if (this.getChessColor(m, n) === chessColor) {
				nums++
			} else {
				if (this.getChessColor(m, n) === 0) {
					side2 = true
				}
				break
			}
		}
		return {"nums": nums, "side1": side1, "side2": side2};
    }
    
    putDirectYX(i: number, j: number, chessColor: number) {
		let m, n,
			nums = 1,
			side1 = false,
			side2 = false
		for (m = i - 1, n = j + 1; m >= 0 && n < 15; m--, n++) {
			if (this.getChessColor(m, n) === chessColor) {
				nums++
			} else {
				if (this.getChessColor(m, n) === 0) {
					side1 = true
				}
				break;
			}
		}
		for (m = i + 1, n = j - 1; m < 15 && n >= 0; m++, n--) {
			if (this.getChessColor(m, n) === chessColor) {
				nums++
			} else {
				if (this.getChessColor(m, n) === 0) {
					side2 = true
				}
				break
			}
		}
		return {"nums": nums, "side1": side1, "side2": side2}
	}
    
    // 权重方案   独：两边为空可下子，单：一边为空
	weightStatus(nums: number, side1: number, side2: number, isAI: boolean) {
		let weight = 0
		switch (nums) {
			case 1:
				if (side1 && side2) {
					weight = isAI ? 15 : 10;	//独一
				}
				break
			case 2:
				if (side1 && side2) {
					weight = isAI ? 100 : 50;	//独二
				}
				else if (side1 || side2) {
					weight = isAI ? 10 : 5;	//单二
				}
				break
			case 3:
				if (side1 && side2) {
					weight = isAI ? 500 : 200;	//独三
				}
				else if (side1 || side2) {
					weight = isAI ? 30 : 20;	//单三
				}
				break
			case 4:
				if (side1 && side2) {
					weight = isAI ? 5000 : 2000;	//独四
				}
				else if (side1 || side2) {
					weight = isAI ? 400 : 100;	//单四
				}
				break
			case 5:
				weight = isAI ? 100000 : 10000;	//五
				break
			default:
				weight = isAI ? 500000 : 250000;
				break
		}
		return weight
	}

    // 检测当前的底板是否已经满了
    checkBoardComplete() {
        return this.state.board.filter(item => item === 0).length === 0;
    }

    getChessColor(x: number, y: number) {
        return this.state.board[x + BOARD_WIDTH * y]
    }

    // 检测是否成功
    checkWin (i: number, j: number, move: number) : boolean {
		let num = 1, chessColor = move, m = 0, n = 0
		//x方向
		for (m = j - 1; m >= 0; m--) {
			if (this.getChessColor(i, m) === chessColor) {
				num++;
			}
			else {
				break;
			}
		}
		for (m = j + 1; m < 15; m++) {
			if (this.getChessColor(i, m) === chessColor) {
				num++
			}
			else {
				break;
			}
		}
		if (num >= 5) {
			return true
		} else {
			num = 1
		}
		//y方向
		for (m = i - 1; m >= 0; m--) {
			if (this.getChessColor(m, j) === chessColor) {
				num++
			} else {
				break
			}
		}
		for (m = i + 1; m < 15; m++) {
			if (this.getChessColor(m, j)  === chessColor) {
				num++
			} else {
				break
			}
		}
		if (num >= 5) {
			return true
		} else {
			num = 1
		}
		//左斜方向
		for (m = i - 1, n = j - 1; m >= 0 && n >= 0; m--, n--) {
			if (this.getChessColor(m, n) === chessColor) {
				num++
			} else {
				break
			}
		}
		for (m = i + 1, n = j + 1; m < 15 && n < 15; m++, n++) {
			if (this.getChessColor(m, n) === chessColor) {
				num++
			} else {
				break
			}
		}
		if (num >= 5) {
			return true
		} else {
			num = 1
		}
		//右斜方向
		for (m = i - 1, n = j + 1; m >= 0 && n < 15; m--, n++) {
			if (this.getChessColor(m, n) === chessColor) {
				num++
			} else {
				break
			}
		}
		for (m = i + 1, n = j - 1; m < 15 && n >= 0; m++, n--) {
			if (this.getChessColor(m, n) === chessColor) {
				num++
			} else {
				break
			}
		}
		if (num >= 5) {
			return true
        }
        return false
    }

    onLeave (client: Client, consented: boolean) {
        // 删除当前离开的玩家
        delete this.state.players[ client.sessionId ]
        // 清除自动移动的定时器
        if (this.randomMoveTimeout) {
            this.randomMoveTimeout.clear()
        }
        // 获取剩余玩家
        let remainingPlayerIds = Object.keys(this.state.players)
        if (remainingPlayerIds.length > 0) {
            // 设置当前玩家为赢家
            this.state.winner = remainingPlayerIds[0]
        }
    }

    onDispose() {

    }

}

import FiveChess from "./FiveChess";

const {ccclass, property} = cc._decorator;

const enum ResultType {
    WIN,
    LOSE,
    DRAW
}

const enum GameState {
    NON,
    MATCH,
    GAME,
    RESULT
}

@ccclass
export default class FiveGame extends cc.Component {

    client: Colyseus.Client
    room: Colyseus.Room
    gameState: GameState = GameState.NON

    @property() host: string = ''
    @property(cc.Node) boardNode: cc.Node = null
    @property(cc.Node) matchingLayer: cc.Node = null
    @property(cc.Node) resultLayer: cc.Node = null
    @property(cc.Label) turnLabel: cc.Label = null
    @property(cc.Label) timeLabel: cc.Label = null
    @property(cc.Label) resultLabel: cc.Label = null
    @property(cc.Button) matchBtn: cc.Button = null
    @property(cc.EditBox) nameEditBox: cc.EditBox = null
    @property(cc.Label) yourName: cc.Label = null
    @property(cc.Label) otherName: cc.Label = null
    @property(cc.Button) aiButton: cc.Button = null
    curTurn: string
    turnTimer: any
    time: number = 0
    playerMap: Map<string, {name: string, id: string}> = new Map<string, {name: string, id: string}>()
    useAi: boolean = false

    start () {

        this.aiButton.node.on('click', () => {
            this.room.send('ai')
        })

        this.matchBtn.node.on('click', () => {
            this.resultLayer.active = false
            this.matchBtn.node.active = false
            this.startMatch()
        })

        this.boardNode.children.forEach((node: cc.Node, i: number) => {
            node.on(cc.Node.EventType.TOUCH_START, () => {
                console.log('点击')
                if (this.gameState != GameState.GAME) {
                    return
                }
                this.room.send('pos', { x: (i % 13) , y: ~~(i / 13)})
            })
        })
        this.client = new Colyseus.Client(this.host)
        this.cleanBoard()
    }

    cleanBoard() {
        this.boardNode.children.forEach((node: cc.Node) => {
            node.getComponent(FiveChess).setIcon(0)
        })
    }

    startMatch() {
        this.gameState = GameState.MATCH
        this.matchingLayer.active = true
        this.nameEditBox.node.active = false
        this.useAi = false
        if (this.nameEditBox.string == 'joker') {
            this.useAi = true
        }
        this.client.joinOrCreate('five', {name: this.nameEditBox.string}).then(room => {
            this.room = room
            room.state.players.onAdd = (player: any) => {
                this.playerMap.set(player.id, player)
                if (room.sessionId === player.id) {
                    this.yourName.string = player.name
                } else {
                    this.otherName.string = player.name
                }
            }
            room.state.players.onChange = (player: any) => {
                this.playerMap.set(player.id, player)
            }
            room.state.players.onRemove= (player: any) => {
                this.playerMap.delete(player.id)
            }

            room.onStateChange(state => {
                if (this.gameState == GameState.MATCH && Object.keys(room.state.players).length === 2) {
                    this.curTurn = state.currentTurn
                    this.startGame()
                }
                if (state.draw) {
                    this.gameResult(ResultType.DRAW)
                }
                if (state.winner) {
                    if (this.room.sessionId === state.winner) {
                        this.gameResult(ResultType.WIN)
                    } else {
                        this.gameResult(ResultType.LOSE)
                    }
                }
                if (this.gameState == GameState.GAME) {
                    this.turnLabel.string = this.room.sessionId === state.currentTurn ? '你的回合' : '对手回合'
                }
                // 棋局
                this.boardNode.children.forEach((node: cc.Node, i: number) => {
                    let chess = node.getComponent(FiveChess)
                    if (this.gameState == GameState.GAME && chess.getCurIndex() == 0 && state.board[i] != 0) {
                        this.changeTurn()
                    }
                    chess.setIcon(state.board[i])
                })
            })
        }) as any
    }

    startGame() {
        this.aiButton.node.active = this.useAi
        this.gameState = GameState.GAME
        this.matchingLayer.active = false
        this.changeTurn()
    }

    gameResult(type: ResultType) {
        this.gameState = GameState.RESULT
        this.matchBtn.node.active = true
        this.resultLayer.active = true
        this.nameEditBox.node.active = true
        this.aiButton.node.active = false
        this.yourName.string = ''
        this.otherName.string = ''
        this.playerMap.clear()
        switch(type) {
            case ResultType.WIN: {
                this.resultLabel.string = '赢就是这样简单'
                break
            }
            case ResultType.LOSE: {
                this.resultLabel.string = '失败也是一种进步'
                break
            }
            case ResultType.DRAW: {
                this.resultLabel.string = '和棋是一种态度'
                break
            }
        }
        this.turnLabel.string = '未知'
        this.timeLabel.string = '0'
        if (this.turnTimer) {
            clearInterval(this.turnTimer)
        }
    }

    changeTurn() {
        this.time = 10
        this.timeLabel.string = this.time + ''
        if (this.turnTimer) {
            clearInterval(this.turnTimer)
        }
        this.turnTimer = setInterval(() => {
            this.time--
            if (this.time < 0) {
                this.time = 0
            }
            this.timeLabel.string = this.time + ''
        }, 1000)
    }
}

const {ccclass, property} = cc._decorator;

@ccclass
export default class FiveChess extends cc.Component {

    @property([cc.SpriteFrame])
    chessIcons: cc.SpriteFrame[] = []

    @property(cc.Sprite)
    icon: cc.Sprite = null

    curIndex: number = 0

    setIcon(id: number) {
        switch(id) {
            case 0: {
                this.icon.spriteFrame = null
                break
            }
            case 1: {
                this.icon.spriteFrame = this.chessIcons[1]
                break
            }
            case 2: {
                this.icon.spriteFrame = this.chessIcons[0]
                break
            }
        }
        this.curIndex = id
    }

    getCurIndex() {
        return this.curIndex
    }
}

import { Server, Client, Packet, Authorizer } from 'mosca'

// 简单的设置方法
const setting = {
    // 监听的端口
    port: 12345,
    // 开启http的客户端
    http: {
        port: 12346,    // http的绑定端口
        bundle: true,   // 提供mqtt.js文件地址
    }
}

const server = new Server(setting)
const auth = new Authorizer()


server.on('clientConnected', (client: Client) => {
    console.log('客户端连接的ID：', client.id)
})

server.on('clientDisconnecting', (client: Client) => {
    console.log('客户端正在断连', client.id)
})

server.on('clientDisconnected', (client: Client) => {
    console.log('客户端已经断连', client.id)
})

server.on('published', (packet: Packet, client: Client) => {
    console.log('发布消息：', packet)
})

server.on('subscribed', (topic, client: Client) => {
    console.log('订阅主题：', topic)
})

server.on('unsubscribed', (topic, client: Client) => {
    console.log('取消订阅：', topic)
})

server.on('ready', () => {
    console.log('服务器启动成功！')
    // 简单的acl版本
    // server.authenticate = auth.authenticate
    // auth.addUser('limo', 'limo1234', '+', '+', (err) => {})

    // 自定义的校验方法
    server.authenticate = (client: Client, username: string, password: string, callback) => {
        if (username == 'limo' && password == 'limo123') {
            return callback(null, true)
        } else {
            return callback(null, false)
        }
    }

    server.authorizePublish = (client: Client, topic: string, payload: string, callback) => {
        return callback(null, true)
    }

    server.authorizeSubscribe = (client: Client, topic: string, callback) => {
        return callback(null, true)
    }
});

import { connect, Client } from 'mqtt'

const client: Client  = connect('mqtt://127.0.0.1:12345', {
    username: 'limo',
    password: 'limo123'
})

const topic = 'sys/log/now'

client.on('connect', () => {
    console.log('客户端连接成功！')
    client.subscribe(topic)
    setInterval(() => {
        client.publish(topic, new Date().toLocaleString())
    }, 1000)
})

client.on('error', (err) => {
    console.log('连接失败！')
    client.end()
})

client.on('message', (topic, message) => {
    console.log(`topic:${topic} message:${message}`)
})

import { RedPointKey, RedPointCalKey, RED_POINT_MESSAGE } from "./RedPointEnum";
import { RedPointControl } from "./RedPointControl";

const {ccclass, property} = cc._decorator;

@ccclass
export default class RedPoint extends cc.Component {
    // 红点条件key值
    @property({type: [cc.Enum(RedPointKey)], tooltip:"红点条件key值"})
    public keyArr:Array<RedPointKey> = []

    // 红点计算key值
    @property({type: [cc.Enum(RedPointCalKey)], tooltip:"红点计算key值"})
    public CalKeyArr: Array<RedPointCalKey> = []

    // 红点图片
    private redSprite:cc.Node = null;

    onLoad() {
        this.redSprite = this.node.getChildByName('redSprite')
        if(!this.redSprite) {
            this.redSprite = this.node
        }
        // 绑定监听
        cc.director.on(RED_POINT_MESSAGE, (calKey: RedPointCalKey) => {
            for(let v in this.CalKeyArr) {
                if (this.CalKeyArr[v] == calKey) {
                    this.updateUI()
                    return
                }
            }
        })
    }

    // 当界面的红点数据已经存在的时候，进入界面使用红点数据
    onEnable() {
        this.updateUI()
    }

    updateUI() {

        for (let v in this.keyArr) {
            let redKey = this.keyArr[v]
            let isShow = RedPointControl.getInstance().isShow(redKey)
            if (isShow) {
                this.redSprite.active = true
                return
            }
        }

        this.redSprite.active = false;
    }

}

/**
 * 红点的key
 *
 * @export
 * @enum {number}
 */
export enum RedPointKey {
    MIN = 0,
    k_BUTTON_1,
    k_BUTTON_2,
    k_BUTTON_3
}

/**
 * 红点的计算的key
 *
 * @export
 * @enum {number}
 */
export enum RedPointCalKey {
    MIN = 0,
    ck_TEST_BUTTON
}

// 红点的消息
export let RED_POINT_MESSAGE = 'RED_POINT_MESSAGE'

import { RedPointKey, RedPointCalKey, RED_POINT_MESSAGE } from "./RedPointEnum";
import { GameData } from "../script/util/GameData";

export class RedPointControl {
    private static _instance: RedPointControl
    private constructor() {}
    static getInstance() : RedPointControl {
        if (!RedPointControl._instance) {
            RedPointControl._instance = new RedPointControl()
        }
        return RedPointControl._instance
    }

    private pointData: Map<RedPointKey, boolean> = new Map<RedPointKey, boolean>()

    /**
     * 当前红点是否显示
     *
     * @param {RedPointKey} key
     * @returns {boolean}
     * @memberof RedPointControl
     */
    public isShow(key: RedPointKey) : boolean {
        return this.pointData.get(key)
    }

    /**
     * 设置当前的红点数据
     *
     * @private
     * @param {RedPointKey} key
     * @param {boolean} isShow
     * @memberof RedPointControl
     */
    private setPointData(key: RedPointKey, isShow: boolean) {
        this.pointData.set(key, isShow)
    }

    /**
     * 计算红点的方法类
     *
     * @param {RedPointCalKey} calKey
     * @memberof RedPointControl
     */
    public cal(calKey: RedPointCalKey) {
        switch(calKey) {
            case RedPointCalKey.ck_TEST_BUTTON: {
                this.setPointData(RedPointKey.k_BUTTON_1, GameData.getInstance().getFlag())
                this.setPointData(RedPointKey.k_BUTTON_2, GameData.getInstance().getFlag2())
                this.setPointData(RedPointKey.k_BUTTON_3, true)
            }
        }

        cc.director.emit(RED_POINT_MESSAGE, calKey)
    }

}

RedPointControl.getInstance().cal(RedPointCalKey.ck_TEST_BUTTON)

/**
 * 冒泡排序
 *
 * @param {Array<number>} array
 * @returns {Array<number>}
 */
function BubbleSort(array: Array<number>) : Array<number> {
    let retArray = [].concat(array)
    for (let i = 0, n = retArray.length; i < n; i++) {
        for (let j = 0; j < n  - i - 1; j++) {
            if (retArray[j] > retArray[j + 1]) {
                let temp = retArray[j]
                retArray[j] = retArray[j + 1]
                retArray[j + 1] = temp
            }
        }
    }
    return retArray
}

/**
 * 选择排序
 *
 * @param {Array<number>} array
 * @returns {Array<number>}
 */
function ChooseSort(array: Array<number>) : Array<number> {
    let retArray = [].concat(array)
    let min = 0, key = 0
    for (let i = 0, n = retArray.length; i < n; i++) {
        min = retArray[i]
        key = i
        for (let j = i + 1; j < n; j++) {
            if (min > retArray[j]) {
                key = j
                min = retArray[j]
            }
        }
        if (key != i) {
            let temp = retArray[i]
            retArray[i] = retArray[key]
            retArray[key] = temp
        }
    }
    return retArray
}

/**
 * 插入排序
 *
 * @param {Array<number>} array
 * @returns {Array<number>}
 */
function InsertSort(array: Array<number>) : Array<number> {
    let retArray = [].concat(array)
    for (let i = 1, n = retArray.length; i < n; i++ ) {
        let temp = retArray[i]
        let j = i
        while(j > 0 && retArray[j - 1] > temp) {
            retArray[j] = retArray[j - 1]
            j--
        }
        retArray[j] = temp
    }
    return retArray
}

/**
 * 希尔排序
 *
 * @param {Array<number>} array
 * @returns {Array<number>}
 */
function ShellSort(array: Array<number>) : Array<number> {
    let retArray = [].concat(array)
    let n = retArray.length
    let gap = ~~(n / 2)
    while (gap >= 1) {
        for (let i = gap; i < n; i++) {
            let temp = retArray[i]
            let j = i
            while(j > gap - 1 && retArray[j - gap] > temp) {
                retArray[j] = retArray[j - gap]
                j -= gap
            }
            retArray[j] = temp
        }
        gap = ~~(gap / 2)
    }
    return retArray
}

/**
 * 快速排序
 *
 * @param {Array<number>} array
 * @returns {Array<number>}
 */
function QuickSort(array: Array<number>) : Array<number> {
    let retArray = [].concat(array)
    let n = retArray.length
    /**
     * 快速排序的递归方法
     *
     * @param {number} left
     * @param {number} right
     */
    function quick(begin: number, end: number) {

        //递归出口
        if (begin >= end) {
            return
        }
        let l = begin // 左指针
        let r = end // 右指针
        let temp = retArray[l] // 基准数，这里取数组第一个数
        // 左右指针相遇的时候退出扫描循环
        while(l < r) {
            // 右指针从右向左扫描，碰到第一个小于基准数的时候停住
            while(l < r && retArray[r] >= temp) {
                r--
            }
            // 左指针从左向右扫描，碰到第一个大于基准数的时候停住
            while(l < r && retArray[l] <= temp) {
                l++
            }
            // 交换左右指针所停位置的数
            [retArray[l], retArray[r]] = [retArray[r], retArray[l]]
        }
        // 最后交换基准数与指针相遇位置的数
        [retArray[begin], retArray[l]] = [retArray[l], retArray[begin]]
        // 递归处理左右数组
        quick(begin, l - 1)
        quick(l + 1, end)
    }
    quick(0, n - 1)
    return retArray
}

let testArr = []
let len = 5000
let time = Date.now()
for (let i = 0; i < len; i++) {
    testArr.push(~~(Math.random() * len))
}
// 答案
let resultArr = testArr.sort((a: number, b: number) => a - b)

// 冒泡排序
time = Date.now()
let ans1 = BubbleSort(testArr)
if (JSON.stringify(resultArr) === JSON.stringify(ans1)) {
    console.log('BubbleSort Cost', Date.now() - time, 'ms')
}

// 选择排序
time = Date.now()
let ans2 = ChooseSort(testArr)
if (JSON.stringify(resultArr) === JSON.stringify(ans2)) {
    console.log('ChooseSort Cost', Date.now() - time, 'ms')
}

// 插入排序
time = Date.now()
let ans3 = InsertSort(testArr)
if (JSON.stringify(resultArr) === JSON.stringify(ans3)) {
    console.log('InsertSort Cost', Date.now() - time, 'ms')
}

// 希尔排序
time = Date.now()
let ans4 = ShellSort(testArr)
if (JSON.stringify(resultArr) === JSON.stringify(ans4)) {
    console.log('ShellSort Cost', Date.now() - time, 'ms')
}

// 快速排序
time = Date.now()
let ans5 = QuickSort(testArr)
if (JSON.stringify(resultArr) === JSON.stringify(ans5)) {
    console.log('QuickSort Cost', Date.now() - time, 'ms')
}

/**
 * 栈
 *
 * @export
 * @class Stack
 * @template T
 */
export class Stack<T> {
    // 使用数组作为数据源
    private _data: Array<T> = new Array<T>()

    /**
     * 添加数据
     *
     * @param {T} element
     * @memberof Stack
     */
    push(element: T) {
        this._data.push(element)
    }

    /**
     * 查看栈顶数据
     *
     * @returns {T}
     * @memberof Stack
     */
    peek() : T {
        if (this._data.length > 0) {
            return this._data[this._data.length - 1]
        }
        return null
    }

    /**
     * 查看并弹出栈顶数据
     *
     * @returns {T}
     * @memberof Stack
     */
    pop() : T {
        return this._data.pop()
    }

    /**
     * 判断栈是否为空
     *
     * @returns {boolean}
     * @memberof Stack
     */
    isEmpty() : boolean {
        return this._data.length == 0
    }

    /**
     * 清除栈的方法
     *
     * @memberof Stack
     */
    clean() {
        this._data = new Array<T>()
    }

    /**
     * 返回栈的长度
     *
     * @returns {number}
     * @memberof Stack
     */
    size() : number {
        return this._data.length
    }

    /**
     * 栈的打印
     *
     * @returns {string}
     * @memberof Stack
     */
    toString() : string {
        return this._data.toString()
    }
}

/**
 * 队列
 *
 * @export
 * @class Queue
 * @template T
 */
export class Queue<T> {
    // 使用数组作为数据源
    private _data: Array<T> = new Array<T>()

    /**
     * 入队
     *
     * @param {T} element
     * @memberof Queue
     */
    enqueue(element: T) {
        this._data.push(element)
    }

    /**
     * 出队
     *
     * @returns {T}
     * @memberof Queue
     */
    dequeue() : T {
        return this._data.shift()
    }

    /**
     * 查看队伍的第一个
     *
     * @returns {T}
     * @memberof Queue
     */
    front() : T {
        if (this._data.length > 0) {
            this._data[0]
        }
        return null
    }

    /**
     * 是否为空队
     *
     * @returns {boolean}
     * @memberof Queue
     */
    isEmpty() : boolean {
        return this._data.length == 0
    }

    /**
     * 队列的长度
     *
     * @returns {number}
     * @memberof Queue
     */
    size() : number {
        return this._data.length
    }

    /**
     * 队列的打印
     *
     * @returns
     * @memberof Queue
     */
    toString() {
        return this._data.toString()
    }
}

/**
 * 队列的数据节点, 带优先级
 *
 * @class QueueElement
 * @template T
 */
class QueueElement<T> {
    constructor(public element: T, public priority: number) {}
}

/**
 * 优先级队列
 *
 * @export
 * @class PriorityQueue
 * @template T
 */
export class PriorityQueue<T> {
    // 优先级队列的数据源
    private _data: Array<QueueElement<T>> = new Array<QueueElement<T>>()

    /**
     * 通过优先级入队,越大越优先
     *
     * @param {T} element
     * @param {number} [priority=0]
     * @memberof PriorityQueue
     */
    enqueue(element: T, priority: number = 0) {
        let added = false
        for (let i = 0; i < this._data.length; i++) {
            if (priority <= this._data[i].priority) {
                this._data.splice(i, 0, new QueueElement(element, priority))
                added = true
                break
            }
        }
        if (!added) {
            this._data.push(new QueueElement(element, priority))
        }
    }

    /**
     * 查看队首位置
     *
     * @returns {T}
     * @memberof PriorityQueue
     */
    front() : T {
        if (this._data.length > 0) {
            return this._data[this._data.length - 1].element
        }
        return null
    }

    /**
     * 出队
     *
     * @returns {T}
     * @memberof PriorityQueue
     */
    dequeue() : T {
        let queueElement: QueueElement<T> = this._data.pop()
        if (queueElement) {
            return queueElement.element
        }
        return null
    }

    /**
     * 队列是否为空
     *
     * @returns {boolean}
     * @memberof PriorityQueue
     */
    isEmpty() : boolean {
        return this._data.length == 0
    }

    /**
     * 队列的数量
     *
     * @returns
     * @memberof PriorityQueue
     */
    size() {
        return this._data.length
    }

    /**
     * 队列的打印
     *
     * @returns
     * @memberof PriorityQueue
     */
    toString() {
        return this._data.toString()
    }
}

/**
 * 链表的节点
 *
 * @class LinkedNode
 * @template T
 */
class LinkedNode<T> {
    constructor(public element: T, public next: LinkedNode<T> = null) {}
}

/**
 * 单向链表
 *
 * @export
 * @class LinkedList
 * @template T
 */
export class LinkedList<T> {
    // 链表的表头
    private _head: LinkedNode<T> = null
    // 链表的长度
    private _length: number = 0

    /**
     * 在链表尾部添加元素
     *
     * @param {T} element
     * @memberof LinkedList
     */
    append(element: T) {
        if (this._length == 0) {
            this._head = new LinkedNode<T>(element)
        } else {
            let curNode = this._head
            while(curNode.next) {
                curNode = curNode.next
            }
            curNode.next = new LinkedNode<T>(element)
        }
        this._length++
    }

    /**
     * 在链表中插入元素
     *
     * @param {number} position
     * @param {T} element
     * @returns {boolean}
     * @memberof LinkedList
     */
    insert(position: number, element: T) : boolean {
        if (position < 0 || position > this._length) {
            return false
        }
        let newNode = new LinkedNode<T>(element)
        let curNode = this._head
        if (position == 0) {
            newNode.next = curNode
            this._head = newNode
            this._length++
            return true
        }
        let index = 0
        let preNode = null
        while(index++ < position) {
            preNode = curNode
            curNode =curNode.next
        }
        preNode.next = newNode
        newNode.next = curNode
        this._length++
        return true
    }

    /**
     * 获取指定位置的元素
     *
     * @param {number} position
     * @returns {T}
     * @memberof LinkedList
     */
    get(position: number) : T {
        if (position < 0 || position >= this._length) {
            return null
        }
        let index = 0
        let curNode = this._head
        while(index++ < position) {
            curNode = curNode.next
        }
        return curNode.element
    }

    /**
     * 获得元素的下标
     *
     * @param {T} element
     * @returns {number}
     * @memberof LinkedList
     */
    indexOf(element: T) : number {
        let index = 0
        let curNode = this._head
        while(curNode) {
            if (curNode.element == element) {
                return index
            }
            index++
            curNode = curNode.next
        }
        return -1
    }

    /**
     * 修改指定下标的元素内容
     *
     * @param {number} position
     * @param {T} element
     * @returns {boolean}
     * @memberof LinkedList
     */
    update(position: number, element: T) : boolean {
        if (position < 0 || position >= this._length) {
            return false
        }
        let index = 0
        let curNode = this._head
        while(index++ < position) {
            curNode = curNode.next
        }
        curNode.element = element
        return true
    }

    /**
     * 删除元素
     *
     * @param {T} element
     * @returns {boolean}
     * @memberof LinkedList
     */
    remove(element: T) : boolean {
        if (this.removeAt(this.indexOf(element))) {
            return true
        } else {
            return false
        }
    }

    /**
     * 删除指定下标的元素
     *
     * @param {number} position
     * @returns {T}
     * @memberof LinkedList
     */
    removeAt(position: number) : T {
        if (position < 0 || position >= this._length) {
            return null
        }
        let curNode = this._head
        if (position == 0) {
            this._head = this._head.next
            this._length--
            return curNode.element
        }
        let index = 0
        let preNode = null
        while(index++ < position) {
            preNode = curNode
            curNode = curNode.next
        }
        preNode.next = curNode.next
        this._length--
        return curNode.element
    }

    /**
     * 判断是否为空
     *
     * @returns
     * @memberof LinkedList
     */
    isEmpty() {
        return this._length == 0
    }

    /**
     * 链表的打印
     *
     * @returns
     * @memberof LinkedList
     */
    toString() {
        let curNode = this._head
        let ret = ''
        while (curNode) {
            ret += curNode.element.toString() + '->'
            curNode = curNode.next
        }
        return ret
    }

    /**
     * 链表的长度
     *
     * @returns
     * @memberof LinkedList
     */
    size() {
        return this._length
    }
}

/**
 * 双向链表的节点
 *
 * @class DoublyLinkedNode
 * @template T
 */
class DoublyLinkedNode<T> {
    constructor(public element: T, public previous: DoublyLinkedNode<T> = null, public next: DoublyLinkedNode<T> = null) {}
}

/**
 * 双向链表
 *
 * @export
 * @class DoublyLinkedList
 * @template T
 */
export class DoublyLinkedList<T> {
    // 头节点
    private _head: DoublyLinkedNode<T> = null
    // 尾节点
    private _tail: DoublyLinkedNode<T> = null
    // 链表的长度
    private _length = 0

    /**
     * 添加数据
     *
     * @param {T} element
     * @memberof DoublyLinkedList
     */
    append(element: T) {
        let newNode = new DoublyLinkedNode(element)
        if (this._length == 0) {
            this._head = newNode
            this._tail = newNode
            this._length++
            return
        }
        this._tail.next = newNode
        newNode.previous = this._tail
        this._tail = newNode
        this._length++
    }

    /**
     * 指定位置插入数据
     *
     * @param {number} position
     * @param {T} element
     * @returns {boolean}
     * @memberof DoublyLinkedList
     */
    insert(position: number, element: T) : boolean {
        if (position < 0 || position > this._length) {
            return false
        }
        let newNode = new DoublyLinkedNode(element)
        // 当前的数组为空
        if (this._length == 0) {
            this._head = newNode
            this._tail = newNode
            this._length++
            return true
        }
        // 插入到最前面
        if (position == 0) {
            newNode.next = this._head
            this._head.previous = newNode
            this._head = newNode
            this._length++
            return true
        }
        // 插入到最后
        if (position == this._length) {
            this._tail.next = newNode
            newNode.previous = this._tail
            this._tail = newNode
            this._length++
            return true
        }
        // TODO 实现二分插入 先判断插入位置 然后确定从头或者从尾开始插入
        // 从前面插入
        let index = 0
        let curNode = this._head
        while(index++ < position) {
            curNode = curNode.next
        }
        curNode.previous.next = newNode
        newNode.previous = curNode.previous
        curNode.previous = newNode
        newNode.next = curNode
        this._length++
        return true
    }

    /**
     * 删除数据
     *
     * @param {T} element
     * @returns {boolean}
     * @memberof DoublyLinkedList
     */
    remove(element: T) : boolean {
        if (this.removeAt(this.indexOf(element))) {
            return true
        } else {
            return false
        }
    }

    /**
     * 删除指定节点数据
     *
     * @param {number} position
     * @returns {T}
     * @memberof DoublyLinkedList
     */
    removeAt(position: number) : T {
        if (position < 0 || position >= this._length) {
            return null
        }
        let curNode = null
        if (this._length == 1) {
            curNode = this._head
            this._head = null
            this._tail = null
            this._length--
            return curNode.element
        }
        // 删除第一个节点
        if (position == 0) {
            curNode = this._head
            this._head = this._head.next
            this._head.previous = null
            this._length--
            return curNode.element
        }
        // 删除最后一个节点
        if (position == this._length - 1) {
            curNode = this._tail
            this._tail = this._tail.previous
            this._tail.next = null
            return curNode.element
        }
        // 从前面开始遍历
        let index = 0
        curNode = this._head
        while (index++ < position) {
            curNode = curNode.next
        }
        curNode.previous.next = curNode.next
        curNode.next.previous = curNode.previous
        return curNode.element
    }

    /**
     * 更新指定节点数据
     *
     * @param {number} position
     * @param {T} element
     * @returns {boolean}
     * @memberof DoublyLinkedList
     */
    update(position: number, element: T) : boolean {
        if (position < 0 || position >= this._length) {
            return false
        }
        let index = 0
        let curNode = this._head
        while(index++ < position) {
            curNode = curNode.next
        }
        curNode.element = element
        return true
    }

    /**
     * 返回数据的下标
     *
     * @param {T} element
     * @returns {number}
     * @memberof DoublyLinkedList
     */
    indexOf(element: T) : number {
        let index = 0
        let curNode = this._head
        while(curNode) {
            if (curNode.element == element) {
                return index
            }
            index++
            curNode = curNode.next
        }
        return -1
    }

    /**
     * 获取指定下标的数据
     *
     * @param {number} position
     * @returns {T}
     * @memberof DoublyLinkedList
     */
    get(position: number) : T {
        if (position < 0 || position >= this._length) {
            return null
        }
        // 实现二分读取 先判断读取位置 然后确定从头或者从尾开始读取
        if (position < this._length / 2) {
            // 从前面读取
            let index = 0
            let curNode = this._head
            while(index++ < position) {
                curNode = curNode.next
            }
            return curNode.element
        } else {
            // 从后面读取
            let index = this._length - 1
            let curNode = this._tail
            while(index-- > position) {
                curNode = curNode.previous
            }
            return curNode.element
        }
    }

    /**
     * 判断是否为空
     *
     * @returns {boolean}
     * @memberof DoublyLinkedList
     */
    isEmpty() : boolean {
        return this._length == 0
    }

    /**
     * 返回链表的长度
     *
     * @returns {number}
     * @memberof DoublyLinkedList
     */
    size() : number {
        return this._length
    }

    /**
     * 从尾开始遍历
     *
     * @returns {string}
     * @memberof DoublyLinkedList
     */
    backwardString() : string {
        let ret = ''
        let curNode = this._tail
        while(curNode) {
            ret += curNode.element + '<-'
            curNode = curNode.previous
        }
        return ret
    }

    /**
     * 从头开始遍历
     *
     * @returns {string}
     * @memberof DoublyLinkedList
     */
    forwardString() : string {
        let ret = ''
        let curNode = this._head
        while(curNode) {
            ret += curNode.element + '->'
            curNode = curNode.next
        }
        return ret
    }

    /**
     * 打印链表
     *
     * @returns {string}
     * @memberof DoublyLinkedList
     */
    toString() : string {
        return this.backwardString()
    }

    /**
     * 获取头数据
     *
     * @returns {T}
     * @memberof DoublyLinkedList
     */
    getHead() : T {
        return this._head.element
    }

    /**
     * 获取尾数据
     *
     * @returns {T}
     * @memberof DoublyLinkedList
     */
    getTail() : T {
        return this._tail.element
    }
}

/**
 * 哈希表
 *
 * @export
 * @class HashTable
 * @template K
 * @template V
 */
export class HashTable <K, V>{
    // 哈希表的数据源
    private _storage = []
    // 哈希表的数量
    private _count = 0
    // 哈希表的限制数量
    private _limit = 17

    /**
     * 哈希函数
     *
     * @param {string} str
     * @param {number} size
     * @returns {number}
     * @memberof HashMap
     */
    private hash(str: string, size: number) : number {
        let index = 0
        let hashCode = 0
        for (let i = 0; i < str.length; i++) {
            hashCode = 37 * hashCode + str.charCodeAt(i)
        }
        index = hashCode % size
        return index
    }

    /**
     * 是否是质数
     *
     * @private
     * @param {number} num
     * @returns {boolean}
     * @memberof HashTable
     */
    private isPrime(num: number) : boolean {
        if (num <= 1) {
            return false
        }
        for (let i = 2, n = ~~(Math.sqrt(num)); i <= n; i++) {
            if (num % i == 0) {
                return false
            }
            return true
        }
        return true
    }

    /**
     * 获取素数
     *
     * @private
     * @param {number} num
     * @returns {number}
     * @memberof HashTable
     */
    private getPrime(num: number) : number {
        while(!this.isPrime(num)) {
            num++
        }
        return num
    }

    /**
     * 修改数据大小
     *
     * @private
     * @param {number} limit
     * @memberof HashTable
     */
    private resize(limit: number) {
        let oldStorage = this._storage
        this._count = 0
        this._limit = limit
        this._storage = []
        oldStorage.forEach(bucket => {
            if (bucket) {
                bucket.forEach(tuple => {
                    this.put(tuple[0], tuple[1])
                })
            }
        })
    }

    /**
     * 插入数据
     *
     * @param {K} key
     * @param {V} value
     * @memberof HashTable
     */
    put(key: K, value: V) {
        let index = this.hash(key + '', this._limit)
        let bucket = this._storage[index]
        if (!bucket) {
            bucket = []
            this._storage[index] = bucket
        }
        let has = bucket.some(tuple => {
            if (key + '' === tuple[0]) {
                tuple[1] = value
                return true
            }
            return false
        })
        if (!has) {
            bucket.push([key + '', value])
            this._count++
            if (this._count > this._limit * 0.75) {
                this.resize(this.getPrime(this._limit * 2))
            }
        }
    }

    /**
     * 获取数据
     *
     * @param {K} key
     * @returns {V}
     * @memberof HashTable
     */
    get(key: K) : V {
        let index = this.hash(key + '', this._limit)
        let bucket = this._storage[index]
        if (!bucket) {
            return null
        }
        for (let i = 0; i < bucket.length; i++) {
            let tuple = bucket[i]
            if (key + '' === tuple[0]) {
                return tuple[1]
            }
        }
        return null
    }

    /**
     * 删除数据
     *
     * @param {K} key
     * @returns {V}
     * @memberof HashTable
     */
    remove(key: K) : V {
        let index = this.hash(key + '', this._limit)
        let bucket = this._storage[index]
        if (!bucket) {
            return null
        }
        for (let i = 0; i < bucket.length; i++) {
            let tuple = bucket[i]
            if (key + '' === tuple[0]) {
                bucket.splice(i, 1)
                this._count--
                if (this._limit > 17 && this._count < this._limit * 0.25) {
                    this.resize(this.getPrime(~~(this._limit / 2)))
                }
                return tuple[1]
            }
        }
        return null
    }

    /**
     * 判断是否为空
     *
     * @returns
     * @memberof HashTable
     */
    isEmpty() {
        return this._count == 0
    }

    /**
     * 返回数据大小
     *
     * @returns
     * @memberof HashTable
     */
    size() {
        return this._count
    }

}