Update constants/magic numbers

match-making/constants/anybody_particiation_policy_argument.go

@@ -0,0 +1,16 @@
+package constants
+
+// AnybodyParticipationPolicyArgument seems to determine whether or not to
+// close participation when the gathering owner changes when MatchmakeSystemTypeAnybody
+// is used?
+type AnybodyParticipationPolicyArgument = PolicyArgument
+
+const (
+	// AnybodyParticipationPolicyArgumentWithoutClose means that participation should not
+	// close when a new owner is selected.
+	AnybodyParticipationPolicyArgumentWithoutClose AnybodyParticipationPolicyArgument = iota
+
+	// AnybodyParticipationPolicyArgumentCloseOnOwnerMigration means that participation should
+	// close when a new owner is selected.
+	AnybodyParticipationPolicyArgumentCloseOnOwnerMigration
+)

match-making/constants/auto_matchmake_option.go

@@ -0,0 +1,39 @@
+package constants
+
+import (
+	"github.com/PretendoNetwork/nex-go/v2/types"
+)
+
+// AutoMatchmakeOption has an unknown use.
+type AutoMatchmakeOption uint32
+
+// WriteTo writes the AutoMatchmakeOption to the given writable
+func (amo AutoMatchmakeOption) WriteTo(writable types.Writable) {
+	writable.WriteUInt32LE(uint32(amo))
+}
+
+// ExtractFrom extracts the AutoMatchmakeOption value from the given readable
+func (amo *AutoMatchmakeOption) ExtractFrom(readable types.Readable) error {
+	value, err := readable.ReadUInt32LE()
+	if err != nil {
+		return err
+	}
+
+	*amo = AutoMatchmakeOption(value)
+	return nil
+}
+
+const (
+	// AutoMatchmakeOptionNone has an unknown use.
+	AutoMatchmakeOptionNone AutoMatchmakeOption = iota
+
+	// AutoMatchmakeOptionRecordLastGIDForParticipationCheck has an unknown use.
+	//
+	// Possibly related to gidForParticipationCheck?
+	AutoMatchmakeOptionRecordLastGIDForParticipationCheck
+
+	// AutoMatchmakeOptionUniqueGatheringByCodeword has an unknown use.
+	//
+	// Possibly related to m_Codeword?
+	AutoMatchmakeOptionUniqueGatheringByCodeword
+)

match-making/constants/constants.go

