mapper

type AcceptMessagePayload struct {
	BaseMessagePayload

	// Messages is a list of message command words.
	Messages []string `json:",omitempty"`
}

type AddCharacterMessagePayload struct {
	BaseMessagePayload
	PlayerToken
}

type AddDicePresetsMessagePayload struct {
	BaseMessagePayload
	For     string               `json:",omitempty"`
	Presets []dice.DieRollPreset `json:",omitempty"`
}

type AddImageMessagePayload struct {
	BaseMessagePayload
	ImageDefinition
}

type AddObjAttributesMessagePayload struct {
	BaseMessagePayload
	ObjID    string
	AttrName string
	Values   []string
}

type AdjustViewMessagePayload struct {
	BaseMessagePayload
	XView, YView float64 `json:",omitempty"`
	Grid         string  `json:",omitempty"`
}

type AllowMessagePayload struct {
	BaseMessagePayload

	// List of supported optional feature names
	Features []string `json:",omitempty"`
}

type AnchorDirection byte

type AoEType byte

type ArcElement struct {
	MapElement
	ArcMode ArcModeType
	Start   float64
	Extent  float64
}

type ArcModeType byte

type ArrowType byte

type AuthMessagePayload struct {
	BaseMessagePayload

	// Client describes the client program (e.g., "mapper 4.0.1")
	Client string `json:",omitempty"`

	// Response gives the binary response to the server's challenge
	Response []byte

	// User gives the username requested by the client
	User string `json:",omitempty"`
}

type BaseMapObject struct {
	// Unique object identifier. May be any string
	// consisting of upper- or lower-case letters, digits, '_', and "#"
	// characters.
	//
	// By convention, we create these from a UUID expressed in
	// hex without punctuation. Local conventions may also be
	// used, such as PC character tokens using ID strings such as
	// "PC1", "PC2", etc.
	ID string
}

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

type ChallengeMessagePayload struct {
	BaseMessagePayload
	Protocol      int
	Challenge     []byte    `json:",omitempty"`
	ServerStarted time.Time `json:",omitempty"`
	ServerActive  time.Time `json:",omitempty"`
	ServerTime    time.Time `json:",omitempty"`
	ServerVersion string    `json:",omitempty"`
}

type CharacterDefinitions map[string]PlayerToken

type ChatCommon struct {
	// The name of the person sending the message.
	Sender string `json:",omitempty"`

	// The names of the people the message was explicitly addressed to.
	// This will be nil for global messages.
	Recipients []string `json:",omitempty"`

	// The unique ID number for the chat message.
	MessageID int `json:",omitempty"`

	// True if this is a global message (sent to all users).
	ToAll bool `json:",omitempty"`

	// True if this message was sent only to the GM.
	ToGM bool `json:",omitempty"`

	// The date/time the message was sent
	Sent time.Time `json:",omitempty"`
}

type ChatMessageMessagePayload struct {
	BaseMessagePayload
	ChatCommon

	// The text of the chat message we received.
	Text string
}

type CircleElement struct {
	MapElement
}

type ClearChatMessagePayload struct {
	BaseMessagePayload

	// User requesting the action, if known.
	RequestedBy string `json:",omitempty"`

	// Don't notify the user of the operation.
	DoSilently bool `json:",omitempty"`

	// If >0, clear all messages with IDs greater than target.
	// If <0, clear most recent -N messages.
	// If 0, clear all messages.
	Target int `json:",omitempty"`

	// Chat message ID of this notice.
	MessageID int `json:",omitempty"`
}

type ClearFromMessagePayload struct {
	BaseMessagePayload
	FileDefinition
}

type ClearMessagePayload struct {
	BaseMessagePayload

	// The ObjID gives the object ID for the object to be removed, or one of
	// the following:
	//   *                    Remove all objects
	//   E*                   Remove all map elements
	//   M*                   Remove all monster tokens
	//   P*                   Remove all player tokens
	//   [<imagename>=]<name> Remove token with given <name>
	ObjID string
}

