nexproto

package module
v1.0.11 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 10, 2023 License: AGPL-3.0 Imports: 5 Imported by: 0

README

NEX Protocols Go

NEX servers with protocol support in Go

GoDoc

Other NEX libraries

nex-go - Barebones NEX/PRUDP server implementation

nex-protocols-common-go - NEX protocols used by many games with premade handlers and a high level API

Install

go get github.com/FuseBarTV/nex-protocols-go

Usage

nex-protocols-go provides a higher level API than the NEX Go module to the underlying PRUDP server by providing a set of NEX protocols. This module only provides access to the lower level raw RMC method calls, however, and all method handlers must be defined in full manually. For a higher level API, see the common NEX method handlers module

Example, friends (Wii U) authentication server
For a complete example, see the complete Friends Authentication Server, and other game servers
package main

import (
	"fmt"

	nex "github.com/PretendoNetwork/nex-go"
	nexproto "github.com/PretendoNetwork/nex-protocols-go"
)

var nexServer *nex.Server

func main() {
	nexServer = nex.NewServer()
	nexServer.SetPrudpVersion(0)
	nexServer.SetSignatureVersion(1)
	nexServer.SetKerberosKeySize(16)
	nexServer.SetAccessKey("ridfebb9")

	authenticationServer := nexproto.NewAuthenticationProtocol(nexServer)

	// Handle Login RMC method
	authenticationServer.Login(login)

	// Handle RequestTicket RMC method
	authenticationServer.RequestTicket(requestTicket)

	nexServer.Listen(":60000")
}

Documentation

Index

Constants

View Source 
const (
	// AccountManagementProtocolID is the protocol ID for the Account Management protocol
	AccountManagementProtocolID = 0x19

	// AccountManagementMethodNintendoCreateAccount is the method ID for the method NintendoCreateAccount
	AccountManagementMethodNintendoCreateAccount = 0x1B
)
View Source 
const (
	// AuthenticationProtocolID is the protocol ID for the Authentication protocol
	AuthenticationProtocolID = 0xA

	// AuthenticationMethodLogin is the method ID for the method Login
	AuthenticationMethodLogin = 0x1

	// AuthenticationMethodLoginEx is the method ID for the method LoginEx
	AuthenticationMethodLoginEx = 0x2

	// AuthenticationMethodRequestTicket is the method ID for the method RequestTicket
	AuthenticationMethodRequestTicket = 0x3

	// AuthenticationMethodGetPID is the method ID for the method GetPID
	AuthenticationMethodGetPID = 0x4

	// AuthenticationMethodGetName is the method ID for the method GetName
	AuthenticationMethodGetName = 0x5

	// AuthenticationMethodLoginWithParam is the method ID for the method LoginWithParam
	AuthenticationMethodLoginWithParam = 0x6
)
View Source 
const (
	// DataStoreProtocolID is the protocol ID for the DataStore protocol
	DataStoreProtocolID = 0x73

	// DataStoreMethodPrepareGetObjectV1 is the method ID for the method PrepareGetObjectV1
	DataStoreMethodPrepareGetObjectV1 = 0x1

	// DataStoreMethodPreparePostObjectV1 is the method ID for the method PreparePostObjectV1
	DataStoreMethodPreparePostObjectV1 = 0x2

	// DataStoreMethodCompletePostObjectV1 is the method ID for the method CompletePostObjectV1
	DataStoreMethodCompletePostObjectV1 = 0x3

	// DataStoreMethodDeleteObject is the method ID for the method DeleteObject
	DataStoreMethodDeleteObject = 0x4

	// DataStoreMethodDeleteObjects is the method ID for the method DeleteObjects
	DataStoreMethodDeleteObjects = 0x5

	// DataStoreMethodChangeMetaV1 is the method ID for the method ChangeMetaV1
	DataStoreMethodChangeMetaV1 = 0x6

	// DataStoreMethodChangeMetasV1 is the method ID for the method ChangeMetasV1
	DataStoreMethodChangeMetasV1 = 0x7

	// DataStoreMethodGetMeta is the method ID for the method GetMeta
	DataStoreMethodGetMeta = 0x8

	// DataStoreMethodGetMetas is the method ID for the method GetMetas
	DataStoreMethodGetMetas = 0x9

	// DataStoreMethodPrepareUpdateObject is the method ID for the method PrepareUpdateObject
	DataStoreMethodPrepareUpdateObject = 0xA

	// DataStoreMethodCompleteUpdateObject is the method ID for the method CompleteUpdateObject
	DataStoreMethodCompleteUpdateObject = 0xB

	// DataStoreMethodSearchObject is the method ID for the method SearchObject
	DataStoreMethodSearchObject = 0xC

	// DataStoreMethodGetNotificationURL is the method ID for the method GetNotificationUrl
	DataStoreMethodGetNotificationURL = 0xD

	// DataStoreMethodGetNewArrivedNotificationsV1 is the method ID for the method GetNewArrivedNotificationsV1
	DataStoreMethodGetNewArrivedNotificationsV1 = 0xE

	// DataStoreMethodRateObject is the method ID for the method RateObject
	DataStoreMethodRateObject = 0xF

	// DataStoreMethodGetRating is the method ID for the method GetRating
	DataStoreMethodGetRating = 0x10

	// DataStoreMethodGetRatings is the method ID for the method GetRatings
	DataStoreMethodGetRatings = 0x11

	// DataStoreMethodResetRating is the method ID for the method ResetRating
	DataStoreMethodResetRating = 0x12

	// DataStoreMethodResetRatings is the method ID for the method ResetRatings
	DataStoreMethodResetRatings = 0x13

	// DataStoreMethodGetSpecificMetaV1 is the method ID for the method GetSpecificMetaV1
	DataStoreMethodGetSpecificMetaV1 = 0x14

	// DataStoreMethodPostMetaBinary is the method ID for the method PostMetaBinary
	DataStoreMethodPostMetaBinary = 0x15

	// DataStoreMethodTouchObject is the method ID for the method TouchObject
	DataStoreMethodTouchObject = 0x16

	// DataStoreMethodGetRatingWithLog is the method ID for the method GetRatingWithLog
	DataStoreMethodGetRatingWithLog = 0x17

	// DataStoreMethodPreparePostObject is the method ID for the method PreparePostObject
	DataStoreMethodPreparePostObject = 0x18

	// DataStoreMethodPrepareGetObject is the method ID for the method PrepareGetObject
	DataStoreMethodPrepareGetObject = 0x19

	// DataStoreMethodCompletePostObject is the method ID for the method CompletePostObject
	DataStoreMethodCompletePostObject = 0x1A

	// DataStoreMethodGetNewArrivedNotifications is the method ID for the method GetNewArrivedNotifications
	DataStoreMethodGetNewArrivedNotifications = 0x1B

	// DataStoreMethodGetSpecificMeta is the method ID for the method GetSpecificMeta
	DataStoreMethodGetSpecificMeta = 0x1C

	// DataStoreMethodGetPersistenceInfo is the method ID for the method GetPersistenceInfo
	DataStoreMethodGetPersistenceInfo = 0x1D

	// DataStoreMethodGetPersistenceInfos is the method ID for the method GetPersistenceInfos
	DataStoreMethodGetPersistenceInfos = 0x1E

	// DataStoreMethodPerpetuateObject is the method ID for the method PerpetuateObject
	DataStoreMethodPerpetuateObject = 0x1F

	// DataStoreMethodUnperpetuateObject is the method ID for the method UnperpetuateObject
	DataStoreMethodUnperpetuateObject = 0x20

	// DataStoreMethodPrepareGetObjectOrMetaBinary is the method ID for the method PrepareGetObjectOrMetaBinary
	DataStoreMethodPrepareGetObjectOrMetaBinary = 0x21

	// DataStoreMethodGetPasswordInfo is the method ID for the method GetPasswordInfo
	DataStoreMethodGetPasswordInfo = 0x22

	// DataStoreMethodGetPasswordInfos is the method ID for the method GetPasswordInfos
	DataStoreMethodGetPasswordInfos = 0x23

	// DataStoreMethodGetMetasMultipleParam is the method ID for the method GetMetasMultipleParam
	DataStoreMethodGetMetasMultipleParam = 0x24

	// DataStoreMethodCompletePostObjects is the method ID for the method CompletePostObjects
	DataStoreMethodCompletePostObjects = 0x25

	// DataStoreMethodChangeMeta is the method ID for the method ChangeMeta
	DataStoreMethodChangeMeta = 0x26

	// DataStoreMethodChangeMetas is the method ID for the method ChangeMetas
	DataStoreMethodChangeMetas = 0x27

	// DataStoreMethodRateObjects is the method ID for the method RateObjects
	DataStoreMethodRateObjects = 0x28

	// DataStoreMethodPostMetaBinaryWithDataID is the method ID for the method PostMetaBinaryWithDataId
	DataStoreMethodPostMetaBinaryWithDataID = 0x29

	// DataStoreMethodPostMetaBinariesWithDataID is the method ID for the method PostMetaBinariesWithDataId
	DataStoreMethodPostMetaBinariesWithDataID = 0x2A

	// DataStoreMethodRateObjectWithPosting is the method ID for the method RateObjectWithPosting
	DataStoreMethodRateObjectWithPosting = 0x2B

	// DataStoreMethodRateObjectsWithPosting is the method ID for the method RateObjectsWithPosting
	DataStoreMethodRateObjectsWithPosting = 0x2C

	// DataStoreMethodGetObjectInfos is the method ID for the method GetObjectInfos
	DataStoreMethodGetObjectInfos = 0x2D

	// DataStoreMethodSearchObjectLight is the method ID for the method SearchObjectLight
	DataStoreMethodSearchObjectLight = 0x2E
)
View Source 
const (
	// DataStoreBadgeArcadeProtocolID is the Protocol ID for the DataStore (Badge Arcade) protocol. ID is the same as the DataStore protocol
	DataStoreBadgeArcadeProtocolID = 0x73

	// DataStoreBadgeArcadeMethodGetMetaByOwnerId is the method ID for GetMetaByOwnerId
	DataStoreBadgeArcadeMethodGetMetaByOwnerId = 0x2D
)
View Source 
const (
	// DataStoreSmash4ProtocolID is the protocol ID for the DataStore (Smash4) protocol. ID is the same as the DataStore protocol
	DataStoreSmash4ProtocolID = 0x73

	// DataStoreSmash4MethodPostProfile is the method ID for the method PostProfile
	DataStoreSmash4MethodPostProfile = 0x2D

	// DataStoreSmash4MethodGetProfiles is the method ID for the method GetProfiles
	DataStoreSmash4MethodGetProfiles = 0x2E

	// DataStoreSmash4MethodSendPlayReport is the method ID for the method SendPlayReport
	DataStoreSmash4MethodSendPlayReport = 0x2F

	// DataStoreSmash4MethodGetWorldPlayReport is the method ID for the method GetWorldPlayReport
	DataStoreSmash4MethodGetWorldPlayReport = 0x30

	// DataStoreSmash4MethodGetReplayMeta is the method ID for the method GetReplayMeta
	DataStoreSmash4MethodGetReplayMeta = 0x31

	// DataStoreSmash4MethodPrepareGetReplay is the method ID for the method PrepareGetReplay
	DataStoreSmash4MethodPrepareGetReplay = 0x32

	// DataStoreSmash4MethodPreparePostReplay is the method ID for the method PreparePostReplay
	DataStoreSmash4MethodPreparePostReplay = 0x33

	// DataStoreSmash4MethodCompletePostReplay is the method ID for the method CompletePostReplay
	DataStoreSmash4MethodCompletePostReplay = 0x34

	// DataStoreSmash4MethodCheckPostReplay is the method ID for the method CheckPostReplay
	DataStoreSmash4MethodCheckPostReplay = 0x35

	// DataStoreSmash4MethodGetNextReplay is the method ID for the method GetNextReplay
	DataStoreSmash4MethodGetNextReplay = 0x36

	// DataStoreSmash4MethodPreparePostSharedData is the method ID for the method PreparePostSharedData
	DataStoreSmash4MethodPreparePostSharedData = 0x37

	// DataStoreSmash4MethodCompletePostSharedData is the method ID for the method CompletePostSharedData
	DataStoreSmash4MethodCompletePostSharedData = 0x38

	// DataStoreSmash4MethodSearchSharedData is the method ID for the method SearchSharedData
	DataStoreSmash4MethodSearchSharedData = 0x39

	// DataStoreSmash4MethodGetApplicationConfig is the method ID for the method GetApplicationConfig
	DataStoreSmash4MethodGetApplicationConfig = 0x3A

	// DataStoreSmash4MethodSearchReplay is the method ID for the method SearchReplay
	DataStoreSmash4MethodSearchReplay = 0x3B

	// DataStoreSmash4MethodPostFightingPowerScore is the method ID for the method PostFightingPowerScore
	DataStoreSmash4MethodPostFightingPowerScore = 0x3C

	// DataStoreSmash4MethodGetFightingPowerChart is the method ID for the method GetFightingPowerChart
	DataStoreSmash4MethodGetFightingPowerChart = 0x3D

	// DataStoreSmash4MethodGetFightingPowerChartAll is the method ID for the method GetFightingPowerChartAll
	DataStoreSmash4MethodGetFightingPowerChartAll = 0x3E

	// DataStoreSmash4MethodReportSharedData is the method ID for the method ReportSharedData
	DataStoreSmash4MethodReportSharedData = 0x3F
)
View Source 
const (
	// DataStoreSMMProtocolID is the protocol ID for the DataStore (SMM) protocol. ID is the same as the DataStore protocol
	DataStoreSMMProtocolID = 0x73

	// DataStoreSMMMethodGetObjectInfos is the method ID for the method GetObjectInfos
	DataStoreSMMMethodGetObjectInfos = 0x2D

	// DataStoreSMMMethodRateCustomRanking is the method ID for the method RateCustomRanking
	DataStoreSMMMethodRateCustomRanking = 0x30

	// DataStoreSMMMethodGetCustomRankingByDataId is the method ID for the method GetCustomRankingByDataId
	DataStoreSMMMethodGetCustomRankingByDataId = 0x32

	// DataStoreSMMMethodAddToBufferQueues is the method ID for the method AddToBufferQueues
	DataStoreSMMMethodAddToBufferQueues = 0x35

	// DataStoreSMMMethodGetBufferQueue is the method ID for the method GetBufferQueue
	DataStoreSMMMethodGetBufferQueue = 0x36

	// DataStoreSMMMethodCompleteAttachFile is the method ID for the method CompleteAttachFile
	DataStoreSMMMethodCompleteAttachFile = 0x39

	// DataStoreSMMMethodPrepareAttachFile is the method ID for the method PrepareAttachFile
	DataStoreSMMMethodPrepareAttachFile = 0x3B

	// DataStoreSMMMethodGetApplicationConfig is the method ID for the method GetApplicationConfig
	DataStoreSMMMethodGetApplicationConfig = 0x3D

	// DataStoreSMMMethodFollowingsLatestCourseSearchObject is the method ID for the method FollowingsLatestCourseSearchObject
	DataStoreSMMMethodFollowingsLatestCourseSearchObject = 0x41

	// DataStoreSMMMethodRecommendedCourseSearchObject is the method ID for the method RecommendedCourseSearchObject
	DataStoreSMMMethodRecommendedCourseSearchObject = 0x42

	// DataStoreSMMMethodSuggestedCourseSearchObjectis the method ID for the method SuggestedCourseSearchObject
	DataStoreSMMMethodSuggestedCourseSearchObject = 0x44

	// DataStoreSMMMethodUploadCourseRecord is the method ID for the method UploadCourseRecord
	DataStoreSMMMethodUploadCourseRecord = 0x47

	// DataStoreSMMMethodGetCourseRecord is the method ID for the method GetCourseRecord
	DataStoreSMMMethodGetCourseRecord = 0x48

	// DataStoreSMMMethodGetApplicationConfigString is the method ID for the method GetApplicationConfigString
	DataStoreSMMMethodGetApplicationConfigString = 0x4A

	// DataStoreSMMMethodGetDeletionReason is the method ID for the method GetDeletionReason
	DataStoreSMMMethodGetDeletionReason = 0x4C

	// DataStoreSMMMethodGetMetasWithCourseRecord is the method ID for the method GetMetasWithCourseRecord
	DataStoreSMMMethodGetMetasWithCourseRecord = 0x4E

	// DataStoreSMMMethodCheckRateCustomRankingCounter is the method ID for the method CheckRateCustomRankingCounter
	DataStoreSMMMethodCheckRateCustomRankingCounter = 0x4F

	// DataStoreSMMMethodCTRPickUpCourseSearchObject is the method ID for the method CTRPickUpCourseSearchObject
	DataStoreSMMMethodCTRPickUpCourseSearchObject = 0x52
)
View Source 
const (
	// DebugProtocolID is the protocol ID for the Debug protocol
	DebugProtocolID = 0x74

	// DebugMethodEnableApiRecorder is the method ID for the method EnableApiRecorder
	DebugMethodEnableApiRecorder = 0x1

	// DebugMethodDisableApiRecorder is the method ID for the method DisableApiRecorder
	DebugMethodDisableApiRecorder = 0x2

	// DebugMethodIsApiRecorderEnabled is the method ID for the method IsApiRecorderEnabled
	DebugMethodIsApiRecorderEnabled = 0x3

	// DebugMethodGetApiCalls is the method ID for the method GetApiCalls
	DebugMethodGetApiCalls = 0x4

	// DebugMethodSetExcludeJoinedMatchmakeSession is the method ID for the method SetExcludeJoinedMatchmakeSession
	DebugMethodSetExcludeJoinedMatchmakeSession = 0x5

	// DebugMethodGetExcludeJoinedMatchmakeSession is the method ID for the method GetExcludeJoinedMatchmakeSession
	DebugMethodGetExcludeJoinedMatchmakeSession = 0x6

	// DebugMethodGetApiCallSummary is the method ID for the method GetApiCallSummary
	DebugMethodGetApiCallSummary = 0x7
)
View Source 
const (
	// Friends3DSProtocolID is the protocol ID for the Friends (3DS) protocol
	Friends3DSProtocolID = 0x65

	// Friends3DSMethodUpdateProfile is the method ID for method UpdateProfile
	Friends3DSMethodUpdateProfile = 0x1

	// Friends3DSMethodUpdateMii is the method ID for method UpdateMii
	Friends3DSMethodUpdateMii = 0x2

	// Friends3DSMethodUpdatePreference is the method ID for method UpdatePreference
	Friends3DSMethodUpdatePreference = 0x5

	// Friends3DSMethodGetFriendMii is the method ID for method GetFriendMii
	Friends3DSMethodGetFriendMii = 0x6

	// Friends3DSMethodAddFriendByPrincipalID is the method ID for method AddFriendByPrincipalID
	Friends3DSMethodAddFriendByPrincipalID = 0xb

	// Friends3DSMethodSyncFriend is the method ID for method SyncFriend
	Friends3DSMethodSyncFriend = 0x11

	// Friends3DSMethodUpdatePresence is the method ID for method UpdatePresence
	Friends3DSMethodUpdatePresence = 0x12

	// Friends3DSMethodUpdateFavoriteGameKey is the method ID for method UpdateFavoriteGameKey
	Friends3DSMethodUpdateFavoriteGameKey = 0x13

	// Friends3DSMethodUpdateComment is the method ID for method UpdateComment
	Friends3DSMethodUpdateComment = 0x14

	// Friends3DSMethodGetFriendPresence is the method ID for method GetFriendPresence
	Friends3DSMethodGetFriendPresence = 0x16

	// Friends3DSMethodGetFriendPersistentInfo is the method ID for method GetFriendPersistentInfo
	Friends3DSMethodGetFriendPersistentInfo = 0x19
)
View Source 
const (
	// FriendsWiiUProtocolID is the protocol ID for the Friends (WiiU) protocol
	FriendsWiiUProtocolID = 0x66

	// FriendsWiiUMethodUpdateAndGetAllInformation is the method ID for method UpdateAndGetAllInformation
	FriendsWiiUMethodUpdateAndGetAllInformation = 0x1

	// FriendsWiiUMethodAddFriend is the method ID for method AddFriend
	FriendsWiiUMethodAddFriend = 0x2

	// FriendsWiiUMethodAddFriendByName is the method ID for method AddFriendByName
	FriendsWiiUMethodAddFriendByName = 0x3

	// FriendsWiiUMethodRemoveFriend is the method ID for method RemoveFriend
	FriendsWiiUMethodRemoveFriend = 0x4

	// FriendsWiiUMethodAddFriendRequest is the method ID for method AddFriendRequest
	FriendsWiiUMethodAddFriendRequest = 0x5

	// FriendsWiiUMethodCancelFriendRequest is the method ID for method CancelFriendRequest
	FriendsWiiUMethodCancelFriendRequest = 0x6

	// FriendsWiiUMethodAcceptFriendRequest is the method ID for method AcceptFriendRequest
	FriendsWiiUMethodAcceptFriendRequest = 0x7

	// FriendsWiiUMethodDeleteFriendRequest is the method ID for method DeleteFriendRequest
	FriendsWiiUMethodDeleteFriendRequest = 0x8

	// FriendsWiiUMethodDenyFriendRequest is the method ID for method DenyFriendRequest
	FriendsWiiUMethodDenyFriendRequest = 0x9

	// FriendsWiiUMethodMarkFriendRequestsAsReceived is the method ID for method MarkFriendRequestsAsReceived
	FriendsWiiUMethodMarkFriendRequestsAsReceived = 0xA

	// FriendsWiiUMethodAddBlackList is the method ID for method AddBlackList
	FriendsWiiUMethodAddBlackList = 0xB

	// FriendsWiiUMethodRemoveBlackList is the method ID for method RemoveBlackList
	FriendsWiiUMethodRemoveBlackList = 0xC

	// FriendsWiiUMethodUpdatePresence is the method ID for method UpdatePresence
	FriendsWiiUMethodUpdatePresence = 0xD

	// FriendsWiiUMethodUpdateMii is the method ID for method UpdateMii
	FriendsWiiUMethodUpdateMii = 0xE

	// FriendsWiiUMethodUpdateComment is the method ID for method UpdateComment
	FriendsWiiUMethodUpdateComment = 0xF

	// FriendsWiiUMethodUpdatePreference is the method ID for method UpdatePreference
	FriendsWiiUMethodUpdatePreference = 0x10

	// FriendsWiiUMethodGetBasicInfo is the method ID for method GetBasicInfo
	FriendsWiiUMethodGetBasicInfo = 0x11

	// FriendsWiiUMethodDeletePersistentNotification is the method ID for method DeletePersistentNotification
	FriendsWiiUMethodDeletePersistentNotification = 0x12

	// FriendsWiiUMethodCheckSettingStatus is the method ID for method CheckSettingStatus
	FriendsWiiUMethodCheckSettingStatus = 0x13

	// FriendsWiiUMethodGetRequestBlockSettings is the method ID for method GetRequestBlockSettings
	FriendsWiiUMethodGetRequestBlockSettings = 0x14
)
View Source 
const (
	// HealthProtocolID is the protocol ID for the Health protocol
	HealthProtocolID = 0x12

	// HealthMethodPingDaemon is the method ID for the method PingDaemon
	HealthMethodPingDaemon = 0x1

	// HealthMethodPingDatabase is the method ID for the method PingDatabase
	HealthMethodPingDatabase = 0x2

	// HealthMethodRunSanityCheck is the method ID for the method RunSanityCheck
	HealthMethodRunSanityCheck = 0x3

	// HealthMethodFixSanityErrors is the method ID for the method FixSanityErrors
	HealthMethodFixSanityErrors = 0x4
)
View Source 
const (
	// MatchMakingExtProtocolID is the protocol ID for the MatchMakingExt protocol
	MatchMakingExtProtocolID = 0x32

	// MatchMakingExtMethodEndParticipation is the method ID for the method EndParticipation
	MatchMakingExtMethodEndParticipation = 0x1

	// MatchMakingExtMethodGetParticipants is the method ID for the method GetParticipants
	MatchMakingExtMethodGetParticipants = 0x2

	// MatchMakingExtMethodGetDetailedParticipants is the method ID for the method GetDetailedParticipants
	MatchMakingExtMethodGetDetailedParticipants = 0x3

	// MatchMakingExtMethodGetParticipantsURLs is the method ID for the method GetParticipantsURLs
	MatchMakingExtMethodGetParticipantsURLs = 0x4

	// MatchMakingExtMethodGetGatheringRelations is the method ID for the method GetGatheringRelations
	MatchMakingExtMethodGetGatheringRelations = 0x5

	// MatchMakingExtMethodDeleteFromDeletions is the method ID for the method DeleteFromDeletions
	MatchMakingExtMethodDeleteFromDeletions = 0x6
)
View Source 
const (
	// MatchmakeExtensionProtocolID is the protocol ID for the Matchmake Extension protocol
	MatchmakeExtensionProtocolID = 0x6D

	// MatchmakeExtensionMethodOpenParticipation is the method ID for method OpenParticipation
	MatchmakeExtensionMethodOpenParticipation = 0x2

	// MatchmakeExtensionMethodAutoMatchmake_Postpone is the method ID for method AutoMatchmake_Postpone
	MatchmakeExtensionMethodAutoMatchmake_Postpone = 0x3

	// MatchmakeExtensionMethodCreateMatchmakeSession is the method ID for method CreateMatchmakeSession
	MatchmakeExtensionMethodCreateMatchmakeSession = 0x6

	// MatchmakeExtensionMethodUpdateNotificationData is the method ID for method UpdateNotificationData
	MatchmakeExtensionMethodUpdateNotificationData = 0x9

	// MatchmakeExtensionMethodGetFriendNotificationData is the method ID for method GetFriendNotificationData
	MatchmakeExtensionMethodGetFriendNotificationData = 0xA

	// MatchmakeExtensionMethodCreateMatchmakeSession is the method ID for method CreateMatchmakeSession
	MatchmakeExtensionMethodAutoMatchmakeWithSearchCriteria_Postpone = 0xF

	// MatchmakeExtensionMethodJoinMatchmakeSessionEx is the method ID for method JoinMatchmakeSessionEx
	MatchmakeExtensionMethodJoinMatchmakeSessionEx = 0x1E

	// MatchmakeExtensionMethodGetSimplePlayingSession is the method ID for method GetSimplePlayingSession
	MatchmakeExtensionMethodGetSimplePlayingSession = 0x1F
)
View Source 
const (
	// MatchMakingProtocolID is the protocol ID for the Match Making protocol
	MatchMakingProtocolID = 0x15

	// MatchMakingMethodUnregisterGathering is the method ID for the method UnregisterGathering
	MatchMakingMethodUnregisterGathering = 0x2

	// MatchMakingMethodUnregisterGatherings is the method ID for the method UnregisterGatherings
	MatchMakingMethodUnregisterGatherings = 0x3

	// MatchMakingMethodFindBySingleID is the method ID for the method FindBySingleID
	MatchMakingMethodFindBySingleID = 0x15

	// MatchMakingMethodUpdateSessionHostV1 is the method ID for the method UpdateSessionHostV1
	MatchMakingMethodUpdateSessionHostV1 = 0x28

	// MatchMakingMethodGetSessionURLs is the method ID for the method GetSessionURLs
	MatchMakingMethodGetSessionURLs = 0x29

	// MatchMakingMethodUpdateSessionHost is the method ID for the method UpdateSessionHost
	MatchMakingMethodUpdateSessionHost = 0x2A
)
View Source 
const (
	// MessageDeliveryProtocolID is the protocol ID for the Message Delivery protocol
	MessageDeliveryProtocolID = 0x1B

	// MessageDeliveryMethodDeliverMessage is the method ID for the method DeliverMessage
	MessageDeliveryMethodDeliverMessage = 0x1
)
View Source 
const (
	// MonitoringProtocolID is the protocol ID for the Monitoring protocol
	MonitoringProtocolID = 0x13

	// MonitoringMethodPingDaemon is the method ID for the method PingDaemon
	MonitoringMethodPingDaemon = 0x1

	// MonitoringMethodGetClusterMembers is the method ID for the method GetClusterMembers
	MonitoringMethodGetClusterMembers = 0x2
)
View Source 
const (
	// NATTraversalProtocolID is the protocol ID for the Message Delivery protocol
	NATTraversalProtocolID = 0x3

	// NATTraversalMethodInitiateProbe is the method ID for the method InitiateProbe
	NATTraversalMethodInitiateProbe = 0x2

	// NATTraversalMethodRequestProbeInitiationExt is the method ID for the method RequestProbeInitiationExt
	NATTraversalMethodRequestProbeInitiationExt = 0x3

	// NATTraversalMethodReportNATTraversalResult is the method ID for the method ReportNATTraversalResult
	NATTraversalMethodReportNATTraversalResult = 0x4

	// NATTraversalMethodReportNATProperties is the method ID for the method ReportNATProperties
	NATTraversalMethodReportNATProperties = 0x5

	// NATTraversalMethodGetRelaySignatureKey is the method ID for the method GetRelaySignatureKey
	NATTraversalMethodGetRelaySignatureKey = 0x6
)
View Source 
const (
	// NintendoNotificationsProtocolID is the protocol ID for the Nintendo Notifications protocol
	NintendoNotificationsProtocolID = 0x64

	// NintendoNotificationsMethodProcessNintendoNotificationEvent1 is the method ID for the method ProcessNintendoNotificationEvent (1)
	NintendoNotificationsMethodProcessNintendoNotificationEvent1 = 0x1

	// NintendoNotificationsMethodProcessNintendoNotificationEvent2 is the method ID for the method ProcessNintendoNotificationEvent (2)
	NintendoNotificationsMethodProcessNintendoNotificationEvent2 = 0x2
)
View Source 
const (
	// NotificationsProtocolID is the protocol ID for the Nintendo Notifications protocol
	NotificationsProtocolID = 0xE

	// NotificationsMethodProcessNotificationEvent is the method ID for the method ProcessNotificationEvent
	NotificationsMethodProcessNotificationEvent = 0x1
)
View Source 
const (
	// RankingProtocolID is the protocol ID for the Ranking protocol
	RankingProtocolID = 0x70

	// RankingMethodUploadScore is the method ID for method UploadScore
	RankingMethodUploadScore = 0x1

	// RankingMethodDeleteScore is the method ID for method DeleteScore
	RankingMethodDeleteScore = 0x2

	// RankingMethodDeleteAllScores is the method ID for method DeleteAllScores
	RankingMethodDeleteAllScores = 0x3

	// RankingMethodUploadCommonData is the method ID for method UploadCommonData
	RankingMethodUploadCommonData = 0x4

	// RankingMethodDeleteCommonData is the method ID for method DeleteCommonData
	RankingMethodDeleteCommonData = 0x5

	// RankingMethodGetCommonData is the method ID for method GetCommonData
	RankingMethodGetCommonData = 0x6

	// RankingMethodChangeAttributes is the method ID for method ChangeAttributes
	RankingMethodChangeAttributes = 0x7

	// RankingMethodChangeAllAttributes is the method ID for method ChangeAllAttributes
	RankingMethodChangeAllAttributes = 0x8

	// RankingMethodGetRanking is the method ID for method GetRanking
	RankingMethodGetRanking = 0x9

	// RankingMethodGetApproxOrder is the method ID for method GetApproxOrder
	RankingMethodGetApproxOrder = 0xA

	// RankingMethodGetStats is the method ID for method GetStats
	RankingMethodGetStats = 0xB

	// RankingMethodGetRankingByPIDList is the method ID for method GetRankingByPIDList
	RankingMethodGetRankingByPIDList = 0xC

	// RankingMethodGetRankingByUniqueIDList is the method ID for method GetRankingByUniqueIdList
	RankingMethodGetRankingByUniqueIDList = 0xD

	// RankingMethodGetCachedTopXRanking is the method ID for method GetCachedTopXRanking
	RankingMethodGetCachedTopXRanking = 0xE

	// RankingMethodGetCachedTopXRankings is the method ID for method GetCachedTopXRankings
	RankingMethodGetCachedTopXRankings = 0xF
)
View Source 
const (
	// RemoteLogDeviceProtocolID is the protocol ID for the RemoteLogDevice protocol
	RemoteLogDeviceProtocolID = 0x1

	// RemoteLogDeviceMethodLog is the method ID for the method Log
	RemoteLogDeviceMethodLog = 0x1
)
View Source 
const (
	// ScreeningProtocolID is the protocol ID for the Screening protocol
	ScreeningProtocolID = 0x7C

	// ScreeningMethodReportDataStoreContent is the method ID for the method ReportDataStoreContent
	ScreeningMethodReportDataStoreContent = 0x1

	// ScreeningMethodReportUser is the method ID for the method ReportUser
	ScreeningMethodReportUser = 0x2
)
View Source 
const (
	// SecureProtocolID is the protocol ID for the Secure Connection protocol
	SecureProtocolID = 0xB

	// SecureMethodRegister is the method ID for the method Register
	SecureMethodRegister = 0x1

	// SecureMethodRequestConnectionData is the method ID for the method RequestConnectionData
	SecureMethodRequestConnectionData = 0x2

	// SecureMethodRequestURLs is the method ID for the method RequestURLs
	SecureMethodRequestURLs = 0x3

	// SecureMethodRegisterEx is the method ID for the method RegisterEx
	SecureMethodRegisterEx = 0x4

	// SecureMethodTestConnectivity is the method ID for the method TestConnectivity
	SecureMethodTestConnectivity = 0x5

	// SecureMethodUpdateURLs is the method ID for the method UpdateURLs
	SecureMethodUpdateURLs = 0x6

	// SecureMethodReplaceURL is the method ID for the method ReplaceURL
	SecureMethodReplaceURL = 0x7

	// SecureMethodSendReport is the method ID for the method SendReport
	SecureMethodSendReport = 0x8
)
View Source 
const (
	// SecureBadgeArcadeProtocolID is the protocol ID for the Secure Connection (Badge Arcade) protocol. ID is the same as the Secure Connection Protocol
	SecureBadgeArcadeProtocolID = 0xB

	// SecureBadgeArcadeMethodGetMaintenanceStatus is the method ID for GetMaintenanceStatus
	SecureBadgeArcadeMethodGetMaintenanceStatus = 0x9
)
View Source 
const (
	// ShopBadgeArcadeProtocolID is the Protocol ID for the Shop (Badge Arcade) protocol
	ShopBadgeArcadeProtocolID = 0x7F

	// ShopBadgeArcadeCustomID is the Custom ID for the Shop (Badge Arcade) protocol
	ShopBadgeArcadeCustomID = 0xC8

	// ShopBadgeArcadeMethodGetRivToken is the method ID for GetRivToken
	ShopBadgeArcadeMethodGetRivToken = 0x1

	// ShopBadgeArcadeMethodPostPlayLog is the method ID for PostPlayLog
	ShopBadgeArcadeMethodPostPlayLog = 0x2
)
View Source 
const (
	// UtilityProtocolID is the protocol ID for the Utility protocol
	UtilityProtocolID = 0x6e

	// UtilityMethodAcquireNexUniqueID is the method ID for the method AcquireNexUniqueID
	UtilityMethodAcquireNexUniqueID = 0x1

	// UtilityMethodAcquireNexUniqueIDWithPassword is the method ID for the method AcquireNexUniqueIDWithPassword
	UtilityMethodAcquireNexUniqueIDWithPassword = 0x2

	// UtilityMethodAssociateNexUniqueIDWithMyPrincipalID is the method ID for the method AssociateNexUniqueIDWithMyPrincipalID
	UtilityMethodAssociateNexUniqueIDWithMyPrincipalID = 0x3

	// UtilityMethodAssociateNexUniqueIDsWithMyPrincipalID is the method ID for the method AssociateNexUniqueIDsWithMyPrincipalID
	UtilityMethodAssociateNexUniqueIDsWithMyPrincipalID = 0x4

	// UtilityMethodGetAssociatedNexUniqueIDWithMyPrincipalID is the method ID for the method GetAssociatedNexUniqueIDWithMyPrincipalID
	UtilityMethodGetAssociatedNexUniqueIDWithMyPrincipalID = 0x5

	// UtilityMethodGetAssociatedNexUniqueIDsWithMyPrincipalID is the method ID for the method GetAssociatedNexUniqueIDsWithMyPrincipalID
	UtilityMethodGetAssociatedNexUniqueIDsWithMyPrincipalID = 0x6

	// UtilityMethodGetIntegerSettings is the method ID for the method GetIntegerSettings
	UtilityMethodGetIntegerSettings = 0x7

	// UtilityMethodGetStringSettings is the method ID for the method GetStringSettings
	UtilityMethodGetStringSettings = 0x8
)
View Source 
const (
	// RankingMK8ProtocolID is the protocol ID for the Ranking (Mario Kart 8) protocol. ID is the same as the Ranking protocol
	RankingMK8ProtocolID = 0x70
)