@@ -0,0 +1,85 @@
+package constants
+
+// * Miscellaneous constants
+
+const (
+	// InvalidGatheringID represents an invalid/unset gathering ID
+	InvalidGatheringID uint32 = 0
+
+	// NumMatchmakeSessionAttributes is the max number of m_Attribs attributes a session may have
+	NumMatchmakeSessionAttributes uint32 = 6
+
+	// MatchmakeSessionNearestNeighborAttributeIndex is the index into m_Attribs for finding the value
+	// used for the SelectionMethodNearestNeighbor method
+	MatchmakeSessionNearestNeighborAttributeIndex uint32 = 1
+
+	// MatchmakeSessionBroadenRangeAttributeIndex is the index into m_Attribs for finding the value
+	// used for the SelectionMethodBroadenRange/SelectionMethodBroadenRangeWithProgressScore methods
+	MatchmakeSessionBroadenRangeAttributeIndex uint32 = 1
+
+	// InvalidPersistentGatheringCode likely represents an invalid result from GatheringIdToPersistentGatheringCode?
+	InvalidPersistentGatheringCode uint64 = 0
+
+	// PersistentGatheringCreationMax is the max number of persistent gatherings a user can create
+	PersistentGatheringCreationMax uint32 = 4
+
+	// PersistentGatheringParticipationMax is the max number of persistent gatherings a user can join
+	PersistentGatheringParticipationMax uint32 = 16
+
+	// PersistentGatheringChatParticipantsMax is unknown. Maybe related to the "SendChat" methods of the NexMessagingClient?
+	PersistentGatheringChatParticipantsMax uint64 = 32
+
+	// SetAttributeVectorSizeMax seems to be the max number of values a m_Attribs string may have? ("1,2,3,4,5" etc.)
+	//
+	// Note: This is a guess based on the "SetAttribute" and "VectorSize" parts. MatchmakeSessionSearchCriteria has a
+	// SetAttribute method which sets the m_Attribs field. We also know that the m_Attribs values can contain multiple
+	// numbers, possibly representing a "vector"
+	SetAttributeVectorSizeMax uint32 = 100
+
+	// MaxProgressScore is the max value for progressScore
+	MaxProgressScore uint8 = 100
+
+	// UpdateProgressScoreMinimumIntervalTime is the minimum interval (in seconds?) for updating the sessions progressScore
+	UpdateProgressScoreMinimumIntervalTime uint32 = 30
+
+	// MaxMatchmakeSessionUserPasswordLength is the max user password length for a matchmake session
+	MaxMatchmakeSessionUserPasswordLength uint32 = 32
+
+	// MatchmakeSessionSystemPasswordLength is the system password length for a matchmake session
+	MatchmakeSessionSystemPasswordLength uint32 = 16
+
+	// MaxMatchmakeBrowseSize is the max number of gatherings that can be returned from the BrowseMatchmakeSession family of methods.
+	//
+	// This seems to also be the max input size for FindMatchmakeSessionByGatheringId?
+	MaxMatchmakeBrowseSize uint32 = 100
+
+	// MaxPrincipalIDSizeToFindMatchmakeSession is the max number of PIDs that can be used in FindMatchmakeSessionByParticipant and GetPlayingSession
+	MaxPrincipalIDSizeToFindMatchmakeSession uint32 = 300
+
+	// MaxMatchmakeBrowseSizeByParticipant is unknown.
+	//
+	// Since the value is the same as, and shares a similar name with, MaxPrincipalIDSizeToFindMatchmakeSession
+	// this is likely a newer/older version of that constant?
+	MaxMatchmakeBrowseSizeByParticipant uint32 = 300
+
+	// MaxMatchmakeSessionByParticipant is the max number of sessions that can be returned by FindMatchmakeSessionByParticipant and GetPlayingSession
+	MaxMatchmakeSessionByParticipant uint32 = 1000
+
+	// MaxExtraParticipants is the max value of extraParticipants
+	MaxExtraParticipants uint32 = 4
+
+	// MaxP2PSignatureKeyLen is the max size of m_SessionKey
+	MaxP2PSignatureKeyLen uint32 = 32
+
+	// ResultRangeAnyOffset when used in MatchmakeSessionSearchCriteria, seems to tell the server to search
+	// the entire database for matching sessions and return up to m_uiSize (max 100) sessions in a random
+	// order. Otherwise the ResultRange offset is used as normal and sessions are returned in order based on
+	// their gathering IDs
+	ResultRangeAnyOffset uint64 = 4294967295
+
+	// MatchmakeStringMaxLength is the max length of matchmaking strings
+	MatchmakeStringMaxLength uint32 = 256
+
+	// MatchmakeBufferMaxLength is the max size of matchmaking binary data
+	MatchmakeBufferMaxLength uint32 = 512
+)

match-making/constants/find_matchmake_session_result_option.go

@@ -0,0 +1,52 @@
+package constants
+
+import "github.com/PretendoNetwork/nex-go/v2/types"
+
+// FindMatchmakeSessionResultOption indicates how to populate the
+// responses from FindMatchmakeSessionByParticipant
+type FindMatchmakeSessionResultOption uint32
+
+// WriteTo writes the FindMatchmakeSessionResultOption to the given writable
+func (fmsr FindMatchmakeSessionResultOption) WriteTo(writable types.Writable) {
+	writable.WriteUInt32LE(uint32(fmsr))
+}
+
+// ExtractFrom extracts the FindMatchmakeSessionResultOption value from the given readable
+func (fmsr *FindMatchmakeSessionResultOption) ExtractFrom(readable types.Readable) error {
+	value, err := readable.ReadUInt32LE()
+	if err != nil {
+		return err
+	}
+
+	*fmsr = FindMatchmakeSessionResultOption(value)
+	return nil
+}
+
+func (fmsr FindMatchmakeSessionResultOption) HasFlag(flag FindMatchmakeSessionResultOption) bool {
+	return fmsr&flag == flag
+}
+
+func (fmsr FindMatchmakeSessionResultOption) HasFlags(flags ...FindMatchmakeSessionResultOption) bool {
+	if len(flags) == 0 {
+		return false
+	}
+
+	for _, flag := range flags {
+		if fmsr&flag != flag {
+			return false
+		}
+	}
+
+	return true
+}
+
+const (
+	// FindMatchmakeSessionResultOptionNone indicates no options
+	FindMatchmakeSessionResultOptionNone FindMatchmakeSessionResultOption = 0
+
+	// FindMatchmakeSessionResultOptionApplicationBuffer populates m_ApplicationBuffer in the results
+	FindMatchmakeSessionResultOptionApplicationBuffer FindMatchmakeSessionResultOption = 1
+
+	// FindMatchmakeSessionResultOptionMatchmakeParam populates m_MatchmakeParam in the results
+	FindMatchmakeSessionResultOptionMatchmakeParam FindMatchmakeSessionResultOption = 2
+)

