feat(matchmake-extension): Support additionalParticipants in AutoMatchmakeWithParamPostpone

globals/matchmaking_utils.go

@@ -625,3 +625,73 @@ func ChangeSessionOwner(currentOwner *nex.PRUDPConnection, gathering uint32, isL
 		return false
 	})
 }
+
+func MovePlayersToSession(newSession *CommonMatchmakeSession, connectionIDs []uint32, initiatingConnection *nex.PRUDPConnection, joinMessage string) *nex.Error {
+	endpoint := initiatingConnection.Endpoint().(*nex.PRUDPEndPoint)
+	server := endpoint.Server
+
+	for _, connectionID := range connectionIDs {
+		target := endpoint.FindConnectionByID(connectionID)
+		if target == nil {
+			Logger.Warning("Connection not found")
+			continue
+		}
+
+		// * Switch to new gathering
+		category := notifications.NotificationCategories.SwitchGathering
+		subtype := notifications.NotificationSubTypes.SwitchGathering.None
+
+		oEvent := notifications_types.NewNotificationEvent()
+		oEvent.PIDSource = initiatingConnection.PID()
+		oEvent.Type = types.NewPrimitiveU32(notifications.BuildNotificationType(category, subtype))
+		oEvent.Param1 = newSession.GameMatchmakeSession.ID.Copy().(*types.PrimitiveU32)
+		oEvent.Param2 = types.NewPrimitiveU32(target.PID().LegacyValue()) // TODO - This assumes a legacy client. Will not work on the Switch
+
+		stream := nex.NewByteStreamOut(endpoint.LibraryVersions(), endpoint.ByteStreamSettings())
+
+		oEvent.WriteTo(stream)
+
+		rmcRequest := nex.NewRMCRequest(endpoint)
+		rmcRequest.ProtocolID = notifications.ProtocolID
+		rmcRequest.CallID = CurrentMatchmakingCallID.Next()
+		rmcRequest.MethodID = notifications.MethodProcessNotificationEvent
+		rmcRequest.Parameters = stream.Bytes()
+
+		rmcRequestBytes := rmcRequest.Bytes()
+
+		var messagePacket nex.PRUDPPacketInterface
+
+		if target.DefaultPRUDPVersion == 0 {
+			messagePacket, _ = nex.NewPRUDPPacketV0(server, target, nil)
+		} else {
+			messagePacket, _ = nex.NewPRUDPPacketV1(server, target, nil)
+		}
+
+		messagePacket.SetType(constants.DataPacket)
+		messagePacket.AddFlag(constants.PacketFlagNeedsAck)
+		messagePacket.AddFlag(constants.PacketFlagReliable)
+		messagePacket.SetSourceVirtualPortStreamType(target.StreamType)
+		messagePacket.SetSourceVirtualPortStreamID(endpoint.StreamID)
+		messagePacket.SetDestinationVirtualPortStreamType(target.StreamType)
+		messagePacket.SetDestinationVirtualPortStreamID(target.StreamID)
+		messagePacket.SetPayload(rmcRequestBytes)
+
+		server.Send(messagePacket)
+
+		// * Remove from old session(s)
+		// * Do it manually instead of RemoveConnectionFromAllSessions to avoid host migration and other confusing
+		// * notifications
+		for gid := FindConnectionSession(target.ID); gid != 0; {
+			RemoveConnectionIDFromSession(target.ID, gid)
+			gid = FindConnectionSession(target.ID)
+		}
+
+		// * Add to new session!
+		err := AddPlayersToSession(newSession, []uint32{target.ID}, initiatingConnection, joinMessage)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

matchmake-extension/auto_matchmake_with_param_postpone.go

@@ -17,9 +17,36 @@ func (commonProtocol *CommonProtocol) autoMatchmakeWithParamPostpone(err error,
 	connection := packet.Sender().(*nex.PRUDPConnection)
 	endpoint := connection.Endpoint().(*nex.PRUDPEndPoint)
 
-	// * A client may disconnect from a session without leaving reliably,
-	// * so let's make sure the client is removed from the session
-	common_globals.RemoveConnectionFromAllSessions(connection)
+	// * Process additionalParticipants early so we can cancel matchmaking if it's wrong
+	// * additionalParticipants is used by Splatoon to move Fest teams around between rooms
+	oldGid := autoMatchmakeParam.GIDForParticipationCheck.Value
+	oldGathering := common_globals.Sessions[oldGid]
+	// * Check the caller is actually in the old session
+	useAdditionalParticipants := oldGathering != nil && oldGathering.ConnectionIDs.Has(connection.ID)
+
+	// * Check the other participants are actually in the old session, and note down the connection IDs
+	additionalParticipants := make([]uint32, autoMatchmakeParam.AdditionalParticipants.Length()+1)
+
+	// * If using additionalParticipants we'll *move* everyone, rather than disconnect/reconnect.
+	// * This prevents issues from host migration and disconnected notifications.
+	if useAdditionalParticipants {
+		for i, pid := range autoMatchmakeParam.AdditionalParticipants.Slice() {
+			targetConnection := endpoint.FindConnectionByPID(pid.Value())
+			if targetConnection == nil || !oldGathering.ConnectionIDs.Has(targetConnection.ID) {
+				// * This code is so early in the matchmaking process so this error can be here
+				return nil, nex.NewError(nex.ResultCodes.RendezVous.NotParticipatedGathering, "Couldn't find connection")
+			}
+
+			additionalParticipants[i] = targetConnection.ID
+		}
+
+		// * Include the host too!
+		additionalParticipants[len(additionalParticipants)-1] = connection.ID
+	} else {
+		// * A client may disconnect from a session without leaving reliably,
+		// * so let's make sure the client is removed from the session.
+		common_globals.RemoveConnectionFromAllSessions(connection)
+	}
 
 	matchmakeSession := autoMatchmakeParam.SourceMatchmakeSession
 
@@ -37,10 +64,19 @@ func (commonProtocol *CommonProtocol) autoMatchmakeWithParamPostpone(err error,
 		session = sessions[0]
 	}
 
-	errCode := common_globals.AddPlayersToSession(session, []uint32{connection.ID}, connection, "")
-	if errCode != nil {
-		common_globals.Logger.Error(errCode.Error())
-		return nil, errCode
+	if useAdditionalParticipants {
+		// * Move everyone. They're still connected to their old session
+		errCode := common_globals.MovePlayersToSession(session, additionalParticipants, connection, autoMatchmakeParam.JoinMessage.Value)
+		if errCode != nil {
+			common_globals.Logger.Error(errCode.Error())
+			return nil, errCode
+		}
+	} else {
+		errCode := common_globals.AddPlayersToSession(session, []uint32{connection.ID}, connection, autoMatchmakeParam.JoinMessage.Value)
+		if errCode != nil {
+			common_globals.Logger.Error(errCode.Error())
+			return nil, errCode
+		}
 	}
 
 	matchmakeDataHolder := types.NewAnyDataHolder()