Variables

This section is empty.

Functions

func ReadListStationURL 

func ReadListStationURL(stream *nex.StreamIn) ([]*nex.StationURL, error)

ReadListStationURL reads a list of StationURL structures

Types

type AccountExtraInfo 

type AccountExtraInfo struct {
	nex.Structure
	Unknown  uint32
	Unknown2 uint32
	Unknown3 uint32
	NEXToken string
}

AccountExtraInfo contains data for creating a new NNID on the network

func NewAccountExtraInfo 

func NewAccountExtraInfo() *AccountExtraInfo

NewAccountExtraInfo returns a new AccountExtraInfo

func (*AccountExtraInfo) ExtractFromStream 

func (accountExtraInfo *AccountExtraInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a AccountExtraInfo structure from a stream

type AccountManagementProtocol 

type AccountManagementProtocol struct {
	NintendoCreateAccountHandler    func(err error, client *nex.Client, callID uint32, strPrincipalName string, strKey string, uiGroups uint32, strEmail string, oAuthData *nex.DataHolder)
	NintendoCreateAccount3DSHandler func(err error, client *nex.Client, callID uint32, strPrincipalName string, strKey string, uiGroups uint32, strEmail string, oAuthData *AccountExtraInfo)
	// contains filtered or unexported fields
}

AccountManagementProtocol handles the Account Management nex protocol

func NewAccountManagementProtocol 

func NewAccountManagementProtocol(server *nex.Server) *AccountManagementProtocol

NewAccountManagementProtocol returns a new AccountManagementProtocol

func (*AccountManagementProtocol) NintendoCreateAccount 

func (accountManagementProtocol *AccountManagementProtocol) NintendoCreateAccount(handler func(err error, client *nex.Client, callID uint32, strPrincipalName string, strKey string, uiGroups uint32, strEmail string, oAuthData *nex.DataHolder))

NintendoCreateAccount sets the NintendoCreateAccount handler function

func (*AccountManagementProtocol) NintendoCreateAccount3DS 

func (accountManagementProtocol *AccountManagementProtocol) NintendoCreateAccount3DS(handler func(err error, client *nex.Client, callID uint32, strPrincipalName string, strKey string, uiGroups uint32, strEmail string, oAuthData *AccountExtraInfo))

NintendoCreateAccount sets the NintendoCreateAccount handler function. This is not a real NEX method, this was made specifically for nex-protocols-go to simplify things

func (*AccountManagementProtocol) Setup 

func (accountManagementProtocol *AccountManagementProtocol) Setup()

Setup initializes the protocol

type AuthenticationInfo 

type AuthenticationInfo struct {
	*nex.Data

	Token         string
	NGSVersion    uint32
	TokenType     uint8
	ServerVersion uint32
	// contains filtered or unexported fields
}

AuthenticationInfo holds information about an authentication request

func NewAuthenticationInfo 

func NewAuthenticationInfo() *AuthenticationInfo

NewAuthenticationInfo returns a new AuthenticationInfo

func (*AuthenticationInfo) ExtractFromStream 

func (authenticationInfo *AuthenticationInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a AuthenticationInfo structure from a stream

func (*AuthenticationInfo) Hierarchy 

func (authenticationInfo *AuthenticationInfo) Hierarchy() []nex.StructureInterface

Hierarchy returns the Structure hierarchy

type AuthenticationProtocol 

type AuthenticationProtocol struct {
	LoginHandler          func(err error, client *nex.Client, callID uint32, username string)
	LoginExHandler        func(err error, client *nex.Client, callID uint32, username string, authenticationInfo *AuthenticationInfo)
	RequestTicketHandler  func(err error, client *nex.Client, callID uint32, userPID uint32, serverPID uint32)
	GetPIDHandler         func(err error, client *nex.Client, callID uint32, username string)
	GetNameHandler        func(err error, client *nex.Client, callID uint32, userPID uint32)
	LoginWithParamHandler func(err error, client *nex.Client, callID uint32)
	// contains filtered or unexported fields
}

AuthenticationProtocol handles the Authentication nex protocol

func NewAuthenticationProtocol 

func NewAuthenticationProtocol(server *nex.Server) *AuthenticationProtocol

NewAuthenticationProtocol returns a new AuthenticationProtocol

func (*AuthenticationProtocol) GetName 

func (authenticationProtocol *AuthenticationProtocol) GetName(handler func(err error, client *nex.Client, callID uint32, userPID uint32))

GetName sets the GetName handler function

func (*AuthenticationProtocol) GetPID 

func (authenticationProtocol *AuthenticationProtocol) GetPID(handler func(err error, client *nex.Client, callID uint32, username string))

GetPID sets the GetPID handler function

func (*AuthenticationProtocol) Login 

func (authenticationProtocol *AuthenticationProtocol) Login(handler func(err error, client *nex.Client, callID uint32, username string))

Login sets the Login handler function

func (*AuthenticationProtocol) LoginEx 

func (authenticationProtocol *AuthenticationProtocol) LoginEx(handler func(err error, client *nex.Client, callID uint32, username string, authenticationInfo *AuthenticationInfo))

LoginEx sets the LoginEx handler function

func (*AuthenticationProtocol) LoginWithParam 

func (authenticationProtocol *AuthenticationProtocol) LoginWithParam(handler func(err error, client *nex.Client, callID uint32))

LoginWithParam sets the LoginWithParam handler function

func (*AuthenticationProtocol) RequestTicket 

func (authenticationProtocol *AuthenticationProtocol) RequestTicket(handler func(err error, client *nex.Client, callID uint32, userPID uint32, serverPID uint32))

RequestTicket sets the RequestTicket handler function

func (*AuthenticationProtocol) Setup 

func (authenticationProtocol *AuthenticationProtocol) Setup()

Setup initializes the protocol

type BinaryMessage 

type BinaryMessage struct {
	nex.Structure
	*UserMessage
	// contains filtered or unexported fields
}

func NewBinaryMessage 

func NewBinaryMessage() *BinaryMessage

NewBinaryMessage returns a new BinaryMessage

func (*BinaryMessage) Bytes 

func (binaryMessage *BinaryMessage) Bytes(stream *nex.StreamOut) []byte

func (*BinaryMessage) ExtractFromStream 

func (binaryMessage *BinaryMessage) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a BinaryMessage structure from a stream

type BlacklistedPrincipal 

type BlacklistedPrincipal struct {
	PrincipalBasicInfo *PrincipalBasicInfo
	GameKey            *GameKey
	BlackListedSince   *nex.DateTime

	nex.Structure
}

BlacklistedPrincipal contains information about a blocked user

func NewBlacklistedPrincipal 

func NewBlacklistedPrincipal() *BlacklistedPrincipal

NewBlacklistedPrincipal returns a new BlacklistedPrincipal

func (*BlacklistedPrincipal) ExtractFromStream 

func (blacklistedPrincipal *BlacklistedPrincipal) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a BlacklistedPrincipal structure from a stream

type BufferQueueParam 

type BufferQueueParam struct {
	nex.Structure
	DataID uint64
	Slot   uint32
}

BufferQueueParam is sent in the GetBufferQueue method

func NewBufferQueueParam 

func NewBufferQueueParam() *BufferQueueParam

NewBufferQueueParam returns a new BufferQueueParam

func ReadListBufferQueueParam 

func ReadListBufferQueueParam(stream *nex.StreamIn) ([]*BufferQueueParam, error)

ReadListBufferQueueParam reads a list of BufferQueueParam structures

func (*BufferQueueParam) ExtractFromStream 

func (bufferQueueParam *BufferQueueParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a BufferQueueParam structure from a stream

type Comment 

type Comment struct {
	Unknown     uint8
	Contents    string
	LastChanged *nex.DateTime

	nex.Structure
}

Comment contains data about a text comment

func NewComment 

func NewComment() *Comment

NewComment returns a new Comment

func (*Comment) Bytes 

func (comment *Comment) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the Comment and returns a byte array

func (*Comment) ExtractFromStream 

func (comment *Comment) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a Comment structure from a stream

type DataStoreAttachFileParam 

type DataStoreAttachFileParam struct {
	nex.Structure
	PostParam   *DataStorePreparePostParam
	ReferDataID uint64
	ContentType string
}

DataStoreAttachFileParam is sent in the PrepareAttachFile method

func NewDataStoreAttachFileParam 

func NewDataStoreAttachFileParam() *DataStoreAttachFileParam

NewDataStoreAttachFileParam returns a new DataStoreAttachFileParam

func (*DataStoreAttachFileParam) ExtractFromStream 

func (dataStoreAttachFileParam *DataStoreAttachFileParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreAttachFileParam structure from a stream

type DataStoreBadgeArcadeProtocol 

type DataStoreBadgeArcadeProtocol struct {
	DataStoreProtocol
	GetMetaByOwnerIdHandler func(err error, client *nex.Client, callID uint32, param *DataStoreGetMetaByOwnerIdParam)
	// contains filtered or unexported fields
}

DataStoreBadgeArcadeProtocol handles the DataStore (Badge Arcade) nex protocol. Embeds DataStoreProtocol

func NewDataStoreBadgeArcadeProtocol 

func NewDataStoreBadgeArcadeProtocol(server *nex.Server) *DataStoreBadgeArcadeProtocol

NewDataStoreBadgeArcadeProtocol returns a new DataStoreBadgeArcadeProtocol

func (*DataStoreBadgeArcadeProtocol) GetMetaByOwnerId 

func (dataStoreBadgeArcadeProtocol *DataStoreBadgeArcadeProtocol) GetMetaByOwnerId(handler func(err error, client *nex.Client, callID uint32, param *DataStoreGetMetaByOwnerIdParam))

GetMetaByOwnerId sets the GetMetaByOwnerId function

func (*DataStoreBadgeArcadeProtocol) Setup 

func (dataStoreBadgeArcadeProtocol *DataStoreBadgeArcadeProtocol) Setup()

Setup initializes the protocol

type DataStoreChangeMetaCompareParam 

type DataStoreChangeMetaCompareParam struct {
	nex.Structure
	ComparisonFlag uint32
	Name           string
	Permission     *DataStorePermission
	DelPermission  *DataStorePermission
	Period         uint16
	MetaBinary     []byte
	Tags           []string
	ReferredCnt    uint32
	DataType       uint16
	Status         uint8
}

DataStoreChangeMetaCompareParam is sent in the ChangeMeta method

func NewDataStoreChangeMetaCompareParam 

func NewDataStoreChangeMetaCompareParam() *DataStoreChangeMetaCompareParam

NewDataStoreChangeMetaCompareParam returns a new DataStoreChangeMetaParam

func (*DataStoreChangeMetaCompareParam) ExtractFromStream 

func (dataStoreChangeMetaCompareParam *DataStoreChangeMetaCompareParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreChangeMetaCompareParam structure from a stream

type DataStoreChangeMetaParam 

type DataStoreChangeMetaParam struct {
	nex.Structure
	DataID         uint64
	ModifiesFlag   uint32
	Name           string
	Permission     *DataStorePermission
	DelPermission  *DataStorePermission
	Period         uint16
	MetaBinary     []byte
	Tags           []string
	UpdatePassword uint64
	ReferredCnt    uint32
	DataType       uint16
	Status         uint8
	CompareParam   *DataStoreChangeMetaCompareParam
}

DataStoreChangeMetaParam is sent in the ChangeMeta method

func NewDataStoreChangeMetaParam 

func NewDataStoreChangeMetaParam() *DataStoreChangeMetaParam

NewDataStoreChangeMetaParam returns a new DataStoreChangeMetaParam

func (*DataStoreChangeMetaParam) ExtractFromStream 

func (dataStoreChangeMetaParam *DataStoreChangeMetaParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreChangeMetaParam structure from a stream

type DataStoreChangeMetaParamV1 

type DataStoreChangeMetaParamV1 struct {
	nex.Structure

	DataID         uint64
	ModifiesFlag   uint32
	Name           string
	Permission     *DataStorePermission
	DelPermission  *DataStorePermission
	Period         uint16
	MetaBinary     []byte
	Tags           []string
	UpdatePassword uint64
}

func NewDataStoreChangeMetaParamV1 

func NewDataStoreChangeMetaParamV1() *DataStoreChangeMetaParamV1

NewDataStoreChangeMetaParamV1 returns a new DataStoreChangeMetaParamV1

func (*DataStoreChangeMetaParamV1) Bytes 

func (dataStoreChangeMetaParamV1 *DataStoreChangeMetaParamV1) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreChangeMetaParamV1 and returns a byte array

func (*DataStoreChangeMetaParamV1) ExtractFromStream 

func (dataStoreChangeMetaParamV1 *DataStoreChangeMetaParamV1) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreChangeMetaParamV1 structure from a stream

type DataStoreCompletePostParam 

type DataStoreCompletePostParam struct {
	nex.Structure
	DataID    uint64
	IsSuccess bool
}

DataStoreCompletePostParam is sent in the CompletePostObject method

func NewDataStoreCompletePostParam 

func NewDataStoreCompletePostParam() *DataStoreCompletePostParam

NewDataStoreCompletePostParam returns a new DataStoreCompletePostParam

func (*DataStoreCompletePostParam) ExtractFromStream 

func (dataStoreCompletePostParam *DataStoreCompletePostParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreCompletePostParam structure from a stream

type DataStoreCompletePostParamV1 

type DataStoreCompletePostParamV1 struct {
	nex.Structure

	DataID    uint32
	IsSuccess bool
}

func NewDataStoreCompletePostParamV1 

func NewDataStoreCompletePostParamV1() *DataStoreCompletePostParamV1

NewDataStoreCompletePostParamV1 returns a new DataStoreCompletePostParamV1

func (*DataStoreCompletePostParamV1) Bytes 

func (dataStoreCompletePostParamV1 *DataStoreCompletePostParamV1) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreCompletePostParamV1 and returns a byte array

func (*DataStoreCompletePostParamV1) ExtractFromStream 

func (dataStoreCompletePostParamV1 *DataStoreCompletePostParamV1) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreCompletePostParamV1 structure from a stream

type DataStoreCompletePostReplayParam 

type DataStoreCompletePostReplayParam struct {
	nex.Structure

	ReplayID      uint64
	CompleteParam *DataStoreCompletePostParam
	PrepareParam  *DataStorePreparePostReplayParam
}

func NewDataStoreCompletePostReplayParam 

func NewDataStoreCompletePostReplayParam() *DataStoreCompletePostReplayParam

NewDataStoreCompletePostReplayParam returns a new DataStoreCompletePostReplayParam

func (*DataStoreCompletePostReplayParam) Bytes 

func (dataStoreCompletePostReplayParam *DataStoreCompletePostReplayParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreCompletePostReplayParam and returns a byte array

func (*DataStoreCompletePostReplayParam) ExtractFromStream 

func (dataStoreCompletePostReplayParam *DataStoreCompletePostReplayParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreCompletePostReplayParam structure from a stream

type DataStoreCompletePostSharedDataParam 

type DataStoreCompletePostSharedDataParam struct {
	nex.Structure

	DataID        uint64
	CompleteParam *DataStoreCompletePostParam
	PrepareParam  *DataStorePreparePostSharedDataParam
}

func NewDataStoreCompletePostSharedDataParam 

func NewDataStoreCompletePostSharedDataParam() *DataStoreCompletePostSharedDataParam

NewDataStoreCompletePostSharedDataParam returns a new DataStoreCompletePostSharedDataParam

func (*DataStoreCompletePostSharedDataParam) Bytes 

func (dataStoreCompletePostSharedDataParam *DataStoreCompletePostSharedDataParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreCompletePostSharedDataParam and returns a byte array

func (*DataStoreCompletePostSharedDataParam) ExtractFromStream 

func (dataStoreCompletePostSharedDataParam *DataStoreCompletePostSharedDataParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreCompletePostSharedDataParam structure from a stream

type DataStoreCompleteUpdateParam 

type DataStoreCompleteUpdateParam struct {
	nex.Structure

	DataID    uint64
	Version   uint32
	IsSuccess bool
}

func NewDataStoreCompleteUpdateParam 

func NewDataStoreCompleteUpdateParam() *DataStoreCompleteUpdateParam

NewDataStoreCompleteUpdateParam returns a new DataStoreCompleteUpdateParam

func (*DataStoreCompleteUpdateParam) Bytes 

func (dataStoreCompleteUpdateParam *DataStoreCompleteUpdateParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreCompleteUpdateParam and returns a byte array

func (*DataStoreCompleteUpdateParam) ExtractFromStream 

func (dataStoreCompleteUpdateParam *DataStoreCompleteUpdateParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreCompleteUpdateParam structure from a stream

type DataStoreCustomRankingResult 

type DataStoreCustomRankingResult struct {
	Order    uint32
	Score    uint32
	MetaInfo *DataStoreMetaInfo

	nex.Structure
}

DataStoreCustomRankingResult is sent in the FollowingsLatestCourseSearchObject method

func NewDataStoreCustomRankingResult 

func NewDataStoreCustomRankingResult() *DataStoreCustomRankingResult

NewDataStoreCustomRankingResult returns a new DataStoreCustomRankingResult

func (*DataStoreCustomRankingResult) Bytes 

func (dataStoreCustomRankingResult *DataStoreCustomRankingResult) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreCustomRankingResult and returns a byte array

func (*DataStoreCustomRankingResult) ExtractFromStream 

func (dataStoreCustomRankingResult *DataStoreCustomRankingResult) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreCustomRankingResult structure from a stream

type DataStoreDeleteParam 

type DataStoreDeleteParam struct {
	nex.Structure

	DataID         uint64
	UpdatePassword uint64
}

func NewDataStoreDeleteParam 

func NewDataStoreDeleteParam() *DataStoreDeleteParam

NewDataStoreDeleteParam returns a new DataStoreDeleteParam

func (*DataStoreDeleteParam) Bytes 

func (dataStoreDeleteParam *DataStoreDeleteParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreDeleteParam and returns a byte array

func (*DataStoreDeleteParam) ExtractFromStream 

func (dataStoreDeleteParam *DataStoreDeleteParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreDeleteParam structure from a stream

type DataStoreFightingPowerChart 

type DataStoreFightingPowerChart struct {
	nex.Structure

	UserNum uint32
	Chart   []*DataStoreFightingPowerScore
}

func NewDataStoreFightingPowerChart 

func NewDataStoreFightingPowerChart() *DataStoreFightingPowerChart

NewDataStoreFightingPowerChart returns a new DataStoreFightingPowerChart

func (*DataStoreFightingPowerChart) Bytes 

func (dataStoreFightingPowerChart *DataStoreFightingPowerChart) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreFightingPowerChart and returns a byte array

func (*DataStoreFightingPowerChart) ExtractFromStream 

func (dataStoreFightingPowerChart *DataStoreFightingPowerChart) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreFightingPowerChart structure from a stream

type DataStoreFightingPowerScore 

type DataStoreFightingPowerScore struct {
	nex.Structure

	Score uint32
	Rank  uint32
}

func NewDataStoreFightingPowerScore 

func NewDataStoreFightingPowerScore() *DataStoreFightingPowerScore

NewDataStoreFightingPowerScore returns a new DataStoreFightingPowerScore

func ReadListDataStoreFightingPowerScore 

func ReadListDataStoreFightingPowerScore(stream *nex.StreamIn) ([]*DataStoreFightingPowerScore, error)

ReadListDataStoreFightingPowerScore reads a list of DataStoreFightingPowerScore structures

func (*DataStoreFightingPowerScore) Bytes 

func (dataStoreFightingPowerScore *DataStoreFightingPowerScore) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreFightingPowerScore and returns a byte array

func (*DataStoreFightingPowerScore) ExtractFromStream 

func (dataStoreFightingPowerScore *DataStoreFightingPowerScore) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreFightingPowerScore structure from a stream

type DataStoreFileServerObjectInfo 

type DataStoreFileServerObjectInfo struct {
	nex.Structure
	DataID  uint64
	GetInfo *DataStoreReqGetInfo
}

DataStoreFileServerObjectInfo is sent in the GetObjectInfos method

func NewDataStoreFileServerObjectInfo 

func NewDataStoreFileServerObjectInfo() *DataStoreFileServerObjectInfo

NewDataStoreFileServerObjectInfo returns a new DataStoreFileServerObjectInfo

func (*DataStoreFileServerObjectInfo) Bytes 

func (dataStoreFileServerObjectInfo *DataStoreFileServerObjectInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreFileServerObjectInfo and returns a byte array

type DataStoreGetCourseRecordParam 

type DataStoreGetCourseRecordParam struct {
	nex.Structure
	DataID uint64
	Slot   uint8
}

DataStoreGetCourseRecordParam is sent in the GetMetasWithCourseRecord method

func NewDataStoreGetCourseRecordParam 

func NewDataStoreGetCourseRecordParam() *DataStoreGetCourseRecordParam

NewDataStoreGetCourseRecordParamreturns a new DataStoreGetCourseRecordParam

func ReadListDataStoreGetCourseRecordParam 

func ReadListDataStoreGetCourseRecordParam(stream *nex.StreamIn) ([]*DataStoreGetCourseRecordParam, error)

ReadListDataStoreGetCourseRecordParam reads a list of DataStoreGetCourseRecordParam structures

func (*DataStoreGetCourseRecordParam) ExtractFromStream 

func (dataStoreGetCourseRecordParam *DataStoreGetCourseRecordParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreGetCourseRecordParam structure from a stream

type DataStoreGetCourseRecordResult 

type DataStoreGetCourseRecordResult struct {
	nex.Structure
	DataID      uint64
	Slot        uint8
	FirstPID    uint32
	BestPID     uint32
	BestScore   int32
	CreatedTime *nex.DateTime
	UpdatedTime *nex.DateTime
}

DataStoreGetCourseRecordResult is used to send data about a courses world record

func NewDataStoreGetCourseRecordResult 

func NewDataStoreGetCourseRecordResult() *DataStoreGetCourseRecordResult

NewDataStoreGetCourseRecordResult returns a new DataStoreGetCourseRecordResult

func (*DataStoreGetCourseRecordResult) Bytes 

func (dataStoreGetCourseRecordResult *DataStoreGetCourseRecordResult) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreGetCourseRecordResult and returns a byte array

type DataStoreGetCustomRankingByDataIdParam 

type DataStoreGetCustomRankingByDataIdParam struct {
	nex.Structure
	ApplicationId uint32
	DataIdList    []uint64
	ResultOption  uint8
}

DataStoreGetCustomRankingByDataIdParam is sent in the GetCustomRankingByDataId method

func NewDataStoreGetCustomRankingByDataIdParam 

func NewDataStoreGetCustomRankingByDataIdParam() *DataStoreGetCustomRankingByDataIdParam

NewDataStoreGetCustomRankingByDataIdParam returns a new DataStoreGetCustomRankingByDataIdParam

func (*DataStoreGetCustomRankingByDataIdParam) ExtractFromStream 

func (dataStoreGetCustomRankingByDataIdParam *DataStoreGetCustomRankingByDataIdParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreGetCustomRankingByDataIdParam structure from a stream

type DataStoreGetMetaByOwnerIdParam 

type DataStoreGetMetaByOwnerIdParam struct {
	nex.Structure
	OwnerIDs     []uint32
	DataTypes    []uint16
	ResultOption uint8
	ResultRange  *nex.ResultRange
}

func NewDataStoreGetMetaByOwnerIdParam 

func NewDataStoreGetMetaByOwnerIdParam() *DataStoreGetMetaByOwnerIdParam

NewDataStoreGetMetaByOwnerIdParam returns a new DataStoreGetMetaByOwnerIdParam

func (*DataStoreGetMetaByOwnerIdParam) Bytes 

func (dataStoreGetMetaByOwnerIdParam *DataStoreGetMetaByOwnerIdParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreGetMetaByOwnerIdParam and returns a byte array

func (*DataStoreGetMetaByOwnerIdParam) ExtractFromStream 

func (dataStoreGetMetaByOwnerIdParam *DataStoreGetMetaByOwnerIdParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreGetMetaByOwnerIdParam structure from a stream

type DataStoreGetMetaParam 

type DataStoreGetMetaParam struct {
	nex.Structure
	DataID            uint64
	PersistenceTarget *DataStorePersistenceTarget
	ResultOption      uint8
	AccessPassword    uint64
}

DataStoreGetMetaParam is sent in the GetMeta method

func NewDataStoreGetMetaParam 

func NewDataStoreGetMetaParam() *DataStoreGetMetaParam

NewDataStoreGetMetaParam returns a new DataStoreGetMetaParam

func ReaListDataStoreGetMetaParam 

func ReaListDataStoreGetMetaParam(stream *nex.StreamIn) ([]*DataStoreGetMetaParam, error)

ReaListDataStoreGetMetaParam reads a list of DataStoreGetMetaParam structures

func (*DataStoreGetMetaParam) ExtractFromStream 

func (dataStoreGetMetaParam *DataStoreGetMetaParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreGetMetaParam structure from a stream

type DataStoreGetNewArrivedNotificationsParam 

type DataStoreGetNewArrivedNotificationsParam struct {
	nex.Structure

	LastNotificationID uint64
	Limit              uint16
}

func NewDataStoreGetNewArrivedNotificationsParam 

func NewDataStoreGetNewArrivedNotificationsParam() *DataStoreGetNewArrivedNotificationsParam

NewDataStoreGetNewArrivedNotificationsParam returns a new DataStoreGetNewArrivedNotificationsParam

func (*DataStoreGetNewArrivedNotificationsParam) Bytes 

func (dataStoreGetNewArrivedNotificationsParam *DataStoreGetNewArrivedNotificationsParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreGetNewArrivedNotificationsParam and returns a byte array

func (*DataStoreGetNewArrivedNotificationsParam) ExtractFromStream 

func (dataStoreGetNewArrivedNotificationsParam *DataStoreGetNewArrivedNotificationsParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreGetNewArrivedNotificationsParam structure from a stream

type DataStoreGetNotificationUrlParam 

type DataStoreGetNotificationUrlParam struct {
	nex.Structure

	PreviousUrl string
}

func NewDataStoreGetNotificationUrlParam 

func NewDataStoreGetNotificationUrlParam() *DataStoreGetNotificationUrlParam

NewDataStoreGetNotificationUrlParam returns a new DataStoreGetNotificationUrlParam

func (*DataStoreGetNotificationUrlParam) Bytes 

func (dataStoreGetNotificationUrlParam *DataStoreGetNotificationUrlParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreGetNotificationUrlParam and returns a byte array

func (*DataStoreGetNotificationUrlParam) ExtractFromStream 

func (dataStoreGetNotificationUrlParam *DataStoreGetNotificationUrlParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreGetNotificationUrlParam structure from a stream

type DataStoreGetReplayMetaParam 

type DataStoreGetReplayMetaParam struct {
	nex.Structure

	ReplayID uint64
	MetaType uint8
}

func NewDataStoreGetReplayMetaParam 

func NewDataStoreGetReplayMetaParam() *DataStoreGetReplayMetaParam

NewDataStoreGetReplayMetaParam returns a new DataStoreGetReplayMetaParam

func (*DataStoreGetReplayMetaParam) Bytes 

func (dataStoreGetReplayMetaParam *DataStoreGetReplayMetaParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreGetReplayMetaParam and returns a byte array

func (*DataStoreGetReplayMetaParam) ExtractFromStream 

func (dataStoreGetReplayMetaParam *DataStoreGetReplayMetaParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreGetReplayMetaParam structure from a stream

type DataStoreGetSpecificMetaParam 

type DataStoreGetSpecificMetaParam struct {
	nex.Structure

	DataIDs []uint64
}

func NewDataStoreGetSpecificMetaParam 

func NewDataStoreGetSpecificMetaParam() *DataStoreGetSpecificMetaParam

NewDataStoreGetSpecificMetaParam returns a new DataStoreGetSpecificMetaParam

func (*DataStoreGetSpecificMetaParam) Bytes 

func (dataStoreGetSpecificMetaParam *DataStoreGetSpecificMetaParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreGetSpecificMetaParam and returns a byte array

func (*DataStoreGetSpecificMetaParam) ExtractFromStream 

func (dataStoreGetSpecificMetaParam *DataStoreGetSpecificMetaParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreGetSpecificMetaParam structure from a stream

type DataStoreGetSpecificMetaParamV1 

type DataStoreGetSpecificMetaParamV1 struct {
	nex.Structure

	DataIDs []uint32
}

func NewDataStoreGetSpecificMetaParamV1 

func NewDataStoreGetSpecificMetaParamV1() *DataStoreGetSpecificMetaParamV1

NewDataStoreGetSpecificMetaParamV1 returns a new DataStoreGetSpecificMetaParamV1

func (*DataStoreGetSpecificMetaParamV1) Bytes 

func (dataStoreGetSpecificMetaParamV1 *DataStoreGetSpecificMetaParamV1) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreGetSpecificMetaParamV1 and returns a byte array

func (*DataStoreGetSpecificMetaParamV1) ExtractFromStream 

func (dataStoreGetSpecificMetaParamV1 *DataStoreGetSpecificMetaParamV1) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreGetSpecificMetaParamV1 structure from a stream

type DataStoreKeyValue 

type DataStoreKeyValue struct {
	nex.Structure
	Key   string
	Value string
}

DataStoreKeyValue is sent in the PrepareGetObject method

func NewDataStoreKeyValue 

func NewDataStoreKeyValue() *DataStoreKeyValue

NewDataStoreKeyValue returns a new DataStoreKeyValue

func ReadListDataStoreKeyValue 

func ReadListDataStoreKeyValue(stream *nex.StreamIn) ([]*DataStoreKeyValue, error)

ReadListDataStoreKeyValue reads a list of DataStoreKeyValue structures

func (*DataStoreKeyValue) Bytes 

func (dataStoreKeyValue *DataStoreKeyValue) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreKeyValue and returns a byte array

type DataStoreMetaInfo 

type DataStoreMetaInfo struct {
	nex.Structure
	DataID        uint64
	OwnerID       uint32
	Size          uint32
	DataType      uint16
	Name          string
	MetaBinary    []byte
	Permission    *DataStorePermission
	DelPermission *DataStorePermission
	CreatedTime   *nex.DateTime
	UpdatedTime   *nex.DateTime
	Period        uint16
	Status        uint8
	ReferredCnt   uint32
	ReferDataID   uint32
	Flag          uint32
	ReferredTime  *nex.DateTime
	ExpireTime    *nex.DateTime
	Tags          []string
	Ratings       []*DataStoreRatingInfoWithSlot
}

DataStoreMetaInfo contains DataStore meta information

func NewDataStoreMetaInfo 

func NewDataStoreMetaInfo() *DataStoreMetaInfo

NewDataStoreMetaInfo returns a new DataStoreMetaInfo

func ReadListDataStoreMetaInfo 

func ReadListDataStoreMetaInfo(stream *nex.StreamIn) ([]*DataStoreMetaInfo, error)

ReadListDataStoreMetaInfo reads a list of DataStoreMetaInfo structures

func (*DataStoreMetaInfo) Bytes 

func (dataStoreMetaInfo *DataStoreMetaInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreMetaInfo and returns a byte array

func (*DataStoreMetaInfo) ExtractFromStream 

func (dataStoreMetaInfo *DataStoreMetaInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreMetaInfo structure from a stream

type DataStoreNotification 

type DataStoreNotification struct {
	nex.Structure

	NotificationID uint64
	DataID         uint64
}

func NewDataStoreNotification 

func NewDataStoreNotification() *DataStoreNotification

NewDataStoreNotification returns a new DataStoreNotification

func (*DataStoreNotification) Bytes 

func (dataStoreNotification *DataStoreNotification) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreNotification and returns a byte array

func (*DataStoreNotification) ExtractFromStream 

func (dataStoreNotification *DataStoreNotification) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreNotification structure from a stream

type DataStoreNotificationV1 

type DataStoreNotificationV1 struct {
	nex.Structure

	NotificationID uint64
	DataID         uint32
}

func NewDataStoreNotificationV1 

func NewDataStoreNotificationV1() *DataStoreNotificationV1

NewDataStoreNotificationV1 returns a new DataStoreNotificationV1

func (*DataStoreNotificationV1) Bytes 

func (dataStoreNotificationV1 *DataStoreNotificationV1) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreNotificationV1 and returns a byte array

func (*DataStoreNotificationV1) ExtractFromStream 

func (dataStoreNotificationV1 *DataStoreNotificationV1) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreNotificationV1 structure from a stream

type DataStorePasswordInfo 

type DataStorePasswordInfo struct {
	nex.Structure

	DataID         uint64
	AccessPassword uint64
	UpdatePassword uint64
}

func NewDataStorePasswordInfo 

func NewDataStorePasswordInfo() *DataStorePasswordInfo

NewDataStorePasswordInfo returns a new DataStorePasswordInfo

func (*DataStorePasswordInfo) Bytes 

func (dataStorePasswordInfo *DataStorePasswordInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePasswordInfo and returns a byte array

func (*DataStorePasswordInfo) ExtractFromStream 

func (dataStorePasswordInfo *DataStorePasswordInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePasswordInfo structure from a stream

type DataStorePermission 

type DataStorePermission struct {
	nex.Structure
	Permission   uint8
	RecipientIds []uint32
}

DataStorePermission contains information about a permission for a DataStore object

func NewDataStorePermission 

func NewDataStorePermission() *DataStorePermission

NewDataStorePermission returns a new DataStorePermission

func (*DataStorePermission) Bytes 

func (dataStorePermission *DataStorePermission) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePermission and returns a byte array

func (*DataStorePermission) ExtractFromStream 

func (dataStorePermission *DataStorePermission) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePermission structure from a stream

type DataStorePersistenceInfo 

type DataStorePersistenceInfo struct {
	nex.Structure

	OwnerID           uint32
	PersistenceSlotID uint16
	DataID            uint64
}

func NewDataStorePersistenceInfo 

func NewDataStorePersistenceInfo() *DataStorePersistenceInfo

NewDataStorePersistenceInfo returns a new DataStorePersistenceInfo

func (*DataStorePersistenceInfo) Bytes 

func (dataStorePersistenceInfo *DataStorePersistenceInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePersistenceInfo and returns a byte array

func (*DataStorePersistenceInfo) ExtractFromStream 

func (dataStorePersistenceInfo *DataStorePersistenceInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePersistenceInfo structure from a stream

type DataStorePersistenceInitParam 

type DataStorePersistenceInitParam struct {
	nex.Structure
	PersistenceSlotId uint16
	DeleteLastObject  bool
}

DataStorePersistenceInitParam is sent in the PreparePostObject method

func NewDataStorePersistenceInitParam 

func NewDataStorePersistenceInitParam() *DataStorePersistenceInitParam

NewDataStorePersistenceInitParam returns a new DataStorePersistenceInitParam

func (*DataStorePersistenceInitParam) ExtractFromStream 

func (dataStorePersistenceInitParam *DataStorePersistenceInitParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePersistenceInitParam structure from a stream

type DataStorePersistenceTarget 

type DataStorePersistenceTarget struct {
	nex.Structure
	OwnerID           uint32
	PersistenceSlotID uint16
}

DataStorePersistenceTarget contains information about a DataStore target

func NewDataStorePersistenceTarget 

func NewDataStorePersistenceTarget() *DataStorePersistenceTarget

NewDataStorePersistenceTarget returns a new DataStorePersistenceTarget

func (*DataStorePersistenceTarget) ExtractFromStream 

func (dataStorePersistenceTarget *DataStorePersistenceTarget) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePersistenceTarget structure from a stream

type DataStorePostFightingPowerScoreParam 

type DataStorePostFightingPowerScoreParam struct {
	nex.Structure

	Mode             uint8
	Score            uint32
	IsWorldHighScore bool
}

func NewDataStorePostFightingPowerScoreParam 

func NewDataStorePostFightingPowerScoreParam() *DataStorePostFightingPowerScoreParam

NewDataStorePostFightingPowerScoreParam returns a new DataStorePostFightingPowerScoreParam

func ReadListDataStorePostFightingPowerScoreParam 

func ReadListDataStorePostFightingPowerScoreParam(stream *nex.StreamIn) ([]*DataStorePostFightingPowerScoreParam, error)

ReadListDataStorePostFightingPowerScoreParam reads a list of DataStorePostFightingPowerScoreParam structures

func (*DataStorePostFightingPowerScoreParam) Bytes 

func (dataStorePostFightingPowerScoreParam *DataStorePostFightingPowerScoreParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePostFightingPowerScoreParam and returns a byte array

func (*DataStorePostFightingPowerScoreParam) ExtractFromStream 

func (dataStorePostFightingPowerScoreParam *DataStorePostFightingPowerScoreParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePostFightingPowerScoreParam structure from a stream

type DataStorePostProfileParam 

type DataStorePostProfileParam struct {
	nex.Structure

	Profile []byte
}

func NewDataStorePostProfileParam 

func NewDataStorePostProfileParam() *DataStorePostProfileParam

NewDataStorePostProfileParam returns a new DataStorePostProfileParam

func (*DataStorePostProfileParam) Bytes 

func (dataStorePostProfileParam *DataStorePostProfileParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePostProfileParam and returns a byte array

func (*DataStorePostProfileParam) ExtractFromStream 

func (dataStorePostProfileParam *DataStorePostProfileParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePostProfileParam structure from a stream

type DataStorePrepareGetParam 

type DataStorePrepareGetParam struct {
	nex.Structure
	DataID            uint64
	LockID            uint32
	PersistenceTarget *DataStorePersistenceTarget
	AccessPassword    uint64
	ExtraData         []string
}

DataStorePrepareGetParam is sent in the PrepareGetObject method

func NewDataStorePrepareGetParam 

func NewDataStorePrepareGetParam() *DataStorePrepareGetParam

NewDataStorePrepareGetParam returns a new DataStorePrepareGetParam

func (*DataStorePrepareGetParam) ExtractFromStream 

func (dataStorePrepareGetParam *DataStorePrepareGetParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePrepareGetParam structure from a stream

type DataStorePrepareGetParamV1 

type DataStorePrepareGetParamV1 struct {
	nex.Structure

	DataID uint32
	LockID uint32
}

func NewDataStorePrepareGetParamV1 

func NewDataStorePrepareGetParamV1() *DataStorePrepareGetParamV1

NewDataStorePrepareGetParamV1 returns a new DataStorePrepareGetParamV1

func (*DataStorePrepareGetParamV1) Bytes 

func (dataStorePrepareGetParamV1 *DataStorePrepareGetParamV1) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePrepareGetParamV1 and returns a byte array

func (*DataStorePrepareGetParamV1) ExtractFromStream 

func (dataStorePrepareGetParamV1 *DataStorePrepareGetParamV1) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePrepareGetParamV1 structure from a stream

type DataStorePrepareGetReplayParam 

type DataStorePrepareGetReplayParam struct {
	nex.Structure

	ReplayID  uint64
	ExtraData []string
}

func NewDataStorePrepareGetReplayParam 

func NewDataStorePrepareGetReplayParam() *DataStorePrepareGetReplayParam

NewDataStorePrepareGetReplayParam returns a new DataStorePrepareGetReplayParam

func (*DataStorePrepareGetReplayParam) Bytes 

func (dataStorePrepareGetReplayParam *DataStorePrepareGetReplayParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePrepareGetReplayParam and returns a byte array

func (*DataStorePrepareGetReplayParam) ExtractFromStream 

func (dataStorePrepareGetReplayParam *DataStorePrepareGetReplayParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePrepareGetReplayParam structure from a stream

type DataStorePreparePostParam 

type DataStorePreparePostParam struct {
	nex.Structure
	Size                 uint32
	Name                 string
	DataType             uint16
	MetaBinary           []byte
	Permission           *DataStorePermission
	DelPermission        *DataStorePermission
	Flag                 uint32
	Period               uint16
	ReferDataId          uint32
	Tags                 []string
	RatingInitParams     []*DataStoreRatingInitParamWithSlot
	PersistenceInitParam *DataStorePersistenceInitParam
	ExtraData            []string
}

DataStoreSearchParam is sent in the PreparePostObject method

func NewDataStorePreparePostParam 

func NewDataStorePreparePostParam() *DataStorePreparePostParam

NewDataStorePreparePostParam returns a new DataStorePreparePostParam

func (*DataStorePreparePostParam) ExtractFromStream 

func (dataStorePreparePostParam *DataStorePreparePostParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePreparePostParam structure from a stream

type DataStorePreparePostParamV1 

type DataStorePreparePostParamV1 struct {
	nex.Structure

	Size             uint32
	Name             string
	DataType         uint16
	MetaBinary       []byte
	Permission       *DataStorePermission
	DelPermission    *DataStorePermission
	Flag             uint32
	Period           uint16
	ReferDataID      uint32
	Tags             []string
	RatingInitParams []*DataStoreRatingInitParamWithSlot
}

func NewDataStorePreparePostParamV1 

func NewDataStorePreparePostParamV1() *DataStorePreparePostParamV1

NewDataStorePreparePostParamV1 returns a new DataStorePreparePostParamV1

func (*DataStorePreparePostParamV1) Bytes 

func (dataStorePreparePostParamV1 *DataStorePreparePostParamV1) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePreparePostParamV1 and returns a byte array

func (*DataStorePreparePostParamV1) ExtractFromStream 

func (dataStorePreparePostParamV1 *DataStorePreparePostParamV1) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePreparePostParamV1 structure from a stream

type DataStorePreparePostReplayParam 

type DataStorePreparePostReplayParam struct {
	nex.Structure

	Size          uint32
	Mode          uint8
	Style         uint8
	Rule          uint8
	Stage         uint8
	ReplayType    uint8
	CompetitionID uint64
	Score         int32
	Players       []*DataStoreReplayPlayer
	Winners       []uint32
	KeyVersion    uint16
	ExtraData     []string
}

func NewDataStorePreparePostReplayParam 

func NewDataStorePreparePostReplayParam() *DataStorePreparePostReplayParam

NewDataStorePreparePostReplayParam returns a new DataStorePreparePostReplayParam

func (*DataStorePreparePostReplayParam) Bytes 

func (dataStorePreparePostReplayParam *DataStorePreparePostReplayParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePreparePostReplayParam and returns a byte array

func (*DataStorePreparePostReplayParam) ExtractFromStream 

func (dataStorePreparePostReplayParam *DataStorePreparePostReplayParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePreparePostReplayParam structure from a stream

type DataStorePreparePostSharedDataParam 

type DataStorePreparePostSharedDataParam struct {
	nex.Structure

	DataType   uint8
	Region     uint8
	Attribute1 uint8
	Attribute2 uint8
	Fighter    []byte
	Size       uint32
	Comment    string
	MetaBinary []byte
	ExtraData  []string
}

func NewDataStorePreparePostSharedDataParam 

func NewDataStorePreparePostSharedDataParam() *DataStorePreparePostSharedDataParam

NewDataStorePreparePostSharedDataParam returns a new DataStorePreparePostSharedDataParam

func (*DataStorePreparePostSharedDataParam) Bytes 

func (dataStorePreparePostSharedDataParam *DataStorePreparePostSharedDataParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePreparePostSharedDataParam and returns a byte array

func (*DataStorePreparePostSharedDataParam) ExtractFromStream 

func (dataStorePreparePostSharedDataParam *DataStorePreparePostSharedDataParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePreparePostSharedDataParam structure from a stream

type DataStorePrepareUpdateParam 

type DataStorePrepareUpdateParam struct {
	nex.Structure

	DataID         uint64
	Size           uint32
	UpdatePassword uint64
	ExtraData      []string
}

func NewDataStorePrepareUpdateParam 

func NewDataStorePrepareUpdateParam() *DataStorePrepareUpdateParam

NewDataStorePrepareUpdateParam returns a new DataStorePrepareUpdateParam

func (*DataStorePrepareUpdateParam) Bytes 

func (dataStorePrepareUpdateParam *DataStorePrepareUpdateParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStorePrepareUpdateParam and returns a byte array

func (*DataStorePrepareUpdateParam) ExtractFromStream 

func (dataStorePrepareUpdateParam *DataStorePrepareUpdateParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStorePrepareUpdateParam structure from a stream

type DataStoreProfileInfo 

type DataStoreProfileInfo struct {
	nex.Structure

	Pid     uint32
	Profile []byte
}

func NewDataStoreProfileInfo 

func NewDataStoreProfileInfo() *DataStoreProfileInfo

NewDataStoreProfileInfo returns a new DataStoreProfileInfo

func (*DataStoreProfileInfo) Bytes 

func (dataStoreProfileInfo *DataStoreProfileInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreProfileInfo and returns a byte array

func (*DataStoreProfileInfo) ExtractFromStream 

func (dataStoreProfileInfo *DataStoreProfileInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreProfileInfo structure from a stream

type DataStoreProtocol 

type DataStoreProtocol struct {
	GetMetaHandler               func(err error, client *nex.Client, callID uint32, dataStoreGetMetaParam *DataStoreGetMetaParam)
	PrepareUpdateObjectHandler   func(err error, client *nex.Client, callID uint32, dataStorePrepareUpdateParam *DataStorePrepareUpdateParam)
	CompleteUpdateObjectHandler  func(err error, client *nex.Client, callID uint32, dataStoreCompleteUpdateParam *DataStoreCompleteUpdateParam)
	PostMetaBinaryHandler        func(err error, client *nex.Client, callID uint32, dataStorePreparePostParam *DataStorePreparePostParam)
	PreparePostObjectHandler     func(err error, client *nex.Client, callID uint32, dataStorePrepareGetParam *DataStorePreparePostParam)
	PrepareGetObjectHandler      func(err error, client *nex.Client, callID uint32, dataStorePrepareGetParam *DataStorePrepareGetParam)
	CompletePostObjectHandler    func(err error, client *nex.Client, callID uint32, dataStoreCompletePostParam *DataStoreCompletePostParam)
	GetPersistenceInfoHandler    func(err error, client *nex.Client, callID uint32, ownerID uint32, persistenceSlotID uint16)
	GetMetasMultipleParamHandler func(err error, client *nex.Client, callID uint32, dataStoreGetMetaParams []*DataStoreGetMetaParam)
	ChangeMetaHandler            func(err error, client *nex.Client, callID uint32, dataStoreChangeMetaParam *DataStoreChangeMetaParam)
	RateObjectsHandler           func(err error, client *nex.Client, callID uint32, targets []*DataStoreRatingTarget, params []*DataStoreRateObjectParam, transactional bool, fetchRatings bool)
	// contains filtered or unexported fields
}

DataStoreProtocol handles the DataStore nex protocol

func NewDataStoreProtocol 

func NewDataStoreProtocol(server *nex.Server) *DataStoreProtocol

NewDataStoreProtocol returns a new DataStoreProtocol

func (*DataStoreProtocol) ChangeMeta 

func (dataStoreProtocol *DataStoreProtocol) ChangeMeta(handler func(err error, client *nex.Client, callID uint32, dataStoreChangeMetaParam *DataStoreChangeMetaParam))

ChangeMeta sets the ChangeMeta handler function

func (*DataStoreProtocol) CompletePostObject 

func (dataStoreProtocol *DataStoreProtocol) CompletePostObject(handler func(err error, client *nex.Client, callID uint32, dataStoreCompletePostParam *DataStoreCompletePostParam))

CompletePostObject sets the CompletePostObject handler function

func (*DataStoreProtocol) CompleteUpdateObject 

func (dataStoreProtocol *DataStoreProtocol) CompleteUpdateObject(handler func(err error, client *nex.Client, callID uint32, dataStoreCompleteUpdateParam *DataStoreCompleteUpdateParam))

CompleteUpdateObject sets the CompleteUpdateObject handler function

func (*DataStoreProtocol) GetMeta 

func (dataStoreProtocol *DataStoreProtocol) GetMeta(handler func(err error, client *nex.Client, callID uint32, dataStoreGetMetaParam *DataStoreGetMetaParam))

GetMeta sets the GetMeta handler function

func (*DataStoreProtocol) GetMetasMultipleParam 

func (dataStoreProtocol *DataStoreProtocol) GetMetasMultipleParam(handler func(err error, client *nex.Client, callID uint32, dataStorePrepareGetParams []*DataStoreGetMetaParam))

GetMetasMultipleParam sets the GetMetasMultipleParam handler function

func (*DataStoreProtocol) GetPersistenceInfo 

func (dataStoreProtocol *DataStoreProtocol) GetPersistenceInfo(handler func(err error, client *nex.Client, callID uint32, ownerID uint32, persistenceSlotID uint16))

GetPersistenceInfo sets the GetPersistenceInfo handler function

func (*DataStoreProtocol) PostMetaBinary 

func (dataStoreProtocol *DataStoreProtocol) PostMetaBinary(handler func(err error, client *nex.Client, callID uint32, dataStorePreparePostParam *DataStorePreparePostParam))

PostMetaBinary sets the PostMetaBinary handler function

func (*DataStoreProtocol) PrepareGetObject 

func (dataStoreProtocol *DataStoreProtocol) PrepareGetObject(handler func(err error, client *nex.Client, callID uint32, dataStorePrepareGetParam *DataStorePrepareGetParam))

PrepareGetObject sets the PrepareGetObject handler function

func (*DataStoreProtocol) PreparePostObject 

func (dataStoreProtocol *DataStoreProtocol) PreparePostObject(handler func(err error, client *nex.Client, callID uint32, dataStorePreparePostParam *DataStorePreparePostParam))

PreparePostObject sets the PreparePostObject handler function

func (*DataStoreProtocol) PrepareUpdateObject 

func (dataStoreProtocol *DataStoreProtocol) PrepareUpdateObject(handler func(err error, client *nex.Client, callID uint32, dataStorePrepareUpdateParam *DataStorePrepareUpdateParam))

PrepareUpdateObject sets the PrepareUpdateObject handler function

func (*DataStoreProtocol) RateObjects 

func (dataStoreProtocol *DataStoreProtocol) RateObjects(handler func(err error, client *nex.Client, callID uint32, targets []*DataStoreRatingTarget, params []*DataStoreRateObjectParam, transactional bool, fetchRatings bool))

RateObjects sets the RateObjects handler function

func (*DataStoreProtocol) Setup 

func (dataStoreProtocol *DataStoreProtocol) Setup()

Setup initializes the protocol

type DataStoreRateCustomRankingParam 

type DataStoreRateCustomRankingParam struct {
	nex.Structure
	DataID        uint64
	ApplicationId uint32
	Score         uint32
	Period        uint16
}

DataStoreRateCustomRankingParam is sent in the RateCustomRanking method

func NewDataStoreRateCustomRankingParam 

func NewDataStoreRateCustomRankingParam() *DataStoreRateCustomRankingParam

NewDataStoreRateCustomRankingParam returns a new DataStoreRateCustomRankingParam

func ReadListDataStoreRateCustomRankingParam 

func ReadListDataStoreRateCustomRankingParam(stream *nex.StreamIn) ([]*DataStoreRateCustomRankingParam, error)

ReadListDataStoreRateCustomRankingParam reads a list of DataStoreRateCustomRankingParam structures

func (*DataStoreRateCustomRankingParam) ExtractFromStream 

func (dataStoreRateCustomRankingParam *DataStoreRateCustomRankingParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreRateCustomRankingParam structure from a stream

type DataStoreRateObjectParam 

type DataStoreRateObjectParam struct {
	nex.Structure
	RatingValue    int32
	AccessPassword uint64
}

DataStoreRateObjectParam is sent in the RateObjects method

func NewDataStoreRateObjectParam 

func NewDataStoreRateObjectParam() *DataStoreRateObjectParam

NewDataStoreRateObjectParam returns a new DataStoreRateObjectParam

func ReadListDataStoreRateObjectParam 

func ReadListDataStoreRateObjectParam(stream *nex.StreamIn) ([]*DataStoreRateObjectParam, error)

ReadListDataStoreRateObjectParam reads a list of DataStoreRateObjectParam structures

func (*DataStoreRateObjectParam) ExtractFromStream 

func (dataStoreRateObjectParam *DataStoreRateObjectParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreRateObjectParam structure from a stream

type DataStoreRatingInfo 

type DataStoreRatingInfo struct {
	nex.Structure
	TotalValue   int64
	Count        uint32
	InitialValue int64
}

func NewDataStoreRatingInfo 

func NewDataStoreRatingInfo() *DataStoreRatingInfo

NewDataStoreRatingInfo returns a new DataStoreRatingInfo

func (*DataStoreRatingInfo) Bytes 

func (dataStoreRatingInfo *DataStoreRatingInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreRatingInfo and returns a byte array

func (*DataStoreRatingInfo) ExtractFromStream 

func (dataStoreRatingInfo *DataStoreRatingInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreRatingInfo structure from a stream

type DataStoreRatingInfoWithSlot 

type DataStoreRatingInfoWithSlot struct {
	nex.Structure
	Slot   int8
	Rating *DataStoreRatingInfo
}

func NewDataStoreRatingInfoWithSlot 

func NewDataStoreRatingInfoWithSlot() *DataStoreRatingInfoWithSlot

NewDataStoreRatingInfoWithSlot returns a new DataStoreRatingInfoWithSlot

func ReadListDataStoreRatingInfoWithSlot 

func ReadListDataStoreRatingInfoWithSlot(stream *nex.StreamIn) ([]*DataStoreRatingInfoWithSlot, error)

ReadListDataStoreRatingInfoWithSlot reads a list of DataStoreRatingInfoWithSlot structures

func (*DataStoreRatingInfoWithSlot) Bytes 

func (dataStoreRatingInfoWithSlot *DataStoreRatingInfoWithSlot) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreRatingInfoWithSlot and returns a byte array

func (*DataStoreRatingInfoWithSlot) ExtractFromStream 

func (dataStoreRatingInfoWithSlot *DataStoreRatingInfoWithSlot) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreRatingInfoWithSlot structure from a stream

type DataStoreRatingInitParam 

type DataStoreRatingInitParam struct {
	nex.Structure
	Flag         uint8
	InternalFlag uint8
	LockType     uint8
	// contains filtered or unexported fields
}

DataStoreRatingInitParam is sent in the PreparePostObject method

func NewDataStoreRatingInitParam 

func NewDataStoreRatingInitParam() *DataStoreRatingInitParam

NewDataStoreRatingInitParam returns a new DataStoreRatingInitParam

func (*DataStoreRatingInitParam) ExtractFromStream 

func (dataStoreRatingInitParam *DataStoreRatingInitParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreRatingInitParam structure from a stream

type DataStoreRatingInitParamWithSlot 

type DataStoreRatingInitParamWithSlot struct {
	nex.Structure
	Slot  int8
	Param *DataStoreRatingInitParam
}

DataStoreRatingInitParamWithSlot is sent in the PreparePostObject method

func NewDataStoreRatingInitParamWithSlot 

func NewDataStoreRatingInitParamWithSlot() *DataStoreRatingInitParamWithSlot

NewDataStoreRatingInitParamWithSlot returns a new DataStoreRatingInitParamWithSlot

func ReadListDataStoreRatingInitParamWithSlot 

func ReadListDataStoreRatingInitParamWithSlot(stream *nex.StreamIn) ([]*DataStoreRatingInitParamWithSlot, error)

ReadListDataStoreRatingInitParamWithSlot reads a list of DataStoreRatingInitParamWithSlot structures

func (*DataStoreRatingInitParamWithSlot) ExtractFromStream 

func (dataStoreRatingInitParamWithSlot *DataStoreRatingInitParamWithSlot) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreRatingInitParamWithSlot structure from a stream

type DataStoreRatingLog 

type DataStoreRatingLog struct {
	nex.Structure

	IsRated            bool
	Pid                uint32
	RatingValue        int32
	LockExpirationTime *nex.DateTime
}

func NewDataStoreRatingLog 

func NewDataStoreRatingLog() *DataStoreRatingLog

NewDataStoreRatingLog returns a new DataStoreRatingLog

func (*DataStoreRatingLog) Bytes 

func (dataStoreRatingLog *DataStoreRatingLog) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreRatingLog and returns a byte array

func (*DataStoreRatingLog) ExtractFromStream 

func (dataStoreRatingLog *DataStoreRatingLog) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreRatingLog structure from a stream

type DataStoreRatingTarget 

type DataStoreRatingTarget struct {
	nex.Structure
	DataID uint64
	Slot   uint8
}

DataStoreRatingTarget is sent in the RateObjects method

func NewDataStoreRatingTarget 

func NewDataStoreRatingTarget() *DataStoreRatingTarget

NewDataStoreRatingTarget returns a new DataStoreRatingTarget

func ReadListDataStoreRatingTarget 

func ReadListDataStoreRatingTarget(stream *nex.StreamIn) ([]*DataStoreRatingTarget, error)

ReadListDataStoreRatingTarget reads a list of DataStoreRatingTarget structures

func (*DataStoreRatingTarget) ExtractFromStream 

func (dataStoreRatingTarget *DataStoreRatingTarget) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreRatingTarget structure from a stream

type DataStoreReplayMetaInfo 

type DataStoreReplayMetaInfo struct {
	nex.Structure

	ReplayID   uint64
	Size       uint32
	Mode       uint8
	Style      uint8
	Rule       uint8
	Stage      uint8
	ReplayType uint8
	Players    []*DataStoreReplayPlayer
	Winners    []uint32
}

func NewDataStoreReplayMetaInfo 

func NewDataStoreReplayMetaInfo() *DataStoreReplayMetaInfo

NewDataStoreReplayMetaInfo returns a new DataStoreReplayMetaInfo

func (*DataStoreReplayMetaInfo) Bytes 

func (dataStoreReplayMetaInfo *DataStoreReplayMetaInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreReplayMetaInfo and returns a byte array

func (*DataStoreReplayMetaInfo) ExtractFromStream 

func (dataStoreReplayMetaInfo *DataStoreReplayMetaInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreReplayMetaInfo structure from a stream

type DataStoreReplayPlayer 

type DataStoreReplayPlayer struct {
	nex.Structure

	Fighter     uint8
	Health      uint8
	WinningRate uint16
	Color       uint8
	Color2      uint8
	PrincipalID uint32
	Country     uint32
	Region      uint8
	Number      uint8
}

func NewDataStoreReplayPlayer 

func NewDataStoreReplayPlayer() *DataStoreReplayPlayer

NewDataStoreReplayPlayer returns a new DataStoreReplayPlayer

func ReadListDataStoreReplayPlayer 

func ReadListDataStoreReplayPlayer(stream *nex.StreamIn) ([]*DataStoreReplayPlayer, error)

ReadListDataStoreReplayPlayer reads a list of DataStoreReplayPlayer structures

func (*DataStoreReplayPlayer) Bytes 

func (dataStoreReplayPlayer *DataStoreReplayPlayer) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreReplayPlayer and returns a byte array

func (*DataStoreReplayPlayer) ExtractFromStream 

func (dataStoreReplayPlayer *DataStoreReplayPlayer) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreReplayPlayer structure from a stream

type DataStoreReqGetAdditionalMeta 

type DataStoreReqGetAdditionalMeta struct {
	nex.Structure

	OwnerID    uint32
	DataType   uint16
	Version    uint16
	MetaBinary []byte
}

func NewDataStoreReqGetAdditionalMeta 

func NewDataStoreReqGetAdditionalMeta() *DataStoreReqGetAdditionalMeta

NewDataStoreReqGetAdditionalMeta returns a new DataStoreReqGetAdditionalMeta

func (*DataStoreReqGetAdditionalMeta) Bytes 

func (dataStoreReqGetAdditionalMeta *DataStoreReqGetAdditionalMeta) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreReqGetAdditionalMeta and returns a byte array

func (*DataStoreReqGetAdditionalMeta) ExtractFromStream 

func (dataStoreReqGetAdditionalMeta *DataStoreReqGetAdditionalMeta) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreReqGetAdditionalMeta structure from a stream

type DataStoreReqGetInfo 

type DataStoreReqGetInfo struct {
	nex.Structure
	URL            string
	RequestHeaders []*DataStoreKeyValue
	Size           uint32
	RootCA         []byte
	DataID         uint64
}

DataStoreReqGetInfo is sent in the PrepareGetObject method

func NewDataStoreReqGetInfo 

func NewDataStoreReqGetInfo() *DataStoreReqGetInfo

NewDataStoreReqGetInfo returns a new DataStoreReqGetInfo

func (*DataStoreReqGetInfo) Bytes 

func (dataStoreReqGetInfo *DataStoreReqGetInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreReqGetInfo and returns a byte array

type DataStoreReqGetInfoV1 

type DataStoreReqGetInfoV1 struct {
	nex.Structure

	Url            string
	RequestHeaders []*DataStoreKeyValue
	Size           uint32
	RootCaCert     []byte
}

func NewDataStoreReqGetInfoV1 

func NewDataStoreReqGetInfoV1() *DataStoreReqGetInfoV1

NewDataStoreReqGetInfoV1 returns a new DataStoreReqGetInfoV1

func (*DataStoreReqGetInfoV1) Bytes 

func (dataStoreReqGetInfoV1 *DataStoreReqGetInfoV1) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreReqGetInfoV1 and returns a byte array

func (*DataStoreReqGetInfoV1) ExtractFromStream 

func (dataStoreReqGetInfoV1 *DataStoreReqGetInfoV1) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreReqGetInfoV1 structure from a stream

type DataStoreReqGetNotificationUrlInfo 

type DataStoreReqGetNotificationUrlInfo struct {
	nex.Structure

	Url        string
	Key        string
	Query      string
	RootCaCert []byte
}

func NewDataStoreReqGetNotificationUrlInfo 

func NewDataStoreReqGetNotificationUrlInfo() *DataStoreReqGetNotificationUrlInfo

NewDataStoreReqGetNotificationUrlInfo returns a new DataStoreReqGetNotificationUrlInfo

func (*DataStoreReqGetNotificationUrlInfo) Bytes 

func (dataStoreReqGetNotificationUrlInfo *DataStoreReqGetNotificationUrlInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreReqGetNotificationUrlInfo and returns a byte array

func (*DataStoreReqGetNotificationUrlInfo) ExtractFromStream 

func (dataStoreReqGetNotificationUrlInfo *DataStoreReqGetNotificationUrlInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreReqGetNotificationUrlInfo structure from a stream

type DataStoreReqPostInfo 

type DataStoreReqPostInfo struct {
	nex.Structure
	DataID         uint64
	URL            string
	RequestHeaders []*DataStoreKeyValue
	FormFields     []*DataStoreKeyValue
	RootCACert     []byte
}

DataStoreReqPostInfo is sent in the PreparePostObject method

func NewDataStoreReqPostInfo 

func NewDataStoreReqPostInfo() *DataStoreReqPostInfo

NewDataStoreReqPostInfo returns a new DataStoreReqPostInfo

func (*DataStoreReqPostInfo) Bytes 

func (dataStoreReqPostInfo *DataStoreReqPostInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreReqPostInfo and returns a byte array

type DataStoreReqPostInfoV1 

type DataStoreReqPostInfoV1 struct {
	nex.Structure

	DataID         uint32
	Url            string
	RequestHeaders []*DataStoreKeyValue
	FormFields     []*DataStoreKeyValue
	RootCaCert     []byte
}

func NewDataStoreReqPostInfoV1 

func NewDataStoreReqPostInfoV1() *DataStoreReqPostInfoV1

NewDataStoreReqPostInfoV1 returns a new DataStoreReqPostInfoV1

func (*DataStoreReqPostInfoV1) Bytes 

func (dataStoreReqPostInfoV1 *DataStoreReqPostInfoV1) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreReqPostInfoV1 and returns a byte array

func (*DataStoreReqPostInfoV1) ExtractFromStream 

func (dataStoreReqPostInfoV1 *DataStoreReqPostInfoV1) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreReqPostInfoV1 structure from a stream

type DataStoreReqUpdateInfo 

type DataStoreReqUpdateInfo struct {
	nex.Structure

	Version        uint32
	Url            string
	RequestHeaders []*DataStoreKeyValue
	FormFields     []*DataStoreKeyValue
	RootCaCert     []byte
}

func NewDataStoreReqUpdateInfo 

func NewDataStoreReqUpdateInfo() *DataStoreReqUpdateInfo

NewDataStoreReqUpdateInfo returns a new DataStoreReqUpdateInfo

func (*DataStoreReqUpdateInfo) Bytes 

func (dataStoreReqUpdateInfo *DataStoreReqUpdateInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreReqUpdateInfo and returns a byte array

func (*DataStoreReqUpdateInfo) ExtractFromStream 

func (dataStoreReqUpdateInfo *DataStoreReqUpdateInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreReqUpdateInfo structure from a stream

type DataStoreSMMProtocol 

type DataStoreSMMProtocol struct {
	DataStoreProtocol
	GetObjectInfosHandler                     func(err error, client *nex.Client, callID uint32, dataIDs []uint64)
	RateCustomRankingHandler                  func(err error, client *nex.Client, callID uint32, dataStoreRateCustomRankingParams []*DataStoreRateCustomRankingParam)
	GetCustomRankingByDataIdHandler           func(err error, client *nex.Client, callID uint32, dataStoreGetCustomRankingByDataIdParam *DataStoreGetCustomRankingByDataIdParam)
	AddToBufferQueuesHandler                  func(err error, client *nex.Client, callID uint32, params []*BufferQueueParam, buffers [][]byte)
	GetBufferQueueHandler                     func(err error, client *nex.Client, callID uint32, bufferQueueParam *BufferQueueParam)
	CompleteAttachFileHandler                 func(err error, client *nex.Client, callID uint32, dataStoreCompletePostParam *DataStoreCompletePostParam)
	PrepareAttachFileHandler                  func(err error, client *nex.Client, callID uint32, dataStoreAttachFileParam *DataStoreAttachFileParam)
	GetApplicationConfigHandler               func(err error, client *nex.Client, callID uint32, applicationID uint32)
	FollowingsLatestCourseSearchObjectHandler func(err error, client *nex.Client, callID uint32, dataStoreSearchParam *DataStoreSearchParam, extraData []string)
	RecommendedCourseSearchObjectHandler      func(err error, client *nex.Client, callID uint32, dataStoreSearchParam *DataStoreSearchParam, extraData []string)
	SuggestedCourseSearchObjectHandler        func(err error, client *nex.Client, callID uint32, param *DataStoreSearchParam, extraData []string)
	UploadCourseRecordHandler                 func(err error, client *nex.Client, callID uint32, param *DataStoreUploadCourseRecordParam)
	GetCourseRecordHandler                    func(err error, client *nex.Client, callID uint32, param *DataStoreGetCourseRecordParam)
	GetApplicationConfigStringHandler         func(err error, client *nex.Client, callID uint32, applicationID uint32)
	GetDeletionReasonHandler                  func(err error, client *nex.Client, callID uint32, dataIdLst []uint64)
	GetMetasWithCourseRecordHandler           func(err error, client *nex.Client, callID uint32, dataStoreGetCourseRecordParams []*DataStoreGetCourseRecordParam, dataStoreGetMetaParam *DataStoreGetMetaParam)
	CheckRateCustomRankingCounterHandler      func(err error, client *nex.Client, callID uint32, applicationID uint32)
	CTRPickUpCourseSearchObjectHandler        func(err error, client *nex.Client, callID uint32, dataStoreSearchParam *DataStoreSearchParam, extraData []string)
	// contains filtered or unexported fields
}

DataStoreSMMProtocol handles the DataStore (SMM) nex protocol. Embeds DataStoreProtocol

func NewDataStoreSMMProtocol 

func NewDataStoreSMMProtocol(server *nex.Server) *DataStoreSMMProtocol

NewDataStoreSMMProtocol returns a new DataStoreSMMProtocol

func (*DataStoreSMMProtocol) AddToBufferQueues 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) AddToBufferQueues(handler func(err error, client *nex.Client, callID uint32, params []*BufferQueueParam, buffers [][]byte))

AddToBufferQueues sets the AddToBufferQueues handler function

func (*DataStoreSMMProtocol) CTRPickUpCourseSearchObject 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) CTRPickUpCourseSearchObject(handler func(err error, client *nex.Client, callID uint32, dataStoreSearchParam *DataStoreSearchParam, extraData []string))

CTRPickUpCourseSearchObject sets the CTRPickUpCourseSearchObject handler function

func (*DataStoreSMMProtocol) CheckRateCustomRankingCounter 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) CheckRateCustomRankingCounter(handler func(err error, client *nex.Client, callID uint32, applicationID uint32))

CheckRateCustomRankingCounter sets the CheckRateCustomRankingCounter handler function

func (*DataStoreSMMProtocol) CompleteAttachFile 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) CompleteAttachFile(handler func(err error, client *nex.Client, callID uint32, dataStoreCompletePostParam *DataStoreCompletePostParam))

CompleteAttachFile sets the CompleteAttachFile handler function

func (*DataStoreSMMProtocol) FollowingsLatestCourseSearchObject 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) FollowingsLatestCourseSearchObject(handler func(err error, client *nex.Client, callID uint32, dataStoreSearchParam *DataStoreSearchParam, extraData []string))

FollowingsLatestCourseSearchObject sets the FollowingsLatestCourseSearchObject handler function

func (*DataStoreSMMProtocol) GetApplicationConfig 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) GetApplicationConfig(handler func(err error, client *nex.Client, callID uint32, applicationID uint32))

GetApplicationConfig sets the GetApplicationConfig handler function

func (*DataStoreSMMProtocol) GetApplicationConfigString 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) GetApplicationConfigString(handler func(err error, client *nex.Client, callID uint32, applicationID uint32))

GetApplicationConfigString sets the GetApplicationConfigString handler function

func (*DataStoreSMMProtocol) GetBufferQueue 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) GetBufferQueue(handler func(err error, client *nex.Client, callID uint32, bufferQueueParam *BufferQueueParam))

GetBufferQueue sets the GetBufferQueue handler function

func (*DataStoreSMMProtocol) GetCourseRecord 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) GetCourseRecord(handler func(err error, client *nex.Client, callID uint32, param *DataStoreGetCourseRecordParam))

GetCourseRecord sets the GetCourseRecord handler function

func (*DataStoreSMMProtocol) GetCustomRankingByDataId 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) GetCustomRankingByDataId(handler func(err error, client *nex.Client, callID uint32, dataStoreGetCustomRankingByDataIdParam *DataStoreGetCustomRankingByDataIdParam))

GetCustomRankingByDataId sets the GetCustomRankingByDataId handler function

func (*DataStoreSMMProtocol) GetDeletionReason 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) GetDeletionReason(handler func(err error, client *nex.Client, callID uint32, dataIdLst []uint64))

GetDeletionReason sets the GetDeletionReason handler function

func (*DataStoreSMMProtocol) GetMetasWithCourseRecord 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) GetMetasWithCourseRecord(handler func(err error, client *nex.Client, callID uint32, dataStoreGetCourseRecordParams []*DataStoreGetCourseRecordParam, dataStoreGetMetaParam *DataStoreGetMetaParam))

GetMetasWithCourseRecord sets the GetMetasWithCourseRecord handler function

func (*DataStoreSMMProtocol) GetObjectInfos 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) GetObjectInfos(handler func(err error, client *nex.Client, callID uint32, dataIDs []uint64))

GetObjectInfos sets the GetObjectInfos handler function

func (*DataStoreSMMProtocol) PrepareAttachFile 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) PrepareAttachFile(handler func(err error, client *nex.Client, callID uint32, dataStoreAttachFileParam *DataStoreAttachFileParam))

PrepareAttachFile sets the PrepareAttachFile handler function

func (*DataStoreSMMProtocol) RateCustomRanking 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) RateCustomRanking(handler func(err error, client *nex.Client, callID uint32, dataStoreRateCustomRankingParams []*DataStoreRateCustomRankingParam))

RateCustomRanking sets the RateCustomRanking handler function

func (*DataStoreSMMProtocol) RecommendedCourseSearchObject 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) RecommendedCourseSearchObject(handler func(err error, client *nex.Client, callID uint32, dataStoreSearchParam *DataStoreSearchParam, extraData []string))

RecommendedCourseSearchObject sets the RecommendedCourseSearchObject handler function

func (*DataStoreSMMProtocol) Setup 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) Setup()

Setup initializes the protocol

func (*DataStoreSMMProtocol) SuggestedCourseSearchObject 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) SuggestedCourseSearchObject(handler func(err error, client *nex.Client, callID uint32, param *DataStoreSearchParam, extraData []string))

SuggestedCourseSearchObject sets the SuggestedCourseSearchObject handler function

func (*DataStoreSMMProtocol) UploadCourseRecord 

func (dataStoreSMMProtocol *DataStoreSMMProtocol) UploadCourseRecord(handler func(err error, client *nex.Client, callID uint32, param *DataStoreUploadCourseRecordParam))

UploadCourseRecord sets the UploadCourseRecord handler function

type DataStoreSearchParam 

type DataStoreSearchParam struct {
	SearchTarget           uint8
	OwnerIds               []uint32
	OwnerType              uint8
	DestinationIds         []uint64
	DataType               uint16
	CreatedAfter           *nex.DateTime
	CreatedBefore          *nex.DateTime
	UpdatedAfter           *nex.DateTime
	UpdatedBefore          *nex.DateTime
	ReferDataId            uint32
	Tags                   []string
	ResultOrderColumn      uint8
	ResultOrder            uint8
	ResultRange            *nex.ResultRange
	ResultOption           uint8
	MinimalRatingFrequency uint32
	UseCache               bool
	nex.Structure
}

DataStoreSearchParam is sent in DataStore search methods

func NewDataStoreSearchParam 

func NewDataStoreSearchParam() *DataStoreSearchParam

NewDataStoreSearchParam returns a new DataStoreSearchParam

func (*DataStoreSearchParam) ExtractFromStream 

func (dataStoreSearchParam *DataStoreSearchParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreSearchParam structure from a stream

type DataStoreSearchReplayParam 

type DataStoreSearchReplayParam struct {
	nex.Structure

	Mode        uint8
	Style       uint8
	Fighter     uint8
	ResultRange *nex.ResultRange
}

func NewDataStoreSearchReplayParam 

func NewDataStoreSearchReplayParam() *DataStoreSearchReplayParam

NewDataStoreSearchReplayParam returns a new DataStoreSearchReplayParam

func (*DataStoreSearchReplayParam) Bytes 

func (dataStoreSearchReplayParam *DataStoreSearchReplayParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreSearchReplayParam and returns a byte array

func (*DataStoreSearchReplayParam) ExtractFromStream 

func (dataStoreSearchReplayParam *DataStoreSearchReplayParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreSearchReplayParam structure from a stream

type DataStoreSearchResult 

type DataStoreSearchResult struct {
	nex.Structure

	TotalCount     uint32
	Result         []*DataStoreMetaInfo
	TotalCountType uint8
}

func NewDataStoreSearchResult 

func NewDataStoreSearchResult() *DataStoreSearchResult

NewDataStoreSearchResult returns a new DataStoreSearchResult

func (*DataStoreSearchResult) Bytes 

func (dataStoreSearchResult *DataStoreSearchResult) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreSearchResult and returns a byte array

func (*DataStoreSearchResult) ExtractFromStream 

func (dataStoreSearchResult *DataStoreSearchResult) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreSearchResult structure from a stream

type DataStoreSearchSharedDataParam 

type DataStoreSearchSharedDataParam struct {
	nex.Structure

	DataType    uint8
	Owner       uint32
	Region      uint8
	Attribute1  uint8
	Attribute2  uint8
	Fighter     uint8
	ResultRange *nex.ResultRange
}

func NewDataStoreSearchSharedDataParam 

func NewDataStoreSearchSharedDataParam() *DataStoreSearchSharedDataParam

NewDataStoreSearchSharedDataParam returns a new DataStoreSearchSharedDataParam

func (*DataStoreSearchSharedDataParam) Bytes 

func (dataStoreSearchSharedDataParam *DataStoreSearchSharedDataParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreSearchSharedDataParam and returns a byte array

func (*DataStoreSearchSharedDataParam) ExtractFromStream 

func (dataStoreSearchSharedDataParam *DataStoreSearchSharedDataParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreSearchSharedDataParam structure from a stream

type DataStoreSharedDataInfo 

type DataStoreSharedDataInfo struct {
	nex.Structure

	DataID      uint64
	OwnerID     uint32
	DataType    uint8
	Comment     string
	MetaBinary  []byte
	Profile     []byte
	Rating      int64
	CreatedTime *nex.DateTime
	Info        *DataStoreFileServerObjectInfo
}

func NewDataStoreSharedDataInfo 

func NewDataStoreSharedDataInfo() *DataStoreSharedDataInfo

NewDataStoreSharedDataInfo returns a new DataStoreSharedDataInfo

func (*DataStoreSharedDataInfo) Bytes 

func (dataStoreSharedDataInfo *DataStoreSharedDataInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreSharedDataInfo and returns a byte array

func (*DataStoreSharedDataInfo) ExtractFromStream 

func (dataStoreSharedDataInfo *DataStoreSharedDataInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreSharedDataInfo structure from a stream

type DataStoreSmash4Protocol 

type DataStoreSmash4Protocol struct {
	DataStoreProtocol

	PostProfileHandler              func(err error, client *nex.Client, callID uint32, param *DataStorePostProfileParam)
	GetProfilesHandler              func(err error, client *nex.Client, callID uint32, pidList []uint32)
	SendPlayReportHandler           func(err error, client *nex.Client, callID uint32, playReport []int32)
	GetWorldPlayReportHandler       func(err error, client *nex.Client, callID uint32)
	GetReplayMetaHandler            func(err error, client *nex.Client, callID uint32, param *DataStoreGetReplayMetaParam)
	PrepareGetReplayHandler         func(err error, client *nex.Client, callID uint32, param *DataStorePrepareGetReplayParam)
	PreparePostReplayHandler        func(err error, client *nex.Client, callID uint32, param *DataStorePreparePostReplayParam)
	CompletePostReplayHandler       func(err error, client *nex.Client, callID uint32, param *DataStoreCompletePostReplayParam)
	CheckPostReplayHandler          func(err error, client *nex.Client, callID uint32, param *DataStorePreparePostReplayParam)
	GetNextReplayHandler            func(err error, client *nex.Client, callID uint32)
	PreparePostSharedDataHandler    func(err error, client *nex.Client, callID uint32, param *DataStorePreparePostSharedDataParam)
	CompletePostSharedDataHandler   func(err error, client *nex.Client, callID uint32, param *DataStoreCompletePostSharedDataParam)
	SearchSharedDataHandler         func(err error, client *nex.Client, callID uint32, param *DataStoreSearchSharedDataParam)
	GetApplicationConfigHandler     func(err error, client *nex.Client, callID uint32, applicationID uint32)
	SearchReplayHandler             func(err error, client *nex.Client, callID uint32, param *DataStoreSearchReplayParam)
	PostFightingPowerScoreHandler   func(err error, client *nex.Client, callID uint32, params []*DataStorePostFightingPowerScoreParam)
	GetFightingPowerChartHandler    func(err error, client *nex.Client, callID uint32, mode uint8)
	GetFightingPowerChartAllHandler func(err error, client *nex.Client, callID uint32)
	ReportSharedDataHandler         func(err error, client *nex.Client, callID uint32, dataID uint64)
	// contains filtered or unexported fields
}

DataStoreSmash4Protocol handles the DataStore (Smash4) nex protocol. Embeds DataStoreProtocol

func NewDataStoreSmash4Protocol 

func NewDataStoreSmash4Protocol(server *nex.Server) *DataStoreSmash4Protocol

NewDataStoreSmash4Protocol returns a new DataStoreSmash4Protocol

func (*DataStoreSmash4Protocol) CheckPostReplay 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) CheckPostReplay(handler func(err error, client *nex.Client, callID uint32, param *DataStorePreparePostReplayParam))

CheckPostReplay sets the CheckPostReplay handler function

func (*DataStoreSmash4Protocol) CompletePostReplay 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) CompletePostReplay(handler func(err error, client *nex.Client, callID uint32, param *DataStoreCompletePostReplayParam))

CompletePostReplay sets the CompletePostReplay handler function

func (*DataStoreSmash4Protocol) CompletePostSharedData 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) CompletePostSharedData(handler func(err error, client *nex.Client, callID uint32, param *DataStoreCompletePostSharedDataParam))

CompletePostSharedData sets the CompletePostSharedData handler function

func (*DataStoreSmash4Protocol) GetApplicationConfig 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) GetApplicationConfig(handler func(err error, client *nex.Client, callID uint32, applicationID uint32))

GetApplicationConfig sets the GetApplicationConfig handler function

func (*DataStoreSmash4Protocol) GetFightingPowerChart 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) GetFightingPowerChart(handler func(err error, client *nex.Client, callID uint32, mode uint8))

GetFightingPowerChart sets the GetFightingPowerChart handler function

func (*DataStoreSmash4Protocol) GetFightingPowerChartAll 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) GetFightingPowerChartAll(handler func(err error, client *nex.Client, callID uint32))

GetFightingPowerChartAll sets the GetFightingPowerChartAll handler function

func (*DataStoreSmash4Protocol) GetNextReplay 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) GetNextReplay(handler func(err error, client *nex.Client, callID uint32))

GetNextReplay sets the GetNextReplay handler function

func (*DataStoreSmash4Protocol) GetProfiles 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) GetProfiles(handler func(err error, client *nex.Client, callID uint32, pidList []uint32))

GetProfiles sets the GetProfiles handler function

func (*DataStoreSmash4Protocol) GetReplayMeta 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) GetReplayMeta(handler func(err error, client *nex.Client, callID uint32, param *DataStoreGetReplayMetaParam))

GetReplayMeta sets the GetReplayMeta handler function

func (*DataStoreSmash4Protocol) GetWorldPlayReport 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) GetWorldPlayReport(handler func(err error, client *nex.Client, callID uint32))

GetWorldPlayReport sets the GetWorldPlayReport handler function

func (*DataStoreSmash4Protocol) PostFightingPowerScore 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) PostFightingPowerScore(handler func(err error, client *nex.Client, callID uint32, params []*DataStorePostFightingPowerScoreParam))

PostFightingPowerScore sets the PostFightingPowerScore handler function

func (*DataStoreSmash4Protocol) PostProfile 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) PostProfile(handler func(err error, client *nex.Client, callID uint32, param *DataStorePostProfileParam))

PostProfile sets the PostProfile handler function

func (*DataStoreSmash4Protocol) PrepareGetReplay 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) PrepareGetReplay(handler func(err error, client *nex.Client, callID uint32, param *DataStorePrepareGetReplayParam))

PrepareGetReplay sets the PrepareGetReplay handler function

func (*DataStoreSmash4Protocol) PreparePostReplay 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) PreparePostReplay(handler func(err error, client *nex.Client, callID uint32, param *DataStorePreparePostReplayParam))

PreparePostReplay sets the PreparePostReplay handler function

func (*DataStoreSmash4Protocol) PreparePostSharedData 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) PreparePostSharedData(handler func(err error, client *nex.Client, callID uint32, param *DataStorePreparePostSharedDataParam))

PreparePostSharedData sets the PreparePostSharedData handler function

func (*DataStoreSmash4Protocol) ReportSharedData 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) ReportSharedData(handler func(err error, client *nex.Client, callID uint32, dataID uint64))

ReportSharedData sets the ReportSharedData handler function

func (*DataStoreSmash4Protocol) SearchReplay 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) SearchReplay(handler func(err error, client *nex.Client, callID uint32, param *DataStoreSearchReplayParam))

SearchReplay sets the SearchReplay handler function

func (*DataStoreSmash4Protocol) SearchSharedData 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) SearchSharedData(handler func(err error, client *nex.Client, callID uint32, param *DataStoreSearchSharedDataParam))

SearchSharedData sets the SearchSharedData handler function

func (*DataStoreSmash4Protocol) SendPlayReport 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) SendPlayReport(handler func(err error, client *nex.Client, callID uint32, playReport []int32))

SendPlayReport sets the SendPlayReport handler function

func (*DataStoreSmash4Protocol) Setup 

func (dataStoreSmash4Protocol *DataStoreSmash4Protocol) Setup()

Setup initializes the protocol

type DataStoreSpecificMetaInfo 

type DataStoreSpecificMetaInfo struct {
	nex.Structure

	DataID   uint64
	OwnerID  uint32
	Size     uint32
	DataType uint16
	Version  uint32
}

func NewDataStoreSpecificMetaInfo 

func NewDataStoreSpecificMetaInfo() *DataStoreSpecificMetaInfo

NewDataStoreSpecificMetaInfo returns a new DataStoreSpecificMetaInfo

func (*DataStoreSpecificMetaInfo) Bytes 

func (dataStoreSpecificMetaInfo *DataStoreSpecificMetaInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreSpecificMetaInfo and returns a byte array

func (*DataStoreSpecificMetaInfo) ExtractFromStream 

func (dataStoreSpecificMetaInfo *DataStoreSpecificMetaInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreSpecificMetaInfo structure from a stream

type DataStoreSpecificMetaInfoV1 

type DataStoreSpecificMetaInfoV1 struct {
	nex.Structure

	DataID   uint32
	OwnerID  uint32
	Size     uint32
	DataType uint16
	Version  uint16
}

func NewDataStoreSpecificMetaInfoV1 

func NewDataStoreSpecificMetaInfoV1() *DataStoreSpecificMetaInfoV1

NewDataStoreSpecificMetaInfoV1 returns a new DataStoreSpecificMetaInfoV1

func (*DataStoreSpecificMetaInfoV1) Bytes 

func (dataStoreSpecificMetaInfoV1 *DataStoreSpecificMetaInfoV1) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreSpecificMetaInfoV1 and returns a byte array

func (*DataStoreSpecificMetaInfoV1) ExtractFromStream 

func (dataStoreSpecificMetaInfoV1 *DataStoreSpecificMetaInfoV1) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreSpecificMetaInfoV1 structure from a stream

type DataStoreTouchObjectParam 

type DataStoreTouchObjectParam struct {
	nex.Structure

	DataID         uint64
	LockID         uint32
	AccessPassword uint64
}

func NewDataStoreTouchObjectParam 

func NewDataStoreTouchObjectParam() *DataStoreTouchObjectParam

NewDataStoreTouchObjectParam returns a new DataStoreTouchObjectParam

func (*DataStoreTouchObjectParam) Bytes 

func (dataStoreTouchObjectParam *DataStoreTouchObjectParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the DataStoreTouchObjectParam and returns a byte array

func (*DataStoreTouchObjectParam) ExtractFromStream 

func (dataStoreTouchObjectParam *DataStoreTouchObjectParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreTouchObjectParam structure from a stream

type DataStoreUploadCourseRecordParam 

type DataStoreUploadCourseRecordParam struct {
	nex.Structure
	DataID uint64
	Slot   uint8
	Score  int32
}

func NewDataStoreUploadCourseRecordParam 

func NewDataStoreUploadCourseRecordParam() *DataStoreUploadCourseRecordParam

NewDataStoreUploadCourseRecordParam returns a new DataStoreUploadCourseRecordParam

func (*DataStoreUploadCourseRecordParam) ExtractFromStream 

func (dataStoreUploadCourseRecordParam *DataStoreUploadCourseRecordParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a DataStoreUploadCourseRecordParam structure from a stream

type DebugProtocol 

type DebugProtocol struct {
	EnableApiRecorderHandler                func(err error, client *nex.Client, callID uint32)
	DisableApiRecorderHandler               func(err error, client *nex.Client, callID uint32)
	IsApiRecorderEnabledHandler             func(err error, client *nex.Client, callID uint32)
	GetApiCallsHandler                      func(err error, client *nex.Client, callID uint32, pids []uint32, dateUnk1 uint64, dateUnk2 uint64)
	SetExcludeJoinedMatchmakeSessionHandler func(err error, client *nex.Client, callID uint32)
	GetExcludeJoinedMatchmakeSessionHandler func(err error, client *nex.Client, callID uint32)
	GetApiCallSummaryHandler                func(err error, client *nex.Client, callID uint32)
	// contains filtered or unexported fields
}

DebugProtocol handles the Debug protocol

func NewDebugProtocol 

func NewDebugProtocol(server *nex.Server) *DebugProtocol

NewDebugProtocol returns a new DebugProtocol

func (*DebugProtocol) DisableApiRecorder 

func (debugProtocol *DebugProtocol) DisableApiRecorder(handler func(err error, client *nex.Client, callID uint32))

DisableApiRecorder sets the DisableApiRecorder handler function

func (*DebugProtocol) EnableApiRecorder 

func (debugProtocol *DebugProtocol) EnableApiRecorder(handler func(err error, client *nex.Client, callID uint32))

EnableApiRecorder sets the EnableApiRecorder handler function

func (*DebugProtocol) GetApiCallSummary 

func (debugProtocol *DebugProtocol) GetApiCallSummary(handler func(err error, client *nex.Client, callID uint32))

GetApiCallSummary sets the GetApiCallSummary handler function

func (*DebugProtocol) GetApiCalls 

func (debugProtocol *DebugProtocol) GetApiCalls(handler func(err error, client *nex.Client, callID uint32, pids []uint32, dateUnk1 uint64, dateUnk2 uint64))

GetApiCalls sets the GetApiCalls handler function

func (*DebugProtocol) GetExcludeJoinedMatchmakeSession 

func (debugProtocol *DebugProtocol) GetExcludeJoinedMatchmakeSession(handler func(err error, client *nex.Client, callID uint32))

GetExcludeJoinedMatchmakeSession sets the GetExcludeJoinedMatchmakeSession handler function

func (*DebugProtocol) IsApiRecorderEnabled 

func (debugProtocol *DebugProtocol) IsApiRecorderEnabled(handler func(err error, client *nex.Client, callID uint32))

IsApiRecorderEnabled sets the IsApiRecorderEnabled handler function

func (*DebugProtocol) SetExcludeJoinedMatchmakeSession 

func (debugProtocol *DebugProtocol) SetExcludeJoinedMatchmakeSession(handler func(err error, client *nex.Client, callID uint32))

SetExcludeJoinedMatchmakeSession sets the SetExcludeJoinedMatchmakeSession handler function

func (*DebugProtocol) Setup 

func (debugProtocol *DebugProtocol) Setup()

Setup initializes the protocol

type FriendInfo 

type FriendInfo struct {
	NNAInfo      *NNAInfo
	Presence     *NintendoPresenceV2
	Status       *Comment
	BecameFriend *nex.DateTime
	LastOnline   *nex.DateTime
	Unknown      uint64

	nex.Structure
}

FriendInfo contains information about a friend

func NewFriendInfo 

func NewFriendInfo() *FriendInfo

NewFriendInfo returns a new FriendInfo

func (*FriendInfo) Bytes 

func (friendInfo *FriendInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the FriendInfo and returns a byte array

type FriendPersistentInfo 

type FriendPersistentInfo struct {
	PrincipalID  uint32
	Region       uint8
	Country      uint8
	Area         uint8
	Language     uint8
	Platform     uint8
	GameKey      *GameKey
	Message      string
	MsgUpdatedAt *nex.DateTime //appears to be correct, but not 100% sure.
	FriendedAt   *nex.DateTime
	DateTime3    *nex.DateTime

	nex.Structure
}

FriendPersistentInfo contains user settings

func NewFriendPersistentInfo 

func NewFriendPersistentInfo() *FriendPersistentInfo

NewFriendPersistentInfo returns a new FriendPersistentInfo

func (*FriendPersistentInfo) Bytes 

func (friendPersistentInfo *FriendPersistentInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the FriendPersistentInfo and returns a byte array

type FriendRelationship 

type FriendRelationship struct {
	PrincipalID  uint32
	Unknown1     uint64
	RelationType uint8 // guess

	nex.Structure
}

FriendRelationship contains information about a users relationship with another PID

func NewFriendRelationship 

func NewFriendRelationship() *FriendRelationship

NewFriendRelationship returns a new FriendRelationship

func (*FriendRelationship) Bytes 

func (relationship *FriendRelationship) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the FriendRelationship and returns a byte array

type FriendRequest 

type FriendRequest struct {
	PrincipalInfo *PrincipalBasicInfo
	Message       *FriendRequestMessage
	SentOn        *nex.DateTime

	nex.Structure
}

FriendRequest contains information about a friend request

func NewFriendRequest 

func NewFriendRequest() *FriendRequest

NewFriendRequest returns a new FriendRequest

func (*FriendRequest) Bytes 

func (friendRequest *FriendRequest) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the FriendRequest and returns a byte array

type FriendRequestMessage 

type FriendRequestMessage struct {
	FriendRequestID uint64
	Received        bool
	Unknown2        uint8
	Message         string
	Unknown3        uint8
	Unknown4        string
	GameKey         *GameKey
	Unknown5        *nex.DateTime
	ExpiresOn       *nex.DateTime

	nex.Structure
}

FriendRequestMessage contains message data for a FriendRequest

func NewFriendRequestMessage 

func NewFriendRequestMessage() *FriendRequestMessage

NewFriendRequestMessage returns a new FriendRequestMessage

func (*FriendRequestMessage) Bytes 

func (friendRequestMessage *FriendRequestMessage) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the FriendRequestMessage and returns a byte array

type Friends3DSProtocol 

type Friends3DSProtocol struct {
	UpdateProfileHandler           func(err error, client *nex.Client, callID uint32, profileData *MyProfile)
	UpdateMiiHandler               func(err error, client *nex.Client, callID uint32, mii *Mii)
	UpdatePreferenceHandler        func(err error, client *nex.Client, callID uint32, unknown1 bool, unknown2 bool, unknown3 bool)
	UpdatePresenceHandler          func(err error, client *nex.Client, callID uint32, presence *NintendoPresence, unknown bool)
	UpdateFavoriteGameKeyHandler   func(err error, client *nex.Client, callID uint32, gameKey *GameKey)
	UpdateCommentHandler           func(err error, client *nex.Client, callID uint32, comment string)
	SyncFriendHandler              func(err error, client *nex.Client, callID uint32, unknown1 uint64, unknown2 []uint32, unknown3 []uint64)
	AddFriendByPrincipalIDHandler  func(err error, client *nex.Client, callID uint32, unknown1 uint64, principalID uint32)
	GetFriendPersistentInfoHandler func(err error, client *nex.Client, callID uint32, pidList []uint32)
	GetFriendMiiHandler            func(err error, client *nex.Client, callID uint32, pidList []uint32)
	GetFriendPresenceHandler       func(err error, client *nex.Client, callID uint32, pidList []uint32)
	// contains filtered or unexported fields
}

Friends3DSProtocol handles the Friends (3DS) nex protocol

func NewFriends3DSProtocol 

func NewFriends3DSProtocol(server *nex.Server) *Friends3DSProtocol

NewFriends3DSProtocol returns a new Friends3DSProtocol

func (*Friends3DSProtocol) AddFriendByPrincipalID 

func (friends3DSProtocol *Friends3DSProtocol) AddFriendByPrincipalID(handler func(err error, client *nex.Client, callID uint32, unknown1 uint64, principalID uint32))

AddFriendByPrincipalID sets the AddFriendByPrincipalID handler function

func (*Friends3DSProtocol) GetFriendMii 

func (friends3DSProtocol *Friends3DSProtocol) GetFriendMii(handler func(err error, client *nex.Client, callID uint32, pidList []uint32))

GetFriendMii sets the GetFriendMii handler function

func (*Friends3DSProtocol) GetFriendPersistentInfo 

func (friends3DSProtocol *Friends3DSProtocol) GetFriendPersistentInfo(handler func(err error, client *nex.Client, callID uint32, pidList []uint32))

GetFriendPersistentInfo sets the GetFriendPersistentInfo handler function

func (*Friends3DSProtocol) GetFriendPresence 

func (friends3DSProtocol *Friends3DSProtocol) GetFriendPresence(handler func(err error, client *nex.Client, callID uint32, pidList []uint32))

GetFriendPresence sets the GetFriendPresence handler function

func (*Friends3DSProtocol) Setup 

func (friends3DSProtocol *Friends3DSProtocol) Setup()

Setup initializes the protocol

func (*Friends3DSProtocol) SyncFriend 

func (friends3DSProtocol *Friends3DSProtocol) SyncFriend(handler func(err error, client *nex.Client, callID uint32, unknown1 uint64, pids []uint32, unknown3 []uint64))

SyncFriend sets the SyncFriend handler function

func (*Friends3DSProtocol) UpdateComment 

func (friends3DSProtocol *Friends3DSProtocol) UpdateComment(handler func(err error, client *nex.Client, callID uint32, comment string))

UpdateComment sets the UpdateComment handler function

func (*Friends3DSProtocol) UpdateFavoriteGameKey 

func (friends3DSProtocol *Friends3DSProtocol) UpdateFavoriteGameKey(handler func(err error, client *nex.Client, callID uint32, gameKey *GameKey))

UpdateFavoriteGameKey sets the UpdateFavoriteGameKey handler function

func (*Friends3DSProtocol) UpdateMii 

func (friends3DSProtocol *Friends3DSProtocol) UpdateMii(handler func(err error, client *nex.Client, callID uint32, mii *Mii))

UpdateMii sets the UpdateMii handler function

func (*Friends3DSProtocol) UpdatePreference 

func (friends3DSProtocol *Friends3DSProtocol) UpdatePreference(handler func(err error, client *nex.Client, callID uint32, unknown1 bool, unknown2 bool, unknown3 bool))

UpdatePreference sets the UpdatePreference handler function

func (*Friends3DSProtocol) UpdatePresence 

func (friends3DSProtocol *Friends3DSProtocol) UpdatePresence(handler func(err error, client *nex.Client, callID uint32, presence *NintendoPresence, unknown bool))

UpdatePresence sets the UpdatePresence handler function

func (*Friends3DSProtocol) UpdateProfile 

func (friends3DSProtocol *Friends3DSProtocol) UpdateProfile(handler func(err error, client *nex.Client, callID uint32, profileData *MyProfile))

UpdateProfile sets the UpdateProfile handler function

type FriendsWiiUProtocol 

type FriendsWiiUProtocol struct {
	UpdateAndGetAllInformationHandler   func(err error, client *nex.Client, callID uint32, nnaInfo *NNAInfo, presence *NintendoPresenceV2, birthday *nex.DateTime)
	AddFriendHandler                    func(err error, client *nex.Client, callID uint32, pid uint32)
	AddFriendByNameHandler              func(err error, client *nex.Client, callID uint32, username string)
	RemoveFriendHandler                 func(err error, client *nex.Client, callID uint32, pid uint32)
	AddFriendRequestHandler             func(err error, client *nex.Client, callID uint32, pid uint32, unknown2 uint8, message string, unknown4 uint8, unknown5 string, gameKey *GameKey, unknown6 *nex.DateTime)
	CancelFriendRequestHandler          func(err error, client *nex.Client, callID uint32, id uint64)
	AcceptFriendRequestHandler          func(err error, client *nex.Client, callID uint32, id uint64)
	DeleteFriendRequestHandler          func(err error, client *nex.Client, callID uint32, id uint64)
	DenyFriendRequestHandler            func(err error, client *nex.Client, callID uint32, id uint64)
	MarkFriendRequestsAsReceivedHandler func(err error, client *nex.Client, callID uint32, ids []uint64)
	AddBlackListHandler                 func(err error, client *nex.Client, callID uint32, blacklistedPrincipal *BlacklistedPrincipal)
	RemoveBlackListHandler              func(err error, client *nex.Client, callID uint32, pid uint32)
	UpdatePresenceHandler               func(err error, client *nex.Client, callID uint32, presence *NintendoPresenceV2)
	UpdateMiiHandler                    func(err error, client *nex.Client, callID uint32, mii *MiiV2)
	UpdateCommentHandler                func(err error, client *nex.Client, callID uint32, comment *Comment)
	UpdatePreferenceHandler             func(err error, client *nex.Client, callID uint32, preference *PrincipalPreference)
	GetBasicInfoHandler                 func(err error, client *nex.Client, callID uint32, pids []uint32)
	DeletePersistentNotificationHandler func(err error, client *nex.Client, callID uint32, notifications []*PersistentNotification)
	CheckSettingStatusHandler           func(err error, client *nex.Client, callID uint32)
	GetRequestBlockSettingsHandler      func(err error, client *nex.Client, callID uint32, pids []uint32)
	// contains filtered or unexported fields
}

FriendsWiiUProtocol handles the Friends (WiiU) nex protocol

func NewFriendsWiiUProtocol 

func NewFriendsWiiUProtocol(server *nex.Server) *FriendsWiiUProtocol

NewFriendsWiiUProtocol returns a new FriendsWiiUProtocol

func (*FriendsWiiUProtocol) AcceptFriendRequest 

func (friendsWiiUProtocol *FriendsWiiUProtocol) AcceptFriendRequest(handler func(err error, client *nex.Client, callID uint32, id uint64))

AcceptFriendRequest sets the AcceptFriendRequest handler function

func (*FriendsWiiUProtocol) AddBlackList 

func (friendsWiiUProtocol *FriendsWiiUProtocol) AddBlackList(handler func(err error, client *nex.Client, callID uint32, blacklistedPrincipal *BlacklistedPrincipal))

AddBlackList sets the AddBlackList handler function

func (*FriendsWiiUProtocol) AddFriend 

func (friendsWiiUProtocol *FriendsWiiUProtocol) AddFriend(handler func(err error, client *nex.Client, callID uint32, pid uint32))

AddFriend sets the AddFriend handler function

func (*FriendsWiiUProtocol) AddFriendByName 

func (friendsWiiUProtocol *FriendsWiiUProtocol) AddFriendByName(handler func(err error, client *nex.Client, callID uint32, username string))

AddFriendByName sets the AddFriendByName handler function

func (*FriendsWiiUProtocol) AddFriendRequest 

func (friendsWiiUProtocol *FriendsWiiUProtocol) AddFriendRequest(handler func(err error, client *nex.Client, callID uint32, pid uint32, unknown2 uint8, message string, unknown4 uint8, unknown5 string, gameKey *GameKey, unknown6 *nex.DateTime))

AddFriendRequest sets the AddFriendRequest handler function

func (*FriendsWiiUProtocol) CancelFriendRequest 

func (friendsWiiUProtocol *FriendsWiiUProtocol) CancelFriendRequest(handler func(err error, client *nex.Client, callID uint32, id uint64))

CancelFriendRequest sets the CancelFriendRequest handler function

func (*FriendsWiiUProtocol) CheckSettingStatus 

func (friendsWiiUProtocol *FriendsWiiUProtocol) CheckSettingStatus(handler func(err error, client *nex.Client, callID uint32))

CheckSettingStatus sets the CheckSettingStatus handler function

func (*FriendsWiiUProtocol) DeleteFriendRequest 

func (friendsWiiUProtocol *FriendsWiiUProtocol) DeleteFriendRequest(handler func(err error, client *nex.Client, callID uint32, id uint64))

DeleteFriendRequest sets the DeleteFriendRequest handler function

func (*FriendsWiiUProtocol) DeletePersistentNotification 

func (friendsWiiUProtocol *FriendsWiiUProtocol) DeletePersistentNotification(handler func(err error, client *nex.Client, callID uint32, notifications []*PersistentNotification))

DeletePersistentNotification sets the DeletePersistentNotification handler function

func (*FriendsWiiUProtocol) DenyFriendRequest 

func (friendsWiiUProtocol *FriendsWiiUProtocol) DenyFriendRequest(handler func(err error, client *nex.Client, callID uint32, id uint64))

DenyFriendRequest sets the DenyFriendRequest handler function

func (*FriendsWiiUProtocol) GetBasicInfo 

func (friendsWiiUProtocol *FriendsWiiUProtocol) GetBasicInfo(handler func(err error, client *nex.Client, callID uint32, pids []uint32))

GetBasicInfo sets the GetBasicInfo handler function

func (*FriendsWiiUProtocol) GetRequestBlockSettings 

func (friendsWiiUProtocol *FriendsWiiUProtocol) GetRequestBlockSettings(handler func(err error, client *nex.Client, callID uint32, unknowns []uint32))

GetRequestBlockSettings sets the GetRequestBlockSettings handler function

func (*FriendsWiiUProtocol) MarkFriendRequestsAsReceived 

func (friendsWiiUProtocol *FriendsWiiUProtocol) MarkFriendRequestsAsReceived(handler func(err error, client *nex.Client, callID uint32, ids []uint64))

MarkFriendRequestsAsReceived sets the MarkFriendRequestsAsReceived handler function

func (*FriendsWiiUProtocol) RemoveBlackList 

func (friendsWiiUProtocol *FriendsWiiUProtocol) RemoveBlackList(handler func(err error, client *nex.Client, callID uint32, pid uint32))

RemoveBlackList sets the RemoveBlackList handler function

func (*FriendsWiiUProtocol) RemoveFriend 

func (friendsWiiUProtocol *FriendsWiiUProtocol) RemoveFriend(handler func(err error, client *nex.Client, callID uint32, pid uint32))

RemoveFriend sets the RemoveFriend handler function

func (*FriendsWiiUProtocol) Setup 

func (friendsWiiUProtocol *FriendsWiiUProtocol) Setup()

Setup initializes the protocol

func (*FriendsWiiUProtocol) UpdateAndGetAllInformation 

func (friendsWiiUProtocol *FriendsWiiUProtocol) UpdateAndGetAllInformation(handler func(err error, client *nex.Client, callID uint32, nnaInfo *NNAInfo, presence *NintendoPresenceV2, birthday *nex.DateTime))

UpdateAndGetAllInformation sets the UpdateAndGetAllInformation handler function

func (*FriendsWiiUProtocol) UpdateComment 

func (friendsWiiUProtocol *FriendsWiiUProtocol) UpdateComment(handler func(err error, client *nex.Client, callID uint32, comment *Comment))

UpdateComment sets the UpdateComment handler function

func (*FriendsWiiUProtocol) UpdateMii 

func (friendsWiiUProtocol *FriendsWiiUProtocol) UpdateMii(handler func(err error, client *nex.Client, callID uint32, mii *MiiV2))

UpdateMii sets the UpdateMii handler function

func (*FriendsWiiUProtocol) UpdatePreference 

func (friendsWiiUProtocol *FriendsWiiUProtocol) UpdatePreference(handler func(err error, client *nex.Client, callID uint32, preference *PrincipalPreference))

UpdatePreference sets the UpdatePreference handler function

func (*FriendsWiiUProtocol) UpdatePresence 

func (friendsWiiUProtocol *FriendsWiiUProtocol) UpdatePresence(handler func(err error, client *nex.Client, callID uint32, presence *NintendoPresenceV2))

UpdatePresence sets the UpdatePresence handler function

type GameKey 

type GameKey struct {
	TitleID      uint64
	TitleVersion uint16

	nex.Structure
}

GameKey contains the title ID and version for a title

func NewGameKey 

func NewGameKey() *GameKey

NewGameKey returns a new GameKey

func (*GameKey) Bytes 

func (gameKey *GameKey) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the GameKey and returns a byte array

func (*GameKey) ExtractFromStream 

func (gameKey *GameKey) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a GameKey structure from a stream

type Gathering 

type Gathering struct {
	ID                  uint32
	OwnerPID            uint32
	HostPID             uint32
	MinimumParticipants uint16
	MaximumParticipants uint16
	ParticipationPolicy uint32
	PolicyArgument      uint32
	Flags               uint32
	State               uint32
	Description         string

	*nex.Structure
}

Gathering holds information about a matchmake gathering

func NewGathering 

func NewGathering() *Gathering

NewGathering returns a new Gathering

func (*Gathering) Bytes 

func (gathering *Gathering) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the Gathering and returns a byte array

func (*Gathering) ExtractFromStream 

func (gathering *Gathering) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a Gathering structure from a stream

type HealthProtocol 

type HealthProtocol struct {
	PingDaemonHandler      func(err error, client *nex.Client, callID uint32)
	PingDatabaseHandler    func(err error, client *nex.Client, callID uint32)
	RunSanityCheckHandler  func(err error, client *nex.Client, callID uint32)
	FixSanityErrorsHandler func(err error, client *nex.Client, callID uint32)
	// contains filtered or unexported fields
}

HealthProtocol handles the Health protocol

func NewHealthProtocol 

func NewHealthProtocol(server *nex.Server) *HealthProtocol

NewHealthProtocol returns a new HealthProtocol

func (*HealthProtocol) FixSanityErrors 

func (healthProtocol *HealthProtocol) FixSanityErrors(handler func(err error, client *nex.Client, callID uint32))

FixSanityErrors sets the FixSanityErrors handler function

func (*HealthProtocol) PingDaemon 

func (healthProtocol *HealthProtocol) PingDaemon(handler func(err error, client *nex.Client, callID uint32))

PingDaemon sets the PingDaemon handler function

func (*HealthProtocol) PingDatabase 

func (healthProtocol *HealthProtocol) PingDatabase(handler func(err error, client *nex.Client, callID uint32))

PingDatabase sets the PingDatabase handler function

func (*HealthProtocol) RunSanityCheck 

func (healthProtocol *HealthProtocol) RunSanityCheck(handler func(err error, client *nex.Client, callID uint32))

RunSanityCheck sets the RunSanityCheck handler function

func (*HealthProtocol) Setup 

func (healthProtocol *HealthProtocol) Setup()

Setup initializes the protocol

type MatchMakingExtProtocol 

type MatchMakingExtProtocol struct {
	EndParticipationHandler        func(err error, client *nex.Client, callID uint32, idGathering uint32, strMessage string)
	GetParticipantsHandler         func(err error, client *nex.Client, callID uint32, idGathering uint32, bOnlyActive bool)
	GetDetailedParticipantsHandler func(err error, client *nex.Client, callID uint32, idGathering uint32, bOnlyActive bool)
	GetParticipantsURLsHandler     func(err error, client *nex.Client, callID uint32, lstGatherings []uint32)
	GetGatheringRelationsHandler   func(err error, client *nex.Client, callID uint32, id uint32, descr string)
	DeleteFromDeletionsHandler     func(err error, client *nex.Client, callID uint32, lstDeletions []uint32, pid uint32)
	// contains filtered or unexported fields
}

MatchMakingExtProtocol handles the MatchMakingExt protocol

func NewMatchMakingExtProtocol 

func NewMatchMakingExtProtocol(server *nex.Server) *MatchMakingExtProtocol

NewMatchMakingExtProtocol returns a new MatchMakingExtProtocol

func (*MatchMakingExtProtocol) DeleteFromDeletions 

func (matchMakingExtProtocol *MatchMakingExtProtocol) DeleteFromDeletions(handler func(err error, client *nex.Client, callID uint32, lstDeletions []uint32, pid uint32))

DeleteFromDeletions sets the DeleteFromDeletions handler function

func (*MatchMakingExtProtocol) EndParticipation 

func (matchMakingExtProtocol *MatchMakingExtProtocol) EndParticipation(handler func(err error, client *nex.Client, callID uint32, idGathering uint32, strMessage string))

EndParticipation sets the EndParticipation handler function

func (*MatchMakingExtProtocol) GetDetailedParticipants 

func (matchMakingExtProtocol *MatchMakingExtProtocol) GetDetailedParticipants(handler func(err error, client *nex.Client, callID uint32, idGathering uint32, bOnlyActive bool))

GetDetailedParticipants sets the GetDetailedParticipants handler function

func (*MatchMakingExtProtocol) GetGatheringRelations 

func (matchMakingExtProtocol *MatchMakingExtProtocol) GetGatheringRelations(handler func(err error, client *nex.Client, callID uint32, id uint32, descr string))

GetGatheringRelations sets the GetGatheringRelations handler function

func (*MatchMakingExtProtocol) GetParticipants 

func (matchMakingExtProtocol *MatchMakingExtProtocol) GetParticipants(handler func(err error, client *nex.Client, callID uint32, idGathering uint32, bOnlyActive bool))

GetParticipants sets the GetParticipants handler function

func (*MatchMakingExtProtocol) GetParticipantsURLs 

func (matchMakingExtProtocol *MatchMakingExtProtocol) GetParticipantsURLs(handler func(err error, client *nex.Client, callID uint32, lstGatherings []uint32))

GetParticipantsURLs sets the GetParticipantsURLs handler function

func (*MatchMakingExtProtocol) Setup 

func (matchMakingExtProtocol *MatchMakingExtProtocol) Setup()

Setup initializes the protocol

type MatchMakingProtocol 

type MatchMakingProtocol struct {
	UnregisterGatheringHandler  func(err error, client *nex.Client, callID uint32, idGathering uint32)
	UnregisterGatheringsHandler func(err error, client *nex.Client, callID uint32, lstGatherings []uint32)
	FindBySingleIDHandler       func(err error, client *nex.Client, callID uint32, id uint32)
	UpdateSessionHostV1Handler  func(err error, client *nex.Client, callID uint32, gatheringId uint32)
	GetSessionURLsHandler       func(err error, client *nex.Client, callID uint32, gatheringId uint32)
	UpdateSessionHostHandler    func(err error, client *nex.Client, callID uint32, gatheringId uint32)
	// contains filtered or unexported fields
}

AuthenticationProtocol handles the Authentication nex protocol

func NewMatchMakingProtocol 

func NewMatchMakingProtocol(server *nex.Server) *MatchMakingProtocol

NewMatchMakingProtocol returns a new MatchMakingProtocol

func (*MatchMakingProtocol) FindBySingleID 

func (matchMakingProtocol *MatchMakingProtocol) FindBySingleID(handler func(err error, client *nex.Client, callID uint32, id uint32))

FindBySingleID sets the FindBySingleID handler function

func (*MatchMakingProtocol) GetSessionURLs 

func (matchMakingProtocol *MatchMakingProtocol) GetSessionURLs(handler func(err error, client *nex.Client, callID uint32, gatheringId uint32))

GetSessionURLs sets the GetSessionURLs handler function

func (*MatchMakingProtocol) Setup 

func (matchMakingProtocol *MatchMakingProtocol) Setup()

Setup initializes the protocol

func (*MatchMakingProtocol) UnregisterGathering 

func (matchMakingProtocol *MatchMakingProtocol) UnregisterGathering(handler func(err error, client *nex.Client, callID uint32, idGathering uint32))

UnregisterGathering sets the UnregisterGathering handler function

func (*MatchMakingProtocol) UnregisterGatherings 

func (matchMakingProtocol *MatchMakingProtocol) UnregisterGatherings(handler func(err error, client *nex.Client, callID uint32, lstGatherings []uint32))

UnregisterGatherings sets the UnregisterGatherings handler function

func (*MatchMakingProtocol) UpdateSessionHost 

func (matchMakingProtocol *MatchMakingProtocol) UpdateSessionHost(handler func(err error, client *nex.Client, callID uint32, gatheringId uint32))

GetSessionURLs sets the GetSessionURLs handler function

func (*MatchMakingProtocol) UpdateSessionHostV1 

func (matchMakingProtocol *MatchMakingProtocol) UpdateSessionHostV1(handler func(err error, client *nex.Client, callID uint32, gatheringId uint32))

GetSessionURLs sets the GetSessionURLs handler function

type MatchmakeExtensionProtocol 

type MatchmakeExtensionProtocol struct {
	OpenParticipationHandler                        func(err error, client *nex.Client, callID uint32, gid uint32)
	AutoMatchmake_PostponeHandler                   func(err error, client *nex.Client, callID uint32, matchmakeSession *MatchmakeSession, message string)
	CreateMatchmakeSessionHandler                   func(err error, client *nex.Client, callID uint32, matchmakeSession *MatchmakeSession, message string, participationCount uint16)
	UpdateNotificationDataHandler                   func(err error, client *nex.Client, callID uint32, uiType uint32, uiParam1 uint32, uiParam2 uint32, strParam string)
	GetFriendNotificationDataHandler                func(err error, client *nex.Client, callID uint32, uiType int32)
	AutoMatchmakeWithSearchCriteria_PostponeHandler func(err error, client *nex.Client, callID uint32, matchmakeSession *MatchmakeSession, message string)
	JoinMatchmakeSessionExHandler                   func(err error, client *nex.Client, callID uint32, gid uint32, strMessage string, dontCareMyBlockList bool, participationCount uint16)
	GetSimplePlayingSessionHandler                  func(err error, client *nex.Client, callID uint32, listPID []uint32, includeLoginUser bool)
	// contains filtered or unexported fields
}

MatchmakeExtensionProtocol handles the Matchmake Extension nex protocol

func NewMatchmakeExtensionProtocol 

func NewMatchmakeExtensionProtocol(server *nex.Server) *MatchmakeExtensionProtocol

NewMatchmakeExtensionProtocol returns a new MatchmakeExtensionProtocol

func (*MatchmakeExtensionProtocol) AutoMatchmakeWithSearchCriteria_Postpone 

func (matchmakeExtensionProtocol *MatchmakeExtensionProtocol) AutoMatchmakeWithSearchCriteria_Postpone(handler func(err error, client *nex.Client, callID uint32, matchmakeSession *MatchmakeSession, message string))

AutoMatchmakeWithSearchCriteria_Postpone sets the AutoMatchmakeWithSearchCriteria_Postpone handler function

func (*MatchmakeExtensionProtocol) AutoMatchmake_Postpone 

func (matchmakeExtensionProtocol *MatchmakeExtensionProtocol) AutoMatchmake_Postpone(handler func(err error, client *nex.Client, callID uint32, matchmakeSession *MatchmakeSession, message string))

AutoMatchmake_Postpone sets the AutoMatchmake_Postpone handler function

func (*MatchmakeExtensionProtocol) CreateMatchmakeSession 

func (matchmakeExtensionProtocol *MatchmakeExtensionProtocol) CreateMatchmakeSession(handler func(err error, client *nex.Client, callID uint32, matchmakeSession *MatchmakeSession, message string, participationCount uint16))

CreateMatchmakeSession sets the CreateMatchmakeSession handler function

func (*MatchmakeExtensionProtocol) GetFriendNotificationData 

func (matchmakeExtensionProtocol *MatchmakeExtensionProtocol) GetFriendNotificationData(handler func(err error, client *nex.Client, callID uint32, uiType int32))

GetFriendNotificationData sets the GetFriendNotificationData handler function

func (*MatchmakeExtensionProtocol) GetSimplePlayingSession 

func (matchmakeExtensionProtocol *MatchmakeExtensionProtocol) GetSimplePlayingSession(handler func(err error, client *nex.Client, callID uint32, listPID []uint32, includeLoginUser bool))

GetSimplePlayingSession sets the GetSimplePlayingSession handler function

func (*MatchmakeExtensionProtocol) JoinMatchmakeSessionEx 

func (matchmakeExtensionProtocol *MatchmakeExtensionProtocol) JoinMatchmakeSessionEx(handler func(err error, client *nex.Client, callID uint32, gid uint32, strMessage string, dontCareMyBlockList bool, participationCount uint16))

JoinMatchmakeSessionEx sets the JoinMatchmakeSessionEx handler function

func (*MatchmakeExtensionProtocol) OpenParticipation 

func (matchmakeExtensionProtocol *MatchmakeExtensionProtocol) OpenParticipation(handler func(err error, client *nex.Client, callID uint32, gid uint32))

OpenParticipation sets the OpenParticipation handler function

func (*MatchmakeExtensionProtocol) Setup 

func (matchmakeExtensionProtocol *MatchmakeExtensionProtocol) Setup()

Setup initializes the protocol

func (*MatchmakeExtensionProtocol) UpdateNotificationData 

func (matchmakeExtensionProtocol *MatchmakeExtensionProtocol) UpdateNotificationData(handler func(err error, client *nex.Client, callID uint32, uiType uint32, uiParam1 uint32, uiParam2 uint32, strParam string))

UpdateNotificationData sets the UpdateNotificationData handler function

type MatchmakeParam 

type MatchmakeParam struct {
	*nex.Structure
	// contains filtered or unexported fields
}

MatchmakeParam holds parameters for a matchmake session

func NewMatchmakeParam 

func NewMatchmakeParam() *MatchmakeParam

NewMatchmakeParam returns a new MatchmakeParam

func (*MatchmakeParam) ExtractFromStream 

func (matchmakeParam *MatchmakeParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a MatchmakeParam structure from a stream

type MatchmakeSession 

type MatchmakeSession struct {
	GameMode              uint32
	Attributes            []uint32
	OpenParticipation     bool
	MatchmakeSystemType   uint32
	ApplicationData       []byte
	ParticipationCount    uint32
	ProgressScore         uint8           // NEX v3.5.0+
	SessionKey            []byte          // NEX v3.0.0+
	Option                uint32          // NEX v3.5.0+
	MatchmakeParam        *MatchmakeParam // NEX v4.0.0+
	StartedTime           *nex.DateTime   // NEX v4.0.0+
	UserPassword          string          // NEX v4.0.0+
	ReferGID              uint32          // NEX v4.0.0+
	UserPasswordEnabled   bool            // NEX v4.0.0+
	SystemPasswordEnabled bool            // NEX v4.0.0+
	CodeWord              string          // NEX v4.0.0+

	*Gathering
	// contains filtered or unexported fields
}

MatchmakeSession holds information about a matchmake session

func NewMatchmakeSession 

func NewMatchmakeSession() *MatchmakeSession

NewMatchmakeSession returns a new MatchmakeSession

func (*MatchmakeSession) Bytes 

func (matchmakeSession *MatchmakeSession) Bytes(stream *nex.StreamOut) []byte

Bytes extracts a MatchmakeSession structure from a stream

func (*MatchmakeSession) ExtractFromStream 

func (matchmakeSession *MatchmakeSession) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a MatchmakeSession structure from a stream

func (*MatchmakeSession) GetHierarchy 

func (matchmakeSession *MatchmakeSession) GetHierarchy() []nex.StructureInterface

GetHierarchy returns the Structure hierarchy

type MatchmakeSessionSearchCriteria 

type MatchmakeSessionSearchCriteria struct {
	Attribs             []string
	GameMode            string
	MinParticipants     string
	MaxParticipants     string
	MatchmakeSystemType string
	VacantOnly          bool
	ExcludeLocked       bool
	ExcludeNonHostPid   bool
	SelectionMethod     uint32
	VacantParticipants  uint16 // NEX v3.5.0+

	*nex.Structure
}

MatchmakeSessionSearchCriteria holds information about a matchmaking search

func NewMatchmakeSessionSearchCriteria 

func NewMatchmakeSessionSearchCriteria() *MatchmakeSessionSearchCriteria

NewGathering returns a new Gathering

func (*MatchmakeSessionSearchCriteria) Bytes 

func (matchmakeSessionSearchCriteria *MatchmakeSessionSearchCriteria) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the Gathering and returns a byte array

func (*MatchmakeSessionSearchCriteria) ExtractFromStream 

func (matchmakeSessionSearchCriteria *MatchmakeSessionSearchCriteria) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a Gathering structure from a stream

type MessageDeliveryProtocol 

type MessageDeliveryProtocol struct {
	DeliverMessageHandler func(err error, client *nex.Client, callID uint32, oUserMessage nex.StructureInterface)
	// contains filtered or unexported fields
}

AuthenticationProtocol handles the Authentication nex protocol

func NewMessageDeliveryProtocol 

func NewMessageDeliveryProtocol(server *nex.Server) *MessageDeliveryProtocol

NewMessageDeliveryProtocol returns a new MessageDeliveryProtocol

func (*MessageDeliveryProtocol) DeliverMessage 

func (messageDeliveryProtocol *MessageDeliveryProtocol) DeliverMessage(handler func(err error, client *nex.Client, callID uint32, oUserMessage nex.StructureInterface))

DeliverMessage sets the DeliverMessage handler function

func (*MessageDeliveryProtocol) Setup 

func (messageDeliveryProtocol *MessageDeliveryProtocol) Setup()

Setup initializes the protocol

type MessageRecipient 

type MessageRecipient struct {
	nex.Structure
	// contains filtered or unexported fields
}

func NewMessageRecipient 

func NewMessageRecipient() *MessageRecipient

NewMessageRecipient returns a new MessageRecipient

func (*MessageRecipient) ExtractFromStream 

func (messageRecipient *MessageRecipient) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a MessageRecipient structure from a stream

type Mii 

type Mii struct {
	Unknown1 string
	Unknown2 bool
	Unknown3 uint8
	// contains filtered or unexported fields
}

func NewMii 

func NewMii() *Mii

NewMii returns a new Mii

func (*Mii) ExtractFromStream 

func (mii *Mii) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a Mii from a stream

type MiiV2 

type MiiV2 struct {
	Name     string
	Unknown1 uint8
	Unknown2 uint8
	Data     []byte
	Datetime *nex.DateTime

	nex.Structure
}

MiiV2 contains data about a Mii

func NewMiiV2 

func NewMiiV2() *MiiV2

NewMiiV2 returns a new MiiV2

func (*MiiV2) Bytes 

func (mii *MiiV2) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the MiiV2 and returns a byte array

func (*MiiV2) ExtractFromStream 

func (mii *MiiV2) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a MiiV2 structure from a stream

type MonitoringProtocol 

type MonitoringProtocol struct {
	PingDaemonHandler        func(err error, client *nex.Client, callID uint32)
	GetClusterMembersHandler func(err error, client *nex.Client, callID uint32)
	// contains filtered or unexported fields
}

MonitoringProtocol handles the Monitoring protocol

func NewMonitoringProtocol 

func NewMonitoringProtocol(server *nex.Server) *MonitoringProtocol

NewMonitoringProtocol returns a new MonitoringProtocol

func (*MonitoringProtocol) GetClusterMembers 

func (monitoringProtocol *MonitoringProtocol) GetClusterMembers(handler func(err error, client *nex.Client, callID uint32))

GetClusterMembers sets the GetClusterMembers handler function

func (*MonitoringProtocol) PingDaemon 

func (monitoringProtocol *MonitoringProtocol) PingDaemon(handler func(err error, client *nex.Client, callID uint32))

PingDaemon sets the PingDaemon handler function

func (*MonitoringProtocol) Setup 

func (monitoringProtocol *MonitoringProtocol) Setup()

Setup initializes the protocol

type MyProfile 

type MyProfile struct {
	Region   uint8
	Country  uint8
	Area     uint8
	Language uint8
	Platform uint8
	Unknown1 uint64
	Unknown2 string
	Unknown3 string
}

func NewMyProfile 

func NewMyProfile() *MyProfile

NewMyProfile returns a new MyProfile

func (*MyProfile) ExtractFromStream 

func (myProfile *MyProfile) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a MyProfile from a stream

type NATTraversalProtocol 

type NATTraversalProtocol struct {
	InitiateProbeHandler             func(err error, client *nex.Client, callID uint32)
	RequestProbeInitiationExtHandler func(err error, client *nex.Client, callID uint32, targetList []string, stationToProbe string)
	ReportNATTraversalResultHandler  func(err error, client *nex.Client, callID uint32, cid uint32, result bool, rtt uint32)
	ReportNATPropertiesHandler       func(err error, client *nex.Client, callID uint32, natmapping uint32, natfiltering uint32, rtt uint32)
	GetRelaySignatureKeyHandler      func(err error, client *nex.Client, callID uint32)
	// contains filtered or unexported fields
}

AuthenticationProtocol handles the Authentication nex protocol

func NewNATTraversalProtocol 

func NewNATTraversalProtocol(server *nex.Server) *NATTraversalProtocol

NewNATTraversalProtocol returns a new NATTraversalProtocol

func (*NATTraversalProtocol) GetRelaySignatureKey 

func (natTraversalProtocol *NATTraversalProtocol) GetRelaySignatureKey(handler func(err error, client *nex.Client, callID uint32))

GetRelaySignatureKey sets the GetRelaySignatureKey handler function

func (*NATTraversalProtocol) ReportNATProperties 

func (natTraversalProtocol *NATTraversalProtocol) ReportNATProperties(handler func(err error, client *nex.Client, callID uint32, natmapping uint32, natfiltering uint32, rtt uint32))

ReportNATProperties sets the ReportNATProperties handler function

func (*NATTraversalProtocol) ReportNATTraversalResult 

func (natTraversalProtocol *NATTraversalProtocol) ReportNATTraversalResult(handler func(err error, client *nex.Client, callID uint32, cid uint32, result bool, rtt uint32))

ReportNATTraversalResult sets the ReportNATTraversalResult handler function

func (*NATTraversalProtocol) RequestProbeInitiationExt 

func (natTraversalProtocol *NATTraversalProtocol) RequestProbeInitiationExt(handler func(err error, client *nex.Client, callID uint32, targetList []string, stationToProbe string))

RequestProbeInitiationExt sets the RequestProbeInitiationExt handler function

func (*NATTraversalProtocol) Setup 

func (natTraversalProtocol *NATTraversalProtocol) Setup()

Setup initializes the protocol

type NNAInfo 

type NNAInfo struct {
	PrincipalBasicInfo *PrincipalBasicInfo
	Unknown1           uint8
	Unknown2           uint8

	nex.Structure
}

NNAInfo contains information about a Nintendo Network Account

func NewNNAInfo 

func NewNNAInfo() *NNAInfo

NewNNAInfo returns a new NNAInfo

func (*NNAInfo) Bytes 

func (nnaInfo *NNAInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the NNAInfo and returns a byte array

func (*NNAInfo) ExtractFromStream 

func (nnaInfo *NNAInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a NNAInfo structure from a stream

type NintendoCreateAccountData 

type NintendoCreateAccountData struct {
	nex.Structure
	NNAInfo  *NNAInfo
	Token    string
	Birthday *nex.DateTime
	Unknown  uint64
}

NintendoCreateAccountData contains data for creating a new NNID on the network

func NewNintendoCreateAccountData 

func NewNintendoCreateAccountData() *NintendoCreateAccountData

NewNintendoCreateAccountData returns a new NintendoCreateAccountData

func (*NintendoCreateAccountData) ExtractFromStream 

func (nintendoCreateAccountData *NintendoCreateAccountData) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a NintendoCreateAccountData structure from a stream

type NintendoLoginData 

type NintendoLoginData struct {
	Token string
}

NintendoLoginData holds a nex auth token

type NintendoNotificationEvent 

type NintendoNotificationEvent struct {
	nex.Structure
	Type       uint32
	SenderPID  uint32
	DataHolder *nex.DataHolder
}

NintendoNotificationEvent is used to send data about a notification event to a client

func NewNintendoNotificationEvent 

func NewNintendoNotificationEvent() *NintendoNotificationEvent

NewNintendoNotificationEvent returns a new NintendoNotificationEvent

func (*NintendoNotificationEvent) Bytes 

func (nintendoNotificationEvent *NintendoNotificationEvent) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the NintendoNotificationEvent and returns a byte array

type NintendoNotificationEventGeneral 

type NintendoNotificationEventGeneral struct {
	nex.Structure
	U32Param  uint32
	U64Param1 uint64
	U64Param2 uint64
	StrParam  string
}

NintendoNotificationEventGeneral holds general purpose notification data

func NewNintendoNotificationEventGeneral 

func NewNintendoNotificationEventGeneral() *NintendoNotificationEventGeneral

NintendoNotificationEventGeneral returns a new NintendoNotificationEventGeneral

func (*NintendoNotificationEventGeneral) Bytes 

func (nintendoNotificationEventGeneral *NintendoNotificationEventGeneral) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the NintendoNotificationEventGeneral and returns a byte array

type NintendoNotificationsProtocol 

type NintendoNotificationsProtocol struct {
	// contains filtered or unexported fields
}

NintendoNotificationsProtocol handles the NintendoNotifications protocol

func NewNintendoNotificationsProtocol 

func NewNintendoNotificationsProtocol(server *nex.Server) *NintendoNotificationsProtocol

NewNintendoNotificationsProtocol returns a new NintendoNotificationsProtocol

func (*NintendoNotificationsProtocol) Setup 

func (nintendoNotificationsProtocol *NintendoNotificationsProtocol) Setup()

Setup initializes the protocol

type NintendoPresence 

type NintendoPresence struct {
	ChangedFlags      uint32
	GameKey           *GameKey
	Message           string
	JoinAvailableFlag uint32
	MatchmakeType     uint8
	JoinGameID        uint32
	JoinGameMode      uint32
	OwnerPrincipalID  uint32
	JoinGroupID       uint32
	ApplicationArg    []byte

	nex.Structure
}

NintendoPresence contains information about a users online presence

func NewNintendoPresence 

func NewNintendoPresence() *NintendoPresence

NewNintendoPresence returns a new NintendoPresence

func (*NintendoPresence) Bytes 

func (presence *NintendoPresence) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the NintendoPresence and returns a byte array

func (*NintendoPresence) ExtractFromStream 

func (presence *NintendoPresence) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a NintendoPresence structure from a stream

type NintendoPresenceV2 

type NintendoPresenceV2 struct {
	ChangedFlags    uint32
	Online          bool
	GameKey         *GameKey
	Unknown1        uint8
	Message         string
	Unknown2        uint32
	Unknown3        uint8
	GameServerID    uint32
	Unknown4        uint32
	PID             uint32
	GatheringID     uint32
	ApplicationData []byte
	Unknown5        uint8
	Unknown6        uint8
	Unknown7        uint8

	nex.Structure
}

NintendoPresenceV2 contains information about a users online presence

func NewNintendoPresenceV2 

func NewNintendoPresenceV2() *NintendoPresenceV2

NewNintendoPresenceV2 returns a new NintendoPresenceV2

func (*NintendoPresenceV2) Bytes 

func (presence *NintendoPresenceV2) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the NintendoPresenceV2 and returns a byte array

func (*NintendoPresenceV2) ExtractFromStream 

func (presence *NintendoPresenceV2) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a NintendoPresenceV2 structure from a stream

type NotificationEvent 

type NotificationEvent struct {
	nex.Structure
	PIDSource uint32
	Type      uint32
	Param1    uint32
	Param2    uint32
	StrParam  string
}

NotificationEvent holds general purpose notification data

func NewNotificationEvent 

func NewNotificationEvent() *NotificationEvent

NotificationEvent returns a new NotificationEvent

func (*NotificationEvent) Bytes 

func (notificationEventGeneral *NotificationEvent) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the NotificationEvent and returns a byte array

type NotificationsProtocol 

type NotificationsProtocol struct {
	// contains filtered or unexported fields
}

NotificationsProtocol handles the Notifications protocol

func NewNotificationsProtocol 

func NewNotificationsProtocol(server *nex.Server) *NotificationsProtocol

NewNotificationsProtocol returns a new NotificationsProtocol

func (*NotificationsProtocol) Setup 

func (notificationsProtocol *NotificationsProtocol) Setup()

Setup initializes the protocol

type PersistentNotification 

type PersistentNotification struct {
	Unknown1 uint64
	Unknown2 uint32
	Unknown3 uint32
	Unknown4 uint32
	Unknown5 string

	nex.Structure
}

PersistentNotification contains unknown data

func NewPersistentNotification 

func NewPersistentNotification() *PersistentNotification

NewPersistentNotification returns a new PersistentNotification

func ReadListPersistentNotification 

func ReadListPersistentNotification(stream *nex.StreamIn) ([]*PersistentNotification, error)

ReadListPersistentNotification reads a list of PersistentNotification structures

func (*PersistentNotification) ExtractFromStream 

func (notification *PersistentNotification) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a PersistentNotification structure from a stream

type PrincipalBasicInfo 

type PrincipalBasicInfo struct {
	PID     uint32
	NNID    string
	Mii     *MiiV2
	Unknown uint8

	nex.Structure
}

PrincipalBasicInfo contains user account and Mii data

func NewPrincipalBasicInfo 

func NewPrincipalBasicInfo() *PrincipalBasicInfo

NewPrincipalBasicInfo returns a new PrincipalBasicInfo

func (*PrincipalBasicInfo) Bytes 

func (principalInfo *PrincipalBasicInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the PrincipalBasicInfo and returns a byte array

func (*PrincipalBasicInfo) ExtractFromStream 

func (principalInfo *PrincipalBasicInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a PrincipalBasicInfo structure from a stream

type PrincipalPreference 

type PrincipalPreference struct {
	nex.Structure

	ShowOnlinePresence  bool
	ShowCurrentTitle    bool
	BlockFriendRequests bool
}

PrincipalPreference contains unknown data

func NewPrincipalPreference 

func NewPrincipalPreference() *PrincipalPreference

NewPrincipalPreference returns a new PrincipalPreference

func (*PrincipalPreference) Bytes 

func (principalPreference *PrincipalPreference) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the PrincipalPreference and returns a byte array

func (*PrincipalPreference) ExtractFromStream 

func (principalPreference *PrincipalPreference) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a PrincipalPreference structure from a stream

type PrincipalRequestBlockSetting 

type PrincipalRequestBlockSetting struct {
	nex.Structure
	PID       uint32
	IsBlocked bool
}

PrincipalRequestBlockSetting contains unknow data

func NewPrincipalRequestBlockSetting 

func NewPrincipalRequestBlockSetting() *PrincipalRequestBlockSetting

NewPrincipalRequestBlockSetting returns a new PrincipalRequestBlockSetting

func (*PrincipalRequestBlockSetting) Bytes 

func (principalRequestBlockSetting *PrincipalRequestBlockSetting) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the PrincipalRequestBlockSetting and returns a byte array

type RankingMK8Protocol 

type RankingMK8Protocol struct {
	RankingProtocol
	// contains filtered or unexported fields
}

RankingMK8Protocol handles the Ranking (Mario Kart 8) nex protocol. Embeds RankingProtocol

func NewRankingMK8Protocol 

func NewRankingMK8Protocol(server *nex.Server) *RankingMK8Protocol

NewRankingMK8Protocol returns a new RankingMK8Protocol

func (*RankingMK8Protocol) Setup 

func (rankingMK8Protocol *RankingMK8Protocol) Setup()

Setup initializes the protocol

type RankingProtocol 

type RankingProtocol struct {
	UploadCommonDataHandler func(err error, client *nex.Client, callID uint32, commonData []byte, uniqueId uint64)
	// contains filtered or unexported fields
}

RankingProtocol handles the Ranking nex protocol

func NewRankingProtocol 

func NewRankingProtocol(server *nex.Server) *RankingProtocol

NewRankingProtocol returns a new RankingProtocol

func (*RankingProtocol) Setup 

func (rankingProtocol *RankingProtocol) Setup()

Setup initializes the protocol

func (*RankingProtocol) UploadCommonData 

func (rankingProtocol *RankingProtocol) UploadCommonData(handler func(err error, client *nex.Client, callID uint32, commonData []byte, uniqueID uint64))

UploadCommonData sets the UploadCommonData handler function

type RemoteLogDeviceProtocol 

type RemoteLogDeviceProtocol struct {
	LogHandler func(err error, client *nex.Client, callID uint32, strMessage string)
	// contains filtered or unexported fields
}

RemoteLogDeviceProtocol handles the RemoteLogDevice protocol

func NewRemoteLogDeviceProtocol 

func NewRemoteLogDeviceProtocol(server *nex.Server) *RemoteLogDeviceProtocol

NewRemoteLogDeviceProtocol returns a new RemoteLogDeviceProtocol

func (*RemoteLogDeviceProtocol) Log 

func (remoteLogDeviceProtocol *RemoteLogDeviceProtocol) Log(handler func(err error, client *nex.Client, callID uint32, strMessage string))

Log sets the Log handler function

func (*RemoteLogDeviceProtocol) Setup 

func (remoteLogDeviceProtocol *RemoteLogDeviceProtocol) Setup()

Setup initializes the protocol

type ScreeningProtocol 

type ScreeningProtocol struct {
	ReportDataStoreContentHandler func(err error, client *nex.Client, callID uint32)
	ReportUserHandler             func(err error, client *nex.Client, callID uint32)
	// contains filtered or unexported fields
}

ScreeningProtocol handles the Screening protocol

func NewScreeningProtocol 

func NewScreeningProtocol(server *nex.Server) *ScreeningProtocol

NewScreeningProtocol returns a new ScreeningProtocol

func (*ScreeningProtocol) ReportDataStoreContent 

func (screeningProtocol *ScreeningProtocol) ReportDataStoreContent(handler func(err error, client *nex.Client, callID uint32))

ReportDataStoreContent sets the ReportDataStoreContent handler function

func (*ScreeningProtocol) ReportUser 

func (screeningProtocol *ScreeningProtocol) ReportUser(handler func(err error, client *nex.Client, callID uint32))

ReportUser sets the ReportUser handler function

func (*ScreeningProtocol) Setup 

func (screeningProtocol *ScreeningProtocol) Setup()

Setup initializes the protocol

type SecureBadgeArcadeProtocol 

type SecureBadgeArcadeProtocol struct {
	SecureProtocol
	GetMaintenanceStatusHandler func(err error, client *nex.Client, callID uint32)
	// contains filtered or unexported fields
}

SecureBadgeArcadeProtocol handles the Secure Connection (Badge Arcade) nex protocol. Embeds SecureProtocol

func NewSecureBadgeArcadeProtocol 

func NewSecureBadgeArcadeProtocol(server *nex.Server) *SecureBadgeArcadeProtocol

NewSecureBadgeArcadeProtocol returns a new SecureBadgeArcadeProtocol

func (*SecureBadgeArcadeProtocol) GetMaintenanceStatus 

func (secureBadgeArcadeProtocol *SecureBadgeArcadeProtocol) GetMaintenanceStatus(handler func(err error, client *nex.Client, callID uint32))

GetMaintenanceStatus sets the GetMaintenanceStatus function

func (*SecureBadgeArcadeProtocol) Setup 

func (secureBadgeArcadeProtocol *SecureBadgeArcadeProtocol) Setup()

Setup initializes the protocol

type SecureProtocol 

type SecureProtocol struct {
	RegisterHandler              func(err error, client *nex.Client, callID uint32, stationUrls []*nex.StationURL)
	RequestConnectionDataHandler func(err error, client *nex.Client, callID uint32, stationCID uint32, stationPID uint32)
	RequestURLsHandler           func(err error, client *nex.Client, callID uint32, stationCID uint32, stationPID uint32)
	RegisterExHandler            func(err error, client *nex.Client, callID uint32, stationUrls []*nex.StationURL, loginData NintendoLoginData)
	TestConnectivityHandler      func(err error, client *nex.Client, callID uint32)
	UpdateURLsHandler            func(err error, client *nex.Client, callID uint32, stationUrls []*nex.StationURL)
	ReplaceURLHandler            func(err error, client *nex.Client, callID uint32, oldStation *nex.StationURL, newStation *nex.StationURL)
	SendReportHandler            func(err error, client *nex.Client, callID uint32, reportID uint32, report []byte)
	// contains filtered or unexported fields
}

SecureProtocol handles the Secure Connection nex protocol

func NewSecureProtocol 

func NewSecureProtocol(server *nex.Server) *SecureProtocol

NewSecureProtocol returns a new SecureProtocol

func (*SecureProtocol) Register 

func (secureProtocol *SecureProtocol) Register(handler func(err error, client *nex.Client, callID uint32, stationUrls []*nex.StationURL))

Register sets the Register handler function

func (*SecureProtocol) RegisterEx 

func (secureProtocol *SecureProtocol) RegisterEx(handler func(err error, client *nex.Client, callID uint32, stationUrls []*nex.StationURL, loginData NintendoLoginData))

RegisterEx sets the RegisterEx handler function

func (*SecureProtocol) ReplaceURL 

func (secureProtocol *SecureProtocol) ReplaceURL(handler func(err error, client *nex.Client, callID uint32, oldStation *nex.StationURL, newStation *nex.StationURL))

ReplaceURL sets the ReplaceURL handler function

func (*SecureProtocol) RequestConnectionData 

func (secureProtocol *SecureProtocol) RequestConnectionData(handler func(err error, client *nex.Client, callID uint32, stationCID uint32, stationPID uint32))

RequestConnectionData sets the RequestConnectionData handler function

func (*SecureProtocol) RequestURLs 

func (secureProtocol *SecureProtocol) RequestURLs(handler func(err error, client *nex.Client, callID uint32, stationCID uint32, stationPID uint32))

RequestURLs sets the RequestURLs handler function

func (*SecureProtocol) SendReport 

func (secureProtocol *SecureProtocol) SendReport(handler func(err error, client *nex.Client, callID uint32, reportID uint32, report []byte))

SendReport sets the SendReport handler function

func (*SecureProtocol) Setup 

func (secureProtocol *SecureProtocol) Setup()

Setup initializes the protocol

func (*SecureProtocol) TestConnectivity 

func (secureProtocol *SecureProtocol) TestConnectivity(handler func(err error, client *nex.Client, callID uint32))

TestConnectivity sets the TestConnectivity handler function

func (*SecureProtocol) UpdateURLs 

func (secureProtocol *SecureProtocol) UpdateURLs(handler func(err error, client *nex.Client, callID uint32, stationUrls []*nex.StationURL))

UpdateURLs sets the UpdateURLs handler function

type ShopBadgeArcadeProtocol 

type ShopBadgeArcadeProtocol struct {
	PostPlayLogHandler func(err error, client *nex.Client, callID uint32, unknown1 uint16, param *ShopPostPlayLogParam)
	// contains filtered or unexported fields
}

ShopBadgeArcadeProtocol handles the Shop (Badge Arcade) nex protocol

func NewShopBadgeArcadeProtocol 

func NewShopBadgeArcadeProtocol(server *nex.Server) *ShopBadgeArcadeProtocol

NewShopBadgeArcadeProtocol returns a new ShopBadgeArcadeProtocol

func (*ShopBadgeArcadeProtocol) PostPlayLog 

func (shopBadgeArcadeProtocol *ShopBadgeArcadeProtocol) PostPlayLog(handler func(err error, client *nex.Client, callID uint32, unknown1 uint16, param *ShopPostPlayLogParam))

PostPlayLog sets the PostPlayLog function

func (*ShopBadgeArcadeProtocol) Setup 

func (shopBadgeArcadeProtocol *ShopBadgeArcadeProtocol) Setup()

Setup initializes the protocol

type ShopPostPlayLogParam 

type ShopPostPlayLogParam struct {
	nex.Structure
	Unknown1  []uint32
	Timestamp *nex.DateTime
	Unknown2  string
}

func NewShopPostPlayLogParam 

func NewShopPostPlayLogParam() *ShopPostPlayLogParam

NewShopPostPlayLogParam returns a new ShopPostPlayLogParam

func (*ShopPostPlayLogParam) Bytes 

func (shopPostPlayLogParam *ShopPostPlayLogParam) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the ShopPostPlayLogParam and returns a byte array

func (*ShopPostPlayLogParam) ExtractFromStream 

func (shopPostPlayLogParam *ShopPostPlayLogParam) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a ShopPostPlayLogParam structure from a stream

type UniqueIDInfo 

type UniqueIDInfo struct {
	NexUniqueID         uint64
	NexUniqueIDPassword uint64

	*nex.Structure
}

UniqueIDInfo holds parameters for a matchmake session

func NewUniqueIDInfo 

func NewUniqueIDInfo() *UniqueIDInfo

NewUniqueIDInfo returns a new UniqueIDInfo

func (*UniqueIDInfo) Bytes 

func (uniqueIDInfo *UniqueIDInfo) Bytes(stream *nex.StreamOut) []byte

Bytes encodes the UniqueIDInfo and returns a byte array

func (*UniqueIDInfo) ExtractFromStream 

func (uniqueIDInfo *UniqueIDInfo) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a UniqueIDInfo structure from a stream

type UserMessage 

type UserMessage struct {
	nex.Structure
	*nex.Data
	// contains filtered or unexported fields
}

func NewUserMessage 

func NewUserMessage() *UserMessage

NewUserMessage returns a new UserMessage

func (*UserMessage) ExtractFromStream 

func (userMessage *UserMessage) ExtractFromStream(stream *nex.StreamIn) error

ExtractFromStream extracts a UserMessage structure from a stream

type UtilityProtocol 

type UtilityProtocol struct {
	AcquireNexUniqueIDHandler                         func(err error, client *nex.Client, callID uint32)
	AcquireNexUniqueIDWithPasswordHandler             func(err error, client *nex.Client, callID uint32)
	AssociateNexUniqueIDWithMyPrincipalIDHandler      func(err error, client *nex.Client, callID uint32, uniqueIDInfo *UniqueIDInfo)
	AssociateNexUniqueIDsWithMyPrincipalIDHandler     func(err error, client *nex.Client, callID uint32, uniqueIDInfo []*UniqueIDInfo)
	GetAssociatedNexUniqueIDWithMyPrincipalIDHandler  func(err error, client *nex.Client, callID uint32)
	GetAssociatedNexUniqueIDsWithMyPrincipalIDHandler func(err error, client *nex.Client, callID uint32)
	GetIntegerSettingsHandler                         func(err error, client *nex.Client, callID uint32, integerSettingIndex uint32)
	GetStringSettingsHandler                          func(err error, client *nex.Client, callID uint32, stringSettingIndex uint32)
	// contains filtered or unexported fields
}

UtilityProtocol handles the Utility nex protocol

func NewUtilityProtocol 

func NewUtilityProtocol(server *nex.Server) *UtilityProtocol

NewUtilityProtocol returns a new UtilityProtocol

func (*UtilityProtocol) AcquireNexUniqueID 

func (utilityProtocol *UtilityProtocol) AcquireNexUniqueID(handler func(err error, client *nex.Client, callID uint32))

AcquireNexUniqueID sets the AcquireNexUniqueID handler function

func (*UtilityProtocol) AcquireNexUniqueIDWithPassword 

func (utilityProtocol *UtilityProtocol) AcquireNexUniqueIDWithPassword(handler func(err error, client *nex.Client, callID uint32))

AcquireNexUniqueIDWithPassword sets the AcquireNexUniqueIDWithPassword handler function

func (*UtilityProtocol) AssociateNexUniqueIDWithMyPrincipalID 

func (utilityProtocol *UtilityProtocol) AssociateNexUniqueIDWithMyPrincipalID(handler func(err error, client *nex.Client, callID uint32, uniqueIDInfo *UniqueIDInfo))

AssociateNexUniqueIDWithMyPrincipalID sets the AssociateNexUniqueIDWithMyPrincipalID handler function

func (*UtilityProtocol) AssociateNexUniqueIDsWithMyPrincipalID 

func (utilityProtocol *UtilityProtocol) AssociateNexUniqueIDsWithMyPrincipalID(handler func(err error, client *nex.Client, callID uint32, uniqueIDInfo []*UniqueIDInfo))

AssociateNexUniqueIDsWithMyPrincipalID sets the AssociateNexUniqueIDsWithMyPrincipalID handler function

func (*UtilityProtocol) GetAssociatedNexUniqueIDWithMyPrincipalID 

func (utilityProtocol *UtilityProtocol) GetAssociatedNexUniqueIDWithMyPrincipalID(handler func(err error, client *nex.Client, callID uint32))

GetAssociatedNexUniqueIDWithMyPrincipalID sets the GetAssociatedNexUniqueIDWithMyPrincipalID handler function

func (*UtilityProtocol) GetAssociatedNexUniqueIDsWithMyPrincipalID 

func (utilityProtocol *UtilityProtocol) GetAssociatedNexUniqueIDsWithMyPrincipalID(handler func(err error, client *nex.Client, callID uint32))

GetAssociatedNexUniqueIDsWithMyPrincipalID sets the GetAssociatedNexUniqueIDsWithMyPrincipalID handler function

func (*UtilityProtocol) GetIntegerSettings 

func (utilityProtocol *UtilityProtocol) GetIntegerSettings(handler func(err error, client *nex.Client, callID uint32, integerSettingIndex uint32))

GetIntegerSettings sets the GetIntegerSettings handler function

func (*UtilityProtocol) GetStringSettings 

func (utilityProtocol *UtilityProtocol) GetStringSettings(handler func(err error, client *nex.Client, callID uint32, stringSettingIndex uint32))

GetStringSettings sets the GetStringSettings handler function

func (*UtilityProtocol) Setup 

func (utilityProtocol *UtilityProtocol) Setup()

Setup initializes the protocol

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.