Godot游戏开发实践之一：使用High Level Multiplayer API制作多人游戏（下）

extends Node

# 自定义信号
signal player_list_update(players, colors)     # 新玩家加入后信息更新
signal player_color_update(id, color)          # 玩家颜色更新
signal player_ready_status_update(id, isReady) # 玩家准备或者取消准备
signal player_disconnected(id)                 # 连接断开信号
signal connection_succeeded()                  # 连接成功信号
signal game_ended(why)                         # 游戏结束信号
signal game_ready(isReady)                     # 游戏玩家是否已经准备好
signal game_loaded()                           # 游戏加载完成即将开始

# 定义端口，最大连接数量，需要加载的游戏场景，还有玩家可选颜色
const PORT := 34567
const MAX_PLAYERS := 4
const GAME_SCENE := 'res://World/Game.tscn'
const COLORS := [Color('#B0BEC5'), Color('#8D6E63'), Color('#FFAB91'), ...] # 省略

# 基本属性：联网id，名字，颜色，其他玩家的相关信息等
var myId := -1
var myName := ''
var myColor := Color.white
var otherPlayerNames := {}   # id-name  字典
var otherPlayerColors := {}  # id-color 字典
var isGameStarted := false

# 已经准备好的玩家和当前可用颜色，只在主场景中使用（实际是服务器）
master var readyPlayers := []
master var availableColors := []

# 这里5个信号都是 Godot High-level multiplayer API 自带信号
func _ready() -> void:
    self.get_tree().connect('network_peer_connected', self, '_onNewPlayerConnected')
    self.get_tree().connect('network_peer_disconnected', self, '_onPlayerDisconnected')
    self.get_tree().connect('server_disconnected', self, '_onServerDisconnected')
    self.get_tree().connect('connected_to_server', self, '_onConnectionSuccess')
    self.get_tree().connect('connection_failed', self, '_onConnectionFail')

# 每当有新客户端连接到服务器，所有其他玩家的id都会调用该方法
# 不论当前节点是服务端还是客户端：相当于我收到了来自该id的玩家连接通知
func _onNewPlayerConnected(id : int) -> void:
    if isGameStarted:
        return

    # 通过 rpc_id 将自己的信息远程发送给对方
    self.rpc_id(id, '_addMyNameToList', myName, myColor)

    # 仅【服务端】处理游戏准备事件、分配颜色
    if self.get_tree().is_network_server():
        self.emit_signal('game_ready', false)

        var color := _getRandomColor()
        self.rpc('_updateColor', id, color)

# 每当客户端id断开链接，所有其他玩家都会调用该方法
# 如果游戏已经开始，则发出 player_disconnected 的信号
# 否则仅需要移除该 id 玩家的相关信息即可（比如准备状态等）
func _onPlayerDisconnected(id : int) -> void:
    if isGameStarted:
        self.emit_signal('player_disconnected', id)
    else:
        _removeDisconnectedPlayer(id)

# 当前客户端链接成功，仅【客户端】调用
# 表明当前本地玩家进入了游戏大厅，可以准备游戏了
func _onConnectionSuccess() -> void:
    self.emit_signal('connection_succeeded')

# 服务器断开，仅【客户端】调用
# 对应操作一般是退出游戏，清空网络连接等相关信息
func _onServerDisconnected() -> void:
    self.emit_signal('game_ended', 'Server disconnected.')

# 客户端链接失败，仅【客户端】调用
func _onConnectionFail() -> void:
    self.emit_signal('game_ended', 'Connection failed.')

# 远程方法，处理来自其他玩家的调用，添加其他玩家的信息到 otherPlayerNames
# 注意，这个方法实际是其他玩家调用（发送），或者说你通过该方法接收到了来自其他玩家的信息
remote func _addMyNameToList(playerName : String, playerColor : Color) -> void:
    var id = self.get_tree().get_rpc_sender_id()
    otherPlayerNames[id] = playerName
    if ! otherPlayerColors.has(id):
        otherPlayerColors[id] = playerColor
    self.emit_signal('player_list_update', otherPlayerNames, otherPlayerColors)

# 更新颜色，颜色随机选取，仅由【服务器】决定分配，确保颜色不重复
# remotesync 表明该方法在每个玩家中都会运行，由服务器统一发起调用
remotesync func _updateColor(id : int, color : Color) -> void:
    if id == myId:
        myColor = color
    else:
        otherPlayerColors[id] = color

    self.emit_signal('player_color_update', id, color)

# 省略部分代码……