match-making/constants/gathering_flags.go

@@ -0,0 +1,100 @@
+package constants
+
+import "github.com/PretendoNetwork/nex-go/v2/types"
+
+// GatheringFlags indicates the flags set on a gathering
+type GatheringFlags uint16
+
+// WriteTo writes the GatheringFlags to the given writable
+func (gf GatheringFlags) WriteTo(writable types.Writable) {
+	writable.WriteUInt16LE(uint16(gf))
+}
+
+// ExtractFrom extracts the GatheringFlags value from the given readable
+func (gf *GatheringFlags) ExtractFrom(readable types.Readable) error {
+	value, err := readable.ReadUInt16LE()
+	if err != nil {
+		return err
+	}
+
+	*gf = GatheringFlags(value)
+	return nil
+}
+
+func (gf GatheringFlags) HasFlag(flag GatheringFlags) bool {
+	return gf&flag == flag
+}
+
+func (gf GatheringFlags) HasFlags(flags ...GatheringFlags) bool {
+	if len(flags) == 0 {
+		return false
+	}
+
+	for _, flag := range flags {
+		if gf&flag != flag {
+			return false
+		}
+	}
+
+	return true
+}
+
+const (
+	// GatheringFlagNone means that no flags are set
+	GatheringFlagNone GatheringFlags = 0x0
+
+	// GatheringFlagPersistentGathering indicates that a gathering is persistent.
+	//
+	// Gatherings with this flag don't get deleted on the server when the user logs
+	// out or when the gathering state is set to "Finished". The gathering MUST be
+	// deleted manually by the owner.
+	//
+	// Seen in Mario Kart 7 communities.
+	GatheringFlagPersistentGathering GatheringFlags = 0x1
+
+	// GatheringFlagMigrateOwner determines whether or not to pick a new owner when
+	// the current owner logs out. If set and the owner disconnects, a new owner is
+	// picked from the remaining participants. If a new owner can't be set, or this
+	// flag is not set, then the gathering is deleted when the owner disconnects.
+	//
+	// Only applies to non-persistent gatherings.
+	GatheringFlagMigrateOwner GatheringFlags = 0x10
+
+	// GatheringFlagNoPersistentParticipation determines whether or not a participant
+	// will have their participation status removed from a persistent gathering when
+	// they log out. If set, the users participation status is removed after disconnecting.
+	GatheringFlagNoPersistentParticipation GatheringFlags = 0x40
+
+	// GatheringFlagAllowNoParticipant determines whether or not a persistent gathering
+	// will be deleted when it has 0 participants. Normally a persistent gathering is
+	// deleted when it has 0 participants. If set, the persistent gathering will NOT be
+	// deleted when it has 0 participants.
+	//
+	// Note: This does NOT mean ACTIVE players. Players may be participants of a persistent
+	// gathering while not actively playing in the session or even online.
+	GatheringFlagAllowNoParticipant GatheringFlags = 0x80
+
+	// GatheringFlagChangeOwnerByOtherHost determines whether or not ownership of a gathering
+	// can be taken by another user. If set, calling UpdateSessionHost and UpdateGatheringOwnership
+	// will allow ownership to be transfered. If set and ownership changes, a OwnershipChangeEvent
+	// notification is sent to all participants.
+	GatheringFlagChangeOwnerByOtherHost GatheringFlags = 0x200
+
+	// GatheringFlagNotifyParticipationEventsToAllParticipants determines whether or
+	// not Participate, Disconnect, and EndParticipation ParticipationEvents notifications
+	// are sent to players in the session. If neither this flag nor
+	// GatheringFlagNotifyParticipationEventsToAllParticipantsReproducibly are set then
+	// only the owner of the session gets these notifications.
+	GatheringFlagNotifyParticipationEventsToAllParticipants GatheringFlags = 0x400
+
+	// GatheringFlagNotifyParticipationEventsToAllParticipantsReproducibly determines
+	// whether or not Participate, Disconnect, and EndParticipation ParticipationEvents
+	// notifications are sent to players in the session. If neither this flag nor
+	// GatheringFlagNotifyParticipationEventsToAllParticipants are set then only the
+	// owner of the session gets these notifications.
+	//
+	// The exact details on how this differs from GatheringFlagNotifyParticipationEventsToAllParticipants
+	// is not known. It seems to seend a duplicate Participate notification event to
+	// all existing players of the session (but not the new player)?
+	GatheringFlagNotifyParticipationEventsToAllParticipantsReproducibly GatheringFlags = 0x800
+)

match-making/constants/gathering_state.go

@@ -0,0 +1,42 @@
+package constants
+
+import (
+	"github.com/PretendoNetwork/nex-go/v2/types"
+)
+
+// GatheringState indicates the state of a gathering.
+//
+// Note: We do not know the real names for any of these, this is
+// all guess work. The values of these states seem to imply that
+// they are bitwise flags, but they seem to be treated as enum
+// values in practice?
+type GatheringState uint32
+
+// WriteTo writes the GatheringState to the given writable
+func (gs GatheringState) WriteTo(writable types.Writable) {
+	writable.WriteUInt32LE(uint32(gs))
+}
+
+// ExtractFrom extracts the GatheringState value from the given readable
+func (gs *GatheringState) ExtractFrom(readable types.Readable) error {
+	value, err := readable.ReadUInt32LE()
+	if err != nil {
+		return err
+	}
+
+	*gs = GatheringState(value)
+	return nil
+}
+
+const (
+	// GatheringStateLocked indicates that a gathering is locked, and no new participants may join
+	// Name assumed from MatchmakeSessionSearchCriteria.ExcludeLocked.
+	GatheringStateLocked GatheringState = 1
+
+	// GatheringStateStarted indicates that the gatherings session has begun.
+	GatheringStateStarted GatheringState = 2
+
+	// GatheringStateFinished indicates that the gatherings session has finished.
+	// Manually setting this state seems to delete gatherings which are non-persistent.
+	GatheringStateFinished GatheringState = 4
+)

match-making/constants/join_matchmake_session_behavior.go

@@ -1,12 +1,35 @@
 package constants
 
+import (
+	"github.com/PretendoNetwork/nex-go/v2/types"
+)
+
 // JoinMatchmakeSessionBehavior is used to indicate the behavior that joining a matchmake session will have
 type JoinMatchmakeSessionBehavior uint8
 
+// WriteTo writes the JoinMatchmakeSessionBehavior to the given writable
+func (jmsb JoinMatchmakeSessionBehavior) WriteTo(writable types.Writable) {
+	writable.WriteUInt8(uint8(jmsb))
+}
+
+// ExtractFrom extracts the JoinMatchmakeSessionBehavior value from the given readable
+func (jmsb *JoinMatchmakeSessionBehavior) ExtractFrom(readable types.Readable) error {
+	value, err := readable.ReadUInt8()
+	if err != nil {
+		return err
+	}
+
+	*jmsb = JoinMatchmakeSessionBehavior(value)
+	return nil
+}
+
 const (
-	// JoinMatchmakeSessionBehaviorJoinMyself indicates that the caller wants to join the session
+	// JoinMatchmakeSessionBehaviorJoinMyself indicates that the caller wants to join the session.
 	JoinMatchmakeSessionBehaviorJoinMyself JoinMatchmakeSessionBehavior = iota
 
-	// JoinMatchmakeSessionBehaviorImAlreadyJoined indicates that the caller is already joined into the session
+	// JoinMatchmakeSessionBehaviorImAlreadyJoined indicates that the caller is already joined into the session.
+	//
+	// This can be useful in cases where the caller wants to add additional users to the session using additionalParticipants
+	// without trying to join the session themselves multiple times.
 	JoinMatchmakeSessionBehaviorImAlreadyJoined
 )