type ClientConnection struct {
	// Client features enabled
	Features struct {
		DiceColorBoxes bool
	}

	// The client's host and port number
	Address string

	// The last time we heard a ping reply from the client
	LastPoloTime time.Time

	// The messages this client wishes to receive
	// (nil means to receive all messages)
	Subscriptions map[ServerMessage]bool

	// Authentication information for this user
	Auth *auth.Authenticator

	// Level of debugging requested for this client
	DebuggingLevel DebugFlags

	Server MapServer

	Conn MapConnection
	D    *dice.DieRoller

	// Quality of Service tracking
	QoS struct {
		QueryImage struct {
			Threshold uint64
			Window    time.Duration
			Count     map[string]uint64
			Ticker    *time.Ticker
		}
		MessageRate struct {
			Count     uint64
			Threshold uint64
			Window    time.Duration
			Ticker    *time.Ticker
		}
		Log struct {
			Window time.Duration
			Ticker *time.Ticker
		}
	}
}

type ClientConnectionOption func(*ClientConnection) error

type ClientPreamble struct {
	// Do we send the connecting client a full dump of the current game state?
	SyncData bool

	// Initial commands sent at the start, after authentication, and
	// at the end of the sign-on sequence.
	Preamble  []string
	PostAuth  []string
	PostReady []string
}

type ClientSettingsOverrides struct {
	MkdirPath      string `json:",omitempty"`
	ImageBaseURL   string `json:",omitempty"`
	ModuleCode     string `json:",omitempty"`
	SCPDestination string `json:",omitempty"`
	ServerHostname string `json:",omitempty"`
}

type CombatModeMessagePayload struct {
	BaseMessagePayload

	// If true, we should be in combat mode.
	Enabled bool `json:",omitempty"`
}

type CommentMessagePayload struct {
	BaseMessagePayload
	Text string
}

type Connection struct {
	// If true, we will always try to reconnect to the server if we
	// lose our connection.
	StayConnected bool

	// If nonzero, we will re-try a failing connection this many
	// times before giving up on the server. Otherwise we will keep
	// trying forever.
	Retries uint

	// The server's protocol version number.
	Protocol int

	// The verbosity level of debugging log messages.
	DebuggingLevel DebugFlags

	// If nonzero, our connection attempts will timeout after the
	// specified time interval. Otherwise they will wait indefinitely.
	Timeout time.Duration

	// The server endpoint, in any form acceptable to the net.Dial
	// function.
	Endpoint string

	// Characters received from the server.
	Characters map[string]PlayerToken

	// Conditions and their token markings received from the server.
	Conditions map[string]StatusMarkerDefinition

	// If we received pre-authentication data from the server other than
	// definition of characters and condition codes, they are technically
	// too early to be valid (the server shouldn't do anything else before
	// authenticating), so we'll merely collect them here in case they are
	// of interest forensically.
	Preamble []string

	// Any progress gauges sent by the server will be tracked here as well
	// as passed to a channel subscribed to UpdateProgress.
	Gauges map[string]*UpdateProgressMessagePayload

	// The list of advertised updates to our software
	PackageUpdatesAvailable map[string][]PackageVersion

	// The last error encountered while communicating with the server.
	LastError error

	// The calendar system the server indicated as preferred, if any
	CalendarSystem string

	// Server overrides to client settings (if non-nil)
	ClientSettings *ClientSettingsOverrides

	// The context for our session, either one we created in the
	// NewConnection function or one we received from the caller.
	Context context.Context

	// If this is non-nil, we will use this to identify the user
	// to the server.
	Authenticator *auth.Authenticator

	// We will log informational messages here as we work.
	Logger *log.Logger

	// Server message subscriptions currently in effect.
	Subscriptions map[ServerMessage]chan MessagePayload

	// Our signal that we're ready for the client to talk.
	ReadySignal chan byte

	// Some statistics we know about the server
	ServerStats struct {
		Started       time.Time // server startup time
		Active        time.Time // time of last ping (at connect-time, this is time of last ping sent by server)
		ConnectTime   time.Time // time server connected (time on the server, for comparison with other server times)
		ServerVersion string    // the server's version number
	}
	// contains filtered or unexported fields
}

type ConnectionOption func(*Connection) error