# 创建服务器，这里返回一个结果
# 如果一个 IP 被占用就会返回错误
func hostGame(playerName: String) -> bool:
    myName = playerName
    otherPlayerNames.clear()
    otherPlayerColors.clear()
    availableColors = COLORS.duplicate()
    readyPlayers.clear()

    var host := NetworkedMultiplayerENet.new()
    var error := host.create_server(PORT, MAX_PLAYERS)
    if error != OK:
        return false

    self.get_tree().network_peer = host
    self.get_tree().refuse_new_network_connections = false

    myId = self.get_tree().get_network_unique_id() # id = 1 is the server
    myColor = _getRandomColor()
    return true

# 创建客户端，加入游戏，需要指定 IP 地址
func joinGame(address: String, playerName: String) -> bool:
    myName = playerName
    otherPlayerNames.clear()
    otherPlayerColors.clear()
    readyPlayers.clear()

    var host := NetworkedMultiplayerENet.new()
    var error := host.create_client(address, PORT)
    if error != OK:
        return false

    self.get_tree().network_peer = host

    myId = self.get_tree().get_network_unique_id()
    return true

# 重设网络为 null ，断开所有连接
func resetNetwork() -> void:
    isGameStarted = false
    otherPlayerNames.clear()
    otherPlayerColors.clear()
    self.get_tree().network_peer = null

# 客户端调用，准备或者取消准备状态
func readyGame(isReady : bool) -> void:
    self.rpc('_readyGame', isReady)

# 远程发送玩家是否处于准备状态的方法
remote func _readyGame(isReady : bool) -> void:
    # 某玩家发送，其他所有玩家都会收到，更新该玩家的准备状态
    var id := self.get_tree().get_rpc_sender_id()
    self.emit_signal('player_ready_status_update', id, isReady)

    # 这部分代码仅【服务器】端处理，可以根据玩家是否【全部准备好】来决定是否可以开始游戏
    if self.get_tree().is_network_server():
        if isReady:
            readyPlayers.append(id)
            self.emit_signal('game_ready', readyPlayers.size() == otherPlayerNames.size())
        else:
            readyPlayers.erase(id)
            self.emit_signal('game_ready', false)

# 【服务器】端调用，房主点击开始游戏按钮
# 正式开启了：一波三折游戏开始系列！
func startGame() -> void:
    self.get_tree().refuse_new_network_connections = true
    readyPlayers.clear()
    self.rpc('_prestartGame')

# 1. 开始游戏第一步：实例化游戏场景，并且暂停，通知服务器等待其他玩家
remotesync func _prestartGame() -> void:
    isGameStarted = true
    # 实例化游戏战场，并暂停，等待
    var game : Node2D = load(GAME_SCENE).instance()
    game.name = 'Game'
    game.set_network_master(1)
    self.get_parent().add_child(game)
    self.get_tree().paused = true

    if self.get_tree().is_network_server():
        # 服务器端本地运行
        _postStartGame(myId)
    else:
        # 1 代表服务器 id，向服务器发送可以开始了的消息
        self.rpc_id(1, '_postStartGame', myId)


# 2. 开始游戏第二步：等待所有玩家全部加载、实例化游戏场景
# 由上面的调用我们知道：这个方法一定只会运行在服务器端
remote func _postStartGame(id : int) -> void:
    readyPlayers.append(id)
    # 确保所有玩家都已经准备好，包括自己
    if readyPlayers.size() == otherPlayerNames.size() + 1:
        self.rpc('_startGame')

# 3. 开始游戏第三步：全部进入游戏，开始
remotesync func _startGame() -> void:
    readyPlayers.clear()
    self.emit_signal('game_loaded')

# 初始化
func _ready() -> void:
    if GameConfig.isSoundOn:
        _audioPlayer.play()

    _resultPopup.showPopup('Waiting for other players...', 'Waiting', true, _resultPopup.BUTTON_BACK_BIT + _resultPopup.BUTTON_STAY_BIT)

    GameState.connect('game_loaded', self, '_onGameLoaded')
    GameState.connect('game_ended', self, '_onGameEnded')
    GameState.connect('player_disconnected', self, '_onPlayerQuit')

    _setDifficulties()
    _addPlayers()

    GameConfig.sendMessage(GameConfig.MessageType.System, GameState.myId, 'enters the game!')
    GameConfig.rpc('sendMessage', GameConfig.MessageType.System, GameState.myId, 'enters the game!')

