channeld

type ACLSettingsType struct {
	Sub    ChannelAccessLevel
	Unsub  ChannelAccessLevel
	Remove ChannelAccessLevel
}

type AlwaysFailAuthProvider struct{}

type AuthEventData struct {
	AuthResult            channeldpb.AuthResultMessage_AuthResult
	Connection            ConnectionInChannel
	PlayerIdentifierToken string
}

type AuthProvider interface {
	DoAuth(connId ConnectionId, pit string, lt string) (channeldpb.AuthResultMessage_AuthResult, error)
}

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

type ChannelAccessLevel uint8

type ChannelAccessType uint8

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

type ChannelDataInitializer interface {
	common.Message
	Init() error
}

type ChannelSettingsType struct {
	TickIntervalMs                 uint
	DefaultFanOutIntervalMs        uint32
	DefaultFanOutDelayMs           int32
	RemoveChannelAfterOwnerRemoved bool
	ACLSettings                    ACLSettingsType
	// Optinal. The full name of the Protobuf message type for the channel data (including the package name)
	DataMsgFullName string
}

type ChannelState uint8

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

type ChannelTime int64 // time.Duration

type Connection struct {
	ConnectionInChannel
	// contains filtered or unexported fields
}

type ConnectionId uint32

type ConnectionInChannel interface {
	Id() ConnectionId
	GetConnectionType() channeldpb.ConnectionType
	OnAuthenticated(pit string)
	HasAuthorityOver(ch *Channel) bool
	Close()
	IsClosing() bool
	Send(ctx MessageContext)
	// Returns the subscription instance if successfully subscribed, and true if subscription message should be sent.
	SubscribeToChannel(ch *Channel, options *channeldpb.ChannelSubscriptionOptions) (*ChannelSubscription, bool)
	UnsubscribeFromChannel(ch *Channel) (*channeldpb.ChannelSubscriptionOptions, error)

	HasInterestIn(spatialChId common.ChannelId) bool
	Logger() *Logger
	RemoteAddr() net.Addr
	// contains filtered or unexported methods
}

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

type EntityGroupController interface {
	Initialize(ch *Channel)
	Uninitialize(ch *Channel)

	AddToGroup(t channeldpb.EntityGroupType, entitiesToAdd []EntityId) error
	RemoveFromGroup(t channeldpb.EntityGroupType, entitiesToRemove []EntityId) error
	GetHandoverEntities() []EntityId
	// contains filtered or unexported methods
}

type EntityId uint32

type Event[T EventData] struct {
	// contains filtered or unexported fields
}

type EventData interface {
}

type FixedPasswordAuthProvider struct {
	Password string
}

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

type GlobalSettingsType struct {
	Development   bool
	LogLevel      *NullableInt // zapcore.Level
	LogFile       *NullableString
	ProfileOption func(*profile.Profile)
	ProfilePath   string

	ServerNetwork         string
	ServerAddress         string
	ServerReadBufferSize  int
	ServerWriteBufferSize int
	ServerFSM             string
	ServerBypassAuth      bool

	ClientNetworkWaitMasterServer bool
	ClientNetwork                 string
	ClientAddress                 string
	ClientReadBufferSize          int
	ClientWriteBufferSize         int
	ClientFSM                     string

	CompressionType channeldpb.CompressionType

	MaxConnectionIdBits uint8

	ConnectionAuthTimeoutMs int64
	MaxFailedAuthAttempts   int
	MaxFsmDisallowed        int

	SpatialControllerConfig NullableString
	SpatialChannelIdStart   common.ChannelId
	EntityChannelIdStart    common.ChannelId

	ChannelSettings map[channeldpb.ChannelType]ChannelSettingsType

	EnableRecordPacket bool

	ReplaySessionPersistenceDir string
}

type HandoverDataMerger interface {
	// Entity channel data merges itself to the spatial channel data for handover.
	// If fullData is true, merge the full entity data into the spatial channel data; otherwise, merge the entity identifier only.
	MergeTo(spatialChannelData common.Message, fullData bool) error
}

type HandoverDataWithPayload interface {
	// Clear the payload of the handover data so it won't be send to the connection that don't have the interest
	ClearPayload()
}

type LocalhostAddr struct {
	NetworkName string
}

type LogLevel zapcore.Level

type Logger struct {
	*zap.Logger
}

type LoggingAuthProvider struct {
	Logger *zap.Logger
	Msg    string
}

