From 5c006a06837af9864c55a01ebc3b009995d02c98 Mon Sep 17 00:00:00 2001 From: shutterbug2000 Date: Fri, 6 Oct 2023 23:07:57 -0500 Subject: [PATCH 1/6] Add common Ranking protocol Tested on both Ultimate NES Remix and DKC:TF without issues --- ranking/get_cached_top_x_ranking.go | 76 ++++++++++++++++++++++++ ranking/get_cached_top_x_rankings.go | 78 ++++++++++++++++++++++++ ranking/get_common_data.go | 56 +++++++++++++++++ ranking/get_ranking.go | 71 ++++++++++++++++++++++ ranking/protocol.go | 89 ++++++++++++++++++++++++++++ ranking/upload_common_data.go | 52 ++++++++++++++++ ranking/upload_score.go | 53 +++++++++++++++++ 7 files changed, 475 insertions(+) create mode 100644 ranking/get_cached_top_x_ranking.go create mode 100644 ranking/get_cached_top_x_rankings.go create mode 100644 ranking/get_common_data.go create mode 100644 ranking/get_ranking.go create mode 100644 ranking/protocol.go create mode 100644 ranking/upload_common_data.go create mode 100644 ranking/upload_score.go diff --git a/ranking/get_cached_top_x_ranking.go b/ranking/get_cached_top_x_ranking.go new file mode 100644 index 0000000..fa0e257 --- /dev/null +++ b/ranking/get_cached_top_x_ranking.go @@ -0,0 +1,76 @@ +package ranking + +import ( + "github.com/PretendoNetwork/nex-go" + ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" + ranking_types "github.com/PretendoNetwork/nex-protocols-go/ranking/types" +) + +func getCachedTopXRanking(err error, client *nex.Client, callID uint32, category uint32, orderParam *ranking_types.RankingOrderParam) uint32 { + if commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler == nil { + logger.Warning("Ranking::GetCachedTopXRanking missing GetRankingsAndCountByCategoryAndRankingOrderParamHandler!") + return nex.Errors.Core.NotImplemented + } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) + server := client.Server() + + if err != nil { + logger.Error(err.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } + + err, rankDataList, totalCount := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(category, orderParam) + if err != nil { + logger.Error(err.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } + + if totalCount == 0 || len(rankDataList) == 0 { + rmcResponse.SetError(nex.Errors.Ranking.NotFound) + } + + if err == nil && totalCount != 0 { + rankingResult := ranking_types.NewRankingResult() + + rankingResult.RankDataList = rankDataList + rankingResult.TotalCount = totalCount + rankingResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back + + pResult := ranking_types.NewRankingCachedResult() + pResult.CreatedTime = nex.NewDateTime(0x1f40420000) //TODO: does this matter? + pResult.ExpiredTime = nex.NewDateTime(0x1f40420000) //TODO: does this matter? + pResult.MaxLength = 0 + + rmcResponseStream := nex.NewStreamOut(server) + + rmcResponseStream.WriteStructure(pResult) + + rmcResponseBody := rmcResponseStream.Bytes() + + rmcResponse.SetSuccess(ranking.MethodGetCachedTopXRanking, rmcResponseBody) + } + + rmcResponseBytes := rmcResponse.Bytes() + + var responsePacket nex.PacketInterface + + if server.PRUDPVersion() == 0 { + responsePacket, _ = nex.NewPacketV0(client, nil) + responsePacket.SetVersion(0) + } else { + responsePacket, _ = nex.NewPacketV1(client, nil) + responsePacket.SetVersion(1) + } + + responsePacket.SetSource(0xA1) + responsePacket.SetDestination(0xAF) + responsePacket.SetType(nex.DataPacket) + responsePacket.SetPayload(rmcResponseBytes) + + responsePacket.AddFlag(nex.FlagNeedsAck) + responsePacket.AddFlag(nex.FlagReliable) + + server.Send(responsePacket) + + return 0 +} diff --git a/ranking/get_cached_top_x_rankings.go b/ranking/get_cached_top_x_rankings.go new file mode 100644 index 0000000..5d1d17f --- /dev/null +++ b/ranking/get_cached_top_x_rankings.go @@ -0,0 +1,78 @@ +package ranking + +import ( + "github.com/PretendoNetwork/nex-go" + ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" + ranking_types "github.com/PretendoNetwork/nex-protocols-go/ranking/types" +) + +func getCachedTopXRankings(err error, client *nex.Client, callID uint32, categories []uint32, orderParams []*ranking_types.RankingOrderParam) uint32 { + if commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler == nil { + logger.Warning("Ranking::GetCachedTopXRankings missing GetRankingsAndCountByCategoryAndRankingOrderParamHandler!") + return nex.Errors.Core.NotImplemented + } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) + server := client.Server() + + if err != nil { + logger.Error(err.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } + + var pResult []*ranking_types.RankingCachedResult + for i := 0; i < len(categories); i++ { + err, rankDataList, totalCount := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(categories[i], orderParams[i]) + if err != nil { + logger.Error(err.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } + + if totalCount == 0 || len(rankDataList) == 0 { + rmcResponse.SetError(nex.Errors.Ranking.NotFound) + } + + if err == nil && totalCount != 0 { + rankingResult := ranking_types.NewRankingResult() + + rankingResult.RankDataList = rankDataList + rankingResult.TotalCount = totalCount + rankingResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back + + result := ranking_types.NewRankingCachedResult() + result.CreatedTime = nex.NewDateTime(0x1f40420000) //TODO: does this matter? + result.ExpiredTime = nex.NewDateTime(0x1f40420000) //TODO: does this matter? + result.MaxLength = 0 + result.SetParentType(rankingResult) + pResult = append(pResult, result) + } + + rmcResponseStream := nex.NewStreamOut(server) + rmcResponseStream.WriteListStructure(pResult) + rmcResponseBody := rmcResponseStream.Bytes() + rmcResponse.SetSuccess(ranking.MethodGetCachedTopXRankings, rmcResponseBody) + } + + rmcResponseBytes := rmcResponse.Bytes() + + var responsePacket nex.PacketInterface + + if server.PRUDPVersion() == 0 { + responsePacket, _ = nex.NewPacketV0(client, nil) + responsePacket.SetVersion(0) + } else { + responsePacket, _ = nex.NewPacketV1(client, nil) + responsePacket.SetVersion(1) + } + + responsePacket.SetSource(0xA1) + responsePacket.SetDestination(0xAF) + responsePacket.SetType(nex.DataPacket) + responsePacket.SetPayload(rmcResponseBytes) + + responsePacket.AddFlag(nex.FlagNeedsAck) + responsePacket.AddFlag(nex.FlagReliable) + + server.Send(responsePacket) + + return 0 +} diff --git a/ranking/get_common_data.go b/ranking/get_common_data.go new file mode 100644 index 0000000..ad57942 --- /dev/null +++ b/ranking/get_common_data.go @@ -0,0 +1,56 @@ +package ranking + +import ( + "github.com/PretendoNetwork/nex-go" + ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" +) + +func getCommonData(err error, client *nex.Client, callID uint32, uniqueID uint64) uint32 { + if commonRankingProtocol.getCommonDataHandler == nil { + logger.Warning("Ranking::GetCommonData missing GetCommonDataHandler!") + return nex.Errors.Core.NotImplemented + } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) + server := client.Server() + + if err != nil { + logger.Error(err.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } + + commonDataErr, commonData := commonRankingProtocol.getCommonDataHandler(uniqueID) + + if commonDataErr == nil { + rmcResponseStream := nex.NewStreamOut(server) + + rmcResponseStream.WriteBuffer(commonData) + + rmcResponseBody := rmcResponseStream.Bytes() + + rmcResponse.SetSuccess(ranking.MethodGetCommonData, rmcResponseBody) + } + + rmcResponseBytes := rmcResponse.Bytes() + + var responsePacket nex.PacketInterface + + if server.PRUDPVersion() == 0 { + responsePacket, _ = nex.NewPacketV0(client, nil) + responsePacket.SetVersion(0) + } else { + responsePacket, _ = nex.NewPacketV1(client, nil) + responsePacket.SetVersion(1) + } + + responsePacket.SetSource(0xA1) + responsePacket.SetDestination(0xAF) + responsePacket.SetType(nex.DataPacket) + responsePacket.SetPayload(rmcResponseBytes) + + responsePacket.AddFlag(nex.FlagNeedsAck) + responsePacket.AddFlag(nex.FlagReliable) + + server.Send(responsePacket) + + return 0 +} diff --git a/ranking/get_ranking.go b/ranking/get_ranking.go new file mode 100644 index 0000000..9a879d2 --- /dev/null +++ b/ranking/get_ranking.go @@ -0,0 +1,71 @@ +package ranking + +import ( + "github.com/PretendoNetwork/nex-go" + ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" + ranking_types "github.com/PretendoNetwork/nex-protocols-go/ranking/types" +) + +func getRanking(err error, client *nex.Client, callID uint32, rankingMode uint8, category uint32, orderParam *ranking_types.RankingOrderParam, uniqueID uint64, principalID uint32) uint32 { + if commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler == nil { + logger.Warning("Ranking::GetRanking missing GetRankingsAndCountByCategoryAndRankingOrderParamHandler!") + return nex.Errors.Core.NotImplemented + } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) + server := client.Server() + + if err != nil { + logger.Error(err.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } + + err, rankDataList, totalCount := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(category, orderParam) + if err != nil { + logger.Error(err.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } + + if totalCount == 0 || len(rankDataList) == 0 { + rmcResponse.SetError(nex.Errors.Ranking.NotFound) + } + + if err == nil && totalCount != 0 { + pResult := ranking_types.NewRankingResult() + + pResult.RankDataList = rankDataList + pResult.TotalCount = totalCount + pResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back + + rmcResponseStream := nex.NewStreamOut(server) + + rmcResponseStream.WriteStructure(pResult) + + rmcResponseBody := rmcResponseStream.Bytes() + + rmcResponse.SetSuccess(ranking.MethodGetRanking, rmcResponseBody) + } + + rmcResponseBytes := rmcResponse.Bytes() + + var responsePacket nex.PacketInterface + + if server.PRUDPVersion() == 0 { + responsePacket, _ = nex.NewPacketV0(client, nil) + responsePacket.SetVersion(0) + } else { + responsePacket, _ = nex.NewPacketV1(client, nil) + responsePacket.SetVersion(1) + } + + responsePacket.SetSource(0xA1) + responsePacket.SetDestination(0xAF) + responsePacket.SetType(nex.DataPacket) + responsePacket.SetPayload(rmcResponseBytes) + + responsePacket.AddFlag(nex.FlagNeedsAck) + responsePacket.AddFlag(nex.FlagReliable) + + server.Send(responsePacket) + + return 0 +} diff --git a/ranking/protocol.go b/ranking/protocol.go new file mode 100644 index 0000000..756351e --- /dev/null +++ b/ranking/protocol.go @@ -0,0 +1,89 @@ +package ranking + +import ( + "strings" + + "github.com/PretendoNetwork/nex-go" + _ "github.com/PretendoNetwork/nex-protocols-go" + ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" + ranking_mario_kart_8 "github.com/PretendoNetwork/nex-protocols-go/ranking/mario-kart-8" + ranking_types "github.com/PretendoNetwork/nex-protocols-go/ranking/types" + "github.com/PretendoNetwork/plogger-go" +) + +var commonRankingProtocol *CommonRankingProtocol +var logger = plogger.NewLogger() + +type CommonRankingProtocol struct { + server *nex.Server + DefaultProtocol *ranking.Protocol + MarioKart8Protocol *ranking_mario_kart_8.Protocol + + getCommonDataHandler func(unique_id uint64) (error, []byte) + uploadCommonDataHandler func(pid uint32, uniqueID uint64, commonData []byte) error + insertRankingByPIDAndRankingScoreDataHandler func(pid uint32, rankingScoreData *ranking_types.RankingScoreData, uniqueID uint64) error + getRankingsAndCountByCategoryAndRankingOrderParamHandler func(category uint32, rankingOrderParam *ranking_types.RankingOrderParam) (error, []*ranking_types.RankingRankData, uint32) +} + +// GetCommonData sets the GetCommonData handler function +func (commonRankingProtocol *CommonRankingProtocol) GetCommonData(handler func(unique_id uint64) (error, []byte)) { + commonRankingProtocol.getCommonDataHandler = handler +} + +// UploadCommonData sets the UploadCommonData handler function +func (commonRankingProtocol *CommonRankingProtocol) UploadCommonData(handler func(pid uint32, uniqueID uint64, commonData []byte) error) { + commonRankingProtocol.uploadCommonDataHandler = handler +} + +// InsertRankingByPIDAndRankingScoreData sets the InsertRankingByPIDAndRankingScoreData handler function +func (commonRankingProtocol *CommonRankingProtocol) InsertRankingByPIDAndRankingScoreData(handler func(pid uint32, rankingScoreData *ranking_types.RankingScoreData, uniqueID uint64) error) { + commonRankingProtocol.insertRankingByPIDAndRankingScoreDataHandler = handler +} + +// GetRankingsAndCountByCategoryAndRankingOrderParam sets the GetRankingsAndCountByCategoryAndRankingOrderParam handler function +func (commonRankingProtocol *CommonRankingProtocol) GetRankingsAndCountByCategoryAndRankingOrderParam(handler func(category uint32, rankingOrderParam *ranking_types.RankingOrderParam) (error, []*ranking_types.RankingRankData, uint32)) { + commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler = handler +} + +func initDefault(c *CommonRankingProtocol) { + // TODO - Organize by method ID + c.DefaultProtocol = ranking.NewProtocol(c.server) + c.DefaultProtocol.GetCachedTopXRanking(getCachedTopXRanking) + c.DefaultProtocol.GetCachedTopXRankings(getCachedTopXRankings) + c.DefaultProtocol.GetCommonData(getCommonData) + c.DefaultProtocol.GetRanking(getRanking) + c.DefaultProtocol.UploadCommonData(uploadCommonData) + c.DefaultProtocol.UploadScore(uploadScore) +} + +func initMarioKart8(c *CommonRankingProtocol) { + // TODO - Organize by method ID + c.MarioKart8Protocol = ranking_mario_kart_8.NewProtocol(c.server) + c.MarioKart8Protocol.GetCachedTopXRanking(getCachedTopXRanking) + c.MarioKart8Protocol.GetCachedTopXRankings(getCachedTopXRankings) + c.MarioKart8Protocol.GetCommonData(getCommonData) + c.MarioKart8Protocol.GetRanking(getRanking) + c.MarioKart8Protocol.UploadCommonData(uploadCommonData) + c.MarioKart8Protocol.UploadScore(uploadScore) +} + +// NewCommonRankingProtocol returns a new CommonRankingProtocol +func NewCommonRankingProtocol(server *nex.Server) *CommonRankingProtocol { + commonRankingProtocol = &CommonRankingProtocol{server: server} + + patch := server.MatchMakingProtocolVersion().GameSpecificPatch + + if strings.EqualFold(patch, "AMKJ") { + logger.Info("Using Mario Kart 8 Ranking protocol") + initMarioKart8(commonRankingProtocol) + } else { + if patch != "" { + logger.Infof("Ranking version patch %q not recognized", patch) + } + + logger.Info("Using default Ranking protocol") + initDefault(commonRankingProtocol) + } + + return commonRankingProtocol +} diff --git a/ranking/upload_common_data.go b/ranking/upload_common_data.go new file mode 100644 index 0000000..30d5dc4 --- /dev/null +++ b/ranking/upload_common_data.go @@ -0,0 +1,52 @@ +package ranking + +import ( + "github.com/PretendoNetwork/nex-go" + ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" +) + +func uploadCommonData(err error, client *nex.Client, callID uint32, commonData []byte, uniqueID uint64) uint32 { + if commonRankingProtocol.uploadCommonDataHandler == nil { + logger.Warning("Ranking::UploadCommonData missing UploadCommonDataHandler!") + return nex.Errors.Core.NotImplemented + } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) + server := client.Server() + + if err != nil { + logger.Error(err.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } + + insertErr := commonRankingProtocol.uploadCommonDataHandler(client.PID(), uniqueID, commonData) + if insertErr != nil { + logger.Error(insertErr.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } else { + rmcResponse.SetSuccess(ranking.MethodUploadCommonData, nil) + } + + rmcResponseBytes := rmcResponse.Bytes() + + var responsePacket nex.PacketInterface + + if server.PRUDPVersion() == 0 { + responsePacket, _ = nex.NewPacketV0(client, nil) + responsePacket.SetVersion(0) + } else { + responsePacket, _ = nex.NewPacketV1(client, nil) + responsePacket.SetVersion(1) + } + + responsePacket.SetSource(0xA1) + responsePacket.SetDestination(0xAF) + responsePacket.SetType(nex.DataPacket) + responsePacket.SetPayload(rmcResponseBytes) + + responsePacket.AddFlag(nex.FlagNeedsAck) + responsePacket.AddFlag(nex.FlagReliable) + + server.Send(responsePacket) + + return 0 +} diff --git a/ranking/upload_score.go b/ranking/upload_score.go new file mode 100644 index 0000000..01abc78 --- /dev/null +++ b/ranking/upload_score.go @@ -0,0 +1,53 @@ +package ranking + +import ( + "github.com/PretendoNetwork/nex-go" + ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" + ranking_types "github.com/PretendoNetwork/nex-protocols-go/ranking/types" +) + +func uploadScore(err error, client *nex.Client, callID uint32, scoreData *ranking_types.RankingScoreData, uniqueID uint64) uint32 { + if commonRankingProtocol.insertRankingByPIDAndRankingScoreDataHandler == nil { + logger.Warning("Ranking::UploadScore missing InsertRankingByPIDAndRankingScoreDataHandler!") + return nex.Errors.Core.NotImplemented + } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) + server := client.Server() + + if err != nil { + logger.Error(err.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } + + insertErr := commonRankingProtocol.insertRankingByPIDAndRankingScoreDataHandler(client.PID(), scoreData, uniqueID) + if insertErr != nil { + logger.Error(insertErr.Error()) + rmcResponse.SetError(nex.Errors.Ranking.Unknown) + } else { + rmcResponse.SetSuccess(ranking.MethodUploadScore, nil) + } + + rmcResponseBytes := rmcResponse.Bytes() + + var responsePacket nex.PacketInterface + + if server.PRUDPVersion() == 0 { + responsePacket, _ = nex.NewPacketV0(client, nil) + responsePacket.SetVersion(0) + } else { + responsePacket, _ = nex.NewPacketV1(client, nil) + responsePacket.SetVersion(1) + } + + responsePacket.SetSource(0xA1) + responsePacket.SetDestination(0xAF) + responsePacket.SetType(nex.DataPacket) + responsePacket.SetPayload(rmcResponseBytes) + + responsePacket.AddFlag(nex.FlagNeedsAck) + responsePacket.AddFlag(nex.FlagReliable) + + server.Send(responsePacket) + + return 0 +} From d60b6b58ad29a58ad850608362931cd2eafe3bce Mon Sep 17 00:00:00 2001 From: shutterbug2000 Date: Wed, 11 Oct 2023 05:28:34 -0500 Subject: [PATCH 2/6] Code review changes --- ranking/get_cached_top_x_ranking.go | 35 ++++++++++++++-------------- ranking/get_cached_top_x_rankings.go | 32 ++++++++++++------------- ranking/get_common_data.go | 18 +++++++------- ranking/get_ranking.go | 27 +++++++++++---------- ranking/upload_common_data.go | 10 ++++---- ranking/upload_score.go | 10 ++++---- 6 files changed, 65 insertions(+), 67 deletions(-) diff --git a/ranking/get_cached_top_x_ranking.go b/ranking/get_cached_top_x_ranking.go index fa0e257..d8bdd33 100644 --- a/ranking/get_cached_top_x_ranking.go +++ b/ranking/get_cached_top_x_ranking.go @@ -11,44 +11,43 @@ func getCachedTopXRanking(err error, client *nex.Client, callID uint32, category logger.Warning("Ranking::GetCachedTopXRanking missing GetRankingsAndCountByCategoryAndRankingOrderParamHandler!") return nex.Errors.Core.NotImplemented } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() if err != nil { logger.Error(err.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) + return nex.Errors.Ranking.InvalidArgument } err, rankDataList, totalCount := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(category, orderParam) if err != nil { - logger.Error(err.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) + logger.Critical(err.Error()) + return nex.Errors.Ranking.Unknown } if totalCount == 0 || len(rankDataList) == 0 { - rmcResponse.SetError(nex.Errors.Ranking.NotFound) + return nex.Errors.Ranking.NotFound } - if err == nil && totalCount != 0 { - rankingResult := ranking_types.NewRankingResult() + rankingResult := ranking_types.NewRankingResult() - rankingResult.RankDataList = rankDataList - rankingResult.TotalCount = totalCount - rankingResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back + rankingResult.RankDataList = rankDataList + rankingResult.TotalCount = totalCount + rankingResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back - pResult := ranking_types.NewRankingCachedResult() - pResult.CreatedTime = nex.NewDateTime(0x1f40420000) //TODO: does this matter? - pResult.ExpiredTime = nex.NewDateTime(0x1f40420000) //TODO: does this matter? - pResult.MaxLength = 0 + pResult := ranking_types.NewRankingCachedResult() + pResult.CreatedTime = nex.NewDateTime(nex.NewDateTime(serverTime.UTC())) + pResult.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC()+300)) //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + pResult.MaxLength = 10 //This is the length Ultimate NES Remix uses. TODO: Does this matter? and are other games different? - rmcResponseStream := nex.NewStreamOut(server) + rmcResponseStream := nex.NewStreamOut(server) - rmcResponseStream.WriteStructure(pResult) + rmcResponseStream.WriteStructure(pResult) - rmcResponseBody := rmcResponseStream.Bytes() + rmcResponseBody := rmcResponseStream.Bytes() - rmcResponse.SetSuccess(ranking.MethodGetCachedTopXRanking, rmcResponseBody) - } + rmcResponse.SetSuccess(ranking.MethodGetCachedTopXRanking, rmcResponseBody) rmcResponseBytes := rmcResponse.Bytes() diff --git a/ranking/get_cached_top_x_rankings.go b/ranking/get_cached_top_x_rankings.go index 5d1d17f..c56bcaa 100644 --- a/ranking/get_cached_top_x_rankings.go +++ b/ranking/get_cached_top_x_rankings.go @@ -11,40 +11,40 @@ func getCachedTopXRankings(err error, client *nex.Client, callID uint32, categor logger.Warning("Ranking::GetCachedTopXRankings missing GetRankingsAndCountByCategoryAndRankingOrderParamHandler!") return nex.Errors.Core.NotImplemented } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() if err != nil { logger.Error(err.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) + return nex.Errors.Ranking.InvalidArgument } var pResult []*ranking_types.RankingCachedResult for i := 0; i < len(categories); i++ { err, rankDataList, totalCount := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(categories[i], orderParams[i]) if err != nil { - logger.Error(err.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) + logger.Critical(err.Error()) + return nex.Errors.Ranking.Unknown } if totalCount == 0 || len(rankDataList) == 0 { - rmcResponse.SetError(nex.Errors.Ranking.NotFound) + return nex.Errors.Ranking.NotFound } - if err == nil && totalCount != 0 { - rankingResult := ranking_types.NewRankingResult() + rankingResult := ranking_types.NewRankingResult() - rankingResult.RankDataList = rankDataList - rankingResult.TotalCount = totalCount - rankingResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back + rankingResult.RankDataList = rankDataList + rankingResult.TotalCount = totalCount + rankingResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back - result := ranking_types.NewRankingCachedResult() - result.CreatedTime = nex.NewDateTime(0x1f40420000) //TODO: does this matter? - result.ExpiredTime = nex.NewDateTime(0x1f40420000) //TODO: does this matter? - result.MaxLength = 0 - result.SetParentType(rankingResult) - pResult = append(pResult, result) - } + result := ranking_types.NewRankingCachedResult() + pResult.CreatedTime = nex.NewDateTime(nex.NewDateTime(serverTime.UTC())) + pResult.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC()+300)) //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + pResult.MaxLength = 10 //This is the length Ultimate NES Remix uses. TODO: Does this matter? and are other games different? + + result.SetParentType(rankingResult) + pResult = append(pResult, result) rmcResponseStream := nex.NewStreamOut(server) rmcResponseStream.WriteListStructure(pResult) diff --git a/ranking/get_common_data.go b/ranking/get_common_data.go index ad57942..a671dce 100644 --- a/ranking/get_common_data.go +++ b/ranking/get_common_data.go @@ -10,25 +10,25 @@ func getCommonData(err error, client *nex.Client, callID uint32, uniqueID uint64 logger.Warning("Ranking::GetCommonData missing GetCommonDataHandler!") return nex.Errors.Core.NotImplemented } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() if err != nil { logger.Error(err.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) + return nex.Errors.Ranking.InvalidArgument } commonDataErr, commonData := commonRankingProtocol.getCommonDataHandler(uniqueID) - if commonDataErr == nil { - rmcResponseStream := nex.NewStreamOut(server) - - rmcResponseStream.WriteBuffer(commonData) - - rmcResponseBody := rmcResponseStream.Bytes() - - rmcResponse.SetSuccess(ranking.MethodGetCommonData, rmcResponseBody) + if commonDataErr != nil { + return nex.Errors.Ranking.NotFound } + + rmcResponseStream := nex.NewStreamOut(server) + rmcResponseStream.WriteBuffer(commonData) + rmcResponseBody := rmcResponseStream.Bytes() + rmcResponse.SetSuccess(ranking.MethodGetCommonData, rmcResponseBody) rmcResponseBytes := rmcResponse.Bytes() diff --git a/ranking/get_ranking.go b/ranking/get_ranking.go index 9a879d2..7c7dc18 100644 --- a/ranking/get_ranking.go +++ b/ranking/get_ranking.go @@ -11,39 +11,38 @@ func getRanking(err error, client *nex.Client, callID uint32, rankingMode uint8, logger.Warning("Ranking::GetRanking missing GetRankingsAndCountByCategoryAndRankingOrderParamHandler!") return nex.Errors.Core.NotImplemented } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() if err != nil { logger.Error(err.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) + return nex.Errors.Ranking.InvalidArgument } err, rankDataList, totalCount := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(category, orderParam) if err != nil { - logger.Error(err.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) + logger.Critical(err.Error()) + return nex.Errors.Ranking.Unknown } if totalCount == 0 || len(rankDataList) == 0 { - rmcResponse.SetError(nex.Errors.Ranking.NotFound) + return nex.Errors.Ranking.NotFound } - if err == nil && totalCount != 0 { - pResult := ranking_types.NewRankingResult() + pResult := ranking_types.NewRankingResult() - pResult.RankDataList = rankDataList - pResult.TotalCount = totalCount - pResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back + pResult.RankDataList = rankDataList + pResult.TotalCount = totalCount + pResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back - rmcResponseStream := nex.NewStreamOut(server) + rmcResponseStream := nex.NewStreamOut(server) - rmcResponseStream.WriteStructure(pResult) + rmcResponseStream.WriteStructure(pResult) - rmcResponseBody := rmcResponseStream.Bytes() + rmcResponseBody := rmcResponseStream.Bytes() - rmcResponse.SetSuccess(ranking.MethodGetRanking, rmcResponseBody) - } + rmcResponse.SetSuccess(ranking.MethodGetRanking, rmcResponseBody) rmcResponseBytes := rmcResponse.Bytes() diff --git a/ranking/upload_common_data.go b/ranking/upload_common_data.go index 30d5dc4..dadb50a 100644 --- a/ranking/upload_common_data.go +++ b/ranking/upload_common_data.go @@ -15,16 +15,16 @@ func uploadCommonData(err error, client *nex.Client, callID uint32, commonData [ if err != nil { logger.Error(err.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) + return nex.Errors.Ranking.InvalidArgument } insertErr := commonRankingProtocol.uploadCommonDataHandler(client.PID(), uniqueID, commonData) if insertErr != nil { - logger.Error(insertErr.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) - } else { - rmcResponse.SetSuccess(ranking.MethodUploadCommonData, nil) + logger.Critical(insertErr.Error()) + return nex.Errors.Ranking.Unknown } + + rmcResponse.SetSuccess(ranking.MethodUploadCommonData, nil) rmcResponseBytes := rmcResponse.Bytes() diff --git a/ranking/upload_score.go b/ranking/upload_score.go index 01abc78..d341418 100644 --- a/ranking/upload_score.go +++ b/ranking/upload_score.go @@ -16,17 +16,17 @@ func uploadScore(err error, client *nex.Client, callID uint32, scoreData *rankin if err != nil { logger.Error(err.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) + return nex.Errors.Ranking.InvalidArgument } insertErr := commonRankingProtocol.insertRankingByPIDAndRankingScoreDataHandler(client.PID(), scoreData, uniqueID) if insertErr != nil { - logger.Error(insertErr.Error()) - rmcResponse.SetError(nex.Errors.Ranking.Unknown) - } else { - rmcResponse.SetSuccess(ranking.MethodUploadScore, nil) + logger.Critical(insertErr.Error()) + return nex.Errors.Ranking.Unknown } + rmcResponse.SetSuccess(ranking.MethodUploadScore, nil) + rmcResponseBytes := rmcResponse.Bytes() var responsePacket nex.PacketInterface From 6b243dea5616197e46e5306d05659e8ff98eb7e6 Mon Sep 17 00:00:00 2001 From: shutterbug2000 Date: Wed, 11 Oct 2023 05:37:20 -0500 Subject: [PATCH 3/6] Fix compile errors and move returned errors to end --- ranking/get_cached_top_x_ranking.go | 9 ++++++--- ranking/get_cached_top_x_rankings.go | 11 +++++++---- ranking/get_common_data.go | 2 +- ranking/get_ranking.go | 2 +- ranking/protocol.go | 8 ++++---- 5 files changed, 19 insertions(+), 13 deletions(-) diff --git a/ranking/get_cached_top_x_ranking.go b/ranking/get_cached_top_x_ranking.go index d8bdd33..cf0c7b2 100644 --- a/ranking/get_cached_top_x_ranking.go +++ b/ranking/get_cached_top_x_ranking.go @@ -4,6 +4,8 @@ import ( "github.com/PretendoNetwork/nex-go" ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" ranking_types "github.com/PretendoNetwork/nex-protocols-go/ranking/types" + + "time" ) func getCachedTopXRanking(err error, client *nex.Client, callID uint32, category uint32, orderParam *ranking_types.RankingOrderParam) uint32 { @@ -20,7 +22,7 @@ func getCachedTopXRanking(err error, client *nex.Client, callID uint32, category return nex.Errors.Ranking.InvalidArgument } - err, rankDataList, totalCount := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(category, orderParam) + rankDataList, totalCount, err := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(category, orderParam) if err != nil { logger.Critical(err.Error()) return nex.Errors.Ranking.Unknown @@ -37,8 +39,9 @@ func getCachedTopXRanking(err error, client *nex.Client, callID uint32, category rankingResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back pResult := ranking_types.NewRankingCachedResult() - pResult.CreatedTime = nex.NewDateTime(nex.NewDateTime(serverTime.UTC())) - pResult.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC()+300)) //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + serverTime := nex.NewDateTime(0) + pResult.CreatedTime = nex.NewDateTime(serverTime.UTC()) + pResult.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC().Add(time.Minute * time.Duration(5)))) //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. pResult.MaxLength = 10 //This is the length Ultimate NES Remix uses. TODO: Does this matter? and are other games different? rmcResponseStream := nex.NewStreamOut(server) diff --git a/ranking/get_cached_top_x_rankings.go b/ranking/get_cached_top_x_rankings.go index c56bcaa..f263b03 100644 --- a/ranking/get_cached_top_x_rankings.go +++ b/ranking/get_cached_top_x_rankings.go @@ -4,6 +4,8 @@ import ( "github.com/PretendoNetwork/nex-go" ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" ranking_types "github.com/PretendoNetwork/nex-protocols-go/ranking/types" + + "time" ) func getCachedTopXRankings(err error, client *nex.Client, callID uint32, categories []uint32, orderParams []*ranking_types.RankingOrderParam) uint32 { @@ -22,7 +24,7 @@ func getCachedTopXRankings(err error, client *nex.Client, callID uint32, categor var pResult []*ranking_types.RankingCachedResult for i := 0; i < len(categories); i++ { - err, rankDataList, totalCount := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(categories[i], orderParams[i]) + rankDataList, totalCount, err := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(categories[i], orderParams[i]) if err != nil { logger.Critical(err.Error()) return nex.Errors.Ranking.Unknown @@ -39,9 +41,10 @@ func getCachedTopXRankings(err error, client *nex.Client, callID uint32, categor rankingResult.SinceTime = nex.NewDateTime(0x1f40420000) // * 2000-01-01T00:00:00.000Z, this is what the real server sends back result := ranking_types.NewRankingCachedResult() - pResult.CreatedTime = nex.NewDateTime(nex.NewDateTime(serverTime.UTC())) - pResult.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC()+300)) //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. - pResult.MaxLength = 10 //This is the length Ultimate NES Remix uses. TODO: Does this matter? and are other games different? + serverTime := nex.NewDateTime(0) + result.CreatedTime = nex.NewDateTime(serverTime.UTC()) + result.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC().Add(time.Minute * time.Duration(5)))) //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + result.MaxLength = 10 //This is the length Ultimate NES Remix uses. TODO: Does this matter? and are other games different? result.SetParentType(rankingResult) pResult = append(pResult, result) diff --git a/ranking/get_common_data.go b/ranking/get_common_data.go index a671dce..b911757 100644 --- a/ranking/get_common_data.go +++ b/ranking/get_common_data.go @@ -19,7 +19,7 @@ func getCommonData(err error, client *nex.Client, callID uint32, uniqueID uint64 return nex.Errors.Ranking.InvalidArgument } - commonDataErr, commonData := commonRankingProtocol.getCommonDataHandler(uniqueID) + commonData, commonDataErr := commonRankingProtocol.getCommonDataHandler(uniqueID) if commonDataErr != nil { return nex.Errors.Ranking.NotFound diff --git a/ranking/get_ranking.go b/ranking/get_ranking.go index 7c7dc18..a0cade1 100644 --- a/ranking/get_ranking.go +++ b/ranking/get_ranking.go @@ -20,7 +20,7 @@ func getRanking(err error, client *nex.Client, callID uint32, rankingMode uint8, return nex.Errors.Ranking.InvalidArgument } - err, rankDataList, totalCount := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(category, orderParam) + rankDataList, totalCount, err := commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler(category, orderParam) if err != nil { logger.Critical(err.Error()) return nex.Errors.Ranking.Unknown diff --git a/ranking/protocol.go b/ranking/protocol.go index 756351e..8d24296 100644 --- a/ranking/protocol.go +++ b/ranking/protocol.go @@ -19,14 +19,14 @@ type CommonRankingProtocol struct { DefaultProtocol *ranking.Protocol MarioKart8Protocol *ranking_mario_kart_8.Protocol - getCommonDataHandler func(unique_id uint64) (error, []byte) + getCommonDataHandler func(unique_id uint64) ([]byte, error) uploadCommonDataHandler func(pid uint32, uniqueID uint64, commonData []byte) error insertRankingByPIDAndRankingScoreDataHandler func(pid uint32, rankingScoreData *ranking_types.RankingScoreData, uniqueID uint64) error - getRankingsAndCountByCategoryAndRankingOrderParamHandler func(category uint32, rankingOrderParam *ranking_types.RankingOrderParam) (error, []*ranking_types.RankingRankData, uint32) + getRankingsAndCountByCategoryAndRankingOrderParamHandler func(category uint32, rankingOrderParam *ranking_types.RankingOrderParam) ([]*ranking_types.RankingRankData, uint32, error) } // GetCommonData sets the GetCommonData handler function -func (commonRankingProtocol *CommonRankingProtocol) GetCommonData(handler func(unique_id uint64) (error, []byte)) { +func (commonRankingProtocol *CommonRankingProtocol) GetCommonData(handler func(unique_id uint64) ([]byte, error)) { commonRankingProtocol.getCommonDataHandler = handler } @@ -41,7 +41,7 @@ func (commonRankingProtocol *CommonRankingProtocol) InsertRankingByPIDAndRanking } // GetRankingsAndCountByCategoryAndRankingOrderParam sets the GetRankingsAndCountByCategoryAndRankingOrderParam handler function -func (commonRankingProtocol *CommonRankingProtocol) GetRankingsAndCountByCategoryAndRankingOrderParam(handler func(category uint32, rankingOrderParam *ranking_types.RankingOrderParam) (error, []*ranking_types.RankingRankData, uint32)) { +func (commonRankingProtocol *CommonRankingProtocol) GetRankingsAndCountByCategoryAndRankingOrderParam(handler func(category uint32, rankingOrderParam *ranking_types.RankingOrderParam) ([]*ranking_types.RankingRankData, uint32, error)) { commonRankingProtocol.getRankingsAndCountByCategoryAndRankingOrderParamHandler = handler } From 962aecdbd5c4bea50c4e505c5221242a79f91f5e Mon Sep 17 00:00:00 2001 From: shutterbug2000 Date: Wed, 11 Oct 2023 05:39:01 -0500 Subject: [PATCH 4/6] Adjust spacing --- ranking/upload_common_data.go | 3 ++- ranking/upload_score.go | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/ranking/upload_common_data.go b/ranking/upload_common_data.go index dadb50a..36696ac 100644 --- a/ranking/upload_common_data.go +++ b/ranking/upload_common_data.go @@ -10,6 +10,7 @@ func uploadCommonData(err error, client *nex.Client, callID uint32, commonData [ logger.Warning("Ranking::UploadCommonData missing UploadCommonDataHandler!") return nex.Errors.Core.NotImplemented } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() @@ -23,7 +24,7 @@ func uploadCommonData(err error, client *nex.Client, callID uint32, commonData [ logger.Critical(insertErr.Error()) return nex.Errors.Ranking.Unknown } - + rmcResponse.SetSuccess(ranking.MethodUploadCommonData, nil) rmcResponseBytes := rmcResponse.Bytes() diff --git a/ranking/upload_score.go b/ranking/upload_score.go index d341418..6e347d0 100644 --- a/ranking/upload_score.go +++ b/ranking/upload_score.go @@ -11,6 +11,7 @@ func uploadScore(err error, client *nex.Client, callID uint32, scoreData *rankin logger.Warning("Ranking::UploadScore missing InsertRankingByPIDAndRankingScoreDataHandler!") return nex.Errors.Core.NotImplemented } + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() From 470f32c0de0e91e9058a22f649ac4799a8a5aa64 Mon Sep 17 00:00:00 2001 From: shutterbug2000 Date: Wed, 11 Oct 2023 07:50:27 -0500 Subject: [PATCH 5/6] Code Review Changes --- ranking/get_cached_top_x_ranking.go | 5 +++-- ranking/get_cached_top_x_rankings.go | 16 +++++++++------- ranking/get_common_data.go | 7 ++++--- ranking/get_ranking.go | 2 +- ranking/protocol.go | 1 - ranking/upload_common_data.go | 12 ++++++------ ranking/upload_score.go | 12 ++++++------ 7 files changed, 29 insertions(+), 26 deletions(-) diff --git a/ranking/get_cached_top_x_ranking.go b/ranking/get_cached_top_x_ranking.go index cf0c7b2..d7a26d5 100644 --- a/ranking/get_cached_top_x_ranking.go +++ b/ranking/get_cached_top_x_ranking.go @@ -14,7 +14,6 @@ func getCachedTopXRanking(err error, client *nex.Client, callID uint32, category return nex.Errors.Core.NotImplemented } - rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() if err != nil { @@ -41,7 +40,8 @@ func getCachedTopXRanking(err error, client *nex.Client, callID uint32, category pResult := ranking_types.NewRankingCachedResult() serverTime := nex.NewDateTime(0) pResult.CreatedTime = nex.NewDateTime(serverTime.UTC()) - pResult.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC().Add(time.Minute * time.Duration(5)))) //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + pResult.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC().Add(time.Minute * time.Duration(5)))) pResult.MaxLength = 10 //This is the length Ultimate NES Remix uses. TODO: Does this matter? and are other games different? rmcResponseStream := nex.NewStreamOut(server) @@ -50,6 +50,7 @@ func getCachedTopXRanking(err error, client *nex.Client, callID uint32, category rmcResponseBody := rmcResponseStream.Bytes() + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) rmcResponse.SetSuccess(ranking.MethodGetCachedTopXRanking, rmcResponseBody) rmcResponseBytes := rmcResponse.Bytes() diff --git a/ranking/get_cached_top_x_rankings.go b/ranking/get_cached_top_x_rankings.go index f263b03..6ceaa63 100644 --- a/ranking/get_cached_top_x_rankings.go +++ b/ranking/get_cached_top_x_rankings.go @@ -14,7 +14,6 @@ func getCachedTopXRankings(err error, client *nex.Client, callID uint32, categor return nex.Errors.Core.NotImplemented } - rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() if err != nil { @@ -43,18 +42,21 @@ func getCachedTopXRankings(err error, client *nex.Client, callID uint32, categor result := ranking_types.NewRankingCachedResult() serverTime := nex.NewDateTime(0) result.CreatedTime = nex.NewDateTime(serverTime.UTC()) - result.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC().Add(time.Minute * time.Duration(5)))) //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + result.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC().Add(time.Minute * time.Duration(5)))) result.MaxLength = 10 //This is the length Ultimate NES Remix uses. TODO: Does this matter? and are other games different? result.SetParentType(rankingResult) pResult = append(pResult, result) - - rmcResponseStream := nex.NewStreamOut(server) - rmcResponseStream.WriteListStructure(pResult) - rmcResponseBody := rmcResponseStream.Bytes() - rmcResponse.SetSuccess(ranking.MethodGetCachedTopXRankings, rmcResponseBody) } + rmcResponseStream := nex.NewStreamOut(server) + rmcResponseStream.WriteListStructure(pResult) + rmcResponseBody := rmcResponseStream.Bytes() + + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) + rmcResponse.SetSuccess(ranking.MethodGetCachedTopXRankings, rmcResponseBody) + rmcResponseBytes := rmcResponse.Bytes() var responsePacket nex.PacketInterface diff --git a/ranking/get_common_data.go b/ranking/get_common_data.go index b911757..b9576e9 100644 --- a/ranking/get_common_data.go +++ b/ranking/get_common_data.go @@ -11,7 +11,6 @@ func getCommonData(err error, client *nex.Client, callID uint32, uniqueID uint64 return nex.Errors.Core.NotImplemented } - rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() if err != nil { @@ -19,15 +18,17 @@ func getCommonData(err error, client *nex.Client, callID uint32, uniqueID uint64 return nex.Errors.Ranking.InvalidArgument } - commonData, commonDataErr := commonRankingProtocol.getCommonDataHandler(uniqueID) + commonData, err := commonRankingProtocol.getCommonDataHandler(uniqueID) - if commonDataErr != nil { + if err != nil { return nex.Errors.Ranking.NotFound } rmcResponseStream := nex.NewStreamOut(server) rmcResponseStream.WriteBuffer(commonData) rmcResponseBody := rmcResponseStream.Bytes() + + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) rmcResponse.SetSuccess(ranking.MethodGetCommonData, rmcResponseBody) rmcResponseBytes := rmcResponse.Bytes() diff --git a/ranking/get_ranking.go b/ranking/get_ranking.go index a0cade1..b45139a 100644 --- a/ranking/get_ranking.go +++ b/ranking/get_ranking.go @@ -12,7 +12,6 @@ func getRanking(err error, client *nex.Client, callID uint32, rankingMode uint8, return nex.Errors.Core.NotImplemented } - rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) server := client.Server() if err != nil { @@ -42,6 +41,7 @@ func getRanking(err error, client *nex.Client, callID uint32, rankingMode uint8, rmcResponseBody := rmcResponseStream.Bytes() + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) rmcResponse.SetSuccess(ranking.MethodGetRanking, rmcResponseBody) rmcResponseBytes := rmcResponse.Bytes() diff --git a/ranking/protocol.go b/ranking/protocol.go index 8d24296..5614db8 100644 --- a/ranking/protocol.go +++ b/ranking/protocol.go @@ -4,7 +4,6 @@ import ( "strings" "github.com/PretendoNetwork/nex-go" - _ "github.com/PretendoNetwork/nex-protocols-go" ranking "github.com/PretendoNetwork/nex-protocols-go/ranking" ranking_mario_kart_8 "github.com/PretendoNetwork/nex-protocols-go/ranking/mario-kart-8" ranking_types "github.com/PretendoNetwork/nex-protocols-go/ranking/types" diff --git a/ranking/upload_common_data.go b/ranking/upload_common_data.go index 36696ac..f3c90dd 100644 --- a/ranking/upload_common_data.go +++ b/ranking/upload_common_data.go @@ -10,8 +10,7 @@ func uploadCommonData(err error, client *nex.Client, callID uint32, commonData [ logger.Warning("Ranking::UploadCommonData missing UploadCommonDataHandler!") return nex.Errors.Core.NotImplemented } - - rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) + server := client.Server() if err != nil { @@ -19,12 +18,13 @@ func uploadCommonData(err error, client *nex.Client, callID uint32, commonData [ return nex.Errors.Ranking.InvalidArgument } - insertErr := commonRankingProtocol.uploadCommonDataHandler(client.PID(), uniqueID, commonData) - if insertErr != nil { - logger.Critical(insertErr.Error()) + err = commonRankingProtocol.uploadCommonDataHandler(client.PID(), uniqueID, commonData) + if err != nil { + logger.Critical(err.Error()) return nex.Errors.Ranking.Unknown } - + + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) rmcResponse.SetSuccess(ranking.MethodUploadCommonData, nil) rmcResponseBytes := rmcResponse.Bytes() diff --git a/ranking/upload_score.go b/ranking/upload_score.go index 6e347d0..460e67c 100644 --- a/ranking/upload_score.go +++ b/ranking/upload_score.go @@ -11,8 +11,7 @@ func uploadScore(err error, client *nex.Client, callID uint32, scoreData *rankin logger.Warning("Ranking::UploadScore missing InsertRankingByPIDAndRankingScoreDataHandler!") return nex.Errors.Core.NotImplemented } - - rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) + server := client.Server() if err != nil { @@ -20,12 +19,13 @@ func uploadScore(err error, client *nex.Client, callID uint32, scoreData *rankin return nex.Errors.Ranking.InvalidArgument } - insertErr := commonRankingProtocol.insertRankingByPIDAndRankingScoreDataHandler(client.PID(), scoreData, uniqueID) - if insertErr != nil { - logger.Critical(insertErr.Error()) + err = commonRankingProtocol.insertRankingByPIDAndRankingScoreDataHandler(client.PID(), scoreData, uniqueID) + if err != nil { + logger.Critical(err.Error()) return nex.Errors.Ranking.Unknown } - + + rmcResponse := nex.NewRMCResponse(ranking.ProtocolID, callID) rmcResponse.SetSuccess(ranking.MethodUploadScore, nil) rmcResponseBytes := rmcResponse.Bytes() From f495b0b755526b4dc81ab6ee6cd0bd7f04a15982 Mon Sep 17 00:00:00 2001 From: shutterbug2000 Date: Wed, 11 Oct 2023 08:04:09 -0500 Subject: [PATCH 6/6] Formatting fixes --- ranking/get_cached_top_x_ranking.go | 4 +++- ranking/get_cached_top_x_rankings.go | 4 +++- ranking/get_common_data.go | 1 - 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/ranking/get_cached_top_x_ranking.go b/ranking/get_cached_top_x_ranking.go index d7a26d5..5201a2d 100644 --- a/ranking/get_cached_top_x_ranking.go +++ b/ranking/get_cached_top_x_ranking.go @@ -40,7 +40,9 @@ func getCachedTopXRanking(err error, client *nex.Client, callID uint32, category pResult := ranking_types.NewRankingCachedResult() serverTime := nex.NewDateTime(0) pResult.CreatedTime = nex.NewDateTime(serverTime.UTC()) - //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + //The real server sends the "CreatedTime" + 5 minutes. + //It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). + //Whether we need to replicate this idk, but in case, here's a note. pResult.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC().Add(time.Minute * time.Duration(5)))) pResult.MaxLength = 10 //This is the length Ultimate NES Remix uses. TODO: Does this matter? and are other games different? diff --git a/ranking/get_cached_top_x_rankings.go b/ranking/get_cached_top_x_rankings.go index 6ceaa63..b34ee58 100644 --- a/ranking/get_cached_top_x_rankings.go +++ b/ranking/get_cached_top_x_rankings.go @@ -42,7 +42,9 @@ func getCachedTopXRankings(err error, client *nex.Client, callID uint32, categor result := ranking_types.NewRankingCachedResult() serverTime := nex.NewDateTime(0) result.CreatedTime = nex.NewDateTime(serverTime.UTC()) - //The real server sends the "CreatedTime" + 5 minutes. It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). Whether we need to replicate this idk, but in case, here's a note. + //The real server sends the "CreatedTime" + 5 minutes. + //It doesn't change, even on subsequent requests, until after the ExpiredTime has passed (seemingly what the "cached" means). + //Whether we need to replicate this idk, but in case, here's a note. result.ExpiredTime = nex.NewDateTime(serverTime.FromTimestamp(time.Now().UTC().Add(time.Minute * time.Duration(5)))) result.MaxLength = 10 //This is the length Ultimate NES Remix uses. TODO: Does this matter? and are other games different? diff --git a/ranking/get_common_data.go b/ranking/get_common_data.go index b9576e9..a3e4c84 100644 --- a/ranking/get_common_data.go +++ b/ranking/get_common_data.go @@ -19,7 +19,6 @@ func getCommonData(err error, client *nex.Client, callID uint32, uniqueID uint64 } commonData, err := commonRankingProtocol.getCommonDataHandler(uniqueID) - if err != nil { return nex.Errors.Ranking.NotFound }