type Coordinates struct {
	X, Y float64
}

type CreatureCustomReach struct {
	// Enabled is true if this custom information should be used for the creature.
	Enabled bool `json:",omitempty"`

	// Natural and Extended give the distance in 5-foot grid squares
	// away from the creature's PERIMETER to which their natural reach
	// and extended (as with a reach weapon) reach extends.
	Natural  int `json:",omitempty"`
	Extended int `json:",omitempty"`
}

type CreatureHealth struct {
	// Is the creature flat-footed?
	IsFlatFooted bool `json:",omitempty"`

	// Has the creature been stabilized to prevent death while critically wounded?
	IsStable bool `json:",omitempty"`

	// The maximum hit points possible for the creature.
	MaxHP int `json:",omitempty"`

	// The amount of lethal and non-lethal damage suffered by the creature.
	LethalDamage    int `json:",omitempty"`
	NonLethalDamage int `json:",omitempty"`

	// The grace amount of hit points a creature may suffer over their maximum before
	// they are actually dead (as opposed to critically wounded). This is generally
	// the creature's Constitution score, hence the name.
	Con int `json:",omitempty"`

	// If 0, the creature's health is displayed accurately on the map. Otherwise,
	// this gives the percentage by which to "blur" the hit points as seen by the
	// players. For example, if HPBlur is 10, then hit points are displayed only in
	// 10% increments.
	HPBlur int `json:",omitempty"`

	// Override the map client's idea of how to display the creature's health condition.
	// Normally this is the empty string which allows the client to calculate it from the
	// information available to it.
	Condition string `json:",omitempty"`
}

type CreatureToken struct {
	BaseMapObject

	// Is the creature currently dead? (This takes precedence over the
	// Health attribute's indication that the creature has taken a
	// fatal amount of damage.)
	Killed bool `json:",omitempty"`

	// In combat, if this is true, the token is "dimmed" to indicate
	// that it is not their turn to act.
	Dim bool `json:",omitempty"`

	// If true, this means the creature token is only visible to the GM.
	Hidden bool `json:",omitempty"`

	// If true, only the GM may access or manipulate the polymorph capabilities
	// of this creature.
	PolyGM bool `json:",omitempty"`

	// The creature type.
	CreatureType CreatureTypeCode

	// The method of locomotion currently being used by this creature.
	// Normally this is MoveModeLand for land-based creatures which
	// are walking/running.
	MoveMode MoveModeType `json:",omitempty"`

	// Is the creature currently wielding a reach weapon or otherwise
	// using the "reach" alternate threat zone?
	// If this value is 0, the threat zone is normal for a creature
	// of its size. If 1, an extended area (appropriate for using
	// a reach weapon) is used instead. If 2, both areas are used,
	// so the creature may attack into the reach zone AND adjacent
	// foes.
	Reach int `json:",omitempty"`

	// For creatures which may change their shape or appearance,
	// multiple "skins" may be defined to display as appropriate.
	//
	// Skin is 0 for the default appearance of the creature, 1
	// for the alternate image, 2 for the 2nd alternate image, etc.
	Skin int `json:",omitempty"`

	// Current elevation in feet relative to the "floor" of the
	// current location.
	Elev int `json:",omitempty"`

	// Grid (x, y) coordinates for the reference point of the
	// creature.  Unlike MapElement coordinates, these are in
	// grid units (1 grid = 5 feet).  The upper-left corner of
	// the creature token is at this location.
	Gx, Gy float64

	// The name of the creature as displayed on the map. Must be unique
	// among the other creatures.
	Name string

	// If non-nil, this tracks the health status of the creature.
	Health *CreatureHealth `json:",omitempty"`

	// If the different "skins" are different sizes, this is a list
	// of size codes for each of them. For example, if there are 3
	// skins defined, the first two medium-size and the 3rd large
	// size, then SkinSize would have the value {"M", "M", "L"}.
	// If this is empty or nil, all skins are assumed to be the
	// size specified in the Size attribute. Note that SkinSize
	// also sets the Area at the same time.
	SkinSize []string `json:",omitempty"`

	// The color to draw the creature's threat zone when in combat.
	Color string

	// A note to attach to the creature token to indicate special
	// conditions affecting the creature which are not otherwise shown.
	Note string `json:",omitempty"`

	// The tactical size category of the creature ("S", "M", "L",
	// etc). Lower-case letters indicate the "wide" version of the
	// category while upper-case indicates "tall" versions.
	//
	// May also be the size in feet (DEPRECATED USAGE).
	//
	// This field is now DEPRECATED. Use SkinSize instead.
	Size string

	// If DispSize is nonempty, it holds the size category to display
	// the creature (say, as a result of casting an enlarge person spell).
	DispSize string `json:",omitempty"`

	// A list of condition codes which apply to the character. These
	// are arbitrary and defined by the server according to the needs
	// of the particular game, but may include things such
	// as "confused", "helpless", "hasted", etc.
	StatusList []string `json:",omitempty"`

	// If there is a spell effect radiating from the creature, its
	// area of effect is described by this value. If there is none,
	// this is nil.
	//
	// Currently only radius emanations are supported. In future, the
	// type of this attribute may change to handle other shapes.
	AoE *RadiusAoE `json:",omitempty"`

	// If there is a custom reach/threat zone defined for this
	// creature, it is detailed here.
	CustomReach CreatureCustomReach `json:",omitempty"`
}