# 添加玩家，仅一个 master 对象，其他都为 puppet
# 只有主人节点添加相关事件，注意设置对应的 master_id
# 玩家的起始位置，由玩家的 id 大小决定，确保统一
func _addPlayers() -> void:
    var positions := [GameState.myId] + GameState.otherPlayerNames.keys()
    positions.sort()
    var player := PlayerNode.instance()
    player.connect('lay_bomb', self, '_on_Player_lay_bomb')
    player.connect('dead', self, '_on_Player_dead')
    player.connect('damaged', self, '_on_Player_damaged')
    player.connect('collect_item', self, '_on_Player_collect_item')
    player.name = str(GameState.myId)
    player.playerId = GameState.myId
    player.playerName = GameState.myName
    player.playerColor = GameState.myColor
    player.global_position = _playerPositionNodes[positions.find(GameState.myId)].position
    player.set_network_master(GameState.myId)
    _playersContainer.add_child(player)
    _allPlayers.append(GameState.myId)

    for id in GameState.otherPlayerNames:
        player = PlayerNode.instance()
        player.name = str(id)
        player.playerId = id
        player.playerName = str(GameState.otherPlayerNames[id])
        player.playerColor = GameState.otherPlayerColors[id]
        player.global_position = _playerPositionNodes[positions.find(id)].position
        player.set_network_master(id)
        _playersContainer.add_child(player)
        _allPlayers.append(id)

    for node in _playerPositionNodes:
        node.queue_free()

func _unhandled_input(event: InputEvent) -> void:
    # 这部分代码不区分主人与非主人节点
    # 主人节点、奴隶节点都显示玩家名字
    if event.is_action_pressed('show_name'):
        _labelName.show()
    elif event.is_action_released('show_name'):
        _labelName.hide()

    if ! self.is_network_master():
        return
    # 这里的代码则只能在【主人节点】中运行：放置炸弹
    if _isStuning || _isDead:
        return
    if event.is_action_pressed('lay_bomb'):
        _layBomb()

func _physics_process(delta):
    # 这里同样只能运行于主人节点中
    if ! self.is_network_master():
        return
    if _isStuning || _isDead:
        return
    self.move_and_slide(_velocity)

    # 更新其他场景中的对应奴隶节点的位置，这里使用 rpc_unreliable 允许丢包
    self.rpc_unreliable('_updatePosition', self.position)

# 下面的方法只能运行在主人节点，代码内部再由主节点发送必要的消息到相对应奴隶节点
master func bomb(byKiller : int, damage : int) -> void:
    damage(damage, Vector2.ZERO, byKiller)

master func damage(amount : float, direction : Vector2 = Vector2.ZERO, byId : int = -1) -> void:
    # ...省略

master func collect(itemIndex : int) -> void:
    # ...省略

`func _process(delta: float) -> void:
    if self.get_tree().network_peer == null || ! self.is_network_master():
        return
    if _isDead || _isPaused:
        return
    self.rpc_unreliable('_puppetSet', self.position, _sprite.flip_h, _animationPlayer.current_animation)

# 运行于服务器
func _onPlayerBeKickedOut(id : int) -> void:
    self.rpc_id(id, '_kickedOut')

# 运行于客户端
remote func _kickedOut() -> void:
    # ...省略
    self.get_tree().network_peer = null

# 生成敌人
func _spawnEnemy() -> void:
    # ......
    # 定义一个整数字段，每生成一个敌人加 1 ，保证每个敌人名字【唯一】
    _enemyNameIndex += 1
    var pos := _tileMap.map_to_world(tile) + _tileMap.cell_size / 2
    var name := 'Enemy' + str(_enemyNameIndex)
    # 将名字作为数据发送到其他客户端，保证名字相同【一致】
    self.rpc('_addEnemy', pos, name)

# 远程添加敌人的方法
remotesync func _addEnemy(pos : Vector2, name : String) -> void:
    var enemy = enemyScene.instance()
    enemy.name = name
    enemy.set_network_master(1) # 以服务器端的对象作为 master
    enemy.global_position = pos
    _enemiesContainer.add_child(enemy)

# 修改前的代码：
self.rpc('_addItem', GameState.myId, item)
remotesync func _addItem(id : int, item : GameConfig.ItemData) -> void:
    var power : Node = load(item.data).instance()
    power.set_network_master(id)
    self.add_child(power)

# 修改后的代码：
self.rpc('_addItem', GameState.myId, item.data)
remotesync func _addItem(id : int, data : String) -> void:
    var power : Node = load(data).instance()
    power.set_network_master(id)
    self.add_child(power)

func _physics_process(delta: float) -> void:
    if self.get_tree().network_peer == null || ! self.get_tree().is_network_server():
        return
    # ......

func _ready() -> void:
    # 这里会运行在服务器端和客户端，保证 _brokenTiles 同步
    _navigation = self.get_parent()
    for tile in self.get_used_cells():
        if self.get_cellv(tile) == GameConfig.GRASS_TILE_ID:
            _brokenTiles.append(tile)