type MapRead[K comparable, V any] interface {
	Load(key K) (value V, ok bool)
}

type MergeableChannelData interface {
	common.Message
	Merge(src common.ChannelDataMessage, options *channeldpb.ChannelDataMergeOptions, spatialNotifier common.SpatialInfoChangedNotifier) error
}

type MessageContext struct {
	MsgType channeldpb.MessageType
	// The weak-typed Message object popped from the message queue
	Msg       common.Message
	Broadcast uint32 //channeldpb.BroadcastType
	StubId    uint32
	// The original channelId in the Packet, could be different from Channel.id.
	// Used for both send and receive.
	ChannelId uint32

	// The connection that received the message. Required for BroadcastType_ALL_BUT_SENDER but not for sending.
	Connection ConnectionInChannel
	// The channel that handling the message. Not required for sending or broadcasting.
	Channel *Channel
	// contains filtered or unexported fields
}

type MessageHandlerFunc func(ctx MessageContext)

type MessageSender interface {
	Send(c *Connection, ctx MessageContext) //(c *Connection, channelId ChannelId, msgType channeldpb.MessageType, msg Message)
}

type NullableInt struct {
	Value    int
	HasValue bool
}

type NullableString struct {
	Value    string
	HasValue bool
}

type RemovableMapField interface {
	GetRemoved() bool
}

type SpatialChannelEntityUpdater interface {
	AddEntity(EntityId, common.Message) error
	RemoveEntity(EntityId) error
}

type SpatialController interface {
	// Initialize the spatial controller parameters from the json config file.
	LoadConfig(config []byte) error
	// Notify() is called in the spatial channels (shared instance)
	common.SpatialInfoChangedNotifier
	// Called in GLOBAL and spatial channels
	GetChannelId(info common.SpatialInfo) (common.ChannelId, error)
	// Called in the spatial channels
	QueryChannelIds(query *channeldpb.SpatialInterestQuery) (map[common.ChannelId]uint, error)
	// Called in GLOBAL channel
	GetRegions() ([]*channeldpb.SpatialRegion, error)
	// Called in the spatial channels
	GetAdjacentChannels(spatialChannelId common.ChannelId) ([]common.ChannelId, error)
	// Create spatial channels for a spatial server.
	// Called in GLOBAL channel
	CreateChannels(ctx MessageContext) ([]*Channel, error)
	// Called in GLOBAL channel
	Tick()
}

type SpatialDampingSettings struct {
	MaxDistance      uint
	FanOutIntervalMs uint32
	DataFieldMasks   []string
}

type StaticGrid2DSpatialController struct {
	SpatialController

	/* Defines how the world is divided into grids */
	// The width of a grid in simulation/engine units
	GridWidth float64
	// The heights of a grid in the simulation/engine units
	GridHeight float64
	// How many grids the world has in X axis. The width of the world = GridWidth x GridCols.
	GridCols uint32
	// How many grids the world has in Z axis. The height of the world = GridHeight x GridRows.
	GridRows uint32

	// In the left-handed coordinate system, the difference between the world origin and the bottom-left corner of the first grid, in the simulation/engine units.
	// This is how we uses the offset value to calculate which grid a (x,z) point is in: gridX = Floor((x - OffsetX) / GridWidth), gridY = Floor((y - OffsetY) / GridHeight)
	// If the world origin is exactly in the middle of the world, the offset should be (-WorldWidth*0.5, -WorldHeight*0.5).
	WorldOffsetX float64
	WorldOffsetZ float64

	/* Defines the authority area of a spatial server, as well as the number of the servers (= ServerCols * ServerRows) */
	// How many servers the world has in X axis.
	ServerCols uint32
	// How many servers the world has in Z axis.
	ServerRows uint32

	/* Defines the extra interest area a spatial server has, adjacent to the authority area */
	// For each side of a server's grids (authority area), how many grids(spatial channels) the server subscribes to, as the extend of its interest area.
	// For example, ServerInterestBorderSize = 1 means a spatial server of 3x3 grids has interest area of 4x4 grids.
	// Remarks: the value should always be less than the size of the authority area (=Min(GridCols/ServerCols, GridRows/ServerRows))
	ServerInterestBorderSize uint32
	// contains filtered or unexported fields
}

type UintId interface {
	common.ChannelId | ConnectionId | EntityId | uint32
}