type CreatureTypeCode byte

type DashType byte

type DebugFlags uint64

type DefineDicePresetDelegatesMessagePayload struct {
	BaseMessagePayload
	For       string   `json:",omitempty"`
	Delegates []string `json:",omitempty"`
}

type DefineDicePresetsMessagePayload struct {
	BaseMessagePayload
	For     string               `json:",omitempty"`
	Presets []dice.DieRollPreset `json:",omitempty"`
}

type DeniedMessagePayload struct {
	BaseMessagePayload
	Reason string
}

type EchoMessagePayload struct {
	BaseMessagePayload

	B            bool           `json:"b,omitempty"`
	I            int            `json:"i,omitempty"`
	S            string         `json:"s,omitempty"`
	O            map[string]any `json:"o,omitempty"`
	ReceivedTime time.Time      `json:",omitempty"`
	SentTime     time.Time      `json:",omitempty"`
}

type ErrorMessagePayload struct {
	BaseMessagePayload
	OriginalMessageType ServerMessage
	Error               error
}

type FileDefinition struct {
	// If IsLocalFile is true, File is the name of the file on disk;
	// otherwise it is the server's internal ID by which you may request
	// that file from the server.
	IsLocalFile bool `json:",omitempty"`

	// The filename or Server ID.
	File string
}

type FilterCoreDataMessagePayload struct {
	BaseMessagePayload
	InvertSelection bool `json:",omitempty"`
	IsHidden        bool `json:",omitempty"`
	Type            string
	Filter          string
}

type FilterDicePresetsMessagePayload struct {
	BaseMessagePayload
	Filter string `json:",omitempty"`
	For    string `json:",omitempty"`
}

type FilterImagesMessagePayload struct {
	BaseMessagePayload
	KeepMatching bool   `json:",omitempty"`
	Filter       string `json:",omitempty"`
}

type FontSlantType byte

type FontWeightType byte

type GrantedMessagePayload struct {
	BaseMessagePayload
	User string
}

type ImageAnimation struct {
	// The number of frames in the animation. These will be in files with
	// :n: prepended to their names where n is the frame number starting with 0.
	Frames int `json:",omitempty"`

	// The number of milliseconds to display each frame.
	FrameSpeed int `json:",omitempty"`

	// The number of loops to play before stopping. 0 means unlimited.
	Loops int `json:",omitempty"`
}

type ImageDefinition struct {
	// The name of the image as known within the mapper.
	Name  string
	Sizes []ImageInstance

	// If non-nil, this indicates that the image is to be animated
	Animation *ImageAnimation `json:",omitempty"`
}

type ImageInstance struct {
	// If IsLocalFile is true, File is the name of the image file on disk;
	// otherwise it is the server's internal ID by which you may request
	// that file from the server.
	IsLocalFile bool `json:",omitempty"`

	// The zoom (magnification) level this bitmap represents for the given
	// image.
	Zoom float64

	// The filename by which the image can be retrieved.
	File string

	// If non-nil, this holds the image data received directly
	// from the server. This usage is not recommended but still
	// supported.
	ImageData []byte `json:",omitempty"`
}

type InitiativeSlot struct {
	// The slot number (currently 0–59, corresponding to the 1/10th second "count" in the initiative round)
	Slot int

	// The current hit point total for the creature.
	CurrentHP int

	// The creature's name as displayed on the map.
	Name string

	// If true, the creature is holding their action.
	IsHolding bool `json:",omitempty"`

	// If true, the creature has a readied action.
	HasReadiedAction bool `json:",omitempty"`

	// It true, the creature is flat-footed.
	IsFlatFooted bool `json:",omitempty"`
}

type JoinStyle byte

type LineElement struct {
	MapElement

	// What arrowheads, if any, to draw on the endpoints
	Arrow ArrowType `json:",omitempty"`
}

type LoadArcObjectMessagePayload struct {
	BaseMessagePayload
	ArcElement
}

type LoadCircleObjectMessagePayload struct {
	BaseMessagePayload
	CircleElement
}

type LoadFromMessagePayload struct {
	BaseMessagePayload
	FileDefinition

	// If true, the client should only pre-load this data into a
	// local cache, but not start displaying these elements yet.
	CacheOnly bool `json:",omitempty"`

	// If true, the elements are merged with the existing map
	// contents rather than replacing them.
	Merge bool `json:",omitempty"`
}

type LoadLineObjectMessagePayload struct {
	BaseMessagePayload
	LineElement
}

type LoadPolygonObjectMessagePayload struct {
	BaseMessagePayload
	PolygonElement
}

type LoadRectangleObjectMessagePayload struct {
	BaseMessagePayload
	RectangleElement
}

type LoadSpellAreaOfEffectObjectMessagePayload struct {
	BaseMessagePayload
	SpellAreaOfEffectElement
}

type LoadTextObjectMessagePayload struct {
	BaseMessagePayload
	TextElement
}

type LoadTileObjectMessagePayload struct {
	BaseMessagePayload
	TileElement
}

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

type MapElement struct {
	BaseMapObject
	Coordinates

	// Is this element currently concealed from view?
	Hidden bool `json:",omitempty"`

	// Is the object locked from editing by the user?
	Locked bool `json:",omitempty"`

	// The element's line(s) are to be drawn with this dash pattern.
	Dash DashType `json:",omitempty"`

	// The z "coordinate" is the vertical stacking order relative to the other
	// displayed on-screen objects.
	Z int

	// The width in pixel units to draw the element's outline.
	Width int `json:",omitempty"`

	// The dungeon level where this element appears. Typically, level 0
	// is the default (ground) level, with level numbers increasing as
	// 1, 2, 3, etc., for floors above it, and with underground levels
	Level int `json:",omitempty"`

	// Objects which need additional coordinate pairs to describe their
	// geometry (beyond the standard reference point) store them here.
	Points []Coordinates `json:",omitempty"`

	// The colors used to draw the element's outline and/or to fill it's interior.
	// These may be standard color names such as "blue" or an RGB string such as
	// "#336699". A fill color that is the empty string means not to fill that element.
	// If Stipple is nonempty, it specifies that the shape should be filled with
	// a stipple pattern. Pattern names "gray12", "gray25", "gray50", and "gray75"
	// should be available by default in clients.
	Line    string `json:",omitempty"`
	Fill    string `json:",omitempty"`
	Stipple string `json:",omitempty"`

	// The map layer this element belongs to.
	Layer string `json:",omitempty"`

	// Elements may be arranged into logical groups to be manipulated
	// together. This is the ID of the group to which this belongs, or
	// is empty if this element is not grouped.
	Group string `json:",omitempty"`
}

type MapMetaData struct {
	// Timestamp is the generation or modification time of the map file
	// as a 64-bit integer Unix timestamp value.
	Timestamp int64 `json:",omitempty"`

	// DateTime is a human-readable string which gives the same information
	// as Timestamp. The software only uses Timestamp. DateTime is provided
	// only for convenience and is not guaranteed to match Timestamp's time
	// value or even any valid value at all. The format is this string is
	// arbitrary.
	DateTime string `json:",omitempty"`

	// Comment is any brief comment the map author wishes to leave in the file
	// about this map.
	Comment string `json:",omitempty"`

	// Location is a string describing the locale within the adventure area or
	// world which is represented by this file.
	Location string `json:",omitempty"`

	// FileVersion is the file format version number detected when reading in
	// the data from this file. This is for informational purposes only and does
	// not control the format used to write the data to a new file.
	FileVersion uint `json:"-"`
}

type MapObject interface {
	ObjID() string
}

type MapServer interface {
	Log(messsage ...any)
	Logf(format string, args ...any)
	GetPersonalCredentials(user string) []byte
	GetClientPreamble() *ClientPreamble
	HandleServerMessage(MessagePayload, *ClientConnection)
	AddClient(*ClientConnection)
	RemoveClient(*ClientConnection)
	SendGameState(*ClientConnection)
	GetAllowedClients() []PackageUpdate
}

type MarcoMessagePayload struct {
	BaseMessagePayload
}

type MarkMessagePayload struct {
	BaseMessagePayload
	Coordinates
}

type MessagePayload interface {
	MessageType() ServerMessage
	RawMessage() string
	RawBytes() []byte
}

type MonsterToken struct {
	CreatureToken
}

type MoveModeType byte

type OptionalFeature byte

type PackageUpdate struct {
	Name           string
	VersionPattern string         `json:",omitempty"`
	VersionRegex   *regexp.Regexp `json:"-"`
	MinimumVersion string         `json:",omitempty"`
	Instances      []PackageVersion
}

type PackageVersion struct {
	OS      string `json:",omitempty"`
	Arch    string `json:",omitempty"`
	Version string
	Token   string `json:",omitempty"`
}

type Peer struct {
	// IP address and port of the peer
	Addr string

	// The username provided by the peer when it authenticated
	User string

	// A description of the peer client program (provided by that client)
	Client string `json:",omitempty"`

	// How many seconds ago the peer last answered a "still alive?" ping from the server
	LastPolo float64

	// True if the client authenticated successfully
	IsAuthenticated bool `json:",omitempty"`

	// True if this structure describes the connection of this client program
	IsMe bool `json:",omitempty"`
}

type PlaceSomeoneMessagePayload struct {
	BaseMessagePayload
	CreatureToken
}

type PlayerToken struct {
	CreatureToken
}

type PoloMessagePayload struct {
	BaseMessagePayload
}

type PolygonElement struct {
	MapElement

	// The join style to control how the intersection between line segments is drawn.
	Join JoinStyle `json:",omitempty"`

	// Spline gives the factor to use when smoothing the sides of the polygon between
	// its points. 0 means not to smooth them at all, resulting in a shape with straight
	// edges between the vertices. Otherwise, larger values provide greater smoothing.
	Spline float64 `json:",omitempty"`
}

type PrivMessagePayload struct {
	BaseMessagePayload
	Command string
	Reason  string
}

type ProtocolMessagePayload struct {
	BaseMessagePayload
	ProtocolVersion int
}

type QueryCoreDataMessagePayload struct {
	BaseMessagePayload
	Type      string
	Code      string `json:",omitempty"`
	Name      string `json:",omitempty"`
	RequestID string `json:",omitempty"`
}

type QueryCoreIndexMessagePayload struct {
	BaseMessagePayload
	Type      string
	CodeRegex string    `json:",omitempty"`
	NameRegex string    `json:",omitempty"`
	Since     time.Time `json:",omitempty"`
	RequestID string    `json:",omitempty"`
}

type QueryDicePresetsMessagePayload struct {
	BaseMessagePayload
	For string `json:",omitempty"`
}

type QueryImageMessagePayload struct {
	BaseMessagePayload
	ImageDefinition
}

type QueryPeersMessagePayload struct {
	BaseMessagePayload
}

type RadiusAoE struct {
	// Distance in standard map pixels away from the creature token's center
	// to the perimeter of the affected area.
	Radius float64

	// Color to draw the affected zone.
	Color string
}

type ReadyMessagePayload struct {
	BaseMessagePayload
}

type RectangleElement struct {
	MapElement
}

type RedirectMessagePayload struct {
	BaseMessagePayload
	Host   string
	Port   int
	Reason string `json:",omitempty"`
}

type RemoveObjAttributesMessagePayload struct {
	BaseMessagePayload

	// The ID of the object to be modified
	ObjID string

	// The name of the attribute to modify. Must be one with a []string value.
	AttrName string

	// The values to remove from the attribute.
	Values []string
}

type RollDiceMessagePayload struct {
	BaseMessagePayload
	ChatCommon

	// If you want to track the results to the requests that created them,
	// put a unique ID here. It will be repeated in the corresponding result(s).
	RequestID string `json:",omitempty"`

	// RollSpec describes the dice to be rolled and any modifiers.
	RollSpec string
}

type RollResultMessagePayload struct {
	BaseMessagePayload
	ChatCommon

	// True if there will be more results following this one for the same request
	MoreResults bool `json:",omitempty"`

	// The ID string passed by the user to associate this result with their request (may be blank)
	RequestID string `json:",omitempty"`

	// The title describing the purpose of the die-roll, as set by the user.
	Title string `json:",omitempty"`

	// The die roll result and details behind where it came from.
	Result dice.StructuredResult
}

type ServerMessage byte

type SpellAreaOfEffectElement struct {
	MapElement

	// The shape of the affected region of the map.
	AoEShape AoEType
}

type StatusMarkerDefinition struct {
	// If the token should be transparent when this condition is in effect
	Transparent bool `json:",omitempty"`

	// The name of the condition
	Condition string

	// The shape of the marker to be drawn on the token. This may
	// be one of the following:
	//   |v  small downward-pointing triangle against the left edge
	//   v|  small downward-pointing triangle against the right edge
	//   |o  small circle against the left edge
	//   o|  small circle against the right edge
	//   |<> small diamond against the left edge
	//   <>| small diamond against the right edge
	//   /   slash from upper right to lower left
	//   \   slash from upper left to lower right
	//   //  double slash from upper right to lower left
	//   \\  double slash from upper left to lower right
	//   -   horizontal line through the center of the token
	//   =   double horizontal line through the center
	//   |   vertical line through the center
	//   ||  double vertical line through the center
	//   +   cross (vertical and horizontal lines) through center
	//   #   double cross (vertical and horizontal lines) through center
	//   V   large downward-pointing triangle around token
	//   ^   large upward-pointing triangle around token
	//   <>  large diamond around token
	//   O   large circle around token
	Shape string

	// The color to draw the marker. If the name begins with a pair
	// of hyphens (e.g., "--red") then the marker is drawn with long
	// dashed lines. If it begins with dots (e.g., "..blue") it is
	// drawn with short dashed lines.
	//
	// The special color "*" may be used to indicate that the marker
	// should be drawn in the same color as the creature's threat zone.
	Color string

	// A player-readable description of the effect the condition has on
	// the affected creature.
	Description string `json:",omitempty"`
}

type StatusMarkerDefinitions map[string]StatusMarkerDefinition

type SyncChatMessagePayload struct {
	BaseMessagePayload
	Target int `json:",omitempty"`
}

type SyncMessagePayload struct {
	BaseMessagePayload
}

type TextElement struct {
	MapElement

	// Where is the reference point in relation to the text?
	Anchor AnchorDirection `json:",omitempty"`

	// The text to be displayed.
	Text string

	// Font to use for the text.
	Font TextFont
}

type TextFont struct {
	// The name of the font family as recognized by Tk.
	Family string

	// The font size as recognized by Tk.
	Size float64

	// The font weight (normal or bold).
	Weight FontWeightType `json:",omitempty"`

	// The font slant (roman or italic).
	Slant FontSlantType `json:",omitempty"`
}

type TileElement struct {
	MapElement

	// Image name as known to the mapper system.
	Image string

	// Bounding box in pixels for the image tile.
	// If for some reason the tile can't be found, clients
	// can use the bounding box to indicate where the tile should be.
	// If the bounding box is not known, these values may both
	// be zero.
	BBHeight, BBWidth float64 `json:",omitempty"`
}

type ToolbarMessagePayload struct {
	BaseMessagePayload
	Enabled bool `json:",omitempty"`
}

type UnknownMessagePayload struct {
	BaseMessagePayload
}

type UpdateClockMessagePayload struct {
	BaseMessagePayload

	// The clock is now at the given absolute number of
	// seconds from the GMA clock's global epoch.
	Absolute int64

	// The elapsed time counter is now this many seconds from
	// some reference point set by the GM (often the start of
	// combat).
	Relative int64

	// If true and not in combat mode, local clients should
	// keep running the clock in real time.
	Running bool `json:",omitempty"`
}

type UpdateCoreDataMessagePayload struct {
	BaseMessagePayload
	// If NoSuchEntry is true, none of the other fields should be considered valid except RequestID.
	NoSuchEntry bool   `json:",omitempty"`
	IsHidden    bool   `json:",omitempty"`
	IsLocal     bool   `json:",omitempty"`
	Code        string `json:",omitempty"`
	Name        string `json:",omitempty"`
	Type        string `json:",omitempty"`
	RequestID   string `json:",omitempty"`
}

type UpdateCoreIndexMessagePayload struct {
	BaseMessagePayload
	IsDone    bool   `json:",omitempty"`
	N         int    `json:",omitempty"`
	Of        int    `json:",omitempty"`
	Code      string `json:",omitempty"`
	Name      string `json:",omitempty"`
	Type      string `json:",omitempty"`
	RequestID string `json:",omitempty"`
}

type UpdateDicePresetsMessagePayload struct {
	BaseMessagePayload
	Presets     []dice.DieRollPreset
	For         string   `json:",omitempty"`
	DelegateFor []string `json:",omitempty"`
	Delegates   []string `json:",omitempty"`
}

type UpdateInitiativeMessagePayload struct {
	BaseMessagePayload
	InitiativeList []InitiativeSlot
}

type UpdateObjAttributesMessagePayload struct {
	BaseMessagePayload

	// The ID of the object to be modified.
	ObjID string

	// A map of attribute name to its new value.
	NewAttrs map[string]any
}

type UpdatePeerListMessagePayload struct {
	BaseMessagePayload
	PeerList []Peer
}

type UpdateProgressMessagePayload struct {
	BaseMessagePayload

	// If true, we can dispose of the tracked operation
	// and should not expect further updates about it.
	IsDone bool `json:",omitempty"`

	// If true, this is not an operation progress meter, but is a view of
	// the status of a running timer.
	IsTimer bool `json:",omitempty"`

	// The current progress toward MaxValue.
	Value int

	// The maximum expected value for the progress indication.
	// If this is 0, we don't yet know what the maximum will be.
	// Note that this may change from one message to another, if
	// the server realizes its previous estimate was incorrect.
	MaxValue int `json:",omitempty"`

	// Unique identifier for the operation we're tracking
	OperationID string

	// Description of the operation in progress, suitable for display.
	Title string `json:",omitempty"`

	// If this relates to specific characters, their names will be listed here.
	Targets []string `json:",omitempty"`
}

type UpdateStatusMarkerMessagePayload struct {
	BaseMessagePayload
	StatusMarkerDefinition
}

type UpdateTurnMessagePayload struct {
	BaseMessagePayload

	// The ObjID of the creature whose turn it is. This may also be one of:
	//   *Monsters*   All monsters are up now.
	//   (empty)      It is no one's turn now.
	//   /regex       All creatures whose names match regex
	ActorID string

	// The time lapsed so far since the start of combat.
	// Count is the initiative slot within the round.
	Hours, Minutes, Seconds, Rounds, Count int
}

type UpdateVersionsMessagePayload struct {
	BaseMessagePayload
	Packages []PackageUpdate `json:",omitempty"`
}

type WorldMessagePayload struct {
	BaseMessagePayload
	Calendar       string
	ClientSettings *ClientSettingsOverrides `json:",omitempty"`
}