mapper

type AddCharacterMessagePayload struct {
	BaseMessagePayload
	CharacterDefinition
}

type AddImageMessagePayload struct {
	BaseMessagePayload

	// The image definition received from the server.
	ImageDefinition

	// If non-nil, this holds the image data received directly
	// from the server. This usage is not recommended but still
	// supported. In this case the "File" member of the ImageDefinition
	// will be empty.
	ImageData []byte
}

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

type AdjustViewMessagePayload struct {
	BaseMessagePayload
	XView, YView float64
}

type AnchorDirection byte

type AoEType byte

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

type ArcModeType byte

type ArrowType byte

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 CharacterDefinition struct {
	// Character name as appears on the map.
	Name string

	// ObjID to use for the character rather than generating one.
	ObjID string

	// Color to use to draw the threat zone around the character.
	Color string

	// Size codes of the threat area and creature token size.
	Area, Size string
}

type CharacterDefinitions map[string]CharacterDefinition

type ChatCommon struct {
	// The name of the person sending the message.
	Sender string

	// The names of the people the message was explicitly addressed to.
	// This will be nil for global messages.
	Recipients []string

	// The unique ID number for the chat message.
	MessageID int

	// True if this is a global message (sent to all users).
	ToAll bool

	// True if this message was sent only to the GM.
	ToGM bool
}

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

	// Don't notify the user of the operation.
	DoSilently bool

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

	// Chat message ID of this notice.
	MessageID int
}

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 CombatModeMessagePayload struct {
	BaseMessagePayload

	// If true, we should be in combat mode.
	Enabled bool
}

type CommentMessagePayload struct {
	BaseMessagePayload
	Text string
}

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

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

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

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

	// 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

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

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

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

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

	// 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 last error encountered while communicating with the server.
	LastError error

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

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

	// If true, we will always try to reconnect to the server if we
	// lose our connection.
	StayConnected bool
	// contains filtered or unexported fields
}

type ConnectionOption func(*Connection) error

type Coordinates struct {
	X, Y float64
}

type CreatureHealth struct {
	// The maximum hit points possible for the creature.
	MaxHP int

	// The amount of lethal and non-lethal damage suffered by the creature.
	LethalDamage    int
	NonLethalDamage int

	// 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

	// Is the creature flat-footed?
	IsFlatFooted bool

	// Has the creature been stabilized to prevent death while critically wounded?
	IsStable bool

	// 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

	// 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
}

type CreatureToken struct {
	BaseMapObject

	// 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

	// 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

	// 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

	// 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

	// Current elevation in feet relative to the "floor" of the
	// current location.
	Elev int

	// 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

	// 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).
	Size string

	// The tactical threat zone size of the creature, specified just
	// as with Size.
	Area string

	// 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

	// 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

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

	// Is the creature currently wielding a reach weapon or otherwise
	// using the "reach" alternate threat zone?
	Reach bool

	// 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

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

	// The creature type.
	CreatureType CreatureTypeCode
}

type CreatureTypeCode byte

type DashType byte

type DieRollPreset struct {
	// The name by which this die-roll preset is identified to the user.
	// This must be unique among that user's presets.
	//
	// Clients typically
	// sort these names before displaying them.
	// Note that if a vertical bar ("|") appears in the name, all text
	// up to and including the bar are suppressed from display. This allows
	// for the displayed names to be forced into a particular order on-screen,
	// and allow a set of presets to appear to have the same name from the user's
	// point of view.
	Name string

	// A text description of the purpose for this die-roll specification.
	Description string

	// The die-roll specification to send to the server. This must be in a
	// form acceptable to the dice.Roll function. For details, see
	// https://pkg.go.dev/github.com/MadScienceZone/go-gma/v4/dice#DieRoller.DoRoll
	DieRollSpec string
}

type ErrorMessagePayload struct {
	BaseMessagePayload
	OriginalMessageType ServerMessage
	Error               error
}

type FileDefinition struct {
	// The filename or Server ID.
	File string

	// 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
}

type FontSlantType byte

type FontWeightType byte

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

	// The name of the image as known within the mapper.
	Name string

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

	// 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
}

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

	// If true, the creature has a readied action.
	HasReadiedAction bool

	// It true, the creature is flat-footed.
	IsFlatFooted bool
}

type JoinStyle byte

type LineElement struct {
	MapElement

	// What arrowheads, if any, to draw on the endpoints
	Arrow ArrowType
}

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

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

type LoadObjectMessagePayload struct {
	BaseMessagePayload
	MapObject
}

type MapElement struct {
	BaseMapObject
	Coordinates

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

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

	// 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.
	Line string
	Fill string

	// The width in pixel units to draw the element's outline.
	Width int

	// The map layer this element belongs to.
	Layer string

	// 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
	// counting down as -1, -2, -3, etc.
	Level int

	// 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

	// The element's line(s) are to be drawn with this dash pattern.
	Dash DashType

	// Is this element currently concealed from view?
	Hidden bool

	// Is the object locked from editing by the user?
	Locked bool
}

type MapObject interface {
	ObjID() string
	// contains filtered or unexported methods
}

type MarcoMessagePayload struct {
	BaseMessagePayload
}

type MarkMessagePayload struct {
	BaseMessagePayload
	Coordinates
}

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

type MonsterToken struct {
	CreatureToken
}

type MoveModeType byte

type OptionalFeature byte

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

	// 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

	// True if this structure describes the connection of this client program
	IsMe bool

	// True if the peer is running as the "main" or "primary" client
	IsMain bool

	// True if the peer client is not paying attention to any incoming
	// messages
	IsWriteOnly bool
}

type PlaceSomeoneMessagePayload struct {
	BaseMessagePayload
	CreatureToken
}

type PlayerToken struct {
	CreatureToken
}

type PolygonElement struct {
	MapElement

	// 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

	// The join style to control how the intersection between line segments is drawn.
	Join JoinStyle
}

type QueryImageMessagePayload struct {
	BaseMessagePayload
	ImageDefinition
}

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 RectangleElement struct {
	MapElement
}

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 RollResultMessagePayload struct {
	BaseMessagePayload
	ChatCommon

	// The title describing the purpose of the die-roll, as set by the user.
	Title string

	// 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 {
	// 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

	// The description of the condition, including what effects it has
	// on the affected creature.
	Description string
}

type StatusMarkerDefinitions map[string]StatusMarkerDefinition

type TextElement struct {
	MapElement

	// The text to be displayed.
	Text string

	// Font to use for the text.
	Font TextFont

	// Where is the reference point in relation to the text?
	Anchor AnchorDirection
}

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

	// The font slant (roman or italic).
	Slant FontSlantType
}

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
}

type ToolbarMessagePayload struct {
	BaseMessagePayload
	Enabled bool
}

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 float64

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

type UpdateDicePresetsMessagePayload struct {
	BaseMessagePayload
	Presets []DieRollPreset
}

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]interface{}
}

type UpdatePeerListMessagePayload struct {
	BaseMessagePayload
	PeerList []Peer
}

type UpdateProgressMessagePayload struct {
	BaseMessagePayload

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

	// Description of the operation in progress, suitable for display.
	Title string

	// 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

	// If true, we can dispose of the tracked operation
	// and should not expect further updates about it.
	IsDone bool
